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