def software_images(self):
"""
Get a list of software image information for the ONU. The information is provided
so that it may be directly added to the protobuf Device information software list.
"""
sw = self._get_capability('_software', SoftwareImage.class_id)
images = list()
if sw is not None:
for inst, inst_data in sw.items():
if isinstance(inst, int):
is_active = inst_data[ATTRIBUTES_KEY].get('is_active', False)
images.append(Image(name='running-revision' if is_active else 'candidate-revision',
version=str(inst_data[ATTRIBUTES_KEY].get('version',
'Not Available').rstrip('\0')),
is_active=is_active,
is_committed=inst_data[ATTRIBUTES_KEY].get('is_committed',
False),
is_valid=inst_data[ATTRIBUTES_KEY].get('is_valid',
False),
install_datetime='Not Available',
hash=str(inst_data[ATTRIBUTES_KEY].get('image_hash',
'Not Available').rstrip('\0'))))
return images if len(images) else None
def update_device_info_from_pkt(self, pkt):
self.device.root = True
self.device.vendor = 'Celestica Inc.'
self.device.model = 'Ruby'
self.device.hardware_version = \
'{}.{}'.format(hex(pkt.major_hardware_version),
pkt.minor_hardware_version)
self.device.firmware_version = '{}.{}.{}'.format(
pkt.major_firmware_version, pkt.minor_firmware_version,
pkt.build_firmware_version)
# There could be multiple software version on the device,
# active, standby etc. Choose the active or running software
# below. See simulated_olt for example implementation
self.device.images.image.extend([Image(version="0.0.1")])
self.device.serial_number = self.device.mac_address
self.device.oper_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(self.device)
for i in CHANNELS:
self.adapter_agent.add_port(
self.device.id,
Port(port_no=i,
label='PON port',
type=Port.PON_OLT,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE))
def get_software_images():
leafs = ['running-revision', 'candidate-revision', 'startup-revision']
image_names = list(set([results.get(img, 'unknown') for img in leafs]))
images = []
for name in image_names:
# TODO: Look into how to find out hash, is_valid, and install date/time
image = Image(name=name, version=name,
is_active=(name == results.get('running-revision', 'xxx')),
is_committed=(name == results.get('startup-revision', 'xxx')))
images.append(image)
return images
def _mib_in_sync(self):
if self._handler.is_mock:
return # Done, Mock has no bridge support
if not self._dev_info_loaded:
# Here if in sync. But verify first
omci = self._onu_omci_device
in_sync = omci.mib_db_in_sync
self.log.info('mib-in-sync', in_sync=in_sync, already_loaded=self._dev_info_loaded)
device = self._handler.adapter_agent.get_device(self._handler.device_id)
device.oper_status = OperStatus.ACTIVE
device.connect_status = ConnectStatus.REACHABLE
device.reason = 'MIB Synchronization complete'
self._handler.adapter_agent.update_device(device)
# In Sync, we can register logical ports now. Ideally this could occur on
# the first time we received a successful (no timeout) OMCI Rx response.
try:
for uni in self._handler.uni_ports:
uni.add_logical_port(None, None)
#BKP
device = self._handler.adapter_agent.get_device(self._handler.device_id)
vendor = omci.query_mib_single_attribute(OntG.class_id, 0, 'vendor_id') or 'ADTN'
assert vendor == 'ADTN', \
"Invalid Device/Wrong device adapter assigned: '{}'".format(vendor)
# TODO: Get serial number and validate!
num_ports = omci.query_mib_single_attribute(CircuitPack.class_id,
257, 'number_of_ports') or 1
assert num_ports == 1, 'Invalid number of ports: {}'.format(num_ports)
host_info = omci.query_mib(IpHostConfigData.class_id)
mgmt_mac_address = next((host_info[inst].get('attributes').get('mac_address')
for inst in host_info
if isinstance(inst, int)), 'unknown')
device.mac_address = str(mgmt_mac_address)
ont2_attributes = omci.query_mib(Ont2G.class_id, 0, ['equipment_id',
'omcc_version',
'vendor_product_code'])
equipment_id = ont2_attributes.get('equipment_id') or " unknown unknown "
eqptId_bootVersion = str(equipment_id).rstrip('\0')
eqptId = eqptId_bootVersion[0:10] # ie) BVMDZ10DRA
bootVersion = eqptId_bootVersion[12:20] # ie) CML.D55~
omcc_version = int(ont2_attributes.get('omcc_version', 0))
vendorProductCode = str(ont2_attributes.get('vendor_product_code', 'unknown')).rstrip('\0')
images = [Image(name='boot-code',
version=bootVersion.rstrip('\0'),
is_active=False,
is_committed=True,
is_valid=True,
install_datetime='Not Available',
hash='Not Available')]
model = omci.query_mib_single_attribute(OntG.class_id, 0, 'version') or 'unknown'
device.model = str(model).rstrip('\0')
sw_info = {k: v.get('attributes') for k, v in omci.query_mib(SoftwareImage.class_id).items()
if isinstance(k, int)}
for info in sw_info.itervalues():
is_active = info.get('is_active', False)
if is_active:
device.firmware_version = str(info.get('version', 'Not Available').rstrip('\0'))
images.append(Image(name='running-revision' if is_active else 'candidate-revision',
version=str(info.get('version', 'Not Available').rstrip('\0')),
is_active=is_active,
is_committed=info.get('is_committed', False),
is_valid=info.get('is_valid', False),
install_datetime='Not Available',
hash=str(info.get('image_hash', 'Not Available').rstrip('\0'))))
device.images.image.extend(images)
# Save our device information
self._handler.adapter_agent.update_device(device)
self._dev_info_loaded = True
self._bridge_initialized = False
except Exception as e:
self.log.exception('device-info-load', e=e)
self._deferred = reactor.callLater(_STARTUP_RETRY_WAIT, self._mib_in_sync())
self._deferred = reactor.callLater(0, self.resync_omci_settings)
def _simulate_device_activation(self, device):
# first we pretend that we were able to contact the device and obtain
# additional information about it
device.root = True
device.vendor = 'simulated'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
image1 = Image(name="olt_candidate1",
version="1.0",
hash="",
install_datetime=datetime.datetime.utcnow().isoformat(),
is_active=True,
is_committed=True,
is_valid=True)
image2 = Image(name="olt_candidate2",
version="1.0",
hash="",
install_datetime=datetime.datetime.utcnow().isoformat(),
is_active=False,
is_committed=False,
is_valid=True)
device.images.image.extend([image1, image2])
self.adapter_agent.update_device(device)
# Now set the initial PM configuration for this device
self.pm_metrics = AdapterPmMetrics(device)
pm_config = self.pm_metrics.make_proto()
log.info("initial-pm-config", pm_config=pm_config)
self.adapter_agent.update_device_pm_config(pm_config, init=True)
# then shortly after we create some ports for the device
yield asleep(0.05)
nni_port = Port(port_no=2,
label='NNI facing Ethernet port',
type=Port.ETHERNET_NNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
self.adapter_agent.add_port(device.id, nni_port)
self.adapter_agent.add_port(
device.id,
Port(port_no=1,
label='PON port',
type=Port.PON_OLT,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE))
# then shortly after we create the logical device with one port
# that will correspond to the NNI port
yield asleep(0.05)
logical_device_id = uuid4().hex[:12]
ld = LogicalDevice(
# not setting id and datapth_id will let the adapter agent pick id
desc=ofp_desc(mfr_desc='cord porject',
hw_desc='simualted pon',
sw_desc='simualted pon',
serial_num=uuid4().hex,
dp_desc='n/a'),
switch_features=ofp_switch_features(
n_buffers=256, # TODO fake for now
n_tables=2, # TODO ditto
capabilities=( # TODO and ditto
OFPC_FLOW_STATS
| OFPC_TABLE_STATS
| OFPC_PORT_STATS
| OFPC_GROUP_STATS)),
root_device_id=device.id)
ld_initialized = self.adapter_agent.create_logical_device(ld)
cap = OFPPF_1GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(
ld_initialized.id,
LogicalPort(id='nni',
ofp_port=ofp_port(port_no=129,
hw_addr=mac_str_to_tuple(
'00:00:00:00:00:%02x' % 129),
name='nni',
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_1GB_FD,
max_speed=OFPPF_1GB_FD),
device_id=device.id,
device_port_no=nni_port.port_no,
root_port=True))
# and finally update to active
device = self.adapter_agent.get_device(device.id)
device.parent_id = ld_initialized.id
device.oper_status = OperStatus.ACTIVE
self.adapter_agent.update_device(device)
reactor.callLater(0.1, self._simulate_detection_of_onus, device.id)
self.start_kpi_collection(device.id)
self.start_alarm_simulation(device.id)
def _process_ping_frame_response(self, device, frame):
vendor = [0xD7, 0x0011]
ponMode = [0xB7, 0x0105]
hw_version = [0xD7, 0x0013]
manufacturer = [0xD7, 0x0006]
branch_leaf_pairs = [vendor, ponMode, hw_version, manufacturer]
for pair in branch_leaf_pairs:
temp_pair = pair
(rc, value) = (get_value_from_msg(log, frame, pair[0], pair[1]))
temp_pair.append(rc)
temp_pair.append(value)
if rc:
overall_rc = True
else:
log.info('Failed to get valid response for Branch 0x{:X} Leaf 0x{:0>4X} '.format(temp_pair[0], temp_pair[1]))
ack = True
if vendor[rc]:
device.vendor = vendor.pop()
if device.vendor.endswith(''):
device.vendor = device.vendor[:-1]
else:
device.vendor = "UNKNOWN"
# mode: 3 = EPON OLT, 7 = GPON OLT
# mode: 2 = EPON ONU, 6 = GPON ONU
if ponMode[rc]:
value = ponMode.pop()
mode = "UNKNOWN"
self.mode = "UNKNOWN"
if value == 6:
mode = "10G GPON ONU"
self.mode = "GPON"
if value == 2:
mode = "10G EPON ONU"
self.mode = "EPON"
if value == 1:
mode = "10G Point to Point"
self.mode = "Unsupported"
device.model = mode
else:
device.model = "UNKNOWN"
self.mode = "UNKNOWN"
log.info("PON Mode is {}".format(self.mode))
if hw_version[rc]:
device.hardware_version = hw_version.pop()
device.hardware_version = device.hardware_version.replace("FA","")
if device.hardware_version.endswith(''):
device.hardware_version = device.hardware_version[:-1]
else:
device.hardware_version = "UNKNOWN"
if manufacturer[rc]:
manu_value = manufacturer.pop()
device.firmware_version = re.search('\Firmware: (.+?) ', manu_value).group(1)
image_1 = Image(version = \
re.search('\Build: (.+?) ', manu_value).group(1))
device.images.image.extend([ image_1 ])
device.serial_number = re.search('\Serial #: (.+?) ', manu_value).group(1)
else:
device.firmware_version = "UNKNOWN"
image_1 = Image(version="UNKNOWN")
device.images.image.extend([ image_1 ])
device.serial_number = "UNKNOWN"
device.connect_status = ConnectStatus.REACHABLE
def _mib_in_sync(self):
"""
This method is ran whenever the ONU MIB database is in-sync. This is often after
the initial MIB Upload during ONU startup, or after it has gone out-of-sync and
then back in. This second case could be due a reboot of the ONU and a new version
of firmware is running on the ONU hardware.
"""
self.log.info('mib-in-sync')
device = self._handler.adapter_agent.get_device(self._handler.device_id)
device.oper_status = OperStatus.ACTIVE
device.connect_status = ConnectStatus.REACHABLE
device.reason = ''
self._handler.adapter_agent.update_device(device)
omci_dev = self._onu_omci_device
config = omci_dev.configuration
# In Sync, we can register logical ports now. Ideally this could occur on
# the first time we received a successful (no timeout) OMCI Rx response.
try:
device = self._handler.adapter_agent.get_device(self._handler.device_id)
ani_g = config.ani_g_entities
uni_g = config.uni_g_entities
pon_ports = len(ani_g) if ani_g is not None else 0
uni_ports = len(uni_g) if uni_g is not None else 0
# For the UNI ports below, they are created after the MIB Sync event occurs
# and the onu handler adds the ONU
assert pon_ports == 1, 'Expected one PON/ANI port, got {}'.format(pon_ports)
assert uni_ports == len(self._handler.uni_ports), \
'Expected {} UNI port(s), got {}'.format(len(self._handler.uni_ports), uni_ports)
# serial_number = omci_dev.configuration.serial_number
# self.log.info('serial-number', serial_number=serial_number)
# Save entity_id of PON ports
self._handler.pon_ports[0].entity_id = ani_g.keys()[0]
self._total_tcont_count = ani_g.get('total-tcont-count')
self._qos_flexibility = config.qos_configuration_flexibility or 0
self._omcc_version = config.omcc_version or OMCCVersion.Unknown
# vendorProductCode = str(config.vendor_product_code or 'unknown').rstrip('\0')
host_info = omci_dev.query_mib(IpHostConfigData.class_id)
mgmt_mac_address = next((host_info[inst].get('attributes').get('mac_address')
for inst in host_info
if isinstance(inst, int)), 'unknown')
device.mac_address = str(mgmt_mac_address)
device.model = str(config.version or 'unknown').rstrip('\0')
equipment_id = config.equipment_id or " unknown unknown "
eqpt_boot_version = str(equipment_id).rstrip('\0')
# eqptId = eqpt_boot_version[:10] # ie) BVMDZ10DRA
boot_version = eqpt_boot_version[12:] # ie) CML.D55~
images = [Image(name='boot-code',
version=boot_version.rstrip('\0'),
is_active=False,
is_committed=True,
is_valid=True,
install_datetime='Not Available',
hash='Not Available')] + \
config.software_images
del (device.images.image[:]) # Clear previous entries
device.images.image.extend(images)
# Save our device information
self._handler.adapter_agent.update_device(device)
# Start MIB download TODO: This will be replaced with a MIB Download task soon
self._in_sync_reached = True
except Exception as e:
self.log.exception('device-info-load', e=e)
self._deferred = reactor.callLater(_STARTUP_RETRY_WAIT, self._mib_in_sync)
def _simulate_device_activation(self, device):
# first we verify that we got parent reference and proxy info
assert device.parent_id
assert device.proxy_address.device_id
assert device.proxy_address.channel_id
# we pretend that we were able to contact the device and obtain
# additional information about it
device.vendor = 'simulated onu adapter'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
image1 = Image(name="onu_candidate1",
version="1.0",
hash="1234567892",
install_datetime=datetime.datetime.utcnow().isoformat(),
is_active=True,
is_committed=True,
is_valid=True)
image2 = Image(name="onu_candidate2",
version="1.0",
hash="1234567893",
install_datetime=datetime.datetime.utcnow().isoformat(),
is_active=False,
is_committed=False,
is_valid=True)
device.images.image.extend([image1, image2])
self.adapter_agent.update_device(device)
# then shortly after we create some ports for the device
yield asleep(0.05)
uni_port = Port(port_no=2,
label='UNI facing Ethernet port',
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
self.adapter_agent.add_port(device.id, uni_port)
self.adapter_agent.add_port(
device.id,
Port(port_no=1,
label='PON port',
type=Port.PON_ONU,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE,
peers=[
Port.PeerPort(device_id=device.parent_id,
port_no=device.parent_port_no)
]))
# TODO adding vports to the logical device shall be done by agent?
# then we create the logical device port that corresponds to the UNI
# port of the device
yield asleep(0.05)
# obtain logical device id
parent_device = self.adapter_agent.get_device(device.parent_id)
logical_device_id = parent_device.parent_id
assert logical_device_id
# we are going to use the proxy_address.channel_id as unique number
# and name for the virtual ports, as this is guaranteed to be unique
# in the context of the OLT port, so it is also unique in the context
# of the logical device
port_no = device.proxy_address.channel_id
cap = OFPPF_1GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(
logical_device_id,
LogicalPort(id=str(port_no),
ofp_port=ofp_port(port_no=port_no,
hw_addr=mac_str_to_tuple(
'00:00:00:00:00:%02x' % port_no),
name='uni-{}'.format(port_no),
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_1GB_FD,
max_speed=OFPPF_1GB_FD),
device_id=device.id,
device_port_no=uni_port.port_no))
# simulate a proxied message sending and receving a reply
reply = yield self._simulate_message_exchange(device)
# and finally update to "ACTIVE"
device = self.adapter_agent.get_device(device.id)
device.oper_status = OperStatus.ACTIVE
self.adapter_agent.update_device(device)
def _onu_device_activation(self, device):
# first we verify that we got parent reference and proxy info
assert device.parent_id
assert device.proxy_address.device_id
assert device.proxy_address.channel_id
# TODO: For now, pretend that we were able to contact the device and obtain
# additional information about it. Should add real message.
device.vendor = 'Sumitomo Electric, Inc.'
device.model = '10G EPON ONU'
device.hardware_version = 'fa161020'
device.firmware_version = '16.12.02'
# There could be multiple software versions on the device (one active, other
# standby etc.). Look for simulated_olt for example implementation.
device.images.image.extend([Image(version="1.0")])
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
# then shortly after we create some ports for the device
uni_port = Port(port_no=2,
label='UNI facing Ethernet port',
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
self.adapter_agent.add_port(device.id, uni_port)
self.adapter_agent.add_port(
device.id,
Port(port_no=1,
label='PON port',
type=Port.PON_ONU,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE,
peers=[
Port.PeerPort(device_id=device.parent_id,
port_no=device.parent_port_no)
]))
# TODO adding vports to the logical device shall be done by agent?
# then we create the logical device port that corresponds to the UNI
# port of the device
# obtain logical device id
parent_device = self.adapter_agent.get_device(device.parent_id)
logical_device_id = parent_device.parent_id
assert logical_device_id
# we are going to use the proxy_address.channel_id as unique number
# and name for the virtual ports, as this is guaranteed to be unique
# in the context of the OLT port, so it is also unique in the context
# of the logical device
port_no = device.proxy_address.channel_id
cap = OFPPF_10GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(
logical_device_id,
LogicalPort(id=str(port_no),
ofp_port=ofp_port(port_no=port_no,
hw_addr=mac_str_to_tuple(
device.mac_address),
name='uni-{}'.format(port_no),
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_10GB_FD,
max_speed=OFPPF_10GB_FD),
device_id=device.id,
device_port_no=uni_port.port_no))
# simulate a proxied message sending and receving a reply
reply = yield self._message_exchange(device)
# and finally update to "ACTIVE"
device = self.adapter_agent.get_device(device.id)
device.oper_status = OperStatus.ACTIVE
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
assert device.proxy_address.device_id
# register for proxied messages right away
self.proxy_address = device.proxy_address
self.adapter_agent.register_for_proxied_messages(device.proxy_address)
# populate device info
device.root = True
device.vendor = 'Adtran Inc.'
device.model = '10G GPON ONU' # TODO: get actual number
device.hardware_version = 'NOT AVAILABLE'
device.firmware_version = 'NOT AVAILABLE'
# TODO: Support more versions as needed
images = Image(version='NOT AVAILABLE')
device.images.image.extend([images])
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
# register physical ports
nni_port = Port(port_no=1,
label='PON port',
type=Port.PON_ONU,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE,
peers=[Port.PeerPort(device_id=device.parent_id,
port_no=device.parent_port_no)])
self.adapter_agent.add_port(device.id, nni_port)
uni_port = Port(port_no=2,
label='Ethernet port',
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
self.adapter_agent.add_port(device.id, uni_port)
# add uni port to logical device
parent_device = self.adapter_agent.get_device(device.parent_id)
logical_device_id = parent_device.parent_id
assert logical_device_id
port_no = device.proxy_address.channel_id
log.info('ONU OPENFLOW PORT WILL BE {}'.format(port_no))
cap = OFPPF_10GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(logical_device_id, LogicalPort(
id='uni-{}'.format(port_no),
ofp_port=ofp_port(
port_no=port_no,
hw_addr=mac_str_to_tuple('08:00:%02x:%02x:%02x:%02x' %
((device.parent_port_no >> 8 & 0xff),
device.parent_port_no & 0xff,
(port_no >> 8) & 0xff,
port_no & 0xff)),
name='uni-{}'.format(port_no),
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_10GB_FD,
max_speed=OFPPF_10GB_FD
),
device_id=device.id,
device_port_no=uni_port.port_no
))
# Begin ONU Activation sequence
reactor.callLater(0, self.message_exchange)
device = self.adapter_agent.get_device(device.id)
device.oper_status = OperStatus.ACTIVE
self.adapter_agent.update_device(device)
def _onu_device_activation(self, device):
# first we verify that we got parent reference and proxy info
assert device.parent_id
assert device.proxy_address.device_id
assert device.proxy_address.channel_id == 0
device.model = 'GPON ONU'
device.hardware_version = 'tbd'
device.firmware_version = 'tbd'
device.images.image.extend([
Image(version="tbd")
])
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
uni_port = Port(port_no=1000, # FIXME It becomes the alloc_id
label="{} ONU".format('PMCS'),
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE
)
self.adapter_agent.add_port(device.id, uni_port)
pon_port = Port(
port_no=1,
label='PON port',
type=Port.PON_ONU,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE,
peers=[
Port.PeerPort(
device_id=device.parent_id,
port_no=device.parent_port_no
)
]
)
self.adapter_agent.add_port(device.id, pon_port)
# obtain logical device id
parent_device = self.adapter_agent.get_device(device.parent_id)
logical_device_id = parent_device.parent_id
assert logical_device_id
# we are going to use the proxy_address.channel_id as unique number
# and name for the virtual ports, as this is guaranteed to be unique
# in the context of the OLT port, so it is also unique in the context
# of the logical device
port_no = device.proxy_address.channel_id # FIXME this may need to be fixed
cap = OFPPF_1GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(logical_device_id, LogicalPort(
id=str(port_no),
ofp_port=ofp_port(
port_no=port_no,
hw_addr=mac_str_to_tuple(device.serial_number)[2:8],
name='uni-{}'.format(port_no),
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_1GB_FD,
max_speed=OFPPF_1GB_FD
),
device_id=device.id,
device_port_no=uni_port.port_no
))
yield self._initialize_onu(device)
# and finally update to "ACTIVE"
device = self.adapter_agent.get_device(device.id)
device.oper_status = OperStatus.ACTIVE
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)