adapters/adtran_onu/omci/adtn_mib_reconcile_task.py - voltha-adtran-adapter - Gitiles

 #
 # 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.defer import returnValue
 from pyvoltha.adapters.extensions.omci.omci_defs import *
 from voltha.extensions.omci.omci_entities import Ieee8021pMapperServiceProfile
 from voltha.extensions.omci.tasks.mib_reconcile_task import MibReconcileTask
 from voltha.extensions.omci.database.mib_db_api import ATTRIBUTES_KEY
 from twisted.internet.defer import  inlineCallbacks
 from voltha.extensions.omci.omci_defs import ReasonCodes, EntityOperations
 from voltha.extensions.omci.omci_me import MEFrame

 OP = EntityOperations
 RC = ReasonCodes
 AA = AttributeAccess


 class AdtnMibReconcileTask(MibReconcileTask):
     """
     Adtran ONU OpenOMCI MIB Reconcile Task

     For some crazy reason, the ADTRAN ONU does not report the IEEE802.1p Mapper ME
     in the ONU upload even though it does exists.  This results in an 'instance
     exists' error when trying to create it on the ONU
     """
     name = "Adtran MIB Reconcile Task"

     def __init__(self, omci_agent, device_id, diffs):
         super(AdtnMibReconcileTask, self).__init__(omci_agent, device_id, diffs)

         self.name = AdtnMibReconcileTask.name
         self._me_130_okay = False   # Set true once bug is fixed (auto detect)
         self._omci_managed = False  # Set once ONU Data tracking of MIB-Data-Sync supported

     @inlineCallbacks
     def fix_olt_only(self, olt, onu_db, olt_db):
         """
         Fix ME's that were only found on the OLT. For OLT only MEs there are
         the following things that will be checked.

             o ME's that do not have an OpenOMCI class decoder. These are stored
               as binary blobs in the MIB database. Since the OLT will never
               create these (all are learned from ONU), it is assumed the ONU
               has removed them for some purpose. So delete them from the OLT
               database.

             o For ME's that are created by the ONU (no create/delete access), the
               MEs 'may' not be on the ONU because of a reboot or an OLT created
               ME was deleted and the ONU gratuitously removes it.  So delete them
               from the OLT database.

             o For ME's that are created by the OLT/OpenOMCI, delete them from the
               ONU

         :param olt: (list(int,int)) List of tuples where (class_id, inst_id)
         :param onu_db: (dict) ONU Database snapshot at time of audit
         :param olt_db: (dict) OLT Database snapshot at time of audit

         :return: (int, int) successes, failures
         """
         # Has IEEE 802.1p reporting Bug fixed?

         if self._me_130_okay or Ieee8021pMapperServiceProfile.class_id in onu_db:
             self._me_130_okay = True
             returnValue(super(AdtnMibReconcileTask, self).fix_olt_only(olt, onu_db, olt_db))

         ############################
         # Base class handles all but ME 130
         local_mes = {Ieee8021pMapperServiceProfile.class_id}
         not_manual = [(cid, eid) for cid, eid in olt if cid not in local_mes]

         results = yield super(AdtnMibReconcileTask, self).fix_olt_only(not_manual,
                                                                        onu_db,
                                                                        olt_db)
         successes = results[0]
         failures = results[1]

         # If IEEE 802.1p mapper needs to be checked, do it manually as the IBONT 602
         # manipulates it during MEF EVC/EVC-Map creation
         for cid in local_mes:
             class_entry = olt_db.get(cid, None)

             if class_entry is not None:
                 entries = {k: v for k, v in class_entry.items() if isinstance(k, int)}
                 for eid, instance in entries.items():
                     try:
                         self.strobe_watchdog()
                         results = yield self.manual_verification(cid, eid, instance[ATTRIBUTES_KEY])
                         successes += results[0]
                         failures += results[1]

                     except Exception as _e:
                         failures += 1

         returnValue((successes, failures))

     @inlineCallbacks
     def update_mib_data_sync(self):
         """ IBONT version does not support MDS"""
         if self._omci_managed:
             results = yield super(AdtnMibReconcileTask, self).update_mib_data_sync()
             returnValue(results)

         returnValue((1, 0))

     @inlineCallbacks
     def manual_verification(self, cid, eid, attributes):
         # Trim off read-only attributes from ones passed in

         me_map = self._device.me_map
         ro_set = {AA.R}
         ro_attrs = {attr.field.name for attr in me_map[cid].attributes
                     if attr.access == ro_set}
         attributes = {k: v for k, v in attributes.items() if k not in ro_attrs}
         attributes_to_fix = dict()

         try:
             while len(attributes):
                 frame = MEFrame(me_map[cid], eid, attributes).get()
                 self.strobe_watchdog()
                 results = yield self._device.omci_cc.send(frame)
                 omci_message = results.fields['omci_message'].fields
                 status = omci_message['success_code']

                 if status == RC.UnknownEntity.value:
                     self.strobe_watchdog()
                     results = yield self.create_instance(me_map[cid], eid, attributes)
                     returnValue((results[0], results[1]))

                 if status != RC.Success.value:
                     self.log.error('manual-check-get-failed', cid=cid, eid=eid,
                                    attributes=attributes, status=status)
                     returnValue((1, 0))

                 onu_attr = {k: v for k, v in omci_message['data'].items()}
                 attributes_to_fix.update({k: v for k, v in onu_attr.items()
                                          if k in attributes and v != attributes[k]})
                 attributes = {k: v for k, v in attributes if k not in onu_attr.keys()}

             if len(attributes_to_fix) > 0:
                 try:
                     frame = MEFrame(me_map[cid], eid, attributes_to_fix).set()
                     self.strobe_watchdog()
                     yield self._device.omci_cc.send(frame)
                     returnValue((1, 0))

                 except Exception as _e:
                     returnValue((0, 1))

         except Exception as e:
             self.log.exception('manual-check-failed', e=e, cid=cid, eid=eid)
             raise

     @inlineCallbacks
     def create_instance(self, cid, eid, attributes):
         try:
             me_map = self._device.me_map
             frame = MEFrame(me_map[cid], eid, attributes).create()

             self.strobe_watchdog()
             results = yield self._device.omci_cc.send(frame)
             status = results.fields['omci_message'].fields['success_code']
             if status == RC.Success.value or status == RC.InstanceExists.value:
                 returnValue((1, 0))

             self.log.error('manual-check-create-failed', cid=cid, eid=eid,
                            attributes=attributes, status=status)
             returnValue((0, 1))

         except Exception as e:
             self.log.exception('manual-check-failed', e=e, cid=cid, eid=eid)
             raise
	#
	# 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.defer import returnValue
	from pyvoltha.adapters.extensions.omci.omci_defs import *
	from voltha.extensions.omci.omci_entities import Ieee8021pMapperServiceProfile
	from voltha.extensions.omci.tasks.mib_reconcile_task import MibReconcileTask
	from voltha.extensions.omci.database.mib_db_api import ATTRIBUTES_KEY
	from twisted.internet.defer import inlineCallbacks
	from voltha.extensions.omci.omci_defs import ReasonCodes, EntityOperations
	from voltha.extensions.omci.omci_me import MEFrame

	OP = EntityOperations
	RC = ReasonCodes
	AA = AttributeAccess


	class AdtnMibReconcileTask(MibReconcileTask):
	"""
	Adtran ONU OpenOMCI MIB Reconcile Task

	For some crazy reason, the ADTRAN ONU does not report the IEEE802.1p Mapper ME
	in the ONU upload even though it does exists. This results in an 'instance
	exists' error when trying to create it on the ONU
	"""
	name = "Adtran MIB Reconcile Task"

	def __init__(self, omci_agent, device_id, diffs):
	super(AdtnMibReconcileTask, self).__init__(omci_agent, device_id, diffs)

	self.name = AdtnMibReconcileTask.name
	self._me_130_okay = False # Set true once bug is fixed (auto detect)
	self._omci_managed = False # Set once ONU Data tracking of MIB-Data-Sync supported

	@inlineCallbacks
	def fix_olt_only(self, olt, onu_db, olt_db):
	"""
	Fix ME's that were only found on the OLT. For OLT only MEs there are
	the following things that will be checked.

	o ME's that do not have an OpenOMCI class decoder. These are stored
	as binary blobs in the MIB database. Since the OLT will never
	create these (all are learned from ONU), it is assumed the ONU
	has removed them for some purpose. So delete them from the OLT
	database.

	o For ME's that are created by the ONU (no create/delete access), the
	MEs 'may' not be on the ONU because of a reboot or an OLT created
	ME was deleted and the ONU gratuitously removes it. So delete them
	from the OLT database.

	o For ME's that are created by the OLT/OpenOMCI, delete them from the
	ONU

	:param olt: (list(int,int)) List of tuples where (class_id, inst_id)
	:param onu_db: (dict) ONU Database snapshot at time of audit
	:param olt_db: (dict) OLT Database snapshot at time of audit

	:return: (int, int) successes, failures
	"""
	# Has IEEE 802.1p reporting Bug fixed?

	if self._me_130_okay or Ieee8021pMapperServiceProfile.class_id in onu_db:
	self._me_130_okay = True
	returnValue(super(AdtnMibReconcileTask, self).fix_olt_only(olt, onu_db, olt_db))

	############################
	# Base class handles all but ME 130
	local_mes = {Ieee8021pMapperServiceProfile.class_id}
	not_manual = [(cid, eid) for cid, eid in olt if cid not in local_mes]

	results = yield super(AdtnMibReconcileTask, self).fix_olt_only(not_manual,
	onu_db,
	olt_db)
	successes = results[0]
	failures = results[1]

	# If IEEE 802.1p mapper needs to be checked, do it manually as the IBONT 602
	# manipulates it during MEF EVC/EVC-Map creation
	for cid in local_mes:
	class_entry = olt_db.get(cid, None)

	if class_entry is not None:
	entries = {k: v for k, v in class_entry.items() if isinstance(k, int)}
	for eid, instance in entries.items():
	try:
	self.strobe_watchdog()
	results = yield self.manual_verification(cid, eid, instance[ATTRIBUTES_KEY])
	successes += results[0]
	failures += results[1]

	except Exception as _e:
	failures += 1

	returnValue((successes, failures))

	@inlineCallbacks
	def update_mib_data_sync(self):
	""" IBONT version does not support MDS"""
	if self._omci_managed:
	results = yield super(AdtnMibReconcileTask, self).update_mib_data_sync()
	returnValue(results)

	returnValue((1, 0))

	@inlineCallbacks
	def manual_verification(self, cid, eid, attributes):
	# Trim off read-only attributes from ones passed in

	me_map = self._device.me_map
	ro_set = {AA.R}
	ro_attrs = {attr.field.name for attr in me_map[cid].attributes
	if attr.access == ro_set}
	attributes = {k: v for k, v in attributes.items() if k not in ro_attrs}
	attributes_to_fix = dict()

	try:
	while len(attributes):
	frame = MEFrame(me_map[cid], eid, attributes).get()
	self.strobe_watchdog()
	results = yield self._device.omci_cc.send(frame)
	omci_message = results.fields['omci_message'].fields
	status = omci_message['success_code']

	if status == RC.UnknownEntity.value:
	self.strobe_watchdog()
	results = yield self.create_instance(me_map[cid], eid, attributes)
	returnValue((results[0], results[1]))

	if status != RC.Success.value:
	self.log.error('manual-check-get-failed', cid=cid, eid=eid,
	attributes=attributes, status=status)
	returnValue((1, 0))

	onu_attr = {k: v for k, v in omci_message['data'].items()}
	attributes_to_fix.update({k: v for k, v in onu_attr.items()
	if k in attributes and v != attributes[k]})
	attributes = {k: v for k, v in attributes if k not in onu_attr.keys()}

	if len(attributes_to_fix) > 0:
	try:
	frame = MEFrame(me_map[cid], eid, attributes_to_fix).set()
	self.strobe_watchdog()
	yield self._device.omci_cc.send(frame)
	returnValue((1, 0))

	except Exception as _e:
	returnValue((0, 1))

	except Exception as e:
	self.log.exception('manual-check-failed', e=e, cid=cid, eid=eid)
	raise

	@inlineCallbacks
	def create_instance(self, cid, eid, attributes):
	try:
	me_map = self._device.me_map
	frame = MEFrame(me_map[cid], eid, attributes).create()

	self.strobe_watchdog()
	results = yield self._device.omci_cc.send(frame)
	status = results.fields['omci_message'].fields['success_code']
	if status == RC.Success.value or status == RC.InstanceExists.value:
	returnValue((1, 0))

	self.log.error('manual-check-create-failed', cid=cid, eid=eid,
	attributes=attributes, status=status)
	returnValue((0, 1))

	except Exception as e:
	self.log.exception('manual-check-failed', e=e, cid=cid, eid=eid)
	raise