def __init__(self, src=None, dst=None, object_id=None, ref_id=None): PsObject.__init__(self, object_id, ref_id) self.src = src self.dst = dst self.src_type = get_address_type(src) self.dst_type = get_address_type(dst)
def find_endpoint(src, dst, dns_lookup=True): src_address_type = get_address_type(src) dst_address_type = get_address_type(dst) if not dns_lookup: src_alter_addresses = [] dst_alter_addresses = [] else: if src_address_type == 'ipv4' or src_address_type == 'ipv6': src_alter_addresses = [reverse_dns(src)] else: src_alter_addresses = forward_dns(src) if dst_address_type == 'ipv4' or dst_address_type == 'ipv6': dst_alter_addresses = [reverse_dns(dst)] else: dst_alter_addresses = forward_dns(dst) src_address_filter = Q(addresses__value=src) dst_address_filter = Q(addresses__value=dst) for src_alter_address in src_alter_addresses: src_address_filter |= Q(addresses__value=src_alter_address) for dst_alter_address in dst_alter_addresses: dst_address_filter |= Q(addresses__value=dst_alter_address) src_ports = Port.objects.filter(src_address_filter) dst_ports = Port.objects.filter(dst_address_filter) if len(src_ports) == 0 or len(dst_ports) == 0: return None endpoints = [] for src_port in src_ports: for dst_port in dst_ports: try: endpoint = EndPointPair.objects.get(src=src_port, dst=dst_port) if endpoint not in endpoints: endpoints.append(endpoint) except EndPointPair.DoesNotExist: pass if len(endpoints) == 0: return None elif len(endpoints) == 1: return endpoints[0] else: raise ValueError("Multiple endpoints found: %s" % endpoints)
def process_EndpointpairSubject(self, service, meta): etype = ContentType.objects.get_for_model(Port) endpointpair = meta.subject.contents try: endpoint = create_endpoint(endpointpair.src, \ get_address_type(endpointpair.src), \ endpointpair.dst, get_address_type(endpointpair.dst)) if isinstance(meta.event_types, str): event_types = [meta.event_types] else: event_types = meta.event_types for event in event_types: w = psServiceWatchList.objects.get_or_create(service=service, eventType=EventType.objects.get(value=event), objectType=etype, objectID=endpoint.id) if w[1] == 1: w[0].watchedObject = endpoint w[0].save() except Exception, ex: logger.error("Couldn't add endpoint '%s', from service '%s'" % (ex, get_service_accesspoint(service)))
def process_EndpointpairSubject(self, service, meta): etype = ContentType.objects.get_for_model(Port) endpointpair = meta.subject.contents try: endpoint = create_endpoint(endpointpair.src, \ get_address_type(endpointpair.src), \ endpointpair.dst, get_address_type(endpointpair.dst)) if isinstance(meta.event_types, str): event_types = [meta.event_types] else: event_types = meta.event_types for event in event_types: w = psServiceWatchList.objects.get_or_create( service=service, eventType=EventType.objects.get(value=event), objectType=etype, objectID=endpoint.id) if w[1] == 1: w[0].watchedObject = endpoint w[0].save() except Exception, ex: logger.error("Couldn't add endpoint '%s', from service '%s'" % (ex, get_service_accesspoint(service)))
def find_node_by_address(address, dns_lookup=True): """ Deep search for the node address or one of it's port and it does DNS lookup and reverse DNS lookup as well. @param address: IP address, hostname, DNS @param dns_lookup: perform forward DNS and/or reverse DNS lookup @type dns_lookup: boolean @returns: L{periscope.topology.models.Node} """ address_type = get_address_type(address) if not dns_lookup: alter_addresses = [] elif address_type == 'ipv4' or address_type == 'ipv6': hostname = reverse_dns(address) if hostname: alter_addresses = [hostname] else: alter_addresses = [] else: alter_addresses = forward_dns(address) address_filter = Q(addresses__value=address) for alter_address in alter_addresses: address_filter |= Q(addresses__value=alter_address) nodes = Node.objects.filter(address_filter) if len(nodes) > 0: return nodes[0] else: # Try with ports ports = Port.objects.filter(address_filter) if len(ports) == 0: return None else: return ports[0].parent.toRealType()
def to_xml(self, parent=None, tostring=True): """Serialize to XML representation.""" if parent is None: tree = etree.Element('{%s}interface' % ns.NMWGT, nsmap=ns.nsmap) else: tree = etree.SubElement(parent, '{%s}interface' % ns.NMWGT) if self.ipAddress: if hasattr(self.ipAddress, 'to_xml'): self.ipAddress.to_xml(tree) else: ip = etree.SubElement(tree, '{%s}ipAddress' % ns.NMWGT) ip.text = self.ipAddress ip.set('type', get_address_type(self.ipAddress)) if self.ifAddress: if hasattr(self.ifAddress, 'to_xml'): self.ifAddress.to_xml(tree) else: ifAddress = etree.SubElement(tree, '{%s}ifAddress' % ns.NMWGT) ifAddress.text = self.ifAddress # ifAddress.set('type', get_address_type(self.ifAddress)) attrs = ['direction', 'ifType', 'ifHostName', 'hostName', \ 'ifDescription', 'classofService', 'ifIndex', \ 'capacity', 'ifName', 'authRealm', 'description'] for attr in attrs: if getattr(self, attr) is not None: node = etree.SubElement(tree, '{%s}%s' % (ns.NMWGT, attr)) node.text = str(getattr(self, attr)) if tostring: return etree.tostring(tree, pretty_print=True) else: return tree
def save_lookup_service_result(result_set, print_services=False): """ Saves the services and their assoicated data to L{periscope.topology.models.psServiceWatchList}. @param result_set: Lookup (gLS/hLS) service result. @type result_set: L{psapi.client.ResultSet}, or raw XML @param print_services: if True the service names will be printed to stdout. @type print_services: boolean @returns: None """ # first parsed the results services = parse_lookup_service_result(result_set) # Register perfSONAR services registered with the lookup service for psservice in services: # perfSONAR services if isinstance(psservice['service'], PsService): service_name = psservice['service'].serviceName access_point = psservice['service'].accessPoint service_type = psservice['service'].serviceType service_description = psservice['service'].serviceDescription #Network topology service elif isinstance(psservice['service'], NMBService): service_name = psservice['service'].name access_point = psservice['service'].address service_type = psservice['service'].type service_description = psservice['service'].description address_type = get_address_type(access_point) if address_type != 'url': access_point = address_type + "://" + access_point else: raise ValueError("undefined service: %s" % type(psservice['service'])) if isinstance(psservice['service'], PsService): # Create UNIS service instance try: service = create_psservice(service_name, access_point, service_type, service_description, psservice['event_types']) except Exception as exp: logger.warn(exp) continue if print_services: print "Adding: %s, %s, %s, %s" % (service_name, access_point, service_type, service_description) # Register meta data assoicated with the service for i in range(len(psservice['data'])): try: net_obj = register_metadata(service, psservice['data'][i].data) except Exception as exp: logger.warn(exp) continue if net_obj and print_services: print "Registered:", net_obj
def __init__(self, address): PsObject.__init__(self, None, None) self.address = address self.address_type = get_address_type(address)
def create_node_by_address(address, dns_lookup=True): """ Creates new node by it's address. See L{find_node_by_address} to make sure that there is no duplicates. @param address: IP address, hostname, DNS. @param dns_lookup: perform forward DNS and/or reverse DNS lookup. @type dns_lookup: boolean. @returns: L{periscope.topology.models.Node} """ address_type = get_address_type(address) if address_type in ['ipv4', 'ipv6']: hostname = None ips = [address] elif address_type in ['hostname', 'dns']: hostname = address ips = [] else: raise ValueError('Address should be valid IP, DNS, or ' 'hostname, not %s' % address) if dns_lookup and not hostname: hostname = reverse_dns(address, True) if dns_lookup and not ips: ips = forward_dns(address, True) # if the address cannot be mapped to DNS name use '*' as domain if hostname is None: node_n = ips[0] domain_n = '*' else: node_n = hostname.split('.')[0] domain_n = hostname.replace(hostname.split('.')[0] + '.', '') unis_id = "urn:ogf:network:domain=%s:node=%s" % (domain_n, node_n) node = Node.objects.create(unis_id=unis_id) if hostname: name = Name.objects.create(value=hostname, type='hostname') net_name = NetworkObjectNames(name=name, networkobject=node) net_name.save() addr = Address.objects.create(value=hostname, type=get_address_type(hostname)) net_addr = NodeAddresses(node=node, address=addr) net_addr.save() for ip_addr in ips: port = Port.objects.create(parent=node, unis_id=node.unis_id + ":port=%s" % ip_addr) addr = Address.objects.create(value=ip_addr, type=get_address_type(ip_addr)) port_addr = PortAddresses(port=port, address=addr) port_addr.save() if dns_lookup: dns = reverse_dns(ip_addr) if dns: addr = Address.objects.create(value=dns, type='dns') port_addr = PortAddresses(port=port, address=addr) port_addr.save() logger.info("New node '%s' is created" % node.unis_id) return node
def create_port(node, address=None, address_type=None, ifaddress=None, ifname=None, unis_id=None): """ Creates new UNIS Port instance @param node: Node object @param address: valid ipv4, ipv6, DNS (only if it has one IP address) @param address_type: optional srting ipv4,ipv6, DNS, URL, or hostname @param ifaddress: address with special schema for internal interface addressing @param ifname: port name @param unis_id: unique URN, otherwise it will generated based on node's unis_id @returns: Port instance """ if not isinstance(node, NetworkObject): raise ValueError("node is not is instance of " "NetworkObject: %s" % type(node)) if get_address_type(address) == 'hostname': raise ValueError("Port cannot accept hostname address " "unless it has only one IP address.") elif get_address_type(address) == 'dns': ips = forward_dns(address) if len(ips) != 1: raise ValueError("Port cannot accept DNS address " "unless it has only one IP address.") if not unis_id: # Create new unis id unis_id = node.unis_id if ifname: unis_id += ":port=%s" % ifname elif ifaddress: unis_id += ":port=%s" % ifaddress elif address: unis_id += ":port=%s" % address # Create port and save it port = Port.objects.create(parent=node, unis_id=unis_id) # Assign name to the port if ifname: NetworkObjectNames.objects.create( name=Name.objects.create(value=ifname, type='ifname'), networkobject=port) # save address if address: if address_type is None: address_type = get_address_type(address) address = Address.objects.create(value=address, type=address_type) PortAddresses.objects.create(port=port, address=address) if address_type == 'dns': ip_addr = forward_dns(address)[0] ip_type = get_address_type(ip_addr) address = Address.objects.create(value=ip_addr, type=ip_type) PortAddresses.objects.create(port=port, address=address) # Interface special address if ifaddress: ifaddress_type = 'ifaddress' address = Address.objects.create(value=ifaddress, type=ifaddress_type) PortAddresses.objects.create(port=port, address=address) logger.info("Port '%s' is created" % port.unis_id) return port
def create_port(node, address=None, address_type=None, ifaddress=None, ifname=None, unis_id=None): """ Creates new UNIS Port instance @param node: Node object @param address: valid ipv4, ipv6, DNS (only if it has one IP address) @param address_type: optional srting ipv4,ipv6, DNS, URL, or hostname @param ifaddress: address with special schema for internal interface addressing @param ifname: port name @param unis_id: unique URN, otherwise it will generated based on node's unis_id @returns: Port instance """ if not isinstance(node, NetworkObject): raise ValueError("node is not is instance of " "NetworkObject: %s" % type(node)) if get_address_type(address) == 'hostname': raise ValueError("Port cannot accept hostname address " "unless it has only one IP address.") elif get_address_type(address) == 'dns': ips = forward_dns(address) if len(ips) != 1: raise ValueError("Port cannot accept DNS address " "unless it has only one IP address.") if not unis_id: # Create new unis id unis_id = node.unis_id if ifname: unis_id += ":port=%s" % ifname elif ifaddress: unis_id += ":port=%s" % ifaddress elif address: unis_id += ":port=%s" % address # Create port and save it port = Port.objects.create(parent=node, unis_id=unis_id) # Assign name to the port if ifname: NetworkObjectNames.objects.create(name=Name.objects.create( value=ifname, type='ifname'), networkobject=port) # save address if address: if address_type is None: address_type = get_address_type(address) address = Address.objects.create(value=address, type=address_type) PortAddresses.objects.create(port=port, address=address) if address_type == 'dns': ip_addr = forward_dns(address)[0] ip_type = get_address_type(ip_addr) address = Address.objects.create(value=ip_addr, type=ip_type) PortAddresses.objects.create(port=port, address=address) # Interface special address if ifaddress: ifaddress_type = 'ifaddress' address = Address.objects.create(value=ifaddress, type=ifaddress_type) PortAddresses.objects.create(port=port, address=address) logger.info("Port '%s' is created" % port.unis_id) return port