1 from __future__ import print_function
8 from urlparse import urlparse
13 print('Warning, could not import pygraphviz, test mode only')
15 from optparse import OptionParser
17 from sfa.client.return_value import ReturnValue
18 from sfa.client.sfi import Sfi
19 from sfa.util.sfalogging import logger, DEBUG
20 from sfa.client.sfaserverproxy import SfaServerProxy
22 def url_hostname_port (url):
25 parsed_url=urlparse(url)
26 # 0(scheme) returns protocol
28 if parsed_url[0]=='https': default_port='443'
29 # 1(netloc) returns the hostname+port part
30 parts=parsed_url[1].split(":")
33 return (url,parts[0],default_port)
35 return (url,parts[0],parts[1])
37 ### a very simple cache mechanism so that successive runs (see make)
38 ### will go *much* faster
39 ### assuming everything is sequential, as simple as it gets
40 ### { url -> (timestamp,version)}
42 # default expiration period is 1h
43 def __init__ (self, filename=None, expires=60*60):
44 # default is to store cache in the same dir as argv[0]
46 filename=os.path.join(os.path.dirname(sys.argv[0]),"sfascan-version-cache.pickle")
47 self.filename=filename
54 infile=open(self.filename,'r')
55 self.url2version=pickle.load(infile)
58 logger.debug("Cannot load version cache, restarting from scratch")
60 logger.debug("loaded version cache with %d entries %s"%(len(self.url2version),self.url2version.keys()))
64 outfile=open(self.filename,'w')
65 pickle.dump(self.url2version,outfile)
68 logger.log_exc ("Cannot save version cache into %s"%self.filename)
71 retcod=os.unlink(self.filename)
72 logger.info("Cleaned up version cache %s, retcod=%d"%(self.filename,retcod))
74 logger.info ("Could not unlink version cache %s"%self.filename)
77 entries=len(self.url2version)
78 print("version cache from file %s has %d entries"%(self.filename,entries))
79 key_values=self.url2version.items()
80 def old_first (kv1,kv2): return int(kv1[1][0]-kv2[1][0])
81 key_values.sort(old_first)
82 for key_value in key_values:
83 (url,tuple) = key_value
84 (timestamp,version) = tuple
85 how_old = time.time()-timestamp
86 if how_old<=self.expires:
87 print(url,"-- %d seconds ago"%how_old)
89 print("OUTDATED",url,"(%d seconds ago, expires=%d)"%(how_old,self.expires))
91 # turns out we might have trailing slashes or not
92 def normalize (self, url):
95 def set (self,url,version):
96 url=self.normalize(url)
97 self.url2version[url]=( time.time(), version)
99 url=self.normalize(url)
101 (timestamp,version)=self.url2version[url]
102 how_old = time.time()-timestamp
103 if how_old<=self.expires: return version
109 # non-existing hostnames happen...
110 # for better perfs we cache the result of gethostbyname too
113 def __init__ (self,url,mentioned_in=None,verbose=False):
117 key="interface:%s"%url
119 (self._url,self.hostname,self.port)=url_hostname_port(url)
120 # look for ip in the cache
123 (self.hostname, self.ip, self.port) = tuple
125 self.ip=socket.gethostbyname(self.hostname)
127 msg="can't resolve hostname %s\n\tfound in url %s"%(self.hostname,self._url)
129 msg += "\n\t(mentioned at %s)"%mentioned_in
131 self.hostname="unknown"
135 cache.set(key, (self.hostname, self.ip, self.port,) )
139 # mark unknown interfaces as probed to avoid unnecessary attempts
140 if self.hostname=='unknown':
141 # don't really try it
149 # this is used as a key for creating graph nodes and to avoid duplicates
151 return "%s:%s"%(self.ip,self.port)
153 # connect to server and trigger GetVersion
154 def get_version(self):
155 ### if we already know the answer:
158 ### otherwise let's look in the cache file
159 logger.debug("searching in version cache %s"%self.url())
160 cached_version = VersionCache().get(self.url())
161 if cached_version is not None:
162 logger.info("Retrieved version info from cache %s"%self.url())
163 return cached_version
164 ### otherwise let's do the hard work
165 # dummy to meet Sfi's expectations for its 'options' field
168 options=DummyOptions()
169 options.verbose=self.verbose
175 key_file = client.private_key
176 cert_file = client.my_gid
177 logger.debug("using key %s & cert %s"%(key_file,cert_file))
179 logger.info('issuing GetVersion at %s'%url)
180 # setting timeout here seems to get the call to fail - even though the response time is fast
181 #server=SfaServerProxy(url, key_file, cert_file, verbose=self.verbose, timeout=options.timeout)
182 server=SfaServerProxy(url, key_file, cert_file, verbose=self.verbose)
183 self._version=ReturnValue.get_value(server.GetVersion())
185 logger.log_exc("failed to get version")
187 # so that next run from this process will find out
189 # store in version cache so next processes will remember for an hour
191 cache.set(self.url(),self._version)
193 logger.debug("Saved version for url=%s in version cache"%self.url())
198 def multi_lines_label(*lines):
199 result='<<TABLE BORDER="0" CELLBORDER="0"><TR><TD>' + \
200 '</TD></TR><TR><TD>'.join(lines) + \
201 '</TD></TR></TABLE>>'
204 # default is for when we can't determine the type of the service
205 # typically the server is down, or we can't authenticate, or it's too old code
206 shapes = {"registry": "diamond", "slicemgr":"ellipse", "aggregate":"box", 'default':'plaintext'}
207 abbrevs = {"registry": "REG", "slicemgr":"SA", "aggregate":"AM", 'default':'[unknown interface]'}
209 # return a dictionary that translates into the node's attr
210 def get_layout (self):
212 ### retrieve cached GetVersion
213 version=self.get_version()
214 # set the href; xxx would make sense to try and 'guess' the web URL, not the API's one...
215 layout['href']=self.url()
216 ### set html-style label
217 ### see http://www.graphviz.org/doc/info/shapes.html#html
218 # if empty the service is unreachable
223 try: abbrev=Interface.abbrevs[version['interface']]
224 except: abbrev=Interface.abbrevs['default']
226 if 'hrn' in version: label += " %s"%version['hrn']
227 else: label += "[no hrn]"
228 if 'code_tag' in version:
229 label += " %s"%version['code_tag']
230 if 'testbed' in version:
231 label += " (%s)"%version['testbed']
232 layout['label']=Interface.multi_lines_label(self.url(),label)
234 try: shape=Interface.shapes[version['interface']]
235 except: shape=Interface.shapes['default']
236 layout['shape']=shape
237 ### fill color to outline wrongly configured or unreachable bodies
238 # as of sfa-2.0 registry doesn't have 'sfa' not 'geni_api', but have peers
239 # slicemgr and aggregate have 'geni_api' and 'sfa'
240 if 'geni_api' not in version and 'peers' not in version:
241 layout['style']='filled'
242 layout['fillcolor']='gray'
247 # provide the entry points (a list of interfaces)
248 def __init__ (self, left_to_right=False, verbose=False):
250 self.left_to_right=left_to_right
252 def graph (self,entry_points):
253 graph=pygraphviz.AGraph(directed=True)
254 if self.left_to_right:
255 graph.graph_attr['rankdir']='LR'
256 self.scan(entry_points,graph)
259 # scan from the given interfaces as entry points
260 def scan(self,interfaces,graph):
261 if not isinstance(interfaces,list):
262 interfaces=[interfaces]
264 # remember node to interface mapping
266 # add entry points right away using the interface uid's as a key
269 graph.add_node(i.uid())
270 node2interface[graph.get_node(i.uid())]=i
272 # keep on looping until we reach a fixed point
273 # don't worry about abels and shapes that will get fixed later on
275 for interface in to_scan:
276 # performing xmlrpc call
277 logger.info("retrieving/fetching version at interface %s"%interface.url())
278 version=interface.get_version()
280 logger.info("<EMPTY GetVersion(); offline or cannot authenticate>")
282 for (k,v) in version.iteritems():
283 if not isinstance(v,dict):
284 logger.debug("\r\t%s:%s"%(k,v))
287 for (k1,v1) in v.iteritems():
288 logger.debug("\r\t\t%s:%s"%(k1,v1))
289 # proceed with neighbours
290 if 'peers' in version:
291 for (next_name,next_url) in version['peers'].iteritems():
292 next_interface=Interface(next_url,mentioned_in=interface.url())
293 # locate or create node in graph
295 # if found, we're good with this one
296 next_node=graph.get_node(next_interface.uid())
298 # otherwise, let's move on with it
299 graph.add_node(next_interface.uid())
300 next_node=graph.get_node(next_interface.uid())
301 node2interface[next_node]=next_interface
302 to_scan.append(next_interface)
303 graph.add_edge(interface.uid(),next_interface.uid())
304 scanned.append(interface)
305 to_scan.remove(interface)
306 # we've scanned the whole graph, let's get the labels and shapes right
307 for node in graph.nodes():
308 interface=node2interface.get(node,None)
310 for (k,v) in interface.get_layout().iteritems():
313 logger.error("MISSED interface with node %s"%node)
318 default_outfiles=['sfa.png','sfa.svg','sfa.dot']
321 usage="%prog [options] url-entry-point(s)"
322 parser=OptionParser(usage=usage)
323 parser.add_option("-d", "--dir", dest="sfi_dir",
324 help="config & working directory - default is " + Sfi.default_sfi_dir(),
325 metavar="PATH", default=Sfi.default_sfi_dir())
326 parser.add_option("-o","--output",action='append',dest='outfiles',default=[],
327 help="output filenames (cumulative) - defaults are %r"%SfaScan.default_outfiles)
328 parser.add_option("-l","--left-to-right",action="store_true",dest="left_to_right",default=False,
329 help="instead of top-to-bottom")
330 parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0,
331 help="verbose - can be repeated for more verbosity")
332 parser.add_option("-c", "--clean-cache",action='store_true',
333 dest='clean_cache',default=False,
334 help='clean/trash version cache and exit')
335 parser.add_option("-s","--show-cache",action='store_true',
336 dest='show_cache',default=False,
337 help='show/display version cache')
339 (options,args)=parser.parse_args()
340 logger.enable_console()
341 # apply current verbosity to logger
342 logger.setLevelFromOptVerbose(options.verbose)
343 # figure if we need to be verbose for these local classes that only have a bool flag
344 bool_verbose=logger.getBoolVerboseFromOpt(options.verbose)
346 if options.show_cache:
347 VersionCache().show()
349 if options.clean_cache:
350 VersionCache().clean()
356 if not options.outfiles:
357 options.outfiles=SfaScan.default_outfiles
358 scanner=Scanner(left_to_right=options.left_to_right, verbose=bool_verbose)
359 entries = [ Interface(entry,mentioned_in="command line") for entry in args ]
361 g=scanner.graph(entries)
362 logger.info("creating layout")
364 for outfile in options.outfiles:
365 logger.info("drawing in %s"%outfile)
368 # test mode when pygraphviz is not available
371 print("GetVersion at %s returned %s"%(entry.url(),entry.get_version()))