Revert "First implementation of PolicyService." (9416c3e4) · Commits · TFS / controller

src/context/service/database/PolicyRuleModel.py

deleted100644 → 0

+0 −55

Original line number	Original line	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 logging
	from typing import Dict, List, Optional, Tuple
	from common.orm.Database import Database
	from common.orm.HighLevel import get_object
	from common.orm.backend.Tools import key_to_str
	from common.orm.fields.EnumeratedField import EnumeratedField
	from common.orm.fields.ForeignKeyField import ForeignKeyField
	from common.orm.fields.PrimaryKeyField import PrimaryKeyField
	from common.orm.fields.StringField import StringField
	from common.orm.model.Model import Model
	from common.proto.context_pb2 import EndPointId
	from .DeviceModel import DeviceModel
	from .KpiSampleType import ORM_KpiSampleTypeEnum, grpc_to_enum__kpi_sample_type
	from .TopologyModel import TopologyModel

	LOGGER = logging.getLogger(__name__)


	class PolicyRuleModel(Model):
	pk = PrimaryKeyField()
	value = StringField(required=True, allow_empty=False)

	def delete(self) -> None:
	db_policy_rule_pks = self.references(PolicyRuleModel)
	for pk,_ in db_policy_rule_pks:
	PolicyRuleModel(self.database, pk).delete()
	super().delete()

	def dump_id(self) -> Dict:
	if 'service' in self.value:
	policy_rule_type = 'service'
	else:
	policy_rule_type = 'device'

	result = {
	'uuid': self.value[policy_rule_type].uuid
	}
	return result

	def dump(self) -> Dict:
	return self.value

src/context/service/grpc_server/ContextServiceServicerImpl.py

+1 −59

