Loading proto/context.proto +2 −0 Viewed Changes for proto/context.proto: 2 added lines, 0 removed lines. Original line number Diff line number Diff line Loading @@ -214,6 +214,7 @@ enum DeviceDriverEnum { DEVICEDRIVER_OPTICAL_TFS = 9; DEVICEDRIVER_IETF_ACTN = 10; DEVICEDRIVER_OC = 11; DEVICEDRIVER_QKD = 12; } enum DeviceOperationalStatusEnum { Loading Loading @@ -300,6 +301,7 @@ enum ServiceTypeEnum { SERVICETYPE_TE = 4; SERVICETYPE_E2E = 5; SERVICETYPE_OPTICAL_CONNECTIVITY = 6; SERVICETYPE_QKD = 7; } enum ServiceStatusEnum { Loading src/common/DeviceTypes.py +1 −0 Viewed Changes for src/common/DeviceTypes.py: 1 added line, 0 removed lines. Original line number Diff line number Diff line Loading @@ -47,6 +47,7 @@ class DeviceTypeEnum(Enum): PACKET_ROUTER = 'packet-router' PACKET_SWITCH = 'packet-switch' XR_CONSTELLATION = 'xr-constellation' QKD_NODE = 'qkd-node' # ETSI TeraFlowSDN controller TERAFLOWSDN_CONTROLLER = 'teraflowsdn' src/context/service/database/models/enums/DeviceDriver.py +1 −0 Viewed Changes for src/context/service/database/models/enums/DeviceDriver.py: 1 added line, 0 removed lines. Original line number Diff line number Diff line Loading @@ -34,6 +34,7 @@ class ORM_DeviceDriverEnum(enum.Enum): OPTICAL_TFS = DeviceDriverEnum.DEVICEDRIVER_OPTICAL_TFS IETF_ACTN = DeviceDriverEnum.DEVICEDRIVER_IETF_ACTN OC = DeviceDriverEnum.DEVICEDRIVER_OC QKD = DeviceDriverEnum.DEVICEDRIVER_QKD grpc_to_enum__device_driver = functools.partial( grpc_to_enum, DeviceDriverEnum, ORM_DeviceDriverEnum) src/device/service/drivers/qkd/QKDDriver.py 0 → 100644 +168 −0 Viewed Changes for src/device/service/drivers/qkd/QKDDriver.py: 168 added lines, 0 removed lines. Original line number Diff line number Diff line # Copyright 2022-2024 ETSI OSG/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, logging, requests, threading from requests.auth import HTTPBasicAuth from typing import Any, Iterator, List, Optional, Tuple, Union from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method from common.type_checkers.Checkers import chk_string, chk_type from device.service.driver_api._Driver import _Driver from . import ALL_RESOURCE_KEYS from .Tools import find_key, config_getter, create_connectivity_link LOGGER = logging.getLogger(__name__) DRIVER_NAME = 'qkd' METRICS_POOL = MetricsPool('Device', 'Driver', labels={'driver': DRIVER_NAME}) class QKDDriver(_Driver): def __init__(self, address: str, port: int, **settings) -> None: super().__init__(DRIVER_NAME, address, port, **settings) self.__lock = threading.Lock() self.__started = threading.Event() self.__terminate = threading.Event() username = self.settings.get('username') password = self.settings.get('password') self.__auth = HTTPBasicAuth(username, password) if username is not None and password is not None else None scheme = self.settings.get('scheme', 'http') self.__qkd_root = '{:s}://{:s}:{:d}'.format(scheme, self.address, int(self.port)) self.__timeout = int(self.settings.get('timeout', 120)) self.__node_ids = set(self.settings.get('node_ids', [])) token = self.settings.get('token') self.__headers = {'Authorization': 'Bearer ' + token} self.__initial_data = None def Connect(self) -> bool: url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' with self.__lock: if self.__started.is_set(): return True r = None try: LOGGER.info(f'requests.get("{url}", timeout={self.__timeout}, verify=False, auth={self.__auth}, headers={self.__headers})') r = requests.get(url, timeout=self.__timeout, verify=False, auth=self.__auth, headers=self.__headers) LOGGER.info(f'R: {r}') LOGGER.info(f'Text: {r.text}') LOGGER.info(f'Json: {r.json()}') except requests.exceptions.Timeout: LOGGER.exception('Timeout connecting {:s}'.format(str(self.__qkd_root))) return False except Exception: # pylint: disable=broad-except LOGGER.exception('Exception connecting {:s}'.format(str(self.__qkd_root))) return False else: self.__started.set() self.__initial_data = r.json() return True def Disconnect(self) -> bool: with self.__lock: self.__terminate.set() return True @metered_subclass_method(METRICS_POOL) def GetInitialConfig(self) -> List[Tuple[str, Any]]: with self.__lock: return self.__initial_data @metered_subclass_method(METRICS_POOL) def GetConfig(self, resource_keys : List[str] = []) -> List[Tuple[str, Union[Any, None, Exception]]]: chk_type('resources', resource_keys, list) results = [] with self.__lock: if len(resource_keys) == 0: resource_keys = ALL_RESOURCE_KEYS for i, resource_key in enumerate(resource_keys): str_resource_name = 'resource_key[#{:d}]'.format(i) chk_string(str_resource_name, resource_key, allow_empty=False) results.extend(config_getter( self.__qkd_root, resource_key, timeout=self.__timeout, auth=self.__auth, node_ids=self.__node_ids, headers=self.__headers)) return results @metered_subclass_method(METRICS_POOL) def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource_key, resource_value in resources: LOGGER.info('resource = {:s}'.format(str(resource_key))) if resource_key.startswith('/link'): try: resource_value = json.loads(resource_value) link_uuid = resource_value['uuid'] node_id_src = resource_value['src_qkdn_id'] interface_id_src = resource_value['src_interface_id'] node_id_dst = resource_value['dst_qkdn_id'] interface_id_dst = resource_value['dst_interface_id'] virt_prev_hop = resource_value.get('virt_prev_hop') virt_next_hops = resource_value.get('virt_next_hops') virt_bandwidth = resource_value.get('virt_bandwidth') data = create_connectivity_link( self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, virt_prev_hop, virt_next_hops, virt_bandwidth, timeout=self.__timeout, auth=self.__auth, headers=self.__headers ) #data = create_connectivity_link( # self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, # timeout=self.__timeout, auth=self.__auth #) results.append(True) except Exception as e: # pylint: disable=broad-except LOGGER.exception('Unhandled error processing resource_key({:s})'.format(str(resource_key))) results.append(e) else: results.append(True) LOGGER.info('Test keys: ' + str([x for x,y in resources])) LOGGER.info('Test values: ' + str(results)) return results ''' @metered_subclass_method(METRICS_POOL) def DeleteConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource in resources: LOGGER.info('resource = {:s}'.format(str(resource))) uuid = find_key(resource, 'uuid') results.extend(delete_connectivity_service( self.__qkd_root, uuid, timeout=self.__timeout, auth=self.__auth)) return results ''' @metered_subclass_method(METRICS_POOL) def SubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: # TODO: QKD API Driver does not support monitoring by now LOGGER.info(f'Subscribe {self.address}: {subscriptions}') return [True for _ in subscriptions] @metered_subclass_method(METRICS_POOL) def UnsubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: # TODO: QKD API Driver does not support monitoring by now return [False for _ in subscriptions] def GetState( self, blocking=False, terminate : Optional[threading.Event] = None ) -> Iterator[Tuple[float, str, Any]]: # TODO: QKD API Driver does not support monitoring by now LOGGER.info(f'GetState {self.address} called') return [] src/device/service/drivers/qkd/QKDDriver2.py 0 → 100644 +216 −0 Viewed Changes for src/device/service/drivers/qkd/QKDDriver2.py: 216 added lines, 0 removed lines. Original line number Diff line number Diff line # Copyright 2022-2024 ETSI OSG/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 os import json import logging import requests import threading from requests.auth import HTTPBasicAuth from typing import Any, List, Optional, Tuple, Union from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method from common.type_checkers.Checkers import chk_string, chk_type from device.service.driver_api._Driver import _Driver from .Tools2 import config_getter, create_connectivity_link from device.service.driver_api._Driver import _Driver from . import ALL_RESOURCE_KEYS LOGGER = logging.getLogger(__name__) DRIVER_NAME = 'qkd' METRICS_POOL = MetricsPool('Device', 'Driver', labels={'driver': DRIVER_NAME}) class QKDDriver(_Driver): def __init__(self, address: str, port: int, **settings) -> None: LOGGER.info(f"Initializing QKDDriver with address={address}, port={port}, settings={settings}") super().__init__(DRIVER_NAME, address, port, **settings) self.__lock = threading.Lock() self.__started = threading.Event() self.__terminate = threading.Event() self.__auth = None self.__headers = {} self.__qkd_root = os.getenv('QKD_API_URL', f"http://{self.address}:{self.port}") # Simplified URL management self.__timeout = int(self.settings.get('timeout', 120)) self.__node_ids = set(self.settings.get('node_ids', [])) self.__initial_data = None # Optionally pass headers for authentication (e.g., JWT) self.__headers = settings.get('headers', {}) self.__auth = settings.get('auth', None) LOGGER.info(f"QKDDriver initialized with QKD root URL: {self.__qkd_root}") def Connect(self) -> bool: url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' with self.__lock: LOGGER.info(f"Starting connection to {url}") if self.__started.is_set(): LOGGER.info("Already connected, skipping re-connection.") return True try: LOGGER.info(f'Attempting to connect to {url} with headers {self.__headers} and timeout {self.__timeout}') response = requests.get(url, timeout=self.__timeout, verify=False, headers=self.__headers, auth=self.__auth) LOGGER.info(f'Received response: {response.status_code}, content: {response.text}') response.raise_for_status() self.__initial_data = response.json() self.__started.set() LOGGER.info('Connection successful') return True except requests.exceptions.RequestException as e: LOGGER.error(f'Connection failed: {e}') return False def Disconnect(self) -> bool: LOGGER.info("Disconnecting QKDDriver") with self.__lock: self.__terminate.set() LOGGER.info("QKDDriver disconnected successfully") return True @metered_subclass_method(METRICS_POOL) def GetInitialConfig(self) -> List[Tuple[str, Any]]: LOGGER.info("Getting initial configuration") with self.__lock: if isinstance(self.__initial_data, dict): initial_config = [('qkd_node', self.__initial_data.get('qkd_node', {}))] LOGGER.info(f"Initial configuration: {initial_config}") return initial_config LOGGER.warning("Initial data is not a dictionary") return [] @metered_subclass_method(METRICS_POOL) def GetConfig(self, resource_keys: List[str] = []) -> List[Tuple[str, Union[Any, None, Exception]]]: chk_type('resources', resource_keys, list) LOGGER.info(f"Getting configuration for resource_keys: {resource_keys}") results = [] with self.__lock: if not resource_keys: resource_keys = ALL_RESOURCE_KEYS for i, resource_key in enumerate(resource_keys): chk_string(f'resource_key[{i}]', resource_key, allow_empty=False) LOGGER.info(f"Retrieving resource key: {resource_key}") resource_results = config_getter( self.__qkd_root, resource_key, timeout=self.__timeout, headers=self.__headers, auth=self.__auth) results.extend(resource_results) LOGGER.info(f"Resource results for {resource_key}: {resource_results}") LOGGER.info(f"Final configuration results: {results}") return results @metered_subclass_method(METRICS_POOL) def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource_key, resource_value in resources: LOGGER.info('Processing resource_key = {:s}'.format(str(resource_key))) # Only process '/link' keys if resource_key.startswith('/link'): try: # Ensure resource_value is deserialized if isinstance(resource_value, str): resource_value = json.loads(resource_value) # Extract values from resource_value dictionary link_uuid = resource_value['uuid'] node_id_src = resource_value['src_qkdn_id'] interface_id_src = resource_value['src_interface_id'] node_id_dst = resource_value['dst_qkdn_id'] interface_id_dst = resource_value['dst_interface_id'] virt_prev_hop = resource_value.get('virt_prev_hop') virt_next_hops = resource_value.get('virt_next_hops') virt_bandwidth = resource_value.get('virt_bandwidth') # Call create_connectivity_link with the extracted values LOGGER.info(f"Creating connectivity link with UUID: {link_uuid}") data = create_connectivity_link( self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, virt_prev_hop, virt_next_hops, virt_bandwidth, timeout=self.__timeout, auth=self.__auth ) # Append success result results.append(True) LOGGER.info(f"Connectivity link {link_uuid} created successfully") except Exception as e: # Catch and log any unhandled exceptions LOGGER.exception(f'Unhandled error processing resource_key({resource_key})') results.append(e) else: # Skip unsupported resource keys and append success results.append(True) # Logging test results LOGGER.info('Test keys: ' + str([x for x,y in resources])) LOGGER.info('Test values: ' + str(results)) return results @metered_subclass_method(METRICS_POOL) def DeleteConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Deleting configuration for resources: {resources}") results = [] if not resources: LOGGER.warning("No resources provided for DeleteConfig") return results with self.__lock: for resource in resources: LOGGER.info(f'Resource to delete: {resource}') uuid = resource[1].get('uuid') if uuid: LOGGER.info(f'Resource with UUID {uuid} deleted successfully') results.append(True) else: LOGGER.warning(f"UUID not found in resource: {resource}") results.append(False) LOGGER.info(f"DeleteConfig results: {results}") return results @metered_subclass_method(METRICS_POOL) def SubscribeState(self, subscriptions: List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Subscribing to state updates: {subscriptions}") results = [True for _ in subscriptions] LOGGER.info(f"Subscription results: {results}") return results @metered_subclass_method(METRICS_POOL) def UnsubscribeState(self, subscriptions: List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Unsubscribing from state updates: {subscriptions}") results = [True for _ in subscriptions] LOGGER.info(f"Unsubscription results: {results}") return results @metered_subclass_method(METRICS_POOL) def GetState(self, blocking=False, terminate: Optional[threading.Event] = None) -> Union[dict, list]: LOGGER.info(f"GetState called with blocking={blocking}, terminate={terminate}") url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' try: LOGGER.info(f"Making GET request to {url} to retrieve state") response = requests.get(url, timeout=self.__timeout, verify=False, headers=self.__headers, auth=self.__auth) LOGGER.info(f"Received state response: {response.status_code}, content: {response.text}") response.raise_for_status() state_data = response.json() LOGGER.info(f"State data retrieved: {state_data}") return state_data except requests.exceptions.Timeout: LOGGER.error(f'Timeout getting state from {self.__qkd_root}') return [] except Exception as e: LOGGER.error(f'Exception getting state from {self.__qkd_root}: {e}') return [] Loading
proto/context.proto +2 −0 Viewed Changes for proto/context.proto: 2 added lines, 0 removed lines. Original line number Diff line number Diff line Loading @@ -214,6 +214,7 @@ enum DeviceDriverEnum { DEVICEDRIVER_OPTICAL_TFS = 9; DEVICEDRIVER_IETF_ACTN = 10; DEVICEDRIVER_OC = 11; DEVICEDRIVER_QKD = 12; } enum DeviceOperationalStatusEnum { Loading Loading @@ -300,6 +301,7 @@ enum ServiceTypeEnum { SERVICETYPE_TE = 4; SERVICETYPE_E2E = 5; SERVICETYPE_OPTICAL_CONNECTIVITY = 6; SERVICETYPE_QKD = 7; } enum ServiceStatusEnum { Loading
src/common/DeviceTypes.py +1 −0 Viewed Changes for src/common/DeviceTypes.py: 1 added line, 0 removed lines. Original line number Diff line number Diff line Loading @@ -47,6 +47,7 @@ class DeviceTypeEnum(Enum): PACKET_ROUTER = 'packet-router' PACKET_SWITCH = 'packet-switch' XR_CONSTELLATION = 'xr-constellation' QKD_NODE = 'qkd-node' # ETSI TeraFlowSDN controller TERAFLOWSDN_CONTROLLER = 'teraflowsdn'
src/context/service/database/models/enums/DeviceDriver.py +1 −0 Viewed Changes for src/context/service/database/models/enums/DeviceDriver.py: 1 added line, 0 removed lines. Original line number Diff line number Diff line Loading @@ -34,6 +34,7 @@ class ORM_DeviceDriverEnum(enum.Enum): OPTICAL_TFS = DeviceDriverEnum.DEVICEDRIVER_OPTICAL_TFS IETF_ACTN = DeviceDriverEnum.DEVICEDRIVER_IETF_ACTN OC = DeviceDriverEnum.DEVICEDRIVER_OC QKD = DeviceDriverEnum.DEVICEDRIVER_QKD grpc_to_enum__device_driver = functools.partial( grpc_to_enum, DeviceDriverEnum, ORM_DeviceDriverEnum)
src/device/service/drivers/qkd/QKDDriver.py 0 → 100644 +168 −0 Viewed Changes for src/device/service/drivers/qkd/QKDDriver.py: 168 added lines, 0 removed lines. Original line number Diff line number Diff line # Copyright 2022-2024 ETSI OSG/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, logging, requests, threading from requests.auth import HTTPBasicAuth from typing import Any, Iterator, List, Optional, Tuple, Union from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method from common.type_checkers.Checkers import chk_string, chk_type from device.service.driver_api._Driver import _Driver from . import ALL_RESOURCE_KEYS from .Tools import find_key, config_getter, create_connectivity_link LOGGER = logging.getLogger(__name__) DRIVER_NAME = 'qkd' METRICS_POOL = MetricsPool('Device', 'Driver', labels={'driver': DRIVER_NAME}) class QKDDriver(_Driver): def __init__(self, address: str, port: int, **settings) -> None: super().__init__(DRIVER_NAME, address, port, **settings) self.__lock = threading.Lock() self.__started = threading.Event() self.__terminate = threading.Event() username = self.settings.get('username') password = self.settings.get('password') self.__auth = HTTPBasicAuth(username, password) if username is not None and password is not None else None scheme = self.settings.get('scheme', 'http') self.__qkd_root = '{:s}://{:s}:{:d}'.format(scheme, self.address, int(self.port)) self.__timeout = int(self.settings.get('timeout', 120)) self.__node_ids = set(self.settings.get('node_ids', [])) token = self.settings.get('token') self.__headers = {'Authorization': 'Bearer ' + token} self.__initial_data = None def Connect(self) -> bool: url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' with self.__lock: if self.__started.is_set(): return True r = None try: LOGGER.info(f'requests.get("{url}", timeout={self.__timeout}, verify=False, auth={self.__auth}, headers={self.__headers})') r = requests.get(url, timeout=self.__timeout, verify=False, auth=self.__auth, headers=self.__headers) LOGGER.info(f'R: {r}') LOGGER.info(f'Text: {r.text}') LOGGER.info(f'Json: {r.json()}') except requests.exceptions.Timeout: LOGGER.exception('Timeout connecting {:s}'.format(str(self.__qkd_root))) return False except Exception: # pylint: disable=broad-except LOGGER.exception('Exception connecting {:s}'.format(str(self.__qkd_root))) return False else: self.__started.set() self.__initial_data = r.json() return True def Disconnect(self) -> bool: with self.__lock: self.__terminate.set() return True @metered_subclass_method(METRICS_POOL) def GetInitialConfig(self) -> List[Tuple[str, Any]]: with self.__lock: return self.__initial_data @metered_subclass_method(METRICS_POOL) def GetConfig(self, resource_keys : List[str] = []) -> List[Tuple[str, Union[Any, None, Exception]]]: chk_type('resources', resource_keys, list) results = [] with self.__lock: if len(resource_keys) == 0: resource_keys = ALL_RESOURCE_KEYS for i, resource_key in enumerate(resource_keys): str_resource_name = 'resource_key[#{:d}]'.format(i) chk_string(str_resource_name, resource_key, allow_empty=False) results.extend(config_getter( self.__qkd_root, resource_key, timeout=self.__timeout, auth=self.__auth, node_ids=self.__node_ids, headers=self.__headers)) return results @metered_subclass_method(METRICS_POOL) def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource_key, resource_value in resources: LOGGER.info('resource = {:s}'.format(str(resource_key))) if resource_key.startswith('/link'): try: resource_value = json.loads(resource_value) link_uuid = resource_value['uuid'] node_id_src = resource_value['src_qkdn_id'] interface_id_src = resource_value['src_interface_id'] node_id_dst = resource_value['dst_qkdn_id'] interface_id_dst = resource_value['dst_interface_id'] virt_prev_hop = resource_value.get('virt_prev_hop') virt_next_hops = resource_value.get('virt_next_hops') virt_bandwidth = resource_value.get('virt_bandwidth') data = create_connectivity_link( self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, virt_prev_hop, virt_next_hops, virt_bandwidth, timeout=self.__timeout, auth=self.__auth, headers=self.__headers ) #data = create_connectivity_link( # self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, # timeout=self.__timeout, auth=self.__auth #) results.append(True) except Exception as e: # pylint: disable=broad-except LOGGER.exception('Unhandled error processing resource_key({:s})'.format(str(resource_key))) results.append(e) else: results.append(True) LOGGER.info('Test keys: ' + str([x for x,y in resources])) LOGGER.info('Test values: ' + str(results)) return results ''' @metered_subclass_method(METRICS_POOL) def DeleteConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource in resources: LOGGER.info('resource = {:s}'.format(str(resource))) uuid = find_key(resource, 'uuid') results.extend(delete_connectivity_service( self.__qkd_root, uuid, timeout=self.__timeout, auth=self.__auth)) return results ''' @metered_subclass_method(METRICS_POOL) def SubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: # TODO: QKD API Driver does not support monitoring by now LOGGER.info(f'Subscribe {self.address}: {subscriptions}') return [True for _ in subscriptions] @metered_subclass_method(METRICS_POOL) def UnsubscribeState(self, subscriptions : List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: # TODO: QKD API Driver does not support monitoring by now return [False for _ in subscriptions] def GetState( self, blocking=False, terminate : Optional[threading.Event] = None ) -> Iterator[Tuple[float, str, Any]]: # TODO: QKD API Driver does not support monitoring by now LOGGER.info(f'GetState {self.address} called') return []
src/device/service/drivers/qkd/QKDDriver2.py 0 → 100644 +216 −0 Viewed Changes for src/device/service/drivers/qkd/QKDDriver2.py: 216 added lines, 0 removed lines. Original line number Diff line number Diff line # Copyright 2022-2024 ETSI OSG/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 os import json import logging import requests import threading from requests.auth import HTTPBasicAuth from typing import Any, List, Optional, Tuple, Union from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method from common.type_checkers.Checkers import chk_string, chk_type from device.service.driver_api._Driver import _Driver from .Tools2 import config_getter, create_connectivity_link from device.service.driver_api._Driver import _Driver from . import ALL_RESOURCE_KEYS LOGGER = logging.getLogger(__name__) DRIVER_NAME = 'qkd' METRICS_POOL = MetricsPool('Device', 'Driver', labels={'driver': DRIVER_NAME}) class QKDDriver(_Driver): def __init__(self, address: str, port: int, **settings) -> None: LOGGER.info(f"Initializing QKDDriver with address={address}, port={port}, settings={settings}") super().__init__(DRIVER_NAME, address, port, **settings) self.__lock = threading.Lock() self.__started = threading.Event() self.__terminate = threading.Event() self.__auth = None self.__headers = {} self.__qkd_root = os.getenv('QKD_API_URL', f"http://{self.address}:{self.port}") # Simplified URL management self.__timeout = int(self.settings.get('timeout', 120)) self.__node_ids = set(self.settings.get('node_ids', [])) self.__initial_data = None # Optionally pass headers for authentication (e.g., JWT) self.__headers = settings.get('headers', {}) self.__auth = settings.get('auth', None) LOGGER.info(f"QKDDriver initialized with QKD root URL: {self.__qkd_root}") def Connect(self) -> bool: url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' with self.__lock: LOGGER.info(f"Starting connection to {url}") if self.__started.is_set(): LOGGER.info("Already connected, skipping re-connection.") return True try: LOGGER.info(f'Attempting to connect to {url} with headers {self.__headers} and timeout {self.__timeout}') response = requests.get(url, timeout=self.__timeout, verify=False, headers=self.__headers, auth=self.__auth) LOGGER.info(f'Received response: {response.status_code}, content: {response.text}') response.raise_for_status() self.__initial_data = response.json() self.__started.set() LOGGER.info('Connection successful') return True except requests.exceptions.RequestException as e: LOGGER.error(f'Connection failed: {e}') return False def Disconnect(self) -> bool: LOGGER.info("Disconnecting QKDDriver") with self.__lock: self.__terminate.set() LOGGER.info("QKDDriver disconnected successfully") return True @metered_subclass_method(METRICS_POOL) def GetInitialConfig(self) -> List[Tuple[str, Any]]: LOGGER.info("Getting initial configuration") with self.__lock: if isinstance(self.__initial_data, dict): initial_config = [('qkd_node', self.__initial_data.get('qkd_node', {}))] LOGGER.info(f"Initial configuration: {initial_config}") return initial_config LOGGER.warning("Initial data is not a dictionary") return [] @metered_subclass_method(METRICS_POOL) def GetConfig(self, resource_keys: List[str] = []) -> List[Tuple[str, Union[Any, None, Exception]]]: chk_type('resources', resource_keys, list) LOGGER.info(f"Getting configuration for resource_keys: {resource_keys}") results = [] with self.__lock: if not resource_keys: resource_keys = ALL_RESOURCE_KEYS for i, resource_key in enumerate(resource_keys): chk_string(f'resource_key[{i}]', resource_key, allow_empty=False) LOGGER.info(f"Retrieving resource key: {resource_key}") resource_results = config_getter( self.__qkd_root, resource_key, timeout=self.__timeout, headers=self.__headers, auth=self.__auth) results.extend(resource_results) LOGGER.info(f"Resource results for {resource_key}: {resource_results}") LOGGER.info(f"Final configuration results: {results}") return results @metered_subclass_method(METRICS_POOL) def SetConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: results = [] if len(resources) == 0: return results with self.__lock: for resource_key, resource_value in resources: LOGGER.info('Processing resource_key = {:s}'.format(str(resource_key))) # Only process '/link' keys if resource_key.startswith('/link'): try: # Ensure resource_value is deserialized if isinstance(resource_value, str): resource_value = json.loads(resource_value) # Extract values from resource_value dictionary link_uuid = resource_value['uuid'] node_id_src = resource_value['src_qkdn_id'] interface_id_src = resource_value['src_interface_id'] node_id_dst = resource_value['dst_qkdn_id'] interface_id_dst = resource_value['dst_interface_id'] virt_prev_hop = resource_value.get('virt_prev_hop') virt_next_hops = resource_value.get('virt_next_hops') virt_bandwidth = resource_value.get('virt_bandwidth') # Call create_connectivity_link with the extracted values LOGGER.info(f"Creating connectivity link with UUID: {link_uuid}") data = create_connectivity_link( self.__qkd_root, link_uuid, node_id_src, interface_id_src, node_id_dst, interface_id_dst, virt_prev_hop, virt_next_hops, virt_bandwidth, timeout=self.__timeout, auth=self.__auth ) # Append success result results.append(True) LOGGER.info(f"Connectivity link {link_uuid} created successfully") except Exception as e: # Catch and log any unhandled exceptions LOGGER.exception(f'Unhandled error processing resource_key({resource_key})') results.append(e) else: # Skip unsupported resource keys and append success results.append(True) # Logging test results LOGGER.info('Test keys: ' + str([x for x,y in resources])) LOGGER.info('Test values: ' + str(results)) return results @metered_subclass_method(METRICS_POOL) def DeleteConfig(self, resources: List[Tuple[str, Any]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Deleting configuration for resources: {resources}") results = [] if not resources: LOGGER.warning("No resources provided for DeleteConfig") return results with self.__lock: for resource in resources: LOGGER.info(f'Resource to delete: {resource}') uuid = resource[1].get('uuid') if uuid: LOGGER.info(f'Resource with UUID {uuid} deleted successfully') results.append(True) else: LOGGER.warning(f"UUID not found in resource: {resource}") results.append(False) LOGGER.info(f"DeleteConfig results: {results}") return results @metered_subclass_method(METRICS_POOL) def SubscribeState(self, subscriptions: List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Subscribing to state updates: {subscriptions}") results = [True for _ in subscriptions] LOGGER.info(f"Subscription results: {results}") return results @metered_subclass_method(METRICS_POOL) def UnsubscribeState(self, subscriptions: List[Tuple[str, float, float]]) -> List[Union[bool, Exception]]: LOGGER.info(f"Unsubscribing from state updates: {subscriptions}") results = [True for _ in subscriptions] LOGGER.info(f"Unsubscription results: {results}") return results @metered_subclass_method(METRICS_POOL) def GetState(self, blocking=False, terminate: Optional[threading.Event] = None) -> Union[dict, list]: LOGGER.info(f"GetState called with blocking={blocking}, terminate={terminate}") url = self.__qkd_root + '/restconf/data/etsi-qkd-sdn-node:qkd_node' try: LOGGER.info(f"Making GET request to {url} to retrieve state") response = requests.get(url, timeout=self.__timeout, verify=False, headers=self.__headers, auth=self.__auth) LOGGER.info(f"Received state response: {response.status_code}, content: {response.text}") response.raise_for_status() state_data = response.json() LOGGER.info(f"State data retrieved: {state_data}") return state_data except requests.exceptions.Timeout: LOGGER.error(f'Timeout getting state from {self.__qkd_root}') return [] except Exception as e: LOGGER.error(f'Exception getting state from {self.__qkd_root}: {e}') return []