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
.wim
.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
.aristaSwitch
import AristaSwitch
49 from osm_rosdn_arista
.aristaConfigLet
import AristaSDNConfigLet
50 from osm_rosdn_arista
.aristaTask
import AristaCVPTask
54 UNREACHABLE
= 'Unable to reach the WIM.',
56 'VLAN value inconsistent between the connection points',
57 VLAN_NOT_PROVIDED
= 'VLAN value not provided',
58 CONNECTION_POINTS_SIZE
= \
59 'Unexpected number of connection points: 2 expected.',
60 ENCAPSULATION_TYPE
= \
61 'Unexpected service_endpoint_encapsulation_type. \
62 Only "dotq1" is accepted.',
63 BANDWIDTH
= 'Unable to get the bandwidth.',
64 STATUS
= 'Unable to get the status for the service.',
65 DELETE
= 'Unable to delete service.',
66 CLEAR_ALL
= 'Unable to clear all the services',
67 UNKNOWN_ACTION
= 'Unknown action invoked.',
68 BACKUP
= 'Unable to get the backup parameter.',
69 UNSUPPORTED_FEATURE
= "Unsupported feature",
70 UNAUTHORIZED
= "Failed while authenticating",
71 INTERNAL_ERROR
= "Internal error"
74 class AristaSdnConnector(SdnConnectorBase
):
75 """Arista class for the SDN connectors
78 wim (dict): WIM record, as stored in the database
79 wim_account (dict): WIM account record, as stored in the database
81 The arguments of the constructor are converted to object attributes.
82 An extra property, ``service_endpoint_mapping`` is created from ``config``.
84 The access to Arista CloudVision is made through the API defined in
85 https://github.com/aristanetworks/cvprac
86 The a connectivity service consist in creating a VLAN and associate the interfaces
87 of the connection points MAC addresses to this VLAN in all the switches of the topology,
88 the BDP is also configured for this VLAN.
90 The Arista Cloud Vision API workflow is the following
91 -- The switch configuration is defined as a set of switch configuration commands,
92 what is called 'ConfigLet'
93 -- The ConfigLet is associated to the device (leaf switch)
94 -- Automatically a task is associated to this activity for change control, the task
95 in this stage is in 'Pending' state
96 -- The task will be executed so that the configuration is applied to the switch.
97 -- The service information is saved in the response of the creation call
98 -- All created services identification is stored in a generic ConfigLet 'OSM_metadata'
99 to keep track of the managed resources by OSM in the Arista deployment.
101 __supported_service_types
= ["ELINE (L2)", "ELINE", "ELAN"]
102 __service_types_ELAN
= "ELAN"
103 __service_types_ELINE
= "ELINE"
104 __ELINE_num_connection_points
= 2
105 __supported_service_types
= ["ELINE", "ELAN"]
106 __supported_encapsulation_types
= ["dot1q"]
107 __WIM_LOGGER
= 'openmano.sdnconn.arista'
108 __SERVICE_ENDPOINT_MAPPING
= 'service_endpoint_mapping'
109 __ENCAPSULATION_TYPE_PARAM
= "service_endpoint_encapsulation_type"
110 __ENCAPSULATION_INFO_PARAM
= "service_endpoint_encapsulation_info"
111 __BACKUP_PARAM
= "backup"
112 __BANDWIDTH_PARAM
= "bandwidth"
113 __SERVICE_ENDPOINT_PARAM
= "service_endpoint_id"
115 __WAN_SERVICE_ENDPOINT_PARAM
= "service_endpoint_id"
116 __WAN_MAPPING_INFO_PARAM
= "service_mapping_info"
117 __DEVICE_ID_PARAM
= "device_id"
118 __DEVICE_INTERFACE_ID_PARAM
= "device_interface_id"
119 __SW_ID_PARAM
= "switch_dpid"
120 __SW_PORT_PARAM
= "switch_port"
121 __VLAN_PARAM
= "vlan"
124 __MANAGED_BY_OSM
= '## Managed by OSM '
125 __OSM_PREFIX
= "osm_"
126 __OSM_METADATA
= "OSM_metadata"
127 __METADATA_PREFIX
= '!## Service'
128 __EXC_TASK_EXEC_WAIT
= 10
129 __ROLLB_TASK_EXEC_WAIT
= 10
130 __API_REQUEST_TOUT
= 60
131 __SWITCH_TAG_NAME
= 'topology_type'
132 __SWITCH_TAG_VALUE
= 'leaf'
135 def __init__(self
, wim
, wim_account
, config
=None, logger
=None):
138 :param wim: (dict). Contains among others 'wim_url'
139 :param wim_account: (dict). Contains among others 'uuid' (internal id), 'name',
140 'sdn' (True if is intended for SDN-assist or False if intended for WIM), 'user', 'password'.
141 :param config: (dict or None): Particular information of plugin. These keys if present have a common meaning:
142 'mapping_not_needed': (bool) False by default or if missing, indicates that mapping is not needed.
143 'service_endpoint_mapping': (list) provides the internal endpoint mapping. The meaning is:
144 KEY meaning for WIM meaning for SDN assist
145 -------- -------- --------
146 device_id pop_switch_dpid compute_id
147 device_interface_id pop_switch_port compute_pci_address
148 service_endpoint_id wan_service_endpoint_id SDN_service_endpoint_id
149 service_mapping_info wan_service_mapping_info SDN_service_mapping_info
150 contains extra information if needed. Text in Yaml format
151 switch_dpid wan_switch_dpid SDN_switch_dpid
152 switch_port wan_switch_port SDN_switch_port
153 datacenter_id vim_account vim_account
154 id: (internal, do not use)
155 wim_id: (internal, do not use)
156 :param logger (logging.Logger): optional logger object. If none is passed 'openmano.sdn.sdnconn' is used.
158 self
.__regex
= re
.compile(
159 r
'^(?:http|ftp)s?://' # http:// or https://
160 r
'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
161 r
'localhost|' # localhost...
162 r
'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
163 r
'(?::\d+)?', re
.IGNORECASE
) # optional port
164 self
.raiseException
= True
165 self
.logger
= logger
or logging
.getLogger(self
.__WIM
_LOGGER
)
166 super().__init
__(wim
, wim_account
, config
, self
.logger
)
168 self
.__wim
_account
= wim_account
169 self
.__config
= config
170 if self
.is_valid_destination(self
.__wim
.get("wim_url")):
171 self
.__wim
_url
= self
.__wim
.get("wim_url")
173 raise SdnConnectorError(message
='Invalid wim_url value',
175 self
.__user
= wim_account
.get("user")
176 self
.__passwd
= wim_account
.get("password")
178 self
.cvp_inventory
= None
180 self
.logger
.debug("Arista SDN plugin {}, cvprac version {}, user:{} and config:{}".
181 format(wim
, cvprac_version
, self
.__user
,
182 self
.delete_keys_from_dict(config
, ('passwd',))))
183 self
.allDeviceFacts
= []
184 self
.clC
= AristaSDNConfigLet()
186 self
.__load
_switches
()
188 def __load_switches(self
):
189 """ Retrieves the switches to configure in the following order
190 1. from incoming configuration:
191 1.1 using port mapping
192 using user and password from WIM
193 retrieving Lo0 and AS from switch
194 1.2 from 'switches' parameter,
195 if any parameter is not present
196 Lo0 and AS - it will be requested to the switch
197 usr and pass - from WIM configuration
198 2. Looking in the CloudVision inventory if not in configuration parameters
199 2.1 using the switches with the topology_type tag set to 'leaf'
200 2.2 using the switches whose parent container is 'leaf'
201 2.3 using the switches whose hostname contains with 'leaf'
203 All the search methods will be used
206 if self
.__config
and self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
207 for port
in self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
208 switch_dpid
= port
.get(self
.__SW
_ID
_PARAM
)
209 if switch_dpid
and switch_dpid
not in self
.switches
:
210 self
.switches
[switch_dpid
] = {'passwd': self
.__passwd
,
216 if self
.__config
and self
.__config
.get('switches'):
217 # Not directly from json, complete one by one
218 config_switches
= self
.__config
.get('switches')
219 for cs
, cs_content
in config_switches
.items():
220 if cs
not in self
.switches
:
221 self
.switches
[cs
] = {'passwd': self
.__passwd
, 'ip': None, 'usr': self
.__user
, 'lo0': None,'AS': None}
223 self
.switches
[cs
].update(cs_content
)
225 # Load the rest of the data
226 if self
.client
is None:
227 self
.client
= self
.__connect
()
228 self
.__load
_inventory
()
229 if not self
.switches
:
230 self
.__get
_tags
(self
.__SWITCH
_TAG
_NAME
, self
.__SWITCH
_TAG
_VALUE
)
231 for device
in self
.allDeviceFacts
:
232 # get the switches whose container parent is 'leaf',
233 # or the topology_tag is 'leaf'
234 # or the hostname contains 'leaf'
235 if ((device
['serialNumber'] in self
.cvp_tags
) or
236 (self
.__SWITCH
_TAG
_VALUE
in device
['containerName'].lower()) or
237 (self
.__SWITCH
_TAG
_VALUE
in device
['hostname'].lower())):
238 if not self
.switches
.get(device
['hostname']):
239 switch_data
= {'passwd': self
.__passwd
,
240 'ip': device
['ipAddress'],
244 self
.switches
[device
['hostname']] = switch_data
245 if len(self
.switches
) == 0:
246 self
.logger
.error("Unable to load Leaf switches from CVP")
249 # self.s_api are switch objects, one for each switch in self.switches,
250 # used to make eAPI calls by using switch.py module
252 for s
in self
.switches
:
253 if not self
.switches
[s
].get('ip'):
254 for device
in self
.allDeviceFacts
:
255 if device
['hostname'] == s
:
256 self
.switches
[s
]['ip'] = device
['ipAddress']
257 if self
.is_valid_destination(self
.switches
[s
].get('ip')):
258 self
.s_api
[s
] = AristaSwitch(host
=self
.switches
[s
]['ip'],
259 user
=self
.switches
[s
]['usr'],
260 passwd
=self
.switches
[s
]['passwd'],
262 # Each switch has a different loopback address,
263 # so it's a different configLet
264 if not self
.switches
[s
].get('lo0'):
265 inf
= self
.__get
_switch
_interface
_ip
(s
, 'Loopback0')
266 self
.switches
[s
]["lo0"] = inf
.split('/')[0]
267 if not self
.switches
[s
].get('AS'):
268 self
.switches
[s
]["AS"] = self
.__get
_switch
_asn
(s
)
269 self
.logger
.debug("Using Arista Leaf switches: {}".format(
270 self
.delete_keys_from_dict(self
.switches
, ('passwd',))))
272 def __lldp_find_neighbor(self
, tlv_name
=None, tlv_value
=None):
273 """Returns a list of dicts where a mathing LLDP neighbor has been found
275 switch -> switch name
276 interface -> switch interface
281 # Get LLDP info from each switch
283 result
= self
.s_api
[s
].run("show lldp neighbors detail")
284 lldp_info
[s
] = result
[0]["lldpNeighbors"]
285 # Look LLDP match on each interface
286 # Note that eAPI returns [] for an interface with no LLDP neighbors
287 # in the corresponding interface lldpNeighborInfo field
288 for interface
in lldp_info
[s
]:
289 if lldp_info
[s
][interface
]["lldpNeighborInfo"]:
290 lldp_nInf
= lldp_info
[s
][interface
]["lldpNeighborInfo"][0]
291 if tlv_name
in lldp_nInf
:
292 if lldp_nInf
[tlv_name
] == tlv_value
:
293 r
.append({"name": s
, "interface": interface
})
297 def __get_switch_asn(self
, switch
):
298 """Returns switch ASN in default VRF
300 bgp_info
= self
.s_api
[switch
].run("show ip bgp summary")[0]
301 return(bgp_info
["vrfs"]["default"]["asn"])
303 def __get_switch_po(self
, switch
, interface
=None):
304 """Returns Port-Channels for a given interface
305 If interface is None returns a list with all PO interfaces
306 Note that if specified, interface should be exact name
307 for instance: Ethernet3 and not e3 eth3 and so on
309 po_inf
= self
.s_api
[switch
].run("show port-channel")[0]["portChannels"]
312 r
= [x
for x
in po_inf
if interface
in po_inf
[x
]["activePorts"]]
318 def __get_switch_interface_ip(self
, switch
, interface
=None):
319 """Returns interface primary ip
320 interface should be exact name
321 for instance: Ethernet3 and not ethernet 3, e3 eth3 and so on
323 cmd
= "show ip interface {}".format(interface
)
324 ip_info
= self
.s_api
[switch
].run(cmd
)[0]["interfaces"][interface
]
326 ip
= ip_info
["interfaceAddress"]["primaryIp"]["address"]
327 mask
= ip_info
["interfaceAddress"]["primaryIp"]["maskLen"]
329 return "{}/{}".format(ip
, mask
)
331 def __check_service(self
, service_type
, connection_points
,
332 check_vlan
=True, check_num_cp
=True, kwargs
=None):
333 """ Reviews the connection points elements looking for semantic errors in the incoming data
335 if service_type
not in self
.__supported
_service
_types
:
336 raise Exception("The service '{}' is not supported. Only '{}' are accepted".format(
338 self
.__supported
_service
_types
))
341 if (len(connection_points
) < 2):
342 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
343 if ((len(connection_points
) != self
.__ELINE
_num
_connection
_points
) and
344 (service_type
== self
.__service
_types
_ELINE
)):
345 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
349 for cp
in connection_points
:
350 enc_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
352 enc_type
not in self
.__supported
_encapsulation
_types
):
353 raise Exception(SdnError
.ENCAPSULATION_TYPE
)
354 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
355 cp_vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
359 elif vlan_id
!= cp_vlan_id
:
360 raise Exception(SdnError
.VLAN_INCONSISTENT
)
362 raise Exception(SdnError
.VLAN_NOT_PROVIDED
)
363 if vlan_id
in self
.__get
_srvVLANs
():
364 raise Exception('VLAN {} already assigned to a connectivity service'.format(vlan_id
))
366 # Commented out for as long as parameter isn't implemented
367 # bandwidth = kwargs.get(self.__BANDWIDTH_PARAM)
368 # if not isinstance(bandwidth, int):
369 # self.__exception(SdnError.BANDWIDTH, http_code=400)
371 # Commented out for as long as parameter isn't implemented
372 # backup = kwargs.get(self.__BACKUP_PARAM)
373 # if not isinstance(backup, bool):
374 # self.__exception(SdnError.BACKUP, http_code=400)
376 def check_credentials(self
):
377 """Retrieves the CloudVision version information, as the easiest way
378 for testing the access to CloudVision API
381 if self
.client
is None:
382 self
.client
= self
.__connect
()
383 result
= self
.client
.api
.get_cvp_info()
384 self
.logger
.debug(result
)
385 except CvpLoginError
as e
:
386 self
.logger
.info(str(e
))
388 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
389 http_code
=401) from e
390 except Exception as ex
:
392 self
.logger
.error(str(ex
))
393 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
394 http_code
=500) from ex
396 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
397 """Monitor the status of the connectivity service established
399 service_uuid (str): UUID of the connectivity service
400 conn_info (dict or None): Information returned by the connector
401 during the service creation/edition and subsequently stored in
405 dict: JSON/YAML-serializable dict that contains a mandatory key
406 ``sdn_status`` associated with one of the following values::
408 {'sdn_status': 'ACTIVE'}
409 # The service is up and running.
411 {'sdn_status': 'INACTIVE'}
412 # The service was created, but the connector
413 # cannot determine yet if connectivity exists
414 # (ideally, the caller needs to wait and check again).
416 {'sdn_status': 'DOWN'}
417 # Connection was previously established,
418 # but an error/failure was detected.
420 {'sdn_status': 'ERROR'}
421 # An error occurred when trying to create the service/
422 # establish the connectivity.
424 {'sdn_status': 'BUILD'}
425 # Still trying to create the service, the caller
426 # needs to wait and check again.
428 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
429 keys can be used to provide additional status explanation or
430 new information available for the connectivity service.
433 self
.logger
.debug("invoked get_connectivity_service_status '{}'".format(service_uuid
))
435 raise SdnConnectorError(message
='No connection service UUID',
438 self
.__get
_Connection
()
439 if conn_info
is None:
440 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
443 if 'configLetPerSwitch' in conn_info
.keys():
447 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
448 conn_info
['service_type'],
449 conn_info
['vlan_id'],
452 t_isCancelled
= False
457 if (len(cls_perSw
[s
]) > 0):
458 for cl
in cls_perSw
[s
]:
459 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
460 # Added protection to check that 'note' exists and additionally
461 # verify that it is managed by OSM
462 if (not cls_perSw
[s
][0]['config'] or
463 not cl
.get('note') or
464 self
.__MANAGED
_BY
_OSM
not in cl
['note']):
467 t_id
= note
.split(self
.__SEPARATOR
)[1]
468 result
= self
.client
.api
.get_task_by_id(t_id
)
469 if result
['workOrderUserDefinedStatus'] == 'Completed':
471 elif result
['workOrderUserDefinedStatus'] == 'Cancelled':
473 elif result
['workOrderUserDefinedStatus'] == 'Failed':
477 failed_switches
.append(s
)
479 error_msg
= 'Some works were cancelled in switches: {}'.format(str(failed_switches
))
482 error_msg
= 'Some works failed in switches: {}'.format(str(failed_switches
))
485 error_msg
= 'Some works are still under execution in switches: {}'.format(str(failed_switches
))
489 sdn_status
= 'ACTIVE'
491 return {'sdn_status': sdn_status
,
492 'error_msg': error_msg
,
493 'sdn_info': sdn_info
}
494 except CvpLoginError
as e
:
495 self
.logger
.info(str(e
))
497 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
498 http_code
=401) from e
499 except Exception as ex
:
501 self
.logger
.error(str(ex
), exc_info
=True)
502 raise SdnConnectorError(message
=str(ex
),
503 http_code
=500) from ex
505 def create_connectivity_service(self
, service_type
, connection_points
,
507 """Stablish SDN/WAN connectivity between the endpoints
509 (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
510 :param connection_points: (list): each point corresponds to
511 an entry point to be connected. For WIM: from the DC
512 to the transport network.
513 For SDN: Compute/PCI to the transport network. One
514 connection point serves to identify the specific access and
515 some other service parameters, such as encapsulation type.
516 Each item of the list is a dict with:
517 "service_endpoint_id": (str)(uuid) Same meaning that for
518 'service_endpoint_mapping' (see __init__)
519 In case the config attribute mapping_not_needed is True,
520 this value is not relevant. In this case
521 it will contain the string "device_id:device_interface_id"
522 "service_endpoint_encapsulation_type": None, "dot1q", ...
523 "service_endpoint_encapsulation_info": (dict) with:
524 "vlan": ..., (int, present if encapsulation is dot1q)
525 "vni": ... (int, present if encapsulation is vxlan),
526 "peers": [(ipv4_1), (ipv4_2)] (present if
527 encapsulation is vxlan)
529 "device_id": ..., same meaning that for
530 'service_endpoint_mapping' (see __init__)
531 "device_interface_id": same meaning that for
532 'service_endpoint_mapping' (see __init__)
533 "switch_dpid": ..., present if mapping has been found
534 for this device_id,device_interface_id
535 "switch_port": ... present if mapping has been found
536 for this device_id,device_interface_id
537 "service_mapping_info": present if mapping has
538 been found for this device_id,device_interface_id
539 :param kwargs: For future versions:
540 bandwidth (int): value in kilobytes
541 latency (int): value in milliseconds
542 Other QoS might be passed as keyword arguments.
543 :return: tuple: ``(service_id, conn_info)`` containing:
544 - *service_uuid* (str): UUID of the established
546 - *conn_info* (dict or None): Information to be
547 stored at the database (or ``None``).
548 This information will be provided to the
549 :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
550 **MUST** be JSON/YAML-serializable (plain data structures).
551 :raises: SdnConnectorError: In case of error. Nothing should be
552 created in this case.
553 Provide the parameter http_code
556 self
.logger
.debug("invoked create_connectivity_service '{}' ports: {}".
557 format(service_type
, connection_points
))
558 self
.__get
_Connection
()
559 self
.__check
_service
(service_type
,
563 service_uuid
= str(uuid
.uuid4())
565 self
.logger
.info("Service with uuid {} created.".
566 format(service_uuid
))
567 s_uid
, s_connInf
= self
.__processConnection
(
573 self
.__addMetadata
(s_uid
, service_type
, s_connInf
['vlan_id'])
574 except Exception as e
:
577 return (s_uid
, s_connInf
)
578 except CvpLoginError
as e
:
579 self
.logger
.info(str(e
))
581 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
582 http_code
=401) from e
583 except SdnConnectorError
as sde
:
585 except Exception as ex
:
587 self
.logger
.error(str(ex
), exc_info
=True)
588 if self
.raiseException
:
590 raise SdnConnectorError(message
=str(ex
),
591 http_code
=500) from ex
593 def __processConnection(self
,
599 Invoked from creation and edit methods
601 Process the connection points array,
602 creating a set of configuration per switch where it has to be applied
603 for creating the configuration, the switches have to be queried for obtaining:
604 - the loopback address
605 - the BGP ASN (autonomous system number)
606 - the interface name of the MAC address to add in the connectivity service
607 Once the new configuration is ready, the __updateConnection method is invoked for appling the changes
616 vlan_processed
= False
619 processed_connection_points
= []
620 for cp
in connection_points
:
622 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
623 if not vlan_processed
:
624 vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
627 vni_id
= encap_info
.get(self
.__VNI
_PARAM
)
629 vni_id
= str(10000 + int(vlan_id
))
631 if service_type
== self
.__service
_types
_ELAN
:
632 cl_vlan
= self
.clC
.getElan_vlan(service_uuid
,
636 cl_vlan
= self
.clC
.getEline_vlan(service_uuid
,
639 vlan_processed
= True
641 encap_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
642 switch_id
= encap_info
.get(self
.__SW
_ID
_PARAM
)
644 point_mac
= encap_info
.get(self
.__MAC
_PARAM
)
645 switches
= self
.__lldp
_find
_neighbor
("chassisId", point_mac
)
646 self
.logger
.debug("Found connection point for MAC {}: {}".
647 format(point_mac
, switches
))
649 interface
= encap_info
.get(self
.__SW
_PORT
_PARAM
)
650 switches
= [{'name': switch_id
, 'interface': interface
}]
652 if len(switches
) == 0:
653 raise SdnConnectorError(message
="Connection point MAC address {} not found in the switches".format(point_mac
),
656 # remove those connections that are equal. This happens when several sriovs are located in the same
657 # compute node interface, that is, in the same switch and interface
658 switches
= [x
for x
in switches
if x
not in processed_connection_points
]
661 processed_connection_points
+= switches
662 for switch
in switches
:
664 port_channel
= self
.__get
_switch
_po
(switch
['name'],
666 if len(port_channel
) > 0:
667 interface
= port_channel
[0]
669 interface
= switch
['interface']
671 raise SdnConnectorError(message
="Connection point switch port empty for switch_dpid {}".format(switch_id
),
673 # it should be only one switch where the mac is attached
674 if encap_type
== 'dot1q':
675 # SRIOV configLet for Leaf switch mac's attached to
676 if service_type
== self
.__service
_types
_ELAN
:
677 cl_encap
= self
.clC
.getElan_sriov(service_uuid
, interface
, vlan_id
, i
)
679 cl_encap
= self
.clC
.getEline_sriov(service_uuid
, interface
, vlan_id
, i
)
681 # PT configLet for Leaf switch attached to the mac
682 if service_type
== self
.__service
_types
_ELAN
:
683 cl_encap
= self
.clC
.getElan_passthrough(service_uuid
,
687 cl_encap
= self
.clC
.getEline_passthrough(service_uuid
,
690 if cls_cp
.get(switch
['name']):
691 cls_cp
[switch
['name']] = str(cls_cp
[switch
['name']]) + cl_encap
693 cls_cp
[switch
['name']] = cl_encap
695 # at least 1 connection point has to be received
696 if not vlan_processed
:
697 raise SdnConnectorError(message
=SdnError
.UNSUPPORTED_FEATURE
,
701 # for cl in cp_configLets:
702 cl_name
= (self
.__OSM
_PREFIX
+
704 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
705 self
.__SEPARATOR
+ service_uuid
)
706 # apply VLAN and BGP configLet to all Leaf switches
707 if service_type
== self
.__service
_types
_ELAN
:
708 cl_bgp
[s
] = self
.clC
.getElan_bgp(service_uuid
,
711 self
.switches
[s
]['lo0'],
712 self
.switches
[s
]['AS'])
714 cl_bgp
[s
] = self
.clC
.getEline_bgp(service_uuid
,
717 self
.switches
[s
]['lo0'],
718 self
.switches
[s
]['AS'])
720 if not cls_cp
.get(s
):
723 cl_config
= str(cl_vlan
) + str(cl_bgp
[s
]) + str(cls_cp
[s
])
725 cls_perSw
[s
] = [{'name': cl_name
, 'config': cl_config
}]
727 allLeafConfigured
, allLeafModified
= self
.__updateConnection
(cls_perSw
)
730 "uuid": service_uuid
,
732 "service_type": service_type
,
734 "connection_points": connection_points
,
735 "configLetPerSwitch": cls_perSw
,
736 'allLeafConfigured': allLeafConfigured
,
737 'allLeafModified': allLeafModified
}
739 return service_uuid
, conn_info
740 except Exception as ex
:
741 self
.logger
.debug("Exception processing connection {}: {}".
742 format(service_uuid
, str(ex
)))
745 def __updateConnection(self
, cls_perSw
):
746 """ Invoked in the creation and modification
748 checks if the new connection points config is:
749 - already in the Cloud Vision, the configLet is modified, and applied to the switch,
750 executing the corresponding task
751 - if it has to be removed:
752 then configuration has to be removed from the switch executing the corresponding task,
753 before trying to remove the configuration
754 - created, the configuration set is created, associated to the switch, and the associated
755 task to the configLet modification executed
756 In case of any error, rollback is executed, removing the created elements, and restoring to the
760 allLeafConfigured
= {}
764 allLeafConfigured
[s
] = False
765 allLeafModified
[s
] = False
769 toDelete_in_cvp
= False
770 if not (cls_perSw
.get(s
) and cls_perSw
[s
][0].get('config')):
771 # when there is no configuration, means that there is no interface
772 # in the switch to be connected, so the configLet has to be removed from CloudVision
773 # after removing the ConfigLet fron the switch if it was already there
775 # get config let name and key
778 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
[0]['name'])
780 cl_toDelete
.append(cvp_cl
)
782 toDelete_in_cvp
= True
783 except CvpApiError
as error
:
784 if "Entity does not exist" in error
.msg
:
788 # remove configLet from device
790 res
= self
.__configlet
_modify
(cls_perSw
[s
])
791 allLeafConfigured
[s
] = res
[0]
792 if not allLeafConfigured
[s
]:
795 res
= self
.__device
_modify
(
798 delete
=toDelete_in_cvp
)
799 if "errorMessage" in str(res
):
800 raise Exception(str(res
))
801 self
.logger
.info("Device {} modify result {}".format(s
, res
))
802 for t_id
in res
[1]['tasks']:
803 if not toDelete_in_cvp
:
804 tasks
[t_id
] = {'workOrderId': t_id
}
805 note_msg
= "{}{}{}{}##".format(self
.__MANAGED
_BY
_OSM
,
809 self
.client
.api
.add_note_to_configlet(
810 cls_perSw
[s
][0]['key'],
812 cls_perSw
[s
][0]['note'] = note_msg
814 delete_tasks
= { t_id
: {'workOrderId': t_id
} }
815 self
.__exec
_task
(delete_tasks
)
816 # with just one configLet assigned to a device,
817 # delete all if there are errors in next loops
818 if not toDelete_in_cvp
:
819 allLeafModified
[s
] = True
821 self
.__exec
_task
(tasks
, self
.__EXC
_TASK
_EXEC
_WAIT
)
822 if len(cl_toDelete
) > 0:
823 self
.__configlet
_modify
(cl_toDelete
, delete
=True)
825 return allLeafConfigured
, allLeafModified
826 except Exception as ex
:
828 self
.__rollbackConnection
(cls_perSw
,
831 except Exception as e
:
832 self
.logger
.error("Exception rolling back in updating connection: {}".
833 format(e
), exc_info
=True)
836 def __rollbackConnection(self
,
840 """ Removes the given configLet from the devices and then remove the configLets
843 if allLeafModified
[s
]:
845 res
= self
.__device
_modify
(
847 new_configlets
=cls_perSw
[s
],
849 if "errorMessage" in str(res
):
850 raise Exception(str(res
))
852 for t_id
in res
[1]['tasks']:
853 tasks
[t_id
] = {'workOrderId': t_id
}
854 self
.__exec
_task
(tasks
)
855 self
.logger
.info("Device {} modify result {}".format(s
, res
))
856 except Exception as e
:
857 self
.logger
.error('Error removing configlets from device {}: {}'.format(s
, e
))
860 if allLeafConfigured
[s
]:
861 self
.__configlet
_modify
(cls_perSw
[s
], delete
=True)
863 def __exec_task(self
, tasks
, tout
=10):
864 if self
.taskC
is None:
866 data
= self
.taskC
.update_all_tasks(tasks
).values()
867 self
.taskC
.task_action(data
, tout
, 'executed')
869 def __device_modify(self
, device_to_update
, new_configlets
, delete
):
870 """ Updates the devices (switches) adding or removing the configLet,
871 the tasks Id's associated to the change are returned
873 self
.logger
.info('Enter in __device_modify delete: {}'.format(
877 # Task Ids that have been identified during device actions
880 if (len(new_configlets
) == 0 or
881 device_to_update
is None or
882 len(device_to_update
) == 0):
883 data
= {'updated': updated
, 'tasks': newTasks
}
884 return [changed
, data
]
886 self
.__load
_inventory
()
888 allDeviceFacts
= self
.allDeviceFacts
889 # Work through Devices list adding device specific information
891 for try_device
in allDeviceFacts
:
892 # Add Device Specific Configlets
893 # self.logger.debug(device)
894 if try_device
['hostname'] not in device_to_update
:
896 dev_cvp_configlets
= self
.client
.api
.get_configlets_by_device_id(
897 try_device
['systemMacAddress'])
898 # self.logger.debug(dev_cvp_configlets)
899 try_device
['deviceSpecificConfiglets'] = []
900 for cvp_configlet
in dev_cvp_configlets
:
901 if int(cvp_configlet
['containerCount']) == 0:
902 try_device
['deviceSpecificConfiglets'].append(
903 {'name': cvp_configlet
['name'],
904 'key': cvp_configlet
['key']})
905 # self.logger.debug(device)
909 # Check assigned configlets
910 device_update
= False
912 remove_configlets
= []
916 for cvp_configlet
in device
['deviceSpecificConfiglets']:
917 for cl
in new_configlets
:
918 if cvp_configlet
['name'] == cl
['name']:
919 remove_configlets
.append(cvp_configlet
)
922 for configlet
in new_configlets
:
923 if configlet
not in device
['deviceSpecificConfiglets']:
924 add_configlets
.append(configlet
)
927 update_devices
.append({'hostname': device
['hostname'],
928 'configlets': [add_configlets
,
931 self
.logger
.info("Device to modify: {}".format(update_devices
))
933 up_device
= update_devices
[0]
934 cl_toAdd
= up_device
['configlets'][0]
935 cl_toDel
= up_device
['configlets'][1]
938 if delete
and len(cl_toDel
) > 0:
939 r
= self
.client
.api
.remove_configlets_from_device(
945 self
.logger
.debug("remove_configlets_from_device {} {}".format(dev_action
, cl_toDel
))
946 elif len(cl_toAdd
) > 0:
947 r
= self
.client
.api
.apply_configlets_to_device(
953 self
.logger
.debug("apply_configlets_to_device {} {}".format(dev_action
, cl_toAdd
))
955 except Exception as error
:
956 errorMessage
= str(error
)
957 msg
= "errorMessage: Device {} Configlets couldnot be updated: {}".format(
958 up_device
['hostname'], errorMessage
)
959 raise SdnConnectorError(msg
) from error
961 if "errorMessage" in str(dev_action
):
962 m
= "Device {} Configlets update fail: {}".format(
963 up_device
['name'], dev_action
['errorMessage'])
964 raise SdnConnectorError(m
)
967 if 'taskIds' in str(dev_action
):
968 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
969 if not dev_action
['data']['taskIds']:
970 raise SdnConnectorError("No taskIds found: Device {} Configlets couldnot be updated".format(
971 up_device
['hostname']))
972 for taskId
in dev_action
['data']['taskIds']:
973 updated
.append({up_device
['hostname']:
974 "Configlets-{}".format(
976 newTasks
.append(taskId
)
978 updated
.append({up_device
['hostname']:
979 "Configlets-No_Specific_Tasks"})
980 data
= {'updated': updated
, 'tasks': newTasks
}
981 return [changed
, data
]
983 def __configlet_modify(self
, configletsToApply
, delete
=False):
984 ''' adds/update or delete the provided configLets
985 :param configletsToApply: list of configLets to apply
986 :param delete: flag to indicate if the configLets have to be deleted
987 from Cloud Vision Portal
988 :return: data: dict of module actions and taskIDs
990 self
.logger
.info('Enter in __configlet_modify delete:{}'.format(
993 # Compare configlets against cvp_facts-configlets
1000 for cl
in configletsToApply
:
1001 found_in_cvp
= False
1007 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
['name'])
1008 cl
['key'] = cvp_cl
['key']
1009 cl
['note'] = cvp_cl
['note']
1011 except CvpApiError
as error
:
1012 if "Entity does not exist" in error
.msg
:
1020 configlet
= {'name': cvp_cl
['name'],
1024 cl_compare
= self
.__compare
(cl
['config'],
1026 # compare function returns a floating point number
1027 if cl_compare
[0] != 100.0:
1029 configlet
= {'name': cl
['name'],
1031 'config': cl
['config']}
1034 configlet
= {'name': cl
['name'],
1035 'key': cvp_cl
['key'],
1037 'config': cl
['config']}
1040 configlet
= {'name': cl
['name'],
1041 'config': cl
['config']}
1044 operation
= 'delete'
1045 resp
= self
.client
.api
.delete_configlet(
1046 configlet
['data']['name'],
1047 configlet
['data']['key'])
1049 operation
= 'update'
1050 resp
= self
.client
.api
.update_configlet(
1051 configlet
['config'],
1052 configlet
['data']['key'],
1053 configlet
['data']['name'],
1056 operation
= 'create'
1057 resp
= self
.client
.api
.add_configlet(
1059 configlet
['config'])
1061 operation
= 'checked'
1063 except Exception as error
:
1064 errorMessage
= str(error
).split(':')[-1]
1065 message
= "Configlet {} cannot be {}: {}".format(
1066 cl
['name'], operation
, errorMessage
)
1068 deleted
.append({configlet
['name']: message
})
1070 updated
.append({configlet
['name']: message
})
1072 new
.append({configlet
['name']: message
})
1074 checked
.append({configlet
['name']: message
})
1077 if "error" in str(resp
).lower():
1078 message
= "Configlet {} cannot be deleted: {}".format(
1079 cl
['name'], resp
['errorMessage'])
1081 deleted
.append({configlet
['name']: message
})
1083 updated
.append({configlet
['name']: message
})
1085 new
.append({configlet
['name']: message
})
1087 checked
.append({configlet
['name']: message
})
1091 deleted
.append({configlet
['name']: "success"})
1094 updated
.append({configlet
['name']: "success"})
1097 cl
['key'] = resp
# This key is used in API call deviceApplyConfigLet FGA
1098 new
.append({configlet
['name']: "success"})
1101 checked
.append({configlet
['name']: "success"})
1103 data
= {'new': new
, 'updated': updated
, 'deleted': deleted
, 'checked': checked
}
1104 return [changed
, data
]
1106 def __get_configletsDevices(self
, configlets
):
1107 for s
in self
.s_api
:
1108 configlet
= configlets
[s
]
1109 # Add applied Devices
1110 if len(configlet
) > 0:
1111 configlet
['devices'] = []
1112 applied_devices
= self
.client
.api
.get_applied_devices(
1114 for device
in applied_devices
['data']:
1115 configlet
['devices'].append(device
['hostName'])
1117 def __get_serviceData(self
, service_uuid
, service_type
, vlan_id
, conn_info
=None):
1119 for s
in self
.s_api
:
1122 srv_cls
= self
.__get
_serviceConfigLets
(service_uuid
,
1125 self
.__get
_configletsDevices
(srv_cls
)
1126 for s
in self
.s_api
:
1129 for dev
in cl
['devices']:
1130 cls_perSw
[dev
].append(cl
)
1132 cls_perSw
= conn_info
['configLetPerSwitch']
1135 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
1137 Disconnect multi-site endpoints previously connected
1139 :param service_uuid: The one returned by create_connectivity_service
1140 :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
1141 if they do not return None
1143 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
1146 self
.logger
.debug('invoked delete_connectivity_service {}'.
1147 format(service_uuid
))
1148 if not service_uuid
:
1149 raise SdnConnectorError(message
='No connection service UUID',
1152 self
.__get
_Connection
()
1153 if conn_info
is None:
1154 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
1157 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
1158 conn_info
['service_type'],
1159 conn_info
['vlan_id'],
1161 allLeafConfigured
= {}
1162 allLeafModified
= {}
1163 for s
in self
.s_api
:
1164 allLeafConfigured
[s
] = True
1165 allLeafModified
[s
] = True
1166 found_in_cvp
= False
1167 for s
in self
.s_api
:
1171 self
.__rollbackConnection
(cls_perSw
,
1175 # if the service is not defined in Cloud Vision, return a 404 - NotFound error
1176 raise SdnConnectorError(message
='Service {} was not found in Arista Cloud Vision {}'.
1177 format(service_uuid
, self
.__wim
_url
),
1179 self
.__removeMetadata
(service_uuid
)
1180 except CvpLoginError
as e
:
1181 self
.logger
.info(str(e
))
1183 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1184 http_code
=401) from e
1185 except SdnConnectorError
as sde
:
1187 except Exception as ex
:
1189 self
.logger
.error(ex
)
1190 if self
.raiseException
:
1192 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1193 http_code
=500) from ex
1195 def __addMetadata(self
, service_uuid
, service_type
, vlan_id
):
1196 """ Adds the connectivity service from 'OSM_metadata' configLet
1198 found_in_cvp
= False
1200 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1202 except CvpApiError
as error
:
1203 if "Entity does not exist" in error
.msg
:
1208 new_serv
= '{} {} {} {}\n'.format(self
.__METADATA
_PREFIX
, service_type
, vlan_id
, service_uuid
)
1211 cl_config
= cvp_cl
['config'] + new_serv
1213 cl_config
= new_serv
1214 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1215 self
.__configlet
_modify
(cl_meta
)
1216 except Exception as e
:
1217 self
.logger
.error('Error in setting metadata in CloudVision from OSM for service {}: {}'.
1218 format(service_uuid
, str(e
)))
1221 def __removeMetadata(self
, service_uuid
):
1222 """ Removes the connectivity service from 'OSM_metadata' configLet
1224 found_in_cvp
= False
1226 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1228 except CvpApiError
as error
:
1229 if "Entity does not exist" in error
.msg
:
1235 if service_uuid
in cvp_cl
['config']:
1237 for line
in cvp_cl
['config'].split('\n'):
1238 if service_uuid
in line
:
1241 cl_config
= cl_config
+ line
1242 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1243 self
.__configlet
_modify
(cl_meta
)
1244 except Exception as e
:
1245 self
.logger
.error('Error in removing metadata in CloudVision from OSM for service {}: {}'.
1246 format(service_uuid
, str(e
)))
1249 def edit_connectivity_service(self
,
1252 connection_points
=None,
1254 """ Change an existing connectivity service.
1256 This method's arguments and return value follow the same convention as
1257 :meth:`~.create_connectivity_service`.
1259 :param service_uuid: UUID of the connectivity service.
1260 :param conn_info: (dict or None): Information previously returned
1261 by last call to create_connectivity_service
1262 or edit_connectivity_service
1263 :param connection_points: (list): If provided, the old list of
1264 connection points will be replaced.
1265 :param kwargs: Same meaning that create_connectivity_service
1266 :return: dict or None: Information to be updated and stored at
1268 When ``None`` is returned, no information should be changed.
1269 When an empty dict is returned, the database record will
1271 **MUST** be JSON/YAML-serializable (plain data structures).
1273 SdnConnectorError: In case of error.
1276 self
.logger
.debug('invoked edit_connectivity_service for service {}. ports: {}'.format(service_uuid
,
1279 if not service_uuid
:
1280 raise SdnConnectorError(message
='Unable to perform operation, missing or empty uuid',
1283 raise SdnConnectorError(message
='Unable to perform operation, missing or empty connection information',
1286 if connection_points
is None:
1289 self
.__get
_Connection
()
1291 cls_currentPerSw
= conn_info
['configLetPerSwitch']
1292 service_type
= conn_info
['service_type']
1294 self
.__check
_service
(service_type
,
1300 s_uid
, s_connInf
= self
.__processConnection
(
1305 self
.logger
.info("Service with uuid {} configuration updated".
1308 except CvpLoginError
as e
:
1309 self
.logger
.info(str(e
))
1311 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1312 http_code
=401) from e
1313 except SdnConnectorError
as sde
:
1315 except Exception as ex
:
1318 # TODO check if there are pending task, and cancel them before restoring
1319 self
.__updateConnection
(cls_currentPerSw
)
1320 except Exception as e
:
1321 self
.logger
.error("Unable to restore configuration in service {} after an error in the configuration updated: {}".
1322 format(service_uuid
, str(e
)))
1323 if self
.raiseException
:
1325 raise SdnConnectorError(message
=str(ex
),
1326 http_code
=500) from ex
1328 def clear_all_connectivity_services(self
):
1329 """ Removes all connectivity services from Arista CloudVision with two steps:
1330 - retrives all the services from Arista CloudVision
1331 - removes each service
1334 self
.logger
.debug('invoked AristaImpl ' +
1335 'clear_all_connectivity_services')
1336 self
.__get
_Connection
()
1337 s_list
= self
.__get
_srvUUIDs
()
1340 conn_info
['service_type'] = serv
['type']
1341 conn_info
['vlan_id'] = serv
['vlan']
1343 self
.delete_connectivity_service(serv
['uuid'], conn_info
)
1344 except CvpLoginError
as e
:
1345 self
.logger
.info(str(e
))
1347 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1348 http_code
=401) from e
1349 except SdnConnectorError
as sde
:
1351 except Exception as ex
:
1353 self
.logger
.error(ex
)
1354 if self
.raiseException
:
1356 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1357 http_code
=500) from ex
1359 def get_all_active_connectivity_services(self
):
1360 """ Return the uuid of all the active connectivity services with two steps:
1361 - retrives all the services from Arista CloudVision
1362 - retrives the status of each server
1365 self
.logger
.debug('invoked AristaImpl {}'.format(
1366 'get_all_active_connectivity_services'))
1367 self
.__get
_Connection
()
1368 s_list
= self
.__get
_srvUUIDs
()
1372 conn_info
['service_type'] = serv
['type']
1373 conn_info
['vlan_id'] = serv
['vlan']
1375 status
= self
.get_connectivity_service_status(serv
['uuid'], conn_info
)
1376 if status
['sdn_status'] == 'ACTIVE':
1377 result
.append(serv
['uuid'])
1379 except CvpLoginError
as e
:
1380 self
.logger
.info(str(e
))
1382 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1383 http_code
=401) from e
1384 except SdnConnectorError
as sde
:
1386 except Exception as ex
:
1388 self
.logger
.error(ex
)
1389 if self
.raiseException
:
1391 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1392 http_code
=500) from ex
1394 def __get_serviceConfigLets(self
, service_uuid
, service_type
, vlan_id
):
1395 """ Return the configLet's associated with a connectivity service,
1396 There should be one, as maximum, per device (switch) for a given
1397 connectivity service
1400 for s
in self
.s_api
:
1402 found_in_cvp
= False
1403 name
= (self
.__OSM
_PREFIX
+
1405 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
1406 self
.__SEPARATOR
+ service_uuid
)
1408 cvp_cl
= self
.client
.api
.get_configlet_by_name(name
)
1410 except CvpApiError
as error
:
1411 if "Entity does not exist" in error
.msg
:
1419 def __get_srvVLANs(self
):
1420 """ Returns a list with all the VLAN id's used in the connectivity services managed
1421 in tha Arista CloudVision by checking the 'OSM_metadata' configLet where this
1422 information is stored
1424 found_in_cvp
= False
1426 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1428 except CvpApiError
as error
:
1429 if "Entity does not exist" in error
.msg
:
1435 lines
= cvp_cl
['config'].split('\n')
1437 if self
.__METADATA
_PREFIX
in line
:
1438 s_vlan
= line
.split(' ')[3]
1441 if (s_vlan
is not None and
1443 s_vlan
not in s_vlan_list
):
1444 s_vlan_list
.append(s_vlan
)
1448 def __get_srvUUIDs(self
):
1449 """ Retrieves all the connectivity services, managed in tha Arista CloudVision
1450 by checking the 'OSM_metadata' configLet where this information is stored
1452 found_in_cvp
= False
1454 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1456 except CvpApiError
as error
:
1457 if "Entity does not exist" in error
.msg
:
1463 lines
= cvp_cl
['config'].split('\n')
1465 if self
.__METADATA
_PREFIX
in line
:
1466 line
= line
.split(' ')
1467 serv
= {'uuid': line
[4], 'type': line
[2], 'vlan': line
[3]}
1470 if (serv
is not None and
1472 serv
not in serv_list
):
1473 serv_list
.append(serv
)
1477 def __get_Connection(self
):
1478 """ Open a connection with Arista CloudVision,
1479 invoking the version retrival as test
1482 if self
.client
is None:
1483 self
.client
= self
.__connect
()
1484 self
.client
.api
.get_cvp_info()
1485 except (CvpSessionLogOutError
, RequestException
) as e
:
1486 self
.logger
.debug("Connection error '{}'. Reconnecting".format(e
))
1487 self
.client
= self
.__connect
()
1488 self
.client
.api
.get_cvp_info()
1490 def __connect(self
):
1491 ''' Connects to CVP device using user provided credentials from initialization.
1492 :return: CvpClient object with connection instantiated.
1494 client
= CvpClient()
1495 protocol
, _
, rest_url
= self
.__wim
_url
.rpartition("://")
1496 host
, _
, port
= rest_url
.partition(":")
1497 if port
and port
.endswith("/"):
1498 port
= int(port
[:-1])
1504 client
.connect([host
],
1507 protocol
=protocol
or "https",
1510 client
.api
= CvpApi(client
, request_timeout
=self
.__API
_REQUEST
_TOUT
)
1511 self
.taskC
= AristaCVPTask(client
.api
)
1514 def __compare(self
, fromText
, toText
, lines
=10):
1515 """ Compare text string in 'fromText' with 'toText' and produce
1516 diffRatio - a score as a float in the range [0, 1] 2.0*M / T
1517 T is the total number of elements in both sequences,
1518 M is the number of matches.
1519 Score - 1.0 if the sequences are identical, and
1520 0.0 if they have nothing in common.
1523 '- ' line unique to sequence 1
1524 '+ ' line unique to sequence 2
1525 ' ' line common to both sequences
1526 '? ' line not present in either input sequence
1528 fromlines
= fromText
.splitlines(1)
1529 tolines
= toText
.splitlines(1)
1530 diff
= list(difflib
.unified_diff(fromlines
, tolines
, n
=lines
))
1531 textComp
= difflib
.SequenceMatcher(None, fromText
, toText
)
1532 diffRatio
= round(textComp
.quick_ratio()*100, 2)
1533 return [diffRatio
, diff
]
1535 def __load_inventory(self
):
1536 """ Get Inventory Data for All Devices (aka switches) from the Arista CloudVision
1538 if not self
.cvp_inventory
:
1539 self
.cvp_inventory
= self
.client
.api
.get_inventory()
1540 self
.allDeviceFacts
= []
1541 for device
in self
.cvp_inventory
:
1542 self
.allDeviceFacts
.append(device
)
1544 def __get_tags(self
, name
, value
):
1545 if not self
.cvp_tags
:
1547 url
= '/api/v1/rest/analytics/tags/labels/devices/{}/value/{}/elements'.format(name
, value
)
1548 self
.logger
.debug('get_tags: URL {}'.format(url
))
1549 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1550 for dev
in data
['notifications']:
1551 for elem
in dev
['updates']:
1552 self
.cvp_tags
.append(elem
)
1553 self
.logger
.debug('Available devices with tag_name {} - value {}: {} '.format(name
, value
, self
.cvp_tags
))
1555 def is_valid_destination(self
, url
):
1556 """ Check that the provided WIM URL is correct
1558 if re
.match(self
.__regex
, url
):
1560 elif self
.is_valid_ipv4_address(url
):
1563 return self
.is_valid_ipv6_address(url
)
1565 def is_valid_ipv4_address(self
, address
):
1566 """ Checks that the given IP is IPv4 valid
1569 socket
.inet_pton(socket
.AF_INET
, address
)
1570 except AttributeError: # no inet_pton here, sorry
1572 socket
.inet_aton(address
)
1573 except socket
.error
:
1575 return address
.count('.') == 3
1576 except socket
.error
: # not a valid address
1580 def is_valid_ipv6_address(self
, address
):
1581 """ Checks that the given IP is IPv6 valid
1584 socket
.inet_pton(socket
.AF_INET6
, address
)
1585 except socket
.error
: # not a valid address
1589 def delete_keys_from_dict(self
, dict_del
, lst_keys
):
1590 dict_copy
= {k
: v
for k
, v
in dict_del
.items() if k
not in lst_keys
}
1591 for k
, v
in dict_copy
.items():
1592 if isinstance(v
, dict):
1593 dict_copy
[k
] = self
.delete_keys_from_dict(v
, lst_keys
)