import sys
import socket
-import re
+import traceback
+from urlparse import urlparse
import pygraphviz
from optparse import OptionParser
from sfa.client.sfi import Sfi
-from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console
+from sfa.util.sfalogging import logger
import sfa.util.xmlrpcprotocol as xmlrpcprotocol
-m_url_with_proto=re.compile("\w+://(?P<hostname>[\w\-\.]+):(?P<port>[0-9]+).*")
-m_url_without_proto=re.compile("(?P<hostname>[\w\-\.]+):(?P<port>[0-9]+).*")
-def url_to_hostname_port (url):
- match=m_url_with_proto.match(url)
- if match:
- return (match.group('hostname'),match.group('port'))
- match=m_url_without_proto.match(url)
- if match:
- return (match.group('hostname'),match.group('port'))
- return ('undefined','???')
+def url_hostname_port (url):
+ if url.find("://")<0:
+ url="http://"+url
+ parsed_url=urlparse(url)
+ # 0(scheme) returns protocol
+ default_port='80'
+ if parsed_url[0]=='https': default_port='443'
+ # 1(netloc) returns the hostname+port part
+ parts=parsed_url[1].split(":")
+ # just a hostname
+ if len(parts)==1:
+ return (url,parts[0],default_port)
+ else:
+ return (url,parts[0],parts[1])
###
class Interface:
def __init__ (self,url):
+ self._url=url
try:
- (self.hostname,self.port)=url_to_hostname_port(url)
+ (self._url,self.hostname,self.port)=url_hostname_port(url)
self.ip=socket.gethostbyname(self.hostname)
self.probed=False
except:
- import traceback
- traceback.print_exc()
- self.hostname="undefined"
+# traceback.print_exc()
+ self.hostname="unknown"
+ self.ip='0.0.0.0'
self.port="???"
+ # don't really try it
self.probed=True
self._version={}
def url(self):
- return "http://%s:%s/"%(self.hostname,self.port)
+ return self._url
+ # this is used as a key for creating graph nodes and to avoid duplicates
def uid (self):
return "%s:%s"%(self.ip,self.port)
client.read_config()
key_file = client.get_key_file()
cert_file = client.get_cert_file(key_file)
- url="http://%s:%s/"%(self.hostname,self.port)
- sfa_logger().info('issuing get version at %s'%url)
+ url=self.url()
+ logger.info('issuing get version at %s'%url)
server=xmlrpcprotocol.get_server(url, key_file, cert_file, options)
self._version=server.GetVersion()
- sfa_logger().info("get_version at %s returned %r"%(url,self._version))
except:
- sfa_logger().info("get_version at %s failed"%(url))
+# traceback.print_exc()
self._version={}
self.probed=True
return self._version
- abbrevs = {"registry": "REG", "slicemgr":"SM", "aggregate":"AM"}
+ @staticmethod
+ def multi_lines_label(*lines):
+ result='<<TABLE BORDER="0" CELLBORDER="0"><TR><TD>' + \
+ '</TD></TR><TR><TD>'.join(lines) + \
+ '</TD></TR></TABLE>>'
+# print 'multilines=',result
+ return result
+
+ # default is for when we can't determine the type of the service
+ # typically the server is down, or we can't authenticate, or it's too old code
shapes = {"registry": "diamond", "slicemgr":"ellipse", "aggregate":"box", 'default':'plaintext'}
+ abbrevs = {"registry": "REG", "slicemgr":"SA", "aggregate":"AM", 'default':'[unknown interface]'}
- def get_name(self):
+ # return a dictionary that translates into the node's attr
+ def get_layout (self):
+ layout={}
+ ### retrieve cached GetVersion
version=self.get_version()
- if 'hrn' not in version: return self.url()
- hrn=version['hrn']
- interface=version['interface']
- abbrev=Interface.abbrevs.get(interface,"XXX")
- result="%s %s"%(hrn,abbrev)
- if 'code_tag' in version: result += " %s"%version['code_tag']
- return result
-
- def get_shape(self):
- default=Interface.shapes['default']
- try:
- version=self.get_version()
- return Interface.shapes.get(version['interface'],default)
- except:
- return default
+ # set the href; xxx would make sense to try and 'guess' the web URL, not the API's one...
+ layout['href']=self.url()
+ ### set html-style label
+ ### see http://www.graphviz.org/doc/info/shapes.html#html
+ # if empty the service is unreachable
+ if not version:
+ label="offline"
+ else:
+ label=''
+ try: abbrev=Interface.abbrevs[version['interface']]
+ except: abbrev=Interface.abbrevs['default']
+ label += abbrev
+ if 'hrn' in version: label += " %s"%version['hrn']
+ else: label += "[no hrn]"
+ if 'code_tag' in version:
+ label += " %s"%version['code_tag']
+ if 'testbed' in version:
+ label += " (%s)"%version['testbed']
+ layout['label']=Interface.multi_lines_label(self.url(),label)
+ ### set shape
+ try: shape=Interface.shapes[version['interface']]
+ except: shape=Interface.shapes['default']
+ layout['shape']=shape
+ ### fill color to outline wrongly configured bodies
+ if 'geni_api' not in version and 'sfa' not in version:
+ layout['style']='filled'
+ layout['fillcolor']='gray'
+ return layout
class SfaScan:
# provide the entry points (a list of interfaces)
- def __init__ (self):
- pass
+ def __init__ (self, left_to_right=False, verbose=False):
+ self.verbose=verbose
+ self.left_to_right=left_to_right
def graph (self,entry_points):
graph=pygraphviz.AGraph(directed=True)
+ if self.left_to_right:
+ graph.graph_attr['rankdir']='LR'
self.scan(entry_points,graph)
return graph
# add entry points right away using the interface uid's as a key
to_scan=interfaces
for i in interfaces:
- sfa_logger().info("adding initial node %s"%i.uid())
graph.add_node(i.uid())
node2interface[graph.get_node(i.uid())]=i
scanned=[]
for interface in to_scan:
# performing xmlrpc call
version=interface.get_version()
- # 'sfa' is expected if the call succeeded at all
+ if self.verbose:
+ logger.info("GetVersion at interface %s"%interface.url())
+ if not version:
+ logger.info("<EMPTY GetVersion(); offline or cannot authenticate>")
+ else:
+ for (k,v) in version.iteritems():
+ if not isinstance(v,dict):
+ logger.info("\r\t%s:%s"%(k,v))
+ else:
+ logger.info(k)
+ for (k1,v1) in v.iteritems():
+ logger.info("\r\t\t%s:%s"%(k1,v1))
+ # 'geni_api' is expected if the call succeeded at all
# 'peers' is needed as well as AMs typically don't have peers
- if 'sfa' in version and 'peers' in version:
+ if 'geni_api' in version and 'peers' in version:
# proceed with neighbours
- for (next_name,next_url) in version['peers'].items():
+ for (next_name,next_url) in version['peers'].iteritems():
next_interface=Interface(next_url)
# locate or create node in graph
try:
for node in graph.nodes():
interface=node2interface.get(node,None)
if interface:
- node.attr['label']=interface.get_name()
- node.attr['shape']=interface.get_shape()
+ for (k,v) in interface.get_layout().iteritems():
+ node.attr[k]=v
else:
- sfa_logger().info("MISSED interface with node %s"%node)
+ logger.error("MISSED interface with node %s"%node)
-default_entry_points=["http://www.planet-lab.eu:12345/"]
-default_outfiles=['sfa.png']
+default_outfiles=['sfa.png','sfa.svg','sfa.dot']
def main():
- sfa_logger_goes_to_console()
- parser=OptionParser()
- parser.add_option("-e","--entry",action='append',dest='entry_points',default=[],
- help="Specify entry points - defaults are %r"%default_entry_points)
+ usage="%prog [options] url-entry-point(s)"
+ parser=OptionParser(usage=usage)
parser.add_option("-o","--output",action='append',dest='outfiles',default=[],
- help="Output filenames - defaults are %r"%default_outfiles)
+ help="output filenames (cumulative) - defaults are %r"%default_outfiles)
+ parser.add_option("-l","--left-to-right",action="store_true",dest="left_to_right",default=False,
+ help="instead of top-to-bottom")
+ parser.add_option("-v","--verbose",action='store_true',dest='verbose',default=False,
+ help="verbose")
(options,args)=parser.parse_args()
- if args:
+ if not args:
parser.print_help()
sys.exit(1)
- if not options.entry_points:
- options.entry_points=default_entry_points
if not options.outfiles:
options.outfiles=default_outfiles
- scanner=SfaScan()
- entries = [ Interface(entry) for entry in options.entry_points ]
+ scanner=SfaScan(left_to_right=options.left_to_right, verbose=options.verbose)
+ entries = [ Interface(entry) for entry in args ]
g=scanner.graph(entries)
- sfa_logger().info("creating layout")
+ logger.info("creating layout")
g.layout(prog='dot')
for outfile in options.outfiles:
- sfa_logger().info("drawing in %s"%outfile)
+ logger.info("drawing in %s"%outfile)
g.draw(outfile)
- sfa_logger().info("done")
+ logger.info("done")
if __name__ == '__main__':
main()
git://git.onelab.eu / sfa.git / blobdiff