diff --git a/src/service/service/database/ConfigModel.py b/src/service/service/database/ConfigModel.py
deleted file mode 100644
index 8472a44eaefefceaee36dcbe40d9a427eb2cbb36..0000000000000000000000000000000000000000
--- a/src/service/service/database/ConfigModel.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# 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 functools, logging, operator
-from enum import Enum
-from typing import Dict, List, Tuple, Union
-from common.orm.Database import Database
-from common.orm.HighLevel import get_object, get_or_create_object, update_or_create_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.IntegerField import IntegerField
-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 ConfigActionEnum
-from common.tools.grpc.Tools import grpc_message_to_json_string
-from .Tools import fast_hasher, grpc_to_enum, remove_dict_key
-
-LOGGER = logging.getLogger(__name__)
-
-class ORM_ConfigActionEnum(Enum):
- UNDEFINED = ConfigActionEnum.CONFIGACTION_UNDEFINED
- SET = ConfigActionEnum.CONFIGACTION_SET
- DELETE = ConfigActionEnum.CONFIGACTION_DELETE
-
-grpc_to_enum__config_action = functools.partial(
- grpc_to_enum, ConfigActionEnum, ORM_ConfigActionEnum)
-
-class ConfigModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
-
- def dump(self) -> List[Dict]:
- db_config_rule_pks = self.references(ConfigRuleModel)
- config_rules = [ConfigRuleModel(self.database, pk).dump(include_position=True) for pk,_ in db_config_rule_pks]
- config_rules = sorted(config_rules, key=operator.itemgetter('position'))
- return [remove_dict_key(config_rule, 'position') for config_rule in config_rules]
-
-class ConfigRuleModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- config_fk = ForeignKeyField(ConfigModel)
- position = IntegerField(min_value=0, required=True)
- action = EnumeratedField(ORM_ConfigActionEnum, required=True)
- key = StringField(required=True, allow_empty=False)
- value = StringField(required=False, allow_empty=True)
-
- def dump(self, include_position=True) -> Dict: # pylint: disable=arguments-differ
- result = {
- 'action': self.action.value,
- 'custom': {
- 'resource_key': self.key,
- 'resource_value': self.value,
- },
- }
- if include_position: result['position'] = self.position
- return result
-
-def delete_all_config_rules(database : Database, db_parent_pk : str, config_name : str) -> None:
- str_config_key = key_to_str([db_parent_pk, config_name], separator=':')
- db_config : ConfigModel = get_object(database, ConfigModel, str_config_key, raise_if_not_found=False)
- if db_config is None: return
- db_config_rule_pks = db_config.references(ConfigRuleModel)
- for pk,_ in db_config_rule_pks: ConfigRuleModel(database, pk).delete()
-
-def grpc_config_rules_to_raw(grpc_config_rules) -> List[Tuple[ORM_ConfigActionEnum, str, str]]:
- def translate(grpc_config_rule):
- action = grpc_to_enum__config_action(grpc_config_rule.action)
- config_rule_type = str(grpc_config_rule.WhichOneof('config_rule'))
- if config_rule_type != 'custom':
- raise NotImplementedError('ConfigRule of type {:s} is not implemented: {:s}'.format(
- config_rule_type, grpc_message_to_json_string(grpc_config_rule)))
- return action, grpc_config_rule.custom.resource_key, grpc_config_rule.custom.resource_value
- return [translate(grpc_config_rule) for grpc_config_rule in grpc_config_rules]
-
-def get_config_rules(
- database : Database, db_parent_pk : str, config_name : str
- ) -> List[Tuple[ORM_ConfigActionEnum, str, str]]:
-
- str_config_key = key_to_str([db_parent_pk, config_name], separator=':')
- db_config = get_object(database, ConfigModel, str_config_key, raise_if_not_found=False)
- return [] if db_config is None else [
- # pylint: disable=no-member, protected-access
- (ORM_ConfigActionEnum._value2member_map_.get(config_rule['action']),
- config_rule['custom']['resource_key'], config_rule['custom']['resource_value'])
- for config_rule in db_config.dump()
- if 'custom' in config_rule
- ]
-
-def update_config(
- database : Database, db_parent_pk : str, config_name : str,
- raw_config_rules : List[Tuple[ORM_ConfigActionEnum, str, str]]
-) -> List[Tuple[Union[ConfigModel, ConfigRuleModel], bool]]:
-
- str_config_key = key_to_str([db_parent_pk, config_name], separator=':')
- result : Tuple[ConfigModel, bool] = get_or_create_object(database, ConfigModel, str_config_key)
- db_config, created = result
-
- db_objects : List[Tuple[Union[ConfigModel, ConfigRuleModel], bool]] = [(db_config, created)]
-
- for position,(action, resource_key, resource_value) in enumerate(raw_config_rules):
- str_rule_key_hash = fast_hasher(resource_key)
- str_config_rule_key = key_to_str([db_config.pk, str_rule_key_hash], separator=':')
- result : Tuple[ConfigRuleModel, bool] = update_or_create_object(
- database, ConfigRuleModel, str_config_rule_key, {
- 'config_fk': db_config, 'position': position, 'action': action, 'key': resource_key,
- 'value': resource_value,
- })
- db_config_rule, updated = result
- db_objects.append((db_config_rule, updated))
-
- return db_objects
diff --git a/src/service/service/database/ConstraintModel.py b/src/service/service/database/ConstraintModel.py
deleted file mode 100644
index f75acf540fa04349cc3925bb11db94581232dd85..0000000000000000000000000000000000000000
--- a/src/service/service/database/ConstraintModel.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# 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, operator
-from typing import Dict, List, Tuple, Union
-from common.orm.Database import Database
-from common.orm.HighLevel import get_object, get_or_create_object, update_or_create_object
-from common.orm.backend.Tools import key_to_str
-from common.orm.fields.ForeignKeyField import ForeignKeyField
-from common.orm.fields.IntegerField import IntegerField
-from common.orm.fields.PrimaryKeyField import PrimaryKeyField
-from common.orm.fields.StringField import StringField
-from common.orm.model.Model import Model
-from service.service.database.Tools import fast_hasher, remove_dict_key
-
-LOGGER = logging.getLogger(__name__)
-
-class ConstraintsModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
-
- def dump(self) -> List[Dict]:
- db_constraint_pks = self.references(ConstraintModel)
- constraints = [ConstraintModel(self.database, pk).dump(include_position=True) for pk,_ in db_constraint_pks]
- constraints = sorted(constraints, key=operator.itemgetter('position'))
- return [remove_dict_key(constraint, 'position') for constraint in constraints]
-
-class ConstraintModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- constraints_fk = ForeignKeyField(ConstraintsModel)
- position = IntegerField(min_value=0, required=True)
- constraint_type = StringField(required=True, allow_empty=False)
- constraint_value = StringField(required=True, allow_empty=False)
-
- def dump(self, include_position=True) -> Dict: # pylint: disable=arguments-differ
- result = {
- 'custom': {
- 'constraint_type': self.constraint_type,
- 'constraint_value': self.constraint_value,
- },
- }
- if include_position: result['position'] = self.position
- return result
-
-def delete_all_constraints(database : Database, db_parent_pk : str, constraints_name : str) -> None:
- str_constraints_key = key_to_str([db_parent_pk, constraints_name], separator=':')
- db_constraints : ConstraintsModel = get_object(
- database, ConstraintsModel, str_constraints_key, raise_if_not_found=False)
- if db_constraints is None: return
- db_constraint_pks = db_constraints.references(ConstraintModel)
- for pk,_ in db_constraint_pks: ConstraintModel(database, pk).delete()
-
-def grpc_constraints_to_raw(grpc_constraints) -> List[Tuple[str, str]]:
- return [
- (grpc_constraint.custom.constraint_type, grpc_constraint.custom.constraint_value)
- for grpc_constraint in grpc_constraints
- if grpc_constraint.WhichOneof('constraint') == 'custom'
- ]
-
-def get_constraints(database : Database, db_parent_pk : str, constraints_name : str) -> List[Tuple[str, str]]:
- str_constraints_key = key_to_str([db_parent_pk, constraints_name], separator=':')
- db_constraints : ConstraintsModel = get_object(
- database, ConstraintsModel, str_constraints_key, raise_if_not_found=False)
- return [] if db_constraints is None else [
- (constraint['custom']['constraint_type'], constraint['custom']['constraint_value'])
- for constraint in db_constraints.dump()
- if 'custom' in constraint
- ]
-
-def update_constraints(
- database : Database, db_parent_pk : str, constraints_name : str, raw_constraints : List[Tuple[str, str]]
-) -> List[Tuple[Union[ConstraintsModel, ConstraintModel], bool]]:
-
- str_constraints_key = key_to_str([db_parent_pk, constraints_name], separator=':')
- result : Tuple[ConstraintsModel, bool] = get_or_create_object(database, ConstraintsModel, str_constraints_key)
- db_constraints, created = result
-
- db_objects : List[Tuple[Union[ConstraintsModel, ConstraintModel], bool]] = [(db_constraints, created)]
-
- for position,(constraint_type, constraint_value) in enumerate(raw_constraints):
- str_constraint_key_hash = fast_hasher(constraint_type)
- str_constraint_key = key_to_str([db_constraints.pk, str_constraint_key_hash], separator=':')
- result : Tuple[ConstraintModel, bool] = update_or_create_object(
- database, ConstraintModel, str_constraint_key, {
- 'constraints_fk': db_constraints, 'position': position, 'constraint_type': constraint_type,
- 'constraint_value': constraint_value})
- db_constraints_rule, updated = result
- db_objects.append((db_constraints_rule, updated))
-
- return db_objects
diff --git a/src/service/service/database/ContextModel.py b/src/service/service/database/ContextModel.py
deleted file mode 100644
index b094961ca5ae7468505414ac164ebaa7b0f8f6f4..0000000000000000000000000000000000000000
--- a/src/service/service/database/ContextModel.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# 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
-from common.orm.fields.PrimaryKeyField import PrimaryKeyField
-from common.orm.fields.StringField import StringField
-from common.orm.model.Model import Model
-
-LOGGER = logging.getLogger(__name__)
-
-class ContextModel(Model):
- pk = PrimaryKeyField()
- context_uuid = StringField(required=True, allow_empty=False)
-
- def dump_id(self) -> Dict:
- return {'context_uuid': {'uuid': self.context_uuid}}
-
-# def dump_service_ids(self) -> List[Dict]:
-# from .ServiceModel import ServiceModel # pylint: disable=import-outside-toplevel
-# db_service_pks = self.references(ServiceModel)
-# return [ServiceModel(self.database, pk).dump_id() for pk,_ in db_service_pks]
-#
-# def dump_topology_ids(self) -> List[Dict]:
-# from .TopologyModel import TopologyModel # pylint: disable=import-outside-toplevel
-# db_topology_pks = self.references(TopologyModel)
-# return [TopologyModel(self.database, pk).dump_id() for pk,_ in db_topology_pks]
-#
-# def dump(self, include_services=True, include_topologies=True) -> Dict: # pylint: disable=arguments-differ
-# result = {'context_id': self.dump_id()}
-# if include_services: result['service_ids'] = self.dump_service_ids()
-# if include_topologies: result['topology_ids'] = self.dump_topology_ids()
-# return result
diff --git a/src/service/service/database/DatabaseDeviceTools.py b/src/service/service/database/DatabaseDeviceTools.py
deleted file mode 100644
index 2da9c584f731723b24b80439020c6a5eabe1f72e..0000000000000000000000000000000000000000
--- a/src/service/service/database/DatabaseDeviceTools.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# 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 grpc
-from typing import Tuple
-from common.orm.Database import Database
-from common.orm.HighLevel import get_or_create_object, update_or_create_object
-from common.orm.backend.Tools import key_to_str
-from common.proto.context_pb2 import Device, DeviceId
-from common.rpc_method_wrapper.ServiceExceptions import InvalidArgumentException
-from context.client.ContextClient import ContextClient
-from .ConfigModel import delete_all_config_rules, grpc_config_rules_to_raw, update_config
-from .ContextModel import ContextModel
-from .DeviceModel import DeviceModel, grpc_to_enum__device_operational_status, set_drivers
-from .EndPointModel import EndPointModel
-from .TopologyModel import TopologyModel
-
-def update_device_in_local_database(database : Database, device : Device) -> Tuple[DeviceModel, bool]:
- device_uuid = device.device_id.device_uuid.uuid
-
- for i,endpoint in enumerate(device.device_endpoints):
- endpoint_device_uuid = endpoint.endpoint_id.device_id.device_uuid.uuid
- if len(endpoint_device_uuid) == 0: endpoint_device_uuid = device_uuid
- if device_uuid != endpoint_device_uuid:
- raise InvalidArgumentException(
- 'request.device_endpoints[{:d}].device_id.device_uuid.uuid'.format(i), endpoint_device_uuid,
- ['should be == {:s}({:s})'.format('request.device_id.device_uuid.uuid', device_uuid)])
-
- config_rules = grpc_config_rules_to_raw(device.device_config.config_rules)
- delete_all_config_rules(database, device_uuid, 'running')
- running_config_result = update_config(database, device_uuid, 'running', config_rules)
-
- result : Tuple[DeviceModel, bool] = update_or_create_object(database, DeviceModel, device_uuid, {
- 'device_uuid' : device_uuid,
- 'device_type' : device.device_type,
- 'device_operational_status': grpc_to_enum__device_operational_status(device.device_operational_status),
- 'device_config_fk' : running_config_result[0][0],
- })
- db_device, updated = result
- set_drivers(database, db_device, device.device_drivers)
-
- for i,endpoint in enumerate(device.device_endpoints):
- endpoint_uuid = endpoint.endpoint_id.endpoint_uuid.uuid
- endpoint_device_uuid = endpoint.endpoint_id.device_id.device_uuid.uuid
- if len(endpoint_device_uuid) == 0: endpoint_device_uuid = device_uuid
-
- str_endpoint_key = key_to_str([device_uuid, endpoint_uuid])
- endpoint_attributes = {
- 'device_fk' : db_device,
- 'endpoint_uuid': endpoint_uuid,
- 'endpoint_type': endpoint.endpoint_type,
- }
-
- endpoint_topology_context_uuid = endpoint.endpoint_id.topology_id.context_id.context_uuid.uuid
- endpoint_topology_uuid = endpoint.endpoint_id.topology_id.topology_uuid.uuid
- if len(endpoint_topology_context_uuid) > 0 and len(endpoint_topology_uuid) > 0:
- result : Tuple[ContextModel, bool] = get_or_create_object(
- database, ContextModel, endpoint_topology_context_uuid, defaults={
- 'context_uuid': endpoint_topology_context_uuid,
- })
- db_context, _ = result
-
- str_topology_key = key_to_str([endpoint_topology_context_uuid, endpoint_topology_uuid])
- result : Tuple[TopologyModel, bool] = get_or_create_object(
- database, TopologyModel, str_topology_key, defaults={
- 'context_fk': db_context,
- 'topology_uuid': endpoint_topology_uuid,
- })
- db_topology, _ = result
-
- str_endpoint_key = key_to_str([str_endpoint_key, str_topology_key], separator=':')
- endpoint_attributes['topology_fk'] = db_topology
-
- result : Tuple[EndPointModel, bool] = update_or_create_object(
- database, EndPointModel, str_endpoint_key, endpoint_attributes)
- _, db_endpoint_updated = result
- updated = updated or db_endpoint_updated
-
- return db_device, updated
-
-def sync_device_from_context(
- device_uuid : str, context_client : ContextClient, database : Database
- ) -> Tuple[DeviceModel, bool]:
-
- try:
- device : Device = context_client.GetDevice(DeviceId(device_uuid={'uuid': device_uuid}))
- except grpc.RpcError as e:
- if e.code() != grpc.StatusCode.NOT_FOUND: raise # pylint: disable=no-member
- return None
- return update_device_in_local_database(database, device)
diff --git a/src/service/service/database/DatabaseServiceTools.py b/src/service/service/database/DatabaseServiceTools.py
deleted file mode 100644
index 27efa17ffca50737daba28ac2d8a81438eb2a433..0000000000000000000000000000000000000000
--- a/src/service/service/database/DatabaseServiceTools.py
+++ /dev/null
@@ -1,144 +0,0 @@
-# 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 grpc
-from typing import Tuple
-from common.Constants import DEFAULT_CONTEXT_UUID, DEFAULT_TOPOLOGY_UUID
-from common.orm.Database import Database
-from common.orm.HighLevel import get_object, get_or_create_object, update_or_create_object
-from common.orm.backend.Tools import key_to_str
-from common.proto.context_pb2 import Service, ServiceId
-from common.rpc_method_wrapper.ServiceExceptions import InvalidArgumentException
-from context.client.ContextClient import ContextClient
-from .ConfigModel import delete_all_config_rules, grpc_config_rules_to_raw, update_config
-from .ConstraintModel import delete_all_constraints, grpc_constraints_to_raw, update_constraints
-from .ContextModel import ContextModel
-from .EndPointModel import EndPointModel
-from .RelationModels import ServiceEndPointModel
-from .ServiceModel import ServiceModel, grpc_to_enum__service_status, grpc_to_enum__service_type
-from .TopologyModel import TopologyModel
-
-def update_service_in_local_database(database : Database, service : Service) -> Tuple[ServiceModel, bool]:
- service_uuid = service.service_id.service_uuid.uuid
- service_context_uuid = service.service_id.context_id.context_uuid.uuid
- if len(service_context_uuid) == 0: service_context_uuid = DEFAULT_CONTEXT_UUID
-
- topology_uuids = {}
- for i,endpoint_id in enumerate(service.service_endpoint_ids):
- endpoint_uuid = endpoint_id.endpoint_uuid.uuid
- endpoint_device_uuid = endpoint_id.device_id.device_uuid.uuid
- endpoint_topology_uuid = endpoint_id.topology_id.topology_uuid.uuid
- endpoint_topology_context_uuid = endpoint_id.topology_id.context_id.context_uuid.uuid
-
- if len(endpoint_device_uuid) == 0:
- raise InvalidArgumentException(
- 'request.service_endpoint_ids[{:d}].device_id.device_uuid.uuid'.format(i), endpoint_device_uuid,
- ['not set'])
-
- if len(endpoint_topology_context_uuid) == 0: endpoint_topology_context_uuid = service_context_uuid
- if service_context_uuid != endpoint_topology_context_uuid:
- raise InvalidArgumentException(
- 'request.service_endpoint_ids[{:d}].topology_id.context_id.context_uuid.uuid'.format(i),
- endpoint_device_uuid,
- ['should be == {:s}({:s})'.format('service_id.context_id.context_uuid.uuid', service_context_uuid)])
-
- topology_uuids.setdefault(endpoint_topology_uuid, set()).add(
- 'request.service_endpoint_ids[{:d}].device_id.device_uuid.uuid'.format(i))
-
- if len(topology_uuids) > 1:
- raise InvalidArgumentException(
- 'request.service_endpoint_ids', '...',
- ['Multiple different topology_uuid values specified: {:s}'.format(str(topology_uuids))])
- if len(topology_uuids) == 1:
- topology_uuid = topology_uuids.popitem()[0]
- else:
- topology_uuid = DEFAULT_TOPOLOGY_UUID
-
- result : Tuple[ContextModel, bool] = get_or_create_object(
- database, ContextModel, service_context_uuid, defaults={'context_uuid': service_context_uuid})
- db_context, _ = result
-
- str_topology_key = None
- if len(topology_uuid) > 0:
- str_topology_key = key_to_str([service_context_uuid, topology_uuid])
- result : Tuple[TopologyModel, bool] = get_or_create_object(
- database, TopologyModel, str_topology_key, defaults={
- 'context_fk': db_context, 'topology_uuid': topology_uuid})
- #db_topology, _ = result
-
- str_service_key = key_to_str([service_context_uuid, service_uuid])
-
- config_rules = grpc_config_rules_to_raw(service.service_config.config_rules)
- delete_all_config_rules(database, str_service_key, 'running')
- running_config_result = update_config(database, str_service_key, 'running', config_rules)
-
- constraints = grpc_constraints_to_raw(service.service_constraints)
- delete_all_constraints(database, str_service_key, 'running')
- running_constraints_result = update_constraints(database, str_service_key, 'running', constraints)
-
- result : Tuple[ContextModel, bool] = get_or_create_object(
- database, ContextModel, service_context_uuid, defaults={
- 'context_uuid': service_context_uuid,
- })
- db_context, _ = result
-
- result : Tuple[ServiceModel, bool] = update_or_create_object(database, ServiceModel, str_service_key, {
- 'context_fk' : db_context,
- 'service_uuid' : service_uuid,
- 'service_type' : grpc_to_enum__service_type(service.service_type),
- 'service_status' : grpc_to_enum__service_status(service.service_status.service_status),
- 'service_constraints_fk': running_constraints_result[0][0],
- 'service_config_fk' : running_config_result[0][0],
- })
- db_service, updated = result
-
- for i,endpoint_id in enumerate(service.service_endpoint_ids):
- endpoint_uuid = endpoint_id.endpoint_uuid.uuid
- endpoint_device_uuid = endpoint_id.device_id.device_uuid.uuid
-
- str_endpoint_key = key_to_str([endpoint_device_uuid, endpoint_uuid])
- if str_topology_key is not None:
- str_endpoint_key = key_to_str([str_endpoint_key, str_topology_key], separator=':')
- db_endpoint : EndPointModel = get_object(database, EndPointModel, str_endpoint_key)
-
- str_service_endpoint_key = key_to_str([str_service_key, str_endpoint_key], separator='--')
- result : Tuple[ServiceEndPointModel, bool] = get_or_create_object(
- database, ServiceEndPointModel, str_service_endpoint_key, {
- 'service_fk': db_service, 'endpoint_fk': db_endpoint})
- _, service_endpoint_created = result
- updated = updated or service_endpoint_created
-
- return db_service, updated
-
-def sync_service_from_context(
- context_uuid : str, service_uuid : str, context_client : ContextClient, database : Database
- ) -> Tuple[ServiceModel, bool]:
-
- try:
- service : Service = context_client.GetService(ServiceId(
- context_id={'context_uuid': {'uuid': context_uuid}},
- service_uuid={'uuid': service_uuid}))
- except grpc.RpcError as e:
- if e.code() != grpc.StatusCode.NOT_FOUND: raise # pylint: disable=no-member
- return None
- return update_service_in_local_database(database, service)
-
-def sync_service_to_context(db_service : ServiceModel, context_client : ContextClient) -> None:
- if db_service is None: return
- context_client.SetService(Service(**db_service.dump(
- include_endpoint_ids=True, include_constraints=True, include_config_rules=True)))
-
-def delete_service_from_context(db_service : ServiceModel, context_client : ContextClient) -> None:
- if db_service is None: return
- context_client.RemoveService(ServiceId(**db_service.dump_id()))
diff --git a/src/service/service/database/DeviceModel.py b/src/service/service/database/DeviceModel.py
deleted file mode 100644
index 0f0201190542397a34b68fa217706c904606ead3..0000000000000000000000000000000000000000
--- a/src/service/service/database/DeviceModel.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# 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 functools, logging
-from enum import Enum
-from typing import Dict, List
-from common.orm.Database import Database
-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 DeviceDriverEnum, DeviceOperationalStatusEnum
-from .ConfigModel import ConfigModel
-from .Tools import grpc_to_enum
-
-LOGGER = logging.getLogger(__name__)
-
-class ORM_DeviceDriverEnum(Enum):
- UNDEFINED = DeviceDriverEnum.DEVICEDRIVER_UNDEFINED
- OPENCONFIG = DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG
- TRANSPORT_API = DeviceDriverEnum.DEVICEDRIVER_TRANSPORT_API
- P4 = DeviceDriverEnum.DEVICEDRIVER_P4
- IETF_NETWORK_TOPOLOGY = DeviceDriverEnum.DEVICEDRIVER_IETF_NETWORK_TOPOLOGY
- ONF_TR_352 = DeviceDriverEnum.DEVICEDRIVER_ONF_TR_352
-
-grpc_to_enum__device_driver = functools.partial(
- grpc_to_enum, DeviceDriverEnum, ORM_DeviceDriverEnum)
-
-class ORM_DeviceOperationalStatusEnum(Enum):
- UNDEFINED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_UNDEFINED
- DISABLED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_DISABLED
- ENABLED = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED
-
-grpc_to_enum__device_operational_status = functools.partial(
- grpc_to_enum, DeviceOperationalStatusEnum, ORM_DeviceOperationalStatusEnum)
-
-class DeviceModel(Model):
- pk = PrimaryKeyField()
- device_uuid = StringField(required=True, allow_empty=False)
- device_type = StringField()
- device_config_fk = ForeignKeyField(ConfigModel)
- device_operational_status = EnumeratedField(ORM_DeviceOperationalStatusEnum, required=True)
-
- def dump_id(self) -> Dict:
- return {'device_uuid': {'uuid': self.device_uuid}}
-
- def dump_config(self) -> Dict:
- return ConfigModel(self.database, self.device_config_fk).dump()
-
- def dump_drivers(self) -> List[int]:
- db_driver_pks = self.references(DriverModel)
- return [DriverModel(self.database, pk).dump() for pk,_ in db_driver_pks]
-
- def dump_endpoints(self) -> List[Dict]:
- from .EndPointModel import EndPointModel # pylint: disable=import-outside-toplevel
- db_endpoints_pks = self.references(EndPointModel)
- return [EndPointModel(self.database, pk).dump() for pk,_ in db_endpoints_pks]
-
- def dump( # pylint: disable=arguments-differ
- self, include_config_rules=True, include_drivers=True, include_endpoints=True
- ) -> Dict:
- result = {
- 'device_id': self.dump_id(),
- 'device_type': self.device_type,
- 'device_operational_status': self.device_operational_status.value,
- }
- if include_config_rules: result.setdefault('device_config', {})['config_rules'] = self.dump_config()
- if include_drivers: result['device_drivers'] = self.dump_drivers()
- if include_endpoints: result['device_endpoints'] = self.dump_endpoints()
- return result
-
-class DriverModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- device_fk = ForeignKeyField(DeviceModel)
- driver = EnumeratedField(ORM_DeviceDriverEnum, required=True)
-
- def dump(self) -> Dict:
- return self.driver.value
-
-def set_drivers(database : Database, db_device : DeviceModel, grpc_device_drivers):
- db_device_pk = db_device.pk
- for driver in grpc_device_drivers:
- orm_driver = grpc_to_enum__device_driver(driver)
- str_device_driver_key = key_to_str([db_device_pk, orm_driver.name])
- db_device_driver = DriverModel(database, str_device_driver_key)
- db_device_driver.device_fk = db_device
- db_device_driver.driver = orm_driver
- db_device_driver.save()
diff --git a/src/service/service/database/EndPointModel.py b/src/service/service/database/EndPointModel.py
deleted file mode 100644
index e043e1c0e5c91f98fb23a53b9a1367f0f64a1ba1..0000000000000000000000000000000000000000
--- a/src/service/service/database/EndPointModel.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# 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.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 .TopologyModel import TopologyModel
-
-LOGGER = logging.getLogger(__name__)
-
-class EndPointModel(Model):
- pk = PrimaryKeyField()
- topology_fk = ForeignKeyField(TopologyModel, required=False)
- device_fk = ForeignKeyField(DeviceModel)
- endpoint_uuid = StringField(required=True, allow_empty=False)
- endpoint_type = StringField()
-
- def dump_id(self) -> Dict:
- device_id = DeviceModel(self.database, self.device_fk).dump_id()
- result = {
- 'device_id': device_id,
- 'endpoint_uuid': {'uuid': self.endpoint_uuid},
- }
- if self.topology_fk is not None:
- result['topology_id'] = TopologyModel(self.database, self.topology_fk).dump_id()
- return result
-
- def dump(self) -> Dict:
- return {
- 'endpoint_id': self.dump_id(),
- 'endpoint_type': self.endpoint_type,
- }
-
-def grpc_endpointids_to_raw(grpc_endpointids : List[EndPointId]) -> List[Tuple[str, str, Optional[str]]]:
- def translate(grpc_endpointid : EndPointId) -> Tuple[str, str, Optional[str]]:
- device_uuid = grpc_endpointid.device_id.device_uuid.uuid
- endpoint_uuid = grpc_endpointid.endpoint_uuid.uuid
- topology_uuid = grpc_endpointid.topology_id.topology_uuid.uuid
- if len(topology_uuid) == 0: topology_uuid = None
- return device_uuid, endpoint_uuid, topology_uuid
- return [translate(grpc_endpointid) for grpc_endpointid in grpc_endpointids]
diff --git a/src/service/service/database/LinkModel.py b/src/service/service/database/LinkModel.py
deleted file mode 100644
index 742044b9758df297413ad2d0318520c825e8b738..0000000000000000000000000000000000000000
--- a/src/service/service/database/LinkModel.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# 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, operator
-from typing import Dict, List
-from common.orm.fields.PrimaryKeyField import PrimaryKeyField
-from common.orm.fields.StringField import StringField
-from common.orm.model.Model import Model
-from common.orm.HighLevel import get_related_objects
-
-LOGGER = logging.getLogger(__name__)
-
-class LinkModel(Model):
- pk = PrimaryKeyField()
- link_uuid = StringField(required=True, allow_empty=False)
-
- def dump_id(self) -> Dict:
- return {'link_uuid': {'uuid': self.link_uuid}}
-
- def dump_endpoint_ids(self) -> List[Dict]:
- from .RelationModels import LinkEndPointModel # pylint: disable=import-outside-toplevel
- db_endpoints = get_related_objects(self, LinkEndPointModel, 'endpoint_fk')
- return [db_endpoint.dump_id() for db_endpoint in sorted(db_endpoints, key=operator.attrgetter('pk'))]
-
- def dump(self) -> Dict:
- return {
- 'link_id': self.dump_id(),
- 'link_endpoint_ids': self.dump_endpoint_ids(),
- }
diff --git a/src/service/service/database/RelationModels.py b/src/service/service/database/RelationModels.py
deleted file mode 100644
index ce596893f756c66a84cb6e516871f2cb3d5d181b..0000000000000000000000000000000000000000
--- a/src/service/service/database/RelationModels.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# 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 common.orm.fields.ForeignKeyField import ForeignKeyField
-from common.orm.fields.PrimaryKeyField import PrimaryKeyField
-from common.orm.model.Model import Model
-from .DeviceModel import DeviceModel
-from .EndPointModel import EndPointModel
-from .LinkModel import LinkModel
-from .ServiceModel import ServiceModel
-from .TopologyModel import TopologyModel
-
-LOGGER = logging.getLogger(__name__)
-
-class LinkEndPointModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- link_fk = ForeignKeyField(LinkModel)
- endpoint_fk = ForeignKeyField(EndPointModel)
-
-class ServiceEndPointModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- service_fk = ForeignKeyField(ServiceModel)
- endpoint_fk = ForeignKeyField(EndPointModel)
-
-class TopologyDeviceModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- topology_fk = ForeignKeyField(TopologyModel)
- device_fk = ForeignKeyField(DeviceModel)
-
-class TopologyLinkModel(Model): # pylint: disable=abstract-method
- pk = PrimaryKeyField()
- topology_fk = ForeignKeyField(TopologyModel)
- link_fk = ForeignKeyField(LinkModel)
diff --git a/src/service/service/database/ServiceModel.py b/src/service/service/database/ServiceModel.py
deleted file mode 100644
index cf756af60a8178a9ae2fda2a5fa5ddeebc73912c..0000000000000000000000000000000000000000
--- a/src/service/service/database/ServiceModel.py
+++ /dev/null
@@ -1,88 +0,0 @@
-# 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 functools, logging, operator
-from enum import Enum
-from typing import Dict, List
-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.orm.HighLevel import get_related_objects
-from common.proto.context_pb2 import ServiceStatusEnum, ServiceTypeEnum
-from .ConfigModel import ConfigModel
-from .ConstraintModel import ConstraintsModel
-from .ContextModel import ContextModel
-from .Tools import grpc_to_enum
-
-LOGGER = logging.getLogger(__name__)
-
-class ORM_ServiceTypeEnum(Enum):
- UNKNOWN = ServiceTypeEnum.SERVICETYPE_UNKNOWN
- L3NM = ServiceTypeEnum.SERVICETYPE_L3NM
- L2NM = ServiceTypeEnum.SERVICETYPE_L2NM
- TAPI_CONNECTIVITY_SERVICE = ServiceTypeEnum.SERVICETYPE_TAPI_CONNECTIVITY_SERVICE
-
-grpc_to_enum__service_type = functools.partial(
- grpc_to_enum, ServiceTypeEnum, ORM_ServiceTypeEnum)
-
-class ORM_ServiceStatusEnum(Enum):
- UNDEFINED = ServiceStatusEnum.SERVICESTATUS_UNDEFINED
- PLANNED = ServiceStatusEnum.SERVICESTATUS_PLANNED
- ACTIVE = ServiceStatusEnum.SERVICESTATUS_ACTIVE
- PENDING_REMOVAL = ServiceStatusEnum.SERVICESTATUS_PENDING_REMOVAL
-
-grpc_to_enum__service_status = functools.partial(
- grpc_to_enum, ServiceStatusEnum, ORM_ServiceStatusEnum)
-
-class ServiceModel(Model):
- pk = PrimaryKeyField()
- context_fk = ForeignKeyField(ContextModel)
- service_uuid = StringField(required=True, allow_empty=False)
- service_type = EnumeratedField(ORM_ServiceTypeEnum, required=True)
- service_constraints_fk = ForeignKeyField(ConstraintsModel)
- service_status = EnumeratedField(ORM_ServiceStatusEnum, required=True)
- service_config_fk = ForeignKeyField(ConfigModel)
-
- def dump_id(self) -> Dict:
- context_id = ContextModel(self.database, self.context_fk).dump_id()
- return {
- 'context_id': context_id,
- 'service_uuid': {'uuid': self.service_uuid},
- }
-
- def dump_endpoint_ids(self) -> List[Dict]:
- from .RelationModels import ServiceEndPointModel # pylint: disable=import-outside-toplevel
- db_endpoints = get_related_objects(self, ServiceEndPointModel, 'endpoint_fk')
- return [db_endpoint.dump_id() for db_endpoint in sorted(db_endpoints, key=operator.attrgetter('pk'))]
-
- def dump_constraints(self) -> List[Dict]:
- return ConstraintsModel(self.database, self.service_constraints_fk).dump()
-
- def dump_config(self) -> Dict:
- return ConfigModel(self.database, self.service_config_fk).dump()
-
- def dump( # pylint: disable=arguments-differ
- self, include_endpoint_ids=True, include_constraints=True, include_config_rules=True
- ) -> Dict:
- result = {
- 'service_id': self.dump_id(),
- 'service_type': self.service_type.value,
- 'service_status': {'service_status': self.service_status.value},
- }
- if include_endpoint_ids: result['service_endpoint_ids'] = self.dump_endpoint_ids()
- if include_constraints: result['service_constraints'] = self.dump_constraints()
- if include_config_rules: result.setdefault('service_config', {})['config_rules'] = self.dump_config()
- return result
diff --git a/src/service/service/database/Tools.py b/src/service/service/database/Tools.py
deleted file mode 100644
index 43bb71bd90582644c67d3ca528611eae937b6460..0000000000000000000000000000000000000000
--- a/src/service/service/database/Tools.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# 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 hashlib, re
-from enum import Enum
-from typing import Dict, List, Tuple, Union
-
-# Convenient helper function to remove dictionary items in dict/list/set comprehensions.
-
-def remove_dict_key(dictionary : Dict, key : str):
- dictionary.pop(key, None)
- return dictionary
-
-# Enumeration classes are redundant with gRPC classes, but gRPC does not provide a programmatical method to retrieve
-# the values it expects from strings containing the desired value symbol or its integer value, so a kind of mapping is
-# required. Besides, ORM Models expect Enum classes in EnumeratedFields; we create specific and conveniently defined
-# Enum classes to serve both purposes.
-
-def grpc_to_enum(grpc_enum_class, orm_enum_class : Enum, grpc_enum_value):
- grpc_enum_name = grpc_enum_class.Name(grpc_enum_value)
- grpc_enum_prefix = orm_enum_class.__name__.upper()
- grpc_enum_prefix = re.sub(r'^ORM_(.+)$', r'\1', grpc_enum_prefix)
- grpc_enum_prefix = re.sub(r'^(.+)ENUM$', r'\1', grpc_enum_prefix)
- grpc_enum_prefix = grpc_enum_prefix + '_'
- orm_enum_name = grpc_enum_name.replace(grpc_enum_prefix, '')
- orm_enum_value = orm_enum_class._member_map_.get(orm_enum_name) # pylint: disable=protected-access
- return orm_enum_value
-
-# For some models, it is convenient to produce a string hash for fast comparisons of existence or modification. Method
-# fast_hasher computes configurable length (between 1 and 64 byte) hashes and retrieves them in hex representation.
-
-FASTHASHER_ITEM_ACCEPTED_FORMAT = 'Union[bytes, str]'
-FASTHASHER_DATA_ACCEPTED_FORMAT = 'Union[{fmt:s}, List[{fmt:s}], Tuple[{fmt:s}]]'.format(
- fmt=FASTHASHER_ITEM_ACCEPTED_FORMAT)
-
-def fast_hasher(data : Union[bytes, str, List[Union[bytes, str]], Tuple[Union[bytes, str]]], digest_size : int = 8):
- hasher = hashlib.blake2b(digest_size=digest_size)
- # Do not accept sets, dicts, or other unordered dats tructures since their order is arbitrary thus producing
- # different hashes depending on the order. Consider adding support for sets or dicts with previous sorting of
- # items by their key.
-
- if isinstance(data, bytes):
- data = [data]
- elif isinstance(data, str):
- data = [data.encode('UTF-8')]
- elif isinstance(data, (list, tuple)):
- pass
- else:
- msg = 'data({:s}) must be {:s}, found {:s}'
- raise TypeError(msg.format(str(data), FASTHASHER_DATA_ACCEPTED_FORMAT, str(type(data))))
-
- for i,item in enumerate(data):
- if isinstance(item, str):
- item = item.encode('UTF-8')
- elif isinstance(item, bytes):
- pass
- else:
- msg = 'data[{:d}]({:s}) must be {:s}, found {:s}'
- raise TypeError(msg.format(i, str(item), FASTHASHER_ITEM_ACCEPTED_FORMAT, str(type(item))))
- hasher.update(item)
- return hasher.hexdigest()
diff --git a/src/service/service/database/TopologyModel.py b/src/service/service/database/TopologyModel.py
deleted file mode 100644
index 5909c7a2c63d05f2cbde7f0d8555e63587e96682..0000000000000000000000000000000000000000
--- a/src/service/service/database/TopologyModel.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# 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, operator
-from typing import Dict, List
-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.orm.HighLevel import get_related_objects
-from .ContextModel import ContextModel
-
-LOGGER = logging.getLogger(__name__)
-
-class TopologyModel(Model):
- pk = PrimaryKeyField()
- context_fk = ForeignKeyField(ContextModel)
- topology_uuid = StringField(required=True, allow_empty=False)
-
- def dump_id(self) -> Dict:
- context_id = ContextModel(self.database, self.context_fk).dump_id()
- return {
- 'context_id': context_id,
- 'topology_uuid': {'uuid': self.topology_uuid},
- }
-
- def dump_device_ids(self) -> List[Dict]:
- from .RelationModels import TopologyDeviceModel # pylint: disable=import-outside-toplevel
- db_devices = get_related_objects(self, TopologyDeviceModel, 'device_fk')
- return [db_device.dump_id() for db_device in sorted(db_devices, key=operator.attrgetter('pk'))]
-
- def dump_link_ids(self) -> List[Dict]:
- from .RelationModels import TopologyLinkModel # pylint: disable=import-outside-toplevel
- db_links = get_related_objects(self, TopologyLinkModel, 'link_fk')
- return [db_link.dump_id() for db_link in sorted(db_links, key=operator.attrgetter('pk'))]
-
- def dump( # pylint: disable=arguments-differ
- self, include_devices=True, include_links=True
- ) -> Dict:
- result = {'topology_id': self.dump_id()}
- if include_devices: result['device_ids'] = self.dump_device_ids()
- if include_links: result['link_ids'] = self.dump_link_ids()
- return result
diff --git a/src/service/service/database/__init__.py b/src/service/service/database/__init__.py
deleted file mode 100644
index 926623031b92b7dc7ad545b5f5da369b7ab79856..0000000000000000000000000000000000000000
--- a/src/service/service/database/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# 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.
-
-# In-Memory database with a simplified representation of Context Database focused on the Service model.
-# Used as an internal data cache, for message validation, and message formatting purposes.
diff --git a/src/service/service/service_handler_api/_ServiceHandler.py b/src/service/service/service_handler_api/_ServiceHandler.py
index 9cbe3f49e8594badf3b419b24154cb59a30a17bf..c642afe75342309f607ed722cf78544bcfdb1ebd 100644
--- a/src/service/service/service_handler_api/_ServiceHandler.py
+++ b/src/service/service/service_handler_api/_ServiceHandler.py
@@ -13,30 +13,22 @@
# limitations under the License.
from typing import Any, List, Optional, Tuple, Union
-from common.orm.Database import Database
-from context.client.ContextClient import ContextClient
-from device.client.DeviceClient import DeviceClient
-from service.service.database.ServiceModel import ServiceModel
+from common.proto.context_pb2 import Service
+from service.task_scheduler.TaskExecutor import TaskExecutor
class _ServiceHandler:
def __init__(self,
- db_service: ServiceModel,
- database: Database,
- context_client: ContextClient,
- device_client: DeviceClient,
+ service: Service,
+ task_executor : TaskExecutor,
**settings) -> None:
""" Initialize Driver.
Parameters:
- db_service
- The service instance from the local in-memory database.
- database
- The instance of the local in-memory database.
- context_client
- An instance of context client to be used to retrieve
- information from the service and the devices.
- device_client
- An instance of device client to be used to configure
- the devices.
+ service
+ The service instance (gRPC message) to be managed.
+ task_executor
+ An instance of Task Executor providing access to the
+ service handlers factory, the context and device clients,
+ and an internal cache of already-loaded gRPC entities.
**settings
Extra settings required by the service handler.
"""
diff --git a/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py b/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
index 14a5e111b18fa46fc7a7e89f213cb9fe68684f1b..f94948129f23c1aff3a3db3dbb4c236ae161e5e1 100644
--- a/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
+++ b/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
@@ -14,12 +14,10 @@
import anytree, json, logging
from typing import Any, Dict, List, Optional, Tuple, Union
-from common.orm.HighLevel import get_object
-from common.proto.context_pb2 import ConfigActionEnum, ConfigRule, Device, DeviceId, Service
+from common.proto.context_pb2 import ConfigActionEnum, ConfigRule, DeviceId, Service
from common.tools.object_factory.ConfigRule import json_config_rule_delete, json_config_rule_set
from common.tools.object_factory.Device import json_device_id
from common.type_checkers.Checkers import chk_type
-from service.service.database.DeviceModel import DeviceModel
from service.service.service_handler_api._ServiceHandler import _ServiceHandler
from service.service.service_handler_api.AnyTreeTools import TreeNode, delete_subnode, get_subnode, set_subnode_value
from service.service.task_scheduler.TaskExecutor import TaskExecutor