# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import Dict import grpc, logging, queue, threading from common.method_wrappers.ServiceExceptions import ServiceException from common.proto import monitoring_pb2 from common.proto.context_pb2 import DeviceOperationalStatusEnum, Empty, EventTypeEnum from common.proto.kpi_sample_types_pb2 import KpiSampleType from context.client.ContextClient import ContextClient from monitoring.client.MonitoringClient import MonitoringClient from monitoring.service.MonitoringServiceServicerImpl import LOGGER from monitoring.service.NameMapping import NameMapping LOGGER = logging.getLogger(__name__) DEVICE_OP_STATUS_UNDEFINED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_UNDEFINED DEVICE_OP_STATUS_DISABLED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_DISABLED DEVICE_OP_STATUS_ENABLED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED DEVICE_OP_STATUS_NOT_ENABLED = {DEVICE_OP_STATUS_UNDEFINED, DEVICE_OP_STATUS_DISABLED} KPISAMPLETYPE_UNKNOWN = KpiSampleType.KPISAMPLETYPE_UNKNOWN class EventsDeviceCollector: def __init__(self, name_mapping : NameMapping) -> None: # pylint: disable=redefined-outer-name self._events_queue = queue.Queue() self._context_client_grpc = ContextClient() self._device_stream = self._context_client_grpc.GetDeviceEvents(Empty()) self._context_client = self._context_client_grpc self._channel = self._context_client_grpc.channel self._monitoring_client = MonitoringClient(host='127.0.0.1') self._device_thread = threading.Thread(target=self._collect, args=(self._device_stream,), daemon=False) self._device_to_state : Dict[str, DeviceOperationalStatusEnum] = dict() self._name_mapping = name_mapping def grpc_server_on(self): try: grpc.channel_ready_future(self._channel).result(timeout=15) return True except grpc.FutureTimeoutError: return False def _collect(self, events_stream): try: for event in events_stream: self._events_queue.put_nowait(event) except grpc.RpcError as e: if e.code() != grpc.StatusCode.CANCELLED: # pylint: disable=no-member raise # pragma: no cover def start(self): try: self._device_thread.start() except RuntimeError: LOGGER.exception('Start EventTools exception') def get_event(self, block : bool = True, timeout : float = 0.1): return self._events_queue.get(block=block, timeout=timeout) def stop(self): self._device_stream.cancel() self._device_thread.join() def listen_events(self): try: kpi_id_list = [] while True: # LOGGER.info('getting Kpi by KpiID') try: event = self.get_event(block=True, timeout=0.5) event_type = event.event.event_type device_uuid = event.device_id.device_uuid.uuid if event_type in {EventTypeEnum.EVENTTYPE_REMOVE}: self._device_to_state.pop(device_uuid, None) continue if event_type not in {EventTypeEnum.EVENTTYPE_CREATE, EventTypeEnum.EVENTTYPE_UPDATE}: # Unknown event type continue device = self._context_client.GetDevice(event.device_id) self._name_mapping.set_device_name(device_uuid, device.name) old_operational_status = self._device_to_state.get(device_uuid, DEVICE_OP_STATUS_UNDEFINED) device_was_not_enabled = (old_operational_status in DEVICE_OP_STATUS_NOT_ENABLED) new_operational_status = device.device_operational_status device_is_enabled = (new_operational_status == DEVICE_OP_STATUS_ENABLED) self._device_to_state[device_uuid] = new_operational_status activate_monitoring = device_was_not_enabled and device_is_enabled if not activate_monitoring: # device is not ready for monitoring continue for endpoint in device.device_endpoints: endpoint_uuid = endpoint.endpoint_id.endpoint_uuid.uuid self._name_mapping.set_endpoint_name(endpoint_uuid, endpoint.name) for value in endpoint.kpi_sample_types: if value == KPISAMPLETYPE_UNKNOWN: continue kpi_descriptor = monitoring_pb2.KpiDescriptor() kpi_descriptor.kpi_description = device.device_type kpi_descriptor.kpi_sample_type = value kpi_descriptor.device_id.CopyFrom(device.device_id) # pylint: disable=no-member kpi_descriptor.endpoint_id.CopyFrom(endpoint.endpoint_id) # pylint: disable=no-member kpi_id = self._monitoring_client.SetKpi(kpi_descriptor) kpi_id_list.append(kpi_id) except queue.Empty: break return kpi_id_list except ServiceException: LOGGER.exception('ListenEvents exception') except Exception: # pragma: no cover # pylint: disable=broad-except LOGGER.exception('ListenEvents exception')