Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 1 | # |
| 2 | # Copyright 2017 the original author or authors. |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | # you may not use this file except in compliance with the License. |
| 6 | # You may obtain a copy of the License at |
| 7 | # |
| 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | # |
| 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | # See the License for the specific language governing permissions and |
| 14 | # limitations under the License. |
| 15 | # |
| 16 | |
| 17 | """ |
| 18 | Broadcom OpenOMCI OLT/ONU adapter. |
| 19 | |
| 20 | This adapter does NOT support XPON |
| 21 | """ |
| 22 | |
Matt Jeanneret | 2e3cb8d | 2019-11-16 09:22:41 -0500 | [diff] [blame] | 23 | from __future__ import absolute_import |
| 24 | import structlog |
| 25 | from twisted.internet import reactor |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 26 | from twisted.internet.defer import inlineCallbacks |
| 27 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 28 | from zope.interface import implementer |
| 29 | |
Matt Jeanneret | 72f96fc | 2019-02-11 10:53:05 -0500 | [diff] [blame] | 30 | from pyvoltha.adapters.interface import IAdapterInterface |
William Kurkian | 8235c1e | 2019-03-05 12:58:28 -0500 | [diff] [blame] | 31 | from voltha_protos.adapter_pb2 import Adapter |
| 32 | from voltha_protos.adapter_pb2 import AdapterConfig |
| 33 | from voltha_protos.common_pb2 import LogLevel |
Matt Jeanneret | 2e3cb8d | 2019-11-16 09:22:41 -0500 | [diff] [blame] | 34 | from voltha_protos.device_pb2 import DeviceType, DeviceTypes |
William Kurkian | 8235c1e | 2019-03-05 12:58:28 -0500 | [diff] [blame] | 35 | from voltha_protos.health_pb2 import HealthStatus |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 36 | |
Matt Jeanneret | 72f96fc | 2019-02-11 10:53:05 -0500 | [diff] [blame] | 37 | from pyvoltha.adapters.common.frameio.frameio import hexify |
| 38 | from pyvoltha.adapters.extensions.omci.openomci_agent import OpenOMCIAgent, OpenOmciAgentDefaults |
Matt Jeanneret | 98f99dc | 2019-09-25 11:05:25 -0400 | [diff] [blame] | 39 | from pyvoltha.adapters.extensions.omci.database.mib_db_dict import MibDbVolatileDict |
Matt Jeanneret | 72f96fc | 2019-02-11 10:53:05 -0500 | [diff] [blame] | 40 | |
| 41 | from brcm_openomci_onu_handler import BrcmOpenomciOnuHandler |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 42 | from omci.brcm_capabilities_task import BrcmCapabilitiesTask |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 43 | from copy import deepcopy |
| 44 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 45 | |
| 46 | @implementer(IAdapterInterface) |
| 47 | class BrcmOpenomciOnuAdapter(object): |
| 48 | |
| 49 | name = 'brcm_openomci_onu' |
| 50 | |
| 51 | supported_device_types = [ |
| 52 | DeviceType( |
| 53 | id=name, |
Mahir Gunyel | d680cb6 | 2020-02-18 10:28:12 -0800 | [diff] [blame] | 54 | vendor_ids=['OPEN', 'ALCL', 'BRCM', 'TWSH', 'ALPH', 'ISKT', 'SFAA', 'BBSM', 'SCOM', 'ARPX', 'DACM', 'ERSN', 'HWTC', 'CIGG'], |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 55 | adapter=name, |
Mahir Gunyel | 9dfab82 | 2020-02-20 15:52:15 -0800 | [diff] [blame^] | 56 | accepts_bulk_flow_update=False, |
| 57 | accepts_add_remove_flow_updates=True |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 58 | ) |
| 59 | ] |
| 60 | |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 61 | def __init__(self, core_proxy, adapter_proxy, config, build_info): |
| 62 | self.log = structlog.get_logger() |
| 63 | self.log.debug('starting-adapter', config=config) |
| 64 | |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 65 | self.core_proxy = core_proxy |
Matt Jeanneret | 0bd63c8 | 2019-02-15 05:40:44 -0500 | [diff] [blame] | 66 | self.adapter_proxy = adapter_proxy |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 67 | self.config = config |
| 68 | self.descriptor = Adapter( |
| 69 | id=self.name, |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 70 | vendor='VOLTHA OpenONU', |
| 71 | version=build_info.version, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 72 | config=AdapterConfig(log_level=LogLevel.INFO) |
| 73 | ) |
| 74 | self.devices_handlers = dict() |
Matt Jeanneret | 2136320 | 2019-02-13 16:21:48 -0500 | [diff] [blame] | 75 | self.device_handler_class = BrcmOpenomciOnuHandler |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 76 | |
| 77 | # Customize OpenOMCI for Broadcom ONUs |
| 78 | self.broadcom_omci = deepcopy(OpenOmciAgentDefaults) |
| 79 | |
Matt Jeanneret | de16ed5 | 2019-09-18 19:05:15 -0400 | [diff] [blame] | 80 | self.broadcom_omci['mib-synchronizer']['audit-delay'] = 0 # disable audits as brcm onu wont upload once provisioned |
Matt Jeanneret | 98f99dc | 2019-09-25 11:05:25 -0400 | [diff] [blame] | 81 | self.broadcom_omci['mib-synchronizer']['database'] = MibDbVolatileDict |
| 82 | self.broadcom_omci['alarm-synchronizer']['database'] = MibDbVolatileDict |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 83 | self.broadcom_omci['omci-capabilities']['tasks']['get-capabilities'] = BrcmCapabilitiesTask |
| 84 | |
| 85 | # Defer creation of omci agent to a lazy init that allows subclasses to override support classes |
| 86 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 87 | def custom_me_entities(self): |
| 88 | return None |
| 89 | |
| 90 | @property |
| 91 | def omci_agent(self): |
| 92 | if not hasattr(self, '_omci_agent') or self._omci_agent is None: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 93 | self.log.debug('creating-omci-agent') |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 94 | self._omci_agent = OpenOMCIAgent(self.core_proxy, |
| 95 | self.adapter_proxy, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 96 | support_classes=self.broadcom_omci) |
| 97 | return self._omci_agent |
| 98 | |
| 99 | def start(self): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 100 | self.log.debug('starting') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 101 | self.omci_agent.start() |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 102 | self.log.info('started') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 103 | |
| 104 | def stop(self): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 105 | self.log.debug('stopping') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 106 | |
| 107 | omci, self._omci_agent = self._omci_agent, None |
| 108 | if omci is not None: |
| 109 | self._omci_agent.stop() |
| 110 | |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 111 | self.log.info('stopped') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 112 | |
| 113 | def adapter_descriptor(self): |
| 114 | return self.descriptor |
| 115 | |
| 116 | def device_types(self): |
| 117 | return DeviceTypes(items=self.supported_device_types) |
| 118 | |
| 119 | def health(self): |
| 120 | return HealthStatus(state=HealthStatus.HealthState.HEALTHY) |
| 121 | |
| 122 | def change_master_state(self, master): |
| 123 | raise NotImplementedError() |
| 124 | |
| 125 | def adopt_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 126 | self.log.info('adopt-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 127 | self.devices_handlers[device.id] = BrcmOpenomciOnuHandler(self, device.id) |
| 128 | reactor.callLater(0, self.devices_handlers[device.id].activate, device) |
| 129 | return device |
| 130 | |
| 131 | def reconcile_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 132 | self.log.info('reconcile-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 133 | self.devices_handlers[device.id] = BrcmOpenomciOnuHandler(self, device.id) |
| 134 | reactor.callLater(0, self.devices_handlers[device.id].reconcile, device) |
| 135 | |
| 136 | def abandon_device(self, device): |
| 137 | raise NotImplementedError() |
| 138 | |
| 139 | def disable_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 140 | self.log.info('disable-onu-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 141 | if device.id in self.devices_handlers: |
| 142 | handler = self.devices_handlers[device.id] |
| 143 | if handler is not None: |
| 144 | handler.disable(device) |
| 145 | |
| 146 | def reenable_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 147 | self.log.info('reenable-onu-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 148 | if device.id in self.devices_handlers: |
| 149 | handler = self.devices_handlers[device.id] |
| 150 | if handler is not None: |
| 151 | handler.reenable(device) |
| 152 | |
| 153 | def reboot_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 154 | self.log.info('reboot-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 155 | if device.id in self.devices_handlers: |
| 156 | handler = self.devices_handlers[device.id] |
| 157 | if handler is not None: |
| 158 | handler.reboot() |
| 159 | |
| 160 | def download_image(self, device, request): |
| 161 | raise NotImplementedError() |
| 162 | |
| 163 | def get_image_download_status(self, device, request): |
| 164 | raise NotImplementedError() |
| 165 | |
| 166 | def cancel_image_download(self, device, request): |
| 167 | raise NotImplementedError() |
| 168 | |
| 169 | def activate_image_update(self, device, request): |
| 170 | raise NotImplementedError() |
| 171 | |
| 172 | def revert_image_update(self, device, request): |
| 173 | raise NotImplementedError() |
| 174 | |
kesavand | 54959a3 | 2020-01-20 18:52:42 +0530 | [diff] [blame] | 175 | def enable_port(self, device_id, port): |
| 176 | raise NotImplementedError() |
| 177 | |
| 178 | def disable_port(self, device_id, port): |
| 179 | raise NotImplementedError() |
| 180 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 181 | def self_test_device(self, device): |
| 182 | """ |
| 183 | This is called to Self a device based on a NBI call. |
| 184 | :param device: A Voltha.Device object. |
| 185 | :return: Will return result of self test |
| 186 | """ |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 187 | self.log.info('self-test-device - Not implemented yet', device_id=device.id, serial_number=device.serial_number) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 188 | raise NotImplementedError() |
| 189 | |
| 190 | def delete_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 191 | self.log.info('delete-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 192 | if device.id in self.devices_handlers: |
| 193 | handler = self.devices_handlers[device.id] |
| 194 | if handler is not None: |
| 195 | handler.delete(device) |
| 196 | del self.devices_handlers[device.id] |
| 197 | return |
| 198 | |
| 199 | def get_device_details(self, device): |
| 200 | raise NotImplementedError() |
| 201 | |
| 202 | # TODO(smbaker): When BrcmOpenomciOnuAdapter is updated to inherit from OnuAdapter, this function can be deleted |
| 203 | def update_pm_config(self, device, pm_config): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 204 | self.log.info("adapter-update-pm-config", device_id=device.id, serial_number=device.serial_number, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 205 | pm_config=pm_config) |
| 206 | handler = self.devices_handlers[device.id] |
| 207 | handler.update_pm_config(device, pm_config) |
| 208 | |
| 209 | def update_flows_bulk(self, device, flows, groups): |
| 210 | ''' |
| 211 | log.info('bulk-flow-update', device_id=device.id, |
| 212 | flows=flows, groups=groups) |
| 213 | ''' |
| 214 | assert len(groups.items) == 0 |
| 215 | handler = self.devices_handlers[device.id] |
| 216 | return handler.update_flow_table(device, flows.items) |
| 217 | |
| 218 | def update_flows_incrementally(self, device, flow_changes, group_changes): |
Mahir Gunyel | d680cb6 | 2020-02-18 10:28:12 -0800 | [diff] [blame] | 219 | self.log.info('incremental-flow-update', device_id=device.id, |
| 220 | flows=flow_changes, groups=group_changes) |
| 221 | # For now, there is no support for group changes |
| 222 | assert len(group_changes.to_add.items) == 0 |
| 223 | assert len(group_changes.to_remove.items) == 0 |
| 224 | |
| 225 | handler = self.devices_handlers[device.id] |
| 226 | # Remove flows |
| 227 | if len(flow_changes.to_remove.items) != 0: |
| 228 | handler.remove_onu_flows(device, flow_changes.to_remove.items) |
| 229 | |
| 230 | # Add flows |
| 231 | if len(flow_changes.to_add.items) != 0: |
| 232 | handler.add_onu_flows(device, flow_changes.to_add.items) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 233 | |
| 234 | def send_proxied_message(self, proxy_address, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 235 | self.log.debug('send-proxied-message', proxy_address=proxy_address, msg=msg) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 236 | |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 237 | @inlineCallbacks |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 238 | def receive_proxied_message(self, proxy_address, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 239 | self.log.debug('receive-proxied-message', proxy_address=proxy_address, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 240 | device_id=proxy_address.device_id, msg=hexify(msg)) |
| 241 | # Device_id from the proxy_address is the olt device id. We need to |
| 242 | # get the onu device id using the port number in the proxy_address |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 243 | device = self.core_proxy. \ |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 244 | get_child_device_with_proxy_address(proxy_address) |
| 245 | if device: |
| 246 | handler = self.devices_handlers[device.id] |
| 247 | handler.receive_message(msg) |
| 248 | |
| 249 | def receive_packet_out(self, logical_device_id, egress_port_no, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 250 | self.log.debug('packet-out', logical_device_id=logical_device_id, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 251 | egress_port_no=egress_port_no, msg_len=len(msg)) |
| 252 | |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 253 | @inlineCallbacks |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 254 | def receive_inter_adapter_message(self, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 255 | self.log.debug('receive-inter-adapter-message', msg=msg) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 256 | proxy_address = msg['proxy_address'] |
| 257 | assert proxy_address is not None |
| 258 | # Device_id from the proxy_address is the olt device id. We need to |
| 259 | # get the onu device id using the port number in the proxy_address |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 260 | device = self.core_proxy. \ |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 261 | get_child_device_with_proxy_address(proxy_address) |
| 262 | if device: |
| 263 | handler = self.devices_handlers[device.id] |
| 264 | handler.event_messages.put(msg) |
| 265 | else: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 266 | self.log.error("device-not-found") |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 267 | |
Matt Jeanneret | c083f46 | 2019-03-11 15:02:01 -0400 | [diff] [blame] | 268 | def get_ofp_port_info(self, device, port_no): |
| 269 | ofp_port_info = self.devices_handlers[device.id].get_ofp_port_info(device, port_no) |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 270 | self.log.debug('get-ofp-port-info', device_id=device.id, |
Matteo Scandolo | d8d7317 | 2019-11-26 12:15:15 -0700 | [diff] [blame] | 271 | port_name=ofp_port_info.port.ofp_port.name, port_no=ofp_port_info.port.device_port_no) |
Matt Jeanneret | c083f46 | 2019-03-11 15:02:01 -0400 | [diff] [blame] | 272 | return ofp_port_info |
| 273 | |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 274 | def process_inter_adapter_message(self, msg): |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 275 | # Unpack the header to know which device needs to handle this message |
| 276 | if msg.header: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 277 | self.log.debug('process-inter-adapter-message', type=msg.header.type, from_topic=msg.header.from_topic, |
Matteo Scandolo | d8d7317 | 2019-11-26 12:15:15 -0700 | [diff] [blame] | 278 | to_topic=msg.header.to_topic, to_device_id=msg.header.to_device_id) |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 279 | handler = self.devices_handlers[msg.header.to_device_id] |
| 280 | handler.process_inter_adapter_message(msg) |