WIP, pending update develop branch (917f709d) · Commits · TFS / controller

proto/monitoring.proto

+4 −4

Original line number	Diff line number	Diff line
		@@ -22,9 +22,9 @@ service MonitoringService {
		rpc CreateKpi (KpiDescriptor ) returns (KpiId ) {}
		rpc EditKpiDescriptor (EditedKpiDescriptor ) returns (context.Empty ) {}
		rpc DeleteKpi (KpiId ) returns (context.Empty ) {}
		rpc GetKpiDescriptor (KpiId ) returns (KpiDescriptor ) {}
		rpc GetKpiDescriptorList (context.Empty ) returns (KpiDescriptorList) {}
		rpc CreateBundleKpi (BundleKpiDescriptor ) returns (KpiId ) {}
		rpc GetKpiDescriptor (KpiId ) returns (KpiDescriptor ) {}
		rpc IncludeKpi (Kpi ) returns (context.Empty ) {}
		rpc MonitorKpi (MonitorKpiRequest ) returns (context.Empty ) {}
		rpc QueryKpiData (KpiQuery ) returns (KpiList ) {}
		@@ -37,8 +37,8 @@ service MonitoringService {
		rpc GetAlarms (context.Empty ) returns (AlarmIDList ) {}
		rpc GetAlarmDescriptor (AlarmID ) returns (AlarmDescriptor ) {}
		rpc GetAlarmResponseStream (AlarmID ) returns (stream AlarmResponse ) {}
		// rpc GetStreamKpi (KpiId ) returns (stream Kpi ) {}
		// rpc GetInstantKpi (KpiId ) returns (KpiList ) {}
		rpc GetStreamKpi (KpiId ) returns (stream Kpi ) {}
		rpc GetInstantKpi (KpiId ) returns (KpiList ) {}
		}

		message KpiDescriptor {

src/monitoring/client/MonitoringClient.py

+107 −9

Original line number	Diff line number	Diff line
		@@ -19,7 +19,9 @@ from common.Settings import get_service_host, get_service_port_grpc
		from common.tools.client.RetryDecorator import retry, delay_exponential
		from common.tools.grpc.Tools import grpc_message_to_json_string
		from monitoring.proto.context_pb2 import Empty
		from monitoring.proto.monitoring_pb2 import Kpi, KpiDescriptor, KpiId, MonitorKpiRequest
		from monitoring.proto.monitoring_pb2 import Kpi, KpiDescriptor, KpiId, MonitorKpiRequest, EditedKpiDescriptor, \
		KpiDescriptorList, BundleKpiDescriptor, KpiQuery, KpiList, SubsDescriptor, SubscriptionID, SubsIDList, \
		AlarmDescriptor, AlarmID, AlarmIDList, AlarmResponse
		from monitoring.proto.monitoring_pb2_grpc import MonitoringServiceStub

		LOGGER = logging.getLogger(__name__)
		@@ -54,6 +56,20 @@ class MonitoringClient:
		LOGGER.debug('CreateKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def EditKpiDescriptor(self, request : EditedKpiDescriptor) -> Empty:
		LOGGER.debug('EditKpiDescriptor: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.EditKpiDescriptor(request)
		LOGGER.info('EditKpiDescriptor result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def DeleteKpi(self,request : KpiId) -> Empty:
		LOGGER.debug('DeleteKpi: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.DeleteKpi(request)
		LOGGER.info('DeleteKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def GetKpiDescriptor(self, request : KpiId) -> KpiDescriptor:
		LOGGER.debug('GetKpiDescriptor: {:s}'.format(grpc_message_to_json_string(request)))
		@@ -61,6 +77,20 @@ class MonitoringClient:
		LOGGER.debug('GetKpiDescriptor result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def GetKpiDescriptorList(self, request : Empty) -> KpiDescriptorList:
		LOGGER.debug('GetKpiDescriptorList: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetKpiDescriptorList(request)
		LOGGER.debug('GetKpiDescriptorList result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def CreateBundleKpi(self, request : BundleKpiDescriptor) -> KpiId:
		LOGGER.debug('CreateBundleKpi: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.CreateBundleKpi(request)
		LOGGER.debug('CreateBundleKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def IncludeKpi(self, request : Kpi) -> Empty:
		LOGGER.debug('IncludeKpi: {:s}'.format(grpc_message_to_json_string(request)))
		@@ -76,19 +106,87 @@ class MonitoringClient:
		return response

		@RETRY_DECORATOR
		def GetStreamKpi(self, request : KpiId) -> Iterator[Kpi]:
		LOGGER.debug('GetStreamKpi: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetStreamKpi(request)
		LOGGER.debug('GetStreamKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		def QueryKpiData(self, request : KpiQuery) -> KpiList:
		LOGGER.debug('QueryKpiData: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.QueryKpiData(request)
		LOGGER.debug('QueryKpiData result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def SubscribeKpi(self, request : SubsDescriptor) -> Iterator[KpiList]:
		LOGGER.debug('SubscribeKpi: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.SubscribeKpi(request)
		LOGGER.debug('SubscribeKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def GetSubsDescriptor(self, request : SubscriptionID) -> SubsDescriptor:
		LOGGER.debug('GetSubsDescriptor: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetSubsDescriptor(request)
		LOGGER.debug('GetSubsDescriptor result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def GetInstantKpi(self, request : KpiId) -> Kpi:
		LOGGER.debug('GetInstantKpi: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetInstantKpi(request)
		LOGGER.debug('GetInstantKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		def GetSubscriptions(self, request : Empty) -> SubsIDList:
		LOGGER.debug('GetSubscriptions: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetSubscriptions(request)
		LOGGER.debug('GetSubscriptions result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def EditKpiSubscription(self, request : SubsDescriptor) -> Empty:
		LOGGER.debug('EditKpiSubscription: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetSubscriptions(request)
		LOGGER.debug('EditKpiSubscription result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def CreateKpiAlarm(self, request : AlarmDescriptor) -> AlarmID:
		LOGGER.debug('CreateKpiAlarm: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.CreateKpiAlarm(request)
		LOGGER.debug('CreateKpiAlarm result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def EditKpiAlarm(self, request : AlarmDescriptor) -> Empty:
		LOGGER.debug('EditKpiAlarm: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.EditKpiAlarm(request)
		LOGGER.debug('EditKpiAlarm result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		@RETRY_DECORATOR
		def GetAlarms(self, request : Empty) -> AlarmIDList:
		LOGGER.debug('GetAlarms: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetAlarms(request)
		LOGGER.debug('GetAlarms result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		def GetAlarmDescriptor(self, request : AlarmID) -> AlarmDescriptor:
		LOGGER.debug('GetAlarmDescriptor: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetAlarmDescriptor(request)
		LOGGER.debug('GetAlarmDescriptor result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		def GetAlarmResponseStream(self, request : AlarmID) -> AlarmResponse:
		LOGGER.debug('GetAlarmResponseStream: {:s}'.format(grpc_message_to_json_string(request)))
		response = self.stub.GetAlarmResponseStream(request)
		LOGGER.debug('GetAlarmResponseStream result: {:s}'.format(grpc_message_to_json_string(response)))
		return response

		# @RETRY_DECORATOR
		# def GetStreamKpi(self, request : KpiId) -> Iterator[Kpi]:
		# LOGGER.debug('GetStreamKpi: {:s}'.format(grpc_message_to_json_string(request)))
		# response = self.stub.GetStreamKpi(request)
		# LOGGER.debug('GetStreamKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		# return response
		#
		# @RETRY_DECORATOR
		# def GetInstantKpi(self, request : KpiId) -> Kpi:
		# LOGGER.debug('GetInstantKpi: {:s}'.format(grpc_message_to_json_string(request)))
		# response = self.stub.GetInstantKpi(request)
		# LOGGER.debug('GetInstantKpi result: {:s}'.format(grpc_message_to_json_string(response)))
		# return response


		if __name__ == '__main__':
		import sys

src/monitoring/client/monitoring_client.py

deleted100644 → 0

+0 −150

Original line number	Diff line number	Diff line
		# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		#
		# 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.

		import sys
		import grpc

		from monitoring.proto import monitoring_pb2
		from monitoring.proto import monitoring_pb2_grpc
		from monitoring.proto import context_pb2

		from common.logger import getJSONLogger
		LOGGER = getJSONLogger('monitoring-client')
		LOGGER.setLevel('DEBUG')

		class MonitoringClient:

		def __init__(self, server='monitoring', port='7070'):
		endpoint = '{}:{}'.format(server, port)
		LOGGER.info('init monitoringClient {}'.format(endpoint))
		self.channel = grpc.insecure_channel(endpoint)
		self.server = monitoring_pb2_grpc.MonitoringServiceStub(self.channel)

		def CreateKpi(self, request):
		LOGGER.info('CreateKpi: {}'.format(request))
		response = self.server.CreateKpi(request)
		LOGGER.info('CreateKpi result: {}'.format(response))
		return response

		def EditKpiDescriptor(self, request):
		LOGGER.info('EditKpiDescriptor: {}'.format(request))
		response = self.server.EditKpiDescriptor(request)
		LOGGER.info('EditKpiDescriptor result: {}'.format(response))
		return response

		def DeleteKpi(self, request):
		LOGGER.info('DeleteKpi: {}'.format(request))
		response = self.server.DeleteKpi(request)
		LOGGER.info('DeleteKpi result: {}'.format(response))
		return response

		def GetKpiDescriptorList(self, request):
		LOGGER.info('GetKpiDescriptorList: {}'.format(request))
		response = self.server.GetKpiDescriptorList(request)
		LOGGER.info('GetKpiDescriptorList result: {}'.format(response))
		return response

		def CreateBundleKpi(self, request):
		LOGGER.info('CreateBundleKpi: {}'.format(request))
		response = self.server.CreateBundleKpi(request)
		LOGGER.info('CreateBundleKpi result: {}'.format(response))
		return response

		def GetKpiDescriptor(self, request):
		LOGGER.info('GetKpiDescriptor: {}'.format(request))
		response = self.server.GetKpiDescriptor(request)
		LOGGER.info('GetKpiDescriptor result: {}'.format(response))
		return response

		def MonitorKpi(self, request):
		LOGGER.info('MonitorKpi: {}'.format(request))
		response = self.server.MonitorKpi(request)
		LOGGER.info('MonitorKpi result: {}'.format(response))
		return response

		def IncludeKpi(self, request):
		LOGGER.info('IncludeKpi: {}'.format(request))
		response = self.server.IncludeKpi(request)
		LOGGER.info('IncludeKpi result: {}'.format(response))
		return response

		def QueryKpiData(self, request):
		LOGGER.info('QueryKpiData: {}'.format(request))
		response = self.server.QueryKpiData(request)
		LOGGER.info('QueryKpiData result: {}'.format(response))
		return response

		def SubscribeKpi(self, request):
		LOGGER.info('SubscribeKpi: {}'.format(request))
		response = self.server.SubscribeKpi(request)
		LOGGER.info('SubscribeKpi result: {}'.format(response))
		return response

		def GetSubsDescriptor(self, request):
		LOGGER.info('GetSubsDescriptor: {}'.format(request))
		response = self.server.GetSubsDescriptor(request)
		LOGGER.info('GetSubsDescriptor result: {}'.format(response))
		return response

		def EditKpiSubscription(self, request):
		LOGGER.info('EditKpiSubscription: {}'.format(request))
		response = self.server.EditKpiSubscription(request)
		LOGGER.info('EditKpiSubscription result: {}'.format(response))
		return response

		def CreateKpiAlarm(self, request):
		LOGGER.info('CreateKpiAlarm: {}'.format(request))
		response = self.server.CreateKpiAlarm(request)
		LOGGER.info('CreateKpiAlarm result: {}'.format(response))
		return response

		def EditKpiAlarm(self, request):
		LOGGER.info('EditKpiAlarm: {}'.format(request))
		response = self.server.EditKpiAlarm(request)
		LOGGER.info('EditKpiAlarm result: {}'.format(response))
		return response

		def GetAlarms(self, request):
		LOGGER.info('GetAlarms: {}'.format(request))
		response = self.server.GetAlarms(request)
		LOGGER.info('GetAlarms result: {}'.format(response))
		return response

		def GetAlarmDescriptor(self, request):
		LOGGER.info('GetAlarmDescriptor: {}'.format(request))
		response = self.server.GetAlarmDescriptor(request)
		LOGGER.info('GetAlarmDescriptor result: {}'.format(response))
		return response


		# def GetStreamKpi(self, request):
		# LOGGER.info('GetStreamKpi: {}'.format(request))
		# response = self.server.GetStreamKpi(request)
		# LOGGER.info('GetStreamKpi result: {}'.format(response))
		# yield monitoring_pb2.Kpi()
		#
		# def GetInstantKpi(self, request):
		# LOGGER.info('GetInstantKpi: {}'.format(request))
		# response = self.server.GetInstantKpi(request)
		# LOGGER.info('GetInstantKpi result: {}'.format(response))
		# return monitoring_pb2.Kpi()



		if __name__ == '__main__':
		# get port
		port = sys.argv[1] if len(sys.argv) > 1 else '7070'

		# make call to server
		client = MonitoringClient(port=port)

src/monitoring/service/MonitoringServiceServicerImpl.py

+30 −14

Original line number	Diff line number	Diff line
		@@ -14,13 +14,17 @@

		import os,grpc, logging
		import socket
		from typing import Iterator

		from prometheus_client import Summary
		from prometheus_client import Counter
		from common.Settings import get_setting
		from context.proto.context_pb2 import Empty

		from monitoring.Config import DEVICE_GRPC_SERVICE_PORT, DEVICE_SERVICE_HOST
		from monitoring.proto.kpi_sample_types_pb2 import KpiSampleType
		from monitoring.proto.monitoring_pb2 import AlarmResponse, AlarmDescriptor, AlarmIDList, SubsIDList, KpiId, \
		KpiDescriptor, KpiList, KpiQuery, SubsDescriptor, SubscriptionID, AlarmID
		from monitoring.service import SqliteTools, InfluxTools
		from monitoring.proto import monitoring_pb2
		from monitoring.proto import monitoring_pb2_grpc
		@@ -42,8 +46,8 @@ INFLUXDB_USER = os.environ.get("INFLUXDB_USER")
		INFLUXDB_PASSWORD = os.environ.get("INFLUXDB_PASSWORD")
		INFLUXDB_DATABASE = os.environ.get("INFLUXDB_DATABASE")

		DEVICE_SERVICE_HOST = get_setting('DEVICESERVICE_SERVICE_HOST', default=DEVICE_SERVICE_HOST )
		DEVICE_SERVICE_PORT = get_setting('DEVICESERVICE_SERVICE_PORT_GRPC', default=DEVICE_GRPC_SERVICE_PORT)
		DEVICESERVICE_SERVICE_HOST = get_setting('DEVICESERVICE_SERVICE_HOST', default=DEVICE_SERVICE_HOST )
		DEVICESERVICE_SERVICE_PORT_GRPC = get_setting('DEVICESERVICE_SERVICE_PORT_GRPC', default=DEVICE_GRPC_SERVICE_PORT)


		class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceServicer):
		@@ -52,7 +56,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService

		# Init sqlite monitoring db
		self.sql_db = SqliteTools.SQLite('monitoring.db')
		self.deviceClient = DeviceClient(address=DEVICE_SERVICE_HOST, port=DEVICE_GRPC_SERVICE_PORT) # instantiate the client
		self.deviceClient = DeviceClient(host=DEVICESERVICE_SERVICE_HOST, port=DEVICE_GRPC_SERVICE_PORT) # instantiate the client

		# Create influx_db client
		self.influx_db = InfluxTools.Influx(INFLUXDB_HOSTNAME,"8086",INFLUXDB_USER,INFLUXDB_PASSWORD,INFLUXDB_DATABASE)
		@@ -211,7 +215,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		# return monitoring_pb2.Kpi()


		def GetKpiDescriptor(self, request : monitoring_pb2.KpiId, grpc_context : grpc.ServicerContext) -> monitoring_pb2.KpiDescriptor:
		def GetKpiDescriptor(self, request : KpiId, grpc_context : grpc.ServicerContext) -> KpiDescriptor:
		LOGGER.info('getting Kpi by KpiID')
		try:
		kpi_db = self.sql_db.get_KPI(int(request.kpi_id.uuid))
		@@ -235,7 +239,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetKpiDescriptor exception')

		def QueryKpiData ( self, request : monitoring_pb2.KpiQuery, grpc_context : grpc.ServicerContext) -> monitoring_pb2.KpiList:
		def QueryKpiData ( self, request : KpiQuery, grpc_context : grpc.ServicerContext) -> KpiList:

		LOGGER.info('QueryKpiData')
		try:
		@@ -247,7 +251,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('QueryKpiData exception')

		def SubscribeKpi ( self, request : monitoring_pb2.SubsDescriptor, grpc_context : grpc.ServicerContext) -> monitoring_pb2.KpiList:
		def SubscribeKpi ( self, request : SubsDescriptor, grpc_context : grpc.ServicerContext) -> KpiList:

		LOGGER.info('SubscribeKpi')
		try:
		@@ -260,7 +264,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		LOGGER.exception('SubscribeKpi exception')


		def GetSubsDescriptor ( self, request : monitoring_pb2.SubscriptionID, grpc_context : grpc.ServicerContext) -> monitoring_pb2.SubsDescriptor:
		def GetSubsDescriptor ( self, request : SubscriptionID, grpc_context : grpc.ServicerContext) -> SubsDescriptor:

		LOGGER.info('GetSubsDescriptor')
		try:
		@@ -272,7 +276,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetSubsDescriptor exception')

		def GetSubscriptions ( self, request : context_pb2.Empty, grpc_context : grpc.ServicerContext) -> monitoring_pb2.SubsIDList:
		def GetSubscriptions ( self, request : Empty, grpc_context : grpc.ServicerContext) -> SubsIDList:

		LOGGER.info('GetSubscriptions')
		try:
		@@ -284,7 +288,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetSubscriptions exception')

		def EditKpiSubscription ( self, request : monitoring_pb2.SubsDescriptor, grpc_context : grpc.ServicerContext) -> context_pb2.Empty:
		def EditKpiSubscription ( self, request : SubsDescriptor, grpc_context : grpc.ServicerContext) -> Empty:

		LOGGER.info('EditKpiSubscription')
		try:
		@@ -296,7 +300,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('EditKpiSubscription exception')

		def CreateKpiAlarm ( self, request : monitoring_pb2.AlarmDescriptor, grpc_context : grpc.ServicerContext) -> monitoring_pb2.AlarmResponse:
		def CreateKpiAlarm ( self, request : AlarmDescriptor, grpc_context : grpc.ServicerContext) -> AlarmResponse:

		LOGGER.info('CreateKpiAlarm')
		try:
		@@ -308,7 +312,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('CreateKpiAlarm exception')

		def EditKpiAlarm ( self, request : monitoring_pb2.AlarmDescriptor, grpc_context : grpc.ServicerContext) -> context_pb2.Empty:
		def EditKpiAlarm ( self, request : AlarmDescriptor, grpc_context : grpc.ServicerContext) -> Empty:

		LOGGER.info('EditKpiAlarm')
		try:
		@@ -320,7 +324,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('EditKpiAlarm exception')

		def GetAlarms ( self, request : context_pb2.Empty, grpc_context : grpc.ServicerContext) -> monitoring_pb2.AlarmIDList:
		def GetAlarms ( self, request : context_pb2.Empty, grpc_context : grpc.ServicerContext) -> AlarmIDList:

		LOGGER.info('GetAlarms')
		try:
		@@ -332,7 +336,7 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetAlarms exception')

		def GetAlarmDescriptor ( self, request : monitoring_pb2.AlarmID, grpc_context : grpc.ServicerContext) -> monitoring_pb2.AlarmDescriptor:
		def GetAlarmDescriptor ( self, request : AlarmID, grpc_context : grpc.ServicerContext) -> AlarmDescriptor:

		LOGGER.info('GetAlarmDescriptor')
		try:
		@@ -343,3 +347,15 @@ class MonitoringServiceServicerImpl(monitoring_pb2_grpc.MonitoringServiceService
		grpc_context.abort(e.code, e.details)
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetAlarmDescriptor exception')

		def GetAlarmResponseStream(self, request : AlarmID, grpc_context : grpc.ServicerContext) -> Iterator[AlarmResponse]:

		LOGGER.info('GetAlarmResponseStream')
		try:
		# TBC
		yield monitoring_pb2.AlarmResponse()
		except ServiceException as e:
		LOGGER.exception('GetAlarmResponseStream exception')
		grpc_context.abort(e.code, e.details)
		except Exception as e: # pragma: no cover
		LOGGER.exception('GetAlarmResponseStream exception')

src/monitoring/tests/test_unitary.py

+16 −17

Original line number	Diff line number	Diff line
		@@ -19,7 +19,7 @@ import pytest
		from typing import Tuple


		from monitoring.client.monitoring_client import MonitoringClient
		from monitoring.client.MonitoringClient import MonitoringClient
		from monitoring.Config import GRPC_SERVICE_PORT, GRPC_MAX_WORKERS, GRPC_GRACE_PERIOD, DEVICE_GRPC_SERVICE_PORT
		from monitoring.proto import context_pb2, monitoring_pb2
		from monitoring.proto.kpi_sample_types_pb2 import KpiSampleType
		@@ -31,18 +31,19 @@ from common.orm.Database import Database
		from common.orm.Factory import get_database_backend, BackendEnum as DatabaseBackendEnum
		from common.message_broker.Factory import get_messagebroker_backend, BackendEnum as MessageBrokerBackendEnum
		from common.message_broker.MessageBroker import MessageBroker
		from common.Constants import ServiceNameEnum
		from common.Settings import get_grpc_max_workers, get_service_port_grpc, get_grpc_grace_period

		from context.Config import (
		GRPC_SERVICE_PORT as grpc_port_context,
		GRPC_MAX_WORKERS as grpc_workers_context,
		GRPC_GRACE_PERIOD as grpc_grace_context
		)
		from context.client.ContextClient import ContextClient
		from context.service.grpc_server.ContextService import ContextService
		from context.service.Populate import populate
		from context.proto.context_pb2 import EventTypeEnum, DeviceEvent, Device
		from context.tests.Objects import (DEVICE_R1, DEVICE_R1_UUID)

		from .PrepareTestScenario import ( # pylint: disable=unused-import
		# be careful, order of symbols is important here!
		mock_service, device_service, context_client, device_client, monitoring_client, test_prepare_environment)

		LOGGER = logging.getLogger(__name__)
		LOGGER.setLevel(logging.DEBUG)

		@@ -52,11 +53,13 @@ LOGGER.setLevel(logging.DEBUG)

		SERVER_ADDRESS = '127.0.0.1'
		LISTEN_ADDRESS = '[::]'
		GRPC_PORT_MONITORING = 7070

		GRPC_PORT_CONTEXT = 10000 + grpc_port_context # avoid privileged ports
		DEVICE_GRPC_SERVICE_PORT = 10000 + DEVICE_GRPC_SERVICE_PORT # avoid privileged ports
		MONITORING_GRPC_SERVICE_PORT = GRPC_PORT_MONITORING # avoid privileged ports
		GRPC_PORT_CONTEXT = 10000 + get_service_port_grpc(ServiceNameEnum.CONTEXT) # avoid privileged ports
		DEVICE_GRPC_SERVICE_PORT = 10000 + get_service_port_grpc(ServiceNameEnum.DEVICE) # avoid privileged ports
		MONITORING_GRPC_SERVICE_PORT = get_service_port_grpc(ServiceNameEnum.MONITORING) # avoid privileged ports

		grpc_workers_context = get_grpc_max_workers()
		grpc_grace_context = get_grpc_grace_period()


		SCENARIOS = [ # comment/uncomment scenarios to activate/deactivate them in the test unit
		@@ -81,18 +84,14 @@ def context_db_mb(request) -> Tuple[Database, MessageBroker]:

		@pytest.fixture(scope='session')
		def context_service_grpc(context_db_mb : Tuple[Database, MessageBroker]): # pylint: disable=redefined-outer-name
		database = context_db_mb[0]
		database.clear_all()
		_service = ContextService(
		database, context_db_mb[1], port=GRPC_PORT_CONTEXT, max_workers=grpc_workers_context,
		grace_period=grpc_grace_context)
		_service = ContextService(context_db_mb[0], context_db_mb[1])
		_service.start()
		yield _service
		_service.stop()

		@pytest.fixture(scope='session')
		def context_client_grpc(context_service_grpc : ContextService): # pylint: disable=redefined-outer-name
		_client = ContextClient(address='localhost', port=GRPC_PORT_CONTEXT)
		_client = ContextClient(host='localhost', port=GRPC_PORT_CONTEXT)
		yield _client
		_client.close()

		@@ -122,7 +121,7 @@ def monitoring_service():
		@pytest.fixture(scope='session')
		def monitoring_client(monitoring_service):
		LOGGER.warning('monitoring_client begin')
		client = MonitoringClient(server=SERVER_ADDRESS, port=GRPC_PORT_MONITORING) # instantiate the client
		client = MonitoringClient(host=SERVER_ADDRESS, port=MONITORING_GRPC_SERVICE_PORT) # instantiate the client
		LOGGER.warning('monitoring_client returning')
		return client