-#!/usr/bin/python
+#!/usr/bin/env python
import sys
import socket
from optparse import OptionParser
from sfa.client.sfi import Sfi
-from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console
-import sfa.util.xmlrpcprotocol as xmlrpcprotocol
+from sfa.util.sfalogging import logger, DEBUG
+import sfa.client.xmlrpcprotocol as xmlrpcprotocol
-def url_to_hostname_port (url):
+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=urlparse(url)[1].split(":")
+ parts=parsed_url[1].split(":")
# just a hostname
if len(parts)==1:
- return (parts[0],'80')
+ return (url,parts[0],default_port)
else:
- return (parts[0],parts[1])
+ return (url,parts[0],parts[1])
###
class Interface:
- def __init__ (self,url):
+ def __init__ (self,url,verbose=False):
self._url=url
+ self.verbose=verbose
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:
-# traceback.print_exc()
self.hostname="unknown"
self.ip='0.0.0.0'
self.port="???"
class DummyOptions:
pass
options=DummyOptions()
- options.verbose=False
+ options.verbose=self.verbose
+ options.timeout=10
try:
client=Sfi(options)
client.read_config()
key_file = client.get_key_file()
cert_file = client.get_cert_file(key_file)
url=self.url()
- sfa_logger().info('issuing get version at %s'%url)
- server=xmlrpcprotocol.get_server(url, key_file, cert_file, options)
+ logger.info('issuing GetVersion at %s'%url)
+ logger.debug("GetVersion, using key_file=%s"%key_file)
+ logger.debug("GetVersion, using cert_file=%s"%cert_file)
+ logger.debug("GetVersion, using timeout=%s"%options.timeout)
+ # setting timeout here seems to get the call to fail - even though the response time is fast
+ #server=xmlrpcprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose, timeout=options.timeout)
+ server=xmlrpcprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose)
self._version=server.GetVersion()
except:
-# traceback.print_exc()
+ logger.log_exc("failed to get version")
self._version={}
self.probed=True
return self._version
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
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
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:
- for (k,v) in interface.get_layout().items():
+ for (k,v) in interface.get_layout().iteritems():
node.attr[k]=v
else:
- sfa_logger().error("MISSED interface with node %s"%node)
+ logger.error("MISSED interface with node %s"%node)
default_outfiles=['sfa.png','sfa.svg','sfa.dot']
def main():
- sfa_logger_goes_to_console()
usage="%prog [options] url-entry-point(s)"
parser=OptionParser(usage=usage)
parser.add_option("-o","--output",action='append',dest='outfiles',default=[],
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="count", dest="verbose", default=0,
+ help="verbose - can be repeated for more verbosity")
(options,args)=parser.parse_args()
if not args:
parser.print_help()
sys.exit(1)
if not options.outfiles:
options.outfiles=default_outfiles
- scanner=SfaScan()
+ logger.enable_console()
+ # apply current verbosity to logger
+ logger.setLevelFromOptVerbose(options.verbose)
+ # figure if we need to be verbose for these local classes that only have a bool flag
+ bool_verbose=logger.getBoolVerboseFromOpt(options.verbose)
+ scanner=SfaScan(left_to_right=options.left_to_right, verbose=bool_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