def delete(self): ''' Perform DELETE call to delete OSPF Interface ''' uri = "{base_url}{class_uri}/{id}".format( base_url=self.session.base_url, class_uri=self.base_uri, id=self.interface_name) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Delete OSPF Interface table\ entry {} succeeded".format(self.interface_name)) # Delete back reference from ospf_areas for ospf_interface in self.__parent_ospf_area.ospf_interfaces: if ospf_interface.interface_name == self.interface_name: self.__parent_ospf_area.ospf_interfaces.remove(ospf_interface) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def delete(self): ''' Perform DELETE call to delete specified Static Route table entry. ''' uri = "{base_url}{class_uri}/{prefix}".format( base_url=self.session.base_url, class_uri=self.base_uri, prefix=self.reference_address ) try: response = self.session.s.delete( uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Delete static_route table entry {} succeeded".format( self.prefix)) # Delete back reference from VRF for static_route in self.__parent_vrf.static_routes: if static_route.prefix == self.prefix: self.__parent_vrf.static_routes.remove(static_route) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def get_all(cls, session): ''' Perform a GET call to retrieve all system VRFs and create a dictionary containing them :param cls: Object's class :param session: pyaoscx.Session object used to represent a logical connection to the device :return: Dictionary containing VRF names as keys and a Vrf objects as values ''' logging.info("Retrieving the VRFs inside the switch") uri = '{base_url}{class_uri}'.format(base_url=session.base_url, class_uri=Vrf.base_uri) try: response = session.s.get(uri, verify=False, proxies=session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) data = json.loads(response.text) vrfs_dict = {} # Get all URI elements in the form of a list uri_list = session.api_version.get_uri_from_data(data) for uri in uri_list: # Create Vrf object name, vrf = Vrf.from_uri(session, uri) # Set VRF in dictionary vrfs_dict[name] = vrf return vrfs_dict
def delete(self): ''' Perform DELETE call to delete VRF Address Family table entry ''' uri = "{base_url}{class_uri}/{address_family}".format( base_url=self.session.base_url, class_uri=self.base_uri, address_family=self.address_family) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Delete VRF Address Family table entry {} succeeded\ ".format(self.address_family)) # Delete back reference from VRF for vrf_address_family in self.__parent_vrf.address_families: if vrf_address_family.address_family == self.address_family: self.__parent_vrf.address_families.remove(vrf_address_family) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def delete(self): ''' Perform DELETE call to delete OSPF Router table entry. ''' uri = "{base_url}{class_uri}/{instance_tag}".format( base_url=self.session.base_url, class_uri=self.base_uri, instance_tag=self.instance_tag) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Delete OSPF Router table entry {} succeeded".format( self.instance_tag)) # Delete back reference from VRF for ospf_router in self.__parent_vrf.ospf_routers: if ospf_router.instance_tag == self.instance_tag: self.__parent_vrf.ospf_routers.remove(ospf_router) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def tftp_switch_config_from_remote_location(self, config_file_location, config_name, vrf): ''' TFTP switch config from TFTP server. :param config_file_location: TFTP server address and path for uploading configuration. :param config_name: Config file or checkpoint to be uploaded to. When using TFTP only running-config or startup-config can be used. :param vrf: VRF to be used to contact TFTP server, required if remote_output_file_tftp_path is provided. :return success: Return True if response is successful or False if it was not. ''' success = False uri = '{base_url}fullconfigs/'\ '{cfg}?from={dest}&vrf={vrf}'.format( base_url=self.session.base_url, cfg=config_name, dest=config_file_location, vrf=vrf) try: response = self.session.s.put( uri, verify=False, proxies=self.session.proxy) success = True except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) return success
def create_checkpoint(self, source_config, destination_config): ''' Perform a PUT request to create a new checkpoint or copy an existing checkpoint to AOS-CX switch config. :param source_config: Name of the source configuration from which checkpoint needs to be created or copied. :param destination_config: Name of the destination configuration or name of checkpoint. :return bool: True if success ''' success = False uri = '{base_url}fullconfigs/{dest}?from={prefix}fullconfigs/{src}'.format( base_url=self.session.base_url, prefix=self.session.resource_prefix, dest=destination_config, src=source_config) try: response = self.session.s.put( uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) success = True # Return result return success
def get_full_config(self, config_name='running-config'): ''' Perform a GET request to obtain the device's full config :param config_name: String with the local-config name wanted Defaults to running-config :return config_data: Data containing the full configuration ''' uri = "{base_url}fullconfigs/{cfg}".format( base_url=self.session.base_url, cfg=config_name ) try: response = self.session.s.get( uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) # Configurable data config_data = json.loads(response.text) return config_data
def delete(self): ''' Perform DELETE call to delete VRF table entry. ''' # Delete object attributes utils.delete_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{name}".format( base_url=self.session.base_url, class_uri=Vrf.base_uri, name=self.name) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Delete VRF table entry '%s' succeeded" % self.name)
def delete(self): ''' Perform DELETE call to delete BGP Neighbor table entry. ''' uri = "{base_url}{class_uri}/{id}".format( base_url=self.session.base_url, class_uri=self.base_uri, id=self.ip_or_ifname_or_group_name) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Delete BGP table entry {} succeeded".format( self.ip_or_ifname_or_group_name)) # Delete back reference from BGP_Routers for neighbor in self.__parent_bgp_router.bgp_neighbors: if neighbor.ip_or_ifname_or_group_name == \ self.ip_or_ifname_or_group_name: self.__parent_bgp_router.bgp_neighbors.remove(neighbor) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def update(self): ''' Perform a PUT call to apply changes to an existing static_nexthop :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False static_nexthop_data = {} static_nexthop_data = utils.get_attrs(self, self.config_attrs) # Get port uri if hasattr(self, 'port') and \ self.port is not None: static_nexthop_data["port"] = \ self.port.get_info_format() uri = "{base_url}{class_uri}/{id}".format( base_url=self.session.base_url, class_uri=self.base_uri, id=self.id) # Compare dictionaries if static_nexthop_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(static_nexthop_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Update static_nexthop table entry {} succeeded". format(self.id)) # Set new original attributes self.__original_attributes = static_nexthop_data # Object was modified modified = True return modified
def delete(self): ''' Perform DELETE call to delete ACL Entry from parent ACL on the switch. ''' uri = "{base_url}{class_uri}/{sequence_number}".format( base_url=self.session.base_url, class_uri=self.base_uri, sequence_number=self.sequence_number) try: response = self.session.s.delete(uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('DELETE', e) if not utils._response_ok(response, "DELETE"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Delete ACL Entry table entry {} succeeded".format( self.sequence_number)) # Delete back reference from ACL for acl_entry in self.__parent_acl.cfg_aces: if acl_entry.sequence_number == self.sequence_number: self.__parent_acl.cfg_aces.remove(acl_entry) # Delete object attributes utils.delete_attrs(self, self.config_attrs)
def create(self): ''' Perform a POST call to create a new OSPF Router table entry Only returns if an exception is not raise :return modified: True if entry was created ''' ospf_router_data = {} ospf_router_data = utils.get_attrs(self, self.config_attrs) ospf_router_data['instance_tag'] = self.instance_tag # Set passive_interfaces into correct form if hasattr(self, 'passive_interfaces') \ and self.passive_interfaces is not None: formated_interfaces = {} # Set interfaces into correct form for element in self.passive_interfaces: # Verify object is materialized if not element.materialized: raise VerificationError( 'Interface {}'.format(element.name), 'Object inside passive_interfaces not materialized') formated_element = element.get_info_format() formated_interfaces.update(formated_element) # Set values in correct form ospf_router_data["passive_interfaces"] = formated_interfaces uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=self.base_uri) post_data = json.dumps(ospf_router_data, sort_keys=True, indent=4) try: response = self.session.s.post(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('POST', e) if not utils._response_ok(response, "POST"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Adding OSPF table entry {} succeeded\ ".format(self.instance_tag)) # Get all object's data self.get() # Object was created return True
def update(self): ''' Perform a PUT call to apply changes to an existing BGP Neighbor table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False bgp_neighbor_data = {} bgp_neighbor_data = utils.get_attrs(self, self.config_attrs) # Get ISL port uri if self.local_interface is not None: bgp_neighbor_data["local_interface"] = \ self.local_interface.get_info_format() uri = "{base_url}{class_uri}/{id}".format( base_url=self.session.base_url, class_uri=self.base_uri, id=self.ip_or_ifname_or_group_name) # Compare dictionaries if bgp_neighbor_data == self.__original_attributes: # Object was not modified modified = False else: put_data = json.dumps(bgp_neighbor_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=put_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Update BGP table entry {} succeeded".format( self.ip_or_ifname_or_group_name)) # Set new original attributes self.__original_attributes = bgp_neighbor_data # Object was modified modified = True return modified
def create(self): ''' Perform a POST call to create a new BGP Neighbor table entry Only returns if an exception is not raise :return modified: Boolean, True if entry was created ''' bgp_neighbor_data = {} bgp_neighbor_data = utils.get_attrs(self, self.config_attrs) bgp_neighbor_data['ip_or_ifname_or_group_name'] = \ self.ip_or_ifname_or_group_name if hasattr(self, 'local_interface'): # If local interface is NOT a string if not isinstance(self.local_interface, str): if not self.local_interface.materialized: raise VerificationError('Local Interface', 'Object not materialized') # Get ISL port uri bgp_neighbor_data["local_interface"] = \ self.local_interface.get_info_format() uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=self.base_uri) post_data = json.dumps(bgp_neighbor_data, sort_keys=True, indent=4) try: response = self.session.s.post(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('POST', e) if not utils._response_ok(response, "POST"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Adding BGP table entry {} succeeded".format( self.ip_or_ifname_or_group_name)) # Get all object's data self.get() # Object was modified, as it was created inside Device return True
def upload_switch_config_from_local(self, config_json=None, config_file=None, config_name=None): ''' Uploads configuration from a configuration file. :param config_name: String with the Config file or checkpoint to be uploaded to. When using TFTP only running-config or startup-config can be used. Default: None. :param config_file: String with the File name and path for locally downloading configuration, only JSON version of configuration will be downloaded. Default: None. :param config_json: String with the JSON file name and path for locally uploading configuration, only JSON version of configuration can be uploaded. Default: None. :return success: Return boolean True if response is successful or False if it was not. ''' success = False if config_json: with open(config_json) as json_file: config_json = json.load(json_file) if config_file: with open(config_file) as json_file: config_json = json.load(json_file) config_json = json.dumps(config_json) # Create URI from the session base url and the configuration name uri = '{base_url}fullconfigs/{cfg}'.format( base_url=self.session.base_url, cfg=config_name ) try: # Put (REST) configuration file response = self.session.s.put( url=uri, verify=False, proxies=self.session.proxy, data=config_json) success = True except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError( response.text, response.status_code) return success
def get_facts(cls, session): ''' Modify this to Perform a GET call to retrieve all VLANs and their respective data :param cls: Class reference. :param session: pyaoscx.Session object used to represent a logical connection to the device :return facts: Dictionary containing VLAN IDs as keys and Vlan objects as values ''' # Log logging.info("Retrieving switch VLANs facts") # Set VLAN facts depth vlan_depth = session.api_version.default_facts_depth # Build URI uri = '{base_url}{class_uri}?depth={depth}'.format( base_url=session.base_url, class_uri=Vlan.base_uri, depth=vlan_depth ) try: # Try to get facts data via GET method response = session.s.get( uri, verify=False, proxies=session.proxy ) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError( response.text, response.status_code) # Load response text into json format facts = json.loads(response.text) # Delete internal VLANs internal_vlan_list = [] for vlan in facts.keys(): if 'type' in facts[vlan].keys(): if facts[vlan]['type'] == 'internal': internal_vlan_list.append(vlan) for vlan in internal_vlan_list: facts.pop(vlan) return facts
def create(self): ''' Perform a POST call to create a new ACL Entry. Only returns if an exception is not raise :return modified: Boolean, True if entry was created ''' acl_entry_data = {} acl_entry_data = utils.get_attrs(self, self.config_attrs) acl_entry_data['sequence_number'] = self.sequence_number uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=self.base_uri) # Try to get protocol number try: if isinstance(self.protocol, str): if self.protocol == 'any' or self.protocol == '': acl_entry_data.pop('protocol') else: protocol_num = self.protocol_dict[self.protocol] acl_entry_data['protocol'] = protocol_num elif isinstance(self.protocol, int): acl_entry_data['protocol'] = self.protocol except Exception: pass post_data = json.dumps(acl_entry_data, sort_keys=True, indent=4) try: response = self.session.s.post(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('POST', e) if not utils._response_ok(response, "POST"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Adding ACL Entry table entry {} succeeded\ ".format(self.sequence_number)) # Get all object's data self.get() # Object was created, means modified return True
def update(self): ''' Perform a PUT call to apply changes to an existing DHCP Relay table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False dhcp_relay_data = {} dhcp_relay_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{id1}{separator}{id2}".format( base_url=self.session.base_url, class_uri=DhcpRelay.base_uri, id1=self.vrf.name, separator=self.session.api_version.compound_index_separator, id2=self.port.percents_name ) # Compare dictionaries if dhcp_relay_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(dhcp_relay_data, sort_keys=True, indent=4) try: response = self.session.s.put( uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError( response.text, response.status_code) else: logging.info( "SUCCESS: Update DHCP Relay table entry {} succeeded") # Set new original attributes self.__original_attributes = dhcp_relay_data # Object was modified, returns True modified = True return modified
def update(self): ''' Perform a PUT call to apply changes to an existing Aggregate Address table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False agg_address_data = {} agg_address_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{id1}{separator}{id2}".format( base_url=self.session.base_url, class_uri=self.base_uri, id1=self.address_family, separator=self.session.api_version.compound_index_separator, id2=self.reference_ip_prefix) # Compare dictionaries if agg_address_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(agg_address_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Update Aggregate Address table entry {} succeeded\ ".format(self.address_family)) # Set new original attributes self.__original_attributes = agg_address_data # Object was modified modified = True return modified
def __set_to_default(self): ''' Perform a PUT call to set Interface to default settings :return: True if object was changed ''' uri_ports = "{base_url}{class_uri}/{name}".format( base_url=self.session.base_url, class_uri=Interface.base_uri_ports, name=self.percents_name ) # get Port data related to configuration port_data = {} # Set interfaces into correct form if "interfaces" in port_data: if self.__is_special_type and self.name == 'lag': self.interfaces = [] for element in self.__prev_interfaces: # If element was deleted from interfaces if element not in self.interfaces: # Delete element reference to current LAG element.__delete_lag(self) else: self.interfaces = [self] # Set prev interfaces with current ones # Copies interfaces self.__prev_interfaces = list(self.interfaces) # Set put_port_data put_port_data = json.dumps(port_data, sort_keys=True, indent=4) # Update Port information try: response_ports = self.session.s.put( uri_ports, verify=False, data=put_port_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response_ports, "PUT"): raise GenericOperationError(response_ports.text, response_ports.status_code) # Update values with new ones self.get() return True
def update(self): ''' Perform a PUT call to apply changes to an existing ACL Entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False acl_entry_data = {} acl_entry_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{sequence_number}".format( base_url=self.session.base_url, class_uri=self.base_uri, sequence_number=self.sequence_number) # Compare dictionaries if acl_entry_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(acl_entry_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info( "SUCCESS: Update ACL Entry table entry {} succeeded\ ".format(self.sequence_number)) # Set new original attributes self.__original_attributes = acl_entry_data # Object was modified modified = True return modified
def update(self): ''' Perform a PUT call to apply changes to an existing VRF table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' vrf_data = {} vrf_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{name}".format( base_url=self.session.base_url, class_uri=Vrf.base_uri, name=self.name) # Compare dictionaries # if vrf_data == self.__original_attributes: if json.dumps( vrf_data, sort_keys=True, indent=4) == \ json.dumps( self.__original_attributes, sort_keys=True, indent=4): # Object was not modified modified = False else: post_data = json.dumps(vrf_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Adding VRF table entry '%s' succeeded" % self.name) # Set new original attributes self.__original_attributes = vrf_data modified = True return modified
def update(self): ''' Perform a PUT call to apply changes to an existing VSX inside the switch :return modified: True if Object was modified and a PUT request was made. False otherwise ''' vsx_data = {} vsx_data = utils.get_attrs(self, self.config_attrs) # Get VRF uri vsx_data["keepalive_vrf"] = self.keepalive_vrf.get_info_format() # Get ISL port uri vsx_data["isl_port"] = self.isl_port.get_info_format() uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=Vsx.base_uri) # Compare dictionaries if vsx_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(vsx_data, sort_keys=True, indent=4) try: response = self.session.s.put(uri, verify=False, data=post_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError(response.text, response.status_code) else: logging.info("SUCCESS: Adding VSX configuration") # Set new original attributes self.__original_attributes = vsx_data # Object was modified modified = True return modified
def get_next_id(cls, session, parent_static_route): ''' Method used to obtain the ID for the next Static Nexthop. Thus Perform a GET call to retrieve all system Static Nexthop inside a Static Route, and with it determine the next ID :param cls: Object's class :param session: pyaoscx.Session object used to represent a logical connection to the device :param parent_static_route: StaticRoute object, parent for the Static Nexthops :return new_id: Integer with the new Id for the next Static Nexthop ''' logging.info("Retrieving the switch static_nexthop") base_uri = '{base_static_route_uri}/{static_route_name}/static_nexthops'.format( base_static_route_uri=parent_static_route.base_uri, static_route_name=parent_static_route.reference_address) uri = '{base_url}{class_uri}'.format(base_url=session.base_url, class_uri=base_uri) try: response = session.s.get(uri, verify=False, proxies=session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) data = json.loads(response.text) next_id = None # Get all URI elements in the form of a list uri_list = session.api_version.get_uri_from_data(data) for uri in uri_list: # Obtain ID from uri _id, static_nexthop = StaticNexthop.from_uri( session, parent_static_route, uri) next_id = int(_id) # Set next ID if next_id is not None: next_id += 1 else: next_id = 0 return next_id
def update(self): ''' Perform a PUT call to apply changes to a Device Configuration :return modified: Boolean, True if object was modified ''' system_data = {} system_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=Configuration.base_uri ) # Compare dictionaries if system_data == self.__original_attributes: # Object was not modified modified = False else: put_data = json.dumps(system_data, sort_keys=True, indent=4) try: response = self.session.s.put( uri, verify=False, data=put_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response, "PUT"): raise GenericOperationError( response.text, response.status_code, "UPDATE SYSTEM ATTRIBUTES") else: logging.info("SUCCESS: Updating System Attributes") # Set new original attributes self.__original_attributes = system_data # Object was modified, returns True modified = True return modified
def get(self): ''' Perform a GET call to retrieve device attributes After data from response, Device class attributes are generated using create_attrs() ''' logging.info("Retrieving the switch attributes and capabilities") attributes = [ 'software_version', 'software_images', 'software_info', 'platform_name', 'hostname', 'boot_time', 'mgmt_intf_status', 'aruba_central', 'capabilities', 'capacities', 'admin_password_set', 'other_config', 'domain_name' ] attributes_list = ','.join(attributes) uri = "{}system?attributes={}&depth={}".format( self.session.base_url, attributes_list, self.session.api_version.default_depth) try: response = self.session.s.get( uri, verify=False, proxies=self.session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) # Load into json format data = json.loads(response.text) # Create class attributes using util.create_attrs utils.create_attrs(self, data) # Set device as materialized self.materialized = True
def get_all(cls, session, parent_ospf_area): ''' Perform a GET call to retrieve all system OSPF Interfaces inside a OSPF Area, and create a dictionary containing them as OspfInterface objects :param cls: Object's class :param session: pyaoscx.Session object used to represent a logical connection to the device :param parent_ospf_area: parent OspfArea object where OspfInterface object is stored :return: Dictionary containing OSPF Interface IDs as keys and a OspfInterface objects as values ''' logging.info("Retrieving the switch OSPF Interfaces of an OSPF area") base_uri = '{base_ospf_area_uri}/{ospf_area_area_id}/ospf_interfaces'.format( base_ospf_area_uri=parent_ospf_area.base_uri, ospf_area_area_id=parent_ospf_area.area_id) uri = '{base_url}{class_uri}'.format(base_url=session.base_url, class_uri=base_uri) try: response = session.s.get(uri, verify=False, proxies=session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) data = json.loads(response.text) ospf_interface_dict = {} # Get all URI elements in the form of a list uri_list = session.api_version.get_uri_from_data(data) for uri in uri_list: # Create a OspfInterface object interface_name, ospf_interface = OspfInterface.from_uri( session, parent_ospf_area, uri) # Load all OSPF Interfaces data from within the Switch ospf_interface.get() ospf_interface_dict[interface_name] = ospf_interface return ospf_interface_dict
def get_all(cls, session, parent_acl): ''' Perform a GET call to retrieve all system ACL Entries inside an ACL, and create a dictionary containing them :param cls: Object's class :param session: pyaoscx.Session object used to represent a logical connection to the device :param parent_acl: parent Acl object where ACL Entry is stored :return acl_entry_dict: Dictionary containing ACL Entry IDs as keys and an ACL Entry objects as values ''' logging.info("Retrieving all ACL entries within switch for ACL") # Set URI base_uri = '{base_acl_uri}/{id1}{separator}{id2}/cfg_aces'.format( base_acl_uri=parent_acl.base_uri, id1=parent_acl.name, separator=session.api_version.compound_index_separator, id2=parent_acl.list_type) uri = '{base_url}{class_uri}'.format(base_url=session.base_url, class_uri=base_uri) try: response = session.s.get(uri, verify=False, proxies=session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) data = json.loads(response.text) acl_entry_dict = {} # Get all URI elements in the form of a list uri_list = session.api_version.get_uri_from_data(data) for uri in uri_list: # Create a AclEntry object and adds it to parent acl list sequence_number, acl_entry = AclEntry.from_uri( session, parent_acl, uri) # Load all acl_entry data from within the Switch acl_entry.get() acl_entry_dict[sequence_number] = acl_entry return acl_entry_dict
def get_all(cls, session, parent_static_route): ''' Perform a GET call to retrieve all system Static Nexthop related to a Static Route , and create a dictionary containing StaticNexthop objects. :param cls: Object's class :param session: pyaoscx.Session object used to represent a logical connection to the device :param parent_static_route: StaticRoute object, parent for the Static Nexthops :return: Dictionary containing Static Nexthop IDs as keys and a Static NexthopThis objects as values ''' logging.info("Retrieving the switch static_nexthop") base_uri = '{base_static_route_uri}/{static_route_name}/static_nexthops'.format( base_static_route_uri=parent_static_route.base_uri, static_route_name=parent_static_route.reference_address) uri = '{base_url}{class_uri}'.format(base_url=session.base_url, class_uri=base_uri) try: response = session.s.get(uri, verify=False, proxies=session.proxy) except Exception as e: raise ResponseError('GET', e) if not utils._response_ok(response, "GET"): raise GenericOperationError(response.text, response.status_code) data = json.loads(response.text) static_nexthop_dict = {} # Get all URI elements in the form of a list uri_list = session.api_version.get_uri_from_data(data) for uri in uri_list: # Create a StaticNexthop object and adds it to parent static_route # list _id, static_nexthop = StaticNexthop.from_uri( session, parent_static_route, uri) # Load all Static Nexthop data from within the Switch static_nexthop.get() static_nexthop_dict[_id] = static_nexthop return static_nexthop_dict