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 |
Matt Jeanneret | 2e3cb8d | 2019-11-16 09:22:41 -0500 | [diff] [blame] | 33 | from voltha_protos.device_pb2 import DeviceType, DeviceTypes |
William Kurkian | 8235c1e | 2019-03-05 12:58:28 -0500 | [diff] [blame] | 34 | from voltha_protos.health_pb2 import HealthStatus |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 35 | |
Matt Jeanneret | 72f96fc | 2019-02-11 10:53:05 -0500 | [diff] [blame] | 36 | from pyvoltha.adapters.common.frameio.frameio import hexify |
| 37 | from pyvoltha.adapters.extensions.omci.openomci_agent import OpenOMCIAgent, OpenOmciAgentDefaults |
Matt Jeanneret | 98f99dc | 2019-09-25 11:05:25 -0400 | [diff] [blame] | 38 | from pyvoltha.adapters.extensions.omci.database.mib_db_dict import MibDbVolatileDict |
Matt Jeanneret | 5e33189 | 2019-12-07 21:31:45 -0500 | [diff] [blame] | 39 | from pyvoltha.adapters.extensions.omci.database.mib_db_dict_lazy import MibDbLazyWriteDict |
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 | |
Matteo Scandolo | bb3317d | 2020-03-31 10:49:42 -0700 | [diff] [blame] | 61 | def __init__(self, id, core_proxy, adapter_proxy, config, build_info, current_replica, total_replicas, endpoint): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 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( |
Matteo Scandolo | bb3317d | 2020-03-31 10:49:42 -0700 | [diff] [blame] | 69 | id=id, |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 70 | vendor='VOLTHA OpenONU', |
| 71 | version=build_info.version, |
Matteo Scandolo | bb3317d | 2020-03-31 10:49:42 -0700 | [diff] [blame] | 72 | config=AdapterConfig(), |
| 73 | currentReplica=current_replica, |
| 74 | totalReplicas=total_replicas, |
| 75 | endpoint=endpoint, |
| 76 | type=self.name |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 77 | ) |
| 78 | self.devices_handlers = dict() |
Matt Jeanneret | 2136320 | 2019-02-13 16:21:48 -0500 | [diff] [blame] | 79 | self.device_handler_class = BrcmOpenomciOnuHandler |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 80 | |
| 81 | # Customize OpenOMCI for Broadcom ONUs |
| 82 | self.broadcom_omci = deepcopy(OpenOmciAgentDefaults) |
| 83 | |
Matt Jeanneret | de16ed5 | 2019-09-18 19:05:15 -0400 | [diff] [blame] | 84 | self.broadcom_omci['mib-synchronizer']['audit-delay'] = 0 # disable audits as brcm onu wont upload once provisioned |
Matt Jeanneret | 5e33189 | 2019-12-07 21:31:45 -0500 | [diff] [blame] | 85 | self.broadcom_omci['mib-synchronizer']['database'] = MibDbLazyWriteDict |
Matt Jeanneret | 98f99dc | 2019-09-25 11:05:25 -0400 | [diff] [blame] | 86 | self.broadcom_omci['alarm-synchronizer']['database'] = MibDbVolatileDict |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 87 | self.broadcom_omci['omci-capabilities']['tasks']['get-capabilities'] = BrcmCapabilitiesTask |
| 88 | |
| 89 | # Defer creation of omci agent to a lazy init that allows subclasses to override support classes |
| 90 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 91 | def custom_me_entities(self): |
| 92 | return None |
| 93 | |
| 94 | @property |
| 95 | def omci_agent(self): |
| 96 | if not hasattr(self, '_omci_agent') or self._omci_agent is None: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 97 | self.log.debug('creating-omci-agent') |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 98 | self._omci_agent = OpenOMCIAgent(self.core_proxy, |
| 99 | self.adapter_proxy, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 100 | support_classes=self.broadcom_omci) |
| 101 | return self._omci_agent |
| 102 | |
| 103 | def start(self): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 104 | self.log.debug('starting') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 105 | self.omci_agent.start() |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 106 | self.log.info('started') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 107 | |
| 108 | def stop(self): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 109 | self.log.debug('stopping') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 110 | |
| 111 | omci, self._omci_agent = self._omci_agent, None |
| 112 | if omci is not None: |
| 113 | self._omci_agent.stop() |
| 114 | |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 115 | self.log.info('stopped') |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 116 | |
| 117 | def adapter_descriptor(self): |
| 118 | return self.descriptor |
| 119 | |
| 120 | def device_types(self): |
| 121 | return DeviceTypes(items=self.supported_device_types) |
| 122 | |
| 123 | def health(self): |
| 124 | return HealthStatus(state=HealthStatus.HealthState.HEALTHY) |
| 125 | |
| 126 | def change_master_state(self, master): |
| 127 | raise NotImplementedError() |
| 128 | |
| 129 | def adopt_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 130 | self.log.info('adopt-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 131 | self.devices_handlers[device.id] = BrcmOpenomciOnuHandler(self, device.id) |
| 132 | reactor.callLater(0, self.devices_handlers[device.id].activate, device) |
| 133 | return device |
| 134 | |
| 135 | def reconcile_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 136 | self.log.info('reconcile-device', device_id=device.id) |
Matt Jeanneret | 5e33189 | 2019-12-07 21:31:45 -0500 | [diff] [blame] | 137 | if not device.id in self.devices_handlers: |
| 138 | self.devices_handlers[device.id] = BrcmOpenomciOnuHandler(self, device.id) |
| 139 | reactor.callLater(0, self.devices_handlers[device.id].reconcile, device) |
| 140 | else: |
| 141 | self.log.debug('already-called-reconcile-device', device_id=device.id) |
| 142 | return device |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 143 | |
| 144 | def abandon_device(self, device): |
| 145 | raise NotImplementedError() |
| 146 | |
| 147 | def disable_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 148 | self.log.info('disable-onu-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 149 | if device.id in self.devices_handlers: |
| 150 | handler = self.devices_handlers[device.id] |
| 151 | if handler is not None: |
| 152 | handler.disable(device) |
| 153 | |
| 154 | def reenable_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 155 | self.log.info('reenable-onu-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 156 | if device.id in self.devices_handlers: |
| 157 | handler = self.devices_handlers[device.id] |
| 158 | if handler is not None: |
| 159 | handler.reenable(device) |
| 160 | |
| 161 | def reboot_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 162 | self.log.info('reboot-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 163 | if device.id in self.devices_handlers: |
| 164 | handler = self.devices_handlers[device.id] |
| 165 | if handler is not None: |
| 166 | handler.reboot() |
| 167 | |
| 168 | def download_image(self, device, request): |
| 169 | raise NotImplementedError() |
| 170 | |
| 171 | def get_image_download_status(self, device, request): |
| 172 | raise NotImplementedError() |
| 173 | |
| 174 | def cancel_image_download(self, device, request): |
| 175 | raise NotImplementedError() |
| 176 | |
| 177 | def activate_image_update(self, device, request): |
| 178 | raise NotImplementedError() |
| 179 | |
| 180 | def revert_image_update(self, device, request): |
| 181 | raise NotImplementedError() |
| 182 | |
kesavand | 54959a3 | 2020-01-20 18:52:42 +0530 | [diff] [blame] | 183 | def enable_port(self, device_id, port): |
| 184 | raise NotImplementedError() |
| 185 | |
| 186 | def disable_port(self, device_id, port): |
| 187 | raise NotImplementedError() |
| 188 | |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 189 | def self_test_device(self, device): |
| 190 | """ |
| 191 | This is called to Self a device based on a NBI call. |
| 192 | :param device: A Voltha.Device object. |
| 193 | :return: Will return result of self test |
| 194 | """ |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 195 | 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] | 196 | raise NotImplementedError() |
| 197 | |
| 198 | def delete_device(self, device): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 199 | self.log.info('delete-device', device_id=device.id) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 200 | if device.id in self.devices_handlers: |
| 201 | handler = self.devices_handlers[device.id] |
| 202 | if handler is not None: |
| 203 | handler.delete(device) |
| 204 | del self.devices_handlers[device.id] |
| 205 | return |
| 206 | |
| 207 | def get_device_details(self, device): |
| 208 | raise NotImplementedError() |
| 209 | |
| 210 | # TODO(smbaker): When BrcmOpenomciOnuAdapter is updated to inherit from OnuAdapter, this function can be deleted |
Rohan Agrawal | f0f8c29 | 2020-06-01 09:30:55 +0000 | [diff] [blame] | 211 | def update_pm_config(self, device, pm_configs): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 212 | self.log.info("adapter-update-pm-config", device_id=device.id, serial_number=device.serial_number, |
Rohan Agrawal | f0f8c29 | 2020-06-01 09:30:55 +0000 | [diff] [blame] | 213 | pm_configs=pm_configs) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 214 | handler = self.devices_handlers[device.id] |
Rohan Agrawal | f0f8c29 | 2020-06-01 09:30:55 +0000 | [diff] [blame] | 215 | handler.update_pm_config(device, pm_configs) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 216 | |
| 217 | def update_flows_bulk(self, device, flows, groups): |
| 218 | ''' |
| 219 | log.info('bulk-flow-update', device_id=device.id, |
| 220 | flows=flows, groups=groups) |
| 221 | ''' |
| 222 | assert len(groups.items) == 0 |
| 223 | handler = self.devices_handlers[device.id] |
| 224 | return handler.update_flow_table(device, flows.items) |
| 225 | |
| 226 | def update_flows_incrementally(self, device, flow_changes, group_changes): |
Mahir Gunyel | d680cb6 | 2020-02-18 10:28:12 -0800 | [diff] [blame] | 227 | self.log.info('incremental-flow-update', device_id=device.id, |
| 228 | flows=flow_changes, groups=group_changes) |
| 229 | # For now, there is no support for group changes |
| 230 | assert len(group_changes.to_add.items) == 0 |
| 231 | assert len(group_changes.to_remove.items) == 0 |
| 232 | |
| 233 | handler = self.devices_handlers[device.id] |
| 234 | # Remove flows |
| 235 | if len(flow_changes.to_remove.items) != 0: |
| 236 | handler.remove_onu_flows(device, flow_changes.to_remove.items) |
| 237 | |
| 238 | # Add flows |
| 239 | if len(flow_changes.to_add.items) != 0: |
| 240 | handler.add_onu_flows(device, flow_changes.to_add.items) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 241 | |
| 242 | def send_proxied_message(self, proxy_address, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 243 | self.log.debug('send-proxied-message', proxy_address=proxy_address, msg=msg) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 244 | |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 245 | @inlineCallbacks |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 246 | def receive_proxied_message(self, proxy_address, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 247 | self.log.debug('receive-proxied-message', proxy_address=proxy_address, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 248 | device_id=proxy_address.device_id, msg=hexify(msg)) |
| 249 | # Device_id from the proxy_address is the olt device id. We need to |
| 250 | # 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] | 251 | device = self.core_proxy. \ |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 252 | get_child_device_with_proxy_address(proxy_address) |
| 253 | if device: |
| 254 | handler = self.devices_handlers[device.id] |
| 255 | handler.receive_message(msg) |
| 256 | |
| 257 | def receive_packet_out(self, logical_device_id, egress_port_no, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 258 | self.log.debug('packet-out', logical_device_id=logical_device_id, |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 259 | egress_port_no=egress_port_no, msg_len=len(msg)) |
| 260 | |
William Kurkian | 3a20633 | 2019-04-29 11:05:47 -0400 | [diff] [blame] | 261 | @inlineCallbacks |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 262 | def receive_inter_adapter_message(self, msg): |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 263 | self.log.debug('receive-inter-adapter-message', msg=msg) |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 264 | proxy_address = msg['proxy_address'] |
| 265 | assert proxy_address is not None |
| 266 | # Device_id from the proxy_address is the olt device id. We need to |
| 267 | # 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] | 268 | device = self.core_proxy. \ |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 269 | get_child_device_with_proxy_address(proxy_address) |
| 270 | if device: |
| 271 | handler = self.devices_handlers[device.id] |
| 272 | handler.event_messages.put(msg) |
| 273 | else: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 274 | self.log.error("device-not-found") |
Matt Jeanneret | f1e9c5d | 2019-02-08 07:41:29 -0500 | [diff] [blame] | 275 | |
Matt Jeanneret | c083f46 | 2019-03-11 15:02:01 -0400 | [diff] [blame] | 276 | |
Matteo Scandolo | b33166d | 2020-06-16 16:08:00 -0700 | [diff] [blame] | 277 | def process_inter_adapter_message(self, msg, max_retry=0, current_retry=0): |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 278 | # Unpack the header to know which device needs to handle this message |
| 279 | if msg.header: |
Matt Jeanneret | 08a8e86 | 2019-12-20 14:02:32 -0500 | [diff] [blame] | 280 | 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] | 281 | to_topic=msg.header.to_topic, to_device_id=msg.header.to_device_id) |
Matteo Scandolo | b33166d | 2020-06-16 16:08:00 -0700 | [diff] [blame] | 282 | |
| 283 | # NOTE this should only happen in the case of ONU_IND_REQUEST as described in VOL-3223 |
| 284 | if not msg.header.to_device_id in self.devices_handlers: |
| 285 | self.log.warn('process-inter-adapter-message-handler-not-found-retry-in-one-sec', type=msg.header.type, |
| 286 | from_topic=msg.header.from_topic, to_topic=msg.header.to_topic, to_device_id=msg.header.to_device_id) |
| 287 | if current_retry == max_retry: |
| 288 | self.log.error('process-inter-adapter-message-handler-not-found-no-more-retry', type=msg.header.type, |
| 289 | from_topic=msg.header.from_topic, to_topic=msg.header.to_topic, to_device_id=msg.header.to_device_id) |
| 290 | return |
| 291 | else: |
| 292 | reactor.callLater(1, self.process_inter_adapter_message, msg, max_retry=10, current_retry=current_retry+1) |
| 293 | return |
| 294 | |
Matt Jeanneret | a32441c | 2019-03-07 05:16:37 -0500 | [diff] [blame] | 295 | handler = self.devices_handlers[msg.header.to_device_id] |
| 296 | handler.process_inter_adapter_message(msg) |
onkarkundargi | a1e2af2 | 2020-01-27 11:51:43 +0530 | [diff] [blame] | 297 | |
| 298 | def start_omci_test(self, device, uuid): |
| 299 | """ |
| 300 | |
| 301 | :param device: |
| 302 | :return: |
| 303 | """ |
| 304 | self.log.info('Omci-test-action-request-On', request=device) |
| 305 | handler = self.devices_handlers[device.id] |
| 306 | result = handler.start_omci_test_action(device, uuid) |
| 307 | return result |