Original line number	Original line	Diff line number	Diff line
	@@ -28,16 +28,13 @@ from common.proto.context_pb2 import (
	Service, ServiceEvent, ServiceId, ServiceIdList, ServiceList,		Service, ServiceEvent, ServiceId, ServiceIdList, ServiceList,
	Slice, SliceEvent, SliceId, SliceIdList, SliceList,		Slice, SliceEvent, SliceId, SliceIdList, SliceList,
	Topology, TopologyEvent, TopologyId, TopologyIdList, TopologyList)		Topology, TopologyEvent, TopologyId, TopologyIdList, TopologyList)
	from common.proto.policy_pb2 import (PolicyRuleIdList, PolicyRuleId, PolicyRuleList, PolicyRule)
	from common.proto.context_pb2_grpc import ContextServiceServicer		from common.proto.context_pb2_grpc import ContextServiceServicer
	from common.proto.context_policy_pb2_grpc import ContextPolicyServiceServicer
	from common.rpc_method_wrapper.Decorator import create_metrics, safe_and_metered_rpc_method		from common.rpc_method_wrapper.Decorator import create_metrics, safe_and_metered_rpc_method
	from common.rpc_method_wrapper.ServiceExceptions import InvalidArgumentException		from common.rpc_method_wrapper.ServiceExceptions import InvalidArgumentException
	from context.service.database.ConfigModel import update_config		from context.service.database.ConfigModel import update_config
	from context.service.database.ConnectionModel import ConnectionModel, set_path		from context.service.database.ConnectionModel import ConnectionModel, set_path
	from context.service.database.ConstraintModel import set_constraints		from context.service.database.ConstraintModel import set_constraints
	from context.service.database.ContextModel import ContextModel		from context.service.database.ContextModel import ContextModel
	from context.service.database.PolicyRuleModel import PolicyRuleModel
	from context.service.database.DeviceModel import DeviceModel, grpc_to_enum__device_operational_status, set_drivers		from context.service.database.DeviceModel import DeviceModel, grpc_to_enum__device_operational_status, set_drivers
	from context.service.database.EndPointModel import EndPointModel, set_kpi_sample_types		from context.service.database.EndPointModel import EndPointModel, set_kpi_sample_types
	from context.service.database.Events import notify_event		from context.service.database.Events import notify_event
	@@ -52,7 +49,6 @@ from context.service.database.TopologyModel import TopologyModel
	from .Constants import (		from .Constants import (
	CONSUME_TIMEOUT, TOPIC_CONNECTION, TOPIC_CONTEXT, TOPIC_DEVICE, TOPIC_LINK, TOPIC_SERVICE, TOPIC_SLICE,		CONSUME_TIMEOUT, TOPIC_CONNECTION, TOPIC_CONTEXT, TOPIC_DEVICE, TOPIC_LINK, TOPIC_SERVICE, TOPIC_SLICE,
	TOPIC_TOPOLOGY)		TOPIC_TOPOLOGY)
	from common.tools.grpc.Tools import grpc_message_to_json_string

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

	@@ -65,12 +61,11 @@ METHOD_NAMES = [
	'ListLinkIds', 'ListLinks', 'GetLink', 'SetLink', 'RemoveLink', 'GetLinkEvents',		'ListLinkIds', 'ListLinks', 'GetLink', 'SetLink', 'RemoveLink', 'GetLinkEvents',
	'ListServiceIds', 'ListServices', 'GetService', 'SetService', 'RemoveService', 'GetServiceEvents',		'ListServiceIds', 'ListServices', 'GetService', 'SetService', 'RemoveService', 'GetServiceEvents',
	'ListSliceIds', 'ListSlices', 'GetSlice', 'SetSlice', 'RemoveSlice', 'GetSliceEvents',		'ListSliceIds', 'ListSlices', 'GetSlice', 'SetSlice', 'RemoveSlice', 'GetSliceEvents',
	'ListPolicyRuleIds', 'ListPolicyRules', 'GetPolicyRule', 'SetPolicyRule', 'RemovePolicyRule',
	'UnsetService', 'UnsetSlice',		'UnsetService', 'UnsetSlice',
	]		]
	METRICS = create_metrics(SERVICE_NAME, METHOD_NAMES)		METRICS = create_metrics(SERVICE_NAME, METHOD_NAMES)

	class ContextServiceServicerImpl(ContextServiceServicer, ContextPolicyServiceServicer):		class ContextServiceServicerImpl(ContextServiceServicer):
	def __init__(self, database : Database, messagebroker : MessageBroker):		def __init__(self, database : Database, messagebroker : MessageBroker):
	LOGGER.debug('Creating Servicer...')		LOGGER.debug('Creating Servicer...')
	self.lock = threading.Lock()		self.lock = threading.Lock()
	@@ -78,59 +73,6 @@ class ContextServiceServicerImpl(ContextServiceServicer, ContextPolicyServiceSer
	self.messagebroker = messagebroker		self.messagebroker = messagebroker
	LOGGER.debug('Servicer Created')		LOGGER.debug('Servicer Created')

	# ----- Policy ----------------------------------------------------------------------------------------------------
	@safe_and_metered_rpc_method(METRICS, LOGGER)
	def ListPolicyRuleIds(self, request: Empty, context: grpc.ServicerContext) -> PolicyRuleIdList:
	with self.lock:
	db_policy_rules: List[PolicyRuleModel] = get_all_objects(self.database, PolicyRuleModel)
	db_policy_rules = sorted(db_policy_rules, key=operator.attrgetter('pk'))
	return PolicyRuleIdList(policies_ids=[db_policy_rule.dump_id() for db_policy_rule in db_policy_rules])

	@safe_and_metered_rpc_method(METRICS, LOGGER)
	def ListPolicyRules(self, request: Empty, context: grpc.ServicerContext) -> PolicyRuleList:
	with self.lock:
	db_policy_rules: List[PolicyRuleModel] = get_all_objects(self.database, PolicyRuleModel)
	db_policy_rules = sorted(db_policy_rules, key=operator.attrgetter('pk'))
	return PolicyRuleList(contexts=[db_policy_rule.dump() for db_policy_rule in db_policy_rules])

	@safe_and_metered_rpc_method(METRICS, LOGGER)
	def GetPolicyRule(self, request: PolicyRuleId, context: grpc.ServicerContext) -> PolicyRule:
	with self.lock:
	policy_rule_uuid = request.uuid
	db_policy_rule: PolicyRuleModel = get_object(self.database, PolicyRuleModel, policy_rule_uuid)
	return PolicyRule(**db_policy_rule.dump())

	@safe_and_metered_rpc_method(METRICS, LOGGER)
	def SetPolicyRule(self, request: PolicyRule, context: grpc.ServicerContext) -> PolicyRuleId:
	with self.lock:
	policy_rule_type = request.WichOneof('policy_rule')
	policy_rule_json = grpc_message_to_json_string(request)
	# policy = PolicyRuleModel(**policy_rule_json)
	policy_rule_uuid = policy_rule_json[policy_rule_type]['policyRuleBasic'].uuid

	result: Tuple[PolicyRuleModel, bool] = update_or_create_object(
	self.database, PolicyRuleModel, policy_rule_uuid, policy_rule_json)
	db_policy, updated = result

	event_type = EventTypeEnum.EVENTTYPE_UPDATE if updated else EventTypeEnum.EVENTTYPE_CREATE
	dict_policy_id = db_policy.dump_id()
	notify_event(self.messagebroker, TOPIC_CONTEXT, event_type, {'policy_id': dict_policy_id})
	return PolicyRuleId(**dict_policy_id)

	@safe_and_metered_rpc_method(METRICS, LOGGER)
	def RemovePolicyRule(self, request: PolicyRuleId, context: grpc.ServicerContext) -> Empty:
	with self.lock:
	policy_uuid = request.uuid
	db_policy = PolicyRuleModel(self.database, policy_uuid, auto_load=False)
	found = db_policy.load()
	if not found:
	return Empty()

	dict_policy_id = db_policy.dump_id()
	db_policy.delete()
	event_type = EventTypeEnum.EVENTTYPE_REMOVE
	notify_event(self.messagebroker, TOPIC_CONTEXT, event_type, {'context_id': dict_policy_id})
	return Empty()

	# ----- Context ----------------------------------------------------------------------------------------------------		# ----- Context ----------------------------------------------------------------------------------------------------