def _subscribe_to_events(self): from voltha.extensions.omci.onu_device_entry import OnuDeviceEvents, \ OnuDeviceEntry from voltha.extensions.omci.omci_cc import OMCI_CC, OmciCCRxEvents # OMCI MIB Database sync status bus = self._onu_omci_device.event_bus topic = OnuDeviceEntry.event_bus_topic(self._handler.device_id, OnuDeviceEvents.MibDatabaseSyncEvent) self._in_sync_subscription = bus.subscribe(topic, self.in_sync_handler) # OMCI Capabilities (MEs and Message Types bus = self._onu_omci_device.event_bus topic = OnuDeviceEntry.event_bus_topic(self._handler.device_id, OnuDeviceEvents.OmciCapabilitiesEvent) self._capabilities_subscription = bus.subscribe(topic, self.capabilities_handler) # OMCI-CC Connectivity Events (for reachability/heartbeat) bus = self._onu_omci_device.omci_cc.event_bus topic = OMCI_CC.event_bus_topic(self._handler.device_id, OmciCCRxEvents.Connectivity) self._connectivity_subscription = bus.subscribe(topic, self.onu_is_reachable)
def on_enter_starting(self): """ Determine ONU status and start MIB Synchronization tasks """ self._device = self._agent.get_device(self._device_id) self.log.debug('state-transition', new_onu=self.is_new_onu) # Make sure root of external MIB Database exists self._seed_database() # Set up Response and Autonomous notification subscriptions try: for event, sub in self._sub_mapping.iteritems(): if self._subscriptions[event] is None: self._subscriptions[event] = \ self._device.omci_cc.event_bus.subscribe( topic=OMCI_CC.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('subscription-setup', e=e) # Determine if this ONU has ever synchronized if self.is_new_onu: # Start full MIB upload self._deferred = reactor.callLater(0, self.upload_mib) else: # Examine the MIB Data Sync self._deferred = reactor.callLater(0, self.examine_mds)
def on_enter_starting(self): """ Determine ONU status and start Alarm Synchronization tasks """ self._device = self._agent.get_device(self._device_id) self.advertise(AlarmOpenOmciEventType.state_change, self.state) # Make sure root of external Alarm Database exists self._seed_database() # Set up Response and Autonomous notification subscriptions try: for event, sub in self._omci_cc_sub_mapping.iteritems(): if self._omci_cc_subscriptions[event] is None: self._omci_cc_subscriptions[event] = \ self._device.omci_cc.event_bus.subscribe( topic=OMCI_CC.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('omci-cc-subscription-setup', e=e) # Schedule first audit if enabled if self._audit_delay > 0: # Note using the shorter timeout delay here since this is the first # audit after startup self._deferred = reactor.callLater(self._timeout_delay, self.audit_alarm) else: self._deferred = reactor.callLater(0, self.sync_alarm)
def on_enter_starting(self): """ Determine ONU status and start Alarm Synchronization tasks """ self._device = self._agent.get_device(self._device_id) self.advertise(AlarmOpenOmciEventType.state_change, self.state) # Make sure root of external Alarm Database exists self._seed_database() # Set up Response and Autonomous notification subscriptions try: for event, sub in self._omci_cc_sub_mapping.iteritems(): if self._omci_cc_subscriptions[event] is None: self._omci_cc_subscriptions[event] = \ self._device.omci_cc.event_bus.subscribe( topic=OMCI_CC.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('omci-cc-subscription-setup', e=e) except Exception as e: self.log.exception('dev-subscription-setup', e=e) # Determine if this ONU has ever synchronized if self.is_updated_alarm: self._deferred = reactor.callLater(0, self.update_alarm) else: self._deferred = reactor.callLater(0, self.sync_alarm)
def on_enter_starting(self): """ Determine ONU status and start/re-start MIB Synchronization tasks """ self._device = self._agent.get_device(self._device_id) self.advertise(OpenOmciEventType.state_change, self.state) # Make sure root of external MIB Database exists self._seed_database() # Set up Response and Autonomous notification subscriptions try: for event, sub in self._omci_cc_sub_mapping.iteritems(): if self._omci_cc_subscriptions[event] is None: self._omci_cc_subscriptions[event] = \ self._device.omci_cc.event_bus.subscribe( topic=OMCI_CC.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('omci-cc-subscription-setup', e=e) # Set up ONU device subscriptions try: for event, sub in self._onu_dev_sub_mapping.iteritems(): if self._onu_dev_subscriptions[event] is None: self._onu_dev_subscriptions[event] = \ self._device.event_bus.subscribe( topic=OnuDeviceEntry.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('dev-subscription-setup', e=e) # Clear any previous audit results self._on_olt_only_diffs = None self._on_onu_only_diffs = None self._attr_diffs = None self._audited_olt_db = None self._audited_onu_db = None # Determine if this ONU has ever synchronized if self.is_new_onu: # Start full MIB upload self._deferred = reactor.callLater(0, self.upload_mib) else: # Examine the MIB Data Sync self._deferred = reactor.callLater(0, self.examine_mds)
def __init__(self, omci_agent, device_id, adapter_agent, custom_me_map, mib_db, support_classes): """ Class initializer :param omci_agent: (OpenOMCIAgent) Reference to OpenOMCI Agent :param device_id: (str) ONU Device ID :param adapter_agent: (AdapterAgent) Adapter agent for ONU :param custom_me_map: (dict) Additional/updated ME to add to class map :param mib_db: (MibDbApi) MIB Database reference :param support_classes: (dict) State machines and tasks for this ONU """ self.log = structlog.get_logger(device_id=device_id) self._started = False self._omci_agent = omci_agent # OMCI AdapterAgent self._device_id = device_id # ONU Device ID self._runner = TaskRunner(device_id) # OMCI_CC Task runner self._deferred = None self._first_in_sync = False self._support_classes = support_classes try: self._mib_db_in_sync = False mib_synchronizer_info = support_classes.get('mib-synchronizer') self.mib_sync = mib_synchronizer_info['state-machine']( self._omci_agent, device_id, mib_synchronizer_info['tasks'], mib_db) except Exception as e: self.log.exception('mib-sync-create-failed', e=e) raise self._state_machines = [] self._on_start_state_machines = [self.mib_sync ] # Run when 'start()' called self._on_sync_state_machines = [] # Run after first in_sync event self._custom_me_map = custom_me_map self._me_map = omci_entities.entity_id_to_class_map.copy() if custom_me_map is not None: self._me_map.update(custom_me_map) self.event_bus = EventBusClient() # Create OMCI communications channel self._omci_cc = OMCI_CC(adapter_agent, self.device_id, self._me_map)
def __init__(self, omci_agent, device_id, adapter_agent, custom_me_map, mib_synchronizer_info, mib_db): """ Class initializer :param device_id: (str) ONU Device ID :param custom_me_map: (dict) Additional/updated ME to add to class map """ self.log = structlog.get_logger(device_id=device_id) self._started = False self._omci_agent = omci_agent # OMCI AdapterAgent self._device_id = device_id # ONU Device ID self._runner = TaskRunner(device_id) # OMCI_CC Task runner self._deferred = None try: self._mib_db_in_sync = False self.mib_sync = mib_synchronizer_info['state-machine']( self._omci_agent, device_id, mib_synchronizer_info['tasks'], mib_db) except Exception as e: self.log.exception('mib-sync-create-failed', e=e) raise self._state_machines = [self.mib_sync] self._custom_me_map = custom_me_map self._me_map = omci_entities.entity_id_to_class_map.copy() if custom_me_map is not None: self._me_map.update(custom_me_map) self.event_bus = EventBusClient() # Create OMCI communications channel self._omci_cc = OMCI_CC(adapter_agent, self.device_id, self._me_map)
def _subscribe_to_events(self): from voltha.extensions.omci.onu_device_entry import OnuDeviceEvents, \ OnuDeviceEntry, IN_SYNC_KEY from voltha.extensions.omci.omci_cc import OMCI_CC, OmciCCRxEvents, \ CONNECTED_KEY def in_sync_handler(_topic, msg): if self._in_sync_subscription is not None: try: in_sync = msg[IN_SYNC_KEY] if in_sync: # Only call this once as well (after PON enable) bus = self._onu_omci_device.event_bus bus.unsubscribe(self._in_sync_subscription) self._in_sync_subscription = None # Start up device_info load reactor.callLater(0, self._mib_in_sync) except Exception as e: self.log.exception('in-sync', e=e) def onu_is_reachable(_topic, msg): """ Reach-ability change event :param _topic: (str) subscription topic, not used :param msg: (dict) 'connected' key holds True if reachable """ if self._connectivity_subscription is not None: try: connected = msg[CONNECTED_KEY] # TODO: For now, only care about the first. # Later we could use this for a heartbeat, but may want some hysteresis # Cancel any 'reachable' subscriptions if connected: evt_bus = self._onu_omci_device.omci_cc.event_bus evt_bus.unsubscribe(self._connectivity_subscription) self._connectivity_subscription = None self._connected = True device = self._handler.adapter_agent.get_device(self._handler.device_id) device.oper_status = OperStatus.ACTIVE device.connect_status = ConnectStatus.REACHABLE self._handler.adapter_agent.update_device(device) except Exception as e: self.log.exception('onu-reachable', e=e) # OMCI MIB Database sync status bus = self._onu_omci_device.event_bus topic = OnuDeviceEntry.event_bus_topic(self._handler.device_id, OnuDeviceEvents.MibDatabaseSyncEvent) self._in_sync_subscription = bus.subscribe(topic, in_sync_handler) # OMCI-CC Connectivity Events (for reachbility/heartbeat) bus = self._onu_omci_device.omci_cc.event_bus topic = OMCI_CC.event_bus_topic(self._handler.device_id, OmciCCRxEvents.Connectivity) self._connectivity_subscription = bus.subscribe(topic, onu_is_reachable)
def on_enter_starting(self): """ Add the PON/ANI and UNI PM intervals""" self.advertise(OpenOmciEventType.state_change, self.state) self._device = self._agent.get_device(self._device_id) self._cancel_deferred() # Set up OMCI ME Response subscriptions try: for event, sub in self._omci_cc_sub_mapping.iteritems(): if self._omci_cc_subscriptions[event] is None: self._omci_cc_subscriptions[event] = \ self._device.omci_cc.event_bus.subscribe( topic=OMCI_CC.event_bus_topic(self._device_id, event), callback=sub) except Exception as e: self.log.exception('omci-cc-subscription-setup', e=e) try: # Manually start some ANI/PON and UNI PM interval MEs config = self._device.configuration anis = config.ani_g_entities unis = config.uni_g_entities if anis is not None: for entity_id in anis.iterkeys(): self.add_pm_me( FecPerformanceMonitoringHistoryData.class_id, entity_id) self.add_pm_me( XgPonTcPerformanceMonitoringHistoryData.class_id, entity_id) self.add_pm_me( XgPonDownstreamPerformanceMonitoringHistoryData. class_id, entity_id) self.add_pm_me( XgPonUpstreamPerformanceMonitoringHistoryData.class_id, entity_id) if unis is not None: for entity_id in config.uni_g_entities.iterkeys(): self.add_pm_me(EthernetPMMonitoringHistoryData.class_id, entity_id) # Look for existing instances of dynamically created ME's that have PM # associated with them and add them now for class_id in self._me_watch_list.iterkeys(): instances = { k: v for k, v in self._device.query_mib( class_id=class_id).items() if isinstance(k, int) } for entity_id, data in instances.items(): method = self._me_watch_list[class_id]['create-delete'] cid, eid = method(None, class_id, entity_id, add=True, attributes=data[ATTRIBUTES_KEY]) if cid > 0: # BP entity_id -> (PM class_id, PM entity_id) instances = self._me_watch_list[class_id]['instances'] instances[entity_id] = (cid, eid) except Exception as e: self.log.exception('pm-me-setup', class_id=class_id, e=e) # Got to synchronize_time state self._deferred = reactor.callLater(0, self.tick)
def __init__(self, omci_agent, device_id, adapter_agent, custom_me_map, mib_db, alarm_db, support_classes, clock=None): """ Class initializer :param omci_agent: (OpenOMCIAgent) Reference to OpenOMCI Agent :param device_id: (str) ONU Device ID :param adapter_agent: (AdapterAgent) Adapter agent for ONU :param custom_me_map: (dict) Additional/updated ME to add to class map :param mib_db: (MibDbApi) MIB Database reference :param alarm_db: (MibDbApi) Alarm Table/Database reference :param support_classes: (dict) State machines and tasks for this ONU """ self.log = structlog.get_logger(device_id=device_id) self._started = False self._omci_agent = omci_agent # OMCI AdapterAgent self._device_id = device_id # ONU Device ID self._adapter_agent = adapter_agent self._runner = TaskRunner(device_id, clock=clock) # OMCI_CC Task runner self._deferred = None # self._img_download_deferred = None # deferred of image file download from server self._omci_upgrade_deferred = None # deferred of ONU OMCI upgrading procedure self._omci_activate_deferred = None # deferred of ONU OMCI Softwre Image Activate self._img_deferred = None # deferred returned to caller of do_onu_software_download self._first_in_sync = False self._first_capabilities = False self._timestamp = None # self._image_download = None # (voltha_pb2.ImageDownload) self.reactor = clock if clock is not None else reactor # OMCI related databases are on a per-agent basis. State machines and tasks # are per ONU Vendor # self._support_classes = support_classes self._configuration = None try: # MIB Synchronization state machine self._mib_db_in_sync = False mib_synchronizer_info = support_classes.get('mib-synchronizer') advertise = mib_synchronizer_info['advertise-events'] self._mib_sync_sm = mib_synchronizer_info['state-machine']( self._omci_agent, device_id, mib_synchronizer_info['tasks'], mib_db, advertise_events=advertise) # ONU OMCI Capabilities state machine capabilities_info = support_classes.get('omci-capabilities') advertise = capabilities_info['advertise-events'] self._capabilities_sm = capabilities_info['state-machine']( self._omci_agent, device_id, capabilities_info['tasks'], advertise_events=advertise) # ONU Performance Monitoring Intervals state machine interval_info = support_classes.get('performance-intervals') advertise = interval_info['advertise-events'] self._pm_intervals_sm = interval_info['state-machine']( self._omci_agent, device_id, interval_info['tasks'], advertise_events=advertise) # ONU ALARM Synchronization state machine self._alarm_db_in_sync = False alarm_synchronizer_info = support_classes.get('alarm-synchronizer') advertise = alarm_synchronizer_info['advertise-events'] self._alarm_sync_sm = alarm_synchronizer_info['state-machine']( self._omci_agent, device_id, alarm_synchronizer_info['tasks'], alarm_db, advertise_events=advertise) # State machine of downloading image file from server downloader_info = support_classes.get('image_downloader') image_upgrader_info = support_classes.get('image_upgrader') # image_activate_info = support_classes.get('image_activator') advertise = downloader_info['advertise-event'] # self._img_download_sm = downloader_info['state-machine'](self._omci_agent, device_id, # downloader_info['tasks'], # advertise_events=advertise) self._image_agent = ImageAgent( self._omci_agent, device_id, downloader_info['state-machine'], downloader_info['tasks'], image_upgrader_info['state-machine'], image_upgrader_info['tasks'], # image_activate_info['state-machine'], advertise_events=advertise, clock=clock) # self._omci_upgrade_sm = image_upgrader_info['state-machine'](device_id, advertise_events=advertise) except Exception as e: self.log.exception('state-machine-create-failed', e=e) raise # Put state machines in the order you wish to start them self._state_machines = [] self._on_start_state_machines = [ # Run when 'start()' called self._mib_sync_sm, self._capabilities_sm, ] self._on_sync_state_machines = [ # Run after first in_sync event self._alarm_sync_sm, ] self._on_capabilities_state_machines = [ # Run after first capabilities events self._pm_intervals_sm ] self._custom_me_map = custom_me_map self._me_map = omci_entities.entity_id_to_class_map.copy() if custom_me_map is not None: self._me_map.update(custom_me_map) self.event_bus = EventBusClient() # Create OMCI communications channel self._omci_cc = OMCI_CC(adapter_agent, self.device_id, self._me_map, clock=clock)
def __init__(self, omci_agent, device_id, adapter_agent, custom_me_map, mib_db, alarm_db, support_classes): """ Class initializer :param omci_agent: (OpenOMCIAgent) Reference to OpenOMCI Agent :param device_id: (str) ONU Device ID :param adapter_agent: (AdapterAgent) Adapter agent for ONU :param custom_me_map: (dict) Additional/updated ME to add to class map :param mib_db: (MibDbApi) MIB Database reference :param alarm_db: (MibDbApi) Alarm Table/Database reference :param support_classes: (dict) State machines and tasks for this ONU """ self.log = structlog.get_logger(device_id=device_id) self._started = False self._omci_agent = omci_agent # OMCI AdapterAgent self._device_id = device_id # ONU Device ID self._runner = TaskRunner(device_id) # OMCI_CC Task runner self._deferred = None self._first_in_sync = False self._first_capabilities = False # OMCI related databases are on a per-agent basis. State machines and tasks # are per ONU Vendor # self._support_classes = support_classes self._configuration = None try: # MIB Synchronization state machine self._mib_db_in_sync = False mib_synchronizer_info = support_classes.get('mib-synchronizer') advertise = mib_synchronizer_info['advertise-events'] self._mib_sync_sm = mib_synchronizer_info['state-machine']( self._omci_agent, device_id, mib_synchronizer_info['tasks'], mib_db, advertise_events=advertise) # ONU OMCI Capabilities state machine capabilities_info = support_classes.get('omci-capabilities') advertise = capabilities_info['advertise-events'] self._capabilities_sm = capabilities_info['state-machine']( self._omci_agent, device_id, capabilities_info['tasks'], advertise_events=advertise) # ONU Performance Monitoring Intervals state machine interval_info = support_classes.get('performance-intervals') advertise = interval_info['advertise-events'] self._pm_intervals_sm = interval_info['state-machine']( self._omci_agent, device_id, interval_info['tasks'], advertise_events=advertise) # ONU ALARM Synchronization state machine self._alarm_db_in_sync = False alarm_synchronizer_info = support_classes.get('alarm-synchronizer') advertise = alarm_synchronizer_info['advertise-events'] self._alarm_sync_sm = alarm_synchronizer_info['state-machine']( self._omci_agent, device_id, alarm_synchronizer_info['tasks'], alarm_db, advertise_events=advertise) except Exception as e: self.log.exception('state-machine-create-failed', e=e) raise # Put state machines in the order you wish to start them self._state_machines = [] self._on_start_state_machines = [ # Run when 'start()' called self._mib_sync_sm, self._capabilities_sm, self._alarm_sync_sm, ] self._on_sync_state_machines = [ # Run after first in_sync event ] self._on_capabilities_state_machines = [ # Run after first capabilities events self._pm_intervals_sm ] self._custom_me_map = custom_me_map self._me_map = omci_entities.entity_id_to_class_map.copy() if custom_me_map is not None: self._me_map.update(custom_me_map) self.event_bus = EventBusClient() # Create OMCI communications channel self._omci_cc = OMCI_CC(adapter_agent, self.device_id, self._me_map)