sfa/client/sfascan.py

   1 #!/usr/bin/python
   2
   3 import sys
   4 import socket
   5 import re
   6
   7 import pygraphviz
   8
   9 from optparse import OptionParser
  10
  11 from sfa.client.sfi import Sfi
  12 from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console
  13 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
  14
  15 m_url_with_proto=re.compile("\w+://(?P<hostname>[\w\-\.]+):(?P<port>[0-9]+).*")
  16 m_url_without_proto=re.compile("(?P<hostname>[\w\-\.]+):(?P<port>[0-9]+).*")
  17 def url_to_hostname_port (url):
  18     match=m_url_with_proto.match(url)
  19     if match:
  20         return (match.group('hostname'),match.group('port'))
  21     match=m_url_without_proto.match(url)
  22     if match:
  23         return (match.group('hostname'),match.group('port'))
  24     return ('undefined','???')
  25
  26 ###
  27 class Interface:
  28
  29     def __init__ (self,url):
  30         try:
  31             (self.hostname,self.port)=url_to_hostname_port(url)
  32             self.ip=socket.gethostbyname(self.hostname)
  33             self.probed=False
  34         except:
  35             import traceback
  36             traceback.print_exc()
  37             self.hostname="undefined"
  38             self.port="???"
  39             self.probed=True
  40             self._version={}
  41
  42     def url(self):
  43         return "http://%s:%s/"%(self.hostname,self.port)
  44
  45     def uid (self):
  46         return "%s:%s"%(self.ip,self.port)
  47
  48     # connect to server and trigger GetVersion
  49     def get_version(self):
  50         if self.probed:
  51             return self._version
  52         # dummy to meet Sfi's expectations for its 'options' field
  53         class DummyOptions:
  54             pass
  55         options=DummyOptions()
  56         options.verbose=False
  57         try:
  58             client=Sfi(options)
  59             client.read_config()
  60             key_file = client.get_key_file()
  61             cert_file = client.get_cert_file(key_file)
  62             url="http://%s:%s/"%(self.hostname,self.port)
  63             sfa_logger().info('issuing get version at %s'%url)
  64             server=xmlrpcprotocol.get_server(url, key_file, cert_file, options)
  65             self._version=server.GetVersion()
  66             sfa_logger().info("get_version at %s returned %r"%(url,self._version))
  67         except:
  68             sfa_logger().info("get_version at %s failed"%(url))
  69             self._version={}
  70         self.probed=True
  71         return self._version
  72
  73     abbrevs = {"registry": "REG", "slicemgr":"SM", "aggregate":"AM"}
  74     shapes = {"registry": "diamond", "slicemgr":"ellipse", "aggregate":"box", 'default':'plaintext'}
  75
  76     def get_name(self):
  77         version=self.get_version()
  78         if 'hrn' not in version: return self.url()
  79         hrn=version['hrn']
  80         interface=version['interface']
  81         abbrev=Interface.abbrevs.get(interface,"XXX")
  82         result="%s %s"%(hrn,abbrev)
  83         if 'code_tag' in version: result += " %s"%version['code_tag']
  84         return result
  85
  86     def get_shape(self):
  87         default=Interface.shapes['default']
  88         try:
  89             version=self.get_version()
  90             return Interface.shapes.get(version['interface'],default)
  91         except:
  92             return default
  93
  94 class SfaScan:
  95
  96     # provide the entry points (a list of interfaces)
  97     def __init__ (self):
  98         pass
  99
 100     def graph (self,entry_points):
 101         graph=pygraphviz.AGraph(directed=True)
 102         self.scan(entry_points,graph)
 103         return graph
 104
 105     # scan from the given interfaces as entry points
 106     def scan(self,interfaces,graph):
 107         if not isinstance(interfaces,list):
 108             interfaces=[interfaces]
 109
 110         # remember node to interface mapping
 111         node2interface={}
 112         # add entry points right away using the interface uid's as a key
 113         to_scan=interfaces
 114         for i in interfaces:
 115             sfa_logger().info("adding initial node %s"%i.uid())
 116             graph.add_node(i.uid())
 117             node2interface[graph.get_node(i.uid())]=i
 118         scanned=[]
 119         # keep on looping until we reach a fixed point
 120         # don't worry about abels and shapes that will get fixed later on
 121         while to_scan:
 122             for interface in to_scan:
 123                 # performing xmlrpc call
 124                 version=interface.get_version()
 125                 # 'sfa' is expected if the call succeeded at all
 126                 # 'peers' is needed as well as AMs typically don't have peers
 127                 if 'sfa' in version and 'peers' in version:
 128                     # proceed with neighbours
 129                     for (next_name,next_url) in version['peers'].items():
 130                         next_interface=Interface(next_url)
 131                         # locate or create node in graph
 132                         try:
 133                             # if found, we're good with this one
 134                             next_node=graph.get_node(next_interface.uid())
 135                         except:
 136                             # otherwise, let's move on with it
 137                             graph.add_node(next_interface.uid())
 138                             next_node=graph.get_node(next_interface.uid())
 139                             node2interface[next_node]=next_interface
 140                             to_scan.append(next_interface)
 141                         graph.add_edge(interface.uid(),next_interface.uid())
 142                 scanned.append(interface)
 143                 to_scan.remove(interface)
 144             # we've scanned the whole graph, let's get the labels and shapes right
 145             for node in graph.nodes():
 146                 interface=node2interface.get(node,None)
 147                 if interface:
 148                     node.attr['label']=interface.get_name()
 149                     node.attr['shape']=interface.get_shape()
 150                 else:
 151                     sfa_logger().info("MISSED interface with node %s"%node)
 152
 153
 154 default_entry_points=["http://www.planet-lab.eu:12345/"]
 155 default_outfiles=['sfa.png']
 156
 157 def main():
 158     sfa_logger_goes_to_console()
 159     parser=OptionParser()
 160     parser.add_option("-e","--entry",action='append',dest='entry_points',default=[],
 161                       help="Specify entry points - defaults are %r"%default_entry_points)
 162     parser.add_option("-o","--output",action='append',dest='outfiles',default=[],
 163                       help="Output filenames - defaults are %r"%default_outfiles)
 164     (options,args)=parser.parse_args()
 165     if args:
 166         parser.print_help()
 167         sys.exit(1)
 168     if not options.entry_points:
 169         options.entry_points=default_entry_points
 170     if not options.outfiles:
 171         options.outfiles=default_outfiles
 172     scanner=SfaScan()
 173     entries = [ Interface(entry) for entry in options.entry_points ]
 174     g=scanner.graph(entries)
 175     sfa_logger().info("creating layout")
 176     g.layout(prog='dot')
 177     for outfile in options.outfiles:
 178         sfa_logger().info("drawing in %s"%outfile)
 179         g.draw(outfile)
 180     sfa_logger().info("done")
 181
 182 if __name__ == '__main__':
 183     main()