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
43 from cvprac
.cvp_client
import CvpClient
44 from cvprac
.cvp_api
import CvpApi
45 from cvprac
.cvp_client_errors
import CvpLoginError
, CvpSessionLogOutError
, CvpApiError
46 from cvprac
import __version__
as cvprac_version
48 from osm_rosdn_arista_cloudvision
.aristaConfigLet
import AristaSDNConfigLet
49 from osm_rosdn_arista_cloudvision
.aristaTask
import AristaCVPTask
53 UNREACHABLE
= 'Unable to reach the WIM.',
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 SdnConnectorError
as sc
:
193 except Exception as e
:
194 raise SdnConnectorError(message
="Unable to load switches from CVP",
195 http_code
=500) from e
196 self
.logger
.debug("Using topology {} in Arista Leaf switches: {}".format(
198 self
.delete_keys_from_dict(self
.switches
, ('passwd',))))
199 self
.clC
= AristaSDNConfigLet(self
.topology
)
201 def __load_topology(self
):
202 self
.topology
= self
._VXLAN
_MLAG
203 if self
.__config
and self
.__config
.get('topology'):
204 topology
= self
.__config
.get('topology')
205 if topology
== "VLAN":
206 self
.topology
= self
._VLAN
207 elif topology
== "VXLAN":
208 self
.topology
= self
._VXLAN
209 elif topology
== "VLAN-MLAG":
210 self
.topology
= self
._VLAN
_MLAG
211 elif topology
== "VXLAN-MLAG":
212 self
.topology
= self
._VXLAN
_MLAG
214 def __load_switches(self
):
215 """ Retrieves the switches to configure in the following order
216 1. from incoming configuration:
217 1.1 using port mapping
218 using user and password from WIM
219 retrieving Lo0 and AS from switch
220 1.2 from 'switches' parameter,
221 if any parameter is not present
222 Lo0 and AS - it will be requested to the switch
223 2. Looking in the CloudVision inventory if not in configuration parameters
224 2.1 using the switches with the topology_type tag set to 'leaf'
226 All the search methods will be used
229 if self
.__config
and self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
230 for port
in self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
231 switch_dpid
= port
.get(self
.__SW
_ID
_PARAM
)
232 if switch_dpid
and switch_dpid
not in self
.switches
:
233 self
.switches
[switch_dpid
] = {'passwd': self
.__passwd
,
238 'serialNumber': None,
239 'mlagPeerDevice': None}
241 if self
.__config
and self
.__config
.get('switches'):
242 # Not directly from json, complete one by one
243 config_switches
= self
.__config
.get('switches')
244 for cs
, cs_content
in config_switches
.items():
245 if cs
not in self
.switches
:
246 self
.switches
[cs
] = {'passwd': self
.__passwd
,
251 'serialNumber': None,
252 'mlagPeerDevice': None}
254 self
.switches
[cs
].update(cs_content
)
256 # Load the rest of the data
257 if self
.client
is None:
258 self
.client
= self
.__connect
()
259 self
.__load
_inventory
()
260 if not self
.switches
:
261 self
.__get
_tags
(self
.__SWITCH
_TAG
_NAME
, self
.__SWITCH
_TAG
_VALUE
)
262 for device
in self
.allDeviceFacts
:
263 # get the switches whose topology_tag is 'leaf'
264 if device
['serialNumber'] in self
.cvp_tags
:
265 if not self
.switches
.get(device
['hostname']):
266 switch_data
= {'passwd': self
.__passwd
,
267 'ip': device
['ipAddress'],
271 'serialNumber': None,
272 'mlagPeerDevice': None}
273 self
.switches
[device
['hostname']] = switch_data
274 if len(self
.switches
) == 0:
275 self
.logger
.error("Unable to load Leaf switches from CVP")
278 # self.switches are switch objects, one for each switch in self.switches,
279 # used to make eAPI calls by using switch.py module
280 for s
in self
.switches
:
281 for device
in self
.allDeviceFacts
:
282 if device
['hostname'] == s
:
283 if not self
.switches
[s
].get('ip'):
284 self
.switches
[s
]['ip'] = device
['ipAddress']
285 self
.switches
[s
]['serialNumber'] = device
['serialNumber']
288 # Each switch has a different loopback address,
289 # so it's a different configLet
290 if not self
.switches
[s
].get('lo0'):
291 inf
= self
.__get
_interface
_ip
(self
.switches
[s
]['serialNumber'], self
.__LOOPBACK
_INTF
)
292 self
.switches
[s
]["lo0"] = inf
.split('/')[0]
293 if not self
.switches
[s
].get('AS'):
294 self
.switches
[s
]["AS"] = self
.__get
_device
_ASN
(self
.switches
[s
]['serialNumber'])
295 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VLAN
_MLAG
):
296 for s
in self
.switches
:
297 if not self
.switches
[s
].get('mlagPeerDevice'):
298 self
.switches
[s
]['mlagPeerDevice'] = self
.__get
_peer
_MLAG
(self
.switches
[s
]['serialNumber'])
300 def __check_service(self
, service_type
, connection_points
,
301 check_vlan
=True, check_num_cp
=True, kwargs
=None):
302 """ Reviews the connection points elements looking for semantic errors in the incoming data
304 if service_type
not in self
.__supported
_service
_types
:
305 raise Exception("The service '{}' is not supported. Only '{}' are accepted".format(
307 self
.__supported
_service
_types
))
310 if len(connection_points
) < 2:
311 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
312 if (len(connection_points
) != self
.__ELINE
_num
_connection
_points
and
313 service_type
== self
.__service
_types
_ELINE
):
314 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
318 for cp
in connection_points
:
319 enc_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
321 enc_type
not in self
.__supported
_encapsulation
_types
):
322 raise Exception(SdnError
.ENCAPSULATION_TYPE
)
323 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
324 cp_vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
328 elif vlan_id
!= cp_vlan_id
:
329 raise Exception(SdnError
.VLAN_INCONSISTENT
)
331 raise Exception(SdnError
.VLAN_NOT_PROVIDED
)
332 if vlan_id
in self
.__get
_srvVLANs
():
333 raise Exception('VLAN {} already assigned to a connectivity service'.format(vlan_id
))
335 # Commented out for as long as parameter isn't implemented
336 # bandwidth = kwargs.get(self.__BANDWIDTH_PARAM)
337 # if not isinstance(bandwidth, int):
338 # self.__exception(SdnError.BANDWIDTH, http_code=400)
340 # Commented out for as long as parameter isn't implemented
341 # backup = kwargs.get(self.__BACKUP_PARAM)
342 # if not isinstance(backup, bool):
343 # self.__exception(SdnError.BACKUP, http_code=400)
345 def check_credentials(self
):
346 """Retrieves the CloudVision version information, as the easiest way
347 for testing the access to CloudVision API
350 if self
.client
is None:
351 self
.client
= self
.__connect
()
352 result
= self
.client
.api
.get_cvp_info()
353 self
.logger
.debug(result
)
354 except CvpLoginError
as e
:
355 self
.logger
.info(str(e
))
357 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
358 http_code
=401) from e
359 except Exception as ex
:
361 self
.logger
.error(str(ex
))
362 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
363 http_code
=500) from ex
365 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
366 """Monitor the status of the connectivity service established
368 service_uuid (str): UUID of the connectivity service
369 conn_info (dict or None): Information returned by the connector
370 during the service creation/edition and subsequently stored in
374 dict: JSON/YAML-serializable dict that contains a mandatory key
375 ``sdn_status`` associated with one of the following values::
377 {'sdn_status': 'ACTIVE'}
378 # The service is up and running.
380 {'sdn_status': 'INACTIVE'}
381 # The service was created, but the connector
382 # cannot determine yet if connectivity exists
383 # (ideally, the caller needs to wait and check again).
385 {'sdn_status': 'DOWN'}
386 # Connection was previously established,
387 # but an error/failure was detected.
389 {'sdn_status': 'ERROR'}
390 # An error occurred when trying to create the service/
391 # establish the connectivity.
393 {'sdn_status': 'BUILD'}
394 # Still trying to create the service, the caller
395 # needs to wait and check again.
397 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
398 keys can be used to provide additional status explanation or
399 new information available for the connectivity service.
402 self
.logger
.debug("invoked get_connectivity_service_status '{}'".format(service_uuid
))
404 raise SdnConnectorError(message
='No connection service UUID',
407 self
.__get
_Connection
()
408 if conn_info
is None:
409 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
412 if 'configLetPerSwitch' in conn_info
.keys():
416 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
417 conn_info
['service_type'],
418 conn_info
['vlan_id'],
421 t_isCancelled
= False
425 for s
in self
.switches
:
426 if len(cls_perSw
[s
]) > 0:
427 for cl
in cls_perSw
[s
]:
428 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
429 # Added protection to check that 'note' exists and additionally
430 # verify that it is managed by OSM
431 if (not cls_perSw
[s
][0]['config'] or
432 not cl
.get('note') or
433 self
.__MANAGED
_BY
_OSM
not in cl
['note']):
436 t_id
= note
.split(self
.__SEPARATOR
)[1]
437 result
= self
.client
.api
.get_task_by_id(t_id
)
438 if result
['workOrderUserDefinedStatus'] == 'Completed':
440 elif result
['workOrderUserDefinedStatus'] == 'Cancelled':
442 elif result
['workOrderUserDefinedStatus'] == 'Failed':
446 failed_switches
.append(s
)
448 error_msg
= 'Some works were cancelled in switches: {}'.format(str(failed_switches
))
451 error_msg
= 'Some works failed in switches: {}'.format(str(failed_switches
))
454 error_msg
= 'Some works are still under execution in switches: {}'.format(str(failed_switches
))
458 sdn_status
= 'ACTIVE'
460 return {'sdn_status': sdn_status
,
461 'error_msg': error_msg
,
462 'sdn_info': sdn_info
}
463 except CvpLoginError
as e
:
464 self
.logger
.info(str(e
))
466 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
467 http_code
=401) from e
468 except Exception as ex
:
470 self
.logger
.error(str(ex
), exc_info
=True)
471 raise SdnConnectorError(message
=str(ex
),
472 http_code
=500) from ex
474 def create_connectivity_service(self
, service_type
, connection_points
,
476 """Stablish SDN/WAN connectivity between the endpoints
478 (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
479 :param connection_points: (list): each point corresponds to
480 an entry point to be connected. For WIM: from the DC
481 to the transport network.
482 For SDN: Compute/PCI to the transport network. One
483 connection point serves to identify the specific access and
484 some other service parameters, such as encapsulation type.
485 Each item of the list is a dict with:
486 "service_endpoint_id": (str)(uuid) Same meaning that for
487 'service_endpoint_mapping' (see __init__)
488 In case the config attribute mapping_not_needed is True,
489 this value is not relevant. In this case
490 it will contain the string "device_id:device_interface_id"
491 "service_endpoint_encapsulation_type": None, "dot1q", ...
492 "service_endpoint_encapsulation_info": (dict) with:
493 "vlan": ..., (int, present if encapsulation is dot1q)
494 "vni": ... (int, present if encapsulation is vxlan),
495 "peers": [(ipv4_1), (ipv4_2)] (present if
496 encapsulation is vxlan)
498 "device_id": ..., same meaning that for
499 'service_endpoint_mapping' (see __init__)
500 "device_interface_id": same meaning that for
501 'service_endpoint_mapping' (see __init__)
502 "switch_dpid": ..., present if mapping has been found
503 for this device_id,device_interface_id
504 "switch_port": ... present if mapping has been found
505 for this device_id,device_interface_id
506 "service_mapping_info": present if mapping has
507 been found for this device_id,device_interface_id
508 :param kwargs: For future versions:
509 bandwidth (int): value in kilobytes
510 latency (int): value in milliseconds
511 Other QoS might be passed as keyword arguments.
512 :return: tuple: ``(service_id, conn_info)`` containing:
513 - *service_uuid* (str): UUID of the established
515 - *conn_info* (dict or None): Information to be
516 stored at the database (or ``None``).
517 This information will be provided to the
518 :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
519 **MUST** be JSON/YAML-serializable (plain data structures).
520 :raises: SdnConnectorError: In case of error. Nothing should be
521 created in this case.
522 Provide the parameter http_code
525 self
.logger
.debug("invoked create_connectivity_service '{}' ports: {}".
526 format(service_type
, connection_points
))
527 self
.__get
_Connection
()
528 self
.__check
_service
(service_type
,
532 service_uuid
= str(uuid
.uuid4())
534 self
.logger
.info("Service with uuid {} created.".
535 format(service_uuid
))
536 s_uid
, s_connInf
= self
.__processConnection
(
542 self
.__addMetadata
(s_uid
, service_type
, s_connInf
['vlan_id'])
546 return (s_uid
, s_connInf
)
547 except CvpLoginError
as e
:
548 self
.logger
.info(str(e
))
550 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
551 http_code
=401) from e
552 except SdnConnectorError
as sde
:
554 except ValueError as err
:
556 self
.logger
.error(str(err
), exc_info
=True)
557 raise SdnConnectorError(message
=str(err
),
558 http_code
=500) from err
559 except Exception as ex
:
561 self
.logger
.error(str(ex
), exc_info
=True)
562 if self
.raiseException
:
564 raise SdnConnectorError(message
=str(ex
),
565 http_code
=500) from ex
567 def __processConnection(self
,
573 Invoked from creation and edit methods
575 Process the connection points array,
576 creating a set of configuration per switch where it has to be applied
577 for creating the configuration, the switches have to be queried for obtaining:
578 - the loopback address
579 - the BGP ASN (autonomous system number)
580 - the interface name of the MAC address to add in the connectivity service
581 Once the new configuration is ready, the __updateConnection method is invoked for appling the changes
587 for s
in self
.switches
:
590 vlan_processed
= False
593 processed_connection_points
= []
594 for cp
in connection_points
:
596 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
597 if not vlan_processed
:
598 vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
601 vni_id
= encap_info
.get(self
.__VNI
_PARAM
)
603 vni_id
= str(10000 + int(vlan_id
))
605 if service_type
== self
.__service
_types
_ELAN
:
606 cl_vlan
= self
.clC
.getElan_vlan(service_uuid
,
610 cl_vlan
= self
.clC
.getEline_vlan(service_uuid
,
613 vlan_processed
= True
615 encap_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
616 switch_id
= encap_info
.get(self
.__SW
_ID
_PARAM
)
617 interface
= encap_info
.get(self
.__SW
_PORT
_PARAM
)
618 switches
= [{'name': switch_id
, 'interface': interface
}]
620 # remove those connections that are equal. This happens when several sriovs are located in the same
621 # compute node interface, that is, in the same switch and interface
622 switches
= [x
for x
in switches
if x
not in processed_connection_points
]
625 processed_connection_points
+= switches
626 for switch
in switches
:
628 raise SdnConnectorError(
629 message
="Connection point switch port empty for switch_dpid {}".format(switch_id
),
631 # it should be only one switch where the mac is attached
632 if encap_type
== 'dot1q':
633 # SRIOV configLet for Leaf switch mac's attached to
634 if service_type
== self
.__service
_types
_ELAN
:
635 cl_encap
= self
.clC
.getElan_sriov(service_uuid
, interface
, vlan_id
, i
)
637 cl_encap
= self
.clC
.getEline_sriov(service_uuid
, interface
, vlan_id
, i
)
639 # PT configLet for Leaf switch attached to the mac
640 if service_type
== self
.__service
_types
_ELAN
:
641 cl_encap
= self
.clC
.getElan_passthrough(service_uuid
,
645 cl_encap
= self
.clC
.getEline_passthrough(service_uuid
,
648 if cls_cp
.get(switch
['name']):
649 cls_cp
[switch
['name']] = str(cls_cp
[switch
['name']]) + cl_encap
651 cls_cp
[switch
['name']] = cl_encap
653 # at least 1 connection point has to be received
654 if not vlan_processed
:
655 raise SdnConnectorError(message
=SdnError
.UNSUPPORTED_FEATURE
,
658 for s
in self
.switches
:
659 # for cl in cp_configLets:
660 cl_name
= (self
.__OSM
_PREFIX
+
662 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
663 self
.__SEPARATOR
+ service_uuid
)
665 # Apply BGP configuration only for VXLAN topologies
666 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VXLAN
):
667 if service_type
== self
.__service
_types
_ELAN
:
668 cl_bgp
[s
] = self
.clC
.getElan_bgp(service_uuid
,
671 self
.switches
[s
]['lo0'],
672 self
.switches
[s
]['AS'])
674 cl_bgp
[s
] = self
.clC
.getEline_bgp(service_uuid
,
677 self
.switches
[s
]['lo0'],
678 self
.switches
[s
]['AS'])
682 if not cls_cp
.get(s
):
683 # Apply VLAN configuration to peer MLAG switch,
684 # only necessary when there are no connection points in the switch
685 if self
.topology
in (self
._VXLAN
_MLAG
, self
._VLAN
_MLAG
):
686 for p
in self
.switches
:
687 if self
.switches
[p
]['mlagPeerDevice'] == s
:
689 cl_config
= str(cl_vlan
)
691 cl_config
= str(cl_vlan
) + str(cl_bgp
[s
]) + str(cls_cp
[s
])
693 cls_perSw
[s
] = [{'name': cl_name
, 'config': cl_config
}]
695 allLeafConfigured
, allLeafModified
= self
.__updateConnection
(cls_perSw
)
698 "uuid": service_uuid
,
700 "service_type": service_type
,
702 "connection_points": connection_points
,
703 "configLetPerSwitch": cls_perSw
,
704 'allLeafConfigured': allLeafConfigured
,
705 'allLeafModified': allLeafModified
}
707 return service_uuid
, conn_info
708 except Exception as ex
:
709 self
.logger
.debug("Exception processing connection {}: {}".
710 format(service_uuid
, str(ex
)))
713 def __updateConnection(self
, cls_perSw
):
714 """ Invoked in the creation and modification
716 checks if the new connection points config is:
717 - already in the Cloud Vision, the configLet is modified, and applied to the switch,
718 executing the corresponding task
719 - if it has to be removed:
720 then configuration has to be removed from the switch executing the corresponding task,
721 before trying to remove the configuration
722 - created, the configuration set is created, associated to the switch, and the associated
723 task to the configLet modification executed
724 In case of any error, rollback is executed, removing the created elements, and restoring to the
728 allLeafConfigured
= {}
731 for s
in self
.switches
:
732 allLeafConfigured
[s
] = False
733 allLeafModified
[s
] = False
735 for s
in self
.switches
:
736 toDelete_in_cvp
= False
737 if not (cls_perSw
.get(s
) and cls_perSw
[s
][0].get('config')):
738 # when there is no configuration, means that there is no interface
739 # in the switch to be connected, so the configLet has to be removed from CloudVision
740 # after removing the ConfigLet fron the switch if it was already there
742 # get config let name and key
745 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
[0]['name'])
747 cl_toDelete
.append(cvp_cl
)
749 toDelete_in_cvp
= True
750 except CvpApiError
as error
:
751 if "Entity does not exist" in error
.msg
:
755 # remove configLet from device
757 res
= self
.__configlet
_modify
(cls_perSw
[s
])
758 allLeafConfigured
[s
] = res
[0]
759 if not allLeafConfigured
[s
]:
762 res
= self
.__device
_modify
(
765 delete
=toDelete_in_cvp
)
766 if "errorMessage" in str(res
):
767 raise Exception(str(res
))
768 self
.logger
.info("Device {} modify result {}".format(s
, res
))
769 for t_id
in res
[1]['tasks']:
770 if not toDelete_in_cvp
:
771 note_msg
= "{}{}{}{}##".format(self
.__MANAGED
_BY
_OSM
,
775 self
.client
.api
.add_note_to_configlet(
776 cls_perSw
[s
][0]['key'],
778 cls_perSw
[s
][0]['note'] = note_msg
779 tasks
= {t_id
: {'workOrderId': t_id
}}
780 self
.__exec
_task
(tasks
, self
.__EXC
_TASK
_EXEC
_WAIT
)
781 # with just one configLet assigned to a device,
782 # delete all if there are errors in next loops
783 if not toDelete_in_cvp
:
784 allLeafModified
[s
] = True
785 if len(cl_toDelete
) > 0:
786 self
.__configlet
_modify
(cl_toDelete
, delete
=True)
788 return allLeafConfigured
, allLeafModified
789 except Exception as ex
:
791 self
.__rollbackConnection
(cls_perSw
,
794 except Exception as e
:
795 self
.logger
.error("Exception rolling back in updating connection: {}".
796 format(e
), exc_info
=True)
799 def __rollbackConnection(self
,
803 """ Removes the given configLet from the devices and then remove the configLets
805 for s
in self
.switches
:
806 if allLeafModified
[s
]:
808 res
= self
.__device
_modify
(
810 new_configlets
=cls_perSw
[s
],
812 if "errorMessage" in str(res
):
813 raise Exception(str(res
))
815 for t_id
in res
[1]['tasks']:
816 tasks
[t_id
] = {'workOrderId': t_id
}
817 self
.__exec
_task
(tasks
)
818 self
.logger
.info("Device {} modify result {}".format(s
, res
))
819 except Exception as e
:
820 self
.logger
.error('Error removing configlets from device {}: {}'.format(s
, e
))
822 for s
in self
.switches
:
823 if allLeafConfigured
[s
]:
824 self
.__configlet
_modify
(cls_perSw
[s
], delete
=True)
826 def __exec_task(self
, tasks
, tout
=10):
827 if self
.taskC
is None:
829 data
= self
.taskC
.update_all_tasks(tasks
).values()
830 self
.taskC
.task_action(data
, tout
, 'executed')
832 def __device_modify(self
, device_to_update
, new_configlets
, delete
):
833 """ Updates the devices (switches) adding or removing the configLet,
834 the tasks Id's associated to the change are returned
836 self
.logger
.info('Enter in __device_modify delete: {}'.format(delete
))
839 # Task Ids that have been identified during device actions
842 if (len(new_configlets
) == 0 or
843 device_to_update
is None or
844 len(device_to_update
) == 0):
845 data
= {'updated': updated
, 'tasks': newTasks
}
846 return [changed
, data
]
848 self
.__load
_inventory
()
850 allDeviceFacts
= self
.allDeviceFacts
851 # Work through Devices list adding device specific information
853 for try_device
in allDeviceFacts
:
854 # Add Device Specific Configlets
855 # self.logger.debug(device)
856 if try_device
['hostname'] not in device_to_update
:
858 dev_cvp_configlets
= self
.client
.api
.get_configlets_by_device_id(
859 try_device
['systemMacAddress'])
860 # self.logger.debug(dev_cvp_configlets)
861 try_device
['deviceSpecificConfiglets'] = []
862 for cvp_configlet
in dev_cvp_configlets
:
863 if int(cvp_configlet
['containerCount']) == 0:
864 try_device
['deviceSpecificConfiglets'].append(
865 {'name': cvp_configlet
['name'],
866 'key': cvp_configlet
['key']})
867 # self.logger.debug(device)
871 # Check assigned configlets
872 device_update
= False
874 remove_configlets
= []
878 for cvp_configlet
in device
['deviceSpecificConfiglets']:
879 for cl
in new_configlets
:
880 if cvp_configlet
['name'] == cl
['name']:
881 remove_configlets
.append(cvp_configlet
)
884 for configlet
in new_configlets
:
885 if configlet
not in device
['deviceSpecificConfiglets']:
886 add_configlets
.append(configlet
)
889 update_devices
.append({'hostname': device
['hostname'],
890 'configlets': [add_configlets
,
893 self
.logger
.info("Device to modify: {}".format(update_devices
))
895 up_device
= update_devices
[0]
896 cl_toAdd
= up_device
['configlets'][0]
897 cl_toDel
= up_device
['configlets'][1]
900 if delete
and len(cl_toDel
) > 0:
901 r
= self
.client
.api
.remove_configlets_from_device(
907 self
.logger
.debug("remove_configlets_from_device {} {}".format(dev_action
, cl_toDel
))
908 elif len(cl_toAdd
) > 0:
909 r
= self
.client
.api
.apply_configlets_to_device(
915 self
.logger
.debug("apply_configlets_to_device {} {}".format(dev_action
, cl_toAdd
))
917 except Exception as error
:
918 errorMessage
= str(error
)
919 msg
= "errorMessage: Device {} Configlets couldnot be updated: {}".format(
920 up_device
['hostname'], errorMessage
)
921 raise SdnConnectorError(msg
) from error
923 if "errorMessage" in str(dev_action
):
924 m
= "Device {} Configlets update fail: {}".format(
925 up_device
['name'], dev_action
['errorMessage'])
926 raise SdnConnectorError(m
)
929 if 'taskIds' in str(dev_action
):
930 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
931 if not dev_action
['data']['taskIds']:
932 raise SdnConnectorError("No taskIds found: Device {} Configlets could not be updated".format(
933 up_device
['hostname']))
934 for taskId
in dev_action
['data']['taskIds']:
936 up_device
['hostname']: "Configlets-{}".format(taskId
)})
937 newTasks
.append(taskId
)
939 updated
.append({up_device
['hostname']:
940 "Configlets-No_Specific_Tasks"})
941 data
= {'updated': updated
, 'tasks': newTasks
}
942 return [changed
, data
]
944 def __configlet_modify(self
, configletsToApply
, delete
=False):
945 ''' adds/update or delete the provided configLets
946 :param configletsToApply: list of configLets to apply
947 :param delete: flag to indicate if the configLets have to be deleted
948 from Cloud Vision Portal
949 :return: data: dict of module actions and taskIDs
951 self
.logger
.info('Enter in __configlet_modify delete:{}'.format(
954 # Compare configlets against cvp_facts-configlets
961 for cl
in configletsToApply
:
968 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
['name'])
969 cl
['key'] = cvp_cl
['key']
970 cl
['note'] = cvp_cl
['note']
972 except CvpApiError
as error
:
973 if "Entity does not exist" in error
.msg
:
981 configlet
= {'name': cvp_cl
['name'],
985 cl_compare
= self
.__compare
(cl
['config'],
987 # compare function returns a floating point number
988 if cl_compare
[0] != 100.0:
990 configlet
= {'name': cl
['name'],
992 'config': cl
['config']}
995 configlet
= {'name': cl
['name'],
996 'key': cvp_cl
['key'],
998 'config': cl
['config']}
1001 configlet
= {'name': cl
['name'],
1002 'config': cl
['config']}
1005 operation
= 'delete'
1006 resp
= self
.client
.api
.delete_configlet(
1007 configlet
['data']['name'],
1008 configlet
['data']['key'])
1010 operation
= 'update'
1011 resp
= self
.client
.api
.update_configlet(
1012 configlet
['config'],
1013 configlet
['data']['key'],
1014 configlet
['data']['name'],
1017 operation
= 'create'
1018 resp
= self
.client
.api
.add_configlet(
1020 configlet
['config'])
1022 operation
= 'checked'
1024 except Exception as error
:
1025 errorMessage
= str(error
).split(':')[-1]
1026 message
= "Configlet {} cannot be {}: {}".format(
1027 cl
['name'], operation
, errorMessage
)
1029 deleted
.append({configlet
['name']: message
})
1031 updated
.append({configlet
['name']: message
})
1033 new
.append({configlet
['name']: message
})
1035 checked
.append({configlet
['name']: message
})
1038 if "error" in str(resp
).lower():
1039 message
= "Configlet {} cannot be deleted: {}".format(
1040 cl
['name'], resp
['errorMessage'])
1042 deleted
.append({configlet
['name']: message
})
1044 updated
.append({configlet
['name']: message
})
1046 new
.append({configlet
['name']: message
})
1048 checked
.append({configlet
['name']: message
})
1052 deleted
.append({configlet
['name']: "success"})
1055 updated
.append({configlet
['name']: "success"})
1058 cl
['key'] = resp
# This key is used in API call deviceApplyConfigLet FGA
1059 new
.append({configlet
['name']: "success"})
1062 checked
.append({configlet
['name']: "success"})
1064 data
= {'new': new
, 'updated': updated
, 'deleted': deleted
, 'checked': checked
}
1065 return [changed
, data
]
1067 def __get_configletsDevices(self
, configlets
):
1068 for s
in self
.switches
:
1069 configlet
= configlets
[s
]
1070 # Add applied Devices
1071 if len(configlet
) > 0:
1072 configlet
['devices'] = []
1073 applied_devices
= self
.client
.api
.get_applied_devices(
1075 for device
in applied_devices
['data']:
1076 configlet
['devices'].append(device
['hostName'])
1078 def __get_serviceData(self
, service_uuid
, service_type
, vlan_id
, conn_info
=None):
1080 for s
in self
.switches
:
1083 srv_cls
= self
.__get
_serviceConfigLets
(service_uuid
,
1086 self
.__get
_configletsDevices
(srv_cls
)
1087 for s
in self
.switches
:
1090 for dev
in cl
['devices']:
1091 cls_perSw
[dev
].append(cl
)
1093 cls_perSw
= conn_info
['configLetPerSwitch']
1096 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
1098 Disconnect multi-site endpoints previously connected
1100 :param service_uuid: The one returned by create_connectivity_service
1101 :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
1102 if they do not return None
1104 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
1107 self
.logger
.debug('invoked delete_connectivity_service {}'.
1108 format(service_uuid
))
1109 if not service_uuid
:
1110 raise SdnConnectorError(message
='No connection service UUID',
1113 self
.__get
_Connection
()
1114 if conn_info
is None:
1115 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
1118 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
1119 conn_info
['service_type'],
1120 conn_info
['vlan_id'],
1122 allLeafConfigured
= {}
1123 allLeafModified
= {}
1124 for s
in self
.switches
:
1125 allLeafConfigured
[s
] = True
1126 allLeafModified
[s
] = True
1127 found_in_cvp
= False
1128 for s
in self
.switches
:
1132 self
.__rollbackConnection
(cls_perSw
,
1136 # if the service is not defined in Cloud Vision, return a 404 - NotFound error
1137 raise SdnConnectorError(message
='Service {} was not found in Arista Cloud Vision {}'.
1138 format(service_uuid
, self
.__wim
_url
),
1140 self
.__removeMetadata
(service_uuid
)
1141 except CvpLoginError
as e
:
1142 self
.logger
.info(str(e
))
1144 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1145 http_code
=401) from e
1146 except SdnConnectorError
as sde
:
1148 except Exception as ex
:
1150 self
.logger
.error(ex
)
1151 if self
.raiseException
:
1153 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1154 http_code
=500) from ex
1156 def __addMetadata(self
, service_uuid
, service_type
, vlan_id
):
1157 """ Adds the connectivity service from 'OSM_metadata' configLet
1159 found_in_cvp
= False
1161 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1163 except CvpApiError
as error
:
1164 if "Entity does not exist" in error
.msg
:
1169 new_serv
= '{} {} {} {}\n'.format(self
.__METADATA
_PREFIX
, service_type
, vlan_id
, service_uuid
)
1172 cl_config
= cvp_cl
['config'] + new_serv
1174 cl_config
= new_serv
1175 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1176 self
.__configlet
_modify
(cl_meta
)
1177 except Exception as e
:
1178 self
.logger
.error('Error in setting metadata in CloudVision from OSM for service {}: {}'.
1179 format(service_uuid
, str(e
)))
1182 def __removeMetadata(self
, service_uuid
):
1183 """ Removes the connectivity service from 'OSM_metadata' configLet
1185 found_in_cvp
= False
1187 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1189 except CvpApiError
as error
:
1190 if "Entity does not exist" in error
.msg
:
1196 if service_uuid
in cvp_cl
['config']:
1198 for line
in cvp_cl
['config'].split('\n'):
1199 if service_uuid
in line
:
1202 cl_config
= cl_config
+ line
1203 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1204 self
.__configlet
_modify
(cl_meta
)
1205 except Exception as e
:
1206 self
.logger
.error('Error in removing metadata in CloudVision from OSM for service {}: {}'.
1207 format(service_uuid
, str(e
)))
1210 def edit_connectivity_service(self
,
1213 connection_points
=None,
1215 """ Change an existing connectivity service.
1217 This method's arguments and return value follow the same convention as
1218 :meth:`~.create_connectivity_service`.
1220 :param service_uuid: UUID of the connectivity service.
1221 :param conn_info: (dict or None): Information previously returned
1222 by last call to create_connectivity_service
1223 or edit_connectivity_service
1224 :param connection_points: (list): If provided, the old list of
1225 connection points will be replaced.
1226 :param kwargs: Same meaning that create_connectivity_service
1227 :return: dict or None: Information to be updated and stored at
1229 When ``None`` is returned, no information should be changed.
1230 When an empty dict is returned, the database record will
1232 **MUST** be JSON/YAML-serializable (plain data structures).
1234 SdnConnectorError: In case of error.
1237 self
.logger
.debug('invoked edit_connectivity_service for service {}. ports: {}'.format(service_uuid
,
1240 if not service_uuid
:
1241 raise SdnConnectorError(message
='Unable to perform operation, missing or empty uuid',
1244 raise SdnConnectorError(message
='Unable to perform operation, missing or empty connection information',
1247 if connection_points
is None:
1250 self
.__get
_Connection
()
1252 cls_currentPerSw
= conn_info
['configLetPerSwitch']
1253 service_type
= conn_info
['service_type']
1255 self
.__check
_service
(service_type
,
1261 s_uid
, s_connInf
= self
.__processConnection
(
1266 self
.logger
.info("Service with uuid {} configuration updated".
1269 except CvpLoginError
as e
:
1270 self
.logger
.info(str(e
))
1272 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1273 http_code
=401) from e
1274 except SdnConnectorError
as sde
:
1276 except Exception as ex
:
1279 # TODO check if there are pending task, and cancel them before restoring
1280 self
.__updateConnection
(cls_currentPerSw
)
1281 except Exception as e
:
1282 self
.logger
.error("Unable to restore configuration in service {} after an error in the configuration"
1283 " updated: {}".format(service_uuid
, str(e
)))
1284 if self
.raiseException
:
1286 raise SdnConnectorError(message
=str(ex
),
1287 http_code
=500) from ex
1289 def clear_all_connectivity_services(self
):
1290 """ Removes all connectivity services from Arista CloudVision with two steps:
1291 - retrives all the services from Arista CloudVision
1292 - removes each service
1295 self
.logger
.debug('invoked AristaImpl ' +
1296 'clear_all_connectivity_services')
1297 self
.__get
_Connection
()
1298 s_list
= self
.__get
_srvUUIDs
()
1301 conn_info
['service_type'] = serv
['type']
1302 conn_info
['vlan_id'] = serv
['vlan']
1304 self
.delete_connectivity_service(serv
['uuid'], conn_info
)
1305 except CvpLoginError
as e
:
1306 self
.logger
.info(str(e
))
1308 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1309 http_code
=401) from e
1310 except SdnConnectorError
as sde
:
1312 except Exception as ex
:
1314 self
.logger
.error(ex
)
1315 if self
.raiseException
:
1317 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1318 http_code
=500) from ex
1320 def get_all_active_connectivity_services(self
):
1321 """ Return the uuid of all the active connectivity services with two steps:
1322 - retrives all the services from Arista CloudVision
1323 - retrives the status of each server
1326 self
.logger
.debug('invoked AristaImpl {}'.format(
1327 'get_all_active_connectivity_services'))
1328 self
.__get
_Connection
()
1329 s_list
= self
.__get
_srvUUIDs
()
1333 conn_info
['service_type'] = serv
['type']
1334 conn_info
['vlan_id'] = serv
['vlan']
1336 status
= self
.get_connectivity_service_status(serv
['uuid'], conn_info
)
1337 if status
['sdn_status'] == 'ACTIVE':
1338 result
.append(serv
['uuid'])
1340 except CvpLoginError
as e
:
1341 self
.logger
.info(str(e
))
1343 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1344 http_code
=401) from e
1345 except SdnConnectorError
as sde
:
1347 except Exception as ex
:
1349 self
.logger
.error(ex
)
1350 if self
.raiseException
:
1352 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1353 http_code
=500) from ex
1355 def __get_serviceConfigLets(self
, service_uuid
, service_type
, vlan_id
):
1356 """ Return the configLet's associated with a connectivity service,
1357 There should be one, as maximum, per device (switch) for a given
1358 connectivity service
1361 for s
in self
.switches
:
1363 found_in_cvp
= False
1364 name
= (self
.__OSM
_PREFIX
+
1366 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
1367 self
.__SEPARATOR
+ service_uuid
)
1369 cvp_cl
= self
.client
.api
.get_configlet_by_name(name
)
1371 except CvpApiError
as error
:
1372 if "Entity does not exist" in error
.msg
:
1380 def __get_srvVLANs(self
):
1381 """ Returns a list with all the VLAN id's used in the connectivity services managed
1382 in tha Arista CloudVision by checking the 'OSM_metadata' configLet where this
1383 information is stored
1385 found_in_cvp
= False
1387 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1389 except CvpApiError
as error
:
1390 if "Entity does not exist" in error
.msg
:
1396 lines
= cvp_cl
['config'].split('\n')
1398 if self
.__METADATA
_PREFIX
in line
:
1399 s_vlan
= line
.split(' ')[3]
1402 if (s_vlan
is not None and
1404 s_vlan
not in s_vlan_list
):
1405 s_vlan_list
.append(s_vlan
)
1409 def __get_srvUUIDs(self
):
1410 """ Retrieves all the connectivity services, managed in tha Arista CloudVision
1411 by checking the 'OSM_metadata' configLet where this information is stored
1413 found_in_cvp
= False
1415 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1417 except CvpApiError
as error
:
1418 if "Entity does not exist" in error
.msg
:
1424 lines
= cvp_cl
['config'].split('\n')
1426 if self
.__METADATA
_PREFIX
in line
:
1427 line
= line
.split(' ')
1428 serv
= {'uuid': line
[4], 'type': line
[2], 'vlan': line
[3]}
1431 if (serv
is not None and
1433 serv
not in serv_list
):
1434 serv_list
.append(serv
)
1438 def __get_Connection(self
):
1439 """ Open a connection with Arista CloudVision,
1440 invoking the version retrival as test
1443 if self
.client
is None:
1444 self
.client
= self
.__connect
()
1445 self
.client
.api
.get_cvp_info()
1446 except (CvpSessionLogOutError
, RequestException
) as e
:
1447 self
.logger
.debug("Connection error '{}'. Reconnecting".format(e
))
1448 self
.client
= self
.__connect
()
1449 self
.client
.api
.get_cvp_info()
1451 def __connect(self
):
1452 ''' Connects to CVP device using user provided credentials from initialization.
1453 :return: CvpClient object with connection instantiated.
1455 client
= CvpClient()
1456 protocol
, _
, rest_url
= self
.__wim
_url
.rpartition("://")
1457 host
, _
, port
= rest_url
.partition(":")
1458 if port
and port
.endswith("/"):
1459 port
= int(port
[:-1])
1465 client
.connect([host
],
1468 protocol
=protocol
or "https",
1471 client
.api
= CvpApi(client
, request_timeout
=self
.__API
_REQUEST
_TOUT
)
1472 self
.taskC
= AristaCVPTask(client
.api
)
1475 def __compare(self
, fromText
, toText
, lines
=10):
1476 """ Compare text string in 'fromText' with 'toText' and produce
1477 diffRatio - a score as a float in the range [0, 1] 2.0*M / T
1478 T is the total number of elements in both sequences,
1479 M is the number of matches.
1480 Score - 1.0 if the sequences are identical, and
1481 0.0 if they have nothing in common.
1484 '- ' line unique to sequence 1
1485 '+ ' line unique to sequence 2
1486 ' ' line common to both sequences
1487 '? ' line not present in either input sequence
1489 fromlines
= fromText
.splitlines(1)
1490 tolines
= toText
.splitlines(1)
1491 diff
= list(difflib
.unified_diff(fromlines
, tolines
, n
=lines
))
1492 textComp
= difflib
.SequenceMatcher(None, fromText
, toText
)
1493 diffRatio
= round(textComp
.quick_ratio()*100, 2)
1494 return [diffRatio
, diff
]
1496 def __load_inventory(self
):
1497 """ Get Inventory Data for All Devices (aka switches) from the Arista CloudVision
1499 if not self
.cvp_inventory
:
1500 self
.cvp_inventory
= self
.client
.api
.get_inventory()
1501 self
.allDeviceFacts
= []
1502 for device
in self
.cvp_inventory
:
1503 self
.allDeviceFacts
.append(device
)
1505 def __get_tags(self
, name
, value
):
1506 if not self
.cvp_tags
:
1508 url
= '/api/v1/rest/analytics/tags/labels/devices/{}/value/{}/elements'.format(name
, value
)
1509 self
.logger
.debug('get_tags: URL {}'.format(url
))
1510 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1511 for dev
in data
['notifications']:
1512 for elem
in dev
['updates']:
1513 self
.cvp_tags
.append(elem
)
1514 self
.logger
.debug('Available devices with tag_name {} - value {}: {} '.format(name
, value
, self
.cvp_tags
))
1516 def __get_interface_ip(self
, device_id
, interface
):
1517 url
= '/api/v1/rest/{}/Sysdb/ip/config/ipIntfConfig/{}/'.format(device_id
, interface
)
1518 self
.logger
.debug('get_interface_ip: URL {}'.format(url
))
1520 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1521 return data
['notifications'][0]['updates']['addrWithMask']['value'].split('/')[0]
1523 raise SdnConnectorError("Invalid response from url {}: data {}".format(url
, data
))
1525 def __get_device_ASN(self
, device_id
):
1526 url
= '/api/v1/rest/{}/Sysdb/routing/bgp/config/'.format(device_id
)
1527 self
.logger
.debug('get_device_ASN: URL {}'.format(url
))
1529 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1530 return data
['notifications'][0]['updates']['asNumber']['value']['value']['int']
1532 raise SdnConnectorError("Invalid response from url {}: data {}".format(url
, data
))
1534 def __get_peer_MLAG(self
, device_id
):
1536 url
= '/api/v1/rest/{}/Sysdb/mlag/status/'.format(device_id
)
1537 self
.logger
.debug('get_MLAG_status: URL {}'.format(url
))
1539 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1540 if data
['notifications']:
1542 for notification
in data
['notifications']:
1543 for update
in notification
['updates']:
1544 if update
== 'systemId':
1545 mlagSystemId
= notification
['updates'][update
]['value']
1550 # search the MLAG System Id
1552 for s
in self
.switches
:
1553 if self
.switches
[s
]['serialNumber'] == device_id
:
1555 url
= '/api/v1/rest/{}/Sysdb/mlag/status/'.format(self
.switches
[s
]['serialNumber'])
1556 self
.logger
.debug('Searching for MLAG system id {} in switch {}'.format(mlagSystemId
, s
))
1557 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1559 for notification
in data
['notifications']:
1560 for update
in notification
['updates']:
1561 if update
== 'systemId':
1562 if mlagSystemId
== notification
['updates'][update
]['value']:
1571 self
.logger
.error('No Peer device found for device {} with MLAG address {}'.format(device_id
,
1574 self
.logger
.debug('Peer MLAG for device {} - value {}'.format(device_id
, peer
))
1577 raise SdnConnectorError("Invalid response from url {}: data {}".format(url
, data
))
1579 def is_valid_destination(self
, url
):
1580 """ Check that the provided WIM URL is correct
1582 if re
.match(self
.__regex
, url
):
1584 elif self
.is_valid_ipv4_address(url
):
1587 return self
.is_valid_ipv6_address(url
)
1589 def is_valid_ipv4_address(self
, address
):
1590 """ Checks that the given IP is IPv4 valid
1593 socket
.inet_pton(socket
.AF_INET
, address
)
1594 except AttributeError: # no inet_pton here, sorry
1596 socket
.inet_aton(address
)
1597 except socket
.error
:
1599 return address
.count('.') == 3
1600 except socket
.error
: # not a valid address
1604 def is_valid_ipv6_address(self
, address
):
1605 """ Checks that the given IP is IPv6 valid
1608 socket
.inet_pton(socket
.AF_INET6
, address
)
1609 except socket
.error
: # not a valid address
1613 def delete_keys_from_dict(self
, dict_del
, lst_keys
):
1614 if dict_del
is None:
1616 dict_copy
= {k
: v
for k
, v
in dict_del
.items() if k
not in lst_keys
}
1617 for k
, v
in dict_copy
.items():
1618 if isinstance(v
, dict):
1619 dict_copy
[k
] = self
.delete_keys_from_dict(v
, lst_keys
)