VOL-951: Make OpenOLT adapter pep8
Change-Id: I0fb8ca6e7da4dd83b0149628b5fe57f140d62acf
diff --git a/voltha/adapters/openolt/openolt.py b/voltha/adapters/openolt/openolt.py
index 612ba60..45c8b8e 100644
--- a/voltha/adapters/openolt/openolt.py
+++ b/voltha/adapters/openolt/openolt.py
@@ -17,9 +17,8 @@
"""
Openolt adapter.
"""
-import structlog
-from twisted.internet import reactor, defer
from zope.interface import implementer
+import structlog
from openolt_device import OpenoltDevice
from voltha.adapters.interface import IAdapterInterface
@@ -28,12 +27,12 @@
from voltha.protos.adapter_pb2 import AdapterConfig
from voltha.protos.common_pb2 import LogLevel
from voltha.protos.device_pb2 import DeviceType, DeviceTypes
-from voltha.protos.health_pb2 import HealthStatus
from voltha.registry import registry
_ = third_party
log = structlog.get_logger()
+
@implementer(IAdapterInterface)
class OpenoltAdapter(object):
name = 'openolt'
@@ -72,7 +71,8 @@
return self.descriptor
def device_types(self):
- log.debug('get device_types', interface=self.interface, items=self.supported_device_types)
+ log.debug('get device_types', interface=self.interface,
+ items=self.supported_device_types)
return DeviceTypes(items=self.supported_device_types)
def health(self):
@@ -80,7 +80,8 @@
raise NotImplementedError()
def change_master_state(self, master):
- log.debug('change_master_state', interface=self.interface, master=master)
+ log.debug('change_master_state', interface=self.interface,
+ master=master)
raise NotImplementedError()
def adopt_device(self, device):
@@ -109,10 +110,12 @@
}
try:
reconciled_device = OpenoltDevice(**kwargs)
- log.debug('reconciled-device-recreated', device_id=reconciled_device.device_id)
+ log.debug('reconciled-device-recreated',
+ device_id=reconciled_device.device_id)
self.devices[device.id] = reconciled_device
except Exception as e:
- log.error('Failed to reconcile OpenOLT device', error=e, exception_type=type(e).__name__)
+ log.error('Failed to reconcile OpenOLT device', error=e,
+ exception_type=type(e).__name__)
del self.devices[device.id]
raise
else:
@@ -161,7 +164,7 @@
raise NotImplementedError()
def self_test_device(self, device):
- #from voltha.protos.voltha_pb2 import SelfTestResponse
+ # from voltha.protos.voltha_pb2 import SelfTestResponse
raise NotImplementedError()
def delete_device(self, device):
@@ -182,8 +185,8 @@
return handler.update_flow_table(flows.items)
def update_flows_incrementally(self, device, flow_changes, group_changes):
- log.debug('update_flows_incrementally', device=device, flow_changes=flow_changes,
- group_changes=group_changes)
+ log.debug('update_flows_incrementally', device=device,
+ flow_changes=flow_changes, group_changes=group_changes)
raise NotImplementedError()
def update_pm_config(self, device, pm_configs):
@@ -196,12 +199,14 @@
handler.send_proxied_message(proxy_address, msg)
def receive_proxied_message(self, proxy_address, msg):
- log.debug('receive_proxied_message', proxy_address=proxy_address, msg=msg)
+ log.debug('receive_proxied_message', proxy_address=proxy_address,
+ msg=msg)
raise NotImplementedError()
def receive_packet_out(self, logical_device_id, egress_port_no, msg):
log.debug('packet-out', logical_device_id=logical_device_id,
egress_port_no=egress_port_no, msg_len=len(msg))
+
def ldi_to_di(ldi):
di = self.logical_device_id_to_root_device_id.get(ldi)
if di is None:
@@ -240,7 +245,8 @@
raise NotImplementedError()
def receive_onu_detect_state(self, proxy_address, state):
- log.debug('receive-onu-detect-state', proxy_address=proxy_address, state=state)
+ log.debug('receive-onu-detect-state', proxy_address=proxy_address,
+ state=state)
raise NotImplementedError()
def create_tcont(self, device, tcont_data, traffic_descriptor_data):
diff --git a/voltha/adapters/openolt/openolt_device.py b/voltha/adapters/openolt/openolt_device.py
index dea361e..5082552 100644
--- a/voltha/adapters/openolt/openolt_device.py
+++ b/voltha/adapters/openolt/openolt_device.py
@@ -17,7 +17,6 @@
import structlog
import threading
import grpc
-import collections
import time
from twisted.internet import reactor
@@ -28,10 +27,10 @@
from voltha.protos.device_pb2 import Port, Device
from voltha.protos.common_pb2 import OperStatus, AdminState, ConnectStatus
from voltha.protos.logical_device_pb2 import LogicalDevice
-from voltha.protos.openflow_13_pb2 import OFPPS_LIVE, OFPPF_FIBER, OFPPS_LINK_DOWN, \
- OFPPF_1GB_FD, OFPC_GROUP_STATS, OFPC_PORT_STATS, OFPC_TABLE_STATS, \
- OFPC_FLOW_STATS, ofp_switch_features, ofp_port
-from voltha.protos.logical_device_pb2 import LogicalPort, LogicalDevice
+from voltha.protos.openflow_13_pb2 import OFPPS_LIVE, OFPPF_FIBER, \
+ OFPPS_LINK_DOWN, OFPPF_1GB_FD, OFPC_GROUP_STATS, OFPC_PORT_STATS, \
+ OFPC_TABLE_STATS, OFPC_FLOW_STATS, ofp_switch_features, ofp_port
+from voltha.protos.logical_device_pb2 import LogicalPort
from voltha.core.logical_device_agent import mac_str_to_tuple
from voltha.registry import registry
from voltha.adapters.openolt.protos import openolt_pb2_grpc, openolt_pb2
@@ -50,12 +49,16 @@
"""
OpenoltDevice represents an OLT.
"""
+
+
class OpenoltDevice(object):
states = ['up', 'down']
transitions = [
- { 'trigger': 'olt_up', 'source': 'down', 'dest': 'up', 'before': 'olt_indication_up' },
- { 'trigger': 'olt_down', 'source': 'up', 'dest': 'down', 'before': 'olt_indication_down' }
+ {'trigger': 'olt_up', 'source': 'down', 'dest': 'up',
+ 'before': 'olt_indication_up'},
+ {'trigger': 'olt_down', 'source': 'up', 'dest': 'down',
+ 'before': 'olt_indication_down'}
]
def __init__(self, **kwargs):
@@ -67,7 +70,8 @@
is_reconciliation = kwargs.get('reconciliation', False)
self.device_id = device.id
self.host_and_port = device.host_and_port
- self.log = structlog.get_logger(id=self.device_id, ip=self.host_and_port)
+ self.log = structlog.get_logger(id=self.device_id,
+ ip=self.host_and_port)
self.proxy = registry('core').get_proxy('/')
# Device already set in the event of reconciliation
@@ -75,17 +79,20 @@
# It is a new device
# Update device
device.root = True
- device.serial_number = self.host_and_port # FIXME
+ device.serial_number = self.host_and_port # FIXME
device.connect_status = ConnectStatus.REACHABLE
device.oper_status = OperStatus.ACTIVATING
self.adapter_agent.update_device(device)
# Initialize the OLT state machine
self.machine = Machine(model=self, states=OpenoltDevice.states,
- transitions=OpenoltDevice.transitions,
- send_event=True, initial='down', ignore_invalid_triggers=True)
- self.machine.add_transition(trigger='olt_ind_up', source='down', dest='up')
- self.machine.add_transition(trigger='olt_ind_loss', source='up', dest='down')
+ transitions=OpenoltDevice.transitions,
+ send_event=True, initial='down',
+ ignore_invalid_triggers=True)
+ self.machine.add_transition(trigger='olt_ind_up', source='down',
+ dest='up')
+ self.machine.add_transition(trigger='olt_ind_loss', source='up',
+ dest='down')
# Initialize gRPC
self.channel = grpc.insecure_channel(self.host_and_port)
@@ -108,7 +115,6 @@
self.log.debug('openolt-device-created', device_id=self.device_id)
-
def process_indications(self):
self.log.debug('starting-indications-thread')
@@ -120,7 +126,8 @@
# get the next indication from olt
ind = next(self.indications)
except Exception as e:
- self.log.warn('GRPC-connection-lost-stoping-indications-thread', error=e)
+ self.log.warn('GRPC-connection-lost-stoping-indication-thread',
+ error=e)
self.indications_thread_active = False
else:
self.log.debug("rx indication", indication=ind)
@@ -131,9 +138,11 @@
elif ind.HasField('intf_ind'):
reactor.callFromThread(self.intf_indication, ind.intf_ind)
elif ind.HasField('intf_oper_ind'):
- reactor.callFromThread(self.intf_oper_indication, ind.intf_oper_ind)
+ reactor.callFromThread(self.intf_oper_indication,
+ ind.intf_oper_ind)
elif ind.HasField('onu_disc_ind'):
- reactor.callFromThread(self.onu_discovery_indication, ind.onu_disc_ind)
+ reactor.callFromThread(self.onu_discovery_indication,
+ ind.onu_disc_ind)
elif ind.HasField('onu_ind'):
reactor.callFromThread(self.onu_indication, ind.onu_ind)
elif ind.HasField('omci_ind'):
@@ -174,8 +183,9 @@
)
)
)
- ld_initialized = self.adapter_agent.create_logical_device(ld, dpid=dpid)
- self.logical_device_id = ld_initialized.id
+ ld_init = self.adapter_agent.create_logical_device(ld,
+ dpid=dpid)
+ self.logical_device_id = ld_init.id
else:
# logical device already exists
self.logical_device_id = device.parent_id
@@ -190,7 +200,8 @@
new_admin_state = event.kwargs.get('admin_state', None)
new_oper_state = event.kwargs.get('oper_state', None)
new_connect_state = event.kwargs.get('connect_state', None)
- self.log.debug("olt indication", olt_ind=olt_indication, admin_state=new_admin_state, oper_state=new_oper_state,
+ self.log.debug("olt indication", olt_ind=olt_indication,
+ admin_state=new_admin_state, oper_state=new_oper_state,
connect_state=new_connect_state)
# Propagating to the children
@@ -198,18 +209,24 @@
# Children ports
child_devices = self.adapter_agent.get_child_devices(self.device_id)
for onu_device in child_devices:
- uni_no = platform.mk_uni_port_num(onu_device.proxy_address.channel_id, onu_device.proxy_address.onu_id)
- uni_name = self.port_name(uni_no, Port.ETHERNET_UNI, serial_number=onu_device.serial_number)
+ uni_no = platform.mk_uni_port_num(
+ onu_device.proxy_address.channel_id,
+ onu_device.proxy_address.onu_id)
+ uni_name = self.port_name(uni_no, Port.ETHERNET_UNI,
+ serial_number=onu_device.serial_number)
self.onu_ports_down(onu_device, uni_no, uni_name, new_oper_state)
# Children devices
- self.adapter_agent.update_child_devices_state(self.device_id, oper_status=new_oper_state,
- connect_status=ConnectStatus.UNREACHABLE,
- admin_state=new_admin_state)
+ self.adapter_agent.update_child_devices_state(
+ self.device_id, oper_status=new_oper_state,
+ connect_status=ConnectStatus.UNREACHABLE,
+ admin_state=new_admin_state)
# Device Ports
- device_ports = self.adapter_agent.get_ports(self.device_id, Port.ETHERNET_NNI)
+ device_ports = self.adapter_agent.get_ports(self.device_id,
+ Port.ETHERNET_NNI)
logical_ports_ids = [port.label for port in device_ports]
- device_ports += self.adapter_agent.get_ports(self.device_id, Port.PON_OLT)
+ device_ports += self.adapter_agent.get_ports(self.device_id,
+ Port.PON_OLT)
for port in device_ports:
if new_admin_state is not None:
@@ -220,9 +237,11 @@
# Device logical port
for logical_port_id in logical_ports_ids:
- logical_port = self.adapter_agent.get_logical_port(self.logical_device_id, logical_port_id)
+ logical_port = self.adapter_agent.get_logical_port(
+ self.logical_device_id, logical_port_id)
logical_port.ofp_port.state = OFPPS_LINK_DOWN
- self.adapter_agent.update_logical_port(self.logical_device_id, logical_port)
+ self.adapter_agent.update_logical_port(self.logical_device_id,
+ logical_port)
# Device
device = self.adapter_agent.get_device(self.device_id)
@@ -237,7 +256,7 @@
def intf_indication(self, intf_indication):
self.log.debug("intf indication", intf_id=intf_indication.intf_id,
- oper_state=intf_indication.oper_state)
+ oper_state=intf_indication.oper_state)
if intf_indication.oper_state == "up":
oper_status = OperStatus.ACTIVE
@@ -248,8 +267,10 @@
self.add_port(intf_indication.intf_id, Port.PON_OLT, oper_status)
def intf_oper_indication(self, intf_oper_indication):
- self.log.debug("Received interface oper state change indication", intf_id=intf_oper_indication.intf_id,
- type=intf_oper_indication.type, oper_state=intf_oper_indication.oper_state)
+ self.log.debug("Received interface oper state change indication",
+ intf_id=intf_oper_indication.intf_id,
+ type=intf_oper_indication.type,
+ oper_state=intf_oper_indication.oper_state)
if intf_oper_indication.oper_state == "up":
oper_state = OperStatus.ACTIVE
@@ -263,10 +284,11 @@
return
# add_(logical_)port update the port if it exists
- port_no, label = self.add_port(intf_oper_indication.intf_id, Port.ETHERNET_NNI, oper_state)
+ port_no, label = self.add_port(intf_oper_indication.intf_id,
+ Port.ETHERNET_NNI, oper_state)
self.log.debug("int_oper_indication", port_no=port_no, label=label)
- self.add_logical_port(port_no, intf_oper_indication.intf_id, oper_state)
-
+ self.add_logical_port(port_no, intf_oper_indication.intf_id,
+ oper_state)
elif intf_oper_indication.type == "pon":
# FIXME - handle PON oper state change
@@ -274,23 +296,28 @@
def onu_discovery_indication(self, onu_disc_indication):
intf_id = onu_disc_indication.intf_id
- serial_number=onu_disc_indication.serial_number
+ serial_number = onu_disc_indication.serial_number
serial_number_str = self.stringify_serial_number(serial_number)
- self.log.debug("onu discovery indication", intf_id=intf_id, serial_number=serial_number_str)
+ self.log.debug("onu discovery indication", intf_id=intf_id,
+ serial_number=serial_number_str)
- onu_device = self.adapter_agent.get_child_device(self.device_id, serial_number=serial_number_str)
+ onu_device = self.adapter_agent.get_child_device(
+ self.device_id,
+ serial_number=serial_number_str)
if onu_device is None:
onu_id = self.new_onu_id(intf_id)
try:
- self.add_onu_device(intf_id,
- platform.intf_id_to_port_no(intf_id, Port.PON_OLT),
- onu_id, serial_number)
+ self.add_onu_device(
+ intf_id,
+ platform.intf_id_to_port_no(intf_id, Port.PON_OLT),
+ onu_id, serial_number)
self.log.info("activate-onu", intf_id=intf_id, onu_id=onu_id,
- serial_number=serial_number_str)
- onu = openolt_pb2.Onu(intf_id=intf_id, onu_id=onu_id,serial_number=serial_number)
+ serial_number=serial_number_str)
+ onu = openolt_pb2.Onu(intf_id=intf_id, onu_id=onu_id,
+ serial_number=serial_number)
self.stub.ActivateOnu(onu)
except Exception as e:
self.log.exception('onu-activation-failed', e=e)
@@ -301,37 +328,45 @@
self.adapter_agent.update_device(onu_device)
onu_id = onu_device.proxy_address.onu_id
- if onu_device.oper_status == OperStatus.DISCOVERED or onu_device.oper_status == OperStatus.ACTIVATING:
- self.log.debug("ignore onu discovery indication, the onu has been discovered and should be \
- activating shorlty", intf_id=intf_id, onu_id=onu_id, state=onu_device.oper_status)
- elif onu_device.oper_status== OperStatus.ACTIVE:
- self.log.warn("onu discovery indication whereas onu is supposed to be active",
- intf_id=intf_id, onu_id=onu_id, state=onu_device.oper_status)
+ if onu_device.oper_status == OperStatus.DISCOVERED \
+ or onu_device.oper_status == OperStatus.ACTIVATING:
+ self.log.debug("ignore onu discovery indication, \
+ the onu has been discovered and should be \
+ activating shorlty", intf_id=intf_id,
+ onu_id=onu_id, state=onu_device.oper_status)
+ elif onu_device.oper_status == OperStatus.ACTIVE:
+ self.log.warn("onu discovery indication whereas onu is \
+ supposed to be active",
+ intf_id=intf_id, onu_id=onu_id,
+ state=onu_device.oper_status)
elif onu_device.oper_status == OperStatus.UNKNOWN:
- self.log.info("onu-in-unknow-state-recovering-form-olt-reboot-activate-onu", intf_id=intf_id, onu_id=onu_id,
- serial_number=serial_number_str)
+ self.log.info("onu in unknown state, recovering from olt \
+ reboot, activate onu", intf_id=intf_id,
+ onu_id=onu_id, serial_number=serial_number_str)
onu_device.oper_status = OperStatus.DISCOVERED
self.adapter_agent.update_device(onu_device)
- onu = openolt_pb2.Onu(intf_id=intf_id, onu_id=onu_id, serial_number=serial_number)
+ onu = openolt_pb2.Onu(intf_id=intf_id, onu_id=onu_id,
+ serial_number=serial_number)
self.stub.ActivateOnu(onu)
else:
- self.log.warn('unexpected state', onu_id=onu_id, onu_device_oper_state=onu_device.oper_status)
+ self.log.warn('unexpected state', onu_id=onu_id,
+ onu_device_oper_state=onu_device.oper_status)
def onu_indication(self, onu_indication):
self.log.debug("onu indication", intf_id=onu_indication.intf_id,
- onu_id=onu_indication.onu_id,
- serial_number=onu_indication.serial_number,
- oper_state=onu_indication.oper_state,
- admin_state=onu_indication.admin_state)
+ onu_id=onu_indication.onu_id,
+ serial_number=onu_indication.serial_number,
+ oper_state=onu_indication.oper_state,
+ admin_state=onu_indication.admin_state)
if onu_indication.serial_number:
onu_device = self.adapter_agent.get_child_device(
self.device_id,
serial_number=self.stringify_serial_number(
onu_indication.serial_number))
- else :
+ else:
onu_device = self.adapter_agent.get_child_device(
self.device_id,
parent_port_no=platform.intf_id_to_port_no(
@@ -340,91 +375,102 @@
if onu_device is None:
self.log.error('onu not found', intf_id=onu_indication.intf_id,
- onu_id=onu_indication.onu_id)
+ onu_id=onu_indication.onu_id)
return
if onu_device.connect_status != ConnectStatus.REACHABLE:
onu_device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(onu_device)
- if platform.intf_id_from_pon_port_no(onu_device.parent_port_no) != onu_indication.intf_id:
+ if platform.intf_id_from_pon_port_no(onu_device.parent_port_no) \
+ != onu_indication.intf_id:
self.log.warn('ONU-is-on-a-different-intf-id-now',
- previous_intf_id=platform.intf_id_from_pon_port_no(onu_device.parent_port_no),
+ previous_intf_id=platform.intf_id_from_pon_port_no(
+ onu_device.parent_port_no),
current_intf_id=onu_indication.intf_id)
# FIXME - handle intf_id mismatch (ONU move?)
-
if onu_device.proxy_address.onu_id != onu_indication.onu_id:
# FIXME - handle onu id mismatch
- self.log.warn('ONU-id-mismatch', expected_onu_id=onu_device.proxy_address.onu_id,
+ self.log.warn('ONU-id-mismatch',
+ expected_onu_id=onu_device.proxy_address.onu_id,
received_onu_id=onu_indication.onu_id)
- uni_no = platform.mk_uni_port_num(onu_indication.intf_id, onu_indication.onu_id)
- uni_name = self.port_name(uni_no, Port.ETHERNET_UNI, serial_number=onu_device.serial_number)
+ uni_no = platform.mk_uni_port_num(onu_indication.intf_id,
+ onu_indication.onu_id)
+ uni_name = self.port_name(uni_no, Port.ETHERNET_UNI,
+ serial_number=onu_device.serial_number)
self.log.debug('port-number-ready', uni_no=uni_no, uni_name=uni_name)
- #Admin state
+ # Admin state
if onu_indication.admin_state == 'down':
if onu_indication.oper_state != 'down':
- self.log.error('ONU-admin-state-down-and-oper-status-not-down', oper_state=onu_indication.oper_state)
- onu_indication.oper_state = 'down' # Forcing the oper state change code to execute
+ self.log.error('ONU-admin-state-down-and-oper-status-not-down',
+ oper_state=onu_indication.oper_state)
+ # Forcing the oper state change code to execute
+ onu_indication.oper_state = 'down'
if onu_device.admin_state != AdminState.DISABLED:
onu_device.admin_state = AdminState.DISABLED
self.adapter_agent.update(onu_device)
- self.log.debug('putting-onu-in-disabled-state', onu_serial_number=onu_device.serial_number)
+ self.log.debug('putting-onu-in-disabled-state',
+ onu_serial_number=onu_device.serial_number)
- #Port and logical port update is taken care of by oper state block
+ # Port and logical port update is taken care of by oper state block
elif onu_indication.admin_state == 'up':
if onu_device.admin_state != AdminState.ENABLED:
onu_device.admin_state = AdminState.ENABLED
self.adapter_agent.update(onu_device)
- self.log.debug('putting-onu-in-enabled-state', onu_serial_number=onu_device.serial_number)
+ self.log.debug('putting-onu-in-enabled-state',
+ onu_serial_number=onu_device.serial_number)
else:
- self.log.warn('Invalid-or-not-implemented-admin-state', received_admin_state=onu_indication.admin_state)
+ self.log.warn('Invalid-or-not-implemented-admin-state',
+ received_admin_state=onu_indication.admin_state)
self.log.debug('admin-state-dealt-with')
- #Operating state
+ # Operating state
if onu_indication.oper_state == 'down':
- #Move to discovered state
+ # Move to discovered state
self.log.debug('onu-oper-state-is-down')
if onu_device.oper_status != OperStatus.DISCOVERED:
onu_device.oper_status = OperStatus.DISCOVERED
self.adapter_agent.update_device(onu_device)
- #Set port oper state to Discovered
-
- self.onu_ports_down(onu_device, uni_no, uni_name, OperStatus.DISCOVERED)
+ # Set port oper state to Discovered
+ self.onu_ports_down(onu_device, uni_no, uni_name,
+ OperStatus.DISCOVERED)
elif onu_indication.oper_state == 'up':
if onu_device.oper_status != OperStatus.DISCOVERED:
- self.log.debug("ignore onu indication", intf_id=onu_indication.intf_id,
- onu_id=onu_indication.onu_id, state=onu_device.oper_status,
+ self.log.debug("ignore onu indication",
+ intf_id=onu_indication.intf_id,
+ onu_id=onu_indication.onu_id,
+ state=onu_device.oper_status,
msg_oper_state=onu_indication.oper_state)
return
- #Device was in Discovered state, setting it to active
-
-
-
- onu_adapter_agent = registry('adapter_loader').get_agent(onu_device.adapter)
+ # Device was in Discovered state, setting it to active
+ onu_adapter_agent = \
+ registry('adapter_loader').get_agent(onu_device.adapter)
if onu_adapter_agent is None:
- self.log.error('onu_adapter_agent-could-not-be-retrieved', onu_device=onu_device)
+ self.log.error('onu_adapter_agent-could-not-be-retrieved',
+ onu_device=onu_device)
return
- #Prepare onu configuration
+ # Prepare onu configuration
# onu initialization, base configuration (bridge setup ...)
def onu_initialization():
- #FIXME: that's definitely cheating
+ # FIXME: that's definitely cheating
if onu_device.adapter == 'broadcom_onu':
- onu_adapter_agent.adapter.devices_handlers[onu_device.id].message_exchange()
+ onu_adapter_agent.adapter.devices_handlers[onu_device.id] \
+ .message_exchange()
self.log.debug('broadcom-message-exchange-started')
# tcont creation (onu)
@@ -435,12 +481,12 @@
gem_port = GemportsConfigData()
gem_port.gemport_id = platform.mk_gemport_id(onu_indication.onu_id)
- #ports creation/update
+ # ports creation/update
def port_config():
# "v_enet" creation (olt)
- #add_port update port when it exists
+ # add_port update port when it exists
self.adapter_agent.add_port(
self.device_id,
Port(
@@ -464,14 +510,17 @@
# FIXME : the asynchronicity has to be taken care of properly
onu_initialization()
- reactor.callLater(10, onu_adapter_agent.create_tcont, device=onu_device,
- tcont_data=tcont, traffic_descriptor_data=None)
- reactor.callLater(11, onu_adapter_agent.create_gemport, onu_device, gem_port)
+ reactor.callLater(10, onu_adapter_agent.create_tcont,
+ device=onu_device, tcont_data=tcont,
+ traffic_descriptor_data=None)
+ reactor.callLater(11, onu_adapter_agent.create_gemport, onu_device,
+ gem_port)
reactor.callLater(12, port_config)
reactor.callLater(12, onu_update_oper_status)
else:
- self.log.warn('Not-implemented-or-invalid-value-of-oper-state', oper_state=onu_indication.oper_state)
+ self.log.warn('Not-implemented-or-invalid-value-of-oper-state',
+ oper_state=onu_indication.oper_state)
def onu_ports_down(self, onu_device, uni_no, uni_name, oper_state):
# Set port oper state to Discovered
@@ -492,42 +541,48 @@
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,
+ 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 = 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.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)
+ 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 omci_indication(self, omci_indication):
self.log.debug("omci indication", intf_id=omci_indication.intf_id,
- onu_id=omci_indication.onu_id)
+ onu_id=omci_indication.onu_id)
- onu_device = self.adapter_agent.get_child_device(self.device_id,
- onu_id=omci_indication.onu_id)
+ onu_device = self.adapter_agent.get_child_device(
+ self.device_id, onu_id=omci_indication.onu_id)
self.adapter_agent.receive_proxied_message(onu_device.proxy_address,
- omci_indication.pkt)
+ omci_indication.pkt)
def packet_indication(self, pkt_indication):
self.log.debug("packet indication", intf_id=pkt_indication.intf_id,
- gemport_id=pkt_indication.gemport_id,
- flow_id=pkt_indication.flow_id)
+ gemport_id=pkt_indication.gemport_id,
+ flow_id=pkt_indication.flow_id)
onu_id = platform.onu_id_from_gemport_id(pkt_indication.gemport_id)
- logical_port_num = platform.mk_uni_port_num(pkt_indication.intf_id, onu_id)
+ logical_port_num = platform.mk_uni_port_num(pkt_indication.intf_id,
+ onu_id)
pkt = Ether(pkt_indication.pkt)
kw = dict(logical_device_id=self.logical_device_id,
- logical_port_no=logical_port_num)
+ logical_port_no=logical_port_num)
self.adapter_agent.send_packet_in(packet=str(pkt), **kw)
def olt_reachable(self):
@@ -538,35 +593,42 @@
def heartbeat(self):
- self.channel_ready_future.result() # blocks till gRPC connection is complete
+ # block till gRPC connection is complete
+ self.channel_ready_future.result()
while self.heartbeat_thread_active:
try:
- heartbeat = self.stub.HeartbeatCheck(openolt_pb2.Empty(), timeout=GRPC_TIMEOUT)
+ heartbeat = self.stub.HeartbeatCheck(openolt_pb2.Empty(),
+ timeout=GRPC_TIMEOUT)
except Exception as e:
self.heartbeat_miss += 1
- self.log.warn('heartbeat-miss', missed_heartbeat=self.heartbeat_miss, error=e)
+ self.log.warn('heartbeat-miss',
+ missed_heartbeat=self.heartbeat_miss, error=e)
if self.heartbeat_miss == MAX_HEARTBEAT_MISS:
self.log.error('lost-connectivity-to-olt')
- #TODO : send alarm/notify monitoring system
+ # TODO : send alarm/notify monitoring system
# Using reactor to synchronize update
# flagging it as unreachable and in unknow state
- reactor.callFromThread(self.olt_down, oper_state=OperStatus.UNKNOWN,
- connect_state=ConnectStatus.UNREACHABLE)
+ reactor.callFromThread(
+ self.olt_down,
+ oper_state=OperStatus.UNKNOWN,
+ connect_state=ConnectStatus.UNREACHABLE)
else:
# heartbeat received
if self.heartbeat_signature is None:
# Initialize heartbeat signature
self.heartbeat_signature = heartbeat.heartbeat_signature
- self.log.debug('heartbeat-signature', device_id=self.device_id,
- heartbeat_signature=self.heartbeat_signature)
+ self.log.debug(
+ 'heartbeat-signature',
+ device_id=self.device_id,
+ heartbeat_signature=self.heartbeat_signature)
# Check if signature is different
if self.heartbeat_signature != heartbeat.heartbeat_signature:
# OLT has rebooted
self.log.warn('OLT-was-rebooted', device_id=self.device_id)
- #TODO: notify monitoring system
+ # TODO: notify monitoring system
self.heartbeat_signature = heartbeat.heartbeat_signature
else:
@@ -574,14 +636,15 @@
if self.heartbeat_miss > MAX_HEARTBEAT_MISS:
self.log.info('OLT-connection-restored')
- #TODO : suppress alarm/notify monitoring system
+ # TODO : suppress alarm/notify monitoring system
# flagging it as reachable again
reactor.callFromThread(self.olt_reachable)
if not self.indications_thread_active:
self.log.info('(re)starting-indications-thread')
# reset indications thread
- self.indications_thread = threading.Thread(target=self.process_indications)
+ self.indications_thread = threading.Thread(
+ target=self.process_indications)
self.indications_thread.setDaemon(True)
self.indications_thread_active = True
self.indications_thread.start()
@@ -592,13 +655,10 @@
self.log.debug('stopping-heartbeat-thread', device_id=self.device_id)
-
-
def packet_out(self, egress_port, msg):
pkt = Ether(msg)
self.log.info('packet out', egress_port=egress_port,
- packet=str(pkt).encode("HEX"))
-
+ packet=str(pkt).encode("HEX"))
# Find port type
egress_port_type = self.port_type(egress_port)
@@ -620,50 +680,59 @@
send_pkt = binascii.unhexlify(str(payload).encode("HEX"))
- self.log.info('sending-packet-to-ONU', egress_port=egress_port,
- intf_id=platform.intf_id_from_pon_port_no(egress_port),
- onu_id=platform.onu_id_from_port_num(egress_port),
- packet=str(payload).encode("HEX"))
+ self.log.info(
+ 'sending-packet-to-ONU', egress_port=egress_port,
+ intf_id=platform.intf_id_from_pon_port_no(egress_port),
+ onu_id=platform.onu_id_from_port_num(egress_port),
+ packet=str(payload).encode("HEX"))
- onu_pkt = openolt_pb2.OnuPacket(intf_id=platform.intf_id_from_pon_port_no(egress_port),
- onu_id=platform.onu_id_from_port_num(egress_port), pkt=send_pkt)
+ onu_pkt = openolt_pb2.OnuPacket(
+ intf_id=platform.intf_id_from_pon_port_no(egress_port),
+ onu_id=platform.onu_id_from_port_num(egress_port),
+ pkt=send_pkt)
self.stub.OnuPacketOut(onu_pkt)
elif egress_port_type == Port.ETHERNET_NNI:
- self.log.info('sending-packet-to-uplink', egress_port=egress_port, packet=str(pkt).encode("HEX"))
+ self.log.info('sending-packet-to-uplink', egress_port=egress_port,
+ packet=str(pkt).encode("HEX"))
send_pkt = binascii.unhexlify(str(pkt).encode("HEX"))
- uplink_pkt = openolt_pb2.UplinkPacket(intf_id=platform.intf_id_from_nni_port_num(egress_port), pkt=send_pkt)
+ uplink_pkt = openolt_pb2.UplinkPacket(
+ intf_id=platform.intf_id_from_nni_port_num(egress_port),
+ pkt=send_pkt)
self.stub.UplinkPacketOut(uplink_pkt)
else:
- self.log.warn('Packet-out-to-this-interface-type-not-implemented', egress_port=egress_port,
+ self.log.warn('Packet-out-to-this-interface-type-not-implemented',
+ egress_port=egress_port,
port_type=egress_port_type)
def send_proxied_message(self, proxy_address, msg):
- omci = openolt_pb2.OmciMsg(intf_id=proxy_address.channel_id, # intf_id
- onu_id=proxy_address.onu_id, pkt=str(msg))
+ omci = openolt_pb2.OmciMsg(intf_id=proxy_address.channel_id,
+ onu_id=proxy_address.onu_id, pkt=str(msg))
self.stub.OmciMsgOut(omci)
def add_onu_device(self, intf_id, port_no, onu_id, serial_number):
self.log.info("Adding ONU", port_no=port_no, onu_id=onu_id,
- serial_number=serial_number)
+ serial_number=serial_number)
# NOTE - channel_id of onu is set to intf_id
proxy_address = Device.ProxyAddress(device_id=self.device_id,
- channel_id=intf_id, onu_id=onu_id, onu_session_id=onu_id)
+ channel_id=intf_id, onu_id=onu_id,
+ onu_session_id=onu_id)
self.log.info("Adding ONU", proxy_address=proxy_address)
serial_number_str = self.stringify_serial_number(serial_number)
- self.adapter_agent.add_onu_device(parent_device_id=self.device_id,
- parent_port_no=port_no, vendor_id=serial_number.vendor_id,
- proxy_address=proxy_address, root=True,
- serial_number=serial_number_str, admin_state=AdminState.ENABLED)
+ self.adapter_agent.add_onu_device(
+ parent_device_id=self.device_id, parent_port_no=port_no,
+ vendor_id=serial_number.vendor_id, proxy_address=proxy_address,
+ root=True, serial_number=serial_number_str,
+ admin_state=AdminState.ENABLED)
def port_name(self, port_no, port_type, intf_id=None, serial_number=None):
if port_type is Port.ETHERNET_NNI:
@@ -676,7 +745,6 @@
else:
return "uni-{}".format(port_no)
-
def port_type(self, port_no):
ports = self.adapter_agent.get_ports(self.device_id)
for port in ports:
@@ -684,7 +752,6 @@
return port.type
return None
-
def add_logical_port(self, port_no, intf_id, oper_state):
self.log.info('adding-logical-port', port_no=port_no)
@@ -699,17 +766,19 @@
else:
of_oper_state = OFPPS_LINK_DOWN
- ofp = ofp_port(port_no=port_no,
- hw_addr=mac_str_to_tuple('00:00:00:00:00:%02x' % port_no),
- name=label, config=0, state=of_oper_state, curr=cap,
- advertised=cap, peer=cap, curr_speed=curr_speed,
- max_speed=max_speed)
+ ofp = ofp_port(
+ port_no=port_no,
+ hw_addr=mac_str_to_tuple('00:00:00:00:00:%02x' % port_no),
+ name=label, config=0, state=of_oper_state, curr=cap,
+ advertised=cap, peer=cap, curr_speed=curr_speed,
+ max_speed=max_speed)
- logical_port = LogicalPort(id=label, ofp_port=ofp,
- device_id=self.device_id, device_port_no=port_no,
- root_port=True)
+ logical_port = LogicalPort(
+ id=label, ofp_port=ofp, device_id=self.device_id,
+ device_port_no=port_no, root_port=True)
- self.adapter_agent.add_logical_port(self.logical_device_id, logical_port)
+ self.adapter_agent.add_logical_port(self.logical_device_id,
+ logical_port)
def add_port(self, intf_id, port_type, oper_status):
port_no = platform.intf_id_to_port_no(intf_id, port_type)
@@ -717,10 +786,10 @@
label = self.port_name(port_no, port_type, intf_id)
self.log.info('adding-port', port_no=port_no, label=label,
- port_type=port_type)
+ port_type=port_type)
port = Port(port_no=port_no, label=label, type=port_type,
- admin_state=AdminState.ENABLED, oper_status=oper_status)
+ admin_state=AdminState.ENABLED, oper_status=oper_status)
self.adapter_agent.add_port(self.device_id, port)
@@ -742,16 +811,15 @@
def stringify_vendor_specific(self, vendor_specific):
return ''.join(str(i) for i in [
- hex(ord(vendor_specific[0])>>4 & 0x0f)[2:],
+ hex(ord(vendor_specific[0]) >> 4 & 0x0f)[2:],
hex(ord(vendor_specific[0]) & 0x0f)[2:],
- hex(ord(vendor_specific[1])>>4 & 0x0f)[2:],
+ hex(ord(vendor_specific[1]) >> 4 & 0x0f)[2:],
hex(ord(vendor_specific[1]) & 0x0f)[2:],
- hex(ord(vendor_specific[2])>>4 & 0x0f)[2:],
+ hex(ord(vendor_specific[2]) >> 4 & 0x0f)[2:],
hex(ord(vendor_specific[2]) & 0x0f)[2:],
- hex(ord(vendor_specific[3])>>4 & 0x0f)[2:],
+ hex(ord(vendor_specific[3]) >> 4 & 0x0f)[2:],
hex(ord(vendor_specific[3]) & 0x0f)[2:]])
-
def update_flow_table(self, flows):
device = self.adapter_agent.get_device(self.device_id)
self.log.debug('update flow table')
@@ -761,8 +829,8 @@
is_down_stream = None
in_port = fd.get_in_port(flow)
assert in_port is not None
- # Right now there is only one NNI port. Get the NNI PORT and compare
- # with IN_PUT port number. Need to find better way.
+ # Right now there is only one NNI port. Get the NNI PORT and
+ # compare with IN_PUT port number. Need to find better way.
ports = self.adapter_agent.get_ports(device.id, Port.ETHERNET_NNI)
for port in ports:
@@ -778,7 +846,8 @@
try:
self.flow_mgr.add_flow(flow, is_down_stream)
except Exception as e:
- self.log.exception('failed-to-install-flow', e=e, flow=flow)
+ self.log.exception('failed-to-install-flow', e=e,
+ flow=flow)
# There has to be a better way to do this
def ip_hex(self, ip):
@@ -793,20 +862,23 @@
def stringify_serial_number(self, serial_number):
return ''.join([serial_number.vendor_id,
- self.stringify_vendor_specific(serial_number.vendor_specific)])
+ self.stringify_vendor_specific(
+ serial_number.vendor_specific)])
def disable(self):
- self.log.info('sending-deactivate-olt-message', device_id=self.device_id)
+ self.log.info('sending-deactivate-olt-message',
+ device_id=self.device_id)
# Send grpc call
- #self.stub.DeactivateOlt(openolt_pb2.Empty())
+ # self.stub.DeactivateOlt(openolt_pb2.Empty())
- # Soft deactivate. Turning down hardware should remove flows, but we are not doing that presently
+ # Soft deactivate. Turning down hardware should remove flows,
+ # but we are not doing that presently
# Bring OLT down
- self.olt_down(oper_state=OperStatus.UNKNOWN, admin_state=AdminState.DISABLED,
- connect_state = ConnectStatus.UNREACHABLE)
-
+ self.olt_down(oper_state=OperStatus.UNKNOWN,
+ admin_state=AdminState.DISABLED,
+ connect_state=ConnectStatus.UNREACHABLE)
def delete(self):
self.log.info('delete-olt', device_id=self.device_id)
@@ -831,8 +903,9 @@
# Enable all child devices
self.log.info('enabling-child-devices', device_id=self.device_id)
self.log.info('enabling-child-devices', olt_device_id=self.device_id)
- self.adapter_agent.update_child_devices_state(parent_device_id=self.device_id,
- admin_state=AdminState.ENABLED)
+ self.adapter_agent.update_child_devices_state(
+ parent_device_id=self.device_id,
+ admin_state=AdminState.ENABLED)
# Set all ports to enabled
self.log.info('enabling-all-ports', device_id=self.device_id)
diff --git a/voltha/adapters/openolt/openolt_flow_mgr.py b/voltha/adapters/openolt/openolt_flow_mgr.py
index 367525e..063101b 100644
--- a/voltha/adapters/openolt/openolt_flow_mgr.py
+++ b/voltha/adapters/openolt/openolt_flow_mgr.py
@@ -14,21 +14,20 @@
# limitations under the License.
#
-import time
-
from voltha.protos.openflow_13_pb2 import OFPXMC_OPENFLOW_BASIC
import voltha.core.flow_decomposer as fd
import openolt_platform as platform
from voltha.adapters.openolt.protos import openolt_pb2
-HSIA_FLOW_INDEX = 0 # FIXME
-DHCP_FLOW_INDEX = 1 # FIXME
-EAPOL_FLOW_INDEX = 2 # FIXME
-EAPOL_DOWNLINK_FLOW_INDEX = 3 # FIXME
+HSIA_FLOW_INDEX = 0 # FIXME
+DHCP_FLOW_INDEX = 1 # FIXME
+EAPOL_FLOW_INDEX = 2 # FIXME
+EAPOL_DOWNLINK_FLOW_INDEX = 3 # FIXME
# FIXME - see also BRDCM_DEFAULT_VLAN in broadcom_onu.py
DEFAULT_MGMT_VLAN = 4091
+
class OpenOltFlowMgr(object):
def __init__(self, log, stub):
@@ -47,43 +46,43 @@
if field.type == fd.ETH_TYPE:
classifier_info['eth_type'] = field.eth_type
self.log.debug('field-type-eth-type',
- eth_type=classifier_info['eth_type'])
+ eth_type=classifier_info['eth_type'])
elif field.type == fd.IP_PROTO:
classifier_info['ip_proto'] = field.ip_proto
self.log.debug('field-type-ip-proto',
- ip_proto=classifier_info['ip_proto'])
+ ip_proto=classifier_info['ip_proto'])
elif field.type == fd.IN_PORT:
classifier_info['in_port'] = field.port
self.log.debug('field-type-in-port',
- in_port=classifier_info['in_port'])
+ in_port=classifier_info['in_port'])
elif field.type == fd.VLAN_VID:
classifier_info['vlan_vid'] = field.vlan_vid & 0xfff
self.log.debug('field-type-vlan-vid',
- vlan=classifier_info['vlan_vid'])
+ vlan=classifier_info['vlan_vid'])
elif field.type == fd.VLAN_PCP:
classifier_info['vlan_pcp'] = field.vlan_pcp
self.log.debug('field-type-vlan-pcp',
- pcp=classifier_info['vlan_pcp'])
+ pcp=classifier_info['vlan_pcp'])
elif field.type == fd.UDP_DST:
classifier_info['udp_dst'] = field.udp_dst
self.log.debug('field-type-udp-dst',
- udp_dst=classifier_info['udp_dst'])
+ udp_dst=classifier_info['udp_dst'])
elif field.type == fd.UDP_SRC:
classifier_info['udp_src'] = field.udp_src
self.log.debug('field-type-udp-src',
- udp_src=classifier_info['udp_src'])
+ udp_src=classifier_info['udp_src'])
elif field.type == fd.IPV4_DST:
classifier_info['ipv4_dst'] = field.ipv4_dst
self.log.debug('field-type-ipv4-dst',
- ipv4_dst=classifier_info['ipv4_dst'])
+ ipv4_dst=classifier_info['ipv4_dst'])
elif field.type == fd.IPV4_SRC:
classifier_info['ipv4_src'] = field.ipv4_src
self.log.debug('field-type-ipv4-src',
- ipv4_dst=classifier_info['ipv4_src'])
+ ipv4_dst=classifier_info['ipv4_src'])
elif field.type == fd.METADATA:
classifier_info['metadata'] = field.table_metadata
self.log.debug('field-type-metadata',
- metadata=classifier_info['metadata'])
+ metadata=classifier_info['metadata'])
else:
raise NotImplementedError('field.type={}'.format(
field.type))
@@ -92,8 +91,8 @@
if action.type == fd.OUTPUT:
action_info['output'] = action.output.port
self.log.debug('action-type-output',
- output=action_info['output'],
- in_port=classifier_info['in_port'])
+ output=action_info['output'],
+ in_port=classifier_info['in_port'])
elif action.type == fd.POP_VLAN:
action_info['pop_vlan'] = True
self.log.debug('action-type-pop-vlan', in_port=in_port)
@@ -101,34 +100,37 @@
action_info['push_vlan'] = True
action_info['tpid'] = action.push.ethertype
self.log.debug('action-type-push-vlan',
- push_tpid=action_info['tpid'], in_port=in_port)
+ push_tpid=action_info['tpid'], in_port=in_port)
if action.push.ethertype != 0x8100:
self.log.error('unhandled-tpid',
- ethertype=action.push.ethertype)
+ ethertype=action.push.ethertype)
elif action.type == fd.SET_FIELD:
# action_info['action_type'] = 'set_field'
_field = action.set_field.field.ofb_field
assert (action.set_field.field.oxm_class ==
OFPXMC_OPENFLOW_BASIC)
self.log.debug('action-type-set-field',
- field=_field, in_port=in_port)
+ field=_field, in_port=in_port)
if _field.type == fd.VLAN_VID:
self.log.debug('set-field-type-vlan-vid',
- vlan_vid=_field.vlan_vid & 0xfff)
+ vlan_vid=_field.vlan_vid & 0xfff)
action_info['vlan_vid'] = (_field.vlan_vid & 0xfff)
else:
self.log.error('unsupported-action-set-field-type',
- field_type=_field.type)
+ field_type=_field.type)
else:
self.log.error('unsupported-action-type',
- action_type=action.type, in_port=in_port)
+ action_type=action.type, in_port=in_port)
# FIXME - Why ignore downstream flows?
if is_down_stream is False:
- intf_id = platform.intf_id_from_uni_port_num(classifier_info['in_port'])
- onu_id = platform.onu_id_from_port_num(classifier_info['in_port'])
- self.divide_and_add_flow(intf_id, onu_id, classifier_info, action_info)
- #else:
+ intf_id = platform.intf_id_from_uni_port_num(
+ classifier_info['in_port'])
+ onu_id = platform.onu_id_from_port_num(
+ classifier_info['in_port'])
+ self.divide_and_add_flow(intf_id, onu_id, classifier_info,
+ action_info)
+ # else:
# self.log.info('ignore downstream flow', flow=flow,
# classifier_info=classifier_info,
# action_info=action_info)
@@ -144,8 +146,9 @@
elif classifier['ip_proto'] == 2:
self.log.debug('igmp flow add ignored')
else:
- self.log.debug("Invalid-Classifier-to-handle", classifier=classifier,
- action=action)
+ self.log.debug("Invalid-Classifier-to-handle",
+ classifier=classifier,
+ action=action)
elif 'eth_type' in classifier:
if classifier['eth_type'] == 0x888e:
self.log.debug('eapol flow add')
@@ -153,8 +156,9 @@
elif 'push_vlan' in action:
self.add_data_flow(intf_id, onu_id, classifier, action)
else:
- self.log.debug('Invalid-flow-type-to-handle', classifier=classifier,
- action=action)
+ self.log.debug('Invalid-flow-type-to-handle',
+ classifier=classifier,
+ action=action)
def add_data_flow(self, intf_id, onu_id, uplink_classifier, uplink_action):
@@ -173,27 +177,30 @@
# will take care of handling all the p bits.
# We need to revisit when mulitple gem port per p bits is needed.
self.add_hsia_flow(intf_id, onu_id, uplink_classifier, uplink_action,
- downlink_classifier, downlink_action, HSIA_FLOW_INDEX)
+ downlink_classifier, downlink_action,
+ HSIA_FLOW_INDEX)
def add_hsia_flow(self, intf_id, onu_id, uplink_classifier, uplink_action,
- downlink_classifier, downlink_action, hsia_id):
+ downlink_classifier, downlink_action, hsia_id):
gemport_id = platform.mk_gemport_id(onu_id)
flow_id = platform.mk_flow_id(intf_id, onu_id, hsia_id)
- self.log.debug('add upstream flow', onu_id=onu_id, classifier=uplink_classifier,
- action=uplink_action, gemport_id=gemport_id, flow_id=flow_id)
+ self.log.debug('add upstream flow', onu_id=onu_id,
+ classifier=uplink_classifier, action=uplink_action,
+ gemport_id=gemport_id, flow_id=flow_id)
flow = openolt_pb2.Flow(
- onu_id=onu_id, flow_id=flow_id, flow_type="upstream",
- access_intf_id=intf_id, gemport_id=gemport_id,
- classifier=self.mk_classifier(uplink_classifier), action=self.mk_action(uplink_action))
-
+ onu_id=onu_id, flow_id=flow_id, flow_type="upstream",
+ access_intf_id=intf_id, gemport_id=gemport_id,
+ classifier=self.mk_classifier(uplink_classifier),
+ action=self.mk_action(uplink_action))
self.stub.FlowAdd(flow)
self.log.debug('add downstream flow', classifier=downlink_classifier,
- action=downlink_action, gemport_id=gemport_id, flow_id=flow_id)
+ action=downlink_action, gemport_id=gemport_id,
+ flow_id=flow_id)
flow = openolt_pb2.Flow(
onu_id=onu_id, flow_id=flow_id, flow_type="downstream",
@@ -216,18 +223,20 @@
flow_id = platform.mk_flow_id(intf_id, onu_id, DHCP_FLOW_INDEX)
upstream_flow = openolt_pb2.Flow(
- onu_id=onu_id, flow_id=flow_id, flow_type="upstream",
- access_intf_id=intf_id, gemport_id=gemport_id,
- classifier=self.mk_classifier(classifier), action=self.mk_action(action))
+ onu_id=onu_id, flow_id=flow_id, flow_type="upstream",
+ access_intf_id=intf_id, gemport_id=gemport_id,
+ classifier=self.mk_classifier(classifier),
+ action=self.mk_action(action))
self.stub.FlowAdd(upstream_flow)
def add_eapol_flow(self, intf_id, onu_id, uplink_classifier, uplink_action,
- uplink_eapol_id=EAPOL_FLOW_INDEX,
- downlink_eapol_id=EAPOL_DOWNLINK_FLOW_INDEX,
- vlan_id=DEFAULT_MGMT_VLAN):
+ uplink_eapol_id=EAPOL_FLOW_INDEX,
+ downlink_eapol_id=EAPOL_DOWNLINK_FLOW_INDEX,
+ vlan_id=DEFAULT_MGMT_VLAN):
- self.log.debug('add eapol flow', classifier=uplink_classifier, action=uplink_action)
+ self.log.debug('add eapol flow', classifier=uplink_classifier,
+ action=uplink_action)
downlink_classifier = dict(uplink_classifier)
downlink_action = dict(uplink_action)
@@ -242,22 +251,24 @@
uplink_action['trap_to_host'] = True
upstream_flow = openolt_pb2.Flow(
- onu_id=onu_id, flow_id=uplink_flow_id, flow_type="upstream",
- access_intf_id=intf_id,gemport_id=gemport_id,
- classifier=self.mk_classifier(uplink_classifier), action=self.mk_action(uplink_action))
+ onu_id=onu_id, flow_id=uplink_flow_id, flow_type="upstream",
+ access_intf_id=intf_id, gemport_id=gemport_id,
+ classifier=self.mk_classifier(uplink_classifier),
+ action=self.mk_action(uplink_action))
self.stub.FlowAdd(upstream_flow)
# Add Downstream EAPOL Flow.
- downlink_flow_id = platform.mk_flow_id(intf_id, onu_id, downlink_eapol_id)
+ downlink_flow_id = platform.mk_flow_id(intf_id, onu_id,
+ downlink_eapol_id)
downlink_classifier['pkt_tag_type'] = 'single_tag'
downlink_classifier['vlan_vid'] = vlan_id
downstream_flow = openolt_pb2.Flow(
- onu_id=onu_id, flow_id=downlink_flow_id, flow_type="downstream",
- access_intf_id=intf_id, gemport_id=gemport_id,
- classifier=self.mk_classifier(downlink_classifier), action=self.mk_action(downlink_action))
-
+ onu_id=onu_id, flow_id=downlink_flow_id, flow_type="downstream",
+ access_intf_id=intf_id, gemport_id=gemport_id,
+ classifier=self.mk_classifier(downlink_classifier),
+ action=self.mk_action(downlink_action))
self.stub.FlowAdd(downstream_flow)
@@ -298,15 +309,15 @@
def mk_action(self, action_info):
action = openolt_pb2.Action()
- if 'pop_vlan' in action_info:
- action.o_vid = action_info['vlan_vid']
+ if 'pop_vlan' in action_info:
+ action.o_vid = action_info['vlan_vid']
action.cmd.remove_outer_tag = True
- elif 'push_vlan' in action_info:
- action.o_vid = action_info['vlan_vid']
+ elif 'push_vlan' in action_info:
+ action.o_vid = action_info['vlan_vid']
action.cmd.add_outer_tag = True
- elif 'trap_to_host' in action_info:
+ elif 'trap_to_host' in action_info:
action.cmd.trap_to_host = True
- else:
- self.log.info('Invalid-action-field')
- return
+ else:
+ self.log.info('Invalid-action-field')
+ return
return action
diff --git a/voltha/adapters/openolt/openolt_platform.py b/voltha/adapters/openolt/openolt_platform.py
index 581c15d..d1d7c92 100644
--- a/voltha/adapters/openolt/openolt_platform.py
+++ b/voltha/adapters/openolt/openolt_platform.py
@@ -92,40 +92,50 @@
"""
+
def mk_uni_port_num(intf_id, onu_id):
return intf_id << 11 | onu_id << 4
+
def mk_alloc_id(onu_id, idx=0):
# FIXME - driver should do prefixing 1 << 10 as it is Maple specific
- #return 1<<10 | onu_id<<6 | idx
- return 1023 + onu_id # FIXME
+ # return 1<<10 | onu_id<<6 | idx
+ return 1023 + onu_id # FIXME
+
def mk_gemport_id(onu_id, idx=0):
- return 1<<10 | onu_id<<3 | idx
+ return 1 << 10 | onu_id << 3 | idx
+
def onu_id_from_gemport_id(gemport_id):
- return (gemport_id & ~(1<<10)) >> 3
+ return (gemport_id & ~(1 << 10)) >> 3
+
def mk_flow_id(intf_id, onu_id, idx):
- return intf_id<<11 | onu_id<<4 | idx
+ return intf_id << 11 | onu_id << 4 | idx
+
def onu_id_from_port_num(port_num):
return (port_num >> 4) & 0x7F
+
def intf_id_from_uni_port_num(port_num):
return (port_num >> 11) & 0xF
+
def intf_id_from_pon_port_no(port_no):
return port_no & 0xF
+
def intf_id_to_port_no(intf_id, intf_type):
if intf_type is Port.ETHERNET_NNI:
# FIXME - Remove hardcoded '128'
return intf_id + 128
elif intf_type is Port.PON_OLT:
- return 0x2<<28 | intf_id
+ return 0x2 << 28 | intf_id
else:
raise Exception('Invalid port type')
+
def intf_id_from_nni_port_num(port_num):
return port_num - 128