RO-SDN-juniper_contrail/osm_rosdn_juniper_contrail/sdn_assist_juniper_contrail.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Copyright 2020 ETSI OSM
   4 #
   5 # All Rights Reserved.
   6 #
   7 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   8 #    not use this file except in compliance with the License. You may obtain
   9 #    a copy of the License at
  10 #
  11 #         http://www.apache.org/licenses/LICENSE-2.0
  12 #
  13 #    Unless required by applicable law or agreed to in writing, software
  14 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  16 #    License for the specific language governing permissions and limitations
  17 #    under the License.
  18 #
  19
  20 import logging
  21 import json
  22 import yaml
  23 import random
  24
  25 from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
  26 from osm_rosdn_juniper_contrail.rest_lib import ContrailHttp
  27 from osm_rosdn_juniper_contrail.rest_lib import NotFound
  28 from osm_rosdn_juniper_contrail.rest_lib import DuplicateFound
  29 from osm_rosdn_juniper_contrail.rest_lib import HttpException
  30
  31 from osm_rosdn_juniper_contrail.sdn_api import UnderlayApi
  32
  33
  34 class JuniperContrail(SdnConnectorBase):
  35     """
  36     Juniper Contrail SDN plugin. The plugin interacts with Juniper Contrail Controller,
  37     whose API details can be found in these links:
  38
  39     - https://github.com/tonyliu0592/contrail/wiki/API-Configuration-REST
  40     - https://www.juniper.net/documentation/en_US/contrail19/information-products/pathway-pages/api-guide-1910/tutorial_with_rest.html
  41     - https://github.com/tonyliu0592/contrail-toolbox/blob/master/sriov/sriov
  42     """
  43     _WIM_LOGGER = "openmano.sdnconn.junipercontrail"
  44
  45     def __init__(self, wim, wim_account, config=None, logger=None):
  46         """
  47
  48         :param wim: (dict). Contains among others 'wim_url'
  49         :param wim_account: (dict). Contains among others 'uuid' (internal id), 'name',
  50             'sdn' (True if is intended for SDN-assist or False if intended for WIM), 'user', 'password'.
  51         :param config: (dict or None): Particular information of plugin. These keys if present have a common meaning:
  52             'mapping_not_needed': (bool) False by default or if missing, indicates that mapping is not needed.
  53             'service_endpoint_mapping': (list) provides the internal endpoint mapping. The meaning is:
  54                 KEY                     meaning for WIM                 meaning for SDN assist
  55                 --------                --------                    --------
  56                 device_id                       pop_switch_dpid                 compute_id
  57                 device_interface_id             pop_switch_port                 compute_pci_address
  58                 service_endpoint_id         wan_service_endpoint_id     SDN_service_endpoint_id
  59                 service_mapping_info    wan_service_mapping_info    SDN_service_mapping_info
  60                     contains extra information if needed. Text in Yaml format
  61                 switch_dpid                     wan_switch_dpid                 SDN_switch_dpid
  62                 switch_port                     wan_switch_port                 SDN_switch_port
  63                 datacenter_id           vim_account                 vim_account
  64                 id: (internal, do not use)
  65                 wim_id: (internal, do not use)
  66         :param logger (logging.Logger): optional logger object. If none is passed 'openmano.sdn.sdnconn' is used.
  67         """
  68         self.logger = logger or logging.getLogger(self._WIM_LOGGER)
  69         self.logger.debug('wim: {}, wim_account: {}, config: {}'.format(wim, wim_account, config))
  70         super().__init__(wim, wim_account, config, logger)
  71
  72         self.user = wim_account.get("user")
  73         self.password = wim_account.get("password")
  74
  75         url = wim.get("wim_url") # underlay url
  76         auth_url = None
  77         self.project = None
  78         self.domain = None
  79         self.asn = None
  80         self.fabric = None
  81         overlay_url = None
  82         self.vni_range = None
  83         if config:
  84             auth_url = config.get("auth_url")
  85             self.project = config.get("project")
  86             self.domain = config.get("domain")
  87             self.asn = config.get("asn")
  88             self.fabric = config.get("fabric")
  89             self.overlay_url = config.get("overlay_url")
  90             self.vni_range = config.get("vni_range")
  91
  92         if not url:
  93             raise SdnConnectorError("'url' must be provided")
  94         if not url.startswith("http"):
  95             url = "http://" + url
  96         if not url.endswith("/"):
  97             url = url + "/"
  98         self.url = url
  99
 100         if not self.vni_range:
 101             self.vni_range = ['1000001-2000000']
 102             self.logger.info("No vni_range was provided. Using ['1000001-2000000']")
 103         self.used_vni = set()
 104
 105         if auth_url:
 106             if not auth_url.startswith("http"):
 107                 auth_url = "http://" + auth_url
 108             if not auth_url.endswith("/"):
 109                 auth_url = auth_url + "/"
 110         self.auth_url = auth_url
 111
 112         if overlay_url:
 113             if not overlay_url.startswith("http"):
 114                 overlay_url = "http://" + overlay_url
 115             if not overlay_url.endswith("/"):
 116                 overlay_url = overlay_url + "/"
 117         self.overlay_url = overlay_url
 118
 119         if not self.project:
 120             raise SdnConnectorError("'project' must be provided")
 121         if not self.asn:
 122             # TODO: Get ASN from controller config; otherwise raise ERROR for the moment
 123             raise SdnConnectorError("'asn' was not provided and it was not possible to obtain it")
 124         if not self.fabric:
 125             # TODO: Get FABRIC from controller config; otherwise raise ERROR for the moment
 126             raise SdnConnectorError("'fabric' was not provided and was not possible to obtain it")
 127         if not self.domain:
 128             self.domain = 'default-domain'
 129             self.logger.info("No domain was provided. Using 'default-domain'")
 130
 131         underlay_api_config = {
 132             "auth_url": self.auth_url,
 133             "project": self.project,
 134             "domain": self.domain,
 135             "asn": self.asn,
 136             "fabric": self.fabric
 137         }
 138         self.underlay_api = UnderlayApi(url, underlay_api_config, user=self.user, password=self.password, logger=logger)
 139
 140         self._max_duplicate_retry = 2
 141         self.logger.info("Juniper Contrail Connector Initialized.")
 142
 143     def _generate_vni(self):
 144         """
 145          Method to get unused VxLAN Network Identifier (VNI)
 146             Args:
 147                 None
 148             Returns:
 149                 VNI
 150         """
 151         #find unused VLAN ID
 152         for vlanID_range in self.vni_range:
 153             try:
 154                 start_vni , end_vni = map(int, vlanID_range.replace(" ", "").split("-"))
 155                 for i in range(start_vni, end_vni + 1):
 156                     vni = random.randrange(start_vni, end_vni, 1)
 157                     if vni not in self.used_vni:
 158                         return vni
 159             except Exception as exp:
 160                 raise SdnConnectorError("Exception {} occurred while searching a free VNI.".format(exp))
 161         else:
 162             raise SdnConnectorError("Unable to create the virtual network."\
 163                 " All VNI in VNI range {} are in use.".format(self.vni_range))
 164
 165
 166     # Aux functions for testing
 167     def get_url(self):
 168         return self.url
 169
 170     def get_overlay_url(self):
 171         return self.overlay_url
 172
 173     def _create_port(self, switch_id, switch_port, network, vlan):
 174         """
 175         1 - Look for virtual port groups for provided switch_id, switch_port using name
 176         2 - It the virtual port group does not exist, create it
 177         3 - Create virtual machine interface for the indicated network and vlan
 178         """
 179         self.logger.debug("create_port: switch_id: {}, switch_port: {}, network: {}, vlan: {}".format(
 180             switch_id, switch_port, network, vlan))
 181
 182         # 1 - Check if the vpg exists
 183         vpg_name = self.underlay_api.get_vpg_name(switch_id, switch_port)
 184         vpg = self.underlay_api.get_vpg_by_name(vpg_name)
 185         if not vpg:
 186             # 2 - If it does not exist create it
 187             vpg_id, _ = self.underlay_api.create_vpg(switch_id, switch_port)
 188         else:
 189             # Assign vpg_id from vpg
 190             vpg_id = vpg.get("uuid")
 191
 192         # 3 - Check if the vmi alreaady exists
 193         vmi_id, _ = self.underlay_api.create_vmi(switch_id, switch_port, network, vlan)
 194         self.logger.debug("port created")
 195
 196         return vpg_id, vmi_id
 197
 198     def _delete_port(self, switch_id, switch_port, vlan):
 199         self.logger.debug("delete port, switch_id: {}, switch_port: {}, vlan: {}".format(switch_id, switch_port, vlan))
 200
 201         vpg_name = self.underlay_api.get_vpg_name(switch_id, switch_port)
 202         vmi_name = self.underlay_api.get_vmi_name(switch_id, switch_port, vlan)
 203
 204         # 1 - Obtain vpg by id (if not vpg_id must have been error creating ig, nothing to be done)
 205         vpg_fqdn = ["default-global-system-config", self.fabric, vpg_name]
 206         vpg = self.underlay_api.get_by_fq_name("virtual-port-group", vpg_fqdn)
 207         if not vpg:
 208             self.logger.warning("vpg: {} to be deleted not found".format(vpg_name))
 209         else:
 210             # 2 - Get vmi interfaces from vpg
 211             vmi_list = vpg.get("virtual_machine_interface_refs")
 212             if not vmi_list:
 213                 # must have been an error during port creation when vmi is created
 214                 # may happen if there has been an error during creation
 215                 self.logger.warning("vpg: {} has not vmi, will delete nothing".format(vpg))
 216             else:
 217                 num_vmis = len(vmi_list)
 218                 for vmi in vmi_list:
 219                     uuid = vmi.get("uuid")
 220                     fqdn = vmi.get("to")
 221                     # check by name
 222                     if fqdn[2] == vmi_name:
 223                         self.underlay_api.unref_vmi_vpg(vpg.get("uuid"), vmi.get("uuid"), fqdn)
 224                         self.underlay_api.delete_vmi(vmi.get("uuid"))
 225                         num_vmis = num_vmis - 1
 226
 227             # 3 - If there are no more vmi delete the vpg
 228             if not vmi_list or num_vmis == 0:
 229                 self.underlay_api.delete_vpg(vpg.get("uuid"))
 230
 231     def check_credentials(self):
 232         """Check if the connector itself can access the SDN/WIM with the provided url (wim.wim_url),
 233             user (wim_account.user), and password (wim_account.password)
 234
 235         Raises:
 236             SdnConnectorError: Issues regarding authorization, access to
 237                 external URLs, etc are detected.
 238         """
 239         self.logger.debug("")
 240         try:
 241             resp = self.underlay_api.check_auth()
 242             if not resp:
 243                 raise SdnConnectorError('Empty response')
 244         except Exception as e:
 245             self.logger.error('Error checking credentials')
 246             raise SdnConnectorError('Error checking credentials: {}'.format(str(e)))
 247
 248     def get_connectivity_service_status(self, service_uuid, conn_info=None):
 249         """Monitor the status of the connectivity service established
 250
 251         Arguments:
 252             service_uuid (str): UUID of the connectivity service
 253             conn_info (dict or None): Information returned by the connector
 254                 during the service creation/edition and subsequently stored in
 255                 the database.
 256
 257         Returns:
 258             dict: JSON/YAML-serializable dict that contains a mandatory key
 259                 ``sdn_status`` associated with one of the following values::
 260
 261                     {'sdn_status': 'ACTIVE'}
 262                         # The service is up and running.
 263
 264                     {'sdn_status': 'INACTIVE'}
 265                         # The service was created, but the connector
 266                         # cannot determine yet if connectivity exists
 267                         # (ideally, the caller needs to wait and check again).
 268
 269                     {'sdn_status': 'DOWN'}
 270                         # Connection was previously established,
 271                         # but an error/failure was detected.
 272
 273                     {'sdn_status': 'ERROR'}
 274                         # An error occurred when trying to create the service/
 275                         # establish the connectivity.
 276
 277                     {'sdn_status': 'BUILD'}
 278                         # Still trying to create the service, the caller
 279                         # needs to wait and check again.
 280
 281                 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
 282                 keys can be used to provide additional status explanation or
 283                 new information available for the connectivity service.
 284         """
 285         self.logger.debug("")
 286         try:
 287             resp = self.underlay_api.get_virtual_network(service_uuid)
 288             if not resp:
 289                 raise SdnConnectorError('Empty response')
 290             if resp:
 291                 vnet_info = resp
 292
 293                 # Check if conn_info reports error
 294                 if conn_info.get("sdn_status") == "ERROR":
 295                     return {'sdn_status': 'ERROR', 'sdn_info': conn_info}
 296                 else:
 297                     return {'sdn_status': 'ACTIVE', 'sdn_info': vnet_info}
 298             else:
 299                 return {'sdn_status': 'ERROR', 'sdn_info': 'not found'}
 300         except SdnConnectorError:
 301             raise
 302         except HttpException as e:
 303             self.logger.error("Error getting connectivity service: {}".format(e))
 304             raise SdnConnectorError("Exception deleting connectivity service: {}".format(str(e)))
 305         except Exception as e:
 306             self.logger.error('Exception getting connectivity service info: %s', e, exc_info=True)
 307             return {'sdn_status': 'ERROR', 'error_msg': str(e)}
 308
 309
 310     def create_connectivity_service(self, service_type, connection_points, **kwargs):
 311         """
 312         Establish SDN/WAN connectivity between the endpoints
 313         :param service_type: (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
 314         :param connection_points:  (list): each point corresponds to
 315             an entry point to be connected. For WIM: from the DC to the transport network.
 316             For SDN: Compute/PCI to the transport network. One
 317             connection point serves to identify the specific access and
 318             some other service parameters, such as encapsulation type.
 319             Each item of the list is a dict with:
 320                 "service_endpoint_id": (str)(uuid)  Same meaning that for 'service_endpoint_mapping' (see __init__)
 321                     In case the config attribute mapping_not_needed is True, this value is not relevant. In this case
 322                     it will contain the string "device_id:device_interface_id"
 323                 "service_endpoint_encapsulation_type": None, "dot1q", ...
 324                 "service_endpoint_encapsulation_info": (dict) with:
 325                     "vlan": ..., (int, present if encapsulation is dot1q)
 326                     "vni": ... (int, present if encapsulation is vxlan),
 327                     "peers": [(ipv4_1), (ipv4_2)] (present if encapsulation is vxlan)
 328                     "mac": ...
 329                     "device_id": ..., same meaning that for 'service_endpoint_mapping' (see __init__)
 330                     "device_interface_id": same meaning that for 'service_endpoint_mapping' (see __init__)
 331                     "switch_dpid": ..., present if mapping has been found for this device_id,device_interface_id
 332                     "switch_port": ... present if mapping has been found for this device_id,device_interface_id
 333                     "service_mapping_info": present if mapping has been found for this device_id,device_interface_id
 334         :param kwargs: For future versions:
 335             bandwidth (int): value in kilobytes
 336             latency (int): value in milliseconds
 337             Other QoS might be passed as keyword arguments.
 338         :return: tuple: ``(service_id, conn_info)`` containing:
 339             - *service_uuid* (str): UUID of the established connectivity service
 340             - *conn_info* (dict or None): Information to be stored at the database (or ``None``).
 341                 This information will be provided to the :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
 342                 **MUST** be JSON/YAML-serializable (plain data structures).
 343         :raises: SdnConnectorException: In case of error. Nothing should be created in this case.
 344             Provide the parameter http_code
 345         """
 346         # Step 1. Check in the overlay controller the virtual network created by the VIM
 347         #   Best option: get network id of the VIM as param (if the VIM already created the network),
 348         #    and do a request to the controller of the virtual networks whose VIM network id is the provided
 349         #   Next best option: obtain the network by doing a request to the controller
 350         #    of the virtual networks using the VLAN ID of any service endpoint.
 351         #   1.1 Read VLAN ID from a service endpoint
 352         #   1.2 Look for virtual networks with "Provider Network" including a VLAN ID.
 353         #   1.3 If more than one, ERROR
 354         # Step 2. Modify the existing virtual network in the overlay controller
 355         #   2.1 Add VNI (VxLAN Network Identifier - one free from the provided range)
 356         #   2.2 Add RouteTarget (RT) ('ASN:VNI', ASN = Autonomous System Number, provided as param or read from controller config)
 357         # Step 3. Create a virtual network in the underlay controller
 358         #   3.1 Create virtual network (name, VNI, RT)
 359         #      If the network already existed in the overlay controller, we should use the same name
 360         #         name = 'osm-plugin-' + overlay_name
 361         #      Else:
 362         #         name = 'osm-plugin-' + VNI
 363         self.logger.info("create_connectivity_service, service_type: {}, connection_points: {}".
 364                          format(service_type, connection_points))
 365         if service_type.lower() != 'elan':
 366             raise SdnConnectorError('Only ELAN network type is supported by Juniper Contrail.')
 367
 368         try:
 369             # Initialize data
 370             conn_info = None
 371
 372
 373             # 1 - Filter connection_points (transform cp to a dictionary with no duplicates)
 374             # This data will be returned even if no cp can be created if something is created
 375             vlans = set()
 376             work_cps = {}
 377             for cp in connection_points:
 378                 switch_id = cp.get("service_endpoint_encapsulation_info").get("switch_dpid")
 379                 switch_port = cp.get("service_endpoint_encapsulation_info").get("switch_port")
 380                 service_endpoint_id = cp.get("service_endpoint_id")
 381                 cp_name = self.underlay_api.get_vpg_name(switch_id, switch_port)
 382                 add_cp = work_cps.get(cp_name)
 383                 if not add_cp:
 384                     # check cp has vlan
 385                     vlan = cp.get("service_endpoint_encapsulation_info").get("vlan")
 386                     if vlan:
 387                         # add cp to dict
 388                         service_endpoint_ids = []
 389                         service_endpoint_ids.append(service_endpoint_id)
 390                         add_cp = {"service_endpoint_ids": service_endpoint_ids,
 391                                   "switch_dpid": switch_id,
 392                                   "switch_port": switch_port,
 393                                   "vlan": vlan}
 394                         work_cps[cp_name] = add_cp
 395                     else:
 396                         self.logger.warning("cp service_endpoint_id : {} has no vlan, ignore".format(service_endpoint_id))
 397                 else:
 398                     # add service_endpoint_id to list
 399                     service_endpoint_ids = add_cp["service_endpoint_ids"]
 400                     service_endpoint_ids.append(service_endpoint_id)
 401
 402             # 2 - Obtain free VNI
 403             vni = self._generate_vni()
 404             self.logger.debug("VNI: {}".format(vni))
 405
 406             # 3 - Create virtual network (name, VNI, RT), by the moment the name will use VNI
 407             retry = 0
 408             while retry < self._max_duplicate_retry:
 409                 try:
 410                     vnet_name = 'osm-plugin-' + str(vni)
 411                     vnet_id, _ = self.underlay_api.create_virtual_network(vnet_name, vni)
 412                     self.used_vni.add(vni)
 413                     break
 414                 except DuplicateFound as e:
 415                     self.logger.debug("Duplicate error for vnet_name: {}".format(vnet_name))
 416                     self.used_vni.add(vni)
 417                     retry += 1
 418                     if retry >= self._max_duplicate_retry:
 419                         raise e
 420                     else:
 421                         # Try to obtain a new vni
 422                         vni = self._generate_vni()
 423                         continue
 424             conn_info = {
 425                 "vnet": {
 426                     "uuid": vnet_id,
 427                     "name": vnet_name
 428                 },
 429                 "connection_points": work_cps # dict with port_name as key
 430             }
 431
 432             # 4 - Create a port for each endpoint
 433             for cp in work_cps.values():
 434                 switch_id = cp.get("switch_dpid")
 435                 switch_port = cp.get("switch_port")
 436                 vlan = cp.get("vlan")
 437                 vpg_id, vmi_id = self._create_port(switch_id, switch_port, vnet_name, vlan)
 438                 cp["vpg_id"] = vpg_id
 439                 cp["vmi_id"] = vmi_id
 440
 441             self.logger.info("created connectivity service, uuid: {}, name: {}".format(vnet_id, vnet_name))
 442             return vnet_id, conn_info
 443
 444         except Exception as e:
 445             # Log error
 446             if isinstance(e, SdnConnectorError) or isinstance(e, HttpException):
 447                 self.logger.error("Error creating connectivity service: {}".format(e))
 448             else:
 449                 self.logger.error("Error creating connectivity service: {}".format(e), exc_info=True)
 450
 451
 452             # If nothing is created raise error else return what has been created and mask as error
 453             if not conn_info:
 454                 raise SdnConnectorError("Exception create connectivity service: {}".format(str(e)))
 455             else:
 456                 conn_info["sdn_status"] = "ERROR"
 457                 conn_info["sdn_info"] = repr(e)
 458                 # iterate over not added connection_points and add but marking them as error
 459                 for cp in work_cps.values():
 460                     if not cp.get("vmi_id") or not cp.get("vpg_id"):
 461                         cp["sdn_status"] = "ERROR"
 462                 return vnet_id, conn_info
 463
 464     def delete_connectivity_service(self, service_uuid, conn_info=None):
 465         """
 466         Disconnect multi-site endpoints previously connected
 467
 468         :param service_uuid: The one returned by create_connectivity_service
 469         :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
 470             if they do not return None
 471         :return: None
 472         :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
 473         """
 474         self.logger.info("delete_connectivity_service vnet_name: {}, connection_points: {}".
 475                           format(service_uuid, conn_info))
 476
 477         try:
 478             vnet_uuid = service_uuid
 479             vnet_name = conn_info["vnet"]["name"]   # always should exist as the network is the first thing created
 480             work_cps = conn_info["connection_points"]
 481
 482             # 1: For each connection point delete vlan from vpg and it is is the
 483             # last one, delete vpg
 484             for cp in work_cps.values():
 485                 self._delete_port(cp.get("switch_dpid"), cp.get("switch_port"), cp.get("vlan"))
 486
 487             # 2: Delete vnet
 488             self.underlay_api.delete_virtual_network(vnet_uuid)
 489             self.logger.info("deleted connectivity_service vnet_name: {}, connection_points: {}".
 490                              format(service_uuid, conn_info))
 491         except SdnConnectorError:
 492             raise
 493         except HttpException as e:
 494             self.logger.error("Error deleting connectivity service: {}".format(e))
 495             raise SdnConnectorError("Exception deleting connectivity service: {}".format(str(e)))
 496         except Exception as e:
 497             self.logger.error("Error deleting connectivity service: {}".format(e), exc_info=True)
 498             raise SdnConnectorError("Exception deleting connectivity service: {}".format(str(e)))
 499
 500     def edit_connectivity_service(self, service_uuid, conn_info = None, connection_points = None, **kwargs):
 501         """ Change an existing connectivity service.
 502
 503         This method's arguments and return value follow the same convention as
 504         :meth:`~.create_connectivity_service`.
 505
 506         :param service_uuid: UUID of the connectivity service.
 507         :param conn_info: (dict or None): Information previously returned by last call to create_connectivity_service
 508             or edit_connectivity_service
 509         :param connection_points: (list): If provided, the old list of connection points will be replaced.
 510         :param kwargs: Same meaning that create_connectivity_service
 511         :return: dict or None: Information to be updated and stored at the database.
 512                 When ``None`` is returned, no information should be changed.
 513                 When an empty dict is returned, the database record will be deleted.
 514                 **MUST** be JSON/YAML-serializable (plain data structures).
 515         Raises:
 516             SdnConnectorException: In case of error.
 517         """
 518         # 0 - Check if there are connection_points marked as error and delete them
 519         # 1 - Compare conn_info (old connection points) and connection_points (new ones to be applied):
 520         #     Obtain list of connection points to be added and to be deleted
 521         #     Obtain vlan and check it has not changed
 522         # 2 - Obtain network: Check vnet exists and obtain name
 523         # 3 - Delete unnecesary ports
 524         # 4 - Add new ports
 525         self.logger.info("edit connectivity service, service_uuid: {}, conn_info: {}, "
 526                           "connection points: {} ".format(service_uuid, conn_info, connection_points))
 527
 528         # conn_info should always exist and have connection_points and vnet elements
 529         old_cp = conn_info.get("connection_points", {})
 530
 531         # Check if an element of old_cp is marked as error, in case it is delete it
 532         # Not return a new conn_info in this case because it is only partial information
 533         # Current conn_info already marks ports as error
 534         try:
 535             deleted_ports = []
 536             for cp in old_cp.values():
 537                 if cp.get("sdn_status") == "ERROR":
 538                     switch_id = cp.get("switch_dpid")
 539                     switch_port = cp.get("switch_port")
 540                     old_vlan = cp.get("vlan")
 541                     self._delete_port(switch_id, switch_port, old_vlan)
 542                     deleted_ports.append(self.underlay_api.get_vpg_name(switch_id, switch_port))
 543
 544             for port in deleted_ports:
 545                 del old_cp[port]
 546
 547             # Delete sdn_status and sdn_info if exists (possibly marked as error)
 548             if conn_info.get("vnet",{}).get("sdn_status"):
 549                 del conn_info["vnet"]["sdn_status"]
 550         except HttpException as e:
 551             self.logger.error("Error trying to delete old ports marked as error: {}".format(e))
 552             raise SdnConnectorError(e)
 553         except SdnConnectorError as e:
 554             self.logger.error("Error trying to delete old ports marked as error: {}".format(e))
 555             raise
 556         except Exception as e:
 557             self.logger.error("Error trying to delete old ports marked as error: {}".format(e), exc_info=True)
 558             raise SdnConnectorError("Error trying to delete old ports marked as error: {}".format(e))
 559
 560         if connection_points:
 561
 562             # Check and obtain what should be added and deleted, if there is an error here raise an exception
 563             try:
 564                 work_cps = {}
 565                 for cp in connection_points:
 566                     switch_id = cp.get("service_endpoint_encapsulation_info").get("switch_dpid")
 567                     switch_port = cp.get("service_endpoint_encapsulation_info").get("switch_port")
 568                     service_endpoint_id = cp.get("service_endpoint_id")
 569                     cp_name = self.underlay_api.get_vpg_name(switch_id, switch_port)
 570                     add_cp = work_cps.get(cp_name)
 571                     if not add_cp:
 572                         # add cp to dict
 573                         # check cp has vlan
 574                         vlan = cp.get("service_endpoint_encapsulation_info").get("vlan")
 575                         if vlan:
 576                             service_endpoint_ids = []
 577                             service_endpoint_ids.append(service_endpoint_id)
 578                             add_cp = {"service_endpoint_ids": service_endpoint_ids,
 579                                       "switch_dpid": switch_id,
 580                                       "switch_port": switch_port,
 581                                       "vlan": vlan}
 582                             work_cps[cp_name] = add_cp
 583                         else:
 584                             self.logger.warning("cp service_endpoint_id : {} has no vlan, ignore".
 585                                                 format(service_endpoint_id))
 586                     else:
 587                         # add service_endpoint_id to list
 588                         service_endpoint_ids = add_cp["service_endpoint_ids"]
 589                         service_endpoint_ids.append(service_endpoint_id)
 590
 591                 old_port_list = list(old_cp.keys())
 592                 port_list = list(work_cps.keys())
 593                 to_delete_ports = list(set(old_port_list) - set(port_list))
 594                 to_add_ports = list(set(port_list) - set(old_port_list))
 595                 self.logger.debug("ports to delete: {}".format(to_delete_ports))
 596                 self.logger.debug("ports to add: {}".format(to_add_ports))
 597
 598                 # Obtain network (check it is correctly created)
 599                 vnet = self.underlay_api.get_virtual_network(service_uuid)
 600                 if vnet:
 601                     vnet_name = vnet["name"]
 602                 else:
 603                     raise SdnConnectorError("vnet uuid: {} not found".format(service_uuid))
 604
 605             except SdnConnectorError:
 606                 raise
 607             except Exception as e:
 608                 self.logger.error("Error edit connectivity service: {}".format(e), exc_info=True)
 609                 raise SdnConnectorError("Exception edit connectivity service: {}".format(str(e)))
 610
 611             # Delete unneeded ports and add new ones: if there is an error return conn_info
 612             try:
 613                 # Connection points returned in con_info should reflect what has (and should as ERROR) be done
 614                 # Start with old cp dictionary and modify it as we work
 615                 conn_info_cp = old_cp
 616
 617                 # Delete unneeded ports
 618                 deleted_ports = []
 619                 for port_name in conn_info_cp.keys():
 620                     if port_name in to_delete_ports:
 621                         cp = conn_info_cp[port_name]
 622                         switch_id = cp.get("switch_dpid")
 623                         switch_port = cp.get("switch_port")
 624                         self.logger.debug("delete port switch_id, switch_port: {}".format(switch_id, switch_port))
 625                         self._delete_port(switch_id, switch_port, vlan)
 626                         deleted_ports.append(port_name)
 627
 628                 # Delete ports
 629                 for port_name in deleted_ports:
 630                     del conn_info_cp[port_name]
 631
 632                 # Add needed ports
 633                 for port_name, cp in work_cps.items():
 634                     if port_name in to_add_ports:
 635                         switch_id = cp.get("switch_dpid")
 636                         switch_port = cp.get("switch_port")
 637                         vlan = cp.get("vlan")
 638                         self.logger.debug("add port switch_id, switch_port: {}".format(switch_id, switch_port))
 639                         vpg_id, vmi_id = self._create_port(switch_id, switch_port, vnet_name, vlan)
 640                         cp_added = cp.copy()
 641                         cp_added["vpg_id"] = vpg_id
 642                         cp_added["vmi_id"] = vmi_id
 643                         conn_info_cp[port_name] = cp_added
 644                     # replace endpoints in case they have changed
 645                     conn_info_cp[port_name]["service_endpoint_ids"] = cp["service_endpoint_ids"]
 646
 647                 conn_info["connection_points"] = conn_info_cp
 648                 return conn_info
 649
 650             except Exception as e:
 651                 # Log error
 652                 if isinstance(e, SdnConnectorError) or isinstance(e, HttpException):
 653                     self.logger.error("Error edit connectivity service: {}".format(e), exc_info=True)
 654                 else:
 655                     self.logger.error("Error edit connectivity service: {}".format(e))
 656
 657                 # There has been an error mount conn_info_cp marking as error cp that should
 658                 # have been deleted but have not or should have been added
 659                 for port_name, cp in conn_info_cp.items():
 660                     if port_name in to_delete_ports:
 661                         cp["sdn_status"] = "ERROR"
 662
 663                 for port_name, cp in work_cps.items():
 664                     curr_cp = conn_info_cp.get(port_name)
 665                     if not curr_cp:
 666                         cp_error = work_cps.get(port_name).copy()
 667                         cp_error["sdn_status"] = "ERROR"
 668                         conn_info_cp[port_name] = cp_error
 669                     conn_info_cp[port_name]["service_endpoint_ids"] = cp["service_endpoint_ids"]
 670
 671                 conn_info["sdn_status"] = "ERROR"
 672                 conn_info["sdn_info"] = repr(e)
 673                 conn_info["connection_points"] = conn_info_cp
 674                 return conn_info
 675
 676         else:
 677             # Connection points have not changed, so do nothing
 678             self.logger.info("no new connection_points provided, nothing to be done")
 679             return
 680
 681
 682 if __name__ == '__main__':
 683     # Init logger
 684     log_format = "%(asctime)s %(levelname)s %(name)s %(filename)s:%(lineno)s %(funcName)s(): %(message)s"
 685     log_formatter = logging.Formatter(log_format, datefmt='%Y-%m-%dT%H:%M:%S')
 686     handler = logging.StreamHandler()
 687     handler.setFormatter(log_formatter)
 688     logger = logging.getLogger('openmano.sdnconn.junipercontrail')
 689     #logger.setLevel(level=logging.ERROR)
 690     #logger.setLevel(level=logging.INFO)
 691     logger.setLevel(level=logging.DEBUG)
 692     logger.addHandler(handler)
 693
 694     # Read config
 695     with open('test.yaml') as f:
 696         config = yaml.safe_load(f.read())
 697     wim = {'wim_url': config.pop('wim_url')}
 698     wim_account = {'user': config.pop('user'), 'password': config.pop('password')}
 699     logger.info('wim: {}, wim_account: {}, config: {}'.format(wim, wim_account, config))
 700
 701     # Init controller
 702     juniper_contrail = JuniperContrail(wim=wim, wim_account=wim_account, config=config, logger=logger)
 703
 704     # Tests
 705     # Generate VNI
 706     for i in range(5):
 707         vni = juniper_contrail._generate_vni()
 708         juniper_contrail.used_vni.add(vni)
 709     print(juniper_contrail.used_vni)
 710     #juniper_contrail.used_vni.remove(1000003)
 711     print(juniper_contrail.used_vni)
 712     for i in range(2):
 713         vni = juniper_contrail._generate_vni()
 714         juniper_contrail.used_vni.add(vni)
 715     print(juniper_contrail.used_vni)
 716
 717
 718     # 0. Check credentials
 719     print('0. Check credentials')
 720     #juniper_contrail.check_credentials()
 721
 722     # 1 - Create and delete connectivity service
 723     conn_point_0 = {
 724         "service_endpoint_id": "0000:83:11.4",
 725         "service_endpoint_encapsulation_type": "dot1q",
 726         "service_endpoint_encapsulation_info": {
 727             "switch_dpid": "LEAF-1",
 728             "switch_port": "xe-0/0/17",
 729             "vlan": "501"
 730         }
 731     }
 732     conn_point_1 = {
 733         "service_endpoint_id": "0000:81:10.3",
 734         "service_endpoint_encapsulation_type": "dot1q",
 735         "service_endpoint_encapsulation_info": {
 736             "switch_dpid": "LEAF-2",
 737             "switch_port": "xe-0/0/16",
 738             "vlan": "501"
 739         }
 740     }
 741     conn_point_2 = {
 742         "service_endpoint_id": "0000:08:11.7",
 743         "service_endpoint_encapsulation_type": "dot1q",
 744         "service_endpoint_encapsulation_info": {
 745             "switch_dpid": "LEAF-2",
 746             "switch_port": "xe-0/0/16",
 747             "vlan": "502"
 748         }
 749     }
 750     conn_point_3 = {
 751         "service_endpoint_id": "0000:83:10.4",
 752         "service_endpoint_encapsulation_type": "dot1q",
 753         "service_endpoint_encapsulation_info": {
 754             "switch_dpid": "LEAF-1",
 755             "switch_port": "xe-0/0/17",
 756             "vlan": "502"
 757         }
 758     }
 759
 760     # 1 - Define connection points
 761     logger.debug("create first connection service")
 762     print("Create connectivity service")
 763     connection_points = [conn_point_0, conn_point_1]
 764     service_id, conn_info = juniper_contrail.create_connectivity_service("ELAN", connection_points)
 765     logger.info("Created connectivity service 1")
 766     logger.info(service_id)
 767     logger.info(yaml.safe_dump(conn_info, indent=4, default_flow_style=False))
 768
 769     logger.debug("create second connection service")
 770     print("Create connectivity service")
 771     connection_points = [conn_point_2, conn_point_3]
 772     service_id2, conn_info2 = juniper_contrail.create_connectivity_service("ELAN", connection_points)
 773     logger.info("Created connectivity service 2")
 774     logger.info(service_id2)
 775     logger.info(yaml.safe_dump(conn_info2, indent=4, default_flow_style=False))
 776
 777     logger.debug("Delete connectivity service 1")
 778     juniper_contrail.delete_connectivity_service(service_id, conn_info)
 779     logger.debug("Delete Ok")
 780
 781     logger.debug("Delete connectivity service 2")
 782     juniper_contrail.delete_connectivity_service(service_id2, conn_info2)
 783     logger.debug("Delete Ok")
 784