def from_xml_node(cls, xml_node):
name = get_xml_text_value(xml_node, Elements.NAME)
ip = get_xml_text_value(xml_node, Elements.IP)
subnet = get_xml_text_value(xml_node, Elements.SUBNET)
incoming_vrf = get_xml_text_value(xml_node, Elements.INCOMINGVRF)
vpn_connection = get_xml_text_value(xml_node, Elements.VPNCONNECTION)
return cls(name, ip, subnet, incoming_vrf, vpn_connection)
def from_xml_node(cls, xml_node):
count = get_xml_text_value(xml_node, Elements.COUNT)
total = get_xml_text_value(xml_node, Elements.TOTAL)
topology_clouds = []
for topology_cloud_node in xml_node.iter(tag=Elements.TOPOLOGY_CLOUD):
topology_clouds.append(TopologyCloud.from_xml_node(topology_cloud_node))
return cls(count, total, topology_clouds)
def from_xml_node(cls, xml_node):
name = get_xml_text_value(xml_node, Elements.NAME)
vendor = get_xml_text_value(xml_node, Elements.VENDOR)
incoming_interfaces = []
for node in xml_node.iter(tag=Elements.INCOMINGINTERFACES):
incoming_interfaces.append(Interface.from_xml_node(node))
next_devices = []
for node in xml_node.iter(tag=Elements.NEXTDEVICES):
next_devices.append(NextDevice.from_xml_node(node))
bindings = []
for node in xml_node.iter(tag=Elements.BINDINGS):
bindings.append(Binding.from_xml_node(node))
nat_list = []
for node in xml_node.iter(tag=Elements.NATLIST):
nat_list.append(Nat.from_xml_node(node))
ipsec_list = []
for node in xml_node.iter(tag=Elements.IPSECLIST):
ipsec_list.append(IPSec.from_xml_node(node))
return cls(name, vendor, incoming_interfaces, next_devices, bindings,
nat_list, ipsec_list)
def from_xml_node(cls, xml_node):
name = get_xml_text_value(xml_node, Elements.NAME)
enforced = get_xml_text_value(xml_node, Elements.ENFORCEDON)
rules = []
for node in xml_node.iter(tag=Elements.RULES):
rules.append(Rule.from_xml_node(node))
return cls(name, rules, enforced)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
protocol = get_xml_text_value(xml_node, xml_tags.Elements.PROTOCOL)
port = get_xml_text_value(xml_node, xml_tags.Elements.PORT)
return cls(item_id, protocol, port)
def from_xml_node(cls, xml_node):
cloud_id = get_xml_int_value(xml_node, Elements.ID)
name = get_xml_text_value(xml_node, Elements.NAME)
domain = get_xml_text_value(xml_node, Elements.DOMAIN)
cloud_type = get_xml_text_value(xml_node, Elements.TYPE)
ip = get_xml_text_value(xml_node, Elements.IP)
members = []
for topology_cloud_members_node in xml_node.iter(tag=Elements.MEMBERS):
members.append(TopologyCloudMember.from_xml_node(topology_cloud_members_node))
return cls(cloud_id, name, domain, cloud_type, ip, members)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
minIp = get_xml_text_value(xml_node, xml_tags.Elements.MINIP)
maxIp = get_xml_text_value(xml_node, xml_tags.Elements.MAXIP)
return cls(item_id, minIp, maxIp)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
action = get_xml_text_value(xml_node, xml_tags.Elements.ACTION)
admin = get_xml_text_value(xml_node, xml_tags.Elements.ADMIN)
auditLog = get_xml_text_value(xml_node, xml_tags.Elements.AUDITLOG)
authorizationStatus = get_xml_text_value(
xml_node, xml_tags.Elements.AUTHORIZATIONSTATUS)
revision_date = get_xml_text_value(xml_node, xml_tags.Elements.DATE)
gui_client = get_xml_text_value(xml_node, xml_tags.Elements.GUICLIENT)
num_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
modules_and_policy_node = get_xml_node(
xml_node, xml_tags.Elements.MODULES_AND_POLICY, optional=True)
if modules_and_policy_node:
modules_and_policy = []
for node in modules_and_policy_node.iterfind('module_and_policy'):
modules_and_policy.append(
Module_And_Policy.from_xml_node(node))
else:
modules_and_policy = None
policy_package = get_xml_text_value(xml_node,
xml_tags.Elements.POLICYPACKAGE)
revision_id = get_xml_int_value(xml_node, xml_tags.Elements.REVISIONID)
revision_time = get_xml_text_value(xml_node, xml_tags.Elements.TIME)
ready = get_xml_text_value(xml_node, xml_tags.Elements.READY)
return cls(action, num_id, admin, auditLog, authorizationStatus,
revision_date, revision_time, gui_client, revision_id,
modules_and_policy, policy_package, ready)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
ip = get_xml_text_value(xml_node, xml_tags.Elements.IP)
mask = get_xml_text_value(xml_node, xml_tags.Elements.MASK)
prefix = get_xml_text_value(xml_node, xml_tags.Elements.PREFIX)
return cls(item_id, ip, mask, prefix)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
num_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
code = get_xml_text_value(xml_node, xml_tags.Elements.CODE)
name = get_xml_text_value(xml_node, xml_tags.Elements.NAME)
instances_total = get_xml_int_value(xml_node,
xml_tags.Elements.INSTANCES_TOTAL)
return cls(num_id, code, name, instances_total)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
mgmt_id = get_xml_int_value(xml_node, xml_tags.Elements.MGMT_ID)
service_uid = get_xml_text_value(xml_node,
xml_tags.Elements.SERVICE_UID)
service_name = get_xml_text_value(xml_node,
xml_tags.Elements.SERVICE_NAME)
mgmt_name = get_xml_text_value(xml_node, xml_tags.Elements.MGMT_NAME)
return cls(item_id, mgmt_id, service_uid, service_name, mgmt_name)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
from_zone = get_xml_text_value(xml_node, xml_tags.Elements.FROM_ZONE)
to_zone = get_xml_text_value(xml_node, xml_tags.Elements.TO_ZONE)
policy_name = get_xml_text_value(xml_node,
xml_tags.Elements.POLICY_NAME)
from_domain = get_xml_text_value(xml_node,
xml_tags.Elements.FROM_DOMAIN)
to_domain = get_xml_text_value(xml_node, xml_tags.Elements.TO_DOMAIN)
return cls(from_zone, to_zone, policy_name, from_domain, to_domain)
def from_xml_node(cls, xml_node):
rule_id = get_xml_text_value(xml_node, Elements.RULEIDENTIFIER)
action = get_xml_text_value(xml_node, Elements.ACTION)
sources = get_xml_text_value(xml_node, Elements.SOURCES)
destinations = get_xml_text_value(xml_node, Elements.DESTINATIONS)
services = get_xml_text_value(xml_node, Elements.SERVICES)
applications = get_xml_text_value(xml_node, Elements.APPLICATIONS)
users = get_xml_text_value(xml_node, Elements.USERS)
src_negated = get_xml_text_value(xml_node, Elements.SOURCENEGATED)
dest_negated = get_xml_text_value(xml_node, Elements.DESTNEGATED)
srv_negated = get_xml_text_value(xml_node, Elements.SERVICENEGATED)
return cls(rule_id, sources, destinations, services, users,
applications, action, src_negated, dest_negated, srv_negated)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
display_name = get_xml_text_value(xml_node, Elements.DISPLAY_NAME)
is_global = get_xml_text_value(xml_node, Elements.GLOBAL)
service_id = get_xml_int_value(xml_node, Elements.ID)
name = get_xml_text_value(xml_node, Elements.NAME)
service_type = get_xml_text_value(xml_node, Elements.TYPE)
uid = get_xml_text_value(xml_node, Elements.UID)
application_id = get_xml_int_value(xml_node, Elements.APPLICATION_ID)
return cls(display_name, is_global, service_id, name, service_type,
uid, application_id)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
policy_id = get_xml_int_value(xml_node, Elements.ID)
policy_name = get_xml_text_value(xml_node, Elements.NAME)
domain_id = get_xml_int_value(xml_node, Elements.DOMAIN_ID)
domain_name = get_xml_text_value(xml_node, Elements.DOMAIN_NAME)
try:
attr_type = xml_node.attrib[Attributes.XSI_NAMESPACE_TYPE]
except (AttributeError, KeyError):
attr_type = None
return cls(policy_id, policy_name, domain_id, domain_name, attr_type)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
source_network_collection_node = get_xml_node(
xml_node, xml_tags.Elements.SOURCE_NETWORK_COLLECTION)
source_network_collection = Exception_Network_Source_Collection.from_xml_node(
source_network_collection_node)
dest_network_collection_node = get_xml_node(
xml_node, xml_tags.Elements.DEST_NETWORK_COLLECTION)
dest_network_collection = Exception_Network_Destination_Collection.from_xml_node(
dest_network_collection_node)
service_collection_node = get_xml_node(
xml_node, xml_tags.Elements.SERVICE_COLLECTION)
service_collection = Exception_Service_Collection.from_xml_node(
service_collection_node)
security_requirements = XML_List.from_xml_node_by_tags(
xml_node, xml_tags.Elements.SECURITY_REQUIREMENTS,
xml_tags.Elements.ZONE_TO_ZONE_SECURITY_REQUIREMENT,
Zone_To_Zone_Security_Requirement)
comment = get_xml_text_value(xml_node, xml_tags.Elements.COMMENT)
return cls(source_network_collection, dest_network_collection,
service_collection, security_requirements, comment)
def from_xml_node(cls, xml_node):
traffic_allowed = get_xml_text_value(xml_node, Elements.TRAFFIC_ALLOWED)
devices_info = []
for device_info_node in xml_node.iter(tag=Elements.DEVICE_INFO):
devices_info.append(DeviceInfo.from_xml_node(device_info_node))
return cls(traffic_allowed, devices_info)
def from_xml_node(cls, xml_node):
name = get_xml_text_value(xml_node, Elements.NAME)
routes = []
for node in xml_node.iter(tag=Elements.ROUTES):
routes.append(Route.from_xml_node(node))
return cls(name, routes)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
name = get_xml_text_value(xml_node, xml_tags.Elements.NAME)
model = get_xml_text_value(xml_node, xml_tags.Elements.MODEL)
num_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
domain_id = get_xml_int_value(xml_node, xml_tags.Elements.DOMAIN_ID)
domain_name = get_xml_text_value(xml_node,
xml_tags.Elements.DOMAIN_NAME)
vendor = get_xml_text_value(xml_node, xml_tags.Elements.VENDOR)
topology = get_xml_text_value(xml_node, xml_tags.Elements.TOPOLOGY)
offline = get_xml_text_value(xml_node, xml_tags.Elements.OFFLINE)
ip = get_xml_text_value(xml_node, xml_tags.Elements.IP)
parent_id = get_xml_int_value(xml_node, xml_tags.Elements.PARENT_ID)
return cls(model,
vendor,
domain_id,
domain_name,
num_id,
name,
offline,
topology,
ip,
parent_id=parent_id)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
name = get_xml_text_value(xml_node, xml_tags.Elements.NAME)
expiration_date = get_xml_text_value(xml_node,
xml_tags.Elements.EXPIRATION_DATE)
ticket_id = get_xml_int_value(xml_node, xml_tags.Elements.TICKET_ID)
created_by = get_xml_text_value(xml_node, xml_tags.Elements.CREATED_BY)
approved_by = get_xml_text_value(xml_node,
xml_tags.Elements.APPROVED_BY)
requested_by = get_xml_text_value(xml_node,
xml_tags.Elements.REQUESTED_BY)
creation_date = get_xml_text_value(xml_node,
xml_tags.Elements.CREATION_DATE)
description = get_xml_text_value(xml_node,
xml_tags.Elements.DESCRIPTION)
exempted_traffic_list = XML_List.from_xml_node_by_tags(
xml_node, xml_tags.Elements.EXEMPTED_TRAFFIC_LIST,
xml_tags.Elements.EXEMPTED_TRAFFIC, Exception_Exempted_Traffic)
domain = Domain.from_xml_node(xml_node)
return cls(name, expiration_date, ticket_id, created_by, approved_by,
requested_by, creation_date, description,
exempted_traffic_list, domain)
def parse_api_message(http_response):
try:
error_response_xml = ET.fromstring(http_response.content)
api_error_message = get_xml_text_value(error_response_xml,
"message")
except (ET.ParseError, AttributeError):
return None
else:
return api_error_message
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
dnsAddress = get_xml_text_value(xml_node, xml_tags.Elements.DNSADDRESS)
return cls(item_id, dnsAddress)
def _ensure_response_status(self):
"""Check if the self.response object contains at least one of HTTP status code in self.expected_status_codes.
:return: Returns True if the specified status code was found in the self.response member object.
:rtype: bool
@raise requests.HTTPError: If the specified status code was not found in the self.response member object.
"""
status_code_ok = True
if not self.expected_status_codes:
return True
try:
self.response.raise_for_status()
except requests.exceptions.HTTPError as local_request_exception:
request_exception = local_request_exception
logger.error(
"Got the following error while performing request: '%s'.",
request_exception)
status_code_ok = False
if status_code_ok:
if isinstance(self.expected_status_codes, collections.Iterable):
if self.response.status_code not in self.expected_status_codes:
status_code_ok = False
elif isinstance(self.expected_status_codes, int):
if self.expected_status_codes != self.response.status_code:
status_code_ok = False
else:
raise ValueError(
"self.expected_status_codes must either be an int or list of ints."
)
if not status_code_ok:
error_message = ""
try:
error_response_xml = ET.fromstring(self.response.content)
api_error_message = get_xml_text_value(error_response_xml,
"message")
api_error_code = error_response_xml.find("code").text
if api_error_message is not None:
error_message = "Message from API is '{}'.\n".format(
api_error_message)
logger.error(error_message)
error_message += "Error from API is '{}'.".format(
api_error_code)
logger.error(error_message)
except (ParseError, AttributeError):
error_message = "Could not parse response from API."
logger.error(error_message)
logger.error("Status code for request is '%s'.",
self.response.status_code)
http_exception = REST_HTTP_Exception.get_exception(
self.response, self.expected_status_codes)
raise http_exception
else:
logger.info("Status code for request is '%s'.",
self.response.status_code)
return True
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
zone_id = get_xml_int_value(xml_node, xml_tags.Elements.ZONE_ID)
zone_name = get_xml_text_value(xml_node, xml_tags.Elements.ZONE_NAME)
return cls(item_id, zone_id, zone_name)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
port_min = get_xml_int_value(xml_node, xml_tags.Elements.MIN)
port_max = get_xml_int_value(xml_node, xml_tags.Elements.MAX)
protocol = get_xml_int_value(xml_node, xml_tags.Elements.PROTOCOL)
negate = get_xml_text_value(xml_node, xml_tags.Elements.NEGATE)
return cls(port_min, port_max, protocol, negate)
def from_xml_node(cls, xml_node):
name = get_xml_text_value(xml_node, Elements.NAME)
seq_num = get_xml_int_value(xml_node, Elements.SEQNUMBER)
ipsec_type = get_xml_text_value(xml_node, Elements.TYPE)
peer = get_xml_text_value(xml_node, Elements.PEER)
acl = get_xml_text_value(xml_node, Elements.ACL)
source_ip = get_xml_text_value(xml_node, Elements.SOURCEIP)
out_iface = get_xml_text_value(xml_node, Elements.OUTGOINGINTERFACE)
participating_gws = get_xml_text_value(xml_node, Elements.PARTICIPATINGGATEWAYS)
satellite_gws = get_xml_text_value(xml_node, Elements.SATELLITEGATEWAYS)
return cls(name, seq_num, ipsec_type, peer, acl, source_ip,
out_iface, participating_gws, satellite_gws)
def from_xml_node(cls, xml_node):
route_dest = get_xml_text_value(xml_node, Elements.ROUTEDESTINATION)
next_hop_ip = get_xml_text_value(xml_node, Elements.NEXTHOPIP)
outgoing_interface_name = get_xml_text_value(xml_node, Elements.OUTGOINGINTERFACENAME)
outgoin_vrf = get_xml_text_value(xml_node, Elements.OUTGOINGVRF)
mpls_input_label = get_xml_text_value(xml_node, Elements.MPLSINPUTLABEL)
mpls_output_label = get_xml_text_value(xml_node, Elements.MPLSOUTPUTLABEL)
return cls(route_dest, next_hop_ip, outgoing_interface_name,
outgoin_vrf, mpls_input_label, mpls_output_label)
def from_xml_node(cls, xml_node):
nat_type = get_xml_text_value(xml_node, Elements.TYPE)
object_names = get_xml_text_value(xml_node, Elements.OBJECTNAMES)
policy_rule_num = get_xml_int_value(xml_node, Elements.POLICYRULENUMBER)
original_ips = get_xml_text_value(xml_node, Elements.ORIGINALIPS)
translated_ips = get_xml_text_value(xml_node, Elements.TRANSLATEDIPS)
original_srvs = get_xml_text_value(xml_node, Elements.ORIGINALSERVICES)
translated_srvs = get_xml_text_value(xml_node, Elements.TRANSLATEDSERVICES)
return cls(object_names, nat_type, policy_rule_num, original_ips,
translated_ips, original_srvs, translated_srvs)
def from_xml_node(cls, xml_node):
"""
Initialize the object from a XML node.
:param xml_node: The XML node from which all necessary parameters will be parsed.
:type xml_node: xml.etree.Element
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
predefined_service_id = get_xml_int_value(
xml_node, xml_tags.Elements.PREDEFINED_SERVICE_ID)
predefined_service_name = get_xml_text_value(
xml_node, xml_tags.Elements.PREDEFINED_SERVICE_NAME)
predefined_service_ranges = XML_List.from_xml_node_by_tags(
xml_node, xml_tags.Elements.PREDEFINED_SERVICE_RANGES,
xml_tags.Elements.PREDEFINED_SERVICE_RANGE,
Exception_Predefined_Service_Range)
return cls(item_id, predefined_service_id, predefined_service_name,
predefined_service_ranges)
def __init__(self, xml_node):
# The base node has no child nodes, we are in test mode.
if len(xml_node.getchildren()) == 0:
raise ValueError(
"The ticket can not be constructed as the script is in test mode."
)
try:
self.id = get_xml_int_value(xml_node, Elements.ID)
self.subject = get_xml_text_value(xml_node, Elements.SUBJECT)
self.createDate = get_xml_text_value(xml_node,
Elements.CREATE_DATE)
self.updateDate = get_xml_text_value(xml_node,
Elements.UPDATE_DATE)
current_stage_node = get_xml_node(xml_node, Elements.CURRENT_STAGE,
True)
if current_stage_node:
self.current_stage_id = get_xml_int_value(
current_stage_node, Elements.ID)
self.current_stage_name = get_xml_text_value(
current_stage_node, Elements.NAME)
else:
self.current_stage_id, self.current_stage_name = None, None
completion_data = get_xml_node(xml_node, Elements.COMPLETION_DATA,
True)
if completion_data:
self.completion_step_id = get_xml_int_value(
completion_data, 'stage/' + Elements.ID)
self.completion_step_name = get_xml_text_value(
completion_data, 'stage/' + Elements.NAME)
else:
self.completion_step_id, self.completion_step_name = None, None
self.open_request_id = get_xml_int_value(
get_xml_node(xml_node, Elements.OPEN_REQUEST_STAGE),
Elements.ID)
self.open_request_name = get_xml_text_value(
get_xml_node(xml_node, Elements.OPEN_REQUEST_STAGE),
Elements.NAME)
except AttributeError as attr_error:
message = "Could not parse ticket_info XML into Ticket_Info object, error was {0}.".format(
attr_error)
logger.error(message)
raise AttributeError(message)
super().__init__(Elements.TICKET_INFO)
