voltha/adapters/tlgs_onu/tlgs_onu.py

#
# Copyright 2017 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""
PMC Sierra ONU adapter
"""

import structlog
from twisted.internet import reactor
from twisted.internet.defer import DeferredQueue, inlineCallbacks, returnValue
from zope.interface import implementer
import voltha.core.flow_decomposer as fd

from voltha.adapters.interface import IAdapterInterface
from voltha.adapters.microsemi_olt.DeviceManager import mac_str_to_tuple
from voltha.adapters.microsemi_olt.PAS5211 import PAS5211GetOnuAllocs, PAS5211GetOnuAllocsResponse, PAS5211GetSnInfo, \
    PAS5211GetSnInfoResponse, PAS5211GetOnusRange, PAS5211GetOnusRangeResponse, PAS5211MsgSetOnuOmciPortId, \
    PAS5211MsgSetOnuOmciPortIdResponse, PAS5211MsgSetOnuAllocId, PAS5211MsgSetOnuAllocIdResponse, \
    PAS5211SetSVlanAtConfig, PAS5211SetSVlanAtConfigResponse, PAS5211SetVlanDownConfig, \
    PAS5211SetVlanDownConfigResponse, PAS5211SetDownVlanHandl, PAS5211SetDownVlanHandlResponse, \
    PAS5211SetUplinkVlanHandl, PAS5211SetDownstreamPolicingConfigResponse, PAS5211SetDownstreamPolicingConfig, \
    PAS5211SetPortIdPolicingConfig, PAS5211UnsetPortIdPolicingConfig, \
    PAS5211MsgSendDbaAlgorithmMsg, PAS5211MsgSendDbaAlgorithmMsgResponse, \
    PAS5211SetUpstreamPolicingConfigResponse, PAS5211SetUpstreamPolicingConfig, \
    PAS5211MsgSetPortIdConfig, PAS5211MsgSetPortIdConfigResponse, \
    PAS5211MsgGetOnuIdByPortId, PAS5211MsgGetOnuIdByPortIdResponse, \
    PAS5211SetVlanUplinkConfiguration, PAS5211SetVlanUplinkConfigurationResponse, PAS5211SetUplinkVlanHandlResponse, PAS5211SetVlanGenConfig, PAS5211SetVlanGenConfigResponse, \
    PAS5211GetPortIdDownstreamPolicingConfig, PAS5211GetPortIdDownstreamPolicingConfigResponse, PAS5211RemoveDownstreamPolicingConfig, \
    PAS5211MsgHeader, PAS5211UnsetPortIdPolicingConfigResponse, PAS5211RemoveDownstreamPolicingConfigResponse, \
    PAS5211SetPortIdPolicingConfigResponse
from voltha.adapters.microsemi_olt.PAS5211_constants import OMCI_GEM_IWTP_IW_OPT_8021P_MAPPER, PON_FALSE, \
    PON_1_TO_1_VLAN_MODE, PON_TRUE, PON_VLAN_UNUSED_TAG, PON_VLAN_UNUSED_PRIORITY, PON_VLAN_REPLACE_PRIORITY, \
    PON_OUTPUT_VLAN_PRIO_HANDLE_INCOMING_VLAN, PON_VLAN_UNCHANGED_PRIORITY, PON_OUTPUT_VLAN_PRIO_HANDLE_DONT_CHANGE, \
    PON_OUTPUT_VLAN_PRIO_HANDLE_DL_VLAN_TABLE, PON_DL_VLAN_SVLAN_REMOVE, PON_DL_VLAN_CVLAN_NO_CHANGE, \
    PON_VLAN_DEST_DATAPATH, GEM_DIR_BIDIRECT, OMCI_MAC_BRIDGE_PCD_LANFCS_FORWARDED, \
    OMCI_MAC_BRIDGE_PCD_ENCAP_METHOD_LLC, OMCI_8021P_MSP_UNMARKED_FRAME_TAG_FRAME, OMCI_8021P_MSP_TP_TYPE_NULL, \
    OMCI_EX_VLAN_TAG_OCD_ASSOCIATION_TYPE_PPTP_ETH_UNI, OMCI_EX_VLAN_TAG_OCD_DS_MODE_US_INVERSE, PMC_UPSTREAM_PORT, \
    PON_DISABLE, PON_VLAN_CHANGE_TAG, PON_VLAN_DONT_CHANGE_TAG, PON_PORT_TYPE_GEM, PON_PORT_DESTINATION_CNI0, PON_ENABLE, SLA_gr_bw_gros, PYTHAGORAS_UPDATE_AID_SLA, \
    SLA_gr_bw_gros, SLA_be_bw_gros, SLA_gr_bw_fine, SLA_be_bw_fine, PYTHAGORAS_DBA_DATA_COS, PYTHAGORAS_DBA_STATUS_REPORT_NSR, \
    PMC_OFAL_NO_POLICY, UPSTREAM, DOWNSTREAM

from voltha.extensions.omci.omci_frame import OmciFrame
from voltha.protos import third_party
from voltha.protos.adapter_pb2 import Adapter
from voltha.protos.adapter_pb2 import AdapterConfig
from voltha.protos.common_pb2 import LogLevel, ConnectStatus, AdminState, OperStatus
from voltha.protos.device_pb2 import DeviceType, DeviceTypes, Port
from voltha.protos.health_pb2 import HealthStatus
from voltha.protos.logical_device_pb2 import LogicalPort
from voltha.protos.openflow_13_pb2 import OFPPF_1GB_FD, OFPPF_FIBER, ofp_port, OFPPS_LIVE, OFPXMC_OPENFLOW_BASIC

from voltha.extensions.omci.omci_messages import OmciGet, OmciGetResponse, OmciCreate, OmciMibResetResponse, OmciSet, \
    OmciSetResponse, OmciCreateResponse, OmciMibReset, OmciDelete, OmciDeleteResponse
from adapters.microsemi_olt.OMCIProxy import OMCIProxy
from voltha.adapters.microsemi_olt.APIProxy import APIProxy
from voltha.registry import registry
from voltha.extensions.omci.omci_entities import VlanTaggingOperation
from voltha.protos.openflow_13_pb2 import Flows, FlowGroups

import Queue
from struct import pack, unpack

_ = third_party
log = structlog.get_logger()

OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_NO_TAG = 15
OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE = 4096
OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE = 0
OMCI_EX_VLAN_TAG_OCD_FILTER_ETYPE_NONE = 0
OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_DEFAULT = 14
OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_8100 = 4
OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE = 15
OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_OUTER = 1
OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_COPY_FROM_INNER = 4096
OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_INNER = 0
OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_EQ_8100 = 4

MAX_FLOW_EVENT_RETRIES = 5

def sequence_generator(init):
    num = init
    while True:
        yield num
        num += 1

@implementer(IAdapterInterface)
class TlgsOnuAdapter(object):

    name = 'tlgs_onu'

    supported_device_types = [
        DeviceType(
            id=name,
            adapter=name,
            accepts_bulk_flow_update=True
        )
    ]


    def __init__(self, adapter_agent, config):
        self.omci_proxy = None
        self.api_proxy = None
        self.adapter_agent = adapter_agent
        self.config = config
        self.descriptor = Adapter(
            id=self.name,
            vendor='TLGS',
            version='0.1',
            config=AdapterConfig(log_level=LogLevel.INFO)
        )

        # self.incoming_messages = DeferredQueue()
        #self.trangen = sequence_generator(1)

        # As of broadcom_onu.py
        self.device_handlers = dict()
        # register for adapter messages
        self.adapter_agent.register_for_inter_adapter_messages()

        self.interface = registry('main').get_args().interface

    def start(self):
        log.debug('starting')
        log.info('started')

    def stop(self):
        log.debug('stopping')
        log.info('stopped')

    def adapter_descriptor(self):
        return self.descriptor

    def device_types(self):
        return DeviceTypes(items=self.supported_device_types)

    def health(self):
        return HealthStatus(state=HealthStatus.HealthState.HEALTHY)

    def change_master_state(self, master):
        raise NotImplementedError()

    def create_tcont(self, device, tcont_data, traffic_descriptor_data):
        raise NotImplementedError()

    def update_tcont(self, device, tcont_data, traffic_descriptor_data):
        raise NotImplementedError()

    def remove_tcont(self, device, tcont_data, traffic_descriptor_data):
        raise NotImplementedError()

    def create_gemport(self, device, data):
        raise NotImplementedError()

    def update_gemport(self, device, data):
        raise NotImplementedError()

    def remove_gemport(self, device, data):
        raise NotImplementedError()

    def create_multicast_gemport(self, device, data):
        raise NotImplementedError()

    def update_multicast_gemport(self, device, data):
        raise NotImplementedError()

    def remove_multicast_gemport(self, device, data):
        raise NotImplementedError()

    def create_multicast_distribution_set(self, device, data):
        raise NotImplementedError()

    def update_multicast_distribution_set(self, device, data):
        raise NotImplementedError()

    def remove_multicast_distribution_set(self, device, data):
        raise NotImplementedError()

    def adopt_device(self, device):
        log.debug('adopt-device', device=device)
        # reactor.callLater(0.1, self._onu_device_activation, device)
        # return device
        # two level array channel

        if device.proxy_address.channel_id not in self.device_handlers:
            self.device_handlers[device.proxy_address.channel_id] = dict()

        self.device_handlers[device.proxy_address.channel_id][
            device.proxy_address.onu_id] = TlgsOnuHandler(self, device.id)

        reactor.callLater(1, self.device_handlers[device.proxy_address.channel_id][
                          device.proxy_address.onu_id].activate, device)

        return device

    def reconcile_device(self, device):
        raise NotImplementedError()

    def abandon_device(self, device):
        raise NotImplementedError()

    def disable_device(self, device):
        log.debug('disable-device', device=device.id)

        reactor.callLater(0, self.device_handlers[device.proxy_address.channel_id][
            device.proxy_address.onu_id].deactivate, device)
        #raise NotImplementedError()

    def reenable_device(self, device):
        raise NotImplementedError()

    def reboot_device(self, device):
        log.debug('reboot-device', device=device.id)

        reactor.callLater(0, self.device_handlers[device.proxy_address.channel_id][
            device.proxy_address.onu_id].reboot, device)
        # raise NotImplementedError()

    def download_image(self, device, request):
        raise NotImplementedError()

    def get_image_download_status(self, device, request):
        raise NotImplementedError()

    def cancel_image_download(self, device, request):
        raise NotImplementedError()

    def activate_image_update(self, device, request):
        raise NotImplementedError()

    def revert_image_update(self, device, request):
        raise NotImplementedError()

    def self_test_device(self, device):
        """
        This is called to Self a device based on a NBI call.
        :param device: A Voltha.Device object.
        :return: Will return result of self test
        """
        log.debug('self-test-device', device=device.id)
        raise NotImplementedError()

    def delete_device(self, device):
        log.debug('delete-device', device_id=device.id)

    def get_device_details(self, device):
        raise NotImplementedError()

    def deactivate(self, device):
        try:
            handler = self.device_handlers[
                device.proxy_address.channel_id][device.proxy_address.onu_id]
            return handler.deactivate(device)
        except Exception as e:
            log.exception('failed-to-deactivate-onu', e=e)
            raise e

    def update_pm_config(self, device, pm_configs):
        raise NotImplementedError()

    # @inlineCallbacks
    def update_flows_bulk(self, device, flows, groups):
        log.debug('onu-bulk-flow-update', device_id=device.id,
            flows=flows, groups=groups)
        log.debug(str(self.device_handlers.keys))
        try:
            assert len(groups.items) == 0
            handler = self.device_handlers[
                device.proxy_address.channel_id][device.proxy_address.onu_id]
            handler.update_flow_table(device, flows.items)
        except Exception as e:
            log.exception('failed-to-update-flow-table', e=e)
            raise e

    def update_flows_incrementally(self, device, flow_changes, group_changes):
        raise NotImplementedError()

    def send_proxied_message(self, proxy_address, msg):
        log.debug("send-proxied-message in TLGS ONU")

    def receive_proxied_message(self, proxy_address, msg):
        log.debug('receive-proxied-message')
        # mgs - > onu_id
        if PAS5211MsgHeader in msg:
            if msg['PAS5211MsgHeader'].onu_id != -1:
                handler = self.device_handlers[
                    proxy_address.channel_id][msg.onu_id]
                handler.receive_message(msg)

        # for onu, handler in self.device_handlers[proxy_address.channel_id].iteritems():
        #     handler.receive_message(msg)

    def receive_packet_out(self, logical_device_id, egress_port_no, msg):
        log.debug('packet-out', logical_device_id=logical_device_id,
                 egress_port_no=egress_port_no, msg_len=len(msg))

    def create_interface(self, device, data):
        raise NotImplementedError()

    def update_interface(self, device, data):
        raise NotImplementedError()

    def remove_interface(self, device, data):
        raise NotImplementedError()

    def receive_onu_detect_state(self, device_id, state):
        raise NotImplementedError()

    def receive_inter_adapter_message(self, msg):
        raise NotImplementedError()

    def suppress_alarm(self, filter):
        raise NotImplementedError()

    def unsuppress_alarm(self, filter):
        raise NotImplementedError()

    # Not used, delegated to handler
    def update_flow_table(self, device, flows):
        log.debug('update-flow-table', device_id=device.id, flows=flows)

class TlgsOnuHandler(object):

    def __init__(self, adapter, device_id):
        self.adapter = adapter
        self.adapter_agent = adapter.adapter_agent
        self.device_id = device_id
        self.log = structlog.get_logger(device_id=device_id)
        #self.incoming_messages = Queue.Queue()
        self.incoming_messages = DeferredQueue()
        self.event_messages = Queue.Queue()
        self.proxy_address = None
        self.tx_id = 0
        self.trangen = sequence_generator(1)
        self.port_id = None
        self.alloc_id = None
        self.cvlan_id = None
        self.subsvlan_id = None
        self.bandwidth = None
        self.flows_lock = 0
        self.flows = None
        self.policy_id = None
        self.flow_queue = DeferredQueue()

    def receive_message(self, msg):
        log.debug("receive-message",msg=msg.show(dump=True))
        self.incoming_messages.put(msg)

    def activate(self, device):
        log.debug('activate-onu-handler', device=device)
        try:

            # register for proxied messages right away
            self.proxy_address = device.proxy_address
            self.adapter_agent.register_for_proxied_messages(device.proxy_address)

            # First we verify that we got parent reference and proxy info
            assert device.parent_id
            assert device.proxy_address.device_id
            # == 0 # We want to activate multiple ONT's
            assert device.proxy_address.channel_id is not None
            # to get onu_id = device.proxy_address.onu_id

            # From PMC code:
            self.port_id = 1000 + 16 * device.proxy_address.onu_id
            self.alloc_id = self.port_id

            # we are going to use the proxy_address.channel_id as unique number
            # and name for the virtual ports, as this is guaranteed to be unique
            # in the context of the OLT port, so it is also unique in the context
            # of the logical device

            device.model = 'GPON ONU'
            device.hardware_version = 'tbd'
            device.firmware_version = 'tbd'

            device.connect_status = ConnectStatus.REACHABLE

            uni_port = Port(port_no=1,
                            label="{} ONU".format('TLGS'),
                            type=Port.ETHERNET_UNI,
                            admin_state=AdminState.ENABLED,
                            oper_status=OperStatus.ACTIVE
                            )

            self.adapter_agent.add_port(device.id, uni_port)

            log.debug('add-onu-port')

            pon_port = Port(
                            port_no=2,
                            label='PON port',
                            type=Port.PON_ONU,
                            admin_state=AdminState.ENABLED,
                            oper_status=OperStatus.ACTIVE,
                            peers=[
                                Port.PeerPort(
                                    device_id=device.parent_id,
                                    port_no=device.parent_port_no
                                )
                            ]
                        )

            self.adapter_agent.add_port(device.id, pon_port)

            log.debug('add-onu-port')

            # obtain logical device id
            parent_device = self.adapter_agent.get_device(device.parent_id)
            logical_device_id = parent_device.parent_id
            assert logical_device_id
            port_no = (device.proxy_address.channel_id * 32) + \
                (device.proxy_address.onu_id + 1)
            cap = OFPPF_1GB_FD | OFPPF_FIBER

            self.adapter_agent.add_logical_port(logical_device_id, LogicalPort(
                id=str(port_no),
                ofp_port=ofp_port(
                    port_no=port_no,
                    hw_addr=mac_str_to_tuple(device.serial_number)[2:8],
                    # name='uni-{}'.format(port_no),
                    name=device.serial_number[0:6],
                    config=0,
                    state=OFPPS_LIVE,
                    curr=cap,
                    advertised=cap,
                    peer=cap,
                    curr_speed=OFPPF_1GB_FD,
                    max_speed=OFPPF_1GB_FD
                ),
                device_id=device.id,
                device_port_no=uni_port.port_no
            ))

            log.debug('add-onu-logical-port')

            # Input logical port from ONT
            self.port_no = port_no

            # Finally update to "ACTIVE"
            device = self.adapter_agent.get_device(device.id)
            # In broadcom_onu.py this state is DISCOVERED
            device.oper_status = OperStatus.ACTIVE
            self.adapter_agent.update_device(device)

            log.info('activate-onu-end', device=device)

            # # Just in case, pull for existing flows...
            # flows = self.adapter_agent.root_proxy.get('/devices/{}/flows'.format(device.id))

            # log.debug('flows-got-from-deviceid', flows=flows.items)
            # reactor.callLater(0, self.update_flow_table, device, flows.items)

            # Listening thread (we wait 5 secs to start reading from queue)
            reactor.callLater(0, self.wait_for_flow_events, device)

        except Exception as e:
            log.exception('activate-failed', e=e)
            # raise Exception('Exception during onu activation')

    @inlineCallbacks
    def wait_for_flow_events(self, device):

        log.debug('wait-for-flow-events')
        event = yield self.flow_queue.get()
        log.debug("unqueued-flow-event")

        try:
            if event['action'] == 'install':
                response = yield self.install_flows_sequence(device, event['cvlan'], event['subsvlan'])
            elif event['action'] == 'reinstall':
                response = yield self.reinstall_flows_sequence(device, event['cvlan'], event['subsvlan'])
            elif event['action'] == 'remove':
                response = yield self.uninstall_flows_sequence(device)

            if response:
                log.debug("Event handled flow successfully")
            else:
                log.debug("Error handling flow event")
                # if event['retries'] < MAX_FLOW_EVENT_RETRIES:
                #     # Failed install events are turned into reinstall...
                #     if event['action'] == 'install':
                #         event['action'] = 'reinstall'
                #     event['retries'] += 1
                #     log.debug("Flow event retry")
                #     self.flow_queue.put(event)
                # else:
                #     log.debug("Max retries done for flow event handling.", event=event)
                #     # If we were trying to install a flow, we remove it...
                #     if event['action'] !=  'remove':
                #         event['action'] = 'remove'
                #         event['retries'] = 0
                #         self.flow_queue.put(event)

        except Exception as e:
            log.exception('wait-for-flow-events-exception', e=e)

        reactor.callLater(0, self.wait_for_flow_events, device)

    def reboot(self, device):
        log.debug('onu-reboot-start', device=device)

        if self.cvlan_id is not None and self.subsvlan_id is not None:
            flow_event = {'action': 'reinstall', 'cvlan': self.cvlan_id,
                    'subsvlan': self.subsvlan_id, 'retries': 0}
            self.flow_queue.put(flow_event)
            log.debug('onu-reinstall-event-created')
        else:
            log.debug('onu-reboot-ignored')

        log.debug('onu-reboot-end', device=device)

    def deactivate(self, device):
        try:
            log.debug('deactivate-onu', device=device)
            # Check parent reference and proxy info exists
            assert device.parent_id
            assert device.proxy_address.device_id

            # unregister from proxy messages
            self.adapter_agent.unregister_for_proxied_messages(device.proxy_address)
            self.proxy_address = None

            # Delete references to ports, if any

            if self.adapter_agent.get_ports(device.id, Port.ETHERNET_UNI):
                onu_port = self.adapter_agent.get_ports(device.id, Port.ETHERNET_UNI)[0]
                self.adapter_agent.delete_port_reference_from_parent(device.id, onu_port)

            if  self.adapter_agent.get_ports(device.id, Port.PON_ONU):
                pon_port = self.adapter_agent.get_ports(device.id, Port.PON_ONU)[0]
                self.adapter_agent.delete_port_reference_from_parent(device.id, pon_port)

            # Delete device and logical ports
            parent_device = self.adapter_agent.get_device(device.parent_id)
            logical_device_id = parent_device.parent_id
            # logical_device = self.adapter_agent.get_logical_device(logical_device_id)
            # self.adapter_agent.delete_logical_device(logical_device)

            if logical_device_id:
                logical_port = self.adapter_agent.get_logical_port(logical_device_id, self.port_no)
                if logical_port:
                    self.adapter_agent.delete_logical_port(logical_device_id, logical_port)

            # Finally delete device
            self.adapter_agent.delete_child_device(
                parent_device_id=device.proxy_address.device_id,
                child_device_id=device.id)

            log.debug('deactivate-onu-end')

        except Exception as e:
            log.exception('deactivate-failed', e=e)
            # raise Exception('Exception during onu deactivation')

    # @inlineCallbacks
    def update_flow_table(self, device, flows):
        cvlan_found = None
        subsvlan_found = 0


        log.debug('onu-update-flow-table', device_id=device.id, flows=flows)
        port_no = (device.proxy_address.channel_id * 32) + (device.proxy_address.onu_id + 1)
        log.debug('Checking {} flows for port:{}'.format(len(flows), port_no))
        try:

            for flow in flows:
                # Look for inner VLAN:
                for field in fd.get_ofb_fields(flow):

                    if field.type == fd.IN_PORT and field.port == 1:
                        if flow.table_id == 0:
                            if flow.priority == 1000:
                                for action in fd.get_actions(flow):
                                    if action.type == fd.SET_FIELD:
                                        cvlan_found = action.set_field.field.ofb_field.vlan_vid & 0xfff
                                        log.debug('CVLAN found:{}'.format(cvlan_found))

            if cvlan_found:
                if cvlan_found != self.cvlan_id:
                    if self.cvlan_id:
                        log.debug('Reinstall flow triggered')
                        flow_event = {'action': 'reinstall', 'cvlan': cvlan_found,
                                'subsvlan': subsvlan_found, 'retries': 0}
                        self.flow_queue.put(flow_event)
                    else:
                        log.debug('Flows installation triggered')
                        flow_event = {'action': 'install', 'cvlan': cvlan_found,
                                'subsvlan': subsvlan_found, 'retries': 0}
                        self.flow_queue.put(flow_event)
                else:
                    log.debug('Flows already installed')
            else:
                if self.cvlan_id:
                    log.debug('Flows deinstallation triggered')
                    flow_event = {'action': 'remove', 'cvlan': self.cvlan_id,
                                'subsvlan': self.subsvlan_id, 'retries': 0}
                    self.flow_queue.put(flow_event)
                else:
                    log.debug('Incomplete flow')

            self.cvlan_id = cvlan_found
            self.subsvlan_id = subsvlan_found

        except Exception as e:
            log.exception('failed-to-launch-install-flow', e=e, flow=flows)

    @inlineCallbacks
    def uninstall_flows_sequence(self, device):
        log.debug('init-flow-deinstallaton')
        try:
            response = yield self.delete_data_flow_omci_config(device)
            returnValue(response)
        except Exception as e:
            log.exception('failed-to-launch-uninstall-flow', e=e)

    @inlineCallbacks
    def reinstall_flows_sequence(self, device, cvlan_id, subsvlan_id):
        log.debug('init-flow-reinstallaton')
        try:
            response = yield self.uninstall_flows_sequence(device)
            if response:
                response = yield self.install_flows_sequence(device, cvlan_id, subsvlan_id)
                returnValue(response)
            returnValue(False)
        except Exception as e:
            log.exception('failed-to-launch-reinstall-flow', e=e)

    @inlineCallbacks
    def install_flows_sequence(self, device, cvlan_id, subsvlan_id):
        log.debug('init-flow-installaton')
        try:
            log.debug("ONT flow OMCI config", device=device)
            response = yield self.create_data_flow_omci_config(device, cvlan_id, subsvlan_id)
            returnValue(response)
        except Exception as e:
            log.exception('failed-to-launch-install-flow', e=e)

    @inlineCallbacks
    def wait_for_response(self):
        log.debug('wait-for-response')
        response = yield self.incoming_messages.get()
        log.debug("unqueued-message",msg=response.show(dump=True))
        returnValue(response)


    # PMC_OFAL.c line:2554
    @inlineCallbacks
    def create_data_flow_omci_config(self, device, cvlan_id, subsvlan_id):

        self.OMCI_ont_data_mib_reset(device)
        response = yield self.wait_for_response()

        if OmciMibResetResponse not in response:
            log.error("Failed to perform a MIB reset for {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_ont_data_mib_reset")

        self.OMCI_tcont_set(device)
        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to set alloc id for {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_tcont_set")

        self.pmc_omci_mac_bridge_sp_me_create(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to set parameter on {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_mac_bridge_sp_me_create")

        self.pmc_omci_mac_bridge_pcd_me_create(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to set info for {}".format(device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_mac_bridge_pcd_me_create")

        self.pmc_omci_evto_create(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to set association info for {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_evto_create")

        self.pmc_omci_evto_set(device)
        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to set association tpid info for {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_evto_set")

        # Reuse create_default_data_flow_omci_config (confirmed from logs)
        self.pmc_omci_8021p_msp_me_allocate(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to create 8021p msp on {}".format(
                device.proxy_address))
            if response is not None:
                log.error("Response received: {}".format(response.summary()))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_8021p_msp_me_allocate")

        # Reuse create_default_data_flow_omci_config?
        self.pmc_omci_mac_bridge_pcd_me_allocate(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to create mac bridge pcd on {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_mac_bridge_pcd_me_allocate")

        response = yield self.send_set_extended_vlan_tagging_operation_vlan_configuration_data(
            device, cvlan_id, subsvlan_id)

        if not response:
            returnValue(False)
        log.debug("[RESPONSE] OMCI_send_set_extended_vlan_tagging")

        self.send_create_vlan_tagging_filter_data(device, cvlan_id)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to set vlan tagging filter in {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_send_create_vlan_tagging_filter_data")

        self.pmc_omci_gem_nctp_me_allocate(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to Create gem nctp on {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_gem_nctp_me_allocate")

        self.pmc_omci_gem_iwtp_me_allocate(device)
        response = yield self.wait_for_response()
        if OmciCreateResponse not in response:
            log.error("Failed to Create gem iwtp on {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_gem_iwtp_me_allocate")

        self.pmc_omci_8021p_msp_me_assign(device)

        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to assign sp {}".format(
                device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] OMCI_8021p_msp_me_assign")

        returnValue(True)

    # PMC_OFAL.c line:3065
    @inlineCallbacks
    def delete_data_flow_omci_config(self, device):

        self.pmc_omci_evto_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate evt for {}".format(device.proxy_address))
            if response is not None:
                log.error("Response received: {}".format(response.summary()))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_evto_deallocate", device=device)

        self.pmc_omci_gem_iwtp_me_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate iwtp for {}".format(device.proxy_address))
            if response is not None:
                log.error("Response received: {}".format(response.summary()))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_gem_iwtp_me_deallocate", device=device)

        self.pmc_omci_gem_nctp_me_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate nctp for {}".format(device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_gem_nctp_me_deallocate", device=device)

        self.pmc_omci_vlan_tagging_filter_me_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate vlan tagging for {}".format(device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_vlan_tagging_filter_me_deallocate", device=device)

        self.pmc_omci_mac_bridge_pcd_me_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate bridge pcd for {}".format(device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_mac_bridge_pcd_me_deallocate", device=device)

        self.pmc_omci_8021p_msp_me_deallocate(device)
        response = yield self.wait_for_response()
        if OmciDeleteResponse not in response:
            log.error(
                "Failed to deallocate msp for {}".format(device.proxy_address))
            returnValue(False)
        log.debug("[RESPONSE] pmc_omci_8021p_msp_me_deallocate", device=device)

        returnValue(True)


    """ -   -   -   -   -   -   -     create_data_flow_omci_config      -   -   -   -   -   -   - """


    def OMCI_ont_data_mib_reset(self, device):
        # DO things to the ONU
        # |###[ OmciFrame ]###
        #     |  transaction_id= 1
        #     |  message_type= 79
        #     |  omci      = 10
        #     |  \omci_message\
        #     |   |###[ OmciMibReset ]###
        #     |   |  entity_class= 2
        #     |   |  entity_id = 0
        #     |  omci_trailer= 40

        # OmciMibReset

        msg = OmciMibReset(entity_class=2, entity_id=0)
        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciMibReset.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] OMCI_ont_data_mib_reset")

    def OMCI_tcont_set(self, device):
        # | ###[ OmciFrame ]###
        # | transaction_id = 2
        # | message_type = 72
        # | omci = 10
        # |   \omci_message \
        #      | |  ###[ OmciSet ]###
        # | | entity_class = 262
        # | | entity_id = 32769
        # | | attributes_mask = 32768
        # | | data = {'alloc_id': 1000}
        # | omci_trailer = 40

        # tcont_id = 1; //one tcont for one ONU.
        # slot_id = 128; /* represent the ONT as a whole entinty */
        # entity_instance = ((slot_id<<8) | tcont_id); /* Compose entity
        # instance by the slot-id and t-cont id*/

        # OmciSet
        # TODO: maskdata
        msg = OmciSet(entity_class=262, entity_id=32769, attributes_mask=32768,
                      data=dict(
                          alloc_id=self.alloc_id
                      ))
        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciSet.message_id,
                          omci_message=msg)
        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] OMCI_tcont_set")

    def pmc_omci_mac_bridge_sp_me_create(self, device):
        # length = 44
        # port_type = 0
        # port_id = 0
        # management_frame = 1
        # \frame \
        #  |  ###[ OmciFrame ]###
        # | transaction_id = 3
        # | message_type = 68
        # | omci = 10
        # |   \omci_message \
        #      | |  ###[ OmciCreate ]###
        # | | entity_class = 45
        # | | entity_id = 1
        # | | data = {'max_age': 5120, 'hello_time': 512, 'priority': 32768, 'port_bridging_ind': 0,
        #             'spanning_tree_ind': 0, 'unknown_mac_address_discard': 0, 'mac_learning_depth': 128,
        #             'learning_ind': 0, 'forward_delay': 3840}
        # | |  ###[ Raw ]###
        # | | load = '\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
        # | omci_trailer = 40

        # Found in method: pmc_omci_mac_bridge_sp_me_create from: PMC_OFAL.c
        # Params
        #   - priority: The bridge priority set on the LAN card
        #   - max_age: The maximum age for an entry in the spanning tree listing
        #   - hello_time: The time interval between hello packets
        #   - forward_delay: The time that the bridge on the Ethernet card in the ONT retains a packet before forwarding it
        #   - unknown_mac_address_discard: frames with unknown destination addresses will be forwarded to all allowed ports

        msg = OmciCreate(entity_class=45, entity_id=1,
                         data=dict(
                             max_age=5120,
                             hello_time=512,
                             priority=32768,
                             port_bridging_ind=PON_FALSE,
                             spanning_tree_ind=PON_FALSE,
                             unknown_mac_address_discard=0,
                             mac_learning_depth=128,
                             learning_ind=PON_FALSE,
                             forward_delay=3840
                         ))
        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)
        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_mac_bridge_sp_me_create")

    def pmc_omci_mac_bridge_pcd_me_create(self, device):

        # |###[ OmciFrame ]###
        #     |  transaction_id= 4
        #     |  message_type= 68
        #     |  omci      = 10
        #     |  \omci_message\
        #     |   |###[ OmciCreate ]###
        #     |   |  entity_class= 47
        #     |   |  entity_id = 0
        #     |   |  data      = {'tp_pointer': 257, 'encapsulation_methods': 1, 'port_num': 0, 'port_priority': 10, 'tp_type': 1, 'port_path_cost': 100, 'port_spanning_tree_in': 0, 'lan_fcs_ind': 0, 'bridge_id_pointer': 1}
        #     |  omci_trailer= 40

        # Found in method: pmc_omci_mac_bridge_pcd_me_create from: PMC_OFAL.c
        # Params
        #   - port_path_cost: The cost contribution of the port to the path cost towards the spanning tree root bridge
        #   - bridge_id_pointer: MAC bridge controlling the port

        msg = OmciCreate(entity_class=47, entity_id=0,
                         data=dict(
                             tp_pointer=257,
                             encapsulation_methods=OMCI_MAC_BRIDGE_PCD_ENCAP_METHOD_LLC,
                             port_num=0,
                             port_priority=10,
                             tp_type=1,
                             port_path_cost=100,
                             port_spanning_tree_in=PON_FALSE,
                             lan_fcs_ind=OMCI_MAC_BRIDGE_PCD_LANFCS_FORWARDED,
                             bridge_id_pointer=1
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_mac_bridge_pcd_me_create")

    def pmc_omci_evto_create(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 5
        # |  message_type= 68
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciCreate ]###
        # |   |  entity_class= 171
        # |   |  entity_id = 0
        # |   |  data      = {'association_type': 2, 'associated_me_pointer': 257}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_evto_create from: PMC_OFAL.c
        msg = OmciCreate(entity_class=171, entity_id=0,
                         data=dict(
                             association_type=OMCI_EX_VLAN_TAG_OCD_ASSOCIATION_TYPE_PPTP_ETH_UNI,
                             associated_me_pointer=257
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_evto_create")

    def pmc_omci_evto_set(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 6
        # |  message_type= 72
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciSet ]###
        # |   |  entity_class= 171
        # |   |  entity_id = 0
        # |   |  attributes_mask= 47616
        # |   |  data      = {'association_type': 2, 'input_tpid': 33024, 'associated_me_pointer': 257, 'downstream_mode': 0, 'output_tpid': 33024}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_evto_set from: PMC_OFAL.c
        msg = OmciSet(entity_class=171, entity_id=0, attributes_mask=47616,
                      data=dict(
                          association_type=OMCI_EX_VLAN_TAG_OCD_ASSOCIATION_TYPE_PPTP_ETH_UNI,
                          input_tpid=33024,
                          associated_me_pointer=257,
                          downstream_mode=OMCI_EX_VLAN_TAG_OCD_DS_MODE_US_INVERSE,
                          output_tpid=33024
                      ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciSet.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_evto_set")



    def pmc_omci_8021p_msp_me_allocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 7
        # |  message_type= 68
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciCreate ]###
        # |   |  entity_class= 130
        # |   |  entity_id = 1
        # |   |  data      = {'tp_pointer': 65535, 'unmarked_frame_option': 1, 'interwork_tp_pointer_for_p_bit_priority_6': 65535,
        #          'interwork_tp_pointer_for_p_bit_priority_7': 65535, 'interwork_tp_pointer_for_p_bit_priority_4': 65535,
        #           'interwork_tp_pointer_for_p_bit_priority_5': 65535, 'interwork_tp_pointer_for_p_bit_priority_2': 65535,
        #           'interwork_tp_pointer_for_p_bit_priority_3': 65535, 'interwork_tp_pointer_for_p_bit_priority_0': 65535,
        #           'interwork_tp_pointer_for_p_bit_priority_1': 65535, 'tp_type': 0, 'default_p_bit_marking': 0}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_8021p_msp_me_create from: PMC_OFAL.c
        msg = OmciCreate(entity_class=130, entity_id=1,
                         data=dict(
                             tp_pointer=65535,
                             unmarked_frame_option=OMCI_8021P_MSP_UNMARKED_FRAME_TAG_FRAME,
                             interwork_tp_pointer_for_p_bit_priority_6=65535,
                             interwork_tp_pointer_for_p_bit_priority_7=65535,
                             interwork_tp_pointer_for_p_bit_priority_4=65535,
                             interwork_tp_pointer_for_p_bit_priority_5=65535,
                             interwork_tp_pointer_for_p_bit_priority_2=65535,
                             interwork_tp_pointer_for_p_bit_priority_3=65535,
                             interwork_tp_pointer_for_p_bit_priority_0=65535,
                             interwork_tp_pointer_for_p_bit_priority_1=65535,
                             tp_type=OMCI_8021P_MSP_TP_TYPE_NULL,
                             default_p_bit_marking=0
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_8021p_msp_me_allocate")

    def pmc_omci_mac_bridge_pcd_me_allocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 8
        # |  message_type= 68
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciCreate ]###
        # |   |  entity_class= 130
        # |   |  entity_id = 1
        # |   |  data      = {'tp_pointer': 1, 'encapsulation_methods': 1, 'port_num': 1, 'port_priority': 3, 'tp_type': 5, 'port_path_cost': 32, 'port_spanning_tree_in': 1, 'lan_fcs_ind': 0, 'bridge_id_pointer': 1}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_mac_bridge_pcd_me_create from: PMC_OFAL.c
        # Params
        #   - port_path_cost: The cost contribution of the port to the path cost towards the spanning tree root bridge
        #   - bridge_id_pointer: MAC bridge controlling the port
        msg = OmciCreate(entity_class=47, entity_id=1,
                         data=dict(
                             tp_pointer=1,
                             encapsulation_methods=OMCI_MAC_BRIDGE_PCD_ENCAP_METHOD_LLC,
                             port_num=1,
                             port_priority=10,
                             tp_type=3,
                             port_path_cost=100,
                             port_spanning_tree_in=PON_FALSE,
                             lan_fcs_ind=OMCI_MAC_BRIDGE_PCD_LANFCS_FORWARDED,
                             bridge_id_pointer=1
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_mac_bridge_pcd_me_allocate")

    def pmc_omci_gem_nctp_me_allocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 9
        # |  message_type= 68
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciCreate ]###
        # |   |  entity_class= 268
        # |   |  entity_id = 1
        # |   |  data      = {'priority_queue_pointer_downstream': 0, 'direction': 3, 'tcont_pointer': 32769, 'traffic_descriptor_profile_pointer': 0, 'traffic_management_pointer_upstream': 4, 'port_id': 1000}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_gem_nctp_create from: PMC_OFAL.c
        msg = OmciCreate(entity_class=268, entity_id=1,
                         data=dict(
                             priority_queue_pointer_downstream=0,   # 0 for default
                             direction=GEM_DIR_BIDIRECT,
                             tcont_pointer=32769,
                             traffic_descriptor_profile_pointer=0,
                             traffic_management_pointer_upstream=4,  # 4 for feault
                             # Same as GEM port
                             # port_id=(1000 + device.proxy_address.onu_id)
                             port_id = self.port_id
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_gem_nctp_me_allocate")

    def pmc_omci_gem_iwtp_me_allocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 10
        # |  message_type= 68
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciCreate ]###
        # |   |  entity_class= 266
        # |   |  entity_id = 1
        # |   |  data      = {'gem_port_network_ctp_pointer': 1, 'gal_profile_pointer': 0, 'service_profile_pointer': 1, 'interworking_option': 5, 'interworking_tp_pointer': 0}
        # |  omci_trailer= 40

        # Found in method: pmc_omci_gem_iwtp_me_create from: PMC_OFAL.c
        # Params
        #   - gem_port_network_ctp_pointer: An instance identifier of the GEM Port Network CTP that is associated with this GEM Interworking Termination Point
        #   - service_profile_pointer: The service profile type and a pointer to the instance of a service profile
        #   - interworking_tp_pointer: Used for in the case of Circuit Emulation Services and 802.1p mapper service
        #   - gal_profile_pointer: A pointer to an instance of the GAL Profile

        msg = OmciCreate(entity_class=266, entity_id=1,
                         data=dict(
                             gem_port_network_ctp_pointer=1,
                             gal_profile_pointer=0,
                             service_profile_pointer=1,
                             interworking_option=OMCI_GEM_IWTP_IW_OPT_8021P_MAPPER,
                             interworking_tp_pointer=0
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_gem_iwtp_me_allocate")



    def send_create_extended_vlan_tagging_operation_configuration_data(self, device):

        msg = OmciCreate(entity_class=171,
                         entity_id=0,
                         data=dict(
                             association_type=2,
                             associated_me_pointer=257
                         ))

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciCreate.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug(
            "[SENT] create_extended_vlan_tagging_operation_configuration_data")

    # self.send_set_extended_vlan_tagging_operation_tpid_configuration_data(0x202, 0x8100, 0x8100)
    def send_set_extended_vlan_tagging_operation_tpid_configuration_data(self, device):

        data = dict(
            association_type=2,
            input_tpid=33024,
            associated_me_pointer=257,
            downstream_mode=OMCI_EX_VLAN_TAG_OCD_DS_MODE_US_INVERSE,
            output_tpid=33024,
        )

        msg = OmciSet(entity_class=171,
                      entity_id=0,
                      attributes_mask=47616,  # 1024 in broadcom but 47616 observed from PMC
                      data=data
                      )

        frame = OmciFrame(
            transaction_id=self.trangen.next(),
            message_type=OmciSet.message_id,
            omci_message=msg
        )
        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug(
            "[SENT] set_extended_vlan_tagging_operation_tpid_configuration_data")

    @inlineCallbacks
    def send_set_extended_vlan_tagging_operation_vlan_configuration_data(self, device, cvlan_id, subs_vlan):
        # ###[ PAS5211MsgSendFrame ]###
        #            length    = 44
        #            port_type = 0
        #            port_id   = 0
        #            management_frame= 1
        #            \frame     \
        #             |###[ OmciFrame ]###
        #             |  transaction_id= 14
        #             |  message_type= 72
        #             |  omci      = 10
        #             |  \omci_message\
        #             |   |###[ OmciSet ]###
        #             |   |  entity_class= 171
        #             |   |  entity_id = 0
        #             |   |  attributes_mask= 1024
        #             |   |  data      = {'received_frame_vlan_tagging_operation_table': '\xf8\x00\x00\x00\x00\x00@\x00@\x0f\x00\x04\x00\x00\x00\x0c'}
        #             |  omci_trailer= 40

        # TODO  Check filter_inner_priority value
        """vlan_oper_table_entry.filter_configuration.filter_inner_tagging.vlan_priority = filter_inner_vlan_pcp;
            vlan_oper_table_entry.filter_configuration.filter_inner_tagging.vlan_vid = filter_inner_vlan_id;
        """
        self.send_vlan_tagging_operation_msg(device,
            VlanTaggingOperation(
                filter_outer_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_NO_TAG,
                filter_outer_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,

                filter_inner_priority=0,
                filter_inner_vid=subs_vlan,
                filter_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_8100,
                filter_ether_type=OMCI_EX_VLAN_TAG_OCD_FILTER_ETYPE_NONE,

                treatment_tags_to_remove=1,
                treatment_outer_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_outer_vid=0,
                treatment_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_EQ_8100,

                treatment_inner_priority=0,
                treatment_inner_vid=cvlan_id,
                treatment_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_EQ_8100
            )
            )
        response = yield self.wait_for_response()

        log.debug(
            "[SENT] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        if OmciSetResponse not in response:
            log.error("Failed to set vlan extended table entry {}".format(
                device.proxy_address))
            returnValue(False)

        log.debug(
            "[RESPONSE] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        self.send_vlan_tagging_operation_msg(device,
            VlanTaggingOperation(
                filter_outer_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_NO_TAG,
                filter_outer_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,

                filter_inner_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_NO_TAG,
                filter_inner_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,
                filter_ether_type=OMCI_EX_VLAN_TAG_OCD_FILTER_ETYPE_NONE,

                treatment_tags_to_remove=3,
                treatment_outer_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_outer_vid=0,
                treatment_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_OUTER,

                treatment_inner_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_inner_vid=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_COPY_FROM_INNER,
                treatment_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_INNER
            )
            )

        log.debug(
            "[SENT] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to set vlan extended table entry {}".format(
                device.proxy_address))
            returnValue(False)

        log.debug(
            "[RESPONSE] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        self.send_vlan_tagging_operation_msg(device,
            VlanTaggingOperation(
                filter_outer_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_NO_TAG,
                filter_outer_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,

                filter_inner_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_DEFAULT,
                filter_inner_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,
                filter_ether_type=OMCI_EX_VLAN_TAG_OCD_FILTER_ETYPE_NONE,

                treatment_tags_to_remove=3,
                treatment_outer_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_outer_vid=0,
                treatment_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_OUTER,

                treatment_inner_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_inner_vid=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_COPY_FROM_INNER,
                treatment_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_INNER
            )
            )

        log.debug(
            "[SENT] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to set vlan extended table entry {}".format(
                device.proxy_address))
            returnValue(False)

        log.debug(
            "[RESPONSE] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        self.send_vlan_tagging_operation_msg(device,
            VlanTaggingOperation(
                filter_outer_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_DEFAULT,
                filter_outer_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,

                filter_inner_priority=OMCI_EX_VLAN_TAG_OCD_FILTER_PRIO_DEFAULT,
                filter_inner_vid=OMCI_EX_VLAN_TAG_OCD_FILTER_VID_NONE,
                filter_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_FILTER_TPID_DE_NONE,
                filter_ether_type=OMCI_EX_VLAN_TAG_OCD_FILTER_ETYPE_NONE,

                treatment_tags_to_remove=3,
                treatment_outer_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_outer_vid=0,
                treatment_outer_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_OUTER,

                treatment_inner_priority=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_NONE,
                treatment_inner_vid=OMCI_EX_VLAN_TAG_OCD_TREAT_PRIO_COPY_FROM_INNER,
                treatment_inner_tpid_de=OMCI_EX_VLAN_TAG_OCD_TREAT_TPID_DE_COPY_FROM_INNER
            )
            )

        log.debug(
            "[SENT] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        response = yield self.wait_for_response()
        if OmciSetResponse not in response:
            log.error("Failed to set vlan extended table entry {}".format(
                device.proxy_address))
            returnValue(False)

        log.debug(
            "[RESPONSE] send_set_extended_vlan_tagging_operation_vlan_configuration_data")

        returnValue(True)


    def send_vlan_tagging_operation_msg(self, device, vlan_tagging_operation_table):

        data = dict(
            received_frame_vlan_tagging_operation_table=vlan_tagging_operation_table
        )

        msg = OmciSet(
            entity_class=171,
            entity_id=0,
            attributes_mask=1024,
            data=data
        )

        frame = OmciFrame(
            transaction_id=self.trangen.next(),
            message_type=OmciSet.message_id,
            omci_message=msg
        )

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] create_vlan_tagging_filter_data")

    def send_create_vlan_tagging_filter_data(self, device, cvlan_id):
        # ###[ PAS5211MsgSendFrame ]###
        #    length    = 44
        #    port_type = 0
        #    port_id   = 0
        #    management_frame= 1
        #    \frame     \
        #     |###[ OmciFrame ]###
        #     |  transaction_id= 18
        #     |  message_type= 68
        #     |  omci      = 10
        #     |  \omci_message\
        #     |   |###[ OmciCreate ]###
        #     |   |  entity_class= 84
        #     |   |  entity_id = 2
        #     |   |  data      = {'vlan_filter_0': 1, 'vlan_filter_1': 0, 'vlan_filter_2': 0, 'vlan_filter_3': 0, 'vlan_filter_4': 0, 'vlan_filter_5': 0, 'vlan_filter_6': 0, 'vlan_filter_7': 0, 'vlan_filter_8': 0, 'vlan_filter_9': 0, 'number_of_entries': 1, 'forward_operation': 16, 'vlan_filter_10': 0, 'vlan_filter_11': 0}
        #     |  omci_trailer= 40

        data = dict(
            vlan_filter_0=cvlan_id,
            forward_operation=16,
            number_of_entries=1
        )

        msg = OmciCreate(
            entity_class=84,
            entity_id=1,
            data=data
        )

        frame = OmciFrame(
            transaction_id=self.trangen.next(),
            message_type=OmciCreate.message_id,
            omci_message=msg
        )

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] create_vlan_tagging_filter_data")

    def pmc_ofal_remove_default_onu_flow_omci(self, device):  # TODO
        # ###[ PAS5211Dot3 ]###
        #     dst = 00:0
        #     c: d5:00: 04:10
        #     src = 02:00: d3:77: 47:49
        #     len = 74
        # ###[ PAS5211FrameHeader ]###
        #     part = 1
        #     total_parts = 1
        #     size = 68
        #     magic_number = 0x1234abcd
        # ###[ PAS5211MsgHeader ]###
        #     sequence_number = 201
        #     opcode = 0x302a
        #     event_type = 0
        #     channel_id = 1
        #     onu_id = 0
        #     onu_session_id = 1
        # ###[ PAS5211MsgSendFrame ]###
        #     length = 44
        #     port_type = 0
        #     port_id = 0
        #     management_frame = 1
        #     \frame \
        #      |  ###[ OmciFrame ]###
        #         | transaction_id = 44
        #         | message_type = 70
        #         | omci = 10
        #         |   \omci_message \
        #              | |  ###[ OmciDelete ]###
        #         | | entity_class = 47
        #         | | entity_id = 1
        #     | omci_trailer = 40
        log.debug("[SENT] pmc_ofal_remove_default_onu_flow_omci")
        pass

    def pmc_omci_evto_vlan_oper_table_entry_assign(self, device):  # TODO

        # /* Fill the set message */
        # entity.entity_class    = OMCI_ENT_EX_VLAN_TAGGING_OPER_CONFIG_DATA;
        # entity.entity_instance = entity_instance;
        # set_req_msg.attr_mask  = attributes_mask;

        # typedef struct OMCI_ex_vlan_tagging_operation_config_me_set_t
        # {
        #     INT8U             association_type;    /* Association type  ,R,W,C  (ASSOCIATION_TYPE_)*/
        #     INT16U            input_tpid;         /* Input TPID value   ,R,W (16 bit value)*/
        #     INT16U            output_tpid;        /* Output TPID value  ,R,W (16 bit value)*/
        #     INT8U             downstream_mode;    /* downstream mode    ,R,W (OCD_DS_MODE_)*/
        #
        #     OMCI_ex_vlan_tag_op_table_entry_t       /* Operation entry    ,R,W (16 bytes)    */
        #                         operations_entry;
        #
        #     OMCI_instance_id_t    associated_me_ptr;
        #
        #     INT8U               dscp2pbit_mapping[OMCI_EX_VLAN_TAG_ATTR_DSCP2PBIT_MAPPING_SIZE];/*dscp-to-pbit mapping ,R,W (24 bytes)*/
        #
        # } OMCI_ex_vlan_tagging_operation_config_me_set_t;

        # attibute_mask = 0
        # # attibute_mask |= ( (INT16U)1 << ((OMCI_ATTR_MAX-1)-(OMCI_EX_VLAN_TAG_OCD_ATTR_RX_FRAME_OP_TABLE)))
        # msg = OmciSet(entity_class=OMCI_ENT_EX_VLAN_TAGGING_OPER_CONFIG_DATA, entity_id=0, attributes_mask=attibute_mask,
        #               data=dict(
        #                   association_type=,
        #                   input_tpid=,
        #                   output_tpid=,
        #                   downstream_mode=,
        #                   associated_me_pointer=,
        #                   dscp2pbit_mapping=
        #               ))

        # frame = OmciFrame(transaction_id=self.trangen.next(),
        #                   message_type=OmciSet.message_id,
        #                   omci_message=msg)

        # self.adapter_agent.send_proxied_message(device.proxy_address, frame)

        # TODO: Sends up to three OMCI Set messages
        log.debug("[SENT] pmc_omci_evto_vlan_oper_table_entry_assign")
        pass

    @inlineCallbacks
    def pmc_omci_vlan_tagging_filter_me_allocate(self, device):  # TODO

        self.OMCI_vlan_tagging_filter_get(device)
        response = yield self.incoming_messages.get()
        if OmciGetResponse not in response:
            log.error("Failed to Get vlan tagging filter {}".format(
                device.proxy_address))
            return

        # if: # OMCI Get is sucessfull
        #     # OMCI_vlan_tagging_filter_create
        # else:
        #     # OMCI_vlan_tagging_filter_set
        log.debug("[SENT] pmc_omci_vlan_tagging_filter_me_allocate")
        pass

    def pmc_omci_8021p_msp_me_assign(self, device):

        # ###[ PAS5211MsgSendFrame ]###
        #    length    = 44
        #    port_type = 0
        #    port_id   = 0
        #    management_frame= 1
        #    \frame     \
        #     |###[ OmciFrame ]###
        #     |  transaction_id= 21
        #     |  message_type= 72
        #     |  omci      = 10
        #     |  \omci_message\
        #     |   |###[ OmciSet ]###
        #     |   |  entity_class= 130
        #     |   |  entity_id = 2
        #     |   |  attributes_mask= 16472
        #     |   |  data      = {'tp_type': 0, 'unmarked_frame_option': 1, 'interwork_tp_pointer_for_p_bit_priority_0': 2, 'default_p_bit_marking': 0}
        #     |  omci_trailer= 40

        data = dict(tp_type=0,
                    output_tpid=33024,
                    unmarked_frame_option=1,
                    interwork_tp_pointer_for_p_bit_priority_0=1,
                    default_p_bit_marking=0
                    )

        msg = OmciSet(entity_class=130,
                      entity_id=1,
                      attributes_mask=16472,
                      data=data
                      )

        frame = OmciFrame(
            transaction_id=self.trangen.next(),
            message_type=OmciSet.message_id,
            omci_message=msg
        )
        self.adapter_agent.send_proxied_message(device.proxy_address, frame)

        log.debug("[SENT] pmc_omci_8021p_msp_me_assign")

    def pmc_ofal_recover_default_onu_flow_omci(self, device):
        log.debug("[SENT] pmc_ofal_recover_default_onu_flow_omci")
        pass

    def OMCI_vlan_tagging_filter_get(self, device):
        # entity_class: OMCI_ENT_VLAN_TAGGING_FILT_DATA
        # entity_instance: mac_bridge_pcd
        # attr_mask = 0
        # attr_mask | OMCI_ATTR_BIT(OMCI_VLAN_TAG_FILTER_ATTR_FILTER_TABLE);
        # attr_mask | OMCI_ATTR_BIT(OMCI_VLAN_TAG_FILTER_ATTR_FWD_OP);
        # attr_mask | OMCI_ATTR_BIT(OMCI_VLAN_TAG_FILTER_ATTR_NOF_ENTRIES);
        log.debug("[SENT] OMCI_vlan_tagging_filter_get")
        pass

    def OMCI_vlan_tagging_filter_create(self, device):  # TODO
        log.debug("[SENT] OMCI_vlan_tagging_filter_create")
        pass

    def OMCI_vlan_tagging_filter_set(self, device):  # TODO
        log.debug("[SENT] OMCI_vlan_tagging_filter_set")
        pass

    """ -   -   -   -   -   -   -    END create_data_flow_omci_config      -   -   -   -   -   -   - """

    """ -   -   -   -   -   -   -   delete_data_flow_omci_config   -   -   -   -   -   -   - """

    def pmc_omci_gem_iwtp_me_deallocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 34
        # |  message_type= 70
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciDelete ]###
        # |   |  entity_class= 266
        # |   |  entity_id = 2
        # |  omci_trailer= 40
        msg = OmciDelete(entity_class=266, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_gem_iwtp_me_deallocate")

    def pmc_omci_gem_nctp_me_deallocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 35
        # |  message_type= 70
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciDelete ]###
        # |   |  entity_class= 268
        # |   |  entity_id = 2
        # |  omci_trailer= 40
        msg = OmciDelete(entity_class=268, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_gem_nctp_me_allocate")

    def pmc_omci_vlan_tagging_filter_me_deallocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 36
        # |  message_type= 70
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciDelete ]###
        # |   |  entity_class= 84
        # |   |  entity_id = 2
        # |  omci_trailer= 40
        msg = OmciDelete(entity_class=84, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_vlan_tagging_filter_me_deallocate")


    def pmc_omci_mac_bridge_pcd_me_deallocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 37
        # |  message_type= 70
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciDelete ]###
        # |   |  entity_class= 47
        # |   |  entity_id = 2
        # |  omci_trailer= 40
        msg = OmciDelete(entity_class=47, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_mac_bridge_pcd_me_deallocate")



    def pmc_omci_8021p_msp_me_deallocate(self, device):
        # |###[ OmciFrame ]###
        # |  transaction_id= 38
        # |  message_type= 70
        # |  omci      = 10
        # |  \omci_message\
        # |   |###[ OmciDelete ]###
        # |   |  entity_class= 130
        # |   |  entity_id = 2
        # |  omci_trailer= 40
        msg = OmciDelete(entity_class=130, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)

        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_8021p_msp_me_deallocate")

    def pmc_omci_evto_deallocate(self, device):

        msg = OmciDelete(entity_class=171, entity_id=1)

        frame = OmciFrame(transaction_id=self.trangen.next(),
                          message_type=OmciDelete.message_id,
                          omci_message=msg)
        self.adapter_agent.send_proxied_message(device.proxy_address, frame)
        log.debug("[SENT] pmc_omci_evto_deallocate")



    """ -   -   -   -   -   -   -   END delete_data_flow_omci_config   -   -   -   -   -   -   - """