| # -*- coding: utf-8 -*- |
| |
| ####################################################################################### |
| # This file is part of OSM RO module |
| # |
| # Copyright ETSI Contributors and Others. |
| # |
| # 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. |
| ####################################################################################### |
| # This work has been performed in the context of the TeraFlow Project - |
| # funded by the European Commission under Grant number 101015857 through the |
| # Horizon 2020 program. |
| # Contributors: |
| # - Lluis Gifre <lluis.gifre@cttc.es> |
| # - Ricard Vilalta <ricard.vilalta@cttc.es> |
| ####################################################################################### |
| |
| """The SDN/WIM connector is responsible for establishing wide area network |
| connectivity. |
| |
| This SDN/WIM connector implements the standard ONF Transport API (TAPI). |
| |
| It receives the endpoints and the necessary details to request the Layer 2 |
| service through the use of the ONF Transport API. |
| """ |
| |
| import logging |
| import uuid |
| |
| from osm_ro_plugin.sdnconn import SdnConnectorBase |
| |
| from .conn_info import ( |
| conn_info_compose_bidirectional, |
| conn_info_compose_unidirectional, |
| ) |
| from .exceptions import ( |
| WimTapiConnectionPointsBadFormat, |
| WimTapiMissingConnPointField, |
| WimTapiUnsupportedServiceType, |
| ) |
| from .services_composer import ServicesComposer |
| from .tapi_client import TransportApiClient |
| |
| |
| class WimconnectorTAPI(SdnConnectorBase): |
| """ONF TAPI WIM connector""" |
| |
| def __init__(self, wim, wim_account, config=None, logger=None): |
| """ONF TAPI WIM connector |
| |
| Arguments: |
| wim (dict): WIM record, as stored in the database |
| wim_account (dict): WIM account record, as stored in the database |
| config (optional dict): optional configuration from the configuration database |
| logger (optional Logger): logger to use with this WIM connector |
| The arguments of the constructor are converted to object attributes. |
| An extra property, ``service_endpoint_mapping`` is created from ``config``. |
| """ |
| logger = logger or logging.getLogger("ro.sdn.tapi") |
| |
| super().__init__(wim, wim_account, config, logger) |
| |
| self.logger.debug("self.config={:s}".format(str(self.config))) |
| |
| if len(self.service_endpoint_mapping) == 0 and self.config.get( |
| "wim_port_mapping" |
| ): |
| self.service_endpoint_mapping = self.config.get("wim_port_mapping", []) |
| |
| self.mappings = { |
| m["service_endpoint_id"]: m for m in self.service_endpoint_mapping |
| } |
| |
| self.logger.debug("self.mappings={:s}".format(str(self.mappings))) |
| |
| self.tapi_client = TransportApiClient(self.logger, wim, wim_account, config) |
| |
| self.logger.info("TAPI WIM Connector Initialized.") |
| |
| def check_credentials(self): |
| """Check if the connector itself can access the SDN/WIM with the provided url (wim.wim_url), |
| user (wim_account.user), and password (wim_account.password) |
| |
| Raises: |
| SdnConnectorError: Issues regarding authorization, access to |
| external URLs, etc are detected. |
| """ |
| _ = self.tapi_client.get_root_context() |
| self.logger.info("Credentials checked") |
| |
| def get_connectivity_service_status(self, service_uuid, conn_info=None): |
| """Monitor the status of the connectivity service established |
| |
| Arguments: |
| service_uuid (str): UUID of the connectivity service |
| conn_info (dict or None): Information returned by the connector |
| during the service creation/edition and subsequently stored in |
| the database. |
| |
| Returns: |
| dict: JSON/YAML-serializable dict that contains a mandatory key |
| ``sdn_status`` associated with one of the following values:: |
| |
| {'sdn_status': 'ACTIVE'} |
| # The service is up and running. |
| |
| {'sdn_status': 'INACTIVE'} |
| # The service was created, but the connector |
| # cannot determine yet if connectivity exists |
| # (ideally, the caller needs to wait and check again). |
| |
| {'sdn_status': 'DOWN'} |
| # Connection was previously established, |
| # but an error/failure was detected. |
| |
| {'sdn_status': 'ERROR'} |
| # An error occurred when trying to create the service/ |
| # establish the connectivity. |
| |
| {'sdn_status': 'BUILD'} |
| # Still trying to create the service, the caller |
| # needs to wait and check again. |
| |
| Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**) |
| keys can be used to provide additional status explanation or |
| new information available for the connectivity service. |
| """ |
| sdn_status = set() |
| bidirectional = conn_info["bidirectional"] |
| |
| tapi_client = self.tapi_client |
| if bidirectional: |
| service_uuid = conn_info["uuid"] |
| service_status = tapi_client.get_service_status("<>", service_uuid) |
| sdn_status.add(service_status["sdn_status"]) |
| else: |
| service_az_uuid = conn_info["az"]["uuid"] |
| service_za_uuid = conn_info["za"]["uuid"] |
| service_az_status = tapi_client.get_service_status(">>", service_az_uuid) |
| service_za_status = tapi_client.get_service_status("<<", service_za_uuid) |
| sdn_status.add(service_az_status["sdn_status"]) |
| sdn_status.add(service_za_status["sdn_status"]) |
| |
| if len(sdn_status) == 1 and "ACTIVE" in sdn_status: |
| service_status = {"sdn_status": "ACTIVE"} |
| else: |
| service_status = {"sdn_status": "ERROR"} |
| |
| return service_status |
| |
| def create_connectivity_service(self, service_type, connection_points, **kwargs): |
| """ |
| Establish SDN/WAN connectivity between the endpoints |
| :param service_type: (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``. |
| :param connection_points: (list): each point corresponds to |
| an entry point to be connected. For WIM: from the DC to the transport network. |
| For SDN: Compute/PCI to the transport network. One |
| connection point serves to identify the specific access and |
| some other service parameters, such as encapsulation type. |
| Each item of the list is a dict with: |
| "service_endpoint_id": (str)(uuid) Same meaning that for 'service_endpoint_mapping' (see __init__) |
| In case the config attribute mapping_not_needed is True, this value is not relevant. In this case |
| it will contain the string "device_id:device_interface_id" |
| "service_endpoint_encapsulation_type": None, "dot1q", ... |
| "service_endpoint_encapsulation_info": (dict) with: |
| "vlan": ..., (int, present if encapsulation is dot1q) |
| "vni": ... (int, present if encapsulation is vxlan), |
| "peers": [(ipv4_1), (ipv4_2)] (present if encapsulation is vxlan) |
| "mac": ... |
| "device_id": ..., same meaning that for 'service_endpoint_mapping' (see __init__) |
| "device_interface_id": same meaning that for 'service_endpoint_mapping' (see __init__) |
| "switch_dpid": ..., present if mapping has been found for this device_id,device_interface_id |
| "swith_port": ... present if mapping has been found for this device_id,device_interface_id |
| "service_mapping_info": present if mapping has been found for this device_id,device_interface_id |
| :param kwargs: For future versions: |
| bandwidth (int): value in kilobytes |
| latency (int): value in milliseconds |
| Other QoS might be passed as keyword arguments. |
| :return: tuple: ``(service_id, conn_info)`` containing: |
| - *service_uuid* (str): UUID of the established connectivity service |
| - *conn_info* (dict or None): Information to be stored at the database (or ``None``). |
| This information will be provided to the :meth:`~.edit_connectivity_service` and :obj:`~.delete`. |
| **MUST** be JSON/YAML-serializable (plain data structures). |
| :raises: SdnConnectorException: In case of error. Nothing should be created in this case. |
| Provide the parameter http_code |
| """ |
| supported_service_types = {"ELINE"} |
| if service_type not in supported_service_types: |
| raise WimTapiUnsupportedServiceType(service_type, supported_service_types) |
| |
| self.logger.debug("connection_points={:s}".format(str(connection_points))) |
| |
| if not isinstance(connection_points, (list, tuple)): |
| raise WimTapiConnectionPointsBadFormat(connection_points) |
| |
| if len(connection_points) != 2: |
| raise WimTapiConnectionPointsBadFormat(connection_points) |
| |
| sips = self.tapi_client.get_service_interface_points() |
| services_composer = ServicesComposer(sips) |
| |
| for connection_point in connection_points: |
| service_endpoint_id = connection_point.get("service_endpoint_id") |
| if service_endpoint_id is None: |
| raise WimTapiMissingConnPointField( |
| connection_point, "service_endpoint_id" |
| ) |
| |
| mapping = self.mappings.get(service_endpoint_id, {}) |
| services_composer.add_service_endpoint(service_endpoint_id, mapping) |
| |
| services_composer.dump(self.logger) |
| |
| service_uuid, conn_info = self._create_services_and_conn_info(services_composer) |
| return service_uuid, conn_info |
| |
| def _create_services_and_conn_info(self, services_composer: ServicesComposer): |
| services = services_composer.services |
| requested_capacity = services_composer.requested_capacity |
| vlan_constraint = services_composer.vlan_constraint |
| |
| service_uuid = str(uuid.uuid4()) |
| |
| if services_composer.is_bidirectional(): |
| service_endpoints = services[0] |
| self.tapi_client.create_service( |
| "<>", |
| service_uuid, |
| service_endpoints, |
| bidirectional=True, |
| requested_capacity=requested_capacity, |
| vlan_constraint=vlan_constraint, |
| ) |
| conn_info = conn_info_compose_bidirectional( |
| service_uuid, |
| service_endpoints, |
| requested_capacity=requested_capacity, |
| vlan_constraint=vlan_constraint, |
| ) |
| |
| else: |
| service_uuid = service_uuid[0 : len(service_uuid) - 4] + "00**" |
| service_az_uuid = service_uuid.replace("**", "af") |
| service_az_endpoints = services[0] |
| service_za_uuid = service_uuid.replace("**", "fa") |
| service_za_endpoints = services[1] |
| |
| self.tapi_client.create_service( |
| ">>", |
| service_az_uuid, |
| service_az_endpoints, |
| bidirectional=False, |
| requested_capacity=requested_capacity, |
| vlan_constraint=vlan_constraint, |
| ) |
| self.tapi_client.create_service( |
| "<<", |
| service_za_uuid, |
| service_za_endpoints, |
| bidirectional=False, |
| requested_capacity=requested_capacity, |
| vlan_constraint=vlan_constraint, |
| ) |
| conn_info = conn_info_compose_unidirectional( |
| service_az_uuid, |
| service_az_endpoints, |
| service_za_uuid, |
| service_za_endpoints, |
| requested_capacity=requested_capacity, |
| vlan_constraint=vlan_constraint, |
| ) |
| |
| return service_uuid, conn_info |
| |
| def delete_connectivity_service(self, service_uuid, conn_info=None): |
| """ |
| Disconnect multi-site endpoints previously connected |
| |
| :param service_uuid: The one returned by create_connectivity_service |
| :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service' |
| if they do not return None |
| :return: None |
| :raises: SdnConnectorException: In case of error. The parameter http_code must be filled |
| """ |
| bidirectional = conn_info["bidirectional"] |
| if bidirectional: |
| service_uuid = conn_info["uuid"] |
| self.tapi_client.delete_service("<>", service_uuid) |
| else: |
| service_az_uuid = conn_info["az"]["uuid"] |
| service_za_uuid = conn_info["za"]["uuid"] |
| self.tapi_client.delete_service(">>", service_az_uuid) |
| self.tapi_client.delete_service("<<", service_za_uuid) |
| |
| def edit_connectivity_service( |
| self, service_uuid, conn_info=None, connection_points=None, **kwargs |
| ): |
| """Change an existing connectivity service. |
| |
| This method's arguments and return value follow the same convention as |
| :meth:`~.create_connectivity_service`. |
| |
| :param service_uuid: UUID of the connectivity service. |
| :param conn_info: (dict or None): Information previously returned by last call to create_connectivity_service |
| or edit_connectivity_service |
| :param connection_points: (list): If provided, the old list of connection points will be replaced. |
| :param kwargs: Same meaning that create_connectivity_service |
| :return: dict or None: Information to be updated and stored at the database. |
| When ``None`` is returned, no information should be changed. |
| When an empty dict is returned, the database record will be deleted. |
| **MUST** be JSON/YAML-serializable (plain data structures). |
| Raises: |
| SdnConnectorException: In case of error. |
| """ |
| raise NotImplementedError |
| |
| def clear_all_connectivity_services(self): |
| """Delete all WAN Links in a WIM. |
| |
| This method is intended for debugging only, and should delete all the |
| connections controlled by the WIM/SDN, not only the connections that |
| a specific RO is aware of. |
| |
| Raises: |
| SdnConnectorException: In case of error. |
| """ |
| raise NotImplementedError |
| |
| def get_all_active_connectivity_services(self): |
| """Provide information about all active connections provisioned by a |
| WIM. |
| |
| Raises: |
| SdnConnectorException: In case of error. |
| """ |
| raise NotImplementedError |