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
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
31 from osm_rosdn_juniper_contrail
.sdn_api
import UnderlayApi
34 class JuniperContrail(SdnConnectorBase
):
36 Juniper Contrail SDN plugin. The plugin interacts with Juniper Contrail Controller,
37 whose API details can be found in these links:
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
43 _WIM_LOGGER
= "openmano.sdnconn.junipercontrail"
45 def __init__(self
, wim
, wim_account
, config
=None, logger
=None):
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.
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
)
72 self
.user
= wim_account
.get("user")
73 self
.password
= wim_account
.get("password")
75 url
= wim
.get("wim_url") # underlay url
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")
93 raise SdnConnectorError("'url' must be provided")
94 if not url
.startswith("http"):
96 if not url
.endswith("/"):
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()
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
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
120 raise SdnConnectorError("'project' must be provided")
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")
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")
128 self
.domain
= 'default-domain'
129 self
.logger
.info("No domain was provided. Using 'default-domain'")
131 underlay_api_config
= {
132 "auth_url": self
.auth_url
,
133 "project": self
.project
,
134 "domain": self
.domain
,
136 "fabric": self
.fabric
138 self
.underlay_api
= UnderlayApi(url
, underlay_api_config
, user
=self
.user
, password
=self
.password
, logger
=logger
)
140 self
._max
_duplicate
_retry
= 2
141 self
.logger
.info("Juniper Contrail Connector Initialized.")
143 def _generate_vni(self
):
145 Method to get unused VxLAN Network Identifier (VNI)
152 for vlanID_range
in self
.vni_range
:
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
:
159 except Exception as exp
:
160 raise SdnConnectorError("Exception {} occurred while searching a free VNI.".format(exp
))
162 raise SdnConnectorError("Unable to create the virtual network."\
163 " All VNI in VNI range {} are in use.".format(self
.vni_range
))
166 # Aux functions for testing
170 def get_overlay_url(self
):
171 return self
.overlay_url
173 def _create_port(self
, switch_id
, switch_port
, network
, vlan
):
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
179 self
.logger
.debug("create_port: switch_id: {}, switch_port: {}, network: {}, vlan: {}".format(
180 switch_id
, switch_port
, network
, vlan
))
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
)
186 # 2 - If it does not exist create it
187 vpg_id
, _
= self
.underlay_api
.create_vpg(switch_id
, switch_port
)
189 # Assign vpg_id from vpg
190 vpg_id
= vpg
.get("uuid")
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")
196 return vpg_id
, vmi_id
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
))
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
)
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
)
208 self
.logger
.warning("vpg: {} to be deleted not found".format(vpg_name
))
210 # 2 - Get vmi interfaces from vpg
211 vmi_list
= vpg
.get("virtual_machine_interface_refs")
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
))
217 num_vmis
= len(vmi_list
)
219 uuid
= vmi
.get("uuid")
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
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"))
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)
236 SdnConnectorError: Issues regarding authorization, access to
237 external URLs, etc are detected.
239 self
.logger
.debug("")
241 resp
= self
.underlay_api
.check_auth()
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
)))
248 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
249 """Monitor the status of the connectivity service established
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
258 dict: JSON/YAML-serializable dict that contains a mandatory key
259 ``sdn_status`` associated with one of the following values::
261 {'sdn_status': 'ACTIVE'}
262 # The service is up and running.
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).
269 {'sdn_status': 'DOWN'}
270 # Connection was previously established,
271 # but an error/failure was detected.
273 {'sdn_status': 'ERROR'}
274 # An error occurred when trying to create the service/
275 # establish the connectivity.
277 {'sdn_status': 'BUILD'}
278 # Still trying to create the service, the caller
279 # needs to wait and check again.
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.
285 self
.logger
.debug("")
287 resp
= self
.underlay_api
.get_virtual_network(service_uuid
)
289 raise SdnConnectorError('Empty response')
293 # Check if conn_info reports error
294 if conn_info
.get("sdn_status") == "ERROR":
295 return {'sdn_status': 'ERROR', 'sdn_info': conn_info
}
297 return {'sdn_status': 'ACTIVE', 'sdn_info': vnet_info
}
299 return {'sdn_status': 'ERROR', 'sdn_info': 'not found'}
300 except SdnConnectorError
:
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
)}
310 def create_connectivity_service(self
, service_type
, connection_points
, **kwargs
):
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)
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
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
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.')
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
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
)
385 vlan
= cp
.get("service_endpoint_encapsulation_info").get("vlan")
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
,
394 work_cps
[cp_name
] = add_cp
396 self
.logger
.warning("cp service_endpoint_id : {} has no vlan, ignore".format(service_endpoint_id
))
398 # add service_endpoint_id to list
399 service_endpoint_ids
= add_cp
["service_endpoint_ids"]
400 service_endpoint_ids
.append(service_endpoint_id
)
402 # 2 - Obtain free VNI
403 vni
= self
._generate
_vni
()
404 self
.logger
.debug("VNI: {}".format(vni
))
406 # 3 - Create virtual network (name, VNI, RT), by the moment the name will use VNI
408 while retry
< self
._max
_duplicate
_retry
:
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
)
414 except DuplicateFound
as e
:
415 self
.logger
.debug("Duplicate error for vnet_name: {}".format(vnet_name
))
416 self
.used_vni
.add(vni
)
418 if retry
>= self
._max
_duplicate
_retry
:
421 # Try to obtain a new vni
422 vni
= self
._generate
_vni
()
429 "connection_points": work_cps
# dict with port_name as key
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
441 self
.logger
.info("created connectivity service, uuid: {}, name: {}".format(vnet_id
, vnet_name
))
442 return vnet_id
, conn_info
444 except Exception as e
:
446 if isinstance(e
, SdnConnectorError
) or isinstance(e
, HttpException
):
447 self
.logger
.error("Error creating connectivity service: {}".format(e
))
449 self
.logger
.error("Error creating connectivity service: {}".format(e
), exc_info
=True)
452 # If nothing is created raise error else return what has been created and mask as error
454 raise SdnConnectorError("Exception create connectivity service: {}".format(str(e
)))
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
464 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
466 Disconnect multi-site endpoints previously connected
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
472 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
474 self
.logger
.info("delete_connectivity_service vnet_name: {}, connection_points: {}".
475 format(service_uuid
, conn_info
))
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"]
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"))
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
:
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
)))
500 def edit_connectivity_service(self
, service_uuid
, conn_info
= None, connection_points
= None, **kwargs
):
501 """ Change an existing connectivity service.
503 This method's arguments and return value follow the same convention as
504 :meth:`~.create_connectivity_service`.
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).
516 SdnConnectorException: In case of error.
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
525 self
.logger
.info("edit connectivity service, service_uuid: {}, conn_info: {}, "
526 "connection points: {} ".format(service_uuid
, conn_info
, connection_points
))
528 # conn_info should always exist and have connection_points and vnet elements
529 old_cp
= conn_info
.get("connection_points", {})
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
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
))
544 for port
in deleted_ports
:
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
))
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
))
560 if connection_points
:
562 # Check and obtain what should be added and deleted, if there is an error here raise an exception
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
)
574 vlan
= cp
.get("service_endpoint_encapsulation_info").get("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
,
582 work_cps
[cp_name
] = add_cp
584 self
.logger
.warning("cp service_endpoint_id : {} has no vlan, ignore".
585 format(service_endpoint_id
))
587 # add service_endpoint_id to list
588 service_endpoint_ids
= add_cp
["service_endpoint_ids"]
589 service_endpoint_ids
.append(service_endpoint_id
)
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
))
598 # Obtain network (check it is correctly created)
599 vnet
= self
.underlay_api
.get_virtual_network(service_uuid
)
601 vnet_name
= vnet
["name"]
603 raise SdnConnectorError("vnet uuid: {} not found".format(service_uuid
))
605 except SdnConnectorError
:
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
)))
611 # Delete unneeded ports and add new ones: if there is an error return conn_info
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
617 # Delete unneeded 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
)
629 for port_name
in deleted_ports
:
630 del conn_info_cp
[port_name
]
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
)
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"]
647 conn_info
["connection_points"] = conn_info_cp
650 except Exception as e
:
652 if isinstance(e
, SdnConnectorError
) or isinstance(e
, HttpException
):
653 self
.logger
.error("Error edit connectivity service: {}".format(e
), exc_info
=True)
655 self
.logger
.error("Error edit connectivity service: {}".format(e
))
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"
663 for port_name
, cp
in work_cps
.items():
664 curr_cp
= conn_info_cp
.get(port_name
)
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"]
671 conn_info
["sdn_status"] = "ERROR"
672 conn_info
["sdn_info"] = repr(e
)
673 conn_info
["connection_points"] = conn_info_cp
677 # Connection points have not changed, so do nothing
678 self
.logger
.info("no new connection_points provided, nothing to be done")
682 if __name__
== '__main__':
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
)
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
))
702 juniper_contrail
= JuniperContrail(wim
=wim
, wim_account
=wim_account
, config
=config
, logger
=logger
)
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
)
713 vni
= juniper_contrail
._generate
_vni
()
714 juniper_contrail
.used_vni
.add(vni
)
715 print(juniper_contrail
.used_vni
)
718 # 0. Check credentials
719 print('0. Check credentials')
720 #juniper_contrail.check_credentials()
722 # 1 - Create and delete connectivity service
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",
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",
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",
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",
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))
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))
777 logger
.debug("Delete connectivity service 1")
778 juniper_contrail
.delete_connectivity_service(service_id
, conn_info
)
779 logger
.debug("Delete Ok")
781 logger
.debug("Delete connectivity service 2")
782 juniper_contrail
.delete_connectivity_service(service_id2
, conn_info2
)
783 logger
.debug("Delete Ok")