Merge branch 'feat/107-implement-service-handler-for-flex-scale-optical-connections' into 'develop' (7d7503e0) · Commits · TFS / controller

src/service/requirements.in

+1 −0

Original line number	Diff line number	Diff line
		@@ -19,3 +19,4 @@ netaddr==0.9.0
		networkx==2.6.3
		pydot==1.4.2
		redis==4.1.2
		requests==2.27.1

src/service/service/ServiceServiceServicerImpl.py

+90 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,13 @@ from .service_handler_api.ServiceHandlerFactory import ServiceHandlerFactory
		from .task_scheduler.TaskScheduler import TasksScheduler
		from .tools.GeodesicDistance import gps_distance

		from common.tools.object_factory.Context import json_context_id
		from common.tools.object_factory.Topology import json_topology_id
		from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME
		from common.proto.context_pb2 import Empty, TopologyId
		from service.service.tools.OpticalTools import add_lightpath, delete_lightpath, adapt_reply, get_device_name_from_uuid, get_optical_band


		LOGGER = logging.getLogger(__name__)

		METRICS_POOL = MetricsPool('Service', 'RPC')
		@@ -242,6 +249,65 @@ class ServiceServiceServicerImpl(ServiceServiceServicer):
		pathcomp_request = PathCompRequest()
		pathcomp_request.services.append(service_with_uuids) # pylint: disable=no-member

		if service.service_type == ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY:
		context_id_x = json_context_id(DEFAULT_CONTEXT_NAME)
		topology_id_x = json_topology_id(
		DEFAULT_TOPOLOGY_NAME, context_id_x)
		topology_details = context_client.GetTopologyDetails(
		TopologyId(**topology_id_x))
		devices = topology_details.devices
		context_uuid_x = topology_details.topology_id.context_id.context_uuid.uuid
		topology_uuid_x = topology_details.topology_id.topology_uuid.uuid
		devs = []
		ports = []
		for endpoint_id in service.service_endpoint_ids:
		devs.append(endpoint_id.device_id.device_uuid.uuid)
		ports.append(endpoint_id.endpoint_uuid.uuid)
		src = devs[0]
		dst = devs[1]
		bidir = None
		ob_band = None
		bitrate = 100
		for constraint in service.service_constraints:
		if "bandwidth" in constraint.custom.constraint_type:
		bitrate = int(float(constraint.custom.constraint_value))
		elif "bidirectionality" in constraint.custom.constraint_type:
		bidir = int(constraint.custom.constraint_value)
		elif "optical-band-width" in constraint.custom.constraint_type:
		ob_band = int(constraint.custom.constraint_value)

		# to get the reply form the optical module
		reply_txt = add_lightpath(src, dst, bitrate, bidir, ob_band)

		# reply with 2 transponders and 2 roadms
		reply_json = json.loads(reply_txt)
		optical_band_txt = ""
		if "new_optical_band" in reply_json.keys():
		if reply_json["new_optical_band"] == 1:
		if reply_json["parent_opt_band"]:
		if "parent_opt_band" in reply_json.keys():
		parent_ob = reply_json["parent_opt_band"]
		LOGGER.debug('Parent optical-band={}'.format(parent_ob))
		optical_band_txt = get_optical_band(parent_ob)
		LOGGER.debug('optical-band details={}'.format(optical_band_txt))
		else:
		LOGGER.debug('expected optical band not found')
		else:
		LOGGER.debug('expected optical band not found')
		else:
		LOGGER.debug('Using existing optical band')
		else:
		LOGGER.debug('Using existing optical band')
		if reply_txt is not None:
		optical_reply = adapt_reply(
		devices, _service, reply_json, context_uuid_x, topology_uuid_x, optical_band_txt
		)
		LOGGER.debug('optical_reply={:s}'.format(
		grpc_message_to_json_string(optical_reply)))

		tasks_scheduler.compose_from_pathcompreply(
		optical_reply, is_delete=False)

		if num_disjoint_paths is None or num_disjoint_paths in {0, 1}:
		pathcomp_request.shortest_path.Clear() # pylint: disable=no-member
		else:
		@@ -280,6 +346,30 @@ class ServiceServiceServicerImpl(ServiceServiceServicer):
		context_client.RemoveService(request)
		return Empty()

		if service.service_type == ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY:
		devs = []

		context_id_x = json_context_id(DEFAULT_CONTEXT_NAME)
		topology_id_x = json_topology_id(
		DEFAULT_TOPOLOGY_NAME, context_id_x)
		topology_details = context_client.GetTopologyDetails(
		TopologyId(**topology_id_x))
		devices = topology_details.devices
		for endpoint_id in service.service_endpoint_ids:
		devs.append(endpoint_id.device_id.device_uuid.uuid)
		src = get_device_name_from_uuid(devices, devs[0])
		dst = get_device_name_from_uuid(devices, devs[1])

		bitrate = int(
		float(service.service_constraints[0].custom.constraint_value))
		if len(service.service_config.config_rules) > 0:
		c_rules_dict = json.loads(
		service.service_config.config_rules[0].custom.resource_value)
		flow_id = c_rules_dict["flow_id"]

		reply = delete_lightpath(flow_id, src, dst, bitrate)


		# Normal service
		# Feed TaskScheduler with this service and the sub-services and sub-connections related to this service.
		# TaskScheduler identifies inter-dependencies among them and produces a schedule of tasks (an ordered list of

src/service/service/service_handlers/init.py

+7 −0

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,
		}
		])
		]

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

0 → 100644

+255 −0

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

File added.

Preview size limit exceeded, changes collapsed.