def _add_peer_reference(self, device_id, port):
# for referential integrity, add/augment references
port.device_id = device_id
me_as_peer = Port.PeerPort(device_id=device_id, port_no=port.port_no)
for peer in port.peers:
peer_port_path = '/devices/{}/ports/{}'.format(
peer.device_id, peer.port_no)
peer_port = self.root_proxy.get(peer_port_path)
if me_as_peer not in peer_port.peers:
new = peer_port.peers.add()
new.CopyFrom(me_as_peer)
self.root_proxy.update(peer_port_path, peer_port)
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
if self.port is None:
self.port = Port(port_no=self.port_number,
label=self.label,
type=Port.PON_OLT,
admin_state=self.admin_state,
oper_status=self.oper_status)
return self.port
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
if self._port is None:
self._port = Port(port_no=self._port_no,
label=self._label,
type=Port.ETHERNET_NNI,
admin_state=self._admin_state,
oper_status=self._oper_status)
return self._port
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
self.log.info('get nni gort', self._port_no)
if self._port is None:
self._port = Port(port_no=self._port_no, \
label='NNI port', \
type=Port.ETHERNET_NNI, \
admin_state=self._admin_state, \
oper_status=self._oper_status)
return self._port
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
self.log.debug('function-entry')
self._port = Port(port_no=self.port_number,
label=self.port_id_name(),
type=Port.ETHERNET_UNI,
admin_state=self._admin_state,
oper_status=self._oper_status)
return self._port
def _del_peer_reference(self, device_id, port):
me_as_peer = Port.PeerPort(device_id=device_id, port_no=port.port_no)
for peer in port.peers:
try:
peer_port_path = '/devices/{}/ports/{}'.format(
peer.device_id, peer.port_no)
peer_port = self.root_proxy.get(peer_port_path)
if me_as_peer in peer_port.peers:
peer_port.peers.remove(me_as_peer)
self.root_proxy.update(peer_port_path, peer_port)
except Exception:
# if the device on the other side was already remove
# the key cannot be found under /devices/<device_id>
pass
def add_port(self, intf_id, port_type, oper_status):
port_no = self.intf_id_to_port_no(intf_id, port_type)
label = self.port_name(port_no, port_type)
self.log.info('adding-port', port_no=port_no, label=label,
port_type=port_type)
port = Port(port_no=port_no, label=label, type=port_type,
admin_state=AdminState.ENABLED, oper_status=oper_status)
self.adapter_agent.add_port(self.device_id, port)
return port_no, label
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
self.log.debug('function-entry')
self._port = Port(port_no=self.port_number,
label='PON port',
type=Port.PON_ONU,
admin_state=self._admin_state,
oper_status=self._oper_status,
peers=[])
return self._port
def __add_port(self, intf_id, port_type, oper_status):
port_no = self.platform.intf_id_to_port_no(intf_id, port_type)
label = OpenoltUtils.port_name(port_no, port_type, intf_id)
self.log.debug('adding-port', port_no=port_no, label=label,
port_type=port_type)
port = Port(port_no=port_no, label=label, type=port_type,
admin_state=AdminState.ENABLED, oper_status=oper_status)
self.adapter_agent.add_port(self.device.id, port)
return port_no, label
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
if self._port is None:
self._port = Port(port_no=self._port_no,
label=self._label,
type=Port.PON_OLT,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
# TODO: For now, no way to report the proper ADMIN or OPER status
# admin_state=self._admin_state,
# oper_status=self._oper_status)
return self._port
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
device = self._handler.adapter_agent.get_device(
self._handler.device_id)
self._port = Port(
port_no=self.port_number,
label=device.serial_number,
# label=self.port_id_name(),
type=Port.ETHERNET_UNI,
admin_state=self._admin_state,
oper_status=self._oper_status)
return self._port
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
self.log.info('get pon gort', self._port_no)
if self._port is None:
self._port = Port( \
port_no=100 + self._port_no, \
#port_no=self._port_no, \
label=self._label, \
type=Port.PON_OLT, \
admin_state=self._admin_state, \
oper_status=self._oper_status \
)
return self._port
def add_port(self, device_id, port):
assert isinstance(port, Port)
# for referential integrity, add/augment references
port.device_id = device_id
me_as_peer = Port.PeerPort(device_id=device_id, port_no=port.port_no)
for peer in port.peers:
peer_port_path = '/devices/{}/ports/{}'.format(
peer.device_id, peer.port_no)
peer_port = self.root_proxy.get(peer_port_path)
if me_as_peer not in peer_port.peers:
new = peer_port.peers.add()
new.CopyFrom(me_as_peer)
self.root_proxy.update(peer_port_path, peer_port)
self._make_up_to_date('/devices/{}/ports'.format(device_id),
port.port_no, port)
def add_port(self, port_no, port_type, label):
self.log.info('adding-port', port_no=port_no, port_type=port_type)
if port_type is Port.ETHERNET_NNI:
oper_status = OperStatus.ACTIVE
elif port_type is Port.PON_OLT:
# To-Do The pon port status should be ACTIVATING.
# For now make the status as Active.
oper_status = OperStatus.ACTIVE
else:
self.log.erro('invalid-port-type', port_type=port_type)
return
port = Port(port_no=port_no,
label=label,
type=port_type,
admin_state=AdminState.ENABLED,
oper_status=oper_status)
self.adapter_agent.add_port(self.device_id, port)
def port_config():
# "v_enet" creation (olt)
# add_port update port when it exists
self.adapter_agent.add_port(
self.device_id,
Port(port_no=uni_no,
label=uni_name,
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE))
# v_enet creation (onu)
venet = VEnetConfig(name=uni_name)
venet.interface.name = uni_name
onu_adapter_agent.create_interface(onu_device, venet)
def onu_ports_down(self, onu_device, uni_no, uni_name, oper_state):
# Set port oper state to Discovered
# add port will update port if it exists
self.adapter_agent.add_port(
self.device_id,
Port(port_no=uni_no,
label=uni_name,
type=Port.ETHERNET_UNI,
admin_state=onu_device.admin_state,
oper_status=oper_state))
# Disable logical port
onu_ports = self.proxy.get('devices/{}/ports'.format(onu_device.id))
onu_port_id = None
for onu_port in onu_ports:
if onu_port.port_no == uni_no:
onu_port_id = onu_port.label
if onu_port_id is None:
self.log.error('matching-onu-port-label-not-found',
onu_id=onu_device.id,
olt_id=self.device_id,
onu_ports=onu_ports)
return
try:
onu_logical_port = self.adapter_agent.get_logical_port(
logical_device_id=self.logical_device_id, port_id=onu_port_id)
onu_logical_port.ofp_port.state = OFPPS_LINK_DOWN
self.adapter_agent.update_logical_port(
logical_device_id=self.logical_device_id,
port=onu_logical_port)
self.log.debug('cascading-oper-state-to-port-and-logical-port')
except KeyError as e:
self.log.error('matching-onu-port-label-invalid',
onu_id=onu_device.id,
olt_id=self.device_id,
onu_ports=onu_ports,
onu_port_id=onu_port_id,
error=e)
def get_port(self):
"""
Get the VOLTHA PORT object for this port
:return: VOLTHA Port object
"""
self.log.debug('get-port-status-update', port=self._port_no,
label=self._label)
if self._port is None:
self._port = Port(port_no=self._port_no,
label=self._label,
type=Port.ETHERNET_NNI,
admin_state=self._admin_state,
oper_status=self._oper_status)
if self._port.admin_state != self._admin_state or\
self._port.oper_status != self._oper_status:
self.log.debug('get-port-status-update', admin_state=self._admin_state,
oper_status = self._oper_status)
self._port.admin_state = self._admin_state
self._port.oper_status = self._oper_status
return self._port
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 PORTS:
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
))
self.create_logical_device()
self.add_upstream_port(129)
self.add_logical_upstream_port(129)
self.device.parent_id = self.logical_device.id
self.adapter_agent.update_device(self.device)
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)
self.device.software_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 _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.software_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 setUp(self):
#calling the parent class setUp
test_logical_device_agent.setUp(self)
#re-initializing ports to VENET topology
self.ports = {
'olt': [
Port(port_no=0, type=Port.ETHERNET_NNI, device_id='olt'),
Port(port_no=1,
type=Port.VENET_OLT,
device_id='olt',
peers=[
Port.PeerPort(device_id='onu1', port_no=1),
Port.PeerPort(device_id='onu2', port_no=1)
])
],
'onu1': [
Port(port_no=0, type=Port.ETHERNET_UNI, device_id='onu1'),
Port(port_no=1,
type=Port.VENET_ONU,
device_id='onu1',
peers=[
Port.PeerPort(device_id='olt', port_no=1),
])
],
'onu2': [
Port(port_no=0, type=Port.ETHERNET_UNI, device_id='onu2'),
Port(port_no=1,
type=Port.VENET_ONU,
device_id='onu2',
peers=[
Port.PeerPort(device_id='olt', port_no=1),
])
],
}
#resetting root_proxy for VENET topology
self.root_proxy = Mock()
def get_devices(path):
if path == '':
return self.devices.values()
if path.endswith('/ports'):
return self.ports[path[:-len('/ports')]]
elif path.find('/') == -1:
return self.devices[path]
else:
raise Exception(
'Nothing to yield for path /devices/{}'.format(path))
def update_devices(path, data):
if path.endswith('/flows'):
self.device_flows[path[:-len('/flows')]] = data
elif path.endswith('/flow_groups'):
self.device_groups[path[:-len('/flow_groups')]] = data
else:
raise NotImplementedError(
'not handling path /devices/{}'.format(path))
self.root_proxy.get = lambda p: \
get_devices(p[len('/devices/'):]) if p.startswith('/devices') \
else None
self.root_proxy.update = lambda p, d: \
update_devices(p[len('/devices/'):], d) \
if p.startswith('/devices') \
else None
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 _tmp_populate_stuff(self):
"""
pretend that we discovered some devices and create:
- devices
- device ports for each
- logical device
- logical device ports
"""
olt = Device(id='simulated_olt_1',
type='simulated_olt',
root=True,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter=self.name,
oper_status=OperStatus.DISCOVERED)
self.adapter_agent.add_device(olt)
self.adapter_agent.add_port(
olt.id, Port(port_no=1, label='pon', type=Port.PON_OLT))
self.adapter_agent.add_port(
olt.id, Port(port_no=2, label='eth', type=Port.ETHERNET_NNI))
onu1 = Device(id='simulated_onu_1',
type='simulated_onu',
root=False,
parent_id=olt.id,
parent_port_no=1,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter='simulated_onu',
oper_status=OperStatus.DISCOVERED,
vlan=101)
self.adapter_agent.add_device(onu1)
self.adapter_agent.add_port(
onu1.id, Port(port_no=2, label='eth', type=Port.ETHERNET_UNI))
self.adapter_agent.add_port(
onu1.id,
Port(port_no=1,
label='pon',
type=Port.PON_ONU,
peers=[Port.PeerPort(device_id=olt.id, port_no=1)]))
onu2 = Device(id='simulated_onu_2',
type='simulated_onu',
root=False,
parent_id=olt.id,
parent_port_no=1,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter='simulated_onu',
oper_status=OperStatus.DISCOVERED,
vlan=102)
self.adapter_agent.add_device(onu2)
self.adapter_agent.add_port(
onu2.id, Port(port_no=2, label='eth', type=Port.ETHERNET_UNI))
self.adapter_agent.add_port(
onu2.id,
Port(port_no=1,
label='pon',
type=Port.PON_ONU,
peers=[Port.PeerPort(device_id=olt.id, port_no=1)]))
ld = LogicalDevice(
id='simulated1',
datapath_id=1,
desc=ofp_desc(mfr_desc='cord project',
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=olt.id)
self.adapter_agent.create_logical_device(ld)
cap = OFPPF_1GB_FD | OFPPF_FIBER
for port_no, name, device_id, device_port_no, root_port in [
(1, 'onu1', onu1.id, 2, False), (2, 'onu2', onu2.id, 2, False),
(129, 'olt1', olt.id, 2, True)
]:
port = LogicalPort(id=name,
ofp_port=ofp_port(
port_no=port_no,
hw_addr=mac_str_to_tuple(
'00:00:00:00:00:%02x' % port_no),
name=name,
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=device_port_no,
root_port=root_port)
self.adapter_agent.add_logical_port(ld.id, port)
olt.parent_id = ld.id
self.adapter_agent.update_device(olt)
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 = 'Tibit Communications, Inc.'
device.model = '10G GPON ONU'
device.hardware_version = 'fa161020'
device.firmware_version = '16.12.02'
device.software_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)
self.start_kpi_collection(device.id)
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 _launch_device_activation(self, device):
try:
log.debug('launch_dev_activation')
# prepare receive queue
self.incoming_queues[device.mac_address] = DeferredQueue(size=100)
# add mac_address to device_ids table
olt_mac = device.mac_address
self.device_ids[olt_mac] = device.id
# send out ping to OLT device
ping_frame = self._make_ping_frame(mac_address=olt_mac)
self.io_port.send(ping_frame)
# wait till we receive a response
## TODO add timeout mechanism so we can signal if we cannot reach
##device
while True:
response = yield self.incoming_queues[olt_mac].get()
# verify response and if not the expected response
if 1: # TODO check if it is really what we expect, and wait if not
break
except Exception as e:
log.exception('launch device failed', e=e)
# if we got response, we can fill out the device info, mark the device
# reachable
jdev = json.loads(response.payload.payload.body.load)
device.root = True
device.vendor = 'Tibit Communications, Inc.'
device.model = jdev.get('results', {}).get('device', 'DEVICE_UNKNOWN')
device.hardware_version = jdev['results']['datecode']
device.firmware_version = jdev['results']['firmware']
device.software_version = jdev['results']['modelversion']
device.serial_number = jdev['results']['manufacturer']
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
# then shortly after we create some ports for the device
log.info('create-port')
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
))
log.info('create-logical-device')
# then shortly after we create the logical device with one port
# that will correspond to the NNI port
ld = LogicalDevice(
desc=ofp_desc(
mfr_desc=device.vendor,
hw_desc=jdev['results']['device'],
sw_desc=jdev['results']['firmware'],
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_10GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(ld_initialized.id, LogicalPort(
id='nni',
ofp_port=ofp_port(
port_no=0,
hw_addr=mac_str_to_tuple(device.mac_address),
name='nni',
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=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)
# Just transitioned to ACTIVE, wait a tenth of second
# before checking for ONUs
reactor.callLater(0.1, self._detect_onus, 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
assert device.proxy_address.channel_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 = 'Broadcom'
device.model = 'n/a'
device.hardware_version = 'to be filled'
device.firmware_version = 'to be filled'
device.software_version = 'to be filled'
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
# register physical ports
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)
]))
# 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
cap = OFPPF_1GB_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(
'00:00:00:00:%02x:%02x' %
((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_1GB_FD,
max_speed=OFPPF_1GB_FD),
device_id=device.id,
device_port_no=uni_port.port_no))
reactor.callLater(10, self.message_exchange)
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')
if not device.host_and_port:
device.oper_status = OperStatus.FAILED
device.reason = 'No host_and_port field provided'
self.adapter_agent.update_device(device)
return
stub = ponsim_pb2.PonSimStub(self.get_channel())
info = stub.GetDeviceInfo(Empty())
log.info('got-info', info=info)
device.root = True
device.vendor = 'ponsim'
device.model = 'n/a'
device.serial_number = device.host_and_port
device.connect_status = ConnectStatus.REACHABLE
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)
# Setup alarm handler
self.alarms = AdapterAlarms(self.adapter, device)
nni_port = Port(
port_no=2,
label='NNI facing Ethernet port',
type=Port.ETHERNET_NNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE
)
self.nni_port = nni_port
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
))
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.ofp_port_no = info.nni_port
self.adapter_agent.add_logical_port(ld_initialized.id, LogicalPort(
id='nni',
ofp_port=ofp_port(
port_no=info.nni_port,
hw_addr=mac_str_to_tuple(
'00:00:00:00:00:%02x' % info.nni_port),
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
))
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)
self.logical_device_id = ld_initialized.id
# register ONUS per uni port
for port_no in info.uni_ports:
vlan_id = port_no
self.adapter_agent.child_device_detected(
parent_device_id=device.id,
parent_port_no=1,
child_device_type='ponsim_onu',
proxy_address=Device.ProxyAddress(
device_id=device.id,
channel_id=vlan_id
),
vlan=vlan_id
)
# finally, open the frameio port to receive in-band packet_in messages
self.log.info('registering-frameio')
self.io_port = registry('frameio').open_port(
self.interface, self.rcv_io, is_inband_frame)
self.log.info('registered-frameio')
# Start collecting stats from the device after a brief pause
self.start_kpi_collection(device.id)
def setUp(self):
self.setup_mock_registry()
self.flows = Flows(items=[])
self.groups = FlowGroups(items=[])
self.ld_ports = [
LogicalPort(id='0',
device_id='olt',
device_port_no=0,
root_port=True,
ofp_port=ofp.ofp_port(port_no=0)),
LogicalPort(id='1',
device_id='onu1',
device_port_no=0,
ofp_port=ofp.ofp_port(port_no=1)),
LogicalPort(id='2',
device_id='onu2',
device_port_no=0,
ofp_port=ofp.ofp_port(port_no=2))
]
self.devices = {
'olt': Device(id='olt', root=True, parent_id='id'),
'onu1': Device(id='onu1',
parent_id='olt',
parent_port_no=1,
vlan=101),
'onu2': Device(id='onu2',
parent_id='olt',
parent_port_no=1,
vlan=102),
}
self.ports = {
'olt': [
Port(port_no=0, type=Port.ETHERNET_NNI, device_id='olt'),
Port(port_no=1,
type=Port.PON_OLT,
device_id='olt',
peers=[
Port.PeerPort(device_id='onu1', port_no=1),
Port.PeerPort(device_id='onu2', port_no=1)
])
],
'onu1': [
Port(port_no=0, type=Port.ETHERNET_UNI, device_id='onu1'),
Port(port_no=1,
type=Port.PON_ONU,
device_id='onu1',
peers=[
Port.PeerPort(device_id='olt', port_no=1),
])
],
'onu2': [
Port(port_no=0, type=Port.ETHERNET_UNI, device_id='onu2'),
Port(port_no=1,
type=Port.PON_ONU,
device_id='onu2',
peers=[
Port.PeerPort(device_id='olt', port_no=1),
])
],
}
self.device_flows = {'olt': Flows(), 'onu1': Flows(), 'onu2': Flows()}
self.device_groups = {
'olt': FlowGroups(),
'onu1': FlowGroups(),
'onu2': FlowGroups()
}
self.ld = LogicalDevice(id='id', root_device_id='olt')
self.root_proxy = Mock()
def get_devices(path):
if path == '':
return self.devices.values()
if path.endswith('/ports'):
return self.ports[path[:-len('/ports')]]
elif path.find('/') == -1:
return self.devices[path]
else:
raise Exception(
'Nothing to yield for path /devices/{}'.format(path))
def update_devices(path, data):
if path.endswith('/flows'):
self.device_flows[path[:-len('/flows')]] = data
elif path.endswith('/flow_groups'):
self.device_groups[path[:-len('/flow_groups')]] = data
else:
raise NotImplementedError(
'not handling path /devices/{}'.format(path))
self.root_proxy.get = lambda p: \
get_devices(p[len('/devices/'):]) if p.startswith('/devices') \
else None
self.root_proxy.update = lambda p, d: \
update_devices(p[len('/devices/'):], d) \
if p.startswith('/devices') \
else None
self.ld_proxy = Mock()
self.ld_proxy.get = lambda p: \
self.ld_ports if p == '/ports' else (
self.ld if p == '/' else None
)
self.flows_proxy = Mock()
self.flows_proxy.get = lambda _: self.flows # always '/' path
def update_flows(_, flows): # always '/' path
self.flows = flows
self.flows_proxy.update = update_flows
self.groups_proxy = Mock()
self.groups_proxy.get = lambda _: self.groups # always '/' path
def update_groups(_, groups): # always '/' path
self.groups = groups
self.groups_proxy.update = update_groups
self.core = Mock()
self.core.get_proxy = lambda path: \
self.root_proxy if path == '/' else (
self.ld_proxy if path.endswith('id') else (
self.flows_proxy if path.endswith('flows') else
self.groups_proxy
)
)
self.lda = LogicalDeviceAgent(self.core, self.ld)
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
assert device.proxy_address.channel_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 = False
device.vendor = 'ponsim'
device.model = 'n/a'
device.connect_status = ConnectStatus.REACHABLE
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)
# register physical ports
self.uni_port = Port(port_no=2,
label='UNI facing Ethernet port',
type=Port.ETHERNET_UNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE)
self.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, self.uni_port)
self.adapter_agent.add_port(device.id, self.pon_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
cap = OFPPF_1GB_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(
'00:00:00:00:00:%02x' % port_no),
name=device.serial_number,
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=self.uni_port.port_no))
device = self.adapter_agent.get_device(device.id)
device.oper_status = OperStatus.ACTIVE
self.adapter_agent.update_device(device)
# Start collecting stats from the device after a brief pause
self.start_kpi_collection(device.id)
