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 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 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 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 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 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 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 create(self): ''' Perform a POST call to create a new static_nexthop Only returns if an exception is not raise :return modified: Boolean, True if entry was created ''' static_nexthop_data = {} static_nexthop_data = utils.get_attrs(self, self.config_attrs) static_nexthop_data['id'] = self.id # 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}".format(base_url=self.session.base_url, class_uri=self.base_uri) post_data = json.dumps(static_nexthop_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 static_nexthop table entry {} succeeded". format(self.id)) # Get all object's data self.get() # Object was created, thus modified return True
def create(self): ''' Perform a POST call to create a new DHCP Relay table entry Only returns if an exception is not raise :return modified: Boolean, True if entry was created ''' dhcp_relay_data = {} dhcp_relay_data = utils.get_attrs(self, self.config_attrs) dhcp_relay_data['vrf'] = self.vrf.get_info_format() dhcp_relay_data['port'] = self.port.get_info_format() uri = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=DhcpRelay.base_uri ) post_data = json.dumps(dhcp_relay_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 DHCP Relay table entry {} succeeded\ ".format(self.vrf)) # Get all object's data self.get() # Object was created, means modified return True
def create(self): ''' Perform a POST call to create a new VLAN using the object's attributes as POST body. Exception is raised if object is unable to be created :return modified: Boolean, True if entry was created ''' vlan_data = {} # Get all VLAN data given by the user vlan_data = utils.get_attrs(self, self.config_attrs) if isinstance(self.id, str): self.id = int(self.id) vlan_data['id'] = self.id uri = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=Vlan.base_uri ) post_data = json.dumps(vlan_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 VLAN table entry '{}' \ succeeded".format(self.id)) # Get all objects data self.get() return True
def create(self): ''' Perform a POST call to create a new Aggregate Address table entry Only returns if an exception is not raise :return modified: True if entry was created. ''' ag_address_data = {} ag_address_data = utils.get_attrs(self, self.config_attrs) ag_address_data['address-family'] = self.address_family ag_address_data['ip_prefix'] = self.ip_prefix uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=self.base_uri) post_data = json.dumps(ag_address_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 Aggregate Address table entry {} succeeded\ ".format(self.address_family)) # Get all object's data self.get() # Object was modified return True
def create(self): ''' Perform a POST call to create a new ACL table entry Only returns if an exception is not raise :return modified: Boolean, True if entry was created. ''' acl_data = {} acl_data = utils.get_attrs(self, self.config_attrs) acl_data['name'] = self.name acl_data['list_type'] = self.list_type uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=ACL.base_uri) post_data = json.dumps(acl_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 table entry {} succeeded\ ".format(self.name)) # Get all object's data self.get() # Object was modified, as it was created return True
def create(self): ''' Perform a POST call to create a new VRF using the object's attributes as POST body Only returns if an exception is not raise :return modified: Boolean, True if entry was created ''' vrf_data = {} vrf_data = utils.get_attrs(self, self.config_attrs) vrf_data['name'] = self.name uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=Vrf.base_uri) post_data = json.dumps(vrf_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 VRF table entry '%s' succeeded" % self.name) # Get all objects data self.get() # Object was modified return True
def create(self): ''' Perform a POST call to create a new Static Route table entry Only returns if an exception is not raise :return: Boolean, True if entry was created ''' static_route_data = {} static_route_data = utils.get_attrs(self, self.config_attrs) static_route_data['prefix'] = self.prefix static_route_data['vrf'] = self.__parent_vrf.get_uri() uri = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=self.base_uri ) post_data = json.dumps(static_route_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 Static Route table entry {} succeeded".format( self.prefix)) # Get all object's data self.get() # Object was created, thus modified return True
def create(self): ''' Perform a POST call to create a new OSPF Interface table entry Only returns if an exception is not raise :return: True if OSPF Interface table entry was added ''' ospf_interface_data = {} ospf_interface_data = utils.get_attrs(self, self.config_attrs) ospf_interface_data['interface_name'] = self.interface_name uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=self.base_uri) post_data = json.dumps(ospf_interface_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 Interface table entry {} succeeded". format(self.interface_name)) # Get all object's data self.get() # Object was modified return True
def update(self): ''' Perform a PUT call to update data for a Port and Interface table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Flag used to determine if Object was modified modified_port = True modified_int = True # Check if Object is a LAG if self.type != 'lag': uri_interfaces = "{base_url}{class_uri}/{name}".format( base_url=self.session.base_url, class_uri=Interface.base_uri_interface, name=self.percents_name ) # get Interface data related to configuration int_data = utils.get_attrs(self, self.config_attrs_int) # Remove type if 'type' in int_data: int_data.pop('type') if 'type' in self.__original_attributes_int: self.__original_attributes_int.pop('type') # Set put_int_data put_int_data = json.dumps(int_data, sort_keys=True, indent=4) # Compare dictionaries if int_data == self.__original_attributes_int: # Object was not modified modified_port = False else: # Bring Interface information try: response_ints = self.session.s.put( uri_interfaces, verify=False, data=put_int_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('PUT', e) if not utils._response_ok(response_ints, "PUT"): raise GenericOperationError( response_ints.text, response_ints.status_code) # Set new original attributes self.__original_attributes_int = int_data 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 = utils.get_attrs(self, self.config_attrs) # Check for Ipv4 try: if self.ip4_address is not None: port_data['ip4_address'] = self.ip4_address except AttributeError: pass # Check if vrf is inside the data related to Port if "vrf" in port_data: # Set VRF in the correct format for PUT port_data['vrf'] = self.vrf.get_info_format() # Check if vlan_tag is inside the data related to Port if "vlan_tag" in port_data: # Set VLAN in the correct format for PUT port_data["vlan_tag"] = self.vlan_tag.get_info_format() # Set interfaces into correct form if "interfaces" in port_data: # Check for interfaces no longer in LAG if self.__is_special_type and self.type == 'lag': 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) # Set prev interfaces with current ones # Copies interfaces self.__prev_interfaces = list(self.interfaces) formated_interfaces = [] # Set interfaces into correct form for element in self.interfaces: # If element is the same as current, ignore if element.name == self.name and self.type == 'lag': pass else: # Verify object is materialized if not element.materialized: raise VerificationError( 'Interface {}'.format(element.name), 'Object inside interfaces not materialized') # Only in V1 get_uri() is used, # In any other version, element.get_info_format() # is used formated_element = element.get_uri(True) formated_interfaces.append(formated_element) if self.type == 'lag': # New element being added to LAG element.__add_member_to_lag(self) # Set values in correct form port_data["interfaces"] = formated_interfaces # Set VLANs into correct form if "vlan_trunks" in port_data: formated_vlans = [] # Set interfaces into correct form for element in self.vlan_trunks: # Verify object is materialized if not element.materialized: raise VerificationError( 'Vlan {}'.format(element), 'Object inside vlan trunks not materialized') formated_element = element.get_info_format() formated_vlans.append(formated_element) # Set values in correct form port_data["vlan_trunks"] = formated_vlans # Set all ACLs if "aclmac_in_cfg" in port_data and self.aclmac_in_cfg is not None: # Set values in correct form port_data["aclmac_in_cfg"] = self.aclmac_in_cfg.get_info_format() if "aclmac_out_cfg" in port_data and self.aclmac_out_cfg is not None: # Set values in correct form port_data["aclmac_out_cfg"] = self.aclmac_out_cfg.get_info_format() if "aclv4_in_cfg" in port_data and self.aclv4_in_cfg is not None: # Set values in correct form port_data["aclv4_in_cfg"] = self.aclv4_in_cfg.get_info_format() if "aclv4_out_cfg" in port_data and self.aclv4_out_cfg is not None: # Set values in correct form port_data["aclv4_out_cfg"] = self.aclv4_out_cfg.get_info_format() if "aclv4_routed_in_cfg" in port_data and self.aclv4_routed_in_cfg is not None: # Set values in correct form port_data["aclv4_routed_in_cfg"] = self.aclv4_routed_in_cfg.get_info_format() if "aclv4_routed_out_cfg" in port_data and self.aclv4_routed_out_cfg is not None: # Set values in correct form port_data["aclv4_routed_out_cfg"] = self.aclv4_routed_out_cfg.get_info_format() if "aclv6_in_cfg" in port_data and self.aclv6_in_cfg is not None: # Set values in correct form port_data["aclv6_in_cfg"] = self.aclv6_in_cfg.get_info_format() if "aclv6_out_cfg" in port_data and self.aclv6_out_cfg is not None: # Set values in correct form port_data["aclv6_out_cfg"] = self.aclv6_out_cfg.get_info_format() if "aclv6_routed_in_cfg" in port_data and self.aclv6_routed_in_cfg is not None: # Set values in correct form port_data["aclv6_routed_in_cfg"] = self.aclv6_routed_in_cfg.get_info_format() if "aclv6_routed_out_cfg" in port_data and self.aclv6_routed_out_cfg is not None: # Set values in correct form port_data["aclv6_routed_out_cfg"] = self.aclv6_routed_out_cfg.get_info_format() # Set addresses the correct way if self.ip6_addresses is not None: ip6_addresses_dict = {} for ip in self.ip6_addresses: ip6_addresses_dict[ip.address] = ip.get_uri() # Set values in correct form port_data["ip6_addresses"] = ip6_addresses_dict # Delete type from Port data if 'type' in port_data: port_data.pop('type') if 'type' in self.__original_attributes_port: self.__original_attributes_port.pop('type') # Special case, if dictionary is empty if port_data["ip6_addresses"] == {}: self.__original_attributes_port["ip6_addresses"] = {} # Compare dictionaries if port_data == self.__original_attributes_port: # Object was not modified modified_int = False else: # Set put_port_data put_port_data = json.dumps(port_data, sort_keys=True, indent=4) # Bring 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) # Set new original attributes self.__original_attributes_port = port_data return modified_int or modified_port
def create(self): """ Perform a POST call to create a Port table entry for Interface. Only returns if an exception is not raise :return True if entry was created inside Device """ port_data = {} port_data = utils.get_attrs(self, self.config_attrs) port_data['name'] = self.name # Creating in the Ports Table uri_ports = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=Interface.base_uri_ports ) post_data_ports = json.dumps(port_data, sort_keys=True, indent=4) try: response = self.session.s.post( uri_ports, verify=False, data=post_data_ports, 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 {} Port table entry succeeded".format( self.name)) # Check if port is a LAG # If not, POST Request to Interface Table if self.type != 'lag': uri_interfaces = "{base_url}{class_uri}".format( base_url=self.session.base_url, class_uri=Interface.base_uri_interface ) interface_data = {} # Set data for Interface Table interface_data = utils.get_attrs(self, self.config_attrs_int) interface_data['name'] = self.name interface_data['type'] = self.type interface_data['referenced_by'] = self.get_uri() # Set post_int_data post_int_data = json.dumps( interface_data, sort_keys=True, indent=4) # Bring Interface information try: response_ints = self.session.s.post( uri_interfaces, verify=False, data=post_int_data, proxies=self.session.proxy) except Exception as e: raise ResponseError('POST', e) if not utils._response_ok(response_ints, "POST"): raise GenericOperationError( response_ints.text, response_ints.status_code) # Get all objects data self.get() # Object was created return True
def update(self): ''' Perform a PUT call to apply changes to an existing OSPF Router table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' ospf_router_data = {} ospf_router_data = utils.get_attrs(self, self.config_attrs) # 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}/{instance_tag}".format( base_url=self.session.base_url, class_uri=self.base_uri, instance_tag=self.instance_tag) # Compare dictionaries if ospf_router_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(ospf_router_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 OSPF Router table entry {} succeeded\ ".format(self.instance_tag)) # Set new original attributes self.__original_attributes = ospf_router_data # Object was modified modified = True return modified
def update(self): ''' Perform a PUT call to apply changes to an existing VLAN table entry :return modified: True if Object was modified and a PUT request was made. False otherwise ''' # Variable returned modified = False vlan_data = {} vlan_data = utils.get_attrs(self, self.config_attrs) uri = "{base_url}{class_uri}/{id}".format( base_url=self.session.base_url, class_uri=Vlan.base_uri, id=self.id ) # Set all ACLs if "aclmac_in_cfg" in vlan_data and self.aclmac_in_cfg is not None: # Set values in correct form vlan_data["aclmac_in_cfg"] = \ self.aclmac_in_cfg.get_info_format() if "aclv4_in_cfg" in vlan_data and self.aclv4_in_cfg is not None: # Set values in correct form vlan_data["aclv4_in_cfg"] = self.aclv4_in_cfg.get_info_format() if "aclv6_in_cfg" in vlan_data and self.aclv6_in_cfg is not None: # Set values in correct form vlan_data["aclv6_in_cfg"] = self.aclv6_in_cfg.get_info_format() # Compare dictionaries if vlan_data == self.__original_attributes: # Object was not modified modified = False else: post_data = json.dumps(vlan_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, "UPDATE VLAN") else: logging.info("SUCCESS: Adding VLAN table entry '{}' \ succeeded".format(self.id)) # Set new original attributes self.__original_attributes = vlan_data # Object was modified, returns True modified = True return modified
def create(self): ''' Perform a POST call to create a new VSX Only returns if an exception is not raise return: True if entry was created ''' vsx_data = {} vsx_data = utils.get_attrs(self, self.config_attrs) # Verify Keepalive is created if hasattr(self, 'keepalive_vrf'): if not self.keepalive_vrf.materialized: raise VerificationError('Keepalive Vrf', 'Object not materialized') # Get VRF uri vsx_data["keepalive_vrf"] = self.keepalive_vrf.get_info_format() if hasattr(self, 'isl_port'): if not self.isl_port.materialized: raise VerificationError('Isl Port ', 'Object not materialized') # Get ISL port uri vsx_data["isl_port"] = self.isl_port.get_info_format() if hasattr(self, 'keepalive_peer') and \ hasattr(self, 'keepalive_src') and \ self.keepalive_src is not None and \ self.keepalive_src is not None: ip_src_subnet = self.keepalive_src.find('/') ip_peer_subnet = self.keepalive_peer.find('/') if ip_src_subnet >= 0: self.keepalive_src = self.keepalive_src[0:ip_src_subnet] if ip_peer_subnet >= 0: self.keepalive_peer = self.keepalive_peer[0:ip_peer_subnet] vsx_data["keepalive_peer_ip"] = self.keepalive_peer vsx_data["keepalive_src_ip"] = self.keepalive_src if hasattr(self, 'system_mac') and self.system_mac is not None: vsx_data["system_mac"] = self.system_mac uri = "{base_url}{class_uri}".format(base_url=self.session.base_url, class_uri=Vsx.base_uri) post_data = json.dumps(vsx_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 VSX table entry succeeded") # Get all objects data self.get() # Object was modified return True