1 # -*- coding: utf-8 -*-
3 # Copyright 2020 ETSI OSM
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
11 # http://www.apache.org/licenses/LICENSE-2.0
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
23 from osm_ro_plugin
.sdnconn
import SdnConnectorBase
, SdnConnectorError
24 from osm_rosdn_juniper_contrail
.rest_lib
import DuplicateFound
25 from osm_rosdn_juniper_contrail
.rest_lib
import HttpException
26 from osm_rosdn_juniper_contrail
.sdn_api
import UnderlayApi
30 class JuniperContrail(SdnConnectorBase
):
32 Juniper Contrail SDN plugin. The plugin interacts with Juniper Contrail Controller,
33 whose API details can be found in these links:
35 - https://github.com/tonyliu0592/contrail/wiki/API-Configuration-REST
36 - https://www.juniper.net/documentation/en_US/contrail19/information-products/pathway-pages/api-guide-1910/
37 tutorial_with_rest.html
38 - https://github.com/tonyliu0592/contrail-toolbox/blob/master/sriov/sriov
41 _WIM_LOGGER
= "ro.sdn.junipercontrail"
43 def __init__(self
, wim
, wim_account
, config
=None, logger
=None):
46 :param wim: (dict). Contains among others 'wim_url'
47 :param wim_account: (dict). Contains among others 'uuid' (internal id), 'name',
48 'sdn' (True if is intended for SDN-assist or False if intended for WIM), 'user', 'password'.
49 :param config: (dict or None): Particular information of plugin. These keys if present have a common meaning:
50 'mapping_not_needed': (bool) False by default or if missing, indicates that mapping is not needed.
51 'service_endpoint_mapping': (list) provides the internal endpoint mapping. The meaning is:
52 KEY meaning for WIM meaning for SDN assist
53 -------- -------- --------
54 device_id pop_switch_dpid compute_id
55 device_interface_id pop_switch_port compute_pci_address
56 service_endpoint_id wan_service_endpoint_id SDN_service_endpoint_id
57 service_mapping_info wan_service_mapping_info SDN_service_mapping_info
58 contains extra information if needed. Text in Yaml format
59 switch_dpid wan_switch_dpid SDN_switch_dpid
60 switch_port wan_switch_port SDN_switch_port
61 datacenter_id vim_account vim_account
62 id: (internal, do not use)
63 wim_id: (internal, do not use)
64 :param logger (logging.Logger): optional logger object. If none is passed 'ro.sdn.sdnconn' is used.
66 self
.logger
= logger
or logging
.getLogger(self
._WIM
_LOGGER
)
68 "wim: {}, wim_account: {}, config: {}".format(wim
, wim_account
, config
)
70 super().__init
__(wim
, wim_account
, config
, logger
)
72 self
.user
= wim_account
.get("user")
73 self
.password
= wim_account
.get("password")
75 url
= wim
.get("wim_url") # underlay url
86 auth_url
= config
.get("auth_url")
87 self
.project
= config
.get("project")
88 self
.domain
= config
.get("domain")
89 self
.asn
= config
.get("asn")
90 self
.fabric
= config
.get("fabric")
91 self
.overlay_url
= config
.get("overlay_url")
92 self
.vni_range
= config
.get("vni_range")
94 if config
.get("insecure") and config
.get("ca_cert"):
95 raise SdnConnectorError(
96 "options insecure and ca_cert are mutually exclusive"
99 if config
.get("ca_cert"):
100 self
.verify
= config
.get("ca_cert")
102 elif config
.get("insecure"):
106 raise SdnConnectorError(
107 "certificate should provided or ssl verification should be "
108 "disabled by setting insecure as True in sdn/wim config."
112 raise SdnConnectorError("'url' must be provided")
114 if not url
.startswith("http"):
115 url
= "http://" + url
117 if not url
.endswith("/"):
122 if not self
.vni_range
:
123 self
.vni_range
= ["1000001-2000000"]
124 self
.logger
.info("No vni_range was provided. Using ['1000001-2000000']")
126 self
.used_vni
= set()
129 if not auth_url
.startswith("http"):
130 auth_url
= "http://" + auth_url
132 if not auth_url
.endswith("/"):
133 auth_url
= auth_url
+ "/"
135 self
.auth_url
= auth_url
138 if not overlay_url
.startswith("http"):
139 overlay_url
= "http://" + overlay_url
141 if not overlay_url
.endswith("/"):
142 overlay_url
= overlay_url
+ "/"
144 self
.overlay_url
= overlay_url
147 raise SdnConnectorError("'project' must be provided")
150 # TODO: Get ASN from controller config; otherwise raise ERROR for the moment
151 raise SdnConnectorError(
152 "'asn' was not provided and it was not possible to obtain it"
156 # TODO: Get FABRIC from controller config; otherwise raise ERROR for the moment
157 raise SdnConnectorError(
158 "'fabric' was not provided and was not possible to obtain it"
162 self
.domain
= "default-domain"
163 self
.logger
.info("No domain was provided. Using 'default-domain'")
165 underlay_api_config
= {
166 "auth_url": self
.auth_url
,
167 "project": self
.project
,
168 "domain": self
.domain
,
170 "fabric": self
.fabric
,
171 "verify": self
.verify
,
173 self
.underlay_api
= UnderlayApi(
177 password
=self
.password
,
181 self
._max
_duplicate
_retry
= 2
182 self
.logger
.info("Juniper Contrail Connector Initialized.")
184 def _generate_vni(self
):
186 Method to get unused VxLAN Network Identifier (VNI)
192 # find unused VLAN ID
193 for vlanID_range
in self
.vni_range
:
195 start_vni
, end_vni
= map(int, vlanID_range
.replace(" ", "").split("-"))
197 for i
in range(start_vni
, end_vni
+ 1):
198 vni
= random
.randrange(start_vni
, end_vni
, 1)
200 if vni
not in self
.used_vni
:
202 except Exception as exp
:
203 raise SdnConnectorError(
204 "Exception {} occurred while searching a free VNI.".format(exp
)
207 raise SdnConnectorError(
208 "Unable to create the virtual network."
209 " All VNI in VNI range {} are in use.".format(self
.vni_range
)
212 # Aux functions for testing
216 def _create_port(self
, switch_id
, switch_port
, network
, vlan
):
218 1 - Look for virtual port groups for provided switch_id, switch_port using name
219 2 - It the virtual port group does not exist, create it
220 3 - Create virtual machine interface for the indicated network and vlan
223 "create_port: switch_id: {}, switch_port: {}, network: {}, vlan: {}".format(
224 switch_id
, switch_port
, network
, vlan
228 # 1 - Check if the vpg exists
229 vpg_name
= self
.underlay_api
.get_vpg_name(switch_id
, switch_port
)
230 vpg
= self
.underlay_api
.get_vpg_by_name(vpg_name
)
233 # 2 - If it does not exist create it
234 vpg_id
, _
= self
.underlay_api
.create_vpg(switch_id
, switch_port
)
236 # Assign vpg_id from vpg
237 vpg_id
= vpg
.get("uuid")
239 # 3 - Check if the vmi alreaady exists
240 vmi_id
, _
= self
.underlay_api
.create_vmi(switch_id
, switch_port
, network
, vlan
)
241 self
.logger
.debug("port created")
243 return vpg_id
, vmi_id
245 def _delete_port(self
, switch_id
, switch_port
, vlan
):
247 "delete port, switch_id: {}, switch_port: {}, vlan: {}".format(
248 switch_id
, switch_port
, vlan
252 vpg_name
= self
.underlay_api
.get_vpg_name(switch_id
, switch_port
)
253 vmi_name
= self
.underlay_api
.get_vmi_name(switch_id
, switch_port
, vlan
)
255 # 1 - Obtain vpg by id (if not vpg_id must have been error creating ig, nothing to be done)
256 vpg_fqdn
= ["default-global-system-config", self
.fabric
, vpg_name
]
257 vpg
= self
.underlay_api
.get_by_fq_name("virtual-port-group", vpg_fqdn
)
260 self
.logger
.warning("vpg: {} to be deleted not found".format(vpg_name
))
262 # 2 - Get vmi interfaces from vpg
263 vmi_list
= vpg
.get("virtual_machine_interface_refs")
266 # must have been an error during port creation when vmi is created
267 # may happen if there has been an error during creation
269 "vpg: {} has not vmi, will delete nothing".format(vpg
)
272 num_vmis
= len(vmi_list
)
278 if fqdn
[2] == vmi_name
:
279 self
.underlay_api
.unref_vmi_vpg(
280 vpg
.get("uuid"), vmi
.get("uuid"), fqdn
282 self
.underlay_api
.delete_vmi(vmi
.get("uuid"))
283 num_vmis
= num_vmis
- 1
285 # 3 - If there are no more vmi delete the vpg
286 if not vmi_list
or num_vmis
== 0:
287 self
.underlay_api
.delete_vpg(vpg
.get("uuid"))
289 def check_credentials(self
):
290 """Check if the connector itself can access the SDN/WIM with the provided url (wim.wim_url),
291 user (wim_account.user), and password (wim_account.password)
294 SdnConnectorError: Issues regarding authorization, access to
295 external URLs, etc are detected.
297 self
.logger
.debug("")
300 resp
= self
.underlay_api
.check_auth()
302 raise SdnConnectorError("Empty response")
303 except Exception as e
:
304 self
.logger
.error("Error checking credentials")
306 raise SdnConnectorError("Error checking credentials: {}".format(str(e
)))
308 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
309 """Monitor the status of the connectivity service established
312 service_uuid (str): UUID of the connectivity service
313 conn_info (dict or None): Information returned by the connector
314 during the service creation/edition and subsequently stored in
318 dict: JSON/YAML-serializable dict that contains a mandatory key
319 ``sdn_status`` associated with one of the following values::
321 {'sdn_status': 'ACTIVE'}
322 # The service is up and running.
324 {'sdn_status': 'INACTIVE'}
325 # The service was created, but the connector
326 # cannot determine yet if connectivity exists
327 # (ideally, the caller needs to wait and check again).
329 {'sdn_status': 'DOWN'}
330 # Connection was previously established,
331 # but an error/failure was detected.
333 {'sdn_status': 'ERROR'}
334 # An error occurred when trying to create the service/
335 # establish the connectivity.
337 {'sdn_status': 'BUILD'}
338 # Still trying to create the service, the caller
339 # needs to wait and check again.
341 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
342 keys can be used to provide additional status explanation or
343 new information available for the connectivity service.
345 self
.logger
.debug("")
348 resp
= self
.underlay_api
.get_virtual_network(service_uuid
)
350 raise SdnConnectorError("Empty response")
355 # Check if conn_info reports error
356 if conn_info
.get("sdn_status") == "ERROR":
357 return {"sdn_status": "ERROR", "sdn_info": conn_info
}
359 return {"sdn_status": "ACTIVE", "sdn_info": vnet_info
}
361 return {"sdn_status": "ERROR", "sdn_info": "not found"}
362 except SdnConnectorError
:
364 except HttpException
as e
:
365 self
.logger
.error("Error getting connectivity service: {}".format(e
))
367 raise SdnConnectorError(
368 "Exception deleting connectivity service: {}".format(str(e
))
370 except Exception as e
:
372 "Exception getting connectivity service info: %s", e
, exc_info
=True
375 return {"sdn_status": "ERROR", "error_msg": str(e
)}
377 def create_connectivity_service(self
, service_type
, connection_points
, **kwargs
):
379 Establish SDN/WAN connectivity between the endpoints
380 :param service_type: (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
381 :param connection_points: (list): each point corresponds to
382 an entry point to be connected. For WIM: from the DC to the transport network.
383 For SDN: Compute/PCI to the transport network. One
384 connection point serves to identify the specific access and
385 some other service parameters, such as encapsulation type.
386 Each item of the list is a dict with:
387 "service_endpoint_id": (str)(uuid) Same meaning that for 'service_endpoint_mapping' (see __init__)
388 In case the config attribute mapping_not_needed is True, this value is not relevant. In this case
389 it will contain the string "device_id:device_interface_id"
390 "service_endpoint_encapsulation_type": None, "dot1q", ...
391 "service_endpoint_encapsulation_info": (dict) with:
392 "vlan": ..., (int, present if encapsulation is dot1q)
393 "vni": ... (int, present if encapsulation is vxlan),
394 "peers": [(ipv4_1), (ipv4_2)] (present if encapsulation is vxlan)
396 "device_id": ..., same meaning that for 'service_endpoint_mapping' (see __init__)
397 "device_interface_id": same meaning that for 'service_endpoint_mapping' (see __init__)
398 "switch_dpid": ..., present if mapping has been found for this device_id,device_interface_id
399 "switch_port": ... present if mapping has been found for this device_id,device_interface_id
400 "service_mapping_info": present if mapping has been found for this device_id,device_interface_id
401 :param kwargs: For future versions:
402 bandwidth (int): value in kilobytes
403 latency (int): value in milliseconds
404 Other QoS might be passed as keyword arguments.
405 :return: tuple: ``(service_id, conn_info)`` containing:
406 - *service_uuid* (str): UUID of the established connectivity service
407 - *conn_info* (dict or None): Information to be stored at the database (or ``None``).
408 This information will be provided to the :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
409 **MUST** be JSON/YAML-serializable (plain data structures).
410 :raises: SdnConnectorException: In case of error. Nothing should be created in this case.
411 Provide the parameter http_code
413 # Step 1. Check in the overlay controller the virtual network created by the VIM
414 # Best option: get network id of the VIM as param (if the VIM already created the network),
415 # and do a request to the controller of the virtual networks whose VIM network id is the provided
416 # Next best option: obtain the network by doing a request to the controller
417 # of the virtual networks using the VLAN ID of any service endpoint.
418 # 1.1 Read VLAN ID from a service endpoint
419 # 1.2 Look for virtual networks with "Provider Network" including a VLAN ID.
420 # 1.3 If more than one, ERROR
421 # Step 2. Modify the existing virtual network in the overlay controller
422 # 2.1 Add VNI (VxLAN Network Identifier - one free from the provided range)
423 # 2.2 Add RouteTarget (RT) ('ASN:VNI', ASN = Autonomous System Number, provided as param or read from
425 # Step 3. Create a virtual network in the underlay controller
426 # 3.1 Create virtual network (name, VNI, RT)
427 # If the network already existed in the overlay controller, we should use the same name
428 # name = 'osm-plugin-' + overlay_name
430 # name = 'osm-plugin-' + VNI
432 "create_connectivity_service, service_type: {}, connection_points: {}".format(
433 service_type
, connection_points
437 if service_type
.lower() != "elan":
438 raise SdnConnectorError(
439 "Only ELAN network type is supported by Juniper Contrail."
446 # 1 - Filter connection_points (transform cp to a dictionary with no duplicates)
447 # This data will be returned even if no cp can be created if something is created
449 for cp
in connection_points
:
450 switch_id
= cp
.get("service_endpoint_encapsulation_info").get(
453 switch_port
= cp
.get("service_endpoint_encapsulation_info").get(
456 service_endpoint_id
= cp
.get("service_endpoint_id")
457 cp_name
= self
.underlay_api
.get_vpg_name(switch_id
, switch_port
)
458 add_cp
= work_cps
.get(cp_name
)
462 vlan
= cp
.get("service_endpoint_encapsulation_info").get("vlan")
466 service_endpoint_ids
= []
467 service_endpoint_ids
.append(service_endpoint_id
)
469 "service_endpoint_ids": service_endpoint_ids
,
470 "switch_dpid": switch_id
,
471 "switch_port": switch_port
,
474 work_cps
[cp_name
] = add_cp
477 "cp service_endpoint_id : {} has no vlan, ignore".format(
482 # add service_endpoint_id to list
483 service_endpoint_ids
= add_cp
["service_endpoint_ids"]
484 service_endpoint_ids
.append(service_endpoint_id
)
486 # 2 - Obtain free VNI
487 vni
= self
._generate
_vni
()
488 self
.logger
.debug("VNI: {}".format(vni
))
490 # 3 - Create virtual network (name, VNI, RT), by the moment the name will use VNI
492 while retry
< self
._max
_duplicate
_retry
:
494 vnet_name
= "osm-plugin-" + str(vni
)
495 vnet_id
, _
= self
.underlay_api
.create_virtual_network(
498 self
.used_vni
.add(vni
)
500 except DuplicateFound
as e
:
502 "Duplicate error for vnet_name: {}".format(vnet_name
)
504 self
.used_vni
.add(vni
)
507 if retry
>= self
._max
_duplicate
_retry
:
510 # Try to obtain a new vni
511 vni
= self
._generate
_vni
()
519 "connection_points": work_cps
, # dict with port_name as key
522 # 4 - Create a port for each endpoint
523 for cp
in work_cps
.values():
524 switch_id
= cp
.get("switch_dpid")
525 switch_port
= cp
.get("switch_port")
526 vlan
= cp
.get("vlan")
527 vpg_id
, vmi_id
= self
._create
_port
(
528 switch_id
, switch_port
, vnet_name
, vlan
530 cp
["vpg_id"] = vpg_id
531 cp
["vmi_id"] = vmi_id
534 "created connectivity service, uuid: {}, name: {}".format(
539 return vnet_id
, conn_info
540 except Exception as e
:
542 if isinstance(e
, SdnConnectorError
) or isinstance(e
, HttpException
):
543 self
.logger
.error("Error creating connectivity service: {}".format(e
))
546 "Error creating connectivity service: {}".format(e
), exc_info
=True
549 # If nothing is created raise error else return what has been created and mask as error
551 raise SdnConnectorError(
552 "Exception create connectivity service: {}".format(str(e
))
555 conn_info
["sdn_status"] = "ERROR"
556 conn_info
["sdn_info"] = repr(e
)
557 # iterate over not added connection_points and add but marking them as error
558 for cp
in work_cps
.values():
559 if not cp
.get("vmi_id") or not cp
.get("vpg_id"):
560 cp
["sdn_status"] = "ERROR"
562 return vnet_id
, conn_info
564 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
566 Disconnect multi-site endpoints previously connected
568 :param service_uuid: The one returned by create_connectivity_service
569 :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
570 if they do not return None
572 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
575 "delete_connectivity_service vnet_name: {}, connection_points: {}".format(
576 service_uuid
, conn_info
581 vnet_uuid
= service_uuid
582 # vnet_name = conn_info["vnet"]["name"]
583 # always should exist as the network is the first thing created
584 work_cps
= conn_info
["connection_points"]
586 # 1: For each connection point delete vlan from vpg and it is is the
587 # last one, delete vpg
588 for cp
in work_cps
.values():
590 cp
.get("switch_dpid"), cp
.get("switch_port"), cp
.get("vlan")
594 self
.underlay_api
.delete_virtual_network(vnet_uuid
)
596 "deleted connectivity_service vnet_uuid: {}, connection_points: {}".format(
597 service_uuid
, conn_info
600 except SdnConnectorError
:
602 except HttpException
as e
:
603 self
.logger
.error("Error deleting connectivity service: {}".format(e
))
605 raise SdnConnectorError(
606 "Exception deleting connectivity service: {}".format(str(e
))
608 except Exception as e
:
610 "Error deleting connectivity service: {}".format(e
),
614 raise SdnConnectorError(
615 "Exception deleting connectivity service: {}".format(str(e
))
618 def edit_connectivity_service(
619 self
, service_uuid
, conn_info
=None, connection_points
=None, **kwargs
621 """Change an existing connectivity service.
623 This method's arguments and return value follow the same convention as
624 :meth:`~.create_connectivity_service`.
626 :param service_uuid: UUID of the connectivity service.
627 :param conn_info: (dict or None): Information previously returned by last call to create_connectivity_service
628 or edit_connectivity_service
629 :param connection_points: (list): If provided, the old list of connection points will be replaced.
630 :param kwargs: Same meaning that create_connectivity_service
631 :return: dict or None: Information to be updated and stored at the database.
632 When ``None`` is returned, no information should be changed.
633 When an empty dict is returned, the database record will be deleted.
634 **MUST** be JSON/YAML-serializable (plain data structures).
636 SdnConnectorException: In case of error.
638 # 0 - Check if there are connection_points marked as error and delete them
639 # 1 - Compare conn_info (old connection points) and connection_points (new ones to be applied):
640 # Obtain list of connection points to be added and to be deleted
641 # Obtain vlan and check it has not changed
642 # 2 - Obtain network: Check vnet exists and obtain name
643 # 3 - Delete unnecesary ports
646 "edit connectivity service, service_uuid: {}, conn_info: {}, "
647 "connection points: {} ".format(service_uuid
, conn_info
, connection_points
)
650 # conn_info should always exist and have connection_points and vnet elements
651 old_cp
= conn_info
.get("connection_points", {})
653 # Check if an element of old_cp is marked as error, in case it is delete it
654 # Not return a new conn_info in this case because it is only partial information
655 # Current conn_info already marks ports as error
658 for cp
in old_cp
.values():
659 if cp
.get("sdn_status") == "ERROR":
660 switch_id
= cp
.get("switch_dpid")
661 switch_port
= cp
.get("switch_port")
662 old_vlan
= cp
.get("vlan")
663 self
._delete
_port
(switch_id
, switch_port
, old_vlan
)
664 deleted_ports
.append(
665 self
.underlay_api
.get_vpg_name(switch_id
, switch_port
)
668 for port
in deleted_ports
:
671 # Delete sdn_status and sdn_info if exists (possibly marked as error)
672 if conn_info
.get("vnet", {}).get("sdn_status"):
673 del conn_info
["vnet"]["sdn_status"]
674 except HttpException
as e
:
676 "Error trying to delete old ports marked as error: {}".format(e
)
679 raise SdnConnectorError(e
)
680 except SdnConnectorError
as e
:
682 "Error trying to delete old ports marked as error: {}".format(e
)
686 except Exception as e
:
688 "Error trying to delete old ports marked as error: {}".format(e
),
692 raise SdnConnectorError(
693 "Error trying to delete old ports marked as error: {}".format(e
)
696 if connection_points
:
697 # Check and obtain what should be added and deleted, if there is an error here raise an exception
700 for cp
in connection_points
:
701 switch_id
= cp
.get("service_endpoint_encapsulation_info").get(
704 switch_port
= cp
.get("service_endpoint_encapsulation_info").get(
707 service_endpoint_id
= cp
.get("service_endpoint_id")
708 cp_name
= self
.underlay_api
.get_vpg_name(switch_id
, switch_port
)
709 add_cp
= work_cps
.get(cp_name
)
714 vlan
= cp
.get("service_endpoint_encapsulation_info").get("vlan")
717 service_endpoint_ids
= []
718 service_endpoint_ids
.append(service_endpoint_id
)
720 "service_endpoint_ids": service_endpoint_ids
,
721 "switch_dpid": switch_id
,
722 "switch_port": switch_port
,
725 work_cps
[cp_name
] = add_cp
728 "cp service_endpoint_id : {} has no vlan, ignore".format(
733 # add service_endpoint_id to list
734 service_endpoint_ids
= add_cp
["service_endpoint_ids"]
735 service_endpoint_ids
.append(service_endpoint_id
)
737 old_port_list
= list(old_cp
.keys())
738 port_list
= list(work_cps
.keys())
739 to_delete_ports
= list(set(old_port_list
) - set(port_list
))
740 to_add_ports
= list(set(port_list
) - set(old_port_list
))
741 self
.logger
.debug("ports to delete: {}".format(to_delete_ports
))
742 self
.logger
.debug("ports to add: {}".format(to_add_ports
))
744 # Obtain network (check it is correctly created)
745 vnet
= self
.underlay_api
.get_virtual_network(service_uuid
)
747 vnet_name
= vnet
["name"]
749 raise SdnConnectorError(
750 "vnet uuid: {} not found".format(service_uuid
)
752 except SdnConnectorError
:
754 except Exception as e
:
756 "Error edit connectivity service: {}".format(e
), exc_info
=True
759 raise SdnConnectorError(
760 "Exception edit connectivity service: {}".format(str(e
))
763 # Delete unneeded ports and add new ones: if there is an error return conn_info
765 # Connection points returned in con_info should reflect what has (and should as ERROR) be done
766 # Start with old cp dictionary and modify it as we work
767 conn_info_cp
= old_cp
769 # Delete unneeded ports
771 for port_name
in conn_info_cp
.keys():
772 if port_name
in to_delete_ports
:
773 cp
= conn_info_cp
[port_name
]
774 switch_id
= cp
.get("switch_dpid")
775 switch_port
= cp
.get("switch_port")
777 "delete port switch_id={}, switch_port={}".format(
778 switch_id
, switch_port
781 self
._delete
_port
(switch_id
, switch_port
, vlan
)
782 deleted_ports
.append(port_name
)
785 for port_name
in deleted_ports
:
786 del conn_info_cp
[port_name
]
789 for port_name
, cp
in work_cps
.items():
790 if port_name
in to_add_ports
:
791 switch_id
= cp
.get("switch_dpid")
792 switch_port
= cp
.get("switch_port")
793 vlan
= cp
.get("vlan")
795 "add port switch_id={}, switch_port={}".format(
796 switch_id
, switch_port
799 vpg_id
, vmi_id
= self
._create
_port
(
800 switch_id
, switch_port
, vnet_name
, vlan
803 cp_added
["vpg_id"] = vpg_id
804 cp_added
["vmi_id"] = vmi_id
805 conn_info_cp
[port_name
] = cp_added
807 # replace endpoints in case they have changed
808 conn_info_cp
[port_name
]["service_endpoint_ids"] = cp
[
809 "service_endpoint_ids"
812 conn_info
["connection_points"] = conn_info_cp
815 except Exception as e
:
817 if isinstance(e
, SdnConnectorError
) or isinstance(e
, HttpException
):
819 "Error edit connectivity service: {}".format(e
), exc_info
=True
822 self
.logger
.error("Error edit connectivity service: {}".format(e
))
824 # There has been an error mount conn_info_cp marking as error cp that should
825 # have been deleted but have not or should have been added
826 for port_name
, cp
in conn_info_cp
.items():
827 if port_name
in to_delete_ports
:
828 cp
["sdn_status"] = "ERROR"
830 for port_name
, cp
in work_cps
.items():
831 curr_cp
= conn_info_cp
.get(port_name
)
834 cp_error
= work_cps
.get(port_name
).copy()
835 cp_error
["sdn_status"] = "ERROR"
836 conn_info_cp
[port_name
] = cp_error
838 conn_info_cp
[port_name
]["service_endpoint_ids"] = cp
[
839 "service_endpoint_ids"
842 conn_info
["sdn_status"] = "ERROR"
843 conn_info
["sdn_info"] = repr(e
)
844 conn_info
["connection_points"] = conn_info_cp
848 # Connection points have not changed, so do nothing
849 self
.logger
.info("no new connection_points provided, nothing to be done")
854 if __name__
== "__main__":
856 log_format
= "%(asctime)s %(levelname)s %(name)s %(filename)s:%(lineno)s %(funcName)s(): %(message)s"
857 log_formatter
= logging
.Formatter(log_format
, datefmt
="%Y-%m-%dT%H:%M:%S")
858 handler
= logging
.StreamHandler()
859 handler
.setFormatter(log_formatter
)
860 logger
= logging
.getLogger("ro.sdn.junipercontrail")
861 # logger.setLevel(level=logging.ERROR)
862 # logger.setLevel(level=logging.INFO)
863 logger
.setLevel(level
=logging
.DEBUG
)
864 logger
.addHandler(handler
)
867 with
open("test.yaml") as f
:
868 config
= yaml
.safe_load(f
.read())
870 wim
= {"wim_url": config
.pop("wim_url")}
871 wim_account
= {"user": config
.pop("user"), "password": config
.pop("password")}
872 logger
.info("wim: {}, wim_account: {}, config: {}".format(wim
, wim_account
, config
))
875 juniper_contrail
= JuniperContrail(
876 wim
=wim
, wim_account
=wim_account
, config
=config
, logger
=logger
882 vni
= juniper_contrail
._generate
_vni
()
883 juniper_contrail
.used_vni
.add(vni
)
885 print(juniper_contrail
.used_vni
)
886 # juniper_contrail.used_vni.remove(1000003)
887 print(juniper_contrail
.used_vni
)
890 vni
= juniper_contrail
._generate
_vni
()
891 juniper_contrail
.used_vni
.add(vni
)
893 print(juniper_contrail
.used_vni
)
895 # 0. Check credentials
896 print("0. Check credentials")
897 # juniper_contrail.check_credentials()
899 # 1 - Create and delete connectivity service
901 "service_endpoint_id": "0000:83:11.4",
902 "service_endpoint_encapsulation_type": "dot1q",
903 "service_endpoint_encapsulation_info": {
904 "switch_dpid": "LEAF-1",
905 "switch_port": "xe-0/0/17",
910 "service_endpoint_id": "0000:81:10.3",
911 "service_endpoint_encapsulation_type": "dot1q",
912 "service_endpoint_encapsulation_info": {
913 "switch_dpid": "LEAF-2",
914 "switch_port": "xe-0/0/16",
919 "service_endpoint_id": "0000:08:11.7",
920 "service_endpoint_encapsulation_type": "dot1q",
921 "service_endpoint_encapsulation_info": {
922 "switch_dpid": "LEAF-2",
923 "switch_port": "xe-0/0/16",
928 "service_endpoint_id": "0000:83:10.4",
929 "service_endpoint_encapsulation_type": "dot1q",
930 "service_endpoint_encapsulation_info": {
931 "switch_dpid": "LEAF-1",
932 "switch_port": "xe-0/0/17",
937 # 1 - Define connection points
938 logger
.debug("create first connection service")
939 print("Create connectivity service")
940 connection_points
= [conn_point_0
, conn_point_1
]
941 service_id
, conn_info
= juniper_contrail
.create_connectivity_service(
942 "ELAN", connection_points
944 logger
.info("Created connectivity service 1")
945 logger
.info(service_id
)
946 logger
.info(yaml
.safe_dump(conn_info
, indent
=4, default_flow_style
=False))
948 logger
.debug("create second connection service")
949 print("Create connectivity service")
950 connection_points
= [conn_point_2
, conn_point_3
]
951 service_id2
, conn_info2
= juniper_contrail
.create_connectivity_service(
952 "ELAN", connection_points
954 logger
.info("Created connectivity service 2")
955 logger
.info(service_id2
)
956 logger
.info(yaml
.safe_dump(conn_info2
, indent
=4, default_flow_style
=False))
958 logger
.debug("Delete connectivity service 1")
959 juniper_contrail
.delete_connectivity_service(service_id
, conn_info
)
960 logger
.debug("Delete Ok")
962 logger
.debug("Delete connectivity service 2")
963 juniper_contrail
.delete_connectivity_service(service_id2
, conn_info2
)
964 logger
.debug("Delete Ok")