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
, config
))
182 self
.allDeviceFacts
= []
183 self
.clC
= AristaSDNConfigLet()
185 self
.__load
_switches
()
187 def __load_switches(self
):
188 """ Retrieves the switches to configure in the following order
189 1. from incoming configuration:
190 1.1 using port mapping
191 using user and password from WIM
192 retrieving Lo0 and AS from switch
193 1.2 from 'switches' parameter,
194 if any parameter is not present
195 Lo0 and AS - it will be requested to the switch
196 usr and pass - from WIM configuration
197 2. Looking in the CloudVision inventory if not in configuration parameters
198 2.1 using the switches with the topology_type tag set to 'leaf'
199 2.2 using the switches whose parent container is 'leaf'
200 2.3 using the switches whose hostname contains with 'leaf'
202 All the search methods will be used
205 if self
.__config
and self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
206 for port
in self
.__config
.get(self
.__SERVICE
_ENDPOINT
_MAPPING
):
207 switch_dpid
= port
.get(self
.__SW
_ID
_PARAM
)
208 if switch_dpid
and switch_dpid
not in self
.switches
:
209 self
.switches
[switch_dpid
] = {'passwd': self
.__passwd
,
215 if self
.__config
and self
.__config
.get('switches'):
216 # Not directly from json, complete one by one
217 config_switches
= self
.__config
.get('switches')
218 for cs
, cs_content
in config_switches
.items():
219 if cs
not in self
.switches
:
220 self
.switches
[cs
] = {'passwd': self
.__passwd
, 'ip': None, 'usr': self
.__user
, 'lo0': None,'AS': None}
222 self
.switches
[cs
].update(cs_content
)
224 # Load the rest of the data
225 if self
.client
is None:
226 self
.client
= self
.__connect
()
227 self
.__load
_inventory
()
228 if not self
.switches
:
229 self
.__get
_tags
(self
.__SWITCH
_TAG
_NAME
, self
.__SWITCH
_TAG
_VALUE
)
230 for device
in self
.allDeviceFacts
:
231 # get the switches whose container parent is 'leaf',
232 # or the topology_tag is 'leaf'
233 # or the hostname contains 'leaf'
234 if ((device
['serialNumber'] in self
.cvp_tags
) or
235 (self
.__SWITCH
_TAG
_VALUE
in device
['containerName'].lower()) or
236 (self
.__SWITCH
_TAG
_VALUE
in device
['hostname'].lower())):
237 if not self
.switches
.get(device
['hostname']):
238 switch_data
= {'passwd': self
.__passwd
,
239 'ip': device
['ipAddress'],
243 self
.switches
[device
['hostname']] = switch_data
244 if len(self
.switches
) == 0:
245 self
.logger
.error("Unable to load Leaf switches from CVP")
248 # self.s_api are switch objects, one for each switch in self.switches,
249 # used to make eAPI calls by using switch.py module
251 for s
in self
.switches
:
252 if not self
.switches
[s
].get('ip'):
253 for device
in self
.allDeviceFacts
:
254 if device
['hostname'] == s
:
255 self
.switches
[s
]['ip'] = device
['ipAddress']
256 if self
.is_valid_destination(self
.switches
[s
].get('ip')):
257 self
.s_api
[s
] = AristaSwitch(host
=self
.switches
[s
]['ip'],
258 user
=self
.switches
[s
]['usr'],
259 passwd
=self
.switches
[s
]['passwd'],
261 # Each switch has a different loopback address,
262 # so it's a different configLet
263 if not self
.switches
[s
].get('lo0'):
264 inf
= self
.__get
_switch
_interface
_ip
(s
, 'Loopback0')
265 self
.switches
[s
]["lo0"] = inf
.split('/')[0]
266 if not self
.switches
[s
].get('AS'):
267 self
.switches
[s
]["AS"] = self
.__get
_switch
_asn
(s
)
268 self
.logger
.debug("Using Arista Leaf switches: {}".format(self
.switches
))
270 def __lldp_find_neighbor(self
, tlv_name
=None, tlv_value
=None):
271 """Returns a list of dicts where a mathing LLDP neighbor has been found
273 switch -> switch name
274 interface -> switch interface
279 # Get LLDP info from each switch
281 result
= self
.s_api
[s
].run("show lldp neighbors detail")
282 lldp_info
[s
] = result
[0]["lldpNeighbors"]
283 # Look LLDP match on each interface
284 # Note that eAPI returns [] for an interface with no LLDP neighbors
285 # in the corresponding interface lldpNeighborInfo field
286 for interface
in lldp_info
[s
]:
287 if lldp_info
[s
][interface
]["lldpNeighborInfo"]:
288 lldp_nInf
= lldp_info
[s
][interface
]["lldpNeighborInfo"][0]
289 if tlv_name
in lldp_nInf
:
290 if lldp_nInf
[tlv_name
] == tlv_value
:
291 r
.append({"name": s
, "interface": interface
})
295 def __get_switch_asn(self
, switch
):
296 """Returns switch ASN in default VRF
298 bgp_info
= self
.s_api
[switch
].run("show ip bgp summary")[0]
299 return(bgp_info
["vrfs"]["default"]["asn"])
301 def __get_switch_po(self
, switch
, interface
=None):
302 """Returns Port-Channels for a given interface
303 If interface is None returns a list with all PO interfaces
304 Note that if specified, interface should be exact name
305 for instance: Ethernet3 and not e3 eth3 and so on
307 po_inf
= self
.s_api
[switch
].run("show port-channel")[0]["portChannels"]
310 r
= [x
for x
in po_inf
if interface
in po_inf
[x
]["activePorts"]]
316 def __get_switch_interface_ip(self
, switch
, interface
=None):
317 """Returns interface primary ip
318 interface should be exact name
319 for instance: Ethernet3 and not ethernet 3, e3 eth3 and so on
321 cmd
= "show ip interface {}".format(interface
)
322 ip_info
= self
.s_api
[switch
].run(cmd
)[0]["interfaces"][interface
]
324 ip
= ip_info
["interfaceAddress"]["primaryIp"]["address"]
325 mask
= ip_info
["interfaceAddress"]["primaryIp"]["maskLen"]
327 return "{}/{}".format(ip
, mask
)
329 def __check_service(self
, service_type
, connection_points
,
330 check_vlan
=True, check_num_cp
=True, kwargs
=None):
331 """ Reviews the connection points elements looking for semantic errors in the incoming data
333 if service_type
not in self
.__supported
_service
_types
:
334 raise Exception("The service '{}' is not supported. Only '{}' are accepted".format(
336 self
.__supported
_service
_types
))
339 if (len(connection_points
) < 2):
340 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
341 if ((len(connection_points
) != self
.__ELINE
_num
_connection
_points
) and
342 (service_type
== self
.__service
_types
_ELINE
)):
343 raise Exception(SdnError
.CONNECTION_POINTS_SIZE
)
347 for cp
in connection_points
:
348 enc_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
350 enc_type
not in self
.__supported
_encapsulation
_types
):
351 raise Exception(SdnError
.ENCAPSULATION_TYPE
)
352 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
353 cp_vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
357 elif vlan_id
!= cp_vlan_id
:
358 raise Exception(SdnError
.VLAN_INCONSISTENT
)
360 raise Exception(SdnError
.VLAN_NOT_PROVIDED
)
361 if vlan_id
in self
.__get
_srvVLANs
():
362 raise Exception('VLAN {} already assigned to a connectivity service'.format(vlan_id
))
364 # Commented out for as long as parameter isn't implemented
365 # bandwidth = kwargs.get(self.__BANDWIDTH_PARAM)
366 # if not isinstance(bandwidth, int):
367 # self.__exception(SdnError.BANDWIDTH, http_code=400)
369 # Commented out for as long as parameter isn't implemented
370 # backup = kwargs.get(self.__BACKUP_PARAM)
371 # if not isinstance(backup, bool):
372 # self.__exception(SdnError.BACKUP, http_code=400)
374 def check_credentials(self
):
375 """Retrieves the CloudVision version information, as the easiest way
376 for testing the access to CloudVision API
379 if self
.client
is None:
380 self
.client
= self
.__connect
()
381 result
= self
.client
.api
.get_cvp_info()
382 self
.logger
.debug(result
)
383 except CvpLoginError
as e
:
384 self
.logger
.info(str(e
))
386 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
387 http_code
=401) from e
388 except Exception as ex
:
390 self
.logger
.error(str(ex
))
391 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
392 http_code
=500) from ex
394 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
395 """Monitor the status of the connectivity service established
397 service_uuid (str): UUID of the connectivity service
398 conn_info (dict or None): Information returned by the connector
399 during the service creation/edition and subsequently stored in
403 dict: JSON/YAML-serializable dict that contains a mandatory key
404 ``sdn_status`` associated with one of the following values::
406 {'sdn_status': 'ACTIVE'}
407 # The service is up and running.
409 {'sdn_status': 'INACTIVE'}
410 # The service was created, but the connector
411 # cannot determine yet if connectivity exists
412 # (ideally, the caller needs to wait and check again).
414 {'sdn_status': 'DOWN'}
415 # Connection was previously established,
416 # but an error/failure was detected.
418 {'sdn_status': 'ERROR'}
419 # An error occurred when trying to create the service/
420 # establish the connectivity.
422 {'sdn_status': 'BUILD'}
423 # Still trying to create the service, the caller
424 # needs to wait and check again.
426 Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
427 keys can be used to provide additional status explanation or
428 new information available for the connectivity service.
431 self
.logger
.debug("invoked get_connectivity_service_status '{}'".format(service_uuid
))
433 raise SdnConnectorError(message
='No connection service UUID',
436 self
.__get
_Connection
()
437 if conn_info
is None:
438 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
441 if 'configLetPerSwitch' in conn_info
.keys():
445 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
446 conn_info
['service_type'],
447 conn_info
['vlan_id'],
450 t_isCancelled
= False
455 if (len(cls_perSw
[s
]) > 0):
456 for cl
in cls_perSw
[s
]:
457 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
458 # Added protection to check that 'note' exists and additionally
459 # verify that it is managed by OSM
460 if (not cls_perSw
[s
][0]['config'] or
461 not cl
.get('note') or
462 self
.__MANAGED
_BY
_OSM
not in cl
['note']):
465 t_id
= note
.split(self
.__SEPARATOR
)[1]
466 result
= self
.client
.api
.get_task_by_id(t_id
)
467 if result
['workOrderUserDefinedStatus'] == 'Completed':
469 elif result
['workOrderUserDefinedStatus'] == 'Cancelled':
471 elif result
['workOrderUserDefinedStatus'] == 'Failed':
475 failed_switches
.append(s
)
477 error_msg
= 'Some works were cancelled in switches: {}'.format(str(failed_switches
))
480 error_msg
= 'Some works failed in switches: {}'.format(str(failed_switches
))
483 error_msg
= 'Some works are still under execution in switches: {}'.format(str(failed_switches
))
487 sdn_status
= 'ACTIVE'
489 return {'sdn_status': sdn_status
,
490 'error_msg': error_msg
,
491 'sdn_info': sdn_info
}
492 except CvpLoginError
as e
:
493 self
.logger
.info(str(e
))
495 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
496 http_code
=401) from e
497 except Exception as ex
:
499 self
.logger
.error(str(ex
), exc_info
=True)
500 raise SdnConnectorError(message
=str(ex
),
501 http_code
=500) from ex
503 def create_connectivity_service(self
, service_type
, connection_points
,
505 """Stablish SDN/WAN connectivity between the endpoints
507 (str): ``ELINE`` (L2), ``ELAN`` (L2), ``ETREE`` (L2), ``L3``.
508 :param connection_points: (list): each point corresponds to
509 an entry point to be connected. For WIM: from the DC
510 to the transport network.
511 For SDN: Compute/PCI to the transport network. One
512 connection point serves to identify the specific access and
513 some other service parameters, such as encapsulation type.
514 Each item of the list is a dict with:
515 "service_endpoint_id": (str)(uuid) Same meaning that for
516 'service_endpoint_mapping' (see __init__)
517 In case the config attribute mapping_not_needed is True,
518 this value is not relevant. In this case
519 it will contain the string "device_id:device_interface_id"
520 "service_endpoint_encapsulation_type": None, "dot1q", ...
521 "service_endpoint_encapsulation_info": (dict) with:
522 "vlan": ..., (int, present if encapsulation is dot1q)
523 "vni": ... (int, present if encapsulation is vxlan),
524 "peers": [(ipv4_1), (ipv4_2)] (present if
525 encapsulation is vxlan)
527 "device_id": ..., same meaning that for
528 'service_endpoint_mapping' (see __init__)
529 "device_interface_id": same meaning that for
530 'service_endpoint_mapping' (see __init__)
531 "switch_dpid": ..., present if mapping has been found
532 for this device_id,device_interface_id
533 "switch_port": ... present if mapping has been found
534 for this device_id,device_interface_id
535 "service_mapping_info": present if mapping has
536 been found for this device_id,device_interface_id
537 :param kwargs: For future versions:
538 bandwidth (int): value in kilobytes
539 latency (int): value in milliseconds
540 Other QoS might be passed as keyword arguments.
541 :return: tuple: ``(service_id, conn_info)`` containing:
542 - *service_uuid* (str): UUID of the established
544 - *conn_info* (dict or None): Information to be
545 stored at the database (or ``None``).
546 This information will be provided to the
547 :meth:`~.edit_connectivity_service` and :obj:`~.delete`.
548 **MUST** be JSON/YAML-serializable (plain data structures).
549 :raises: SdnConnectorError: In case of error. Nothing should be
550 created in this case.
551 Provide the parameter http_code
554 self
.logger
.debug("invoked create_connectivity_service '{}' ports: {}".
555 format(service_type
, connection_points
))
556 self
.__get
_Connection
()
557 self
.__check
_service
(service_type
,
561 service_uuid
= str(uuid
.uuid4())
563 self
.logger
.info("Service with uuid {} created.".
564 format(service_uuid
))
565 s_uid
, s_connInf
= self
.__processConnection
(
571 self
.__addMetadata
(s_uid
, service_type
, s_connInf
['vlan_id'])
572 except Exception as e
:
575 return (s_uid
, s_connInf
)
576 except CvpLoginError
as e
:
577 self
.logger
.info(str(e
))
579 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
580 http_code
=401) from e
581 except SdnConnectorError
as sde
:
583 except Exception as ex
:
585 self
.logger
.error(str(ex
), exc_info
=True)
586 if self
.raiseException
:
588 raise SdnConnectorError(message
=str(ex
),
589 http_code
=500) from ex
591 def __processConnection(self
,
597 Invoked from creation and edit methods
599 Process the connection points array,
600 creating a set of configuration per switch where it has to be applied
601 for creating the configuration, the switches have to be queried for obtaining:
602 - the loopback address
603 - the BGP ASN (autonomous system number)
604 - the interface name of the MAC address to add in the connectivity service
605 Once the new configuration is ready, the __updateConnection method is invoked for appling the changes
614 vlan_processed
= False
617 processed_connection_points
= []
618 for cp
in connection_points
:
620 encap_info
= cp
.get(self
.__ENCAPSULATION
_INFO
_PARAM
)
621 if not vlan_processed
:
622 vlan_id
= str(encap_info
.get(self
.__VLAN
_PARAM
))
625 vni_id
= encap_info
.get(self
.__VNI
_PARAM
)
627 vni_id
= str(10000 + int(vlan_id
))
629 if service_type
== self
.__service
_types
_ELAN
:
630 cl_vlan
= self
.clC
.getElan_vlan(service_uuid
,
634 cl_vlan
= self
.clC
.getEline_vlan(service_uuid
,
637 vlan_processed
= True
639 encap_type
= cp
.get(self
.__ENCAPSULATION
_TYPE
_PARAM
)
640 switch_id
= encap_info
.get(self
.__SW
_ID
_PARAM
)
642 point_mac
= encap_info
.get(self
.__MAC
_PARAM
)
643 switches
= self
.__lldp
_find
_neighbor
("chassisId", point_mac
)
644 self
.logger
.debug("Found connection point for MAC {}: {}".
645 format(point_mac
, switches
))
647 interface
= encap_info
.get(self
.__SW
_PORT
_PARAM
)
648 switches
= [{'name': switch_id
, 'interface': interface
}]
650 if len(switches
) == 0:
651 raise SdnConnectorError(message
="Connection point MAC address {} not found in the switches".format(point_mac
),
654 # remove those connections that are equal. This happens when several sriovs are located in the same
655 # compute node interface, that is, in the same switch and interface
656 switches
= [x
for x
in switches
if x
not in processed_connection_points
]
659 processed_connection_points
+= switches
660 for switch
in switches
:
662 port_channel
= self
.__get
_switch
_po
(switch
['name'],
664 if len(port_channel
) > 0:
665 interface
= port_channel
[0]
667 interface
= switch
['interface']
669 raise SdnConnectorError(message
="Connection point switch port empty for switch_dpid {}".format(switch_id
),
671 # it should be only one switch where the mac is attached
672 if encap_type
== 'dot1q':
673 # SRIOV configLet for Leaf switch mac's attached to
674 if service_type
== self
.__service
_types
_ELAN
:
675 cl_encap
= self
.clC
.getElan_sriov(service_uuid
, interface
, vlan_id
, i
)
677 cl_encap
= self
.clC
.getEline_sriov(service_uuid
, interface
, vlan_id
, i
)
679 # PT configLet for Leaf switch attached to the mac
680 if service_type
== self
.__service
_types
_ELAN
:
681 cl_encap
= self
.clC
.getElan_passthrough(service_uuid
,
685 cl_encap
= self
.clC
.getEline_passthrough(service_uuid
,
688 if cls_cp
.get(switch
['name']):
689 cls_cp
[switch
['name']] = str(cls_cp
[switch
['name']]) + cl_encap
691 cls_cp
[switch
['name']] = cl_encap
693 # at least 1 connection point has to be received
694 if not vlan_processed
:
695 raise SdnConnectorError(message
=SdnError
.UNSUPPORTED_FEATURE
,
699 # for cl in cp_configLets:
700 cl_name
= (self
.__OSM
_PREFIX
+
702 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
703 self
.__SEPARATOR
+ service_uuid
)
704 # apply VLAN and BGP configLet to all Leaf switches
705 if service_type
== self
.__service
_types
_ELAN
:
706 cl_bgp
[s
] = self
.clC
.getElan_bgp(service_uuid
,
709 self
.switches
[s
]['lo0'],
710 self
.switches
[s
]['AS'])
712 cl_bgp
[s
] = self
.clC
.getEline_bgp(service_uuid
,
715 self
.switches
[s
]['lo0'],
716 self
.switches
[s
]['AS'])
718 if not cls_cp
.get(s
):
721 cl_config
= str(cl_vlan
) + str(cl_bgp
[s
]) + str(cls_cp
[s
])
723 cls_perSw
[s
] = [{'name': cl_name
, 'config': cl_config
}]
725 allLeafConfigured
, allLeafModified
= self
.__updateConnection
(cls_perSw
)
728 "uuid": service_uuid
,
730 "service_type": service_type
,
732 "connection_points": connection_points
,
733 "configLetPerSwitch": cls_perSw
,
734 'allLeafConfigured': allLeafConfigured
,
735 'allLeafModified': allLeafModified
}
737 return service_uuid
, conn_info
738 except Exception as ex
:
739 self
.logger
.debug("Exception processing connection {}: {}".
740 format(service_uuid
, str(ex
)))
743 def __updateConnection(self
, cls_perSw
):
744 """ Invoked in the creation and modification
746 checks if the new connection points config is:
747 - already in the Cloud Vision, the configLet is modified, and applied to the switch,
748 executing the corresponding task
749 - if it has to be removed:
750 then configuration has to be removed from the switch executing the corresponding task,
751 before trying to remove the configuration
752 - created, the configuration set is created, associated to the switch, and the associated
753 task to the configLet modification executed
754 In case of any error, rollback is executed, removing the created elements, and restoring to the
758 allLeafConfigured
= {}
762 allLeafConfigured
[s
] = False
763 allLeafModified
[s
] = False
767 toDelete_in_cvp
= False
768 if not (cls_perSw
.get(s
) and cls_perSw
[s
][0].get('config')):
769 # when there is no configuration, means that there is no interface
770 # in the switch to be connected, so the configLet has to be removed from CloudVision
771 # after removing the ConfigLet fron the switch if it was already there
773 # get config let name and key
776 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
[0]['name'])
778 cl_toDelete
.append(cvp_cl
)
780 toDelete_in_cvp
= True
781 except CvpApiError
as error
:
782 if "Entity does not exist" in error
.msg
:
786 # remove configLet from device
788 res
= self
.__configlet
_modify
(cls_perSw
[s
])
789 allLeafConfigured
[s
] = res
[0]
790 if not allLeafConfigured
[s
]:
793 res
= self
.__device
_modify
(
796 delete
=toDelete_in_cvp
)
797 if "errorMessage" in str(res
):
798 raise Exception(str(res
))
799 self
.logger
.info("Device {} modify result {}".format(s
, res
))
800 for t_id
in res
[1]['tasks']:
801 tasks
[t_id
] = {'workOrderId': t_id
}
802 if not toDelete_in_cvp
:
803 note_msg
= "{}{}{}{}##".format(self
.__MANAGED
_BY
_OSM
,
807 self
.client
.api
.add_note_to_configlet(
808 cls_perSw
[s
][0]['key'],
810 cls_perSw
[s
][0]['note'] = note_msg
811 # with just one configLet assigned to a device,
812 # delete all if there are errors in next loops
813 if not toDelete_in_cvp
:
814 allLeafModified
[s
] = True
815 if self
.taskC
is None:
817 data
= self
.taskC
.update_all_tasks(tasks
).values()
818 self
.taskC
.task_action(data
,
819 self
.__EXC
_TASK
_EXEC
_WAIT
,
821 if len(cl_toDelete
) > 0:
822 self
.__configlet
_modify
(cl_toDelete
, delete
=True)
823 return allLeafConfigured
, allLeafModified
824 except Exception as ex
:
826 self
.__rollbackConnection
(cls_perSw
,
829 except Exception as e
:
830 self
.logger
.error("Exception rolling back in updating connection: {}".
831 format(e
), exc_info
=True)
834 def __rollbackConnection(self
,
838 """ Removes the given configLet from the devices and then remove the configLets
842 if allLeafModified
[s
]:
844 res
= self
.__device
_modify
(
846 new_configlets
=cls_perSw
[s
],
848 if "errorMessage" in str(res
):
849 raise Exception(str(res
))
850 for t_id
in res
[1]['tasks']:
851 tasks
[t_id
] = {'workOrderId': t_id
}
852 self
.logger
.info("Device {} modify result {}".format(s
, res
))
853 except Exception as e
:
854 self
.logger
.error('Error removing configlets from device {}: {}'.format(s
, e
))
856 if self
.taskC
is None:
858 data
= self
.taskC
.update_all_tasks(tasks
).values()
859 self
.taskC
.task_action(data
,
860 self
.__ROLLB
_TASK
_EXEC
_WAIT
,
863 if allLeafConfigured
[s
]:
864 self
.__configlet
_modify
(cls_perSw
[s
], delete
=True)
866 def __device_modify(self
, device_to_update
, new_configlets
, delete
):
867 """ Updates the devices (switches) adding or removing the configLet,
868 the tasks Id's associated to the change are returned
870 self
.logger
.info('Enter in __device_modify delete: {}'.format(
874 # Task Ids that have been identified during device actions
877 if (len(new_configlets
) == 0 or
878 device_to_update
is None or
879 len(device_to_update
) == 0):
880 data
= {'updated': updated
, 'tasks': newTasks
}
881 return [changed
, data
]
883 self
.__load
_inventory
()
885 allDeviceFacts
= self
.allDeviceFacts
886 # Work through Devices list adding device specific information
888 for try_device
in allDeviceFacts
:
889 # Add Device Specific Configlets
890 # self.logger.debug(device)
891 if try_device
['hostname'] not in device_to_update
:
893 dev_cvp_configlets
= self
.client
.api
.get_configlets_by_device_id(
894 try_device
['systemMacAddress'])
895 # self.logger.debug(dev_cvp_configlets)
896 try_device
['deviceSpecificConfiglets'] = []
897 for cvp_configlet
in dev_cvp_configlets
:
898 if int(cvp_configlet
['containerCount']) == 0:
899 try_device
['deviceSpecificConfiglets'].append(
900 {'name': cvp_configlet
['name'],
901 'key': cvp_configlet
['key']})
902 # self.logger.debug(device)
906 # Check assigned configlets
907 device_update
= False
909 remove_configlets
= []
913 for cvp_configlet
in device
['deviceSpecificConfiglets']:
914 for cl
in new_configlets
:
915 if cvp_configlet
['name'] == cl
['name']:
916 remove_configlets
.append(cvp_configlet
)
919 for configlet
in new_configlets
:
920 if configlet
not in device
['deviceSpecificConfiglets']:
921 add_configlets
.append(configlet
)
924 update_devices
.append({'hostname': device
['hostname'],
925 'configlets': [add_configlets
,
928 self
.logger
.info("Device to modify: {}".format(update_devices
))
930 up_device
= update_devices
[0]
931 cl_toAdd
= up_device
['configlets'][0]
932 cl_toDel
= up_device
['configlets'][1]
935 if delete
and len(cl_toDel
) > 0:
936 r
= self
.client
.api
.remove_configlets_from_device(
942 self
.logger
.debug("remove_configlets_from_device {} {}".format(dev_action
, cl_toDel
))
943 elif len(cl_toAdd
) > 0:
944 r
= self
.client
.api
.apply_configlets_to_device(
950 self
.logger
.debug("apply_configlets_to_device {} {}".format(dev_action
, cl_toAdd
))
952 except Exception as error
:
953 errorMessage
= str(error
)
954 msg
= "errorMessage: Device {} Configlets couldnot be updated: {}".format(
955 up_device
['hostname'], errorMessage
)
956 raise SdnConnectorError(msg
) from error
958 if "errorMessage" in str(dev_action
):
959 m
= "Device {} Configlets update fail: {}".format(
960 up_device
['name'], dev_action
['errorMessage'])
961 raise SdnConnectorError(m
)
964 if 'taskIds' in str(dev_action
):
965 # Fix 1030 SDN-ARISTA Key error note when deploy a NS
966 if not dev_action
['data']['taskIds']:
967 raise SdnConnectorError("No taskIds found: Device {} Configlets couldnot be updated".format(
968 up_device
['hostname']))
969 for taskId
in dev_action
['data']['taskIds']:
970 updated
.append({up_device
['hostname']:
971 "Configlets-{}".format(
973 newTasks
.append(taskId
)
975 updated
.append({up_device
['hostname']:
976 "Configlets-No_Specific_Tasks"})
977 data
= {'updated': updated
, 'tasks': newTasks
}
978 return [changed
, data
]
980 def __configlet_modify(self
, configletsToApply
, delete
=False):
981 ''' adds/update or delete the provided configLets
982 :param configletsToApply: list of configLets to apply
983 :param delete: flag to indicate if the configLets have to be deleted
984 from Cloud Vision Portal
985 :return: data: dict of module actions and taskIDs
987 self
.logger
.info('Enter in __configlet_modify delete:{}'.format(
990 # Compare configlets against cvp_facts-configlets
997 for cl
in configletsToApply
:
1004 cvp_cl
= self
.client
.api
.get_configlet_by_name(cl
['name'])
1005 cl
['key'] = cvp_cl
['key']
1006 cl
['note'] = cvp_cl
['note']
1008 except CvpApiError
as error
:
1009 if "Entity does not exist" in error
.msg
:
1017 configlet
= {'name': cvp_cl
['name'],
1021 cl_compare
= self
.__compare
(cl
['config'],
1023 # compare function returns a floating point number
1024 if cl_compare
[0] != 100.0:
1026 configlet
= {'name': cl
['name'],
1028 'config': cl
['config']}
1031 configlet
= {'name': cl
['name'],
1032 'key': cvp_cl
['key'],
1034 'config': cl
['config']}
1037 configlet
= {'name': cl
['name'],
1038 'config': cl
['config']}
1041 operation
= 'delete'
1042 resp
= self
.client
.api
.delete_configlet(
1043 configlet
['data']['name'],
1044 configlet
['data']['key'])
1046 operation
= 'update'
1047 resp
= self
.client
.api
.update_configlet(
1048 configlet
['config'],
1049 configlet
['data']['key'],
1050 configlet
['data']['name'],
1053 operation
= 'create'
1054 resp
= self
.client
.api
.add_configlet(
1056 configlet
['config'])
1058 operation
= 'checked'
1060 except Exception as error
:
1061 errorMessage
= str(error
).split(':')[-1]
1062 message
= "Configlet {} cannot be {}: {}".format(
1063 cl
['name'], operation
, errorMessage
)
1065 deleted
.append({configlet
['name']: message
})
1067 updated
.append({configlet
['name']: message
})
1069 new
.append({configlet
['name']: message
})
1071 checked
.append({configlet
['name']: message
})
1074 if "error" in str(resp
).lower():
1075 message
= "Configlet {} cannot be deleted: {}".format(
1076 cl
['name'], resp
['errorMessage'])
1078 deleted
.append({configlet
['name']: message
})
1080 updated
.append({configlet
['name']: message
})
1082 new
.append({configlet
['name']: message
})
1084 checked
.append({configlet
['name']: message
})
1088 deleted
.append({configlet
['name']: "success"})
1091 updated
.append({configlet
['name']: "success"})
1094 cl
['key'] = resp
# This key is used in API call deviceApplyConfigLet FGA
1095 new
.append({configlet
['name']: "success"})
1098 checked
.append({configlet
['name']: "success"})
1100 data
= {'new': new
, 'updated': updated
, 'deleted': deleted
, 'checked': checked
}
1101 return [changed
, data
]
1103 def __get_configletsDevices(self
, configlets
):
1104 for s
in self
.s_api
:
1105 configlet
= configlets
[s
]
1106 # Add applied Devices
1107 if len(configlet
) > 0:
1108 configlet
['devices'] = []
1109 applied_devices
= self
.client
.api
.get_applied_devices(
1111 for device
in applied_devices
['data']:
1112 configlet
['devices'].append(device
['hostName'])
1114 def __get_serviceData(self
, service_uuid
, service_type
, vlan_id
, conn_info
=None):
1116 for s
in self
.s_api
:
1119 srv_cls
= self
.__get
_serviceConfigLets
(service_uuid
,
1122 self
.__get
_configletsDevices
(srv_cls
)
1123 for s
in self
.s_api
:
1126 for dev
in cl
['devices']:
1127 cls_perSw
[dev
].append(cl
)
1129 cls_perSw
= conn_info
['configLetPerSwitch']
1132 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
1134 Disconnect multi-site endpoints previously connected
1136 :param service_uuid: The one returned by create_connectivity_service
1137 :param conn_info: The one returned by last call to 'create_connectivity_service' or 'edit_connectivity_service'
1138 if they do not return None
1140 :raises: SdnConnectorException: In case of error. The parameter http_code must be filled
1143 self
.logger
.debug('invoked delete_connectivity_service {}'.
1144 format(service_uuid
))
1145 if not service_uuid
:
1146 raise SdnConnectorError(message
='No connection service UUID',
1149 self
.__get
_Connection
()
1150 if conn_info
is None:
1151 raise SdnConnectorError(message
='No connection information for service UUID {}'.format(service_uuid
),
1154 cls_perSw
= self
.__get
_serviceData
(service_uuid
,
1155 conn_info
['service_type'],
1156 conn_info
['vlan_id'],
1158 allLeafConfigured
= {}
1159 allLeafModified
= {}
1160 for s
in self
.s_api
:
1161 allLeafConfigured
[s
] = True
1162 allLeafModified
[s
] = True
1163 found_in_cvp
= False
1164 for s
in self
.s_api
:
1168 self
.__rollbackConnection
(cls_perSw
,
1172 # if the service is not defined in Cloud Vision, return a 404 - NotFound error
1173 raise SdnConnectorError(message
='Service {} was not found in Arista Cloud Vision {}'.
1174 format(service_uuid
, self
.__wim
_url
),
1176 self
.__removeMetadata
(service_uuid
)
1177 except CvpLoginError
as e
:
1178 self
.logger
.info(str(e
))
1180 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1181 http_code
=401) from e
1182 except SdnConnectorError
as sde
:
1184 except Exception as ex
:
1186 self
.logger
.error(ex
)
1187 if self
.raiseException
:
1189 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1190 http_code
=500) from ex
1192 def __addMetadata(self
, service_uuid
, service_type
, vlan_id
):
1193 """ Adds the connectivity service from 'OSM_metadata' configLet
1195 found_in_cvp
= False
1197 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1199 except CvpApiError
as error
:
1200 if "Entity does not exist" in error
.msg
:
1205 new_serv
= '{} {} {} {}\n'.format(self
.__METADATA
_PREFIX
, service_type
, vlan_id
, service_uuid
)
1208 cl_config
= cvp_cl
['config'] + new_serv
1210 cl_config
= new_serv
1211 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1212 self
.__configlet
_modify
(cl_meta
)
1213 except Exception as e
:
1214 self
.logger
.error('Error in setting metadata in CloudVision from OSM for service {}: {}'.
1215 format(service_uuid
, str(e
)))
1218 def __removeMetadata(self
, service_uuid
):
1219 """ Removes the connectivity service from 'OSM_metadata' configLet
1221 found_in_cvp
= False
1223 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1225 except CvpApiError
as error
:
1226 if "Entity does not exist" in error
.msg
:
1232 if service_uuid
in cvp_cl
['config']:
1234 for line
in cvp_cl
['config'].split('\n'):
1235 if service_uuid
in line
:
1238 cl_config
= cl_config
+ line
1239 cl_meta
= [{'name': self
.__OSM
_METADATA
, 'config': cl_config
}]
1240 self
.__configlet
_modify
(cl_meta
)
1241 except Exception as e
:
1242 self
.logger
.error('Error in removing metadata in CloudVision from OSM for service {}: {}'.
1243 format(service_uuid
, str(e
)))
1246 def edit_connectivity_service(self
,
1249 connection_points
=None,
1251 """ Change an existing connectivity service.
1253 This method's arguments and return value follow the same convention as
1254 :meth:`~.create_connectivity_service`.
1256 :param service_uuid: UUID of the connectivity service.
1257 :param conn_info: (dict or None): Information previously returned
1258 by last call to create_connectivity_service
1259 or edit_connectivity_service
1260 :param connection_points: (list): If provided, the old list of
1261 connection points will be replaced.
1262 :param kwargs: Same meaning that create_connectivity_service
1263 :return: dict or None: Information to be updated and stored at
1265 When ``None`` is returned, no information should be changed.
1266 When an empty dict is returned, the database record will
1268 **MUST** be JSON/YAML-serializable (plain data structures).
1270 SdnConnectorError: In case of error.
1273 self
.logger
.debug('invoked edit_connectivity_service for service {}. ports: {}'.format(service_uuid
,
1276 if not service_uuid
:
1277 raise SdnConnectorError(message
='Unable to perform operation, missing or empty uuid',
1280 raise SdnConnectorError(message
='Unable to perform operation, missing or empty connection information',
1283 if connection_points
is None:
1286 self
.__get
_Connection
()
1288 cls_currentPerSw
= conn_info
['configLetPerSwitch']
1289 service_type
= conn_info
['service_type']
1291 self
.__check
_service
(service_type
,
1297 s_uid
, s_connInf
= self
.__processConnection
(
1302 self
.logger
.info("Service with uuid {} configuration updated".
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
:
1315 # TODO check if there are pending task, and cancel them before restoring
1316 self
.__updateConnection
(cls_currentPerSw
)
1317 except Exception as e
:
1318 self
.logger
.error("Unable to restore configuration in service {} after an error in the configuration updated: {}".
1319 format(service_uuid
, str(e
)))
1320 if self
.raiseException
:
1322 raise SdnConnectorError(message
=str(ex
),
1323 http_code
=500) from ex
1325 def clear_all_connectivity_services(self
):
1326 """ Removes all connectivity services from Arista CloudVision with two steps:
1327 - retrives all the services from Arista CloudVision
1328 - removes each service
1331 self
.logger
.debug('invoked AristaImpl ' +
1332 'clear_all_connectivity_services')
1333 self
.__get
_Connection
()
1334 s_list
= self
.__get
_srvUUIDs
()
1337 conn_info
['service_type'] = serv
['type']
1338 conn_info
['vlan_id'] = serv
['vlan']
1340 self
.delete_connectivity_service(serv
['uuid'], conn_info
)
1341 except CvpLoginError
as e
:
1342 self
.logger
.info(str(e
))
1344 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1345 http_code
=401) from e
1346 except SdnConnectorError
as sde
:
1348 except Exception as ex
:
1350 self
.logger
.error(ex
)
1351 if self
.raiseException
:
1353 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1354 http_code
=500) from ex
1356 def get_all_active_connectivity_services(self
):
1357 """ Return the uuid of all the active connectivity services with two steps:
1358 - retrives all the services from Arista CloudVision
1359 - retrives the status of each server
1362 self
.logger
.debug('invoked AristaImpl {}'.format(
1363 'get_all_active_connectivity_services'))
1364 self
.__get
_Connection
()
1365 s_list
= self
.__get
_srvUUIDs
()
1369 conn_info
['service_type'] = serv
['type']
1370 conn_info
['vlan_id'] = serv
['vlan']
1372 status
= self
.get_connectivity_service_status(serv
['uuid'], conn_info
)
1373 if status
['sdn_status'] == 'ACTIVE':
1374 result
.append(serv
['uuid'])
1376 except CvpLoginError
as e
:
1377 self
.logger
.info(str(e
))
1379 raise SdnConnectorError(message
=SdnError
.UNAUTHORIZED
,
1380 http_code
=401) from e
1381 except SdnConnectorError
as sde
:
1383 except Exception as ex
:
1385 self
.logger
.error(ex
)
1386 if self
.raiseException
:
1388 raise SdnConnectorError(message
=SdnError
.INTERNAL_ERROR
,
1389 http_code
=500) from ex
1391 def __get_serviceConfigLets(self
, service_uuid
, service_type
, vlan_id
):
1392 """ Return the configLet's associated with a connectivity service,
1393 There should be one, as maximum, per device (switch) for a given
1394 connectivity service
1397 for s
in self
.s_api
:
1399 found_in_cvp
= False
1400 name
= (self
.__OSM
_PREFIX
+
1402 self
.__SEPARATOR
+ service_type
+ str(vlan_id
) +
1403 self
.__SEPARATOR
+ service_uuid
)
1405 cvp_cl
= self
.client
.api
.get_configlet_by_name(name
)
1407 except CvpApiError
as error
:
1408 if "Entity does not exist" in error
.msg
:
1416 def __get_srvVLANs(self
):
1417 """ Returns a list with all the VLAN id's used in the connectivity services managed
1418 in tha Arista CloudVision by checking the 'OSM_metadata' configLet where this
1419 information is stored
1421 found_in_cvp
= False
1423 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1425 except CvpApiError
as error
:
1426 if "Entity does not exist" in error
.msg
:
1432 lines
= cvp_cl
['config'].split('\n')
1434 if self
.__METADATA
_PREFIX
in line
:
1435 s_vlan
= line
.split(' ')[3]
1438 if (s_vlan
is not None and
1440 s_vlan
not in s_vlan_list
):
1441 s_vlan_list
.append(s_vlan
)
1445 def __get_srvUUIDs(self
):
1446 """ Retrieves all the connectivity services, managed in tha Arista CloudVision
1447 by checking the 'OSM_metadata' configLet where this information is stored
1449 found_in_cvp
= False
1451 cvp_cl
= self
.client
.api
.get_configlet_by_name(self
.__OSM
_METADATA
)
1453 except CvpApiError
as error
:
1454 if "Entity does not exist" in error
.msg
:
1460 lines
= cvp_cl
['config'].split('\n')
1462 if self
.__METADATA
_PREFIX
in line
:
1463 line
= line
.split(' ')
1464 serv
= {'uuid': line
[4], 'type': line
[2], 'vlan': line
[3]}
1467 if (serv
is not None and
1469 serv
not in serv_list
):
1470 serv_list
.append(serv
)
1474 def __get_Connection(self
):
1475 """ Open a connection with Arista CloudVision,
1476 invoking the version retrival as test
1479 if self
.client
is None:
1480 self
.client
= self
.__connect
()
1481 self
.client
.api
.get_cvp_info()
1482 except (CvpSessionLogOutError
, RequestException
) as e
:
1483 self
.logger
.debug("Connection error '{}'. Reconnecting".format(e
))
1484 self
.client
= self
.__connect
()
1485 self
.client
.api
.get_cvp_info()
1487 def __connect(self
):
1488 ''' Connects to CVP device using user provided credentials from initialization.
1489 :return: CvpClient object with connection instantiated.
1491 client
= CvpClient()
1492 protocol
, _
, rest_url
= self
.__wim
_url
.rpartition("://")
1493 host
, _
, port
= rest_url
.partition(":")
1494 if port
and port
.endswith("/"):
1495 port
= int(port
[:-1])
1501 client
.connect([host
],
1504 protocol
=protocol
or "https",
1507 client
.api
= CvpApi(client
, request_timeout
=self
.__API
_REQUEST
_TOUT
)
1508 self
.taskC
= AristaCVPTask(client
.api
)
1511 def __compare(self
, fromText
, toText
, lines
=10):
1512 """ Compare text string in 'fromText' with 'toText' and produce
1513 diffRatio - a score as a float in the range [0, 1] 2.0*M / T
1514 T is the total number of elements in both sequences,
1515 M is the number of matches.
1516 Score - 1.0 if the sequences are identical, and
1517 0.0 if they have nothing in common.
1520 '- ' line unique to sequence 1
1521 '+ ' line unique to sequence 2
1522 ' ' line common to both sequences
1523 '? ' line not present in either input sequence
1525 fromlines
= fromText
.splitlines(1)
1526 tolines
= toText
.splitlines(1)
1527 diff
= list(difflib
.unified_diff(fromlines
, tolines
, n
=lines
))
1528 textComp
= difflib
.SequenceMatcher(None, fromText
, toText
)
1529 diffRatio
= round(textComp
.quick_ratio()*100, 2)
1530 return [diffRatio
, diff
]
1532 def __load_inventory(self
):
1533 """ Get Inventory Data for All Devices (aka switches) from the Arista CloudVision
1535 if not self
.cvp_inventory
:
1536 self
.cvp_inventory
= self
.client
.api
.get_inventory()
1537 self
.allDeviceFacts
= []
1538 for device
in self
.cvp_inventory
:
1539 self
.allDeviceFacts
.append(device
)
1541 def __get_tags(self
, name
, value
):
1542 if not self
.cvp_tags
:
1544 url
= '/api/v1/rest/analytics/tags/labels/devices/{}/value/{}/elements'.format(name
, value
)
1545 self
.logger
.debug('get_tags: URL {}'.format(url
))
1546 data
= self
.client
.get(url
, timeout
=self
.__API
_REQUEST
_TOUT
)
1547 for dev
in data
['notifications']:
1548 for elem
in dev
['updates']:
1549 self
.cvp_tags
.append(elem
)
1550 self
.logger
.debug('Available devices with tag_name {} - value {}: {} '.format(name
, value
, self
.cvp_tags
))
1552 def is_valid_destination(self
, url
):
1553 """ Check that the provided WIM URL is correct
1555 if re
.match(self
.__regex
, url
):
1557 elif self
.is_valid_ipv4_address(url
):
1560 return self
.is_valid_ipv6_address(url
)
1562 def is_valid_ipv4_address(self
, address
):
1563 """ Checks that the given IP is IPv4 valid
1566 socket
.inet_pton(socket
.AF_INET
, address
)
1567 except AttributeError: # no inet_pton here, sorry
1569 socket
.inet_aton(address
)
1570 except socket
.error
:
1572 return address
.count('.') == 3
1573 except socket
.error
: # not a valid address
1577 def is_valid_ipv6_address(self
, address
):
1578 """ Checks that the given IP is IPv6 valid
1581 socket
.inet_pton(socket
.AF_INET6
, address
)
1582 except socket
.error
: # not a valid address