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 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 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_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
