blob: eb4d716c0e9f8f5dd9200f576c4ac075c333dcb1 [file] [log] [blame]
khenaidoob9203542018-09-17 22:56:37 -04001#
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"""
khenaidoo6fdf0ba2018-11-02 14:38:33 -040018Represents an ONU device
khenaidoob9203542018-09-17 22:56:37 -040019"""
20
khenaidoo91ecfd62018-11-04 17:13:42 -050021from uuid import uuid4
22
23import arrow
khenaidoob9203542018-09-17 22:56:37 -040024import structlog
khenaidoo91ecfd62018-11-04 17:13:42 -050025from google.protobuf.json_format import MessageToDict
26from google.protobuf.message import Message
27from simplejson import dumps
28from twisted.internet.defer import DeferredQueue, inlineCallbacks, \
29 returnValue, Deferred
30from twisted.internet.task import LoopingCall
khenaidoob9203542018-09-17 22:56:37 -040031
khenaidoofdbad6e2018-11-06 22:26:38 -050032from python.common.utils.asleep import asleep
33from python.adapters.iadapter import OnuAdapter
34from python.adapters.kafka.kafka_proxy import get_kafka_proxy
35from python.protos import third_party
36from python.protos.common_pb2 import OperStatus, ConnectStatus, AdminState
37from python.protos.core_adapter_pb2 import PortCapability, \
khenaidoo6fdf0ba2018-11-02 14:38:33 -040038 InterAdapterMessageType, InterAdapterResponseBody
khenaidoofdbad6e2018-11-06 22:26:38 -050039from python.protos.device_pb2 import Port, PmConfig, PmConfigs
40from python.protos.events_pb2 import KpiEvent, KpiEventType, MetricValuePairs
41from python.protos.logical_device_pb2 import LogicalPort
42from python.protos.openflow_13_pb2 import OFPPS_LIVE, OFPPF_FIBER, \
khenaidoob9203542018-09-17 22:56:37 -040043 OFPPF_1GB_FD
khenaidoofdbad6e2018-11-06 22:26:38 -050044from python.protos.openflow_13_pb2 import ofp_port
45from python.protos.ponsim_pb2 import FlowTable, PonSimMetricsRequest, PonSimMetrics
khenaidoob9203542018-09-17 22:56:37 -040046
47_ = third_party
48log = structlog.get_logger()
49
50
51def mac_str_to_tuple(mac):
52 return tuple(int(d, 16) for d in mac.split(':'))
53
khenaidoo6fdf0ba2018-11-02 14:38:33 -040054
khenaidoo91ecfd62018-11-04 17:13:42 -050055class AdapterPmMetrics:
56 def __init__(self, device):
57 self.pm_names = {'tx_64_pkts', 'tx_65_127_pkts', 'tx_128_255_pkts',
58 'tx_256_511_pkts', 'tx_512_1023_pkts',
59 'tx_1024_1518_pkts', 'tx_1519_9k_pkts',
60 'rx_64_pkts', 'rx_65_127_pkts',
61 'rx_128_255_pkts', 'rx_256_511_pkts',
62 'rx_512_1023_pkts', 'rx_1024_1518_pkts',
63 'rx_1519_9k_pkts'}
64 self.device = device
65 self.id = device.id
66 self.name = 'ponsim_onu'
67 self.default_freq = 150
68 self.grouped = False
69 self.freq_override = False
70 self.pm_metrics = None
71 self.pon_metrics_config = dict()
72 self.uni_metrics_config = dict()
73 self.lc = None
74 for m in self.pm_names:
75 self.pon_metrics_config[m] = PmConfig(name=m,
76 type=PmConfig.COUNTER,
77 enabled=True)
78 self.uni_metrics_config[m] = PmConfig(name=m,
79 type=PmConfig.COUNTER,
80 enabled=True)
81
82 def update(self, pm_config):
83 if self.default_freq != pm_config.default_freq:
84 # Update the callback to the new frequency.
85 self.default_freq = pm_config.default_freq
86 self.lc.stop()
87 self.lc.start(interval=self.default_freq / 10)
88 for m in pm_config.metrics:
89 self.pon_metrics_config[m.name].enabled = m.enabled
90 self.uni_metrics_config[m.name].enabled = m.enabled
91
92 def make_proto(self):
93 pm_config = PmConfigs(
94 id=self.id,
95 default_freq=self.default_freq,
96 grouped=False,
97 freq_override=False)
98 for m in sorted(self.pon_metrics_config):
99 pm = self.pon_metrics_config[m] # Either will do they're the same
100 pm_config.metrics.extend([PmConfig(name=pm.name,
101 type=pm.type,
102 enabled=pm.enabled)])
103 return pm_config
104
105 def extract_metrics(self, stats):
106 rtrn_port_metrics = dict()
107 rtrn_port_metrics['pon'] = self.extract_pon_metrics(stats)
108 rtrn_port_metrics['uni'] = self.extract_uni_metrics(stats)
109 return rtrn_port_metrics
110
111 def extract_pon_metrics(self, stats):
112 rtrn_pon_metrics = dict()
113 for m in stats.metrics:
114 if m.port_name == "pon":
115 for p in m.packets:
116 if self.pon_metrics_config[p.name].enabled:
117 rtrn_pon_metrics[p.name] = p.value
118 return rtrn_pon_metrics
119
120 def extract_uni_metrics(self, stats):
121 rtrn_pon_metrics = dict()
122 for m in stats.metrics:
123 if m.port_name == "uni":
124 for p in m.packets:
125 if self.pon_metrics_config[p.name].enabled:
126 rtrn_pon_metrics[p.name] = p.value
127 return rtrn_pon_metrics
128
129 def start_collector(self, callback):
130 log.info("starting-pm-collection", device_name=self.name,
131 device_id=self.device.id)
132 prefix = 'voltha.{}.{}'.format(self.name, self.device.id)
133 self.lc = LoopingCall(callback, self.device.id, prefix)
134 self.lc.start(interval=self.default_freq / 10)
135
136 def stop_collector(self):
137 log.info("stopping-pm-collection", device_name=self.name,
138 device_id=self.device.id)
139 self.lc.stop()
140
141
khenaidoob9203542018-09-17 22:56:37 -0400142class PonSimOnuAdapter(OnuAdapter):
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400143 def __init__(self, core_proxy, adapter_proxy, config):
khenaidoo91ecfd62018-11-04 17:13:42 -0500144 # DeviceType of ONU should be same as VENDOR ID of ONU Serial Number
145 # as specified by standard
khenaidoob9203542018-09-17 22:56:37 -0400146 # requires for identifying correct adapter or ranged ONU
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400147 super(PonSimOnuAdapter, self).__init__(core_proxy=core_proxy,
148 adapter_proxy=adapter_proxy,
khenaidoob9203542018-09-17 22:56:37 -0400149 config=config,
150 device_handler_class=PonSimOnuHandler,
151 name='ponsim_onu',
152 vendor='Voltha project',
153 version='0.4',
154 device_type='ponsim_onu',
155 vendor_id='PSMO',
156 accepts_bulk_flow_update=True,
157 accepts_add_remove_flow_updates=False)
158
159
160class PonSimOnuHandler(object):
161 def __init__(self, adapter, device_id):
162 self.adapter = adapter
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400163 self.core_proxy = adapter.core_proxy
164 self.adapter_proxy = adapter.adapter_proxy
khenaidoob9203542018-09-17 22:56:37 -0400165 self.device_id = device_id
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400166 self.device_parent_id = None
khenaidoob9203542018-09-17 22:56:37 -0400167 self.log = structlog.get_logger(device_id=device_id)
168 self.incoming_messages = DeferredQueue()
khenaidoo91ecfd62018-11-04 17:13:42 -0500169 self.inter_adapter_message_deferred_map = {}
khenaidoob9203542018-09-17 22:56:37 -0400170 self.proxy_address = None
171 # reference of uni_port is required when re-enabling the device if
172 # it was disabled previously
173 self.uni_port = None
174 self.pon_port = None
175
khenaidoo91ecfd62018-11-04 17:13:42 -0500176 def _to_string(self, unicode_str):
177 if unicode_str is not None:
178 if type(unicode_str) == unicode:
179 return unicode_str.encode('ascii', 'ignore')
180 else:
181 return unicode_str
182 else:
183 return ""
184
khenaidoob9203542018-09-17 22:56:37 -0400185 def receive_message(self, msg):
khenaidoo91ecfd62018-11-04 17:13:42 -0500186 trns_id = self._to_string(msg.header.id)
187 if trns_id in self.inter_adapter_message_deferred_map:
188 self.inter_adapter_message_deferred_map[trns_id].callback(msg)
189 # self.incoming_messages.put(msg)
khenaidoob9203542018-09-17 22:56:37 -0400190
khenaidoob9203542018-09-17 22:56:37 -0400191 @inlineCallbacks
192 def activate(self, device):
193 self.log.info('activating')
194
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400195 self.device_parent_id = device.parent_id
196 self.proxy_address = device.proxy_address
khenaidoob9203542018-09-17 22:56:37 -0400197
198 # populate device info
199 device.root = False
200 device.vendor = 'ponsim'
201 device.model = 'n/a'
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400202 yield self.core_proxy.device_update(device)
khenaidoob9203542018-09-17 22:56:37 -0400203
khenaidoo91ecfd62018-11-04 17:13:42 -0500204 # Now set the initial PM configuration for this device
205 self.pm_metrics = AdapterPmMetrics(device)
206 pm_config = self.pm_metrics.make_proto()
207 log.info("initial-pm-config", pm_config=pm_config)
208 self.core_proxy.device_pm_config_update(pm_config, init=True)
209
khenaidoo4d4802d2018-10-04 21:59:49 -0400210 # register physical ports
khenaidoob9203542018-09-17 22:56:37 -0400211 self.uni_port = Port(
212 port_no=2,
213 label='UNI facing Ethernet port',
214 type=Port.ETHERNET_UNI,
215 admin_state=AdminState.ENABLED,
216 oper_status=OperStatus.ACTIVE
217 )
218 self.pon_port = Port(
219 port_no=1,
220 label='PON port',
221 type=Port.PON_ONU,
222 admin_state=AdminState.ENABLED,
223 oper_status=OperStatus.ACTIVE,
224 peers=[
225 Port.PeerPort(
226 device_id=device.parent_id,
227 port_no=device.parent_port_no
228 )
229 ]
230 )
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400231 self.core_proxy.port_created(device.id, self.uni_port)
232 self.core_proxy.port_created(device.id, self.pon_port)
khenaidoob9203542018-09-17 22:56:37 -0400233
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400234 yield self.core_proxy.device_state_update(device.id,
235 connect_status=ConnectStatus.REACHABLE,
236 oper_status=OperStatus.ACTIVE)
khenaidoob9203542018-09-17 22:56:37 -0400237
khenaidoo91ecfd62018-11-04 17:13:42 -0500238 # Start collecting stats from the device after a brief pause
239 self.start_kpi_collection(device.id)
240
khenaidoo19d7b632018-10-30 10:49:50 -0400241 # TODO: Return only port specific info
khenaidoob9203542018-09-17 22:56:37 -0400242 def get_ofp_port_info(self, device, port_no):
khenaidoo91ecfd62018-11-04 17:13:42 -0500243 # Since the adapter created the device port then it has the reference
244 # of the port to
245 # return the capability. TODO: Do a lookup on the UNI port number
246 # and return the
khenaidoob9203542018-09-17 22:56:37 -0400247 # appropriate attributes
248 self.log.info('get_ofp_port_info', port_no=port_no, device_id=device.id)
khenaidoob9203542018-09-17 22:56:37 -0400249 cap = OFPPF_1GB_FD | OFPPF_FIBER
250 return PortCapability(
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400251 port=LogicalPort(
khenaidoob9203542018-09-17 22:56:37 -0400252 ofp_port=ofp_port(
khenaidoob9203542018-09-17 22:56:37 -0400253 hw_addr=mac_str_to_tuple('00:00:00:00:00:%02x' % port_no),
khenaidoob9203542018-09-17 22:56:37 -0400254 config=0,
255 state=OFPPS_LIVE,
256 curr=cap,
257 advertised=cap,
258 peer=cap,
259 curr_speed=OFPPF_1GB_FD,
260 max_speed=OFPPF_1GB_FD
khenaidoo19d7b632018-10-30 10:49:50 -0400261 ),
262 device_id=device.id,
263 device_port_no=port_no
khenaidoob9203542018-09-17 22:56:37 -0400264 )
265 )
266
khenaidoo92e62c52018-10-03 14:02:54 -0400267 @inlineCallbacks
268 def _get_uni_port(self):
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400269 ports = yield self.core_proxy.get_ports(self.device_id,
270 Port.ETHERNET_UNI)
khenaidoo92e62c52018-10-03 14:02:54 -0400271 returnValue(ports)
272
273 @inlineCallbacks
khenaidoob9203542018-09-17 22:56:37 -0400274 def _get_pon_port(self):
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400275 ports = yield self.core_proxy.get_ports(self.device_id, Port.PON_ONU)
khenaidoo92e62c52018-10-03 14:02:54 -0400276 returnValue(ports)
277
khenaidoob9203542018-09-17 22:56:37 -0400278 def reconcile(self, device):
279 self.log.info('reconciling-ONU-device-starts')
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400280 # TODO: complete code
khenaidoob9203542018-09-17 22:56:37 -0400281
282 @inlineCallbacks
283 def update_flow_table(self, flows):
khenaidoo91ecfd62018-11-04 17:13:42 -0500284 trnsId = None
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400285 try:
286 self.log.info('update_flow_table', flows=flows)
287 # we need to proxy through the OLT to get to the ONU
khenaidoob9203542018-09-17 22:56:37 -0400288
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400289 fb = FlowTable(
290 port=self.proxy_address.channel_id,
291 flows=flows
292 )
khenaidoo91ecfd62018-11-04 17:13:42 -0500293
294 # Create a deferred to wait for the result as well as a transid
295 wait_for_result = Deferred()
296 trnsId = uuid4().hex
297 self.inter_adapter_message_deferred_map[
298 self._to_string(trnsId)] = wait_for_result
299
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400300 # Sends the request via proxy and wait for an ACK
301 yield self.adapter_proxy.send_inter_adapter_message(
302 msg=fb,
303 type=InterAdapterMessageType.FLOW_REQUEST,
304 from_adapter=self.adapter.name,
305 to_adapter=self.proxy_address.device_type,
306 to_device_id=self.device_id,
khenaidoo91ecfd62018-11-04 17:13:42 -0500307 proxy_device_id=self.proxy_address.device_id,
308 message_id=trnsId
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400309 )
310 # Wait for the full response from the proxied adapter
khenaidoo91ecfd62018-11-04 17:13:42 -0500311 res = yield wait_for_result
312 if res.header.type == InterAdapterMessageType.FLOW_RESPONSE:
313 body = InterAdapterResponseBody()
314 res.body.Unpack(body)
315 self.log.info('response-received', result=body.status)
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400316 except Exception as e:
317 self.log.exception("update-flow-error", e=e)
khenaidoo91ecfd62018-11-04 17:13:42 -0500318 finally:
319 if trnsId in self.inter_adapter_message_deferred_map:
320 del self.inter_adapter_message_deferred_map[trnsId]
khenaidoob9203542018-09-17 22:56:37 -0400321
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400322 def process_inter_adapter_message(self, msg):
khenaidoo91ecfd62018-11-04 17:13:42 -0500323 # We expect only responses on the ONU side
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400324 self.log.info('process-inter-adapter-message', msg=msg)
khenaidoo91ecfd62018-11-04 17:13:42 -0500325 self.receive_message(msg)
khenaidoob9203542018-09-17 22:56:37 -0400326
327 def remove_from_flow_table(self, flows):
328 self.log.debug('remove-from-flow-table', flows=flows)
329 # TODO: Update PONSIM code to accept incremental flow changes.
330 # Once completed, the accepts_add_remove_flow_updates for this
331 # device type can be set to True
332
333 def add_to_flow_table(self, flows):
334 self.log.debug('add-to-flow-table', flows=flows)
335 # TODO: Update PONSIM code to accept incremental flow changes
336 # Once completed, the accepts_add_remove_flow_updates for this
337 # device type can be set to True
338
339 @inlineCallbacks
340 def reboot(self):
341 self.log.info('rebooting', device_id=self.device_id)
342
khenaidoo4d4802d2018-10-04 21:59:49 -0400343 # Update the connect status to UNREACHABLE
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400344 yield self.core_proxy.device_state_update(self.device_id,
345 connect_status=ConnectStatus.UNREACHABLE)
khenaidoob9203542018-09-17 22:56:37 -0400346
347 # Sleep 10 secs, simulating a reboot
348 # TODO: send alert and clear alert after the reboot
349 yield asleep(10)
350
khenaidoo4d4802d2018-10-04 21:59:49 -0400351 # Change the connection status back to REACHABLE. With a
352 # real ONU the connection state must be the actual state
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400353 yield self.core_proxy.device_state_update(self.device_id,
354 connect_status=ConnectStatus.REACHABLE)
khenaidoo4d4802d2018-10-04 21:59:49 -0400355
khenaidoob9203542018-09-17 22:56:37 -0400356 self.log.info('rebooted', device_id=self.device_id)
357
358 def self_test_device(self, device):
359 """
360 This is called to Self a device based on a NBI call.
361 :param device: A Voltha.Device object.
362 :return: Will return result of self test
363 """
364 log.info('self-test-device', device=device.id)
365 raise NotImplementedError()
366
khenaidoo92e62c52018-10-03 14:02:54 -0400367 @inlineCallbacks
khenaidoob9203542018-09-17 22:56:37 -0400368 def disable(self):
369 self.log.info('disabling', device_id=self.device_id)
370
khenaidoob9203542018-09-17 22:56:37 -0400371 # Update the device operational status to UNKNOWN
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400372 yield self.core_proxy.device_state_update(self.device_id,
373 oper_status=OperStatus.UNKNOWN,
374 connect_status=ConnectStatus.UNREACHABLE)
khenaidoob9203542018-09-17 22:56:37 -0400375
khenaidoo91ecfd62018-11-04 17:13:42 -0500376 self.stop_kpi_collection()
377
khenaidoob9203542018-09-17 22:56:37 -0400378 # TODO:
379 # 1) Remove all flows from the device
380 # 2) Remove the device from ponsim
khenaidoo92e62c52018-10-03 14:02:54 -0400381 self.log.info('disabled', device_id=self.device_id)
khenaidoob9203542018-09-17 22:56:37 -0400382
khenaidoo92e62c52018-10-03 14:02:54 -0400383 @inlineCallbacks
khenaidoob9203542018-09-17 22:56:37 -0400384 def reenable(self):
385 self.log.info('re-enabling', device_id=self.device_id)
386 try:
khenaidoob9203542018-09-17 22:56:37 -0400387
khenaidoo92e62c52018-10-03 14:02:54 -0400388 # Refresh the port reference - we only use one port for now
389 ports = yield self._get_uni_port()
390 self.log.info('re-enabling-uni-ports', ports=ports)
391 if ports.items:
392 self.uni_port = ports.items[0]
khenaidoob9203542018-09-17 22:56:37 -0400393
khenaidoo92e62c52018-10-03 14:02:54 -0400394 ports = yield self._get_pon_port()
395 self.log.info('re-enabling-pon-ports', ports=ports)
396 if ports.items:
397 self.pon_port = ports.items[0]
398
399 # Update the state of the UNI port
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400400 yield self.core_proxy.port_state_update(self.device_id,
401 port_type=Port.ETHERNET_UNI,
402 port_no=self.uni_port.port_no,
403 oper_status=OperStatus.ACTIVE)
khenaidoo92e62c52018-10-03 14:02:54 -0400404
405 # Update the state of the PON port
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400406 yield self.core_proxy.port_state_update(self.device_id,
407 port_type=Port.PON_ONU,
408 port_no=self.pon_port.port_no,
409 oper_status=OperStatus.ACTIVE)
khenaidoo92e62c52018-10-03 14:02:54 -0400410
khenaidoo6fdf0ba2018-11-02 14:38:33 -0400411 yield self.core_proxy.device_state_update(self.device_id,
412 oper_status=OperStatus.ACTIVE,
413 connect_status=ConnectStatus.REACHABLE)
khenaidoo92e62c52018-10-03 14:02:54 -0400414
khenaidoo91ecfd62018-11-04 17:13:42 -0500415 self.start_kpi_collection(self.device_id)
416
khenaidoo92e62c52018-10-03 14:02:54 -0400417 self.log.info('re-enabled', device_id=self.device_id)
khenaidoob9203542018-09-17 22:56:37 -0400418 except Exception, e:
419 self.log.exception('error-reenabling', e=e)
420
421 def delete(self):
422 self.log.info('deleting', device_id=self.device_id)
423
khenaidoob9203542018-09-17 22:56:37 -0400424 # TODO:
425 # 1) Remove all flows from the device
426 # 2) Remove the device from ponsim
427
428 self.log.info('deleted', device_id=self.device_id)
khenaidoo91ecfd62018-11-04 17:13:42 -0500429
430 def start_kpi_collection(self, device_id):
431 kafka_cluster_proxy = get_kafka_proxy()
432
433 @inlineCallbacks
434 def _collect(device_id, prefix):
435 try:
436 self.log.debug("pm-collection-interval")
437 # Proxy a message to ponsim_olt. The OLT will then query the ONU
438 # for statistics. The reply will
439 # arrive proxied back to us in self.receive_message().
440 msg = PonSimMetricsRequest(port=self.proxy_address.channel_id)
441
442 # Create a deferred to wait for the result as well as a transid
443 wait_for_result = Deferred()
444 trnsId = uuid4().hex
445 self.inter_adapter_message_deferred_map[
446 self._to_string(trnsId)] = wait_for_result
447
448 # Sends the request via proxy and wait for an ACK
449 yield self.adapter_proxy.send_inter_adapter_message(
450 msg=msg,
451 type=InterAdapterMessageType.METRICS_REQUEST,
452 from_adapter=self.adapter.name,
453 to_adapter=self.proxy_address.device_type,
454 to_device_id=self.device_id,
455 proxy_device_id=self.proxy_address.device_id,
456 message_id=trnsId
457 )
458 # Wait for the full response from the proxied adapter
459 res = yield wait_for_result
460 # Remove the transaction from the transaction map
461 del self.inter_adapter_message_deferred_map[self._to_string(trnsId)]
462
463 # Message is a reply to an ONU statistics request. Push it out to
464 # Kafka via adapter.submit_kpis().
465 if res.header.type == InterAdapterMessageType.METRICS_RESPONSE:
466 msg = InterAdapterResponseBody()
467 res.body.Unpack(msg)
468 self.log.debug('metrics-response-received', result=msg.status)
469 if self.pm_metrics:
470 self.log.debug('Handling incoming ONU metrics')
471 response = PonSimMetrics()
472 msg.body.Unpack(response)
473 port_metrics = self.pm_metrics.extract_metrics(response)
474 try:
475 ts = arrow.utcnow().timestamp
476 kpi_event = KpiEvent(
477 type=KpiEventType.slice,
478 ts=ts,
479 prefixes={
480 # OLT NNI port
481 prefix + '.uni': MetricValuePairs(
482 metrics=port_metrics['uni']),
483 # OLT PON port
484 prefix + '.pon': MetricValuePairs(
485 metrics=port_metrics['pon'])
486 }
487 )
488
489 self.log.debug(
490 'Submitting KPI for incoming ONU mnetrics')
491
492 # Step 3: submit directly to the kafka bus
493 if kafka_cluster_proxy:
494 if isinstance(kpi_event, Message):
495 kpi_event = dumps(
496 MessageToDict(kpi_event, True, True))
497 kafka_cluster_proxy.send_message("voltha.kpis",
498 kpi_event)
499
500 except Exception as e:
501 log.exception('failed-to-submit-kpis', e=e)
502 except Exception as e:
503 log.exception('failed-to-collect-metrics', e=e)
504
505 self.pm_metrics.start_collector(_collect)
506
507 def stop_kpi_collection(self):
508 self.pm_metrics.stop_collector()