Resolve "Implement Service Handler for FLEX-SCALE Optical Connections" (!193) · Merge requests · TFS / controller

src/service/service/service_handlers/oc/ConfigRules.py

0 → 100644

+255 −0

Changes for src/service/service/service_handlers/oc/ConfigRules.py: 255 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		from typing import Dict, List
		from common.tools.object_factory.ConfigRule import json_config_rule_delete, json_config_rule_set
		from service.service.service_handler_api.AnyTreeTools import TreeNode

		def setup_config_rules(
		service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str, endpoint_name : str,
		service_settings : TreeNode, endpoint_settings : TreeNode
		) -> List[Dict]:

		if service_settings is None: return []
		if endpoint_settings is None: return []

		json_settings : Dict = service_settings.value
		json_endpoint_settings : Dict = endpoint_settings.value

		service_short_uuid = service_uuid.split('-')[-1]
		network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
		network_interface_desc = '{:s}-NetIf'.format(service_uuid)
		network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)

		mtu = json_settings.get('mtu', 1450 ) # 1512
		#address_families = json_settings.get('address_families', [] ) # ['IPV4']
		bgp_as = json_settings.get('bgp_as', 0 ) # 65000
		bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333

		#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
		route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
		sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
		vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
		address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
		address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
		if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)

		json_config_rules = [
		json_config_rule_set(
		'/network_instance[{:s}]'.format(network_instance_name), {
		'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',
		'route_distinguisher': route_distinguisher,
		#'router_id': router_id, 'address_families': address_families,
		}),
		json_config_rule_set(
		'/interface[{:s}]'.format(endpoint_name), {
		'name': endpoint_name, 'description': network_interface_desc, 'mtu': mtu,
		}),
		json_config_rule_set(
		'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_name, sub_interface_index), {
		'name': endpoint_name, 'index': sub_interface_index,
		'description': network_subinterface_desc, 'vlan_id': vlan_id,
		'address_ip': address_ip, 'address_prefix': address_prefix,
		}),
		json_config_rule_set(
		'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
		'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_name,
		'subinterface': sub_interface_index,
		}),
		json_config_rule_set(
		'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
		'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,
		}),
		json_config_rule_set(
		'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
		'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
		'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
		}),
		json_config_rule_set(
		'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
		network_instance_name), {
		'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
		'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
		}),
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
		'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
		}),
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
		network_instance_name, bgp_route_target), {
		'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
		'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
		}),
		json_config_rule_set(
		'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
		'policy_name': '{:s}_import'.format(network_instance_name),
		}),
		json_config_rule_set(
		'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
		network_instance_name, '3'), {
		'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
		'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
		'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
		}),
		json_config_rule_set(
		# pylint: disable=duplicate-string-formatting-argument
		'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
		network_instance_name, network_instance_name), {
		'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),
		}),
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
		'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
		}),
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
		network_instance_name, bgp_route_target), {
		'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
		'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
		}),
		json_config_rule_set(
		'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
		'policy_name': '{:s}_export'.format(network_instance_name),
		}),
		json_config_rule_set(
		'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
		network_instance_name, '3'), {
		'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
		'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
		'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
		}),
		json_config_rule_set(
		# pylint: disable=duplicate-string-formatting-argument
		'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
		network_instance_name, network_instance_name), {
		'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),
		}),
		]

		return json_config_rules

		def teardown_config_rules(
		service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str, endpoint_name : str,
		service_settings : TreeNode, endpoint_settings : TreeNode
		) -> List[Dict]:

		if service_settings is None: return []
		if endpoint_settings is None: return []

		json_settings : Dict = service_settings.value
		json_endpoint_settings : Dict = endpoint_settings.value

		#mtu = json_settings.get('mtu', 1450 ) # 1512
		#address_families = json_settings.get('address_families', [] ) # ['IPV4']
		#bgp_as = json_settings.get('bgp_as', 0 ) # 65000
		bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333

		#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
		#route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
		sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
		vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
		#address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
		#address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30

		if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)
		service_short_uuid = service_uuid.split('-')[-1]
		network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
		#network_interface_desc = '{:s}-NetIf'.format(service_uuid)
		#network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)

		json_config_rules = [
		json_config_rule_delete(
		'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
		'name': network_instance_name, 'id': if_subif_name,
		}),
		json_config_rule_delete(
		'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_name, sub_interface_index), {
		'name': endpoint_name, 'index': sub_interface_index,
		}),
		json_config_rule_delete(
		'/interface[{:s}]'.format(endpoint_name), {
		'name': endpoint_name,
		}),
		json_config_rule_delete(
		'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
		network_instance_name), {
		'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
		'address_family': 'IPV4',
		}),
		json_config_rule_delete(
		'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
		'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
		'address_family': 'IPV4',
		}),
		json_config_rule_delete(
		'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
		'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP',
		}),
		json_config_rule_delete(
		# pylint: disable=duplicate-string-formatting-argument
		'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
		network_instance_name, network_instance_name), {
		'name': network_instance_name,
		}),
		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
		network_instance_name, '3'), {
		'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
		}),
		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
		'policy_name': '{:s}_import'.format(network_instance_name),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
		network_instance_name, bgp_route_target), {
		'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
		'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
		'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
		}),
		json_config_rule_delete(
		# pylint: disable=duplicate-string-formatting-argument
		'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
		network_instance_name, network_instance_name), {
		'name': network_instance_name,
		}),
		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
		network_instance_name, '3'), {
		'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
		}),
		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
		'policy_name': '{:s}_export'.format(network_instance_name),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
		network_instance_name, bgp_route_target), {
		'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
		'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
		'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
		}),
		json_config_rule_delete(
		'/network_instance[{:s}]'.format(network_instance_name), {
		'name': network_instance_name
		}),
		]
		return json_config_rules

