blob: abc95c117ef673221a6537b183b2ae3782f6e503 [file] [log] [blame]
William Kurkian6f436d02019-02-06 16:25:01 -05001#
2# Copyright 2018 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"""
18Openolt adapter.
19"""
20import arrow
21import grpc
22import structlog
Matt Jeanneret7906d232019-02-14 14:57:38 -050023
24from zope.interface import implementer
William Kurkian6f436d02019-02-06 16:25:01 -050025from google.protobuf.empty_pb2 import Empty
26from google.protobuf.json_format import MessageToDict
27from scapy.layers.inet import Raw
28import json
29from google.protobuf.message import Message
30from grpc._channel import _Rendezvous
31from scapy.layers.l2 import Ether, Dot1Q
32from simplejson import dumps
33from twisted.internet import reactor
34from twisted.internet.defer import inlineCallbacks, returnValue
35from twisted.internet.task import LoopingCall
36
William Kurkian44cd7bb2019-02-11 16:39:12 -050037from pyvoltha.adapters.common.frameio.frameio import BpfProgramFilter, hexify
Matt Jeanneret7906d232019-02-14 14:57:38 -050038from pyvoltha.adapters.iadapter import IAdapterInterface
William Kurkian44cd7bb2019-02-11 16:39:12 -050039from pyvoltha.common.utils.asleep import asleep
40from pyvoltha.common.utils.registry import registry
41from pyvoltha.adapters.kafka.kafka_proxy import get_kafka_proxy
William Kurkian8b1690c2019-03-04 16:53:22 -050042from voltha_protos import openolt_pb2
43#from voltha_protos import third_party
44from voltha_protos.common_pb2 import OperStatus, ConnectStatus
45from voltha_protos.common_pb2 import LogLevel
46from voltha_protos.common_pb2 import OperationResp
47from voltha_protos.inter_container_pb2 import SwitchCapability, PortCapability, \
William Kurkian6f436d02019-02-06 16:25:01 -050048 InterAdapterMessageType, InterAdapterResponseBody
William Kurkian8b1690c2019-03-04 16:53:22 -050049from voltha_protos.device_pb2 import Port, PmConfig, PmConfigs, \
William Kurkian6f436d02019-02-06 16:25:01 -050050 DeviceType, DeviceTypes
William Kurkian8b1690c2019-03-04 16:53:22 -050051from voltha_protos.adapter_pb2 import Adapter
52from voltha_protos.adapter_pb2 import AdapterConfig
William Kurkian33508752019-02-12 14:56:06 -050053from openolt_flow_mgr import OpenOltFlowMgr
54from openolt_alarms import OpenOltAlarmMgr
55from openolt_statistics import OpenOltStatisticsMgr
56from openolt_bw import OpenOltBW
57from openolt_platform import OpenOltPlatform
58from openolt_resource_manager import OpenOltResourceMgr
59from openolt_device import OpenoltDevice
Matt Jeanneret9fd36df2019-02-14 19:14:36 -050060
William Kurkian8b1690c2019-03-04 16:53:22 -050061from voltha_protos.events_pb2 import KpiEvent, KpiEventType, MetricValuePairs
62from voltha_protos.logical_device_pb2 import LogicalPort
63from voltha_protos.openflow_13_pb2 import OFPPS_LIVE, OFPPF_FIBER, \
William Kurkian6f436d02019-02-06 16:25:01 -050064 OFPPF_1GB_FD, \
65 OFPC_GROUP_STATS, OFPC_PORT_STATS, OFPC_TABLE_STATS, OFPC_FLOW_STATS, \
66 ofp_switch_features, ofp_desc
William Kurkian8b1690c2019-03-04 16:53:22 -050067from voltha_protos.openflow_13_pb2 import ofp_port
Arun Arora75e6bb22019-03-07 13:57:31 +000068from pyvoltha.common.utils.nethelpers import mac_str_to_tuple
William Kurkian6f436d02019-02-06 16:25:01 -050069
William Kurkian8b1690c2019-03-04 16:53:22 -050070#_ = third_party
William Kurkian6f436d02019-02-06 16:25:01 -050071log = structlog.get_logger()
William Kurkianfefd4642019-02-07 15:30:03 -050072OpenOltDefaults = {
73 'support_classes': {
74 'platform': OpenOltPlatform,
75 'resource_mgr': OpenOltResourceMgr,
76 'flow_mgr': OpenOltFlowMgr,
77 'alarm_mgr': OpenOltAlarmMgr,
78 'stats_mgr': OpenOltStatisticsMgr,
79 'bw_mgr': OpenOltBW
80 }
81}
William Kurkian6f436d02019-02-06 16:25:01 -050082
William Kurkian6f436d02019-02-06 16:25:01 -050083
Matt Jeanneret7906d232019-02-14 14:57:38 -050084@implementer(IAdapterInterface)
85class OpenoltAdapter(object):
William Kurkian6f436d02019-02-06 16:25:01 -050086 name = 'openolt'
87
88 supported_device_types = [
89 DeviceType(
90 id=name,
91 adapter=name,
92 accepts_bulk_flow_update=True,
93 accepts_add_remove_flow_updates=True
94 )
95 ]
96
97 # System Init Methods #
98 def __init__(self, core_proxy, adapter_proxy, config):
William Kurkian6f436d02019-02-06 16:25:01 -050099 self.adapter_proxy = adapter_proxy
Matt Jeanneret7906d232019-02-14 14:57:38 -0500100 self.adapter_agent = core_proxy
William Kurkian6f436d02019-02-06 16:25:01 -0500101 self.config = config
102 self.descriptor = Adapter(
103 id=self.name,
104 vendor='OLT white box vendor',
105 version='0.1',
Matt Jeanneret7906d232019-02-14 14:57:38 -0500106 config=AdapterConfig(log_level=LogLevel.INFO)
William Kurkian6f436d02019-02-06 16:25:01 -0500107 )
Matt Jeanneret7906d232019-02-14 14:57:38 -0500108 log.debug('openolt.__init__', adapter_agent=adapter_proxy)
William Kurkian6f436d02019-02-06 16:25:01 -0500109 self.devices = dict() # device_id -> OpenoltDevice()
110 self.interface = registry('main').get_args().interface
111 self.logical_device_id_to_root_device_id = dict()
112 self.num_devices = 0
Arun Arora75e6bb22019-03-07 13:57:31 +0000113 self.ofp_port_no = None
William Kurkian6f436d02019-02-06 16:25:01 -0500114
115 def start(self):
116 log.info('started', interface=self.interface)
117
118 def stop(self):
119 log.info('stopped', interface=self.interface)
120
Arun Arora75e6bb22019-03-07 13:57:31 +0000121 def get_ofp_device_info(self, device):
122 log.info('get_ofp_device_info', device_id=device.id)
123 return SwitchCapability(
124 desc=ofp_desc(
125 hw_desc='white box OLT', # Hardware description
126 sw_desc='openolt', # Software description
127 serial_num=device.serial_number, # Serial number
128 dp_desc='n/a' # Human readable description of datapath
129 ),
130 switch_features=ofp_switch_features(
131 n_buffers=256, # Max packets buffered at once # TODO fake for now
132 n_tables=2, # Number of tables supported by datapath # TODO fake for now
133 capabilities=( #Bitmap of support "ofp_capabilities" # TODO fake for now
134 OFPC_FLOW_STATS
135 | OFPC_TABLE_STATS
136 | OFPC_PORT_STATS
137 | OFPC_GROUP_STATS
138 )
139 )
140 )
141
142 def get_ofp_port_info(self, device, port_no):
143 # Since the adapter created the device port then it has the reference of the port to
144 # return the capability. TODO: Do a lookup on the NNI port number and return the
145 # appropriate attributes
146 log.info('get_ofp_port_info', port_no=port_no,
147 info=self.ofp_port_no, device_id=device.id)
148 cap = OFPPF_1GB_FD | OFPPF_FIBER
149 return PortCapability(
150 port=LogicalPort(
151 ofp_port=ofp_port(
152 hw_addr=mac_str_to_tuple(
153 '00:00:00:00:00:%02x' % port_no),
154 config=0,
155 state=OFPPS_LIVE,
156 curr=cap,
157 advertised=cap,
158 peer=cap,
159 curr_speed=OFPPF_1GB_FD,
160 max_speed=OFPPF_1GB_FD
161 ),
162 device_id=device.id,
163 device_port_no=port_no
164 )
165 )
166
William Kurkian6f436d02019-02-06 16:25:01 -0500167 def adapter_descriptor(self):
168 log.debug('get descriptor', interface=self.interface)
169 return self.descriptor
170
171 def device_types(self):
172 log.debug('get device_types', interface=self.interface,
173 items=self.supported_device_types)
174 return DeviceTypes(items=self.supported_device_types)
175
176 def health(self):
177 log.debug('get health', interface=self.interface)
178 raise NotImplementedError()
179
William Kurkian6f436d02019-02-06 16:25:01 -0500180 def change_master_state(self, master):
181 log.debug('change_master_state', interface=self.interface,
182 master=master)
183 raise NotImplementedError()
184
Matt Jeanneret7906d232019-02-14 14:57:38 -0500185 def adopt_device(self, device):
186 log.info('adopt-device', device=device)
187
188 kwargs = {
189 'support_classes': OpenOltDefaults['support_classes'],
190 'adapter_proxy': self.adapter_proxy,
191 'adapter_agent': self.adapter_agent,
192 'device': device,
193 'device_num': self.num_devices + 1
194 }
195 try:
196 self.devices[device.id] = OpenoltDevice(**kwargs)
197 except Exception as e:
198 log.error('Failed to adopt OpenOLT device', error=e)
199 # TODO set status to ERROR so that is clear something went wrong
200 del self.devices[device.id]
201 raise
202 else:
203 self.num_devices += 1
204
205 def reconcile_device(self, device):
206 log.info('reconcile-device', device=device)
207 kwargs = {
208 'support_classes': OpenOltDefaults['support_classes'],
209 'adapter_agent': self.adapter_agent,
210 'device': device,
211 'device_num': self.num_devices + 1,
212 'reconciliation': True
213 }
214 try:
215 reconciled_device = OpenoltDevice(**kwargs)
216 log.debug('reconciled-device-recreated',
217 device_id=reconciled_device.device_id)
218 self.devices[device.id] = reconciled_device
219 except Exception as e:
220 log.error('Failed to reconcile OpenOLT device', error=e,
221 exception_type=type(e).__name__)
222 del self.devices[device.id]
223 raise
224 else:
225 self.num_devices += 1
226 # Invoke the children reconciliation which would setup the
227 # basic children data structures
228 self.adapter_agent.reconcile_child_devices(device.id)
229 return device
230
William Kurkian6f436d02019-02-06 16:25:01 -0500231 def abandon_device(self, device):
232 log.info('abandon-device', device=device)
233 raise NotImplementedError()
234
Matt Jeanneret7906d232019-02-14 14:57:38 -0500235 def disable_device(self, device):
236 log.info('disable-device', device=device)
237 handler = self.devices[device.id]
238 handler.disable()
William Kurkian6f436d02019-02-06 16:25:01 -0500239
Matt Jeanneret7906d232019-02-14 14:57:38 -0500240 def reenable_device(self, device):
241 log.info('reenable-device', device=device)
242 handler = self.devices[device.id]
243 handler.reenable()
William Kurkian6f436d02019-02-06 16:25:01 -0500244
Matt Jeanneret7906d232019-02-14 14:57:38 -0500245 def reboot_device(self, device):
246 log.info('reboot_device', device=device)
247 handler = self.devices[device.id]
248 handler.reboot()
William Kurkian6f436d02019-02-06 16:25:01 -0500249
William Kurkian6f436d02019-02-06 16:25:01 -0500250 def download_image(self, device, request):
251 log.info('image_download - Not implemented yet', device=device,
252 request=request)
253 raise NotImplementedError()
254
255 def get_image_download_status(self, device, request):
256 log.info('get_image_download - Not implemented yet', device=device,
257 request=request)
258 raise NotImplementedError()
259
260 def cancel_image_download(self, device, request):
261 log.info('cancel_image_download - Not implemented yet', device=device)
262 raise NotImplementedError()
263
264 def activate_image_update(self, device, request):
265 log.info('activate_image_update - Not implemented yet',
266 device=device, request=request)
267 raise NotImplementedError()
268
269 def revert_image_update(self, device, request):
270 log.info('revert_image_update - Not implemented yet',
271 device=device, request=request)
272 raise NotImplementedError()
273
274 def self_test_device(self, device):
William Kurkian6f436d02019-02-06 16:25:01 -0500275 log.info('Not implemented yet')
276 raise NotImplementedError()
277
Matt Jeanneret7906d232019-02-14 14:57:38 -0500278 def delete_device(self, device):
279 log.info('delete-device', device=device)
280 handler = self.devices[device.id]
281 handler.delete()
282 del self.devices[device.id]
283 del self.logical_device_id_to_root_device_id[device.parent_id]
284 return device
William Kurkian6f436d02019-02-06 16:25:01 -0500285
Matt Jeanneret7906d232019-02-14 14:57:38 -0500286 def get_device_details(self, device):
287 log.debug('get_device_details', device=device)
288 raise NotImplementedError()
289
290 def update_flows_bulk(self, device, flows, groups):
291 log.info('bulk-flow-update', device_id=device.id,
Matt Jeanneret9fd36df2019-02-14 19:14:36 -0500292 number_of_flows=len(flows.items),
293 number_of_groups=len(groups.items))
Matt Jeanneret7906d232019-02-14 14:57:38 -0500294 log.debug('flows and grousp details', flows=flows, groups=groups)
295 assert len(groups.items) == 0, "Cannot yet deal with groups"
296 handler = self.devices[device.id]
297 return handler.update_flow_table(flows.items)
298
299 def update_flows_incrementally(self, device, flow_changes, group_changes):
300 log.debug('update_flows_incrementally', device=device,
301 flow_changes=flow_changes, group_changes=group_changes)
302 log.info('This device does not allow this, therefore it is Not '
303 'implemented')
304 raise NotImplementedError()
305
306 def update_logical_flows(self, device_id, flows_to_add, flows_to_remove,
307 groups, device_rules_map):
308
309 log.info('logical-flows-update', flows_to_add=len(flows_to_add),
310 flows_to_remove=len(flows_to_remove))
311 log.debug('logical-flows-details', flows_to_add=flows_to_add,
312 flows_to_remove=flows_to_remove)
313 assert len(groups) == 0, "Cannot yet deal with groups"
314 handler = self.devices[device_id]
315 handler.update_logical_flows(flows_to_add, flows_to_remove,
316 device_rules_map)
317
318 def update_pm_config(self, device, pm_configs):
319 log.info('update_pm_config - Not implemented yet', device=device,
320 pm_configs=pm_configs)
321 raise NotImplementedError()
322
323 def send_proxied_message(self, proxy_address, msg):
324 log.debug('send-proxied-message',
325 proxy_address=proxy_address,
326 proxied_msg=msg)
327 handler = self.devices[proxy_address.device_id]
328 handler.send_proxied_message(proxy_address, msg)
329
330 def receive_proxied_message(self, proxy_address, msg):
331 log.debug('receive_proxied_message - Not implemented',
332 proxy_address=proxy_address,
333 proxied_msg=msg)
334 raise NotImplementedError()
335
336 def receive_packet_out(self, logical_device_id, egress_port_no, msg):
337 log.debug('packet-out', logical_device_id=logical_device_id,
338 egress_port_no=egress_port_no, msg_len=len(msg))
339
340 def ldi_to_di(ldi):
341 di = self.logical_device_id_to_root_device_id.get(ldi)
342 if di is None:
343 logical_device = self.adapter_agent.get_logical_device(ldi)
344 di = logical_device.root_device_id
345 self.logical_device_id_to_root_device_id[ldi] = di
346 return di
347
348 try:
349 device_id = ldi_to_di(logical_device_id)
350 handler = self.devices[device_id]
351 handler.packet_out(egress_port_no, msg)
352 except Exception as e:
353 log.error('packet-out:exception', e=e.message)
354
Matt Jeanneretb428b952019-03-07 05:14:17 -0500355 def process_inter_adapter_message(self, msg):
356 log.debug('process-inter-adapter-message', msg=msg)
357 # Unpack the header to know which device needs to handle this message
358 handler = None
359 if msg.header.proxy_device_id:
360 # typical request
361 handler = self.devices[msg.header.proxy_device_id]
362 elif msg.header.to_device_id and \
363 msg.header.to_device_id in self.devices_handlers:
364 # typical response
365 handler = self.devices[msg.header.to_device_id]
366 if handler:
367 reactor.callLater(0, handler.process_inter_adapter_message, msg)
368
Matt Jeanneret7906d232019-02-14 14:57:38 -0500369 def receive_inter_adapter_message(self, msg):
370 log.info('rx_inter_adapter_msg - Not implemented')
371 raise NotImplementedError()
372
373 def suppress_alarm(self, filter):
374 log.info('suppress_alarm - Not implemented yet', filter=filter)
375 raise NotImplementedError()
376
377 def unsuppress_alarm(self, filter):
378 log.info('unsuppress_alarm - Not implemented yet', filter=filter)
379 raise NotImplementedError()
380
381 # PON Mgnt APIs #
William Kurkian6f436d02019-02-06 16:25:01 -0500382 def create_interface(self, device, data):
383 log.debug('create-interface - Not implemented - We do not use this',
384 data=data)
385 raise NotImplementedError()
386
387 def update_interface(self, device, data):
388 log.debug('update-interface - Not implemented - We do not use this',
389 data=data)
390 raise NotImplementedError()
391
392 def remove_interface(self, device, data):
393 log.debug('remove-interface - Not implemented - We do not use this',
394 data=data)
395 raise NotImplementedError()
396
397 def receive_onu_detect_state(self, proxy_address, state):
398 log.debug('receive-onu-detect-state - Not implemented - We do not '
399 'use this', proxy_address=proxy_address,
400 state=state)
401 raise NotImplementedError()
402
403 def create_tcont(self, device, tcont_data, traffic_descriptor_data):
404 log.info('create-tcont - Not implemented - We do not use this',
405 tcont_data=tcont_data,
406 traffic_descriptor_data=traffic_descriptor_data)
407 raise NotImplementedError()
408
409 def update_tcont(self, device, tcont_data, traffic_descriptor_data):
410 log.info('update-tcont - Not implemented - We do not use this',
411 tcont_data=tcont_data,
412 traffic_descriptor_data=traffic_descriptor_data)
413 raise NotImplementedError()
414
415 def remove_tcont(self, device, tcont_data, traffic_descriptor_data):
416 log.info('remove-tcont - Not implemented - We do not use this',
417 tcont_data=tcont_data,
418 traffic_descriptor_data=traffic_descriptor_data)
419 raise NotImplementedError()
420
421 def create_gemport(self, device, data):
422 log.info('create-gemport - Not implemented - We do not use this',
423 data=data)
424 raise NotImplementedError()
425
426 def update_gemport(self, device, data):
427 log.info('update-gemport - Not implemented - We do not use this',
428 data=data)
429 raise NotImplementedError()
430
431 def remove_gemport(self, device, data):
432 log.info('remove-gemport - Not implemented - We do not use this',
433 data=data)
434 raise NotImplementedError()
435
436 def create_multicast_gemport(self, device, data):
437 log.info('create-mcast-gemport - Not implemented - We do not use '
438 'this', data=data)
439 raise NotImplementedError()
440
441 def update_multicast_gemport(self, device, data):
442 log.info('update-mcast-gemport - Not implemented - We do not use '
443 'this', data=data)
444 raise NotImplementedError()
445
446 def remove_multicast_gemport(self, device, data):
447 log.info('remove-mcast-gemport - Not implemented - We do not use '
448 'this', data=data)
449 raise NotImplementedError()
450
451 def create_multicast_distribution_set(self, device, data):
452 log.info('create-mcast-distribution-set - Not implemented - We do '
453 'not use this', data=data)
454 raise NotImplementedError()
455
456 def update_multicast_distribution_set(self, device, data):
457 log.info('update-mcast-distribution-set - Not implemented - We do '
458 'not use this', data=data)
459 raise NotImplementedError()
460
461 def remove_multicast_distribution_set(self, device, data):
462 log.info('remove-mcast-distribution-set - Not implemented - We do '
463 'not use this', data=data)
464 raise NotImplementedError()
465
Matt Jeanneret7906d232019-02-14 14:57:38 -0500466 def delete_child_device(self, parent_device_id, child_device):
467 log.info('delete-child_device', parent_device_id=parent_device_id,
468 child_device=child_device)
469 handler = self.devices[parent_device_id]
470 if handler is not None:
471 handler.delete_child_device(child_device)
William Kurkian6f436d02019-02-06 16:25:01 -0500472 else:
Matt Jeanneret7906d232019-02-14 14:57:38 -0500473 log.error('Could not find matching handler',
474 looking_for_device_id=parent_device_id,
475 available_handlers=self.devices.keys())
William Kurkian6f436d02019-02-06 16:25:01 -0500476
Matt Jeanneret7906d232019-02-14 14:57:38 -0500477 # This is currently not part of the Iadapter interface
478 def collect_stats(self, device_id):
479 log.info('collect_stats', device_id=device_id)
480 handler = self.devices[device_id]
481 if handler is not None:
482 handler.trigger_statistics_collection()
483 else:
484 log.error('Could not find matching handler',
485 looking_for_device_id=device_id,
486 available_handlers=self.devices.keys())
William Kurkian6f436d02019-02-06 16:25:01 -0500487
Matt Jeanneret7906d232019-02-14 14:57:38 -0500488 def simulate_alarm(self, device, request):
489 log.info('simulate_alarm', device=device, request=request)
William Kurkian6f436d02019-02-06 16:25:01 -0500490
Matt Jeanneret7906d232019-02-14 14:57:38 -0500491 if device.id not in self.devices:
492 log.error("Device does not exist", device_id=device.id)
493 return OperationResp(code=OperationResp.OPERATION_FAILURE,
494 additional_info="Device %s does not exist"
Matt Jeanneret9fd36df2019-02-14 19:14:36 -0500495 % device.id)
William Kurkian6f436d02019-02-06 16:25:01 -0500496
Matt Jeanneret7906d232019-02-14 14:57:38 -0500497 handler = self.devices[device.id]
William Kurkian6f436d02019-02-06 16:25:01 -0500498
Matt Jeanneret7906d232019-02-14 14:57:38 -0500499 handler.simulate_alarm(request)
William Kurkian6f436d02019-02-06 16:25:01 -0500500
Matt Jeanneret7906d232019-02-14 14:57:38 -0500501 return OperationResp(code=OperationResp.OPERATION_SUCCESS)