adapters/adtran_onu/omci/deprecated/adtn_service_download_task.py

#
# Copyright 2018 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.
#
from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks, returnValue, TimeoutError, failure
from voltha.extensions.omci.omci_me import *
from voltha.extensions.omci.tasks.task import Task
from voltha.extensions.omci.omci_defs import *
from voltha.adapters.adtran_onu.omci.omci import OMCI

OP = EntityOperations
RC = ReasonCodes


class ServiceDownloadFailure(Exception):
    """
    This error is raised by default when the download fails
    """


class ServiceResourcesFailure(Exception):
    """
    This error is raised by when one or more resources required is not available
    """


class AdtnServiceDownloadTask(Task):
    """
    OpenOMCI MIB Download Example - Service specific

    This task takes the legacy OMCI 'script' for provisioning the Adtran ONU
    and converts it to run as a Task on the OpenOMCI Task runner.  This is
    in order to begin to decompose service instantiation in preparation for
    Technology Profile work.

    Once technology profiles are ready, some of this task may hang around or
    be moved into OpenOMCI if there are any very common settings/configs to do
    for any profile that may be provided in the v2.0 release

    Currently, the only service tech profiles expected by v2.0 will be for AT&T
    residential data service and DT residential data service.
    """
    task_priority = Task.DEFAULT_PRIORITY + 10
    default_tpid = 0x8100                       # TODO: Move to a better location
    name = "ADTRAN Service Download Task"
    free_tcont_alloc_id = 0xFFFF
    free_gpon_tcont_alloc_id = 0xFF

    def __init__(self, omci_agent, handler):
        """
        Class initialization

        :param omci_agent: (OpenOMCIAgent) OMCI Adapter agent
        :param device_id: (str) ONU Device ID
        """
        super(AdtnServiceDownloadTask, self).__init__(AdtnServiceDownloadTask.name,
                                                      omci_agent,
                                                      handler.device_id,
                                                      priority=AdtnServiceDownloadTask.task_priority,
                                                      exclusive=False)
        self._handler = handler
        self._onu_device = omci_agent.get_device(handler.device_id)
        self._local_deferred = None
        self._pon = handler.pon_port()
        self._extended_vlan_me_created = False

        self._input_tpid = AdtnServiceDownloadTask.default_tpid
        self._output_tpid = AdtnServiceDownloadTask.default_tpid

        # TODO: TCIS below is just a test, may need 0x900...as in the xPON mode
        # self._vlan_tcis_1 = OMCI.DEFAULT_UNTAGGED_VLAN
        self._vid = OMCI.DEFAULT_UNTAGGED_VLAN

        # Entity IDs. IDs with values can probably be most anything for most ONUs,
        #             IDs set to None are discovered/set
        #
        # TODO: Probably need to store many of these in the appropriate object (UNI, PON,...)
        #
        self._ieee_mapper_service_profile_entity_id = self._pon.ieee_mapper_service_profile_entity_id
        self._gal_enet_profile_entity_id = self._handler.gal_enet_profile_entity_id

        # Next to are specific
        self._ethernet_uni_entity_id = self._handler.uni_ports[0].entity_id
        self._mac_bridge_service_profile_entity_id = self._handler.mac_bridge_service_profile_entity_id

    def cancel_deferred(self):
        super(AdtnServiceDownloadTask, self).cancel_deferred()

        d, self._local_deferred = self._local_deferred, None
        try:
            if d is not None and not d.called:
                d.cancel()
        except:
            pass

    def start(self):
        """
        Start the MIB Service Download
        """
        super(AdtnServiceDownloadTask, self).start()
        self._local_deferred = reactor.callLater(0, self.perform_service_download)

    def stop(self):
        """
        Shutdown MIB Service download
        """
        self.log.debug('stopping')

        self.cancel_deferred()
        super(AdtnServiceDownloadTask, self).stop()

    def check_status_and_state(self, results, operation=''):
        """
        Check the results of an OMCI response.  An exception is thrown
        if the task was cancelled or an error was detected.

        :param results: (OmciFrame) OMCI Response frame
        :param operation: (str) what operation was being performed
        :return: True if successful, False if the entity existed (already created)
        """
        omci_msg = results.fields['omci_message'].fields
        status = omci_msg['success_code']
        error_mask = omci_msg.get('parameter_error_attributes_mask', 'n/a')
        failed_mask = omci_msg.get('failed_attributes_mask', 'n/a')
        unsupported_mask = omci_msg.get('unsupported_attributes_mask', 'n/a')

        self.log.debug(operation, status=status, error_mask=error_mask,
                       failed_mask=failed_mask, unsupported_mask=unsupported_mask)

        if status == RC.Success:
            self.strobe_watchdog()
            return True

        elif status == RC.InstanceExists:
            return False

        raise ServiceDownloadFailure('{} failed with a status of {}, error_mask: {}, failed_mask: {}, unsupported_mask: {}'
                                     .format(operation, status, error_mask, failed_mask, unsupported_mask))

    @inlineCallbacks
    def perform_service_download(self):
        """
        Send the commands to minimally configure the PON, Bridge, and
        UNI ports for this device. The application of any service flows
        and other characteristics are done once resources (gem-ports, tconts, ...)
        have been defined.
        """
        self.log.debug('perform-service-download')
        device = self._handler.adapter_agent.get_device(self.device_id)

        def resources_available():
            return (len(self._handler.uni_ports) > 0 and
                    len(self._pon.tconts) and
                    len(self._pon.gem_ports))

        if self._handler.enabled and resources_available():
            device.reason = 'Performing Service OMCI Download'
            self._handler.adapter_agent.update_device(device)

            try:
                # Lock the UNI ports to prevent any alarms during initial configuration
                # of the ONU
                self.strobe_watchdog()
                # Provision the initial bridge configuration
                yield self.perform_service_specific_steps()

                # And re-enable the UNIs if needed
                yield self.enable_unis(self._handler.uni_ports, False)

                # If here, we are done
                device = self._handler.adapter_agent.get_device(self.device_id)
                device.reason = ''
                self._handler.adapter_agent.update_device(device)
                self.deferred.callback('service-download-success')

            except TimeoutError as e:
                self.deferred.errback(failure.Failure(e))

            except Exception as e:
                self.deferred.errback(failure.Failure(e))
        else:
            # TODO: Provide better error reason, what was missing...
            e = ServiceResourcesFailure('Required resources are not available')
            self.deferred.errback(failure.Failure(e))

    @inlineCallbacks
    def perform_service_specific_steps(self):
        omci_cc = self._onu_device.omci_cc
        frame = None

        try:
            ################################################################################
            # TCONTS
            #
            #  EntityID will be referenced by:
            #            - GemPortNetworkCtp
            #  References:
            #            - ONU created TCONT (created on ONU startup)

            tcont_idents = self._onu_device.query_mib(Tcont.class_id)
            self.log.debug('tcont-idents', tcont_idents=tcont_idents)

            for tcont in self._pon.tconts.itervalues():
                if tcont.entity_id is None:
                    free_ids = {AdtnServiceDownloadTask.free_tcont_alloc_id,
                                AdtnServiceDownloadTask.free_gpon_tcont_alloc_id}

                    free_entity_id = next((k for k, v in tcont_idents.items()
                                           if isinstance(k, int) and
                                           v.get('attributes', {}).get('alloc_id', 0) in
                                           free_ids), None)

                    if free_entity_id is None:
                        self.log.error('no-available-tconts')
                        raise ServiceResourcesFailure('No Available TConts')

                    try:
                        prev_alloc_id = tcont_idents[free_entity_id].get('attributes').get('alloc_id')
                        yield tcont.add_to_hardware(omci_cc, free_entity_id, prev_alloc_id=prev_alloc_id)

                    except Exception as e:
                        self.log.exception('tcont-set', e=e, eid=free_entity_id)
                        raise

            ################################################################################
            # GEMS  (GemPortNetworkCtp and GemInterworkingTp)
            #
            #  For both of these MEs, the entity_id is the GEM Port ID. The entity id of the
            #  GemInterworkingTp ME could be different since it has an attribute to specify
            #  the GemPortNetworkCtp entity id.
            #
            #  TODO: In the GEM Port routine to add, it has a hardcoded upstream TM ID of 0x8000
            #        for the GemPortNetworkCtp ME
            #
            #  GemPortNetworkCtp
            #    EntityID will be referenced by:
            #              - GemInterworkingTp
            #    References:
            #              - TCONT
            #              - Hardcoded upstream TM Entity ID
            #              - (Possibly in Future) Upstream Traffic descriptor profile pointer
            #
            #  GemInterworkingTp
            #    EntityID will be referenced by:
            #              - Ieee8021pMapperServiceProfile
            #    References:
            #              - GemPortNetworkCtp
            #              - Ieee8021pMapperServiceProfile
            #              - GalEthernetProfile
            #
            for gem_port in self._pon.gem_ports.itervalues():
                if not gem_port.in_hardware:
                    tcont = gem_port.tcont
                    if tcont is None:
                        raise Exception('unknown-tcont-reference', gem_id=gem_port.gem_id)

                    try:
                        yield gem_port.add_to_hardware(omci_cc,
                                                       tcont.entity_id,
                                                       self._ieee_mapper_service_profile_entity_id,
                                                       self._gal_enet_profile_entity_id)
                    except Exception as e:
                        self.log.exception('gem-add-failed', e=e, gem=gem_port)
                        raise

            ################################################################################
            # Update the IEEE 802.1p Mapper Service Profile config
            #
            #  EntityID was created prior to this call. This is a set
            #
            #  References:
            #            - Gem Interworking TPs are set here
            #
            # TODO: All p-bits currently go to the one and only GEMPORT ID for now
            gem_ports = self._pon.gem_ports

            if len(gem_ports):
                gem_entity_ids = [gem_port.entity_id for _, gem_port in gem_ports.items()]
            else:
                gem_entity_ids = [OmciNullPointer]

            frame = Ieee8021pMapperServiceProfileFrame(
                self._ieee_mapper_service_profile_entity_id,  # 802.1p mapper Service Mapper Profile ID
                interwork_tp_pointers=gem_entity_ids          # Interworking TP IDs
            ).set()
            results = yield omci_cc.send(frame)
            self.check_status_and_state(results, 'set-8021p-mapper-service-profile')

            ################################################################################
            # Create Extended VLAN Tagging Operation config (PON-side)
            #
            #  EntityID relates to the VLAN TCIS
            #  References:
            #            - VLAN TCIS from previously created VLAN Tagging filter data
            #            - PPTP Ethernet UNI
            #
            # TODO: add entry here for additional UNI interfaces

            attributes = dict(
                association_type=2,                                 # Assoc Type, PPTP Ethernet UNI
                associated_me_pointer=self._ethernet_uni_entity_id  # Assoc ME, PPTP Entity Id
            )

            frame = ExtendedVlanTaggingOperationConfigurationDataFrame(
                self._mac_bridge_service_profile_entity_id,
                attributes=attributes
            ).create()
            results = yield omci_cc.send(frame)
            self.check_status_and_state(results, 'create-extended-vlan-tagging-operation-configuration-data')
            self._extended_vlan_me_created = True

            ################################################################################
            # Update Extended VLAN Tagging Operation Config Data
            #
            # Specifies the TPIDs in use and that operations in the downstream direction are
            # inverse to the operations in the upstream direction
            # TODO: Downstream mode may need to be modified once we work more on the flow rules

            attributes = dict(
                input_tpid=self._input_tpid,    # input TPID
                output_tpid=self._output_tpid,  # output TPID
                downstream_mode=0,              # inverse of upstream
            )
            frame = ExtendedVlanTaggingOperationConfigurationDataFrame(
                self._mac_bridge_service_profile_entity_id,
                attributes=attributes
            ).set()
            results = yield omci_cc.send(frame)
            self.check_status_and_state(results, 'set-extended-vlan-tagging-operation-configuration-data')

            ################################################################################
            # Update Extended VLAN Tagging Operation Config Data
            #
            # parameters: Entity Id ( 0x900), Filter Inner Vlan Id(0x1000-4096,do not filter on Inner vid,
            #             Treatment Inner Vlan Id : 2

            attributes = dict(
                received_frame_vlan_tagging_operation_table=
                VlanTaggingOperation(
                    filter_outer_priority=15,  # This entry is not a double-tag rule
                    filter_outer_vid=4096,     # Do not filter on the outer VID value
                    filter_outer_tpid_de=0,    # Do not filter on the outer TPID field

                    filter_inner_priority=15,  # This is a no-tag rule, ignore all other VLAN tag filter fields
                    filter_inner_vid=0x1000,   # Do not filter on the inner VID
                    filter_inner_tpid_de=0,    # Do not filter on inner TPID field

                    filter_ether_type=0,         # Do not filter on EtherType
                    treatment_tags_to_remove=0,  # Remove 0 tags

                    treatment_outer_priority=15,  # Do not add an outer tag
                    treatment_outer_vid=0,        # n/a
                    treatment_outer_tpid_de=0,    # n/a

                    treatment_inner_priority=0,      # Add an inner tag and insert this value as the priority
                    treatment_inner_vid=self._vid,   # use this value as the VID in the inner VLAN tag
                    treatment_inner_tpid_de=4,       # set TPID
                )
            )
            frame = ExtendedVlanTaggingOperationConfigurationDataFrame(
                self._mac_bridge_service_profile_entity_id,  # Entity ID
                attributes=attributes                        # See above
            ).set()
            results = yield omci_cc.send(frame)
            self.check_status_and_state(results, 'set-extended-vlan-tagging-operation-configuration-data-untagged')

            ###############################################################################

        except TimeoutError as e:
            self.log.warn('rx-timeout-download', frame=hexlify(frame))
            self.cleanup_on_error()
            raise

        except Exception as e:
            self.log.exception('omci-setup-2', e=e)
            self.cleanup_on_error()
            raise

        returnValue(None)

    @inlineCallbacks
    def enable_unis(self, unis, force_lock):
        """
        Lock or unlock one or more UNI ports

        :param unis: (list) of UNI objects
        :param force_lock: (boolean) If True, force lock regardless of enabled state
        """
        omci_cc = self._onu_device.omci_cc
        frame = None

        for uni in unis:
            ################################################################################
            #  Lock/Unlock UNI  -  0 to Unlock, 1 to lock
            #
            #  EntityID is referenced by:
            #            - MAC bridge port configuration data for the UNI side
            #  References:
            #            - Nothing
            try:
                state = 1 if force_lock or not uni.enabled else 0
                frame = PptpEthernetUniFrame(uni.entity_id,
                                             attributes=dict(administrative_state=state)).set()
                results = yield omci_cc.send(frame)
                self.check_status_and_state(results, 'set-pptp-ethernet-uni-lock-restore')

            except TimeoutError:
                self.log.warn('rx-timeout-unis', frame=hexlify(frame))
                raise

            except Exception as e:
                self.log.exception('omci-failure', e=e)
                raise

        returnValue(None)

    @inlineCallbacks
    def cleanup_on_error(self):

        omci_cc = self._onu_device.omci_cc

        if self._extended_vlan_me_created:
            try:
                eid = self._mac_bridge_service_profile_entity_id
                frame = ExtendedVlanTaggingOperationConfigurationDataFrame(eid).delete()
                results = yield omci_cc.send(frame)
                status = results.fields['omci_message'].fields['success_code']
                self.log.debug('delete-extended-vlan-me', status=status)

            except Exception as e:
                self.log.exception('extended-vlan-cleanup', e=e)
                # Continue processing

        for gem_port in self._pon.gem_ports.itervalues():
            if gem_port.in_hardware:
                try:
                    yield gem_port.remove_from_hardware(omci_cc)

                except Exception as e:
                    self.log.exception('gem-port-cleanup', e=e)
                    # Continue processing

        for tcont in self._pon.tconts.itervalues():
            if tcont.entity_id != AdtnServiceDownloadTask.free_tcont_alloc_id:
                try:
                    yield tcont.remove_from_hardware(omci_cc)

                except Exception as e:
                    self.log.exception('tcont-cleanup', e=e)
                    # Continue processing

        returnValue('Cleanup Complete')