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)