def do_state_init(self, event): # Initialize gRPC self.channel = grpc.insecure_channel(self.host_and_port) self.channel_ready_future = grpc.channel_ready_future(self.channel) self.alarm_mgr = OpenOltAlarmMgr(self.log, self.adapter_agent, self.device_id, self.logical_device_id) self.stats_mgr = OpenOltStatisticsMgr(self, self.log) self.bw_mgr = OpenOltBW(self.log, self.proxy) self.log.info('openolt-device-created', device_id=self.device_id)
def do_state_connected(self, event): self.log.debug("do_state_connected") device = self.adapter_agent.get_device(self.device_id) device.connect_status = ConnectStatus.REACHABLE self.adapter_agent.update_device(device) self.stub = openolt_pb2_grpc.OpenoltStub(self.channel) self.flow_mgr = OpenOltFlowMgr(self.log, self.stub, self.device_id) self.alarm_mgr = OpenOltAlarmMgr(self.log, self.adapter_agent, self.device_id, self.logical_device_id) self.stats_mgr = OpenOltStatisticsMgr(self, self.log) self.bw_mgr = OpenOltBW(self.log, self.proxy)
class OpenoltDevice(object): """ OpenoltDevice state machine: null ----> init ------> connected -----> up -----> down ^ ^ | ^ | | | | | | | | | +-------------+ +---------+ | | | +-----------------------------------------+ """ # pylint: disable=too-many-instance-attributes # pylint: disable=R0904 states = [ 'state_null', 'state_init', 'state_connected', 'state_up', 'state_down' ] transitions = [{ 'trigger': 'go_state_init', 'source': ['state_null', 'state_connected', 'state_down'], 'dest': 'state_init', 'before': 'do_state_init', 'after': 'post_init' }, { 'trigger': 'go_state_connected', 'source': 'state_init', 'dest': 'state_connected', 'before': 'do_state_connected' }, { 'trigger': 'go_state_up', 'source': ['state_connected', 'state_down'], 'dest': 'state_up', 'before': 'do_state_up' }, { 'trigger': 'go_state_down', 'source': ['state_up'], 'dest': 'state_down', 'before': 'do_state_down', 'after': 'post_down' }] def __init__(self, **kwargs): super(OpenoltDevice, self).__init__() self.adapter_agent = kwargs['adapter_agent'] self.device_num = kwargs['device_num'] device = kwargs['device'] is_reconciliation = kwargs.get('reconciliation', False) self.device_id = device.id self.host_and_port = device.host_and_port self.extra_args = device.extra_args 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 if not is_reconciliation: # It is a new device # Update device device.root = True device.serial_number = self.host_and_port # FIXME device.connect_status = ConnectStatus.UNREACHABLE device.oper_status = OperStatus.ACTIVATING self.adapter_agent.update_device(device) # If logical device does not exist create it if not device.parent_id: dpid = '00:00:' + self.ip_hex(self.host_and_port.split(":")[0]) # Create logical OF device ld = LogicalDevice( root_device_id=self.device_id, 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)), desc=ofp_desc(serial_num=device.serial_number)) 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 if is_reconciliation: self.adapter_agent.reconcile_logical_device( self.logical_device_id) # Initialize the OLT state machine self.machine = Machine(model=self, states=OpenoltDevice.states, transitions=OpenoltDevice.transitions, send_event=True, initial='state_null') self.go_state_init() def do_state_init(self, event): # Initialize gRPC self.channel = grpc.insecure_channel(self.host_and_port) self.channel_ready_future = grpc.channel_ready_future(self.channel) self.alarm_mgr = OpenOltAlarmMgr(self.log, self.adapter_agent, self.device_id, self.logical_device_id) self.stats_mgr = OpenOltStatisticsMgr(self, self.log) self.bw_mgr = OpenOltBW(self.log, self.proxy) self.log.info('openolt-device-created', device_id=self.device_id) def post_init(self, event): self.log.debug('post_init') # We have reached init state, starting the indications thread # Catch RuntimeError exception try: # Start indications thread self.indications_thread_handle = threading.Thread( target=self.indications_thread) # Old getter/setter API for daemon; use it directly as a # property instead. The Jinkins error will happon on the reason of # Exception in thread Thread-1 (most likely raised # during # interpreter shutdown) self.indications_thread_handle.setDaemon(True) self.indications_thread_handle.start() except Exception as e: self.log.exception('post_init failed', e=e) @inlineCallbacks def do_state_connected(self, event): self.log.debug("do_state_connected") device = self.adapter_agent.get_device(self.device_id) self.stub = openolt_pb2_grpc.OpenoltStub(self.channel) device_info = self.stub.GetDeviceInfo(openolt_pb2.Empty()) self.log.info('Device connected', device_info=device_info) device.vendor = device_info.vendor device.model = device_info.model device.hardware_version = device_info.hardware_version device.firmware_version = device_info.firmware_version self.resource_manager = OpenOltResourceMgr(self.device_id, self.host_and_port, self.extra_args, device_info) self.flow_mgr = OpenOltFlowMgr(self.log, self.stub, self.device_id, self.logical_device_id, self.resource_manager) yield self._initialize_resource_manager_resource_pools() # TODO: check for uptime and reboot if too long (VOL-1192) device.connect_status = ConnectStatus.REACHABLE self.adapter_agent.update_device(device) def do_state_up(self, event): self.log.debug("do_state_up") device = self.adapter_agent.get_device(self.device_id) # Update phys OF device device.parent_id = self.logical_device_id device.oper_status = OperStatus.ACTIVE self.adapter_agent.update_device(device) def do_state_down(self, event): self.log.debug("do_state_down") oper_state = OperStatus.UNKNOWN connect_state = ConnectStatus.UNREACHABLE # Propagating to the children # 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) if onu_device.adapter == 'brcm_openomci_onu': self.log.debug('using-brcm_openomci_onu, update_interface ' 'down') onu_adapter_agent = \ registry('adapter_loader').get_agent(onu_device.adapter) onu_adapter_agent.update_interface(onu_device, {'oper_state': 'down'}) self.onu_ports_down(onu_device, uni_no, uni_name, oper_state) # Children devices self.adapter_agent.update_child_devices_state( self.device_id, oper_status=oper_state, connect_status=connect_state) # Device Ports 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) for port in device_ports: port.oper_status = oper_state self.adapter_agent.add_port(self.device_id, port) # 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.ofp_port.state = OFPPS_LINK_DOWN self.adapter_agent.update_logical_port(self.logical_device_id, logical_port) # Device device = self.adapter_agent.get_device(self.device_id) device.oper_status = oper_state device.connect_status = connect_state reactor.callLater(2, self.adapter_agent.update_device, device) # def post_up(self, event): # self.log.debug('post-up') # self.flow_mgr.reseed_flows() def post_down(self, event): self.log.debug('post_down') self.flow_mgr.reset_flows() def indications_thread(self): self.log.debug('starting-indications-thread') self.log.debug('connecting to olt', device_id=self.device_id) self.channel_ready_future.result() # blocking call self.log.info('connected to olt', device_id=self.device_id) self.go_state_connected() self.indications = self.stub.EnableIndication(openolt_pb2.Empty()) while True: try: # get the next indication from olt ind = next(self.indications) except Exception as e: self.log.warn('gRPC connection lost', error=e) reactor.callFromThread(self.go_state_down) reactor.callFromThread(self.go_state_init) break else: self.log.debug("rx indication", indication=ind) # indication handlers run in the main event loop if ind.HasField('olt_ind'): reactor.callFromThread(self.olt_indication, ind.olt_ind) 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) elif ind.HasField('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'): reactor.callFromThread(self.omci_indication, ind.omci_ind) elif ind.HasField('pkt_ind'): reactor.callFromThread(self.packet_indication, ind.pkt_ind) elif ind.HasField('port_stats'): reactor.callFromThread( self.stats_mgr.port_statistics_indication, ind.port_stats) elif ind.HasField('flow_stats'): reactor.callFromThread( self.stats_mgr.flow_statistics_indication, ind.flow_stats) elif ind.HasField('alarm_ind'): reactor.callFromThread(self.alarm_mgr.process_alarms, ind.alarm_ind) else: self.log.warn('unknown indication type') def olt_indication(self, olt_indication): if olt_indication.oper_state == "up": self.go_state_up() elif olt_indication.oper_state == "down": self.go_state_down() def intf_indication(self, intf_indication): self.log.debug("intf indication", intf_id=intf_indication.intf_id, oper_state=intf_indication.oper_state) if intf_indication.oper_state == "up": oper_status = OperStatus.ACTIVE else: oper_status = OperStatus.DISCOVERED # add_port update the port if it exists 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) if intf_oper_indication.oper_state == "up": oper_state = OperStatus.ACTIVE else: oper_state = OperStatus.DISCOVERED if intf_oper_indication.type == "nni": # FIXME - creating logical port for 2nd interface throws exception! if intf_oper_indication.intf_id != 0: 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) 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) elif intf_oper_indication.type == "pon": # FIXME - handle PON oper state change pass @inlineCallbacks def onu_discovery_indication(self, onu_disc_indication): intf_id = onu_disc_indication.intf_id 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) # Post ONU Discover alarm 20180809_0805 try: OnuDiscoveryAlarm(self.alarm_mgr.alarms, pon_id=intf_id, serial_number=serial_number_str).raise_alarm() except Exception as disc_alarm_error: self.log.exception("onu-discovery-alarm-error", errmsg=disc_alarm_error.message) # continue for now. onu_device = self.adapter_agent.get_child_device( self.device_id, serial_number=serial_number_str) if onu_device is None: try: onu_id = yield self.resource_manager.get_resource_id( intf_id, PONResourceManager.ONU_ID) if onu_id is None: raise Exception("onu-id-unavailable") pon_intf_onu_id = (intf_id, onu_id) self.resource_manager.init_resource_store(pon_intf_onu_id) alloc_id = yield self.resource_manager.get_alloc_id( pon_intf_onu_id) if alloc_id is None: # Free up other PON resources if are unable to # proceed ahead self.resource_manager.free_resource_id( intf_id, PONResourceManager.ONU_ID, onu_id) raise Exception("alloc-id-unavailable") self.add_onu_device( intf_id, platform.intf_id_to_port_no(intf_id, Port.PON_OLT), onu_id, serial_number) # Use sched_id same as alloc_id for the ONU. self.activate_onu(intf_id, onu_id, serial_number, serial_number_str, alloc_id, alloc_id) except Exception as e: self.log.exception('onu-activation-failed', e=e) else: if onu_device.connect_status != ConnectStatus.REACHABLE: onu_device.connect_status = ConnectStatus.REACHABLE 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) elif onu_device.oper_status == OperStatus.UNKNOWN: self.log.info("onu in unknown state, recovering from olt \ reboot probably, 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) try: pon_intf_onu_id = (intf_id, onu_id) alloc_id = yield self.resource_manager.get_alloc_id( pon_intf_onu_id) # Use sched_id same as alloc_id for the ONU. self.activate_onu(intf_id, onu_id, serial_number, serial_number_str, alloc_id, alloc_id) except Exception as e: self.log.error('onu-activation-error', serial_number=serial_number_str, error=e) else: self.log.warn('unexpected state', onu_id=onu_id, onu_device_oper_state=onu_device.oper_status) @inlineCallbacks 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) try: serial_number_str = self.stringify_serial_number( onu_indication.serial_number) except Exception as e: serial_number_str = None if serial_number_str is not None: onu_device = self.adapter_agent.get_child_device( self.device_id, serial_number=serial_number_str) else: onu_device = self.adapter_agent.get_child_device( self.device_id, parent_port_no=platform.intf_id_to_port_no( onu_indication.intf_id, Port.PON_OLT), onu_id=onu_indication.onu_id) if onu_device is None: self.log.error('onu not found', intf_id=onu_indication.intf_id, onu_id=onu_indication.onu_id) return # We will use this alloc_id and gemport_id to pass on to the onu adapter pon_intf_onu_id = (onu_indication.intf_id, onu_indication.onu_id) alloc_id = yield self.resource_manager.get_alloc_id(pon_intf_onu_id) gemport_id = yield self.resource_manager.get_gemport_id( pon_intf_onu_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), 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, can happen if both voltha and ' 'the olt rebooted', 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) self.log.debug('port-number-ready', uni_no=uni_no, uni_name=uni_name) # 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) # Forcing the oper state change code to execute onu_indication.oper_state = 'down' # Port and logical port update is taken care of by oper state block elif onu_indication.admin_state == 'up': pass else: self.log.warn('Invalid-or-not-implemented-admin-state', received_admin_state=onu_indication.admin_state) self.log.debug('admin-state-dealt-with') 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) return # Operating state if onu_indication.oper_state == 'down': if onu_device.connect_status != ConnectStatus.UNREACHABLE: onu_device.connect_status = ConnectStatus.UNREACHABLE self.adapter_agent.update_device(onu_device) # 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) if onu_device.adapter == 'brcm_openomci_onu': self.log.debug('using-brcm_openomci_onu') onu_adapter_agent.update_interface(onu_device, {'oper_state': 'down'}) elif onu_indication.oper_state == 'up': if onu_device.connect_status != ConnectStatus.REACHABLE: onu_device.connect_status = ConnectStatus.REACHABLE self.adapter_agent.update_device(onu_device) 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, msg_oper_state=onu_indication.oper_state) return # Device was in Discovered state, setting it to active # Prepare onu configuration # If we are brcm_openomci adapter proceed if onu_device.adapter == 'brcm_openomci_onu': self.log.debug('using-brcm_openomci_onu') # tcont creation (onu) tcont = TcontsConfigData() tcont.alloc_id = alloc_id # gem port creation gem_port = GemportsConfigData() gem_port.gemport_id = gemport_id gem_port.tcont_ref = str(tcont.alloc_id) self.log.info('inject-tcont-gem-data-onu-handler', onu_indication=onu_indication, tcont=tcont, gem_port=gem_port) onu_adapter_agent.create_tcont(onu_device, tcont, traffic_descriptor_data=None) onu_adapter_agent.create_gemport(onu_device, gem_port) onu_adapter_agent.create_interface(onu_device, onu_indication) else: self.log.error('unsupported-openolt-onu-adapter', onu_adapter=onu_device.adapter) else: 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 # 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 omci_indication(self, omci_indication): self.log.debug("omci indication", intf_id=omci_indication.intf_id, onu_id=omci_indication.onu_id) onu_device = self.adapter_agent.get_child_device( self.device_id, onu_id=omci_indication.onu_id, parent_port_no=platform.intf_id_to_port_no(omci_indication.intf_id, Port.PON_OLT), ) self.adapter_agent.receive_proxied_message(onu_device.proxy_address, 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) onu_id = None pon_intf_gemport = (pkt_indication.intf_id, pkt_indication.gemport_id) try: onu_id = self.resource_manager.pon_intf_gemport_to_onu_id_map[ pon_intf_gemport] except KeyError: self.log.error("no-onu-reference-for-gem", gemport_id=pkt_indication.gemport_id) return 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) self.adapter_agent.send_packet_in(packet=str(pkt), **kw) def packet_out(self, egress_port, msg): pkt = Ether(msg) self.log.info('packet out', egress_port=egress_port, packet=str(pkt).encode("HEX")) # Find port type egress_port_type = self.port_type(egress_port) if egress_port_type == Port.ETHERNET_UNI: if pkt.haslayer(Dot1Q): outer_shim = pkt.getlayer(Dot1Q) if isinstance(outer_shim.payload, Dot1Q): # If double tag, remove the outer tag payload = ( Ether(src=pkt.src, dst=pkt.dst, type=outer_shim.type) / outer_shim.payload) else: payload = pkt else: payload = pkt send_pkt = binascii.unhexlify(str(payload).encode("HEX")) self.log.debug( 'sending-packet-to-ONU', egress_port=egress_port, intf_id=platform.intf_id_from_uni_port_num(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_uni_port_num(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.debug('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) self.stub.UplinkPacketOut(uplink_pkt) else: 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): onu_device = self.adapter_agent.get_child_device( self.device_id, onu_id=proxy_address.onu_id, parent_port_no=platform.intf_id_to_port_no( proxy_address.channel_id, Port.PON_OLT)) if onu_device.connect_status != ConnectStatus.REACHABLE: self.log.debug('ONU is not reachable, cannot send OMCI', serial_number=onu_device.serial_number, intf_id=onu_device.proxy_address.channel_id, onu_id=onu_device.proxy_address.onu_id) return 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) # 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) self.log.debug("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) def port_name(self, port_no, port_type, intf_id=None, serial_number=None): if port_type is Port.ETHERNET_NNI: return "nni-" + str(port_no) elif port_type is Port.PON_OLT: return "pon" + str(intf_id) elif port_type is Port.ETHERNET_UNI: if serial_number is not None: return serial_number 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: if port.port_no == port_no: 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) label = self.port_name(port_no, Port.ETHERNET_NNI) cap = OFPPF_1GB_FD | OFPPF_FIBER curr_speed = OFPPF_1GB_FD max_speed = OFPPF_1GB_FD if oper_state == OperStatus.ACTIVE: of_oper_state = OFPPS_LIVE else: of_oper_state = OFPPS_LINK_DOWN ofp = ofp_port(port_no=port_no, hw_addr=mac_str_to_tuple( self._get_mac_form_port_no(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_stats = ofp_port_stats(port_no=port_no) logical_port = LogicalPort(id=label, ofp_port=ofp, device_id=self.device_id, device_port_no=port_no, root_port=True, ofp_port_stats=ofp_stats) self.adapter_agent.add_logical_port(self.logical_device_id, logical_port) def _get_mac_form_port_no(self, port_no): mac = '' for i in range(4): mac = ':%02x' % ((port_no >> (i * 8)) & 0xff) + mac return '00:00' + mac def add_port(self, intf_id, port_type, oper_status): port_no = platform.intf_id_to_port_no(intf_id, port_type) label = self.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 delete_logical_port(self, child_device_id): logical_ports = self.proxy.get('/logical_devices/{}/ports'.format( self.logical_device_id)) for logical_port in logical_ports: if logical_port.device_id == child_device_id: self.log.debug('delete-logical-port', onu_device_id=child_device_id, logical_port=logical_port) self.adapter_agent.delete_logical_port(self.logical_device_id, logical_port) return def delete_port(self, child_serial_number): ports = self.proxy.get('/devices/{}/ports'.format(self.device_id)) for port in ports: if port.label == child_serial_number: self.log.debug('delete-port', onu_serial_number=child_serial_number, port=port) self.adapter_agent.delete_port(self.device_id, port) return def update_flow_table(self, flows): self.log.debug('No updates here now, all is done in logical flows ' 'update') def update_logical_flows(self, flows_to_add, flows_to_remove, device_rules_map): if not self.is_state_up(): self.log.info('The OLT is not up, we cannot update flows', flows_to_add=[f.id for f in flows_to_add], flows_to_remove=[f.id for f in flows_to_remove]) return try: self.flow_mgr.update_children_flows(device_rules_map) except Exception as e: self.log.error('Error updating children flows', error=e) self.log.debug('logical flows update', flows_to_add=flows_to_add, flows_to_remove=flows_to_remove) for flow in flows_to_add: try: self.flow_mgr.add_flow(flow) except Exception as e: self.log.error('failed to add flow', flow=flow, e=e) for flow in flows_to_remove: try: self.flow_mgr.remove_flow(flow) except Exception as e: self.log.error('failed to remove flow', flow=flow, e=e) self.flow_mgr.repush_all_different_flows() # There has to be a better way to do this def ip_hex(self, ip): octets = ip.split(".") hex_ip = [] for octet in octets: octet_hex = hex(int(octet)) octet_hex = octet_hex.split('0x')[1] octet_hex = octet_hex.rjust(2, '0') hex_ip.append(octet_hex) return ":".join(hex_ip) 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]) & 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]) & 0x0f)[2:], hex(ord(vendor_specific[3]) >> 4 & 0x0f)[2:], hex(ord(vendor_specific[3]) & 0x0f)[2:] ]) def stringify_serial_number(self, serial_number): return ''.join([ serial_number.vendor_id, self.stringify_vendor_specific(serial_number.vendor_specific) ]) def destringify_serial_number(self, serial_number_str): serial_number = openolt_pb2.SerialNumber( vendor_id=serial_number_str[:4].encode('utf-8'), vendor_specific=binascii.unhexlify(serial_number_str[4:])) return serial_number def disable(self): self.log.debug('sending-deactivate-olt-message', device_id=self.device_id) try: # Send grpc call self.stub.DisableOlt(openolt_pb2.Empty()) # The resulting indication will bring the OLT down # self.go_state_down() self.log.info('openolt device disabled') except Exception as e: self.log.error('Failure to disable openolt device', error=e) def delete(self): self.log.info('deleting-olt', device_id=self.device_id, logical_device_id=self.logical_device_id) # Removes all data from the resource manager KV store # for the device. self.resource_manager.clear_device_resource_pool() try: # Rebooting to reset the state self.reboot() # Removing logical device self.proxy.remove('/logical_devices/{}'.format( self.logical_device_id)) except Exception as e: self.log.error('Failure to delete openolt device', error=e) raise e else: self.log.info('successfully-deleted-olt', device_id=self.device_id) def reenable(self): self.log.debug('reenabling-olt', device_id=self.device_id) try: self.stub.ReenableOlt(openolt_pb2.Empty()) self.log.info('enabling-all-ports', device_id=self.device_id) self.adapter_agent.enable_all_ports(self.device_id) except Exception as e: self.log.error('Failure to reenable openolt device', error=e) else: self.log.info('openolt device reenabled') def activate_onu(self, intf_id, onu_id, serial_number, serial_number_str, agg_port_id, sched_id): pir = self.bw_mgr.pir(serial_number_str) self.log.debug("activating-onu", intf_id=intf_id, onu_id=onu_id, serial_number_str=serial_number_str, serial_number=serial_number, pir=pir) onu = openolt_pb2.Onu(intf_id=intf_id, onu_id=onu_id, serial_number=serial_number, pir=pir, agg_port_id=agg_port_id, sched_id=sched_id) self.stub.ActivateOnu(onu) self.log.info('onu-activated', serial_number=serial_number_str) @inlineCallbacks def delete_child_device(self, child_device): self.log.debug('sending-deactivate-onu', olt_device_id=self.device_id, onu_device=child_device, onu_serial_number=child_device.serial_number) try: self.adapter_agent.delete_child_device(self.device_id, child_device.id, child_device) except Exception as e: self.log.error('adapter_agent error', error=e) try: self.delete_logical_port(child_device.id) except Exception as e: self.log.error('logical_port delete error', error=e) try: self.delete_port(child_device.serial_number) except Exception as e: self.log.error('port delete error', error=e) serial_number = self.destringify_serial_number( child_device.serial_number) pon_intf_id_onu_id = (child_device.proxy_address.channel_id, child_device.proxy_address.onu_id) alloc_id = yield self.resource_manager.get_alloc_id(pon_intf_id_onu_id) # Use sched_id same as alloc_id for the Onu. onu = openolt_pb2.Onu(intf_id=child_device.proxy_address.channel_id, onu_id=child_device.proxy_address.onu_id, serial_number=serial_number, agg_port_id=alloc_id, sched_id=alloc_id) self.stub.DeleteOnu(onu) # Remove reference to (pon_intf_id, onu_id) from the dictionary # when ONU is being removed. del self.resource_manager.pon_intf_id_onu_id_to_resource_map[ pon_intf_id_onu_id] # Free any PON resources that were reserved for the ONU self.resource_manager.free_pon_resources_for_onu( child_device.proxy_address.channel_id, child_device.proxy_address.onu_id) def reboot(self): self.log.debug('rebooting openolt device', device_id=self.device_id) try: self.stub.Reboot(openolt_pb2.Empty()) except Exception as e: self.log.error('something went wrong with the reboot', error=e) else: self.log.info('device rebooted') def trigger_statistics_collection(self): try: self.stub.CollectStatistics(openolt_pb2.Empty()) except Exception as e: self.log.error('Error while triggering statistics collection', error=e) else: self.log.info('statistics requested') def simulate_alarm(self, alarm): self.alarm_mgr.simulate_alarm(alarm) @inlineCallbacks def _initialize_resource_manager_resource_pools(self): try: yield self.resource_manager.initialize_device_resource_range_and_pool( ) except Exception as e: # When resource manager initialization fails we can't proceed # further so, exiting without instantiating openolt adapter self.log.exception("Resource-manager-initialization-failed", e=e) sys.exit(1)
class OpenoltDevice(object): """ OpenoltDevice state machine: null ----> init ------> connected -----> up -----> down ^ ^ | ^ | | | | | | | | | +-------------+ +---------+ | | | +-----------------------------------------+ """ # pylint: disable=too-many-instance-attributes # pylint: disable=R0904 states = [ 'state_null', 'state_init', 'state_connected', 'state_up', 'state_down' ] transitions = [{ 'trigger': 'go_state_init', 'source': ['state_null', 'state_connected', 'state_down'], 'dest': 'state_init', 'before': 'do_state_init' }, { 'trigger': 'go_state_connected', 'source': 'state_init', 'dest': 'state_connected', 'before': 'do_state_connected' }, { 'trigger': 'go_state_up', 'source': ['state_connected', 'state_down'], 'dest': 'state_up', 'before': 'do_state_up' }, { 'trigger': 'go_state_down', 'source': ['state_up'], 'dest': 'state_down', 'before': 'do_state_down' }] def __init__(self, **kwargs): super(OpenoltDevice, self).__init__() self.adapter_agent = kwargs['adapter_agent'] self.device_num = kwargs['device_num'] device = kwargs['device'] 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.proxy = registry('core').get_proxy('/') # Device already set in the event of reconciliation if not is_reconciliation: # It is a new device # Update device device.root = True device.serial_number = self.host_and_port # FIXME device.connect_status = ConnectStatus.UNREACHABLE device.oper_status = OperStatus.ACTIVATING self.adapter_agent.update_device(device) # If logical device does not exist create it if not device.parent_id: dpid = '00:00:' + self.ip_hex(self.host_and_port.split(":")[0]) # Create logical OF device ld = LogicalDevice( root_device_id=self.device_id, 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)), desc=ofp_desc(serial_num=device.serial_number)) 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 if is_reconciliation: self.adapter_agent.reconcile_logical_device( self.logical_device_id) # Initialize the OLT state machine self.machine = Machine(model=self, states=OpenoltDevice.states, transitions=OpenoltDevice.transitions, send_event=True, initial='state_null') self.go_state_init() def do_state_init(self, event): # Initialize gRPC self.channel = grpc.insecure_channel(self.host_and_port) self.channel_ready_future = grpc.channel_ready_future(self.channel) # Catch RuntimeError exception try: # Start indications thread self.indications_thread_handle = threading.Thread( target=self.indications_thread) # Old getter/setter API for daemon; use it directly as a # property instead. The Jinkins error will happon on the reason of # Exception in thread Thread-1 (most likely raised # during # interpreter shutdown) self.indications_thread_handle.setDaemon(True) self.indications_thread_handle.start() except Exception as e: self.log.exception('do_state_init failed', e=e) ''' # FIXME - Move to oper_up state without connecting to OLT? if is_reconciliation: # Put state machine in state up reactor.callFromThread(self.go_state_up, reconciliation=True) ''' self.log.info('openolt-device-created', device_id=self.device_id) def do_state_connected(self, event): self.log.debug("do_state_connected") device = self.adapter_agent.get_device(self.device_id) device.connect_status = ConnectStatus.REACHABLE self.adapter_agent.update_device(device) self.stub = openolt_pb2_grpc.OpenoltStub(self.channel) self.flow_mgr = OpenOltFlowMgr(self.log, self.stub, self.device_id) self.alarm_mgr = OpenOltAlarmMgr(self.log, self.adapter_agent, self.device_id, self.logical_device_id) self.stats_mgr = OpenOltStatisticsMgr(self, self.log) self.bw_mgr = OpenOltBW(self.log, self.proxy) def do_state_up(self, event): self.log.debug("do_state_up") device = self.adapter_agent.get_device(self.device_id) # Update phys OF device device.parent_id = self.logical_device_id device.oper_status = OperStatus.ACTIVE self.adapter_agent.update_device(device) def do_state_down(self, event): self.log.debug("do_state_down") oper_state = OperStatus.UNKNOWN connect_state = ConnectStatus.UNREACHABLE # Propagating to the children # 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) self.onu_ports_down(onu_device, uni_no, uni_name, oper_state) # Children devices self.adapter_agent.update_child_devices_state( self.device_id, oper_status=oper_state, connect_status=connect_state) # Device Ports 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) for port in device_ports: port.oper_status = oper_state self.adapter_agent.add_port(self.device_id, port) # 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.ofp_port.state = OFPPS_LINK_DOWN self.adapter_agent.update_logical_port(self.logical_device_id, logical_port) # Device device = self.adapter_agent.get_device(self.device_id) device.oper_status = oper_state device.connect_status = connect_state self.adapter_agent.update_device(device) def indications_thread(self): self.log.debug('starting-indications-thread') self.log.debug('connecting to olt', device_id=self.device_id) self.channel_ready_future.result() # blocking call self.log.info('connected to olt', device_id=self.device_id) self.go_state_connected() self.indications = self.stub.EnableIndication(openolt_pb2.Empty()) while True: try: # get the next indication from olt ind = next(self.indications) except Exception as e: self.log.warn('gRPC connection lost', error=e) reactor.callFromThread(self.go_state_down) reactor.callFromThread(self.go_state_init) break else: self.log.debug("rx indication", indication=ind) # indication handlers run in the main event loop if ind.HasField('olt_ind'): reactor.callFromThread(self.olt_indication, ind.olt_ind) 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) elif ind.HasField('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'): reactor.callFromThread(self.omci_indication, ind.omci_ind) elif ind.HasField('pkt_ind'): reactor.callFromThread(self.packet_indication, ind.pkt_ind) elif ind.HasField('port_stats'): reactor.callFromThread( self.stats_mgr.port_statistics_indication, ind.port_stats) elif ind.HasField('flow_stats'): reactor.callFromThread( self.stats_mgr.flow_statistics_indication, ind.flow_stats) elif ind.HasField('alarm_ind'): reactor.callFromThread(self.alarm_mgr.process_alarms, ind.alarm_ind) else: self.log.warn('unknown indication type') def olt_indication(self, olt_indication): if olt_indication.oper_state == "up": self.go_state_up() elif olt_indication.oper_state == "down": self.go_state_down() def intf_indication(self, intf_indication): self.log.debug("intf indication", intf_id=intf_indication.intf_id, oper_state=intf_indication.oper_state) if intf_indication.oper_state == "up": oper_status = OperStatus.ACTIVE else: oper_status = OperStatus.DISCOVERED # add_port update the port if it exists 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) if intf_oper_indication.oper_state == "up": oper_state = OperStatus.ACTIVE else: oper_state = OperStatus.DISCOVERED if intf_oper_indication.type == "nni": # FIXME - creating logical port for 2nd interface throws exception! if intf_oper_indication.intf_id != 0: 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) 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) elif intf_oper_indication.type == "pon": # FIXME - handle PON oper state change pass def onu_discovery_indication(self, onu_disc_indication): intf_id = onu_disc_indication.intf_id 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) # Post ONU Discover alarm 20180809_0805 try: OnuDiscoveryAlarm(self.alarm_mgr.alarms, pon_id=intf_id, serial_number=serial_number_str).raise_alarm() except Exception as disc_alarm_error: self.log.exception("onu-discovery-alarm-error", errmsg=disc_alarm_error.message) # continue for now. pir = self.bw_mgr.pir(serial_number_str) self.log.debug("peak information rate", serial_number=serial_number, pir=pir) 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.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, pir=pir) self.stub.ActivateOnu(onu) except Exception as e: self.log.exception('onu-activation-failed', e=e) else: if onu_device.connect_status != ConnectStatus.REACHABLE: onu_device.connect_status = ConnectStatus.REACHABLE 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) elif onu_device.oper_status == OperStatus.UNKNOWN: 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, pir=pir) self.stub.ActivateOnu(onu) else: 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) try: serial_number_str = self.stringify_serial_number( onu_indication.serial_number) except Exception as e: serial_number_str = None if serial_number_str is not None: onu_device = self.adapter_agent.get_child_device( self.device_id, serial_number=serial_number_str) else: onu_device = self.adapter_agent.get_child_device( self.device_id, parent_port_no=platform.intf_id_to_port_no( onu_indication.intf_id, Port.PON_OLT), onu_id=onu_indication.onu_id) if onu_device is None: self.log.error('onu not found', intf_id=onu_indication.intf_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: 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), 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, can happen if both voltha and ' 'the olt rebooted', 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) self.log.debug('port-number-ready', uni_no=uni_no, uni_name=uni_name) # 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) # 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) # 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) else: self.log.warn('Invalid-or-not-implemented-admin-state', received_admin_state=onu_indication.admin_state) self.log.debug('admin-state-dealt-with') 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) return # Operating state if onu_indication.oper_state == 'down': # 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) if onu_device.adapter == 'brcm_openomci_onu': self.log.debug('using-brcm_openomci_onu') onu_adapter_agent.update_interface(onu_device, onu_indication) 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, msg_oper_state=onu_indication.oper_state) return # Device was in Discovered state, setting it to active # Prepare onu configuration # If we are using the old/current broadcom adapter otherwise # use the openomci adapter if onu_device.adapter == 'broadcom_onu': self.log.debug('using-broadcom_onu') # onu initialization, base configuration (bridge setup ...) def onu_initialization(): onu_adapter_agent.adapter.devices_handlers[onu_device.id] \ .message_exchange(cvid=DEFAULT_MGMT_VLAN) self.log.debug('broadcom-message-exchange-started') # tcont creation (onu) tcont = TcontsConfigData() tcont.alloc_id = platform.mk_alloc_id(onu_indication.onu_id) # gem port creation gem_port = GemportsConfigData() gem_port.gemport_id = platform.mk_gemport_id( onu_indication.onu_id) # ports creation/update 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) # ONU device status update in the datastore def onu_update_oper_status(): onu_device.oper_status = OperStatus.ACTIVE onu_device.connect_status = ConnectStatus.REACHABLE self.adapter_agent.update_device(onu_device) # 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(12, port_config) reactor.callLater(12, onu_update_oper_status) elif onu_device.adapter == 'brcm_openomci_onu': self.log.debug('using-brcm_openomci_onu') # tcont creation (onu) tcont = TcontsConfigData() tcont.alloc_id = platform.mk_alloc_id(onu_indication.onu_id) # gem port creation gem_port = GemportsConfigData() gem_port.gemport_id = platform.mk_gemport_id( onu_indication.onu_id) gem_port.tcont_ref = str(tcont.alloc_id) self.log.info('inject-tcont-gem-data-onu-handler', onu_indication=onu_indication, tcont=tcont, gem_port=gem_port) onu_adapter_agent.create_tcont(onu_device, tcont, traffic_descriptor_data=None) onu_adapter_agent.create_gemport(onu_device, gem_port) onu_adapter_agent.create_interface(onu_device, onu_indication) else: self.log.error('unsupported-openolt-onu-adapter') else: 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 # 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 omci_indication(self, omci_indication): self.log.debug("omci indication", intf_id=omci_indication.intf_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) 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) 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) pkt = Ether(pkt_indication.pkt) kw = dict(logical_device_id=self.logical_device_id, logical_port_no=logical_port_num) self.adapter_agent.send_packet_in(packet=str(pkt), **kw) def packet_out(self, egress_port, msg): pkt = Ether(msg) self.log.info('packet out', egress_port=egress_port, packet=str(pkt).encode("HEX")) # Find port type egress_port_type = self.port_type(egress_port) if egress_port_type == Port.ETHERNET_UNI: if pkt.haslayer(Dot1Q): outer_shim = pkt.getlayer(Dot1Q) if isinstance(outer_shim.payload, Dot1Q): # If double tag, remove the outer tag payload = ( Ether(src=pkt.src, dst=pkt.dst, type=outer_shim.type) / outer_shim.payload) else: payload = pkt else: payload = pkt send_pkt = binascii.unhexlify(str(payload).encode("HEX")) self.log.debug( 'sending-packet-to-ONU', egress_port=egress_port, intf_id=platform.intf_id_from_uni_port_num(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_uni_port_num(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.debug('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) self.stub.UplinkPacketOut(uplink_pkt) else: 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, 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) # 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) self.log.debug("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) def port_name(self, port_no, port_type, intf_id=None, serial_number=None): if port_type is Port.ETHERNET_NNI: return "nni-" + str(port_no) elif port_type is Port.PON_OLT: return "pon" + str(intf_id) elif port_type is Port.ETHERNET_UNI: if serial_number is not None: return serial_number 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: if port.port_no == port_no: 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) label = self.port_name(port_no, Port.ETHERNET_NNI) cap = OFPPF_1GB_FD | OFPPF_FIBER curr_speed = OFPPF_1GB_FD max_speed = OFPPF_1GB_FD if oper_state == OperStatus.ACTIVE: of_oper_state = OFPPS_LIVE 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_stats = ofp_port_stats(port_no=port_no) logical_port = LogicalPort(id=label, ofp_port=ofp, device_id=self.device_id, device_port_no=port_no, root_port=True, ofp_port_stats=ofp_stats) 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) label = self.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 new_onu_id(self, intf_id): onu_id = None onu_devices = self.adapter_agent.get_child_devices(self.device_id) for i in range(1, 512): id_not_taken = True for child_device in onu_devices: if child_device.proxy_address.onu_id == i: id_not_taken = False break if id_not_taken: onu_id = i break return onu_id 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]) & 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]) & 0x0f)[2:], hex(ord(vendor_specific[3]) >> 4 & 0x0f)[2:], hex(ord(vendor_specific[3]) & 0x0f)[2:] ]) def update_flow_table(self, flows): if not self.is_state_up() and not self.is_state_connected(): self.log.info('OLT is down, ignore update flow table') return device = self.adapter_agent.get_device(self.device_id) self.log.debug('update flow table', number_of_flows=len(flows)) for flow in flows: 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. ports = self.adapter_agent.get_ports(device.id, Port.ETHERNET_NNI) for port in ports: if (port.port_no == in_port): self.log.debug('downstream-flow', in_port=in_port) is_down_stream = True break if is_down_stream is None: is_down_stream = False self.log.debug('upstream-flow', in_port=in_port) for flow in flows: try: self.flow_mgr.add_flow(flow, is_down_stream) except grpc.RpcError as grpc_e: if grpc_e.code() == grpc.StatusCode.ALREADY_EXISTS: self.log.warn('flow already exists', e=grpc_e, flow=flow) else: self.log.error('failed to add flow', flow=flow, e=grpc_e) except Exception as e: self.log.error('failed to add flow', flow=flow, e=e) def ip_hex(self, ip): octets = ip.split(".") hex_ip = [] for octet in octets: octet_hex = hex(int(octet)) octet_hex = octet_hex.split('0x')[1] octet_hex = octet_hex.rjust(2, '0') hex_ip.append(octet_hex) return ":".join(hex_ip) def stringify_serial_number(self, serial_number): return ''.join([ serial_number.vendor_id, self.stringify_vendor_specific(serial_number.vendor_specific) ]) def disable(self): self.log.debug('sending-deactivate-olt-message', device_id=self.device_id) try: # Send grpc call self.stub.DisableOlt(openolt_pb2.Empty()) # The resulting indication will bring the OLT down # self.go_state_down() self.log.info('openolt device disabled') except Exception as e: self.log.error('Failure to disable openolt device', error=e) def delete(self): self.log.info('deleting-olt', device_id=self.device_id, logical_device_id=self.logical_device_id) try: # Rebooting to reset the state self.reboot() # Removing logical device self.proxy.remove('/logical_devices/{}'.format( self.logical_device_id)) except Exception as e: self.log.error('Failure to delete openolt device', error=e) raise e else: self.log.info('successfully-deleted-olt', device_id=self.device_id) def reenable(self): self.log.debug('reenabling-olt', device_id=self.device_id) try: self.stub.ReenableOlt(openolt_pb2.Empty()) self.log.info('enabling-all-ports', device_id=self.device_id) self.adapter_agent.enable_all_ports(self.device_id) except Exception as e: self.log.error('Failure to reenable openolt device', error=e) else: self.log.info('openolt device reenabled') def disable_child_device(self, child_device): self.log.debug('sending-disable-onu', olt_device_id=self.device_id, onu_device=child_device, onu_serial_number=child_device.serial_number) vendor_id = child_device.vendor_id.encode('hex') vendor_specific = child_device.serial_number.replace( child_device.vendor_id, '').encode('hex') serial_number = openolt_pb2.SerialNumber( vendor_id=vendor_id, vendor_specific=vendor_specific) onu = openolt_pb2.Onu(intf_id=child_device.proxy_address.channel_id, onu_id=child_device.proxy_address.onu_id, serial_number=serial_number) self.stub.DeactivateOnu(onu) def delete_child_device(self, child_device): self.log.debug('sending-deactivate-onu', olt_device_id=self.device_id, onu_device=child_device, onu_serial_number=child_device.serial_number) vendor_id = child_device.vendor_id.encode('hex') vendor_specific = child_device.serial_number.replace( child_device.vendor_id, '').encode('hex') serial_number = openolt_pb2.SerialNumber( vendor_id=vendor_id, vendor_specific=vendor_specific) onu = openolt_pb2.Onu(intf_id=child_device.proxy_address.channel_id, onu_id=child_device.proxy_address.onu_id, serial_number=serial_number) self.stub.DeleteOnu(onu) def reboot(self): self.log.debug('rebooting openolt device', device_id=self.device_id) try: self.stub.Reboot(openolt_pb2.Empty()) except Exception as e: self.log.error('something went wrong with the reboot', error=e) else: self.log.info('device rebooted')