src/service/service/service_handlers/oc/OCServiceHandler.py

0 → 100644

+152 −0

Changes for src/service/service/service_handlers/oc/OCServiceHandler.py: 152 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		import json, logging
		from typing import Any, List, Optional, Tuple, Union
		from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method
		from common.proto.context_pb2 import ConfigRule, DeviceId, EndPointId, Service
		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, 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
		#from .ConfigRules import setup_config_rules, teardown_config_rules
		from .OCTools import convert_endpoints_to_flows, handle_flows_names

		LOGGER = logging.getLogger(__name__)

		METRICS_POOL = MetricsPool('Service', 'Handler', labels={'handler': 'oc'})

		class OCServiceHandler(_ServiceHandler):
		def __init__( # pylint: disable=super-init-not-called
		self, service : Service, task_executor : TaskExecutor, **settings
		) -> None:
		self.__service = service
		self.__task_executor = task_executor
		self.__settings_handler = SettingsHandler(service.service_config, **settings)

		@metered_subclass_method(METRICS_POOL)
		def SetEndpoint(
		self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
		) -> List[Union[bool, Exception]]:

		chk_type('endpoints', endpoints, list)
		if len(endpoints) == 0: return []
		is_opticalband =False
		#service_uuid = self.__service.service_id.service_uuid.uuid
		settings=None
		if self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid)):
		is_opticalband=True
		settings = self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid))
		else:
		settings = self.__settings_handler.get('/settings')

		LOGGER.debug("settings={}".format(settings))
		# settings = self.__settings_handler.get('/settings')

		#flow is the new variable that stores input-output relationship

		flows = convert_endpoints_to_flows(endpoints)
		#handled_flows=handle_flows_names(flows=flows,task_executor=self.__task_executor)
		LOGGER.debug("dict of flows= {}".format(flows))
		#LOGGER.info("Handled Flows %s",handled_flows)

		results = []
		#new cycle for setting optical devices
		for device_uuid, dev_flows in flows.items():
		try:
		device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
		LOGGER.debug("device_obj={}".format(device_obj))
		if (settings):
		LOGGER.debug("settings={}".format(settings))
		self.__task_executor.configure_optical_device(device_obj, settings, dev_flows, is_opticalband)
		results.append(True)
		except Exception as e: # pylint: disable=broad-except
		LOGGER.exception('Unable to configure Device({:s})'.format(str(device_uuid)))
		results.append(e)

		return results

		@metered_subclass_method(METRICS_POOL)
		def DeleteEndpoint(
		self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
		) -> List[Union[bool, Exception]]:
		chk_type('endpoints', endpoints, list)
		if len(endpoints) == 0: return []

		# TODO: to be checked and elaborated

		results = []
		for endpoint in endpoints:
		try:
		device_uuid, endpoint_uuid = get_device_endpoint_uuids(endpoint)
		device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
		self.__task_executor.configure_device(device_obj)
		results.append(True)
		except Exception as e: # pylint: disable=broad-except
		LOGGER.exception('Unable to DeleteEndpoint({:s})'.format(str(endpoint)))
		results.append(e)

		return results

		@metered_subclass_method(METRICS_POOL)
		def SetConstraint(self, constraints : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
		chk_type('constraints', constraints, list)
		if len(constraints) == 0: return []

		msg = '[SetConstraint] Method not implemented. Constraints({:s}) are being ignored.'
		LOGGER.warning(msg.format(str(constraints)))
		return [True for _ in range(len(constraints))]

		@metered_subclass_method(METRICS_POOL)
		def DeleteConstraint(self, constraints : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
		chk_type('constraints', constraints, list)
		if len(constraints) == 0: return []

		msg = '[DeleteConstraint] Method not implemented. Constraints({:s}) are being ignored.'
		LOGGER.warning(msg.format(str(constraints)))
		return [True for _ in range(len(constraints))]

		@metered_subclass_method(METRICS_POOL)
		def SetConfig(self, resources : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
		chk_type('resources', resources, list)
		if len(resources) == 0: return []

		results = []
		for resource in resources:
		try:
		resource_value = json.loads(resource[1])
		self.__settings_handler.set(resource[0], resource_value)
		results.append(True)
		except Exception as e: # pylint: disable=broad-except
		LOGGER.exception('Unable to SetConfig({:s})'.format(str(resource)))
		results.append(e)

		return results

		@metered_subclass_method(METRICS_POOL)
		def DeleteConfig(self, resources : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
		chk_type('resources', resources, list)
		if len(resources) == 0: return []

		results = []
		for resource in resources:
		try:
		self.__settings_handler.delete(resource[0])
		except Exception as e: # pylint: disable=broad-except
		LOGGER.exception('Unable to DeleteConfig({:s})'.format(str(resource)))
		results.append(e)

		return results

src/service/service/service_handlers/oc/OCTools.py

0 → 100644

+140 −0

Changes for src/service/service/service_handlers/oc/OCTools.py: 140 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		from service.service.service_handler_api.Tools import get_device_endpoint_uuids, get_endpoint_matching
		from typing import Dict, Any, List, Optional, Tuple
		import logging
		from common.proto.context_pb2 import ConfigRule, DeviceId, Service
		from common.tools.object_factory.Device import json_device_id
		log = logging.getLogger(__name__)

		#def convert_endpoints_to_flows(endpoints : List[Tuple[str, str, Optional[str]]])->Dict[str: List[Tuple[str, str]]]:

		def convert_endpoints_to_flows(endpoints : List[Tuple[str, str, Optional[str]]])->Dict:
		#entries = List[Tuple[str, str, str, Optional[str]]]
		#entries = Dict[str: List[Tuple[str, str]]]
		entries = {}
		#tuple is in, out
		end = len(endpoints)
		i = 0
		bidir = 0
		log.debug("end={}".format(end))
		while(i < end):
		endpoint = endpoints[i]
		device_uuid, endpoint_uuid = endpoint[0:2]
		log.debug("current OCTools step {}, {}, {}".format(i, device_uuid, endpoint_uuid))
		if device_uuid not in entries.keys():
		entries[device_uuid] = []
		if i == 0:
		entry_tuple = "0", endpoint_uuid
		entries[device_uuid].append(entry_tuple)
		next_endpoint = endpoints[i+1]
		next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
		if next_device_uuid == device_uuid:
		bidir = 1
		log.debug("connection is bidirectional")
		entry_tuple = next_endpoint_uuid, "0"
		entries[device_uuid].append(entry_tuple)
		i = i + 1
		else:
		log.debug("connection is unidirectional")
		else:
		if not bidir:
		if i == end-1:
		#is the last node
		entry_tuple = endpoint_uuid, "0"
		entries[device_uuid].append(entry_tuple)
		else:
		#it is a transit node
		next_endpoint = endpoints[i+1]
		next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
		if next_device_uuid == device_uuid:
		entry_tuple = endpoint_uuid, next_endpoint_uuid
		entries[device_uuid].append(entry_tuple)
		i = i + 1
		log.debug("current OCTools step {}, {}, {}".format(i, next_device_uuid, device_uuid))
		else:
		log.debug("ERROR in unidirectional connection 4")
		return {}
		if bidir:
		log.debug("Ocheck i {}, {}, {}".format(i, i+1, end-1))
		if i + 1 == end-1:
		log.debug("current OCTools step {}, {}, {}".format(i, device_uuid, endpoint_uuid))
		#is the last node
		entry_tuple = endpoint_uuid, "0"
		entries[device_uuid].append(entry_tuple)
		next_endpoint = endpoints[i+1]
		log.debug("OCTools i+1 step {}, {}, {}".format(i+1, next_device_uuid, device_uuid))

		next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
		if next_device_uuid == device_uuid:
		entry_tuple = "0", next_endpoint_uuid
		entries[device_uuid].append(entry_tuple)
		i = i + 1
		else:
		log.debug("ERROR in bidirectional connection 2")
		return entries
		else:
		log.debug("OCTools i+1+2+3 step {}, {}, {}".format(i+1, next_device_uuid, device_uuid))
		#i+1
		next_endpoint = endpoints[i+1]
		next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
		if next_device_uuid == device_uuid:
		entry_tuple = endpoint_uuid, next_endpoint_uuid
		entries[device_uuid].append(entry_tuple)
		else:
		log.debug("ERROR in bidirectional connection 3")
		log.debug("{}, {}, {}".format(i, next_device_uuid, device_uuid))
		return entries
		#i+2
		next_2_endpoint = endpoints[i+2]
		next_2_device_uuid, next_2_endpoint_uuid = next_2_endpoint[0:2]
		#i+3
		next_3_endpoint = endpoints[i+3]
		next_3_device_uuid, next_3_endpoint_uuid = next_3_endpoint[0:2]
		if next_2_device_uuid == next_3_device_uuid and next_3_device_uuid == device_uuid:
		entry_tuple = next_2_endpoint_uuid, next_3_endpoint_uuid
		entries[device_uuid].append(entry_tuple)
		i = i + 3
		else:
		log.debug("ERROR in bidirection connection 4")
		return {}
		i = i + 1
		return entries


		def get_device_endpint_name (endpoint_uuid:str,device_uuid:str,task_executor)->Tuple:
		device_obj = task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
		endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
		endpoint_name = endpoint_obj.name
		return (device_obj.name, endpoint_name)

		def handle_flows_names (task_executor,flows:dict)->Dict :
		new_flows={}
		for index,( device_uuid_key , device_endpoints_list) in enumerate(flows.items()):
		for endpoint_tupple in device_endpoints_list:
		source_port=None
		destination_port=None
		device_name=""
		source_endpoint,destination_endpoint =endpoint_tupple
		if (source_endpoint !='0'):
		if get_device_endpint_name(source_endpoint,device_uuid_key,task_executor) is not None:
		device_name,source_port=get_device_endpint_name(source_endpoint,device_uuid_key,task_executor)
		if (destination_endpoint !='0'):
		if get_device_endpint_name(destination_endpoint,device_uuid_key,task_executor) is not None:
		device_name,destination_port=get_device_endpint_name(destination_endpoint,device_uuid_key,task_executor)
		if (device_name not in new_flows):
		new_flows[device_name]=[]
		new_flows[device_name].append((source_port,destination_port))
		return new_flows

src/service/service/service_handlers/oc/init.py

0 → 100644

+14 −0

Changes for src/service/service/service_handlers/oc/__init__.py: 14 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

src/service/service/service_handlers/init.py

+7 −0

Changes for src/service/service/service_handlers/__init__.py: 7 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@ from .p4.p4_service_handler import P4ServiceHandler
		from .tapi_tapi.TapiServiceHandler import TapiServiceHandler
		from .tapi_xr.TapiXrServiceHandler import TapiXrServiceHandler
		from .e2e_orch.E2EOrchestratorServiceHandler import E2EOrchestratorServiceHandler
		from .oc.OCServiceHandler import OCServiceHandler

		SERVICE_HANDLERS = [
		(L2NMEmulatedServiceHandler, [
		@@ -100,4 +101,10 @@ SERVICE_HANDLERS = [
		FilterFieldEnum.DEVICE_DRIVER : [DeviceDriverEnum.DEVICEDRIVER_FLEXSCALE],
		}
		]),
		(OCServiceHandler, [
		{
		FilterFieldEnum.SERVICE_TYPE : ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY,
		FilterFieldEnum.DEVICE_DRIVER : DeviceDriverEnum.DEVICEDRIVER_OC,
		}
		])
		]

Resolve "Implement Service Handler for FLEX-SCALE Optical Connections"

Merge request reports