Refactor IetfL3VpnDriver and OpticalTfsDriver: remove unused TAPI LSP... (f22e882f) · Commits · TFS / controller

src/device/service/drivers/ietf_l3vpn/IetfL3VpnDriver.py

+1 −9

Original line number	Diff line number	Diff line
		@@ -27,7 +27,7 @@ from .handlers.SubscriptionHandler import (
		from .Constants import SPECIAL_RESOURCE_MAPPINGS
		from .TfsApiClient import TfsApiClient
		from .Tools import compose_resource_endpoint
		from .templates.tools import create_request, tapi_tequest
		from .templates.tools import create_request


		LOGGER = logging.getLogger(__name__)
		@@ -199,14 +199,6 @@ class IetfL3VpnDriver(_Driver):
		except Exception as e:
		MSG = 'Invalid resource_value type: expected dict, got {:s}'
		results.append((resource, e))
		elif "tapi_lsp" in str(resources):
		for resource in resources:
		try:
		tapi_tequest(resource)
		results.append((resource, True))
		except Exception as e:
		MSG = "Invalid resource_value type: expected dict, got {:s}"
		results.append((resource, e))
		else:
		for resource in resources:
		resource_key, resource_value = resource

src/device/service/drivers/ietf_l3vpn/templates/tools.py

+0 −96

Original line number	Diff line number	Diff line
		@@ -313,99 +313,3 @@ def patch_optical_channel_frequency(data, DEVICE_ID):
		headers=HEADERS)
		assert response.status_code == 200
		return response

		def process_uuid(service, url):
		headers = {
		"Content-Type": "application/json",
		"Accept": "application/json"
		}

		LOGGER.info(f"Processing service {service} to URL: {url}")
		try:
		response = 200
		# requests.post(url = url, json=service, headers=headers, timeout=300)
		LOGGER.info("Response Status code: %s", response)
		except requests.exceptions.RequestException as e:
		LOGGER.info(f"ERROR equest to {service} failed: {e}")

		def tapi_tequest(resource_value):

		services, urls = build_tapi_connectivity(resource_value)
		for service, url in zip(services, urls):
		LOGGER.info(f"Services to be processed: {json.dumps(service, indent=2)}")
		LOGGER.info(f"URL to be used: {url}")

		executor.submit(process_uuid, service, url)

		def build_tapi_connectivity(service_data):
		LOGGER.info(f"Building TAPI connectivity for services data: {service_data}")
		outputs = []
		urls = []
		rules_set = service_data[1]["rule_set"]
		for rule_set in rules_set:
		direction = rule_set["direction"]
		layer_name = rule_set["layer_protocol_name"]
		layer_qualifier = rule_set["layer_protocol_qualifier"]
		urls.append(rule_set["url"])
		cs = {
		"uuid": rule_set["tenant_uuid"],
		"connectivity-direction": direction,
		"layer-protocol-name": layer_name,
		"layer-protocol-qualifier": layer_qualifier,
		"end-point": []
		}

		endpoints = []
		if direction == "UNIDIRECTIONAL":
		endpoints.append({
		"layer-protocol-name": layer_name,
		"layer-protocol-qualifier": layer_qualifier,
		"service-interface-point": {"service-interface-point-uuid": rule_set["src"]},
		"direction:": "INPUT",
		"local-id": rule_set["src"]
		})
		endpoints.append({
		"layer-protocol-name": layer_name,
		"layer-protocol-qualifier": layer_qualifier,
		"service-interface-point": {"service-interface-point-uuid": rule_set["dst"]},
		"direction:": "OUTPUT",
		"local-id": rule_set["dst"]
		})
		else:
		for point in [rule_set["src"], rule_set["dst"]]:
		ep = {
		"layer-protocol-name": layer_name,
		"layer-protocol-qualifier": layer_qualifier,
		"service-interface-point": {"service-interface-point-uuid": point},
		"direction:": "BIDIRECTIONAL",
		"local-id": point
		}
		if rule_set.get("lower_frequency_mhz") != "NONE":
		ep["tapi-photonic-media:media-channel-connectivity-service-end-point-spec"] = {
		"mc-config": {
		"spectrum": {
		"frequency-constraint": {
		"adjustment-granularity": rule_set.get("granularity", "NONE"),
		"grid-type": rule_set.get("grid_type", "NONE")
		},
		"lower-frequency": rule_set["lower_frequency_mhz"],
		"upper-frequency": rule_set["upper_frequency_mhz"]
		}
		}
		}
		endpoints.append(ep)
		cs["end-point"] = endpoints

		route_obj = rule_set.get("route_objective_function", "UNSPECIFIED")
		cs["route-objective-function"] = route_obj if route_obj != "NONE" else "10000"
		capacity = rule_set.get("capacity", "NONE")
		if capacity != "NONE":
		parts = capacity.split("-")
		value = parts[0]
		unit = parts[1] if len(parts) > 1 else ""
		cs["requested-capacity"] = {
		"total-size": {"value": value, "unit": unit}
		}
		outputs.append({"tapi-connectivity:connectivity-service": [cs]})
		return outputs, urls

src/device/service/drivers/optical_tfs/OpticalTfsDriver.py

+9 −22

Original line number	Diff line number	Diff line
		@@ -20,7 +20,6 @@ from common.type_checkers.Checkers import chk_string, chk_type
		from device.service.driver_api._Driver import _Driver, RESOURCE_ENDPOINTS, RESOURCE_SERVICES
		from device.service.driver_api.ImportTopologyEnum import ImportTopologyEnum, get_import_topology
		from .TfsApiClient import TfsApiClient
		from .templates.tools import create_request
		#from .TfsOpticalClient import TfsOpticalClient

		LOGGER = logging.getLogger(__name__)
		@@ -119,18 +118,6 @@ class OpticalTfsDriver(_Driver):
		with self.__lock:
		self.tac.check_credentials()
		for resource in resources:
		LOGGER.info('resource = {:s}'.format(str(resource)))
		if 'tapi_lsp' in str(resource):
		LOGGER.info('Processing tapi_lsp resource')
		try:
		create_request(resource)
		LOGGER.info('Request created successfully')
		results.append((resource, True))
		except Exception as e:
		MSG = 'Invalid resource_value type: expected dict, got {:s}'
		results.append((resource, e))
		else:
		LOGGER.info('Processing non-tapi_lsp resource')
		resource_key, resource_value = resource
		try:
		resource_value = json.loads(resource_value)

src/device/service/drivers/optical_tfs/templates/lsp.json

deleted100644 → 0

+0 −52

Original line number	Diff line number	Diff line
		{
		"tapi-connectivity:connectivity-service" : [
		{
		"connectivity-direction" : "",
		"end-point" : [
		{
		"direction" : "",
		"layer-protocol-name" : "",
		"layer-protocol-qualifier" : "",
		"local-id" : "",
		"service-interface-point" : {
		"service-interface-point-uuid" : ""
		},

		"tapi-photonic-media:media-channel-connectivity-service-end-point-spec":{
		"mc-config":{
		"spectrum":{
		"lower-frequency": "",
		"upper-frequency": "",
		"frequency-constraint":{
		"adjustment-granularity" : "",
		"grid-type": ""
		}
		}
		}
		}
		},
		{
		"direction" : "",
		"layer-protocol-name" : "",
		"layer-protocol-qualifier" : "",
		"local-id" : "",
		"service-interface-point" : {
		"service-interface-point-uuid" : ""
		}
		}
		],
		"layer-protocol-name" : "",
		"layer-protocol-qualifier" : "",
		"requested-capacity" : {
		"total-size" : {
		"unit" : "",
		"value" : ""
		}
		},
		"include-link":[
		],
		"route-objective-function" : "10000",
		"uuid" : ""
		}
		]
		}
		No newline at end of file

src/device/service/drivers/optical_tfs/templates/tools.py

deleted100644 → 0

+0 −78

Original line number	Diff line number	Diff line
		# Copyright 2022-2025 ETSI SDG TeraFlowSDN (TFS) (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
		import logging
		import os
		import requests

		LOGGER = logging.getLogger(__name__)

		""" Create and send HTTP request based on a JSON template and provided resource value.
		The JSON template is expected to be in the same directory as this script, named 'lsp.json'."""
		def create_request(resource_value):
		LOGGER.info("Creating request tapi- lsp for resource_value: %s", resource_value)
		try:
		BaseDir = os.path.dirname(os.path.abspath(__file__))
		json_path = os.path.join(BaseDir, 'lsp.json')
		with open(json_path, 'r', encoding='utf-8') as f:
		template = json.load(f)
		rule_set = resource_value[1]['rule_set']
		svc = template["tapi-connectivity:connectivity-service"][0]
		svc["connectivity-direction"] = rule_set["direction"]
		svc["layer-protocol-name"] = rule_set["layer_protocol_name"]
		svc["layer-protocol-qualifier"] = rule_set["layer_protocol_qualifier"]
		svc["requested-capacity"]["total-size"]["unit"] = "GHz"
		svc["requested-capacity"]["total-size"]["value"] = rule_set["bw"]
		svc["include-link"] = rule_set["link_uuid_path"]
		svc["uuid"] = rule_set["uuid"]

		# src - end-point
		ep0 = svc["end-point"][0]
		ep0["service-interface-point"]["service-interface-point-uuid"] = rule_set["src"]
		ep0["direction"] = rule_set["direction"]
		ep0["layer-protocol-name"] = rule_set["layer_protocol_name"]
		ep0["layer-protocol-qualifier"] = rule_set["layer_protocol_qualifier"]
		ep0["local-id"] = rule_set["src"]

		# Accede correctamente a espectro anidado
		media_spec = ep0["tapi-photonic-media:media-channel-connectivity-service-end-point-spec"]
		mc_config = media_spec["mc-config"]
		spectrum = mc_config["spectrum"]
		spectrum["lower-frequency"] = rule_set["lower_frequency_mhz"]
		spectrum["upper-frequency"] = rule_set["upper_frequency_mhz"]
		spectrum["frequency-constraint"]["adjustment-granularity"] = rule_set["granularity"]
		spectrum["frequency-constraint"]["grid-type"] = rule_set["grid_type"]

		tenant = rule_set["tenant_uuid"]

		# dst - end-point
		ep1 = svc["end-point"][1]
		ep1["service-interface-point"]["service-interface-point-uuid"] = rule_set["dst"]
		ep1["direction"] = rule_set["direction"]
		ep1["layer-protocol-name"] = rule_set["layer_protocol_name"]
		ep1["layer-protocol-qualifier"] = rule_set["layer_protocol_qualifier"]
		ep1["local-id"] = rule_set["dst"]

		url = f"http://11.1.1.101:4900/{tenant}/restconf/data/tapi-common:context/tapi-connectivity:connectivity-context"
		headers = {
		"Content-Type": "application/json",
		"Accept": "application/json"
		}
		response = requests.post(url, headers=headers, json=template, timeout=10)
		return response

		except (OSError, json.JSONDecodeError, requests.RequestException) as e:
		LOGGER.error("Error creating request: %s", str(e))