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
"""
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
"""
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):
"""
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
"""
count = get_xml_int_value(xml_node, xml_tags.Elements.COUNT)
total = get_xml_int_value(xml_node, xml_tags.Elements.TOTAL)
score = get_xml_int_value(xml_node, xml_tags.Elements.SCORE)
cleanups = []
for user_node in xml_node.iter(tag=xml_tags.Elements.CLEANUP):
cleanups.append(Generic_Cleanup.from_xml_node(user_node))
return cls(count, total, score, cleanups)
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
"""
item_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
port_min = get_xml_int_value(xml_node, xml_tags.Elements.MIN)
port_max = get_xml_int_value(xml_node, xml_tags.Elements.MAX)
min_protocol = get_xml_int_value(xml_node,
xml_tags.Elements.MIN_PROTOCOL)
max_protocol = get_xml_int_value(xml_node,
xml_tags.Elements.MAX_PROTOCOL)
return cls(item_id, port_min, port_max, min_protocol, max_protocol)
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
"""
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 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)
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 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):
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)
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
"""
devices = []
for device_node in xml_node.iter(tag=xml_tags.Elements.DEVICE):
devices.append(Device.from_xml_node(device_node))
total = get_xml_int_value(xml_node, xml_tags.Elements.TOTAL)
return cls(devices, 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)
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):
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):
domain_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
domain_name = get_xml_text_value(xml_node, xml_tags.Elements.NAME)
description = get_xml_text_value(xml_node, xml_tags.Elements.DESCRIPTION)
address = get_xml_text_value(xml_node, xml_tags.Elements.ADDRESS)
return cls(domain_id, domain_name, description, address)
def from_xml_node(cls, xml_node):
device_id = get_xml_int_value(xml_node, xml_tags.Elements.DEVICE_ID)
object_name = get_xml_text_value(xml_node,
xml_tags.Elements.OBJECT_NAME)
return cls(device_id, object_name)
def from_xml_node(cls, xml_node):
device_id = get_xml_int_value(xml_node, xml_tags.Elements.DEVICE_ID)
revision_id = get_xml_int_value(xml_node,
xml_tags.Elements.REVISION_ID)
rule_count = get_xml_int_value(xml_node, xml_tags.Elements.RULE_COUNT)
return cls(device_id, revision_id, rule_count)
def from_xml_node(cls, xml_node):
ticket_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
source = get_xml_text_value(xml_node, xml_tags.Elements.SOURCE)
return cls(ticket_id, source)
def from_xml_node(cls, xml_node):
device_id = get_xml_int_value(xml_node, xml_tags.Elements.ID)
device_name = get_xml_text_value(xml_node, xml_tags.Elements.NAME)
domain_id = get_xml_int_value(xml_node, xml_tags.Elements.CUSTOMER_ID)
return cls(device_id, device_name, domain_id)
def from_xml_node(cls, xml_node):
cloud_member_id = get_xml_int_value(xml_node, Elements.ID)
ip = get_xml_text_value(xml_node, Elements.IP)
name = get_xml_text_value(xml_node, Elements.NAME)
return cls(cloud_member_id, ip, name)
