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 _subscribe_to_events(self):
self.log.debug('function-entry')
# OMCI MIB Database sync status
bus = self._onu_omci_device.event_bus
topic = OnuDeviceEntry.event_bus_topic(self.device_id,
OnuDeviceEvents.MibDatabaseSyncEvent)
self._in_sync_subscription = bus.subscribe(topic, self.in_sync_handler)
# OMCI Capabilities
bus = self._onu_omci_device.event_bus
topic = OnuDeviceEntry.event_bus_topic(self.device_id,
OnuDeviceEvents.OmciCapabilitiesEvent)
self._capabilities_subscription = bus.subscribe(topic, self.capabilties_handler)
def on_enter_out_of_sync(self):
"""
State machine has just started or the MIB database has transitioned
to an out-of-synchronization state
"""
self.log.debug('state-transition')
self._cancel_deferred()
self._device = self._agent.get_device(self._device_id)
# Subscribe to events of interest
try:
for event, sub in self._sub_mapping.iteritems():
if self._subscriptions[event] is None:
self._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('subscription-setup', e=e)
# Periodically check/poll for in-sync in case subscription was missed or
# already in sync
self._deferred = reactor.callLater(0, self.check_in_sync)
def _subscribe_to_events(self):
from voltha.extensions.omci.onu_device_entry import OnuDeviceEvents, \
OnuDeviceEntry
# OMCI MIB Database sync status
bus = self.openomci.onu_omci_device.event_bus
topic = OnuDeviceEntry.event_bus_topic(self.device_id,
OnuDeviceEvents.MibDatabaseSyncEvent)
self._in_sync_subscription = bus.subscribe(topic, self.in_sync_handler)
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 _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)