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)
