diff --git a/src/service/service/service_handlers/l2nm_ietfl2vpn/L2NM_IETFL2VPN_ServiceHandler.py b/src/service/service/service_handlers/l2nm_ietfl2vpn/L2NM_IETFL2VPN_ServiceHandler.py
index 7a2c4e72326e7a8a2b100076afb6f537d9402cd6..9adc15494798f0e6c58d3bcee0cebb9e4de60fbf 100644
--- a/src/service/service/service_handlers/l2nm_ietfl2vpn/L2NM_IETFL2VPN_ServiceHandler.py
+++ b/src/service/service/service_handlers/l2nm_ietfl2vpn/L2NM_IETFL2VPN_ServiceHandler.py
@@ -55,16 +55,16 @@ class L2NM_IETFL2VPN_ServiceHandler(_ServiceHandler):
src_device_uuid, src_endpoint_uuid = get_device_endpoint_uuids(endpoints[0])
src_device = self.__task_executor.get_device(DeviceId(**json_device_id(src_device_uuid)))
src_endpoint = get_endpoint_matching(src_device, src_endpoint_uuid)
- src_manager = self.__task_executor.get_device_manager(src_device)
+ src_controller = self.__task_executor.get_device_controller(src_device)
dst_device_uuid, dst_endpoint_uuid = get_device_endpoint_uuids(endpoints[1])
dst_device = self.__task_executor.get_device(DeviceId(**json_device_id(dst_device_uuid)))
dst_endpoint = get_endpoint_matching(dst_device, dst_endpoint_uuid)
- dst_manager = self.__task_executor.get_device_manager(dst_device)
+ dst_controller = self.__task_executor.get_device_controller(dst_device)
- if src_manager.device_id.device_uuid.uuid != dst_manager.device_id.device_uuid.uuid:
+ if src_controller.device_id.device_uuid.uuid != dst_controller.device_id.device_uuid.uuid:
raise Exception('Different Src-Dst devices not supported by now')
- manager = src_manager
+ controller = src_controller
json_config_rule = json_config_rule_set('/services/service[{:s}]'.format(service_uuid), {
'uuid' : service_uuid,
@@ -75,9 +75,9 @@ class L2NM_IETFL2VPN_ServiceHandler(_ServiceHandler):
'encapsulation_type': encap_type,
'vlan_id' : vlan_id,
})
- del manager.device_config.config_rules[:]
- manager.device_config.config_rules.append(ConfigRule(**json_config_rule))
- self.__task_executor.configure_device(manager)
+ del controller.device_config.config_rules[:]
+ controller.device_config.config_rules.append(ConfigRule(**json_config_rule))
+ self.__task_executor.configure_device(controller)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetEndpoint for Service({:s})'.format(str(service_uuid)))
@@ -97,21 +97,24 @@ class L2NM_IETFL2VPN_ServiceHandler(_ServiceHandler):
results = []
try:
- device_uuid_src, _ = get_device_endpoint_uuids(endpoints[0])
- device_uuid_dst, _ = get_device_endpoint_uuids(endpoints[1])
+ src_device_uuid, _ = get_device_endpoint_uuids(endpoints[0])
+ src_device = self.__task_executor.get_device(DeviceId(**json_device_id(src_device_uuid)))
+ src_controller = self.__task_executor.get_device_controller(src_device)
- if device_uuid_src != device_uuid_dst:
- raise Exception('Different Src-Dst devices not supported by now')
- device_uuid = device_uuid_src
+ dst_device_uuid, _ = get_device_endpoint_uuids(endpoints[1])
+ dst_device = self.__task_executor.get_device(DeviceId(**json_device_id(dst_device_uuid)))
+ dst_controller = self.__task_executor.get_device_controller(dst_device)
- device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
+ if src_controller.device_id.device_uuid.uuid != dst_controller.device_id.device_uuid.uuid:
+ raise Exception('Different Src-Dst devices not supported by now')
+ controller = src_controller
json_config_rule = json_config_rule_delete('/services/service[{:s}]'.format(service_uuid), {
'uuid': service_uuid
})
- del device_obj.device_config.config_rules[:]
- device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
- self.__task_executor.configure_device(device_obj)
+ del controller.device_config.config_rules[:]
+ controller.device_config.config_rules.append(ConfigRule(**json_config_rule))
+ self.__task_executor.configure_device(controller)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to DeleteEndpoint for Service({:s})'.format(str(service_uuid)))
diff --git a/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py b/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
index dd9ff092ac049054571c661b4a7dd969fba407a9..ee9c4a66da910d63dbc136027384c48708453765 100644
--- a/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
+++ b/src/service/service/service_handlers/tapi_tapi/TapiServiceHandler.py
@@ -19,7 +19,7 @@ from common.proto.context_pb2 import 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.service_handler_api.Tools import get_device_endpoint_uuids
+from service.service.service_handler_api.Tools import get_device_endpoint_uuids, get_endpoint_matching
from service.service.service_handler_api._ServiceHandler import _ServiceHandler
from service.service.service_handler_api.SettingsHandler import SettingsHandler
from service.service.task_scheduler.TaskExecutor import TaskExecutor
@@ -55,28 +55,35 @@ class TapiServiceHandler(_ServiceHandler):
results = []
try:
- device_uuid_src, endpoint_uuid_src = get_device_endpoint_uuids(endpoints[0])
- device_uuid_dst, endpoint_uuid_dst = get_device_endpoint_uuids(endpoints[1])
-
- if device_uuid_src != device_uuid_dst:
+ src_device_uuid, src_endpoint_uuid = get_device_endpoint_uuids(endpoints[0])
+ src_device = self.__task_executor.get_device(DeviceId(**json_device_id(src_device_uuid)))
+ src_endpoint = get_endpoint_matching(src_device, src_endpoint_uuid)
+ src_controller = self.__task_executor.get_device_controller(src_device)
+ if src_controller is None: src_controller = src_device
+
+ dst_device_uuid, dst_endpoint_uuid = get_device_endpoint_uuids(endpoints[1])
+ dst_device = self.__task_executor.get_device(DeviceId(**json_device_id(dst_device_uuid)))
+ dst_endpoint = get_endpoint_matching(dst_device, dst_endpoint_uuid)
+ dst_controller = self.__task_executor.get_device_controller(dst_device)
+ if dst_controller is None: dst_controller = dst_device
+
+ if src_controller.device_id.device_uuid.uuid != dst_controller.device_id.device_uuid.uuid:
raise Exception('Different Src-Dst devices not supported by now')
- device_uuid = device_uuid_src
-
- device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
+ controller = src_controller
json_config_rule = json_config_rule_set('/services/service[{:s}]'.format(service_uuid), {
'uuid' : service_uuid,
- 'input_sip' : endpoint_uuid_src,
- 'output_sip' : endpoint_uuid_dst,
+ 'input_sip' : src_endpoint.name,
+ 'output_sip' : dst_endpoint.name,
'capacity_unit' : capacity_unit,
'capacity_value' : capacity_value,
'layer_protocol_name' : layer_proto_name,
'layer_protocol_qualifier': layer_proto_qual,
'direction' : direction,
})
- del device_obj.device_config.config_rules[:]
- device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
- self.__task_executor.configure_device(device_obj)
+ del controller.device_config.config_rules[:]
+ controller.device_config.config_rules.append(ConfigRule(**json_config_rule))
+ self.__task_executor.configure_device(controller)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetEndpoint for Service({:s})'.format(str(service_uuid)))
@@ -96,21 +103,26 @@ class TapiServiceHandler(_ServiceHandler):
results = []
try:
- device_uuid_src, _ = get_device_endpoint_uuids(endpoints[0])
- device_uuid_dst, _ = get_device_endpoint_uuids(endpoints[1])
+ src_device_uuid, _ = get_device_endpoint_uuids(endpoints[0])
+ src_device = self.__task_executor.get_device(DeviceId(**json_device_id(src_device_uuid)))
+ src_controller = self.__task_executor.get_device_controller(src_device)
+ if src_controller is None: src_controller = src_device
- if device_uuid_src != device_uuid_dst:
- raise Exception('Different Src-Dst devices not supported by now')
- device_uuid = device_uuid_src
+ dst_device_uuid, _ = get_device_endpoint_uuids(endpoints[1])
+ dst_device = self.__task_executor.get_device(DeviceId(**json_device_id(dst_device_uuid)))
+ dst_controller = self.__task_executor.get_device_controller(dst_device)
+ if dst_controller is None: dst_controller = dst_device
- device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
+ if src_controller.device_id.device_uuid.uuid != dst_controller.device_id.device_uuid.uuid:
+ raise Exception('Different Src-Dst devices not supported by now')
+ controller = src_controller
json_config_rule = json_config_rule_delete('/services/service[{:s}]'.format(service_uuid), {
'uuid': service_uuid
})
- del device_obj.device_config.config_rules[:]
- device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
- self.__task_executor.configure_device(device_obj)
+ del controller.device_config.config_rules[:]
+ controller.device_config.config_rules.append(ConfigRule(**json_config_rule))
+ self.__task_executor.configure_device(controller)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to DeleteEndpoint for Service({:s})'.format(str(service_uuid)))
diff --git a/src/service/service/task_scheduler/TaskExecutor.py b/src/service/service/task_scheduler/TaskExecutor.py
index 54aef8c37d1d8aaf3946606d056595e1c7e1538d..3d157e3145d4b195c0251a4ab79f710a38726569 100644
--- a/src/service/service/task_scheduler/TaskExecutor.py
+++ b/src/service/service/task_scheduler/TaskExecutor.py
@@ -105,24 +105,24 @@ class TaskExecutor:
self._device_client.ConfigureDevice(device)
self._store_grpc_object(CacheableObjectType.DEVICE, device_key, device)
- def get_device_manager(self, device : Device) -> Optional[Device]:
- json_manager = None
+ def get_device_controller(self, device : Device) -> Optional[Device]:
+ json_controller = None
for config_rule in device.device_config.config_rules:
if config_rule.WhichOneof('config_rule') != 'custom': continue
- if config_rule.custom.resource_key != '_manager': continue
- json_manager = json.loads(config_rule.custom.resource_value)
+ if config_rule.custom.resource_key != '_controller': continue
+ json_controller = json.loads(config_rule.custom.resource_value)
break
- if json_manager is None: return None
+ if json_controller is None: return None
- manager_uuid = json_manager['uuid']
- manager = self.get_device(DeviceId(**json_device_id(manager_uuid)))
- manager_uuid = manager.device_id.device_uuid.uuid
- if manager is None: raise Exception('Device({:s}) not found'.format(str(manager_uuid)))
- return manager
+ controller_uuid = json_controller['uuid']
+ controller = self.get_device(DeviceId(**json_device_id(controller_uuid)))
+ controller_uuid = controller.device_id.device_uuid.uuid
+ if controller is None: raise Exception('Device({:s}) not found'.format(str(controller_uuid)))
+ return controller
def get_devices_from_connection(
- self, connection : Connection, exclude_managed : bool = False
+ self, connection : Connection, exclude_managed_by_controller : bool = False
) -> Dict[str, Device]:
devices = dict()
for endpoint_id in connection.path_hops_endpoint_ids:
@@ -130,13 +130,13 @@ class TaskExecutor:
device_uuid = endpoint_id.device_id.device_uuid.uuid
if device is None: raise Exception('Device({:s}) not found'.format(str(device_uuid)))
- manager = self.get_device_manager(device)
- if manager is None:
+ controller = self.get_device_controller(device)
+ if controller is None:
devices[device_uuid] = device
else:
- if not exclude_managed:
+ if not exclude_managed_by_controller:
devices[device_uuid] = device
- devices[manager.device_id.device_uuid.uuid] = manager
+ devices[controller.device_id.device_uuid.uuid] = controller
return devices
# ----- Service-related methods ------------------------------------------------------------------------------------
@@ -166,6 +166,6 @@ class TaskExecutor:
def get_service_handler(
self, connection : Connection, service : Service, **service_handler_settings
) -> '_ServiceHandler':
- connection_devices = self.get_devices_from_connection(connection, exclude_managed=True)
+ connection_devices = self.get_devices_from_connection(connection, exclude_managed_by_controller=True)
service_handler_class = get_service_handler_class(self._service_handler_factory, service, connection_devices)
return service_handler_class(service, self, **service_handler_settings)