1 # -*- coding: utf-8 -*-
3 # Copyright 2019 Atos - CoE Telco NFV Team
6 # Contributors: Oscar Luis Peral, Atos
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact with: <oscarluis.peral@atos.net>
23 # Neither the name of Atos nor the names of its
24 # contributors may be used to endorse or promote products derived from
25 # this software without specific prior written permission.
27 # This work has been performed in the context of Arista Telefonica OSM PoC.
29 from osm_ro_plugin
.sdnconn
import SdnConnectorBase
, SdnConnectorError
32 # Required by compare function
34 # Library that uses Levenshtein Distance to calculate the differences
36 # from fuzzywuzzy import fuzz
41 from requests
import RequestException
, ConnectionError
, ConnectTimeout
, Timeout
42 from cvprac
.cvp_client
import CvpClient
43 from cvprac
.cvp_api
import CvpApi
44 from cvprac
.cvp_client_errors
import CvpLoginError
, CvpSessionLogOutError
, CvpApiError
45 from cvprac
import __version__
as cvprac_version
47 from osm_rosdn_arista_cloudvision
.aristaConfigLet
import AristaSDNConfigLet
48 from osm_rosdn_arista_cloudvision
.aristaTask
import AristaCVPTask
52 UNREACHABLE
= 'Unable to reach the WIM url, connect error.',
53 TIMEOUT
= 'Unable to reach the WIM url, timeout.',
55 'VLAN value inconsistent between the connection points',
56 VLAN_NOT_PROVIDED
= 'VLAN value not provided',
57 CONNECTION_POINTS_SIZE
= \
58 'Unexpected number of connection points: 2 expected.',
59 ENCAPSULATION_TYPE
= \
60 'Unexpected service_endpoint_encapsulation_type. ' \
61 'Only "dotq1" is accepted.',
62 BANDWIDTH
= 'Unable to get the bandwidth.',
63 STATUS
= 'Unable to get the status for the service.',
64 DELETE
= 'Unable to delete service.',
65 CLEAR_ALL
= 'Unable to clear all the services',
66 UNKNOWN_ACTION
= 'Unknown action invoked.',
67 BACKUP
= 'Unable to get the backup parameter.',
68 UNSUPPORTED_FEATURE
= "Unsupported feature",
69 UNAUTHORIZED
= "Failed while authenticating",
70 INTERNAL_ERROR
= "Internal error"
73 class AristaSdnConnector(SdnConnectorBase
):
74 """Arista class for the SDN connectors
77 wim (dict): WIM record, as stored in the database
78 wim_account (dict): WIM account record, as stored in the database
80 The arguments of the constructor are converted to object attributes.
81 An extra property, ``service_endpoint_mapping`` is created from ``config``.
83 The access to Arista CloudVision is made through the API defined in
84 https://github.com/aristanetworks/cvprac
85 The a connectivity service consist in creating a VLAN and associate the interfaces
86 of the connection points MAC addresses to this VLAN in all the switches of the topology,
87 the BDP is also configured for this VLAN.
89 The Arista Cloud Vision API workflow is the following
90 -- The switch configuration is defined as a set of switch configuration commands,
91 what is called 'ConfigLet'
92 -- The ConfigLet is associated to the device (leaf switch)
93 -- Automatically a task is associated to this activity for change control, the task
94 in this stage is in 'Pending' state
95 -- The task will be executed so that the configuration is applied to the switch.
96 -- The service information is saved in the response of the creation call
97 -- All created services identification is stored in a generic ConfigLet 'OSM_metadata'
98 to keep track of the managed resources by OSM in the Arista deployment.
100 __supported_service_types
= ["ELINE (L2)", "ELINE", "ELAN"]
101 __service_types_ELAN
= "ELAN"
102 __service_types_ELINE
= "ELINE"
103 __ELINE_num_connection_points
= 2
104 __supported_service_types
= ["ELINE", "ELAN"]
105 __supported_encapsulation_types
= ["dot1q"]
106 __WIM_LOGGER
= 'openmano.sdnconn.arista'
107 __SERVICE_ENDPOINT_MAPPING
= 'service_endpoint_mapping'
108 __ENCAPSULATION_TYPE_PARAM
= "service_endpoint_encapsulation_type"
109 __ENCAPSULATION_INFO_PARAM
= "service_endpoint_encapsulation_info"
110 __BACKUP_PARAM
= "backup"
111 __BANDWIDTH_PARAM
= "bandwidth"
112 __SERVICE_ENDPOINT_PARAM
= "service_endpoint_id"
114 __WAN_SERVICE_ENDPOINT_PARAM
= "service_endpoint_id"
115 __WAN_MAPPING_INFO_PARAM
= "service_mapping_info"
116 __DEVICE_ID_PARAM
= "device_id"
117 __DEVICE_INTERFACE_ID_PARAM
= "device_interface_id"
118 __SW_ID_PARAM
= "switch_dpid"
119 __SW_PORT_PARAM
= "switch_port"
120 __VLAN_PARAM
= "vlan"
123 __MANAGED_BY_OSM
= '## Managed by OSM '
124 __OSM_PREFIX
= "osm_"
125 __OSM_METADATA
= "OSM_metadata"
126 __METADATA_PREFIX
= '!## Service'
127 __EXC_TASK_EXEC_WAIT
= 10
128 __ROLLB_TASK_EXEC_WAIT
= 10
129 __API_REQUEST_TOUT
= 60
130 __SWITCH_TAG_NAME
= 'topology_type'
131 __SWITCH_TAG_VALUE
= 'leaf'
132 __LOOPBACK_INTF
= "Loopback0"
135 _VLAN_MLAG
= "VLAN-MLAG"
136 _VXLAN_MLAG
= "VXLAN-MLAG"
138 def __init__(self
, wim
, wim_account
, config
=None, logger
=None):
141 :param wim: (dict). Contains among others 'wim_url'
142 :param wim_account: (dict). Contains among others 'uuid' (internal id), 'name',
143 'sdn' (True if is intended for SDN-assist or False if intended for WIM), 'user', 'password'.
144 :param config: (dict or None): Particular information of plugin. These keys if present have a common meaning:
145 'mapping_not_needed': (bool) False by default or if missing, indicates that mapping is not needed.
146 'service_endpoint_mapping': (list) provides the internal endpoint mapping. The meaning is:
147 KEY meaning for WIM meaning for SDN assist
148 -------- -------- --------
149 device_id pop_switch_dpid compute_id
150 device_interface_id pop_switch_port compute_pci_address
151 service_endpoint_id wan_service_endpoint_id SDN_service_endpoint_id
152 service_mapping_info wan_service_mapping_info SDN_service_mapping_info
153 contains extra information if needed. Text in Yaml format
154 switch_dpid wan_switch_dpid SDN_switch_dpid
155 switch_port wan_switch_port SDN_switch_port
156 datacenter_id vim_account vim_account
157 id: (internal, do not use)
158 wim_id: (internal, do not use)
159 :param logger (logging.Logger): optional logger object. If none is passed 'openmano.sdn.sdnconn' is used.
161 self
.__regex
= re
.compile(
162 r
'^(?:http|ftp)s?://' # http:// or https://
163 r
'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
164 r
'localhost|' # localhost...
165 r
'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
166 r
'(?::\d+)?', re
.IGNORECASE
) # optional port
167 self
.raiseException
= True
168 self
.logger
= logger
or logging
.getLogger(self
.__WIM
_LOGGER
)
169 super().__init
__(wim
, wim_account
, config
, self
.logger
)
171 self
.__wim
_account
= wim_account
172 self
.__config
= config
173 if self
.is_valid_destination(self
.__wim
.get("wim_url")):
174 self
.__wim
_url
= self
.__wim
.get("wim_url")
176 raise SdnConnectorError(message
='Invalid wim_url value',
178 self
.__user
= wim_account
.get("user")
179 self
.__passwd
= wim_account
.get("password")
181 self
.cvp_inventory
= None
183 self
.logger
.debug("Arista SDN plugin {}, cvprac version {}, user:{} and config:{}".
184 format(wim
, cvprac_version
, self
.__user
,
185 self
.delete_keys_from_dict(config
, ('passwd',))))
186 self
.allDeviceFacts
= []
189 self
.__load
_topology
()
190 self
.__load
_switches
()
191 except (ConnectTimeout
, Timeout
) as ct
:
192 raise SdnConnectorError(message
=SdnError
.TIMEOUT
+ " " + str(ct
), http_code
=408)
193 except ConnectionError
as ce
:
194 raise SdnConnectorError(message
=SdnError
.UNREACHABLE
+ " " + str(ce
), http_code
=404)
195 except SdnConnectorError
as sc
:
197 except CvpLoginError
as le
:
198 raise SdnConnectorError(message
=le
.msg
, http_code
=500) from le
199 except Exception as e
:
200 raise SdnConnectorError(message
="Unable to load switches from CVP" + " " + str(e
),
201 http_code
=500) from e
202 self
.logger
.debug("Using topology {} in Arista Leaf switches: {}".format(
204 self
.delete_keys_from_dict(self
.switches
, ('passwd',))))
205 self
.clC
= AristaSDNConfigLet(self
.topology
)
207 def __load_topology(self
):
208 self
.topology
= self
._VXLAN
_MLAG
209 if self
.__config
and self
.__config
.get('topology'):
210 topology
= self
.__config
.get('topology')
211 if topology
== "VLAN":
212 self
.topology
= self
._VLAN
213 elif topology
== "VXLAN":
214 self
.topology
= self
._VXLAN
215 elif topology
== "VLAN-MLAG":
216 self
.topology
= self
._VLAN
_MLAG
217 elif topology
== "VXLAN-MLAG":
218 self
.topology
= self
._VXLAN
_MLAG
220 def __load_switches(self
):
221 """ Retrieves the switches to configure in the following order
222 1. from incoming configuration:
223 1.1 using port mapping
224 using user and password from WIM
225 retrieving Lo0 and AS from switch
226 1.2 from 'switches' parameter,
227 if any parameter is not present
228 Lo0 and AS - it will be requested to the switch
229 2. Looking in the CloudVision inventory if not in configuration parameters
230 2.1 using the switches with the topology_type tag set to 'leaf'
232 All the search methods will be used
235 if self
.__config
and self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
236 for port
in self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
237 switch_dpid
= port
.get(self
.__SW
_ID
_PARAM
)
238 if switch_dpid
and switch_dpid
not in self
.switches
:
239 self
.switches
[switch_dpid
] = {'passwd': self
.__passwd
,
244 'serialNumber': None,
245 'mlagPeerDevice': None}
247 if self
.__config
and self
.__config
.get('switches'):
248 # Not directly from json, complete one by one
249 config_switches
= self
.__config
.get('switches')
250 for cs
, cs_content
in config_switches
.items():
251 if cs
not in self
.switches
:
252 self
.switches
[cs
] = {'passwd': self
.__passwd
,
257 'serialNumber': None,
258 'mlagPeerDevice': None}
260 self
.switches
[cs
].update(cs_content
)
262 # Load the rest of the data
263 if self
.client
is None:
264 self
.client
= self
.__connect
()
265 self
.__load
_inventory
()
266 if not self
.switches
:
267 self
.__get
_tags
(self
.__SWITCH
_TAG
_NAME
, self
.__SWITCH
_TAG
_VALUE
)
268 for device
in self
.allDeviceFacts
:
269 # get the switches whose topology_tag is 'leaf'
270 if device
['serialNumber'] in self
.cvp_tags
:
271 if not self
.switches
.get(device
['hostname']):
272 switch_data
= {'passwd': self
.__passwd
,
273 'ip': device
['ipAddress'],
277 'serialNumber': None,
278 'mlagPeerDevice': None}
279 self
.switches
[device
['hostname']] = switch_data
280 if len(self
.switches
) == 0:
281 self
.logger
.error("Unable to load Leaf switches from CVP")
284 # self.switches are switch objects, one for each switch in self.switches,
285 # used to make eAPI calls by using switch.py module
286 for s
in self
.switches
:
287 for device
in self
.allDeviceFacts
:
288 if device
['hostname'] == s
:
289 if not self
.switches
[s
].get('ip'):
290 self
.switches
[s
]['ip'] = device
['ipAddress']
291 self
.switches
[s
]['serialNumber'] = device
['serialNumber']
294 # Each switch has a different loopback address,
295 # so it's a different configLet
296 if not self
.switches
[s
].get('lo0'):
297 inf
= self
.__get
_interface
_ip
(self
.switches
[s
]['serialNumber'], self
.__LOOPBACK
_INTF
)
298 self
.switches
[s
]["lo0"] = inf
.split('/')[0]
299 if not self
.switches
[s
].get('AS'):
300 self
.switches
[s
]["AS"] = self
.__get
_device
_ASN
(self
.switches
[s
]['serialNumber'])
301 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VLAN
_MLAG
):
302 for s
in self
.switches
:
303 if not self
.switches
[s
].get('mlagPeerDevice'):
304 self
.switches
[s
]['mlagPeerDevice'] = self
.__get
_peer
_MLAG
(self
.switches
[s
]['serialNumber'])
306 def __check_service(self
, service_type
, connection_points
,
307 check_vlan
=True, check_num_cp
=True, kwargs
=None):
308 """ Reviews the connection points elements looking for semantic errors in the incoming data
310 if service_type
not in self
.__supported
_service
_types
:
311 raise Exception("The service '{}' is not supported. Only '{}' are accepted".format(
313 self
.__supported
_service
_types
))
316 if len(connection_points
) < 2:
317 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
318 if (len(connection_points
) != self
.__ELINE
_num
_connection
_points
and
319 service_type
== self
.__service
_types
_ELINE
):
320 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
324 for cp
in connection_points
:
325 enc_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
327 enc_type
not in self
.__supported
_encapsulation
_types
):
328 raise Exception(SdnError
.ENCAPSULATION_TYPE
)
329 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
330 cp_vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
334 elif vlan_id
!= cp_vlan_id
:
335 raise Exception(SdnError
.VLAN_INCONSISTENT
)
337 raise Exception(SdnError
.VLAN_NOT_PROVIDED
)
338 if vlan_id
in self
.__get
_srvVLANs
():
339 raise Exception('VLAN {} already assigned to a connectivity service'.format(vlan_id
))
341 # Commented out for as long as parameter isn't implemented
342 # bandwidth = kwargs.get(self.__BANDWIDTH_PARAM)
343 # if not isinstance(bandwidth, int):
344 # self.__exception(SdnError.BANDWIDTH, http_code=400)
346 # Commented out for as long as parameter isn't implemented
347 # backup = kwargs.get(self.__BACKUP_PARAM)
348 # if not isinstance(backup, bool):
349 # self.__exception(SdnError.BACKUP, http_code=400)
351 def check_credentials(self
):
352 """Retrieves the CloudVision version information, as the easiest way
353 for testing the access to CloudVision API
356 if self
.client
is None:
357 self
.client
= self
.__connect
()
358 result
= self
.client
.api
.get_cvp_info()
359 self
.logger
.debug(result
)
360 except CvpLoginError
as e
:
361 self
.logger
.info(str(e
))
363 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
364 http_code
=401) from e
365 except Exception as ex
:
367 self
.logger
.error(str(ex
))
368 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
+ " " + str(ex
),
369 http_code
=500) from ex
371 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
372 """Monitor the status of the connectivity service established
374 service_uuid (str): UUID of the connectivity service
375 conn_info (dict or None): Information returned by the connector
376 during the service creation/edition and subsequently stored in
380 dict: JSON/YAML-serializable dict that contains a mandatory key
381 ``sdn_status`` associated with one of the following values::
383 {'sdn_status': 'ACTIVE'}
384 # The service is up and running.
386 {'sdn_status': 'INACTIVE'}
387 # The service was created, but the connector
388 # cannot determine yet if connectivity exists
389 # (ideally, the caller needs to wait and check again).
391 {'sdn_status': 'DOWN'}
392 # Connection was previously established,
393 # but an error/failure was detected.
395 {'sdn_status': 'ERROR'}
396 # An error occurred when trying to create the service/
397 # establish the connectivity.
399 {'sdn_status': 'BUILD'}
400 # Still trying to create the service, the caller
401 # needs to wait and check again.
403 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
404 keys can be used to provide additional status explanation or
405 new information available for the connectivity service.
408 self
.logger
.debug("invoked get_connectivity_service_status '{}'".format(service_uuid
))
410 raise SdnConnectorError(message
='No connection service UUID',
413 self
.__get
_Connection
()
414 if conn_info
is None:
415 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
418 if 'configLetPerSwitch' in conn_info
.keys():
422 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
423 conn_info
['service_type'],
424 conn_info
['vlan_id'],
427 t_isCancelled
= False
431 for s
in self
.switches
:
432 if len(cls_perSw
[s
]) > 0:
433 for cl
in cls_perSw
[s
]:
434 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
435 # Added protection to check that 'note' exists and additionally
436 # verify that it is managed by OSM
437 if (not cls_perSw
[s
][0]['config'] or
438 not cl
.get('note') or
439 self
.__MANAGED
_BY
_OSM
not in cl
['note']):
442 t_id
= note
.split(self
.__SEPARATOR
)[1]
443 result
= self
.client
.api
.get_task_by_id(t_id
)
444 if result
['workOrderUserDefinedStatus'] == 'Completed':
446 elif result
['workOrderUserDefinedStatus'] == 'Cancelled':
448 elif result
['workOrderUserDefinedStatus'] == 'Failed':
452 failed_switches
.append(s
)
454 error_msg
= 'Some works were cancelled in switches: {}'.format(str(failed_switches
))
457 error_msg
= 'Some works failed in switches: {}'.format(str(failed_switches
))
460 error_msg
= 'Some works are still under execution in switches: {}'.format(str(failed_switches
))
464 sdn_status
= 'ACTIVE'
466 return {'sdn_status': sdn_status
,
467 'error_msg': error_msg
,
468 'sdn_info': sdn_info
}
469 except CvpLoginError
as e
:
470 self
.logger
.info(str(e
))
472 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
473 http_code
=401) from e
474 except Exception as ex
:
476 self
.logger
.error(str(ex
), exc_info
=True)
477 raise SdnConnectorError(message
=str(ex
) + " " + str(ex
),
478 http_code
=500) from ex
480 def create_connectivity_service(self
, service_type
, connection_points
,
482 """Stablish SDN/WAN connectivity between the endpoints
484 (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
485 :param connection_points: (list): each point corresponds to
486 an entry point to be connected. For WIM: from the DC
487 to the transport network.
488 For SDN: Compute/PCI to the transport network. One
489 connection point serves to identify the specific access and
490 some other service parameters, such as encapsulation type.
491 Each item of the list is a dict with:
492 "service_endpoint_id": (str)(uuid) Same meaning that for
493 'service_endpoint_mapping' (see __init__)
494 In case the config attribute mapping_not_needed is True,
495 this value is not relevant. In this case
496 it will contain the string "device_id:device_interface_id"
497 "service_endpoint_encapsulation_type": None, "dot1q", ...
498 "service_endpoint_encapsulation_info": (dict) with:
499 "vlan": ..., (int, present if encapsulation is dot1q)
500 "vni": ... (int, present if encapsulation is vxlan),
501 "peers": [(ipv4_1), (ipv4_2)] (present if
502 encapsulation is vxlan)
504 "device_id": ..., same meaning that for
505 'service_endpoint_mapping' (see __init__)
506 "device_interface_id": same meaning that for
507 'service_endpoint_mapping' (see __init__)
508 "switch_dpid": ..., present if mapping has been found
509 for this device_id,device_interface_id
510 "switch_port": ... present if mapping has been found
511 for this device_id,device_interface_id
512 "service_mapping_info": present if mapping has
513 been found for this device_id,device_interface_id
514 :param kwargs: For future versions:
515 bandwidth (int): value in kilobytes
516 latency (int): value in milliseconds
517 Other QoS might be passed as keyword arguments.
518 :return: tuple: ``(service_id, conn_info)`` containing:
519 - *service_uuid* (str): UUID of the established
521 - *conn_info* (dict or None): Information to be
522 stored at the database (or ``None``).
523 This information will be provided to the
524 :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
525 **MUST** be JSON/YAML-serializable (plain data structures).
526 :raises: SdnConnectorError: In case of error. Nothing should be
527 created in this case.
528 Provide the parameter http_code
531 self
.logger
.debug("invoked create_connectivity_service '{}' ports: {}".
532 format(service_type
, connection_points
))
533 self
.__get
_Connection
()
534 self
.__check
_service
(service_type
,
538 service_uuid
= str(uuid
.uuid4())
540 self
.logger
.info("Service with uuid {} created.".
541 format(service_uuid
))
542 s_uid
, s_connInf
= self
.__processConnection
(
548 self
.__addMetadata
(s_uid
, service_type
, s_connInf
['vlan_id'])
552 return (s_uid
, s_connInf
)
553 except CvpLoginError
as e
:
554 self
.logger
.info(str(e
))
556 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
557 http_code
=401) from e
558 except SdnConnectorError
as sde
:
560 except ValueError as err
:
562 self
.logger
.error(str(err
), exc_info
=True)
563 raise SdnConnectorError(message
=str(err
),
564 http_code
=500) from err
565 except Exception as ex
:
567 self
.logger
.error(str(ex
), exc_info
=True)
568 if self
.raiseException
:
570 raise SdnConnectorError(message
=str(ex
),
571 http_code
=500) from ex
573 def __processConnection(self
,
579 Invoked from creation and edit methods
581 Process the connection points array,
582 creating a set of configuration per switch where it has to be applied
583 for creating the configuration, the switches have to be queried for obtaining:
584 - the loopback address
585 - the BGP ASN (autonomous system number)
586 - the interface name of the MAC address to add in the connectivity service
587 Once the new configuration is ready, the __updateConnection method is invoked for appling the changes
593 for s
in self
.switches
:
596 vlan_processed
= False
599 processed_connection_points
= []
600 for cp
in connection_points
:
602 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
603 if not vlan_processed
:
604 vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
607 vni_id
= encap_info
.get(self
.__VNI
_PARAM
)
609 vni_id
= str(10000 + int(vlan_id
))
611 if service_type
== self
.__service
_types
_ELAN
:
612 cl_vlan
= self
.clC
.getElan_vlan(service_uuid
,
616 cl_vlan
= self
.clC
.getEline_vlan(service_uuid
,
619 vlan_processed
= True
621 encap_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
622 switch_id
= encap_info
.get(self
.__SW
_ID
_PARAM
)
623 interface
= encap_info
.get(self
.__SW
_PORT
_PARAM
)
624 switches
= [{'name': switch_id
, 'interface': interface
}]
626 # remove those connections that are equal. This happens when several sriovs are located in the same
627 # compute node interface, that is, in the same switch and interface
628 switches
= [x
for x
in switches
if x
not in processed_connection_points
]
631 processed_connection_points
+= switches
632 for switch
in switches
:
634 raise SdnConnectorError(
635 message
="Connection point switch port empty for switch_dpid {}".format(switch_id
),
637 # it should be only one switch where the mac is attached
638 if encap_type
== 'dot1q':
639 # SRIOV configLet for Leaf switch mac's attached to
640 if service_type
== self
.__service
_types
_ELAN
:
641 cl_encap
= self
.clC
.getElan_sriov(service_uuid
, interface
, vlan_id
, i
)
643 cl_encap
= self
.clC
.getEline_sriov(service_uuid
, interface
, vlan_id
, i
)
645 # PT configLet for Leaf switch attached to the mac
646 if service_type
== self
.__service
_types
_ELAN
:
647 cl_encap
= self
.clC
.getElan_passthrough(service_uuid
,
651 cl_encap
= self
.clC
.getEline_passthrough(service_uuid
,
654 if cls_cp
.get(switch
['name']):
655 cls_cp
[switch
['name']] = str(cls_cp
[switch
['name']]) + cl_encap
657 cls_cp
[switch
['name']] = cl_encap
659 # at least 1 connection point has to be received
660 if not vlan_processed
:
661 raise SdnConnectorError(message
=SdnError
.UNSUPPORTED_FEATURE
,
664 for s
in self
.switches
:
665 # for cl in cp_configLets:
666 cl_name
= (self
.__OSM
_PREFIX
+
668 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
669 self
.__SEPARATOR
+ service_uuid
)
671 # Apply BGP configuration only for VXLAN topologies
672 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VXLAN
):
673 if service_type
== self
.__service
_types
_ELAN
:
674 cl_bgp
[s
] = self
.clC
.getElan_bgp(service_uuid
,
677 self
.switches
[s
]['lo0'],
678 self
.switches
[s
]['AS'])
680 cl_bgp
[s
] = self
.clC
.getEline_bgp(service_uuid
,
683 self
.switches
[s
]['lo0'],
684 self
.switches
[s
]['AS'])
688 if not cls_cp
.get(s
):
689 # Apply VLAN configuration to peer MLAG switch,
690 # only necessary when there are no connection points in the switch
691 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VLAN
_MLAG
):
692 for p
in self
.switches
:
693 if self
.switches
[p
]['mlagPeerDevice'] == s
:
695 if self
.topology
== self
._VXLAN
_MLAG
:
696 cl_config
= str(cl_vlan
) + str(cl_bgp
[s
])
698 cl_config
= str(cl_vlan
)
700 cl_config
= str(cl_vlan
) + str(cl_bgp
[s
]) + str(cls_cp
[s
])
702 cls_perSw
[s
] = [{'name': cl_name
, 'config': cl_config
}]
704 allLeafConfigured
, allLeafModified
= self
.__updateConnection
(cls_perSw
)
707 "uuid": service_uuid
,
709 "service_type": service_type
,
711 "connection_points": connection_points
,
712 "configLetPerSwitch": cls_perSw
,
713 'allLeafConfigured': allLeafConfigured
,
714 'allLeafModified': allLeafModified
}
716 return service_uuid
, conn_info
717 except Exception as ex
:
718 self
.logger
.debug("Exception processing connection {}: {}".
719 format(service_uuid
, str(ex
)))
722 def __updateConnection(self
, cls_perSw
):
723 """ Invoked in the creation and modification
725 checks if the new connection points config is:
726 - already in the Cloud Vision, the configLet is modified, and applied to the switch,
727 executing the corresponding task
728 - if it has to be removed:
729 then configuration has to be removed from the switch executing the corresponding task,
730 before trying to remove the configuration
731 - created, the configuration set is created, associated to the switch, and the associated
732 task to the configLet modification executed
733 In case of any error, rollback is executed, removing the created elements, and restoring to the
737 allLeafConfigured
= {}
740 for s
in self
.switches
:
741 allLeafConfigured
[s
] = False
742 allLeafModified
[s
] = False
744 for s
in self
.switches
:
745 toDelete_in_cvp
= False
746 if not (cls_perSw
.get(s
) and cls_perSw
[s
][0].get('config')):
747 # when there is no configuration, means that there is no interface
748 # in the switch to be connected, so the configLet has to be removed from CloudVision
749 # after removing the ConfigLet from the switch if it was already there
751 # get config let name and key
754 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
[0]['name'])
756 cl_toDelete
.append(cvp_cl
)
758 toDelete_in_cvp
= True
759 except CvpApiError
as error
:
760 if "Entity does not exist" in error
.msg
:
764 # remove configLet from device
766 res
= self
.__configlet
_modify
(cls_perSw
[s
])
767 allLeafConfigured
[s
] = res
[0]
768 if not allLeafConfigured
[s
]:
771 res
= self
.__device
_modify
(
774 delete
=toDelete_in_cvp
)
775 if "errorMessage" in str(res
):
776 raise Exception(str(res
))
777 self
.logger
.info("Device {} modify result {}".format(s
, res
))
778 for t_id
in res
[1]['tasks']:
779 if not toDelete_in_cvp
:
780 note_msg
= "{}{}{}{}##".format(self
.__MANAGED
_BY
_OSM
,
784 self
.client
.api
.add_note_to_configlet(
785 cls_perSw
[s
][0]['key'],
787 cls_perSw
[s
][0]['note'] = note_msg
788 tasks
= {t_id
: {'workOrderId': t_id
}}
789 self
.__exec
_task
(tasks
, self
.__EXC
_TASK
_EXEC
_WAIT
)
790 # with just one configLet assigned to a device,
791 # delete all if there are errors in next loops
792 if not toDelete_in_cvp
:
793 allLeafModified
[s
] = True
794 if len(cl_toDelete
) > 0:
795 self
.__configlet
_modify
(cl_toDelete
, delete
=True)
797 return allLeafConfigured
, allLeafModified
798 except Exception as ex
:
800 self
.__rollbackConnection
(cls_perSw
,
803 except Exception as e
:
804 self
.logger
.error("Exception rolling back in updating connection: {}".
805 format(e
), exc_info
=True)
808 def __rollbackConnection(self
,
812 """ Removes the given configLet from the devices and then remove the configLets
814 for s
in self
.switches
:
815 if allLeafModified
[s
]:
817 res
= self
.__device
_modify
(
819 new_configlets
=cls_perSw
[s
],
821 if "errorMessage" in str(res
):
822 raise Exception(str(res
))
824 for t_id
in res
[1]['tasks']:
825 tasks
[t_id
] = {'workOrderId': t_id
}
826 self
.__exec
_task
(tasks
)
827 self
.logger
.info("Device {} modify result {}".format(s
, res
))
828 except Exception as e
:
829 self
.logger
.error('Error removing configlets from device {}: {}'.format(s
, e
))
831 for s
in self
.switches
:
832 if allLeafConfigured
[s
]:
833 self
.__configlet
_modify
(cls_perSw
[s
], delete
=True)
835 def __exec_task(self
, tasks
, tout
=10):
836 if self
.taskC
is None:
838 data
= self
.taskC
.update_all_tasks(tasks
).values()
839 self
.taskC
.task_action(data
, tout
, 'executed')
841 def __device_modify(self
, device_to_update
, new_configlets
, delete
):
842 """ Updates the devices (switches) adding or removing the configLet,
843 the tasks Id's associated to the change are returned
845 self
.logger
.info('Enter in __device_modify delete: {}'.format(delete
))
848 # Task Ids that have been identified during device actions
851 if (len(new_configlets
) == 0 or
852 device_to_update
is None or
853 len(device_to_update
) == 0):
854 data
= {'updated': updated
, 'tasks': newTasks
}
855 return [changed
, data
]
857 self
.__load
_inventory
()
859 allDeviceFacts
= self
.allDeviceFacts
860 # Work through Devices list adding device specific information
862 for try_device
in allDeviceFacts
:
863 # Add Device Specific Configlets
864 # self.logger.debug(device)
865 if try_device
['hostname'] not in device_to_update
:
867 dev_cvp_configlets
= self
.client
.api
.get_configlets_by_device_id(
868 try_device
['systemMacAddress'])
869 # self.logger.debug(dev_cvp_configlets)
870 try_device
['deviceSpecificConfiglets'] = []
871 for cvp_configlet
in dev_cvp_configlets
:
872 if int(cvp_configlet
['containerCount']) == 0:
873 try_device
['deviceSpecificConfiglets'].append(
874 {'name': cvp_configlet
['name'],
875 'key': cvp_configlet
['key']})
876 # self.logger.debug(device)
880 # Check assigned configlets
881 device_update
= False
883 remove_configlets
= []
887 for cvp_configlet
in device
['deviceSpecificConfiglets']:
888 for cl
in new_configlets
:
889 if cvp_configlet
['name'] == cl
['name']:
890 remove_configlets
.append(cvp_configlet
)
893 for configlet
in new_configlets
:
894 if configlet
not in device
['deviceSpecificConfiglets']:
895 add_configlets
.append(configlet
)
898 update_devices
.append({'hostname': device
['hostname'],
899 'configlets': [add_configlets
,
902 self
.logger
.info("Device to modify: {}".format(update_devices
))
904 up_device
= update_devices
[0]
905 cl_toAdd
= up_device
['configlets'][0]
906 cl_toDel
= up_device
['configlets'][1]
909 if delete
and len(cl_toDel
) > 0:
910 r
= self
.client
.api
.remove_configlets_from_device(
916 self
.logger
.debug("remove_configlets_from_device {} {}".format(dev_action
, cl_toDel
))
917 elif len(cl_toAdd
) > 0:
918 r
= self
.client
.api
.apply_configlets_to_device(
924 self
.logger
.debug("apply_configlets_to_device {} {}".format(dev_action
, cl_toAdd
))
926 except Exception as error
:
927 errorMessage
= str(error
)
928 msg
= "errorMessage: Device {} Configlets couldnot be updated: {}".format(
929 up_device
['hostname'], errorMessage
)
930 raise SdnConnectorError(msg
) from error
932 if "errorMessage" in str(dev_action
):
933 m
= "Device {} Configlets update fail: {}".format(
934 up_device
['name'], dev_action
['errorMessage'])
935 raise SdnConnectorError(m
)
938 if 'taskIds' in str(dev_action
):
939 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
940 if not dev_action
['data']['taskIds']:
941 raise SdnConnectorError("No taskIds found: Device {} Configlets could not be updated".format(
942 up_device
['hostname']))
943 for taskId
in dev_action
['data']['taskIds']:
945 up_device
['hostname']: "Configlets-{}".format(taskId
)})
946 newTasks
.append(taskId
)
948 updated
.append({up_device
['hostname']:
949 "Configlets-No_Specific_Tasks"})
950 data
= {'updated': updated
, 'tasks': newTasks
}
951 return [changed
, data
]
953 def __configlet_modify(self
, configletsToApply
, delete
=False):
954 ''' adds/update or delete the provided configLets
955 :param configletsToApply: list of configLets to apply
956 :param delete: flag to indicate if the configLets have to be deleted
957 from Cloud Vision Portal
958 :return: data: dict of module actions and taskIDs
960 self
.logger
.info('Enter in __configlet_modify delete:{}'.format(
963 # Compare configlets against cvp_facts-configlets
970 for cl
in configletsToApply
:
977 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
['name'])
978 cl
['key'] = cvp_cl
['key']
979 cl
['note'] = cvp_cl
['note']
981 except CvpApiError
as error
:
982 if "Entity does not exist" in error
.msg
:
990 configlet
= {'name': cvp_cl
['name'],
994 cl_compare
= self
.__compare
(cl
['config'],
996 # compare function returns a floating point number
997 if cl_compare
[0] != 100.0:
999 configlet
= {'name': cl
['name'],
1001 'config': cl
['config']}
1004 configlet
= {'name': cl
['name'],
1005 'key': cvp_cl
['key'],
1007 'config': cl
['config']}
1010 configlet
= {'name': cl
['name'],
1011 'config': cl
['config']}
1014 operation
= 'delete'
1015 resp
= self
.client
.api
.delete_configlet(
1016 configlet
['data']['name'],
1017 configlet
['data']['key'])
1019 operation
= 'update'
1020 resp
= self
.client
.api
.update_configlet(
1021 configlet
['config'],
1022 configlet
['data']['key'],
1023 configlet
['data']['name'],
1026 operation
= 'create'
1027 resp
= self
.client
.api
.add_configlet(
1029 configlet
['config'])
1031 operation
= 'checked'
1033 except Exception as error
:
1034 errorMessage
= str(error
).split(':')[-1]
1035 message
= "Configlet {} cannot be {}: {}".format(
1036 cl
['name'], operation
, errorMessage
)
1038 deleted
.append({configlet
['name']: message
})
1040 updated
.append({configlet
['name']: message
})
1042 new
.append({configlet
['name']: message
})
1044 checked
.append({configlet
['name']: message
})
1047 if "error" in str(resp
).lower():
1048 message
= "Configlet {} cannot be deleted: {}".format(
1049 cl
['name'], resp
['errorMessage'])
1051 deleted
.append({configlet
['name']: message
})
1053 updated
.append({configlet
['name']: message
})
1055 new
.append({configlet
['name']: message
})
1057 checked
.append({configlet
['name']: message
})
1061 deleted
.append({configlet
['name']: "success"})
1064 updated
.append({configlet
['name']: "success"})
1067 cl
['key'] = resp
# This key is used in API call deviceApplyConfigLet FGA
1068 new
.append({configlet
['name']: "success"})
1071 checked
.append({configlet
['name']: "success"})
1073 data
= {'new': new
, 'updated': updated
, 'deleted': deleted
, 'checked': checked
}
1074 return [changed
, data
]
1076 def __get_configletsDevices(self
, configlets
):
1077 for s
in self
.switches
:
1078 configlet
= configlets
[s
]
1079 # Add applied Devices
1080 if len(configlet
) > 0:
1081 configlet
['devices'] = []
1082 applied_devices
= self
.client
.api
.get_applied_devices(
1084 for device
in applied_devices
['data']:
1085 configlet
['devices'].append(device
['hostName'])
1087 def __get_serviceData(self
, service_uuid
, service_type
, vlan_id
, conn_info
=None):
1089 for s
in self
.switches
:
1092 srv_cls
= self
.__get
_serviceConfigLets
(service_uuid
,
1095 self
.__get
_configletsDevices
(srv_cls
)
1096 for s
in self
.switches
:
1099 for dev
in cl
['devices']:
1100 cls_perSw
[dev
].append(cl
)
1102 cls_perSw
= conn_info
['configLetPerSwitch']
1105 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
1107 Disconnect multi-site endpoints previously connected
1109 :param service_uuid: The one returned by create_connectivity_service
1110 :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
1111 if they do not return None
1113 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
1116 self
.logger
.debug('invoked delete_connectivity_service {}'.
1117 format(service_uuid
))
1118 if not service_uuid
:
1119 raise SdnConnectorError(message
='No connection service UUID',
1122 self
.__get
_Connection
()
1123 if conn_info
is None:
1124 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
1127 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
1128 conn_info
['service_type'],
1129 conn_info
['vlan_id'],
1131 allLeafConfigured
= {}
1132 allLeafModified
= {}
1133 for s
in self
.switches
:
1134 allLeafConfigured
[s
] = True
1135 allLeafModified
[s
] = True
1136 found_in_cvp
= False
1137 for s
in self
.switches
:
1141 self
.__rollbackConnection
(cls_perSw
,
1145 # if the service is not defined in Cloud Vision, return a 404 - NotFound error
1146 raise SdnConnectorError(message
='Service {} was not found in Arista Cloud Vision {}'.
1147 format(service_uuid
, self
.__wim
_url
),
1149 self
.__removeMetadata
(service_uuid
)
1150 except CvpLoginError
as e
:
1151 self
.logger
.info(str(e
))
1153 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
1154 http_code
=401) from e
1155 except SdnConnectorError
as sde
:
1157 except Exception as ex
:
1159 self
.logger
.error(ex
)
1160 if self
.raiseException
:
1162 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
+ " " + str(ex
),
1163 http_code
=500) from ex
1165 def __addMetadata(self
, service_uuid
, service_type
, vlan_id
):
1166 """ Adds the connectivity service from 'OSM_metadata' configLet
1168 found_in_cvp
= False
1170 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1172 except CvpApiError
as error
:
1173 if "Entity does not exist" in error
.msg
:
1178 new_serv
= '{} {} {} {}\n'.format(self
.__METADATA
_PREFIX
, service_type
, vlan_id
, service_uuid
)
1181 cl_config
= cvp_cl
['config'] + new_serv
1183 cl_config
= new_serv
1184 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1185 self
.__configlet
_modify
(cl_meta
)
1186 except Exception as e
:
1187 self
.logger
.error('Error in setting metadata in CloudVision from OSM for service {}: {}'.
1188 format(service_uuid
, str(e
)))
1191 def __removeMetadata(self
, service_uuid
):
1192 """ Removes the connectivity service from 'OSM_metadata' configLet
1194 found_in_cvp
= False
1196 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1198 except CvpApiError
as error
:
1199 if "Entity does not exist" in error
.msg
:
1205 if service_uuid
in cvp_cl
['config']:
1207 for line
in cvp_cl
['config'].split('\n'):
1208 if service_uuid
in line
:
1211 cl_config
= cl_config
+ line
1212 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1213 self
.__configlet
_modify
(cl_meta
)
1214 except Exception as e
:
1215 self
.logger
.error('Error in removing metadata in CloudVision from OSM for service {}: {}'.
1216 format(service_uuid
, str(e
)))
1219 def edit_connectivity_service(self
,
1222 connection_points
=None,
1224 """ Change an existing connectivity service.
1226 This method's arguments and return value follow the same convention as
1227 :meth:`~.create_connectivity_service`.
1229 :param service_uuid: UUID of the connectivity service.
1230 :param conn_info: (dict or None): Information previously returned
1231 by last call to create_connectivity_service
1232 or edit_connectivity_service
1233 :param connection_points: (list): If provided, the old list of
1234 connection points will be replaced.
1235 :param kwargs: Same meaning that create_connectivity_service
1236 :return: dict or None: Information to be updated and stored at
1238 When ``None`` is returned, no information should be changed.
1239 When an empty dict is returned, the database record will
1241 **MUST** be JSON/YAML-serializable (plain data structures).
1243 SdnConnectorError: In case of error.
1246 self
.logger
.debug('invoked edit_connectivity_service for service {}. ports: {}'.format(service_uuid
,
1249 if not service_uuid
:
1250 raise SdnConnectorError(message
='Unable to perform operation, missing or empty uuid',
1253 raise SdnConnectorError(message
='Unable to perform operation, missing or empty connection information',
1256 if connection_points
is None:
1259 self
.__get
_Connection
()
1261 cls_currentPerSw
= conn_info
['configLetPerSwitch']
1262 service_type
= conn_info
['service_type']
1264 self
.__check
_service
(service_type
,
1270 s_uid
, s_connInf
= self
.__processConnection
(
1275 self
.logger
.info("Service with uuid {} configuration updated".
1278 except CvpLoginError
as e
:
1279 self
.logger
.info(str(e
))
1281 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
1282 http_code
=401) from e
1283 except SdnConnectorError
as sde
:
1285 except Exception as ex
:
1288 # TODO check if there are pending task, and cancel them before restoring
1289 self
.__updateConnection
(cls_currentPerSw
)
1290 except Exception as e
:
1291 self
.logger
.error("Unable to restore configuration in service {} after an error in the configuration"
1292 " updated: {}".format(service_uuid
, str(e
)))
1293 if self
.raiseException
:
1295 raise SdnConnectorError(message
=str(ex
),
1296 http_code
=500) from ex
1298 def clear_all_connectivity_services(self
):
1299 """ Removes all connectivity services from Arista CloudVision with two steps:
1300 - retrives all the services from Arista CloudVision
1301 - removes each service
1304 self
.logger
.debug('invoked AristaImpl ' +
1305 'clear_all_connectivity_services')
1306 self
.__get
_Connection
()
1307 s_list
= self
.__get
_srvUUIDs
()
1310 conn_info
['service_type'] = serv
['type']
1311 conn_info
['vlan_id'] = serv
['vlan']
1313 self
.delete_connectivity_service(serv
['uuid'], conn_info
)
1314 except CvpLoginError
as e
:
1315 self
.logger
.info(str(e
))
1317 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
1318 http_code
=401) from e
1319 except SdnConnectorError
as sde
:
1321 except Exception as ex
:
1323 self
.logger
.error(ex
)
1324 if self
.raiseException
:
1326 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
+ " " + str(ex
),
1327 http_code
=500) from ex
1329 def get_all_active_connectivity_services(self
):
1330 """ Return the uuid of all the active connectivity services with two steps:
1331 - retrives all the services from Arista CloudVision
1332 - retrives the status of each server
1335 self
.logger
.debug('invoked AristaImpl {}'.format(
1336 'get_all_active_connectivity_services'))
1337 self
.__get
_Connection
()
1338 s_list
= self
.__get
_srvUUIDs
()
1342 conn_info
['service_type'] = serv
['type']
1343 conn_info
['vlan_id'] = serv
['vlan']
1345 status
= self
.get_connectivity_service_status(serv
['uuid'], conn_info
)
1346 if status
['sdn_status'] == 'ACTIVE':
1347 result
.append(serv
['uuid'])
1349 except CvpLoginError
as e
:
1350 self
.logger
.info(str(e
))
1352 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
+ " " + str(e
),
1353 http_code
=401) from e
1354 except SdnConnectorError
as sde
:
1356 except Exception as ex
:
1358 self
.logger
.error(ex
)
1359 if self
.raiseException
:
1361 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1362 http_code
=500) from ex
1364 def __get_serviceConfigLets(self
, service_uuid
, service_type
, vlan_id
):
1365 """ Return the configLet's associated with a connectivity service,
1366 There should be one, as maximum, per device (switch) for a given
1367 connectivity service
1370 for s
in self
.switches
:
1372 found_in_cvp
= False
1373 name
= (self
.__OSM
_PREFIX
+
1375 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
1376 self
.__SEPARATOR
+ service_uuid
)
1378 cvp_cl
= self
.client
.api
.get_configlet_by_name(name
)
1380 except CvpApiError
as error
:
1381 if "Entity does not exist" in error
.msg
:
1389 def __get_srvVLANs(self
):
1390 """ Returns a list with all the VLAN id's used in the connectivity services managed
1391 in tha Arista CloudVision by checking the 'OSM_metadata' configLet where this
1392 information is stored
1394 found_in_cvp
= False
1396 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1398 except CvpApiError
as error
:
1399 if "Entity does not exist" in error
.msg
:
1405 lines
= cvp_cl
['config'].split('\n')
1407 if self
.__METADATA
_PREFIX
in line
:
1408 s_vlan
= line
.split(' ')[3]
1411 if (s_vlan
is not None and
1413 s_vlan
not in s_vlan_list
):
1414 s_vlan_list
.append(s_vlan
)
1418 def __get_srvUUIDs(self
):
1419 """ Retrieves all the connectivity services, managed in tha Arista CloudVision
1420 by checking the 'OSM_metadata' configLet where this information is stored
1422 found_in_cvp
= False
1424 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1426 except CvpApiError
as error
:
1427 if "Entity does not exist" in error
.msg
:
1433 lines
= cvp_cl
['config'].split('\n')
1435 if self
.__METADATA
_PREFIX
in line
:
1436 line
= line
.split(' ')
1437 serv
= {'uuid': line
[4], 'type': line
[2], 'vlan': line
[3]}
1440 if (serv
is not None and
1442 serv
not in serv_list
):
1443 serv_list
.append(serv
)
1447 def __get_Connection(self
):
1448 """ Open a connection with Arista CloudVision,
1449 invoking the version retrival as test
1452 if self
.client
is None:
1453 self
.client
= self
.__connect
()
1454 self
.client
.api
.get_cvp_info()
1455 except (CvpSessionLogOutError
, RequestException
) as e
:
1456 self
.logger
.debug("Connection error '{}'. Reconnecting".format(e
))
1457 self
.client
= self
.__connect
()
1458 self
.client
.api
.get_cvp_info()
1460 def __connect(self
):
1461 ''' Connects to CVP device using user provided credentials from initialization.
1462 :return: CvpClient object with connection instantiated.
1464 client
= CvpClient()
1465 protocol
, _
, rest_url
= self
.__wim
_url
.rpartition("://")
1466 host
, _
, port
= rest_url
.partition(":")
1467 if port
and port
.endswith("/"):
1468 port
= int(port
[:-1])
1474 client
.connect([host
],
1477 protocol
=protocol
or "https",
1480 client
.api
= CvpApi(client
, request_timeout
=self
.__API
_REQUEST
_TOUT
)
1481 self
.taskC
= AristaCVPTask(client
.api
)
1484 def __compare(self
, fromText
, toText
, lines
=10):
1485 """ Compare text string in 'fromText' with 'toText' and produce
1486 diffRatio - a score as a float in the range [0, 1] 2.0*M / T
1487 T is the total number of elements in both sequences,
1488 M is the number of matches.
1489 Score - 1.0 if the sequences are identical, and
1490 0.0 if they have nothing in common.
1493 '- ' line unique to sequence 1
1494 '+ ' line unique to sequence 2
1495 ' ' line common to both sequences
1496 '? ' line not present in either input sequence
1498 fromlines
= fromText
.splitlines(1)
1499 tolines
= toText
.splitlines(1)
1500 diff
= list(difflib
.unified_diff(fromlines
, tolines
, n
=lines
))
1501 textComp
= difflib
.SequenceMatcher(None, fromText
, toText
)
1502 diffRatio
= round(textComp
.quick_ratio()*100, 2)
1503 return [diffRatio
, diff
]
1505 def __load_inventory(self
):
1506 """ Get Inventory Data for All Devices (aka switches) from the Arista CloudVision
1508 if not self
.cvp_inventory
:
1509 self
.cvp_inventory
= self
.client
.api
.get_inventory()
1510 self
.allDeviceFacts
= []
1511 for device
in self
.cvp_inventory
:
1512 self
.allDeviceFacts
.append(device
)
1514 def __get_tags(self
, name
, value
):
1515 if not self
.cvp_tags
:
1517 url
= '/api/v1/rest/analytics/tags/labels/devices/{}/value/{}/elements'.format(name
, value
)
1518 self
.logger
.debug('get_tags: URL {}'.format(url
))
1519 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1520 for dev
in data
['notifications']:
1521 for elem
in dev
['updates']:
1522 self
.cvp_tags
.append(elem
)
1523 self
.logger
.debug('Available devices with tag_name {} - value {}: {} '.format(name
, value
, self
.cvp_tags
))
1525 def __get_interface_ip(self
, device_id
, interface
):
1526 url
= '/api/v1/rest/{}/Sysdb/ip/config/ipIntfConfig/{}/'.format(device_id
, interface
)
1527 self
.logger
.debug('get_interface_ip: URL {}'.format(url
))
1530 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1531 if data
['notifications']:
1532 for notification
in data
['notifications']:
1533 for update
in notification
['updates']:
1534 if update
== 'addrWithMask':
1535 return notification
['updates'][update
]['value']
1536 except Exception as e
:
1537 raise SdnConnectorError("Invalid response from url {}: data {} - {}".format(url
, data
, str(e
)))
1538 raise SdnConnectorError("Unable to get ip for interface {} in device {}, data {}".
1539 format(interface
, device_id
, data
))
1541 def __get_device_ASN(self
, device_id
):
1542 url
= '/api/v1/rest/{}/Sysdb/routing/bgp/config/'.format(device_id
)
1543 self
.logger
.debug('get_device_ASN: URL {}'.format(url
))
1546 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1547 if data
['notifications']:
1548 for notification
in data
['notifications']:
1549 for update
in notification
['updates']:
1550 if update
== 'asNumber':
1551 return notification
['updates'][update
]['value']['value']['int']
1552 except Exception as e
:
1553 raise SdnConnectorError("Invalid response from url {}: data {} - {}".format(url
, data
, str(e
)))
1554 raise SdnConnectorError("Unable to get AS in device {}, data {}".format(device_id
, data
))
1556 def __get_peer_MLAG(self
, device_id
):
1558 url
= '/api/v1/rest/{}/Sysdb/mlag/status/'.format(device_id
)
1559 self
.logger
.debug('get_MLAG_status: URL {}'.format(url
))
1561 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1562 if data
['notifications']:
1564 for notification
in data
['notifications']:
1565 for update
in notification
['updates']:
1566 if update
== 'systemId':
1567 mlagSystemId
= notification
['updates'][update
]['value']
1572 # search the MLAG System Id
1574 for s
in self
.switches
:
1575 if self
.switches
[s
]['serialNumber'] == device_id
:
1577 url
= '/api/v1/rest/{}/Sysdb/mlag/status/'.format(self
.switches
[s
]['serialNumber'])
1578 self
.logger
.debug('Searching for MLAG system id {} in switch {}'.format(mlagSystemId
, s
))
1579 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1581 for notification
in data
['notifications']:
1582 for update
in notification
['updates']:
1583 if update
== 'systemId':
1584 if mlagSystemId
== notification
['updates'][update
]['value']:
1593 self
.logger
.error('No Peer device found for device {} with MLAG address {}'.format(device_id
,
1596 self
.logger
.debug('Peer MLAG for device {} - value {}'.format(device_id
, peer
))
1599 raise SdnConnectorError("Invalid response from url {}: data {}".format(url
, data
))
1601 def is_valid_destination(self
, url
):
1602 """ Check that the provided WIM URL is correct
1604 if re
.match(self
.__regex
, url
):
1606 elif self
.is_valid_ipv4_address(url
):
1609 return self
.is_valid_ipv6_address(url
)
1611 def is_valid_ipv4_address(self
, address
):
1612 """ Checks that the given IP is IPv4 valid
1615 socket
.inet_pton(socket
.AF_INET
, address
)
1616 except AttributeError: # no inet_pton here, sorry
1618 socket
.inet_aton(address
)
1619 except socket
.error
:
1621 return address
.count('.') == 3
1622 except socket
.error
: # not a valid address
1626 def is_valid_ipv6_address(self
, address
):
1627 """ Checks that the given IP is IPv6 valid
1630 socket
.inet_pton(socket
.AF_INET6
, address
)
1631 except socket
.error
: # not a valid address
1635 def delete_keys_from_dict(self
, dict_del
, lst_keys
):
1636 if dict_del
is None:
1638 dict_copy
= {k
: v
for k
, v
in dict_del
.items() if k
not in lst_keys
}
1639 for k
, v
in dict_copy
.items():
1640 if isinstance(v
, dict):
1641 dict_copy
[k
] = self
.delete_keys_from_dict(v
, lst_keys
)