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
