def __init__(self, adapter, device_id):
kwargs = dict()
super(AdtranOnuHandler, self).__init__(**kwargs)
self.adapter = adapter
self.adapter_agent = adapter.adapter_agent
self.device_id = device_id
self.log = structlog.get_logger(device_id=device_id)
self.logical_device_id = None
self.proxy_address = None
self._enabled = False
self.pm_metrics = None
self.alarms = None
self._mgmt_gemport_aes = False
self._upstream_channel_speed = 0
self._openomci = OMCI(self, adapter.omci_agent)
self._in_sync_subscription = None
self._onu_port_number = 0
self._pon_port_number = 1
self._port_number_pool = IndexPool(_MAXIMUM_PORT, 0)
self._unis = dict() # Port # -> UniPort
self._pon = PonPort.create(self, self._pon_port_number)
self._heartbeat = HeartBeat.create(self, device_id)
self._deferred = None
# Flow entries
self._flows = dict()
# OMCI resources
# TODO: Some of these could be dynamically chosen
self.vlan_tcis_1 = 0x900
self.mac_bridge_service_profile_entity_id = self.vlan_tcis_1
self.gal_enet_profile_entity_id = 0 # Was 0x100, but ONU seems to overwrite and use zero
def process_southbound_ports(self, device, results):
"""
Process the results from the 'enumerate_southbound_ports' method.
:param device: A voltha.Device object, with possible device-type
specific extensions.
:param results: Results from the 'enumerate_southbound_ports' method that
you implemented. The type and contents are up to you to
:return: (Deferred or None).
"""
from pon_port import PonPort
for pon in results:
# Number PON Ports after the NNI ports
pon_id = pon['pon-id']
log.info('Processing pon port {}'.format(pon_id))
assert pon_id not in self.southbound_ports
admin_state = AdminState.ENABLED if pon.get(
'enabled', PonPort.DEFAULT_ENABLED) else AdminState.DISABLED
self.southbound_ports[pon_id] = PonPort(
pon_id,
self._pon_id_to_port_number(pon_id),
self,
admin_state=admin_state)
# TODO: For now, limit number of PON ports to make debugging easier
if len(self.southbound_ports) >= self.max_ports:
break
self.num_southbound_ports = len(self.southbound_ports)
def process_southbound_ports(self, device, results):
"""
Process the results from the 'enumerate_southbound_ports' method.
:param device: A voltha.Device object, with possible device-type
specific extensions.
:param results: Results from the 'enumerate_southbound_ports' method that
you implemented. The type and contents are up to you to
:return: (Deferred or None).
"""
from pon_port import PonPort
for pon in results:
# Number PON Ports after the NNI ports
pon_id = pon['pon-id']
log.info('processing-pon-port', pon_id=pon_id)
assert pon_id not in self.southbound_ports,\
'Pon ID not found in southbound ports'
self.southbound_ports[pon_id] = PonPort(pon_id,
self._pon_id_to_port_number(pon_id),
self)
if self.autoactivate:
self.southbound_ports[pon_id].downstream_fec_enable = True
self.southbound_ports[pon_id].upstream_fec_enable = True
self.num_southbound_ports = len(self.southbound_ports)
def __init__(self, adapter, device_id):
kwargs = dict()
super(AdtranOnuHandler, self).__init__(**kwargs)
self.adapter = adapter
self.adapter_agent = adapter.adapter_agent
self.device_id = device_id
self.log = structlog.get_logger(device_id=device_id)
self.logical_device_id = None
self.proxy_address = None
self._enabled = False
self.pm_metrics = None
self.alarms = None
self._openomci = OMCI(self, adapter.omci_agent)
self._in_sync_subscription = None
self._pon_port_number = 1
self._unis = dict() # Port # -> UniPort
self._pon = PonPort.create(self, self._pon_port_number)
self._heartbeat = HeartBeat.create(self, device_id)
self._deferred = None
# Flow entries
self._flows = dict()
# OMCI resources # TODO: Some of these could be dynamically chosen
self.vlan_tcis_1 = 0x900
self.mac_bridge_service_profile_entity_id = self.vlan_tcis_1
self.gal_enet_profile_entity_id = 0
# Technology profile related values
self.incoming_messages = DeferredQueue()
self.event_messages = DeferredQueue()
self._tp_service_specific_task = dict()
self._tech_profile_download_done = dict()
# Initialize KV store client
self.args = registry('main').get_args()
if self.args.backend == 'etcd':
host, port = self.args.etcd.split(':', 1)
self.kv_client = EtcdStore(host, port,
TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
elif self.args.backend == 'consul':
host, port = self.args.consul.split(':', 1)
self.kv_client = ConsulStore(host, port,
TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
else:
self.log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
# Handle received ONU event messages
reactor.callLater(0, self.handle_onu_events)
def activate(self, device):
self.log.info('activating')
# first we verify that we got parent reference and proxy info
assert device.parent_id, 'Invalid Parent ID'
assert device.proxy_address.device_id, 'Invalid Device ID'
if device.vlan:
# vlan non-zero if created via legacy method (not xPON). Also
# Set a random serial number since not xPON based
self._olt_created = True
# register for proxied messages right away
self.proxy_address = device.proxy_address
self.adapter_agent.register_for_proxied_messages(device.proxy_address)
# initialize device info
device.root = True
device.vendor = 'Adtran Inc.'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.reason = ''
# TODO: Support more versions as needed
images = Image(version='NOT AVAILABLE')
device.images.image.extend([images])
device.connect_status = ConnectStatus.UNKNOWN
############################################################################
# Setup PM configuration for this device
self.pm_metrics = OnuPmMetrics(self,
device,
grouped=True,
freq_override=False)
pm_config = self.pm_metrics.make_proto()
self.log.info("initial-pm-config", pm_config=pm_config)
self.adapter_agent.update_device_pm_config(pm_config, init=True)
############################################################################
# Setup Alarm handler
self.alarms = AdapterAlarms(self.adapter, device.id)
# reference of uni_port is required when re-enabling the device if
# it was disabled previously
# Need to query ONU for number of supported uni ports
# For now, temporarily set number of ports to 1 - port #2
# Register physical ports. Should have at least one of each
pon_port = PonPort.create(self, self._next_port_number)
self._pons[pon_port.port_number] = pon_port
self.adapter_agent.add_port(device.id, pon_port.get_port())
parent_device = self.adapter_agent.get_device(device.parent_id)
self.logical_device_id = parent_device.parent_id
assert self.logical_device_id, 'Invalid logical device ID'
if self._olt_created:
# vlan non-zero if created via legacy method (not xPON). Also
# Set a random serial number since not xPON based
uni_port = UniPort.create(self, self._next_port_number,
'deprecated', device.vlan)
self._unis[uni_port.port_number] = uni_port
self.adapter_agent.add_port(device.id, uni_port.get_port())
device.serial_number = uuid4().hex
uni_port.add_logical_port(device.vlan, control_vlan=device.vlan)
# Start things up for this ONU Handler.
self.enabled = True
# Start collecting stats from the device after a brief pause
reactor.callLater(30, self.start_kpi_collection, device.id)
self.adapter_agent.update_device(device)
def activate(self, device):
self.log.info('activating')
try:
# first we verify that we got parent reference and proxy info
assert device.parent_id, 'Invalid Parent ID'
assert device.proxy_address.device_id, 'Invalid Device ID'
if device.vlan:
# vlan non-zero if created via legacy method (not xPON).
self._olt_created = True
# register for proxied messages right away
self.proxy_address = device.proxy_address
self.adapter_agent.register_for_proxied_messages(device.proxy_address)
# initialize device info
device.root = True
device.vendor = 'Adtran Inc.'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.reason = ''
device.connect_status = ConnectStatus.UNKNOWN
# Register physical ports. Should have at least one of each
self._pon = PonPort.create(self, self._next_port_number)
self.adapter_agent.add_port(device.id, self._pon.get_port())
if self._olt_created:
# vlan non-zero if created via legacy method (not xPON). Also
# Set a random serial number since not xPON based
uni_port = UniPort.create(self, self._next_port_number, device.vlan,
'deprecated', device.vlan, None)
self._unis[uni_port.port_number] = uni_port
self.adapter_agent.add_port(device.id, uni_port.get_port())
device.serial_number = uuid4().hex
uni_port.add_logical_port(device.vlan, subscriber_vlan=device.vlan)
# Start things up for this ONU Handler.
self.enabled = True
############################################################################
# Setup PM configuration for this device
# Pass in ONU specific options
kwargs = {
'heartbeat': self.heartbeat,
'omci-cc': self.openomci.omci_cc
}
self.pm_metrics = OnuPmMetrics(self.adapter_agent, self.device_id,
grouped=True, freq_override=False,
**kwargs)
pm_config = self.pm_metrics.make_proto()
self.openomci.set_pm_config(self.pm_metrics.omci_pm.openomci_interval_pm)
self.log.info("initial-pm-config", pm_config=pm_config)
self.adapter_agent.update_device_pm_config(pm_config, init=True)
# reference of uni_port is required when re-enabling the device if
# it was disabled previously
# Need to query ONU for number of supported uni ports
# For now, temporarily set number of ports to 1 - port #2
parent_device = self.adapter_agent.get_device(device.parent_id)
self.logical_device_id = parent_device.parent_id
assert self.logical_device_id, 'Invalid logical device ID'
self.adapter_agent.update_device(device)
############################################################################
# Setup Alarm handler
self.alarms = AdapterAlarms(self.adapter_agent, device.id, self.logical_device_id)
############################################################################
# Start collecting stats from the device after a brief pause
reactor.callLater(30, self.pm_metrics.start_collector)
except Exception as e:
self.log.exception('activate-failure', e=e)
device.reason = 'Failed to activate: {}'.format(e.message)
device.connect_status = ConnectStatus.UNREACHABLE
device.oper_status = OperStatus.FAILED
self.adapter_agent.update_device(device)
def activate(self, device):
self.log.info('activating')
# first we verify that we got parent reference and proxy info
assert device.parent_id, 'Invalid Parent ID'
assert device.proxy_address.device_id, 'Invalid Device ID'
if device.vlan:
# vlan non-zero if created via legacy method (not xPON). Also
# Set a random serial number since not xPON based
self._olt_created = True
# register for proxied messages right away
self.proxy_address = device.proxy_address
self.adapter_agent.register_for_proxied_messages(device.proxy_address)
# initialize device info
device.root = True
device.vendor = 'Adtran Inc.'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.reason = ''
# TODO: Support more versions as needed
images = Image(version='NOT AVAILABLE')
device.images.image.extend([images])
device.connect_status = ConnectStatus.UNKNOWN
############################################################################
# Setup PM configuration for this device
self.pm_metrics = OnuPmMetrics(self, device, grouped=True, freq_override=False)
pm_config = self.pm_metrics.make_proto()
self.log.info("initial-pm-config", pm_config=pm_config)
self.adapter_agent.update_device_pm_config(pm_config, init=True)
############################################################################
# Setup Alarm handler
self.alarms = AdapterAlarms(self.adapter, device.id)
# reference of uni_port is required when re-enabling the device if
# it was disabled previously
# Need to query ONU for number of supported uni ports
# For now, temporarily set number of ports to 1 - port #2
# Register physical ports. Should have at least one of each
pon_port = PonPort.create(self, self._next_port_number)
self._pons[pon_port.port_number] = pon_port
self.adapter_agent.add_port(device.id, pon_port.get_port())
parent_device = self.adapter_agent.get_device(device.parent_id)
self.logical_device_id = parent_device.parent_id
assert self.logical_device_id, 'Invalid logical device ID'
if self._olt_created:
# vlan non-zero if created via legacy method (not xPON). Also
# Set a random serial number since not xPON based
uni_port = UniPort.create(self, self._next_port_number,
'deprecated', device.vlan)
self._unis[uni_port.port_number] = uni_port
self.adapter_agent.add_port(device.id, uni_port.get_port())
device.serial_number = uuid4().hex
uni_port.add_logical_port(device.vlan, control_vlan=device.vlan)
# Start things up for this ONU Handler.
self.enabled = True
# Start collecting stats from the device after a brief pause
reactor.callLater(30, self.start_kpi_collection, device.id)
self.adapter_agent.update_device(device)
