class CigOpenomciOnuAdapter(BrcmOpenomciOnuAdapter): name = 'cig_openomci_onu' supported_device_types = [ DeviceType( id=name, #vendor_ids=[], vendor_ids=['CIGG'], adapter=name, accepts_bulk_flow_update=True) ] def __init__(self, adapter_agent, config): super(CigOpenomciOnuAdapter, self).__init__(adapter_agent, config) # self.adapter_agent = adapter_agent # self.config = config self.descriptor = Adapter( id=self.name, vendor='CIG Tech', version='0.10', config=AdapterConfig(log_level=LogLevel.INFO)) # self.devices_handlers = dict() # Customize OpenOMCI for CIG ONUs self._omci_support_cls = deepcopy(OpenOmciAgentDefaults) # self.broadcom_omci['mib-synchronizer']['state-machine'] = BrcmMibSynchronizer # self.broadcom_omci['mib-synchronizer']['database'] = MibDbVolatileDict # self.broadcom_omci['omci-capabilities']['tasks']['get-capabilities'] = BrcmCapabilitiesTask # self._omci_agent = OpenOMCIAgent(self.adapter_agent.core, # support_classes=self.broadcom_omci) self._omci_agent = OpenOMCIAgent( self.adapter_agent.core, support_classes=self._omci_support_cls) # register for adapter messages # self.adapter_agent.register_for_inter_adapter_messages() def device_types(self): return DeviceTypes(items=self.supported_device_types) def adapter_descriptor(self): return self.descriptor def device_types(self): return DeviceTypes(items=self.supported_device_types) def __download_image_success(self, image_download): log.debug("__download_image_success") def __download_image_fail(self, fail): log.debug("__download_image_fail", failure=fail) # TODO: Add callback to the defer to indicate download status def download_image(self, device, request): log.debug('download_image', device=device, request=request) onu_dev = self._omci_agent.get_device(device.id) d = onu_dev.do_onu_software_download(request) d.addCallbacks(self.__download_image_success, self.__download_image_fail) # return d def get_image_download_status(self, device, request): log.debug('get_image_download_status', device=device, request=request) onu_dev = self._omci_agent.get_device(device.id) return onu_dev.get_image_download_status( request.name) if onu_dev else None def cancel_image_download(self, device, request): log.debug('cancel_image_download', device=device, request=request) onu_dev = self._omci_agent.get_device(device.id) onu_dev.cancel_onu_software_download(request.name) def activate_image_update(self, device, request): log.debug('activate_image_update', device=device, request=request) onu_dev = self._omci_agent.get_device(device.id) d = onu_dev.do_onu_image_activate(request.name) def revert_image_update(self, device, request): log.debug('revert_image_update', device=device, request=request)
def omci_agent(): omci = OpenOMCIAgent(Mock()) omci.get_device = Mock() return omci
class TestOnuDeviceEntry(TestCase): """ Test the ONU Device Entry methods """ def setUp(self): self.adapter_agent = MockAdapterAgent() custom = deepcopy(OpenOmciAgentDefaults) custom['mib-synchronizer']['database'] = MibDbVolatileDict self.agent = OpenOMCIAgent(MockCore, support_classes=custom) self.agent.start() def tearDown(self): if self.agent is not None: self.agent.stop() if self.adapter_agent is not None: self.adapter_agent.tearDown() def setup_mock_olt(self, device_id=DEFAULT_OLT_DEVICE_ID): handler = MockOltHandler(self.adapter_agent, device_id) self.adapter_agent.add_device(handler.device) return handler def setup_mock_onu(self, parent_id=DEFAULT_OLT_DEVICE_ID, device_id=DEFAULT_ONU_DEVICE_ID, pon_id=DEFAULT_PON_ID, onu_id=DEFAULT_ONU_ID, serial_no=DEFAULT_ONU_SN): handler = MockOnuHandler(self.adapter_agent, parent_id, device_id, pon_id, onu_id) handler.serial_number = serial_no onu = MockOnu(serial_no, self.adapter_agent, handler.device_id) \ if serial_no is not None else None handler.onu_mock = onu return handler def setup_one_of_each(self): # Most tests will use at lease one or more OLT and ONU self.olt_handler = self.setup_mock_olt() self.onu_handler = self.setup_mock_onu( parent_id=self.olt_handler.device_id) self.onu_device = self.onu_handler.onu_mock self.adapter_agent.add_child_device(self.olt_handler.device, self.onu_handler.device) def test_add_remove_device(self): self.setup_one_of_each() self.assertEqual(len(self.agent.device_ids()), 0) onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) # No MIB if not started assert_raises(KeyError, onu_device.query_mib) self.agent.remove_device(DEFAULT_ONU_DEVICE_ID) self.assertEqual(len(self.agent.device_ids()), 1) def test_delete_device(self): self.setup_one_of_each() self.assertEqual(len(self.agent.device_ids()), 0) onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) # Can delete if it was not started onu_device.delete() self.assertEqual(len(self.agent.device_ids()), 0) ########################################## # Delete of ONU device okay if it is started onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) # Start it and then delete it onu_device.start() onu_device.delete() self.assertEqual(len(self.agent.device_ids()), 0) @deferred(timeout=5) def test_mib_query_fails_if_dev_not_started(self): self.setup_one_of_each() onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) def not_called(_reason): assert False, 'Should never be called' def check_status(_results): # Device not yet started. Query should fail with KeyError since # ONU is not in database yet assert_raises(KeyError, onu_device.query_mib) # Yield context so that MIB Database callLater runs. This is a waiting # Async task from when the OpenOMCIAgent was started. d = asleep(0.2) d.addCallbacks(check_status, not_called) return d @deferred(timeout=5) def test_mib_query_ok_if_dev_started(self): self.setup_one_of_each() onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) def not_called(_reason): onu_device.stop() assert False, 'Should never be called' def check_status(_results): # Device started. Query will succeed but nothing should be populated # but the most basic items results = onu_device.query_mib() self.assertTrue(isinstance(results, dict)) self.assertEqual(results.get(DEVICE_ID_KEY), DEFAULT_ONU_DEVICE_ID) self.assertIsNotNone(results.get(VERSION_KEY)) self.assertIsNotNone(results.get(CREATED_KEY)) self.assertIsNone( results.get(MODIFIED_KEY)) # Created! but not yet modified self.assertEqual(results.get(MDS_KEY), 0) self.assertIsNone(results.get(LAST_SYNC_KEY)) self.assertIsNone(results.get(CLASS_ID_KEY)) # Stopping still allows a query. Note you just delete a device # to clean up any associated databases onu_device.stop() results = onu_device.query_mib() self.assertTrue(isinstance(results, dict)) # Yield context so that MIB Database callLater runs. This is a waiting # Async task from when the OpenOMCIAgent was started. But also start the # device so that it's queued async state machines can run as well onu_device.start() d = asleep(0.2) d.addCallbacks(check_status, not_called) return d @deferred(timeout=5) def test_delete_scrubs_mib(self): self.setup_one_of_each() onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) def not_called(_reason): onu_device.stop() assert False, 'Should never be called' def check_status(_results): # Device started. Query will succeed but nothing should be populated # but the most basic items results = onu_device.query_mib() self.assertTrue(isinstance(results, dict)) self.assertEqual(results.get(DEVICE_ID_KEY), DEFAULT_ONU_DEVICE_ID) # Delete should wipe out any MIB data. Note that a delete of a started # or stopped ONU device is allowed. In this case we are deleting a # started ONU Device onu_device.delete() assert_raises(Exception, onu_device.query_mib) # TODO: When capabilities are supported, make sure capabilities get cleared as well # Yield context so that MIB Database callLater runs. This is a waiting # Async task from when the OpenOMCIAgent was started. But also start the # device so that it's queued async state machines can run as well onu_device.start() d = asleep(0.2) d.addCallbacks(check_status, not_called) return d