Context Navigation

source: fedd/fedd_client.py @ df783c1

axis_examplecompt_changesinfo-opsversion-2.00version-3.01version-3.02

Last change on this file since df783c1 was df783c1, checked in by Ted Faber <faber@…>, 15 years ago
create images from topdl descriptions, a good sign they're coming out right.
Property mode set to `100755`
File size: 44.6 KB

Line
1	#!/usr/local/bin/python
2
3	import sys
4	import os
5	import pwd
6	import tempfile
7	import subprocess
8	import re
9	import xml.parsers.expat
10	import time
11
12	from federation import fedid, service_error
13	from federation.util import fedd_ssl_context, pack_id, unpack_id
14	from federation.remote_service import service_caller
15	from federation import topdl
16
17	from optparse import OptionParser, OptionValueError
18
19
20	class IDFormatException(RuntimeError): pass
21
22	class access_method:
23	"""Encapsulates an access method generically."""
24	(type_ssh, type_x509, type_pgp) = ('sshPubkey', 'X509', 'pgpPubkey')
25	default_type = type_ssh
26	def __init__(self, buf=None, type=None, file=None):
27	self.buf = buf
28
29	if type != None: self.type = type
30	else: self.type = access_method.default_type
31
32	if file != None:
33	self.readfile(file)
34
35	def readfile(self, file, type=None):
36	f = open(file, "r")
37	self.buf = f.read();
38	f.close()
39	if type == None:
40	if self.type == None:
41	self.type = access_method.default_type
42	else:
43	self.type = type;
44
45	class node_desc:
46	def __init__(self, image, hardware, count=1):
47	if getattr(image, "__iter__", None) == None:
48	if image == None: self.image = [ ]
49	else: self.image = [ image ]
50	else:
51	self.image = image
52
53	if getattr(hardware, "__iter__", None) == None:
54	if hardware == None: self.hardware = [ ]
55	else: self.hardware = [ hardware ]
56	else:
57	self.hardware = hardware
58	if count != None: self.count = int(count)
59	else: self.count = 1
60
61	class fedd_client_opts(OptionParser):
62	"""Encapsulate option processing in this class, rather than in main"""
63	def __init__(self):
64	OptionParser.__init__(self, usage="%prog [opts] (--help for details)",
65	version="0.1")
66
67	self.add_option("-c","--cert", action="store", dest="cert",
68	type="string", help="my certificate file")
69	self.add_option("-d", "--debug", action="count", dest="debug",
70	default=0, help="Set debug. Repeat for more information")
71	self.add_option("-s", "--serializeOnly", action="store_true",
72	dest="serialize_only", default=False,
73	help="Print the SOAP request that would be sent and exit")
74	self.add_option("-T","--trusted", action="store", dest="trusted",
75	type="string", help="Trusted certificates (required)")
76	self.add_option("-u", "--url", action="store", dest="url",
77	type="string",default="https://localhost:23235",
78	help="URL to connect to (default %default)")
79	self.add_option("-x","--transport", action="store", type="choice",
80	choices=("xmlrpc", "soap"), default="soap",
81	help="Transport for request (xmlrpc\|soap) (Default: %default)")
82	self.add_option("--trace", action="store_const", dest="tracefile",
83	const=sys.stderr, help="Print SOAP exchange to stderr")
84
85	class fedd_create_opts(fedd_client_opts):
86	def __init__(self, access_keys, add_key_callback=None,
87	add_cert_callback=None):
88	fedd_client_opts.__init__(self)
89	self.add_option("-e", "--experiment_cert", dest="out_certfile",
90	type="string", help="output certificate file")
91	self.add_option("-E", "--experiment_name", dest="exp_name",
92	type="string", help="Suggested experiment name")
93	self.add_option("-F","--useFedid", action="store_true",
94	dest="use_fedid", default=False,
95	help="Use a fedid derived from my certificate as user identity")
96	self.add_option("-f", "--file", dest="file",
97	help="experiment description file")
98	self.add_option("-p", "--project", action="store", dest="project",
99	type="string",
100	help="Project to export from master")
101	if add_key_callback:
102	self.add_option("-k", "--ssh_key", action="callback",
103	type="string", callback=add_key_callback,
104	callback_args=(access_keys,),
105	help="ssh key for access (can be supplied more than once")
106	if add_cert_callback:
107	self.add_option("-K", "--x509Key", action="callback",
108	type="string", callback=add_cert_callback,
109	callback_args=(access_keys,),
110	help="X509 certificate for access " + \
111	"(can be supplied more than once")
112	self.add_option("-m", "--master", dest="master",
113	help="Master testbed in the federation")
114	self.add_option("-U", "--username", action="store", dest="user",
115	type="string", help="Use this username instead of the uid")
116
117	class fedd_split_opts(fedd_create_opts):
118	def __init__(self, access_keys, add_key_callback=None,
119	add_cert_callback=None):
120	fedd_create_opts.__init__(self, access_keys, add_key_callback,
121	add_cert_callback)
122	self.add_option('-t','--fedkit', action='store_true', dest='fedkit',
123	default=False,
124	help="get output suitable for federation kit install")
125	self.add_option('-G','--gatewaykit', action='store_true',
126	dest='gatewaykit', default=False,
127	help="get output suitable for federation gateway kit install")
128
129
130	class fedd_access_opts(fedd_create_opts):
131	def __init__(self, access_keys, node_descs, add_key_callback=None,
132	add_cert_callback=None, add_node_callback=None):
133	fedd_create_opts.__init__(self, access_keys, add_key_callback,
134	add_cert_callback)
135	self.add_option("-a","--anonymous", action="store_true",
136	dest="anonymous", default=False,
137	help="Do not include a user in the request")
138	self.add_option("-l","--label", action="store", dest="label",
139	type="string", help="Label for output")
140	if add_node_callback:
141	self.add_option("-n", "--node", action="callback", type="string",
142	callback=add_node_callback, callback_args=(node_descs,),
143	help="Node description: image:hardware[:count]")
144	self.add_option("-t", "--testbed", action="store", dest="testbed",
145	type="string",
146	help="Testbed identifier (URI) to contact (required)")
147
148	class fedd_exp_data_opts(fedd_client_opts):
149	def __init__(self):
150	fedd_client_opts.__init__(self)
151	self.add_option("-e", "--experiment_cert", dest="exp_certfile",
152	type="string", help="experiment certificate file")
153	self.add_option("-E", "--experiment_name", dest="exp_name",
154	type="string", help="human readable experiment name")
155	self.add_option("--data", dest="data", default=[],
156	action="append", type="choice",
157	choices=("id", "federant", "vtopo", "vis", "log", "status"),
158	help="data to extract")
159
160	class fedd_terminate_opts(fedd_exp_data_opts):
161	def __init__(self):
162	fedd_exp_data_opts.__init__(self)
163	self.add_option("--force", dest="force",
164	action="store_true", default=False,
165	help="Force termination if experiment is in strange state")
166	self.add_option("--logfile", dest="logfile", default=None,
167	help="File to write log to")
168	self.add_option("--print_log", dest="print_log", default=False,
169	action="store_true",
170	help="Print deallocation log to standard output")
171
172	class fedd_multi_exp_data_opts(fedd_client_opts):
173	def __init__(self):
174	fedd_client_opts.__init__(self)
175	self.add_option("--data", dest="data", default=[],
176	action="append", type="choice",
177	choices=("id", "federant", "vtopo", "vis", "log", "status"),
178	help="data to extract")
179
180	class fedd_spew_opts(fedd_client_opts):
181	def __init__(self):
182	fedd_client_opts.__init__(self)
183	self.add_option("-e", "--experiment_cert", dest="exp_certfile",
184	type="string", help="experiment name certificate file")
185	self.add_option("-E", "--experiment_name", dest="exp_name",
186	type="string", help="human readable experiment name")
187	self.add_option("--logfile", dest="logfile", default=None,
188	help="File to write log to")
189	self.add_option('--update_time', dest='update', type='int', default=10,
190	help='how often to update the printed log')
191
192	class fedd_image_opts(fedd_exp_data_opts):
193	def __init__(self):
194	fedd_exp_data_opts.__init__(self)
195	self.add_option("-o", "--output", dest="outfile", type="string",
196	help="output image file")
197	self.add_option("-F", "--format", dest="format", type="choice",
198	choices=("jpg", "png", "dot", "svg"),
199	help="Output file format override")
200	self.add_option("-P", "--program", dest="neato", default=None,
201	type="string",
202	help="Program compatible with dot (from graphviz) used to " + \
203	"render image")
204	self.add_option('-L', "--labels", dest='labels', action='store_true',
205	default=True, help='Label nodes and edges')
206	self.add_option('-A', "--no_labels", dest='labels',
207	default=True, action='store_false',
208	help='Label nodes and edges')
209	self.add_option('-j','--pixels', dest="pixels", default=None,
210	type="int",
211	help="Size of output in pixels (diagrams are square")
212
213	class fedd_ns_image_opts(fedd_split_opts):
214	def __init__(self, access_keys, add_key_callback=None,
215	add_cert_callback=None):
216	fedd_split_opts.__init__(self, access_keys, add_key_callback,
217	add_cert_callback)
218	self.add_option("-o", "--output", dest="outfile", type="string",
219	help="output image file")
220	self.add_option("-Q", "--format", dest="format", type="choice",
221	choices=("jpg", "png", "dot", "svg"),
222	help="Output file format override")
223	self.add_option("-P", "--program", dest="neato", default=None,
224	type="string",
225	help="Program compatible with dot (from graphviz) used to " + \
226	"render image")
227	self.add_option('-L', "--labels", dest='labels', action='store_true',
228	default=True, help='Label nodes and edges')
229	self.add_option('-A', "--no_labels", dest='labels',
230	default=True, action='store_false',
231	help='Label nodes and edges')
232	self.add_option('-j','--pixels', dest="pixels", default=None,
233	type="int",
234	help="Size of output in pixels (diagrams are square")
235
236	def exit_with_fault(dict, out=sys.stderr):
237	""" Print an error message and exit.
238
239	The dictionary contains the FeddFaultBody elements."""
240	codestr = ""
241
242	if dict.has_key('errstr'):
243	codestr = "Error: %s" % dict['errstr']
244
245	if dict.has_key('code'):
246	if len(codestr) > 0 :
247	codestr += " (%d)" % dict['code']
248	else:
249	codestr = "Error Code: %d" % dict['code']
250
251	print>>out, codestr
252	print>>out, "Description: %s" % dict['desc']
253	sys.exit(dict.get('code', 20))
254	# Base class that will do a the SOAP/XMLRPC exchange for a request.
255	class fedd_rpc:
256	class RPCException:
257	def __init__(self, fb):
258	self.desc = fb.get('desc', None)
259	self.code = fb.get('code', -1)
260	self.errstr = fb.get('errstr', None)
261
262	def __init__(self, pre):
263	"""
264	Specialize the class for the pre method
265	"""
266	self.RequestBody="%sRequestBody" % pre
267	self.ResponseBody="%sResponseBody" % pre
268	self.method = pre
269
270	self.caller = service_caller(self.method)
271	self.RPCException = fedd_rpc.RPCException
272
273
274	def add_ssh_key(self, option, opt_str, value, parser, access_keys):
275	try:
276	access_keys.append(access_method(file=value,
277	type=access_method.type_ssh))
278	except IOError, (errno, strerror):
279	raise OptionValueError("Cannot generate sshPubkey from %s: "\
280	"%s (%d)" % (value,strerror,errno))
281
282	def add_x509_cert(self, option, opt_str, value, parser, access_keys):
283	try:
284	access_keys.append(access_method(file=value,
285	type=access_method.type_x509))
286	except IOError, (errno, strerror):
287	raise OptionValueError("Cannot read x509 cert from %s: %s (%d)" %
288	(value,strerror,errno))
289	def add_node_desc(self, option, opt_str, value, parser, node_descs):
290	def none_if_zero(x):
291	if len(x) > 0: return x
292	else: return None
293
294	params = map(none_if_zero, value.split(":"));
295
296	if len(params) < 4 and len(params) > 1:
297	node_descs.append(node_desc(*params))
298	else:
299	raise OptionValueError("Bad node description: %s" % value)
300
301	def get_user_info(self, access_keys):
302	pw = pwd.getpwuid(os.getuid());
303	try_cert=None
304	user = None
305
306	if pw != None:
307	user = pw[0]
308	try_cert = "%s/.ssl/emulab.pem" % pw[5];
309	if not os.access(try_cert, os.R_OK):
310	try_cert = None
311	if len(access_keys) == 0:
312	for k in ["%s/.ssh/id_rsa.pub", "%s/.ssh/id_dsa.pub",
313	"%s/.ssh/identity.pub"]:
314	try_key = k % pw[5];
315	if os.access(try_key, os.R_OK):
316	access_keys.append(access_method(file=try_key,
317	type=access_method.type_ssh))
318	break
319	return (user, try_cert)
320
321	def do_rpc(self, req_dict, url, transport, cert, trusted, tracefile=None,
322	serialize_only=False):
323	"""
324	The work of sending and parsing the RPC as either XMLRPC or SOAP
325	"""
326
327	context = None
328	while context == None:
329	try:
330	context = fedd_ssl_context(cert, trusted)
331	except Exception, e:
332	# Yes, doing this on message type is not ideal. The string
333	# comes from OpenSSL, so check there is this stops working.
334	if str(e) == "bad decrypt":
335	print >>sys.stderr, "Bad Passphrase given."
336	else: raise
337
338	if transport == "soap":
339	if serialize_only:
340	print self.caller.serialize_soap(req_dict)
341	sys.exit(0)
342	else:
343	try:
344	resp = self.caller.call_soap_service(url, req_dict,
345	context=context, tracefile=tracefile)
346	except service_error, e:
347	raise self.RPCException( {\
348	'code': e.code,
349	'desc': e.desc,
350	'errstr': e.code_string()\
351	})
352	elif transport == "xmlrpc":
353	if serialize_only:
354	ser = dumps((req_dict,))
355	print ser
356	sys.exit(0)
357	else:
358	try:
359	resp = self.caller.call_xmlrpc_service(url, req_dict,
360	context=context, tracefile=tracefile)
361	except service_error, e:
362	raise self.RPCException( {\
363	'code': e.code,
364	'desc': e.desc,
365	'errstr': e.code_string()\
366	})
367
368	else:
369	raise RuntimeError("Unknown RPC transport: %s" % transport)
370
371	if resp.has_key(self.ResponseBody):
372	return resp[self.ResponseBody]
373	else:
374	raise RuntimeError("No body in response??")
375
376	class exp_data_base(fedd_rpc):
377	def __init__(self, op='Info'):
378	"""
379	Init the various conversions
380	"""
381
382	fedd_rpc.__init__(self, op)
383	# List of things one could ask for and what formatting routine is
384	# called.
385	self.params = {
386	'vis': ('vis', self.print_xml('vis')),
387	'vtopo': ('vtopo', self.print_xml('vtopo')),
388	'federant': ('federant', self.print_xml),
389	'id': ('experimentID', self.print_id),
390	'status': ('experimentStatus', self.print_string),
391	'log': ('allocationLog', self.print_string),
392	'access': ('experimentAccess', self.print_string),
393	}
394
395	# Utility functions
396	def print_string(self, d, out=sys.stdout):
397	print >>out, d
398
399	def print_id(self, d, out=sys.stdout):
400	if d:
401	for id in d:
402	for k in id.keys():
403	print >>out, "%s: %s" % (k, id[k])
404
405	class print_xml:
406	"""
407	Print the retrieved data is a simple xml representation of the dict.
408	"""
409	def __init__(self, top):
410	self.xml = top
411
412	def __call__(self, d, out=sys.stdout):
413	str = "<%s>\n" % self.xml
414	for t in ('node', 'lan'):
415	if d.has_key(t):
416	for x in d[t]:
417	str += "<%s>" % t
418	for k in x.keys():
419	str += "<%s>%s</%s>" % (k, x[k],k)
420	str += "</%s>\n" % t
421	str+= "</%s>" % self.xml
422	print >>out, str
423
424
425
426	# Querying experiment data follows the same control flow regardless of the
427	# specific data retrieved. This class encapsulates that control flow.
428	class exp_data(exp_data_base):
429	def __init__(self):
430	exp_data_base.__init__(self, 'Info')
431
432	def __call__(self):
433	"""
434	The control flow. Compose the request and print the response.
435	"""
436	# Process the options using the customized option parser defined above
437	parser = fedd_exp_data_opts()
438
439	(opts, args) = parser.parse_args()
440
441	if opts.trusted:
442	if ( not os.access(opts.trusted, os.R_OK) ) :
443	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
444
445	if opts.debug > 0: opts.tracefile=sys.stderr
446
447	(user, cert) = self.get_user_info([])
448
449	if opts.cert != None: cert = opts.cert
450
451	if cert == None:
452	sys.exit("No certificate given (--cert) or found")
453
454	if os.access(cert, os.R_OK):
455	fid = fedid(file=cert)
456	else:
457	sys.exit("Cannot read certificate (%s)" % cert)
458
459	if opts.exp_name and opts.exp_certfile:
460	sys.exit("Only one of --experiment_cert and " +\
461	"--experiment_name permitted");
462
463	if opts.exp_certfile:
464	exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
465
466	if opts.exp_name:
467	exp_id = { 'localname' : opts.exp_name }
468
469	req = { 'experiment': exp_id }
470
471	try:
472	resp_dict = self.do_rpc(req,
473	opts.url, opts.transport, cert, opts.trusted,
474	serialize_only=opts.serialize_only,
475	tracefile=opts.tracefile)
476	except self.RPCException, e:
477	exit_with_fault(\
478	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
479	except RuntimeError, e:
480	sys.exit("Error processing RPC: %s" % e)
481
482	for d in opts.data:
483	key, output = self.params[d]
484	try:
485	if resp_dict.has_key(key):
486	output(resp_dict[key])
487	except RuntimeError, e:
488	sys.exit("Bad response. %s" % e.message)
489
490	class vtopo(exp_data):
491	"""
492	vtopo is just an info --data=vtopo request, so this adds that parameter to
493	the arguments and executes exp_info when called.
494	"""
495	def __init__(self):
496	exp_data.__init__(self)
497	def __call__(self):
498	sys.argv.append('--data=vtopo')
499	exp_data.__call__(self)
500
501
502	class vis(exp_data):
503	"""
504	vis is just an info --data=vis request, so this adds that parameter to
505	the arguments and executes exp_info when called.
506	"""
507	def __init__(self):
508	exp_data.__init__(self)
509	def __call__(self):
510	sys.argv.append('--data=vis')
511	exp_data.__call__(self)
512
513	class status(exp_data):
514	"""
515	status is just an info --data=status request, so this adds that parameter
516	to the arguments and executes exp_info when called.
517	"""
518	def __init__(self):
519	exp_data.__init__(self)
520	def __call__(self):
521	sys.argv.append('--data=status')
522	exp_data.__call__(self)
523
524	class multi_exp_data(exp_data_base):
525	def __init__(self):
526	exp_data_base.__init__(self, 'MultiInfo')
527
528
529	def __call__(self):
530	"""
531	The control flow. Compose the request and print the response.
532	"""
533	# Process the options using the customized option parser defined above
534	parser = fedd_multi_exp_data_opts()
535
536	(opts, args) = parser.parse_args()
537
538	if opts.trusted:
539	if ( not os.access(opts.trusted, os.R_OK) ) :
540	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
541
542	if opts.debug > 0: opts.tracefile=sys.stderr
543
544	(user, cert) = self.get_user_info([])
545
546	if opts.cert != None: cert = opts.cert
547
548	if cert == None:
549	sys.exit("No certificate given (--cert) or found")
550
551	if os.access(cert, os.R_OK):
552	fid = fedid(file=cert)
553	else:
554	sys.exit("Cannot read certificate (%s)" % cert)
555
556	req = { }
557
558	try:
559	resp_dict = self.do_rpc(req,
560	opts.url, opts.transport, cert, opts.trusted,
561	serialize_only=opts.serialize_only,
562	tracefile=opts.tracefile)
563	except self.RPCException, e:
564	exit_with_fault(\
565	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
566	except RuntimeError, e:
567	sys.exit("Error processing RPC: %s" % e)
568
569	exps = resp_dict.get('info', [])
570	if exps:
571	print '---'
572	for exp in exps:
573	for d in opts.data:
574	key, output = self.params[d]
575	try:
576	if exp.has_key(key):
577	output(exp[key])
578	except RuntimeError, e:
579	sys.exit("Bad response. %s" % e.message)
580	print '---'
581
582
583	class multi_status(exp_data_base):
584	def __init__(self):
585	exp_data_base.__init__(self, 'MultiInfo')
586
587
588	def __call__(self):
589	"""
590	The control flow. Compose the request and print the response.
591	"""
592	# Process the options using the customized option parser defined above
593	parser = fedd_client_opts()
594
595	(opts, args) = parser.parse_args()
596
597	if opts.trusted:
598	if ( not os.access(opts.trusted, os.R_OK) ) :
599	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
600
601	if opts.debug > 0: opts.tracefile=sys.stderr
602
603	(user, cert) = self.get_user_info([])
604
605	if opts.cert != None: cert = opts.cert
606
607	if cert == None:
608	sys.exit("No certificate given (--cert) or found")
609
610	if os.access(cert, os.R_OK):
611	fid = fedid(file=cert)
612	else:
613	sys.exit("Cannot read certificate (%s)" % cert)
614
615	req = { }
616
617	try:
618	resp_dict = self.do_rpc(req,
619	opts.url, opts.transport, cert, opts.trusted,
620	serialize_only=opts.serialize_only,
621	tracefile=opts.tracefile)
622	except self.RPCException, e:
623	exit_with_fault(\
624	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
625	except RuntimeError, e:
626	sys.exit("Error processing RPC: %s" % e)
627
628	for exp in resp_dict.get('info', []):
629	out = []
630	for eid in exp.get('experimentID', []):
631	if eid.has_key('localname'):
632	out.append(eid['localname'])
633	break
634	else:
635	out.append("")
636	for eid in exp.get('experimentID', []):
637	if eid.has_key('fedid'):
638	out.append("%s" % eid['fedid'])
639	break
640	else:
641	out.append("")
642
643	out.append(exp.get('experimentStatus', ""))
644
645	for f in exp.get('federant', []):
646	if f.get('master', False):
647	em = f.get('emulab', None)
648	if em:
649	project = em.get('project', None)
650	if project:
651	tb = project.get('testbed', None)
652	if tb and tb.has_key('localname'):
653	out.append(tb['localname'])
654	else:
655	out.append("")
656	pn = project.get('name', None)
657	if pn and pn.has_key('localname'):
658	out.append(pn['localname'])
659	else:
660	out.append("")
661	else:
662	out.extend(("", ""))
663	else:
664	out.extend(("", ""))
665	break
666	else:
667	out.extend(("",""))
668
669	print ":".join(out)
670
671	class image(fedd_rpc):
672	def __init__(self, op='Vtopo'):
673	"""
674	Null constructor
675	"""
676
677	fedd_rpc.__init__(self, op)
678
679	@staticmethod
680	def gen_dot_topo(d, labels, dotfile):
681	lans = { }
682	links = { }
683
684	for n in d.get('node', []):
685	print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n['vname']
686	print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
687
688	# Collect lan members (we have to draw extra stuff for these)
689	for n in d.get('lan', []):
690	v = n['vname']
691	m = n['member']
692	i = n['ip']
693	if m.find(':') != -1:
694	m = m[0:m.find(':')]
695	if lans.has_key(v):
696	lans[v].append((m, i))
697	elif links.has_key(v):
698	links[v].append((m, i))
699	if len(links[v]) > 2:
700	lans[v] = links[v]
701	del links[v]
702	else:
703	links[v] = [(m, i)]
704
705	# Encode the lans and the links
706	for l in lans.keys():
707	print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l
708	print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
709	for n in lans[l]:
710	if labels:
711	print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
712	(l, n[0], n[1])
713	else:
714	print >>dotfile, '\t"%s" -- "%s"' % (l, n[0])
715
716	for k, l in links.items():
717	if len(l) == 2:
718	if labels:
719	print >>dotfile, \
720	('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
721	'headlabel="%s"]') % \
722	(l[0][0], l[1][0], k, l[0][1], l[1][1])
723	else:
724	print >>dotfile, '\t"%s" -- "%s" ' % (l[0][0], l[1][0])
725
726
727	def gen_image(self, d, nodes, file, fmt, neato, labels, pix=None):
728
729	# Open up a temporary file for dot to turn into a visualization
730	try:
731	df, dotname = tempfile.mkstemp(prefix='fedd_client', suffix=".dot")
732	dotfile = os.fdopen(df, 'w')
733	except IOError:
734	raise service_error(service_error.internal,
735	"Failed to open file in genviz")
736
737	if not neato:
738	for f in ['/usr/bin/neato', '/usr/local/bin/neato',
739	'/usr/bin/dot', '/usr/local/bin/dot']:
740	if os.access(f, os.X_OK):
741	neato = f
742	break
743	else:
744	sys.exit("Cannot find graph rendering program")
745
746	cmd = [neato, '-Gsplines=true']
747	if fmt != 'dot': cmd.append('-T%s' % fmt)
748	if file:
749	cmd.append('-o')
750	cmd.append(file)
751	cmd.append(dotname)
752
753	#nodes = d.get('node',[])
754
755	if nodes < 10: size = 5
756	elif nodes < 50: size = 10
757	else: size = 18
758
759	if pix:
760	dpi = pix / size
761	else:
762	dpi = None
763
764
765	print >>dotfile, "graph G {"
766	if dpi:
767	print >>dotfile, '\tgraph [size="%i,%i", dpi="%i", ratio=fill];' \
768	% (size, size, dpi)
769	else:
770	print >>dotfile, '\tgraph [size="%i,%i", ratio=fill];' \
771	% (size, size)
772
773	if labels:
774	print >>dotfile, '\tnode [fontname=arial,fontsize=9,label="\N"];'
775	print >>dotfile, '\tedge [fontname=arial,fontsize=9];\n'
776	else:
777	print >>dotfile, '\tnode [label=""];'
778
779
780	self.gen_dot_topo(d, labels, dotfile)
781	print >>dotfile, "}"
782	dotfile.close()
783
784	# Redirect the drawing program stderr
785	dev_null = open("/dev/null", "w")
786	rv = subprocess.call(cmd, stderr=dev_null)
787	os.remove(dotname)
788	dev_null.close()
789	if rv != 0:
790	sys.exit("Error creating graph")
791
792
793
794	def __call__(self):
795	"""
796	The control flow. Compose the request and print the response.
797	"""
798	# Process the options using the customized option parser defined above
799	parser = fedd_image_opts()
800
801	(opts, args) = parser.parse_args()
802
803	if opts.trusted:
804	if ( not os.access(opts.trusted, os.R_OK) ) :
805	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
806
807	if opts.debug > 0: opts.tracefile=sys.stderr
808
809	(user, cert) = self.get_user_info([])
810
811	if opts.cert != None: cert = opts.cert
812
813	if cert == None:
814	sys.exit("No certificate given (--cert) or found")
815
816	if os.access(cert, os.R_OK):
817	fid = fedid(file=cert)
818	else:
819	sys.exit("Cannot read certificate (%s)" % cert)
820
821	if opts.exp_name and opts.exp_certfile:
822	sys.exit("Only one of --experiment_cert and " +\
823	"--experiment_name permitted");
824
825	if opts.exp_certfile:
826	exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
827
828	if opts.exp_name:
829	exp_id = { 'localname' : opts.exp_name }
830
831	if opts.format and opts.outfile:
832	fmt = opts.format
833	file = opts.outfile
834	elif not opts.format and opts.outfile:
835	fmt = opts.outfile[-3:]
836	if fmt not in ("png", "jpg", "dot", "svg"):
837	sys.exit("Unexpected file type and no format specified")
838	file = opts.outfile
839	elif opts.format and not opts.outfile:
840	fmt = opts.format
841	file = None
842	else:
843	fmt="dot"
844	file = None
845
846
847	req = { 'experiment': exp_id }
848
849	try:
850	resp_dict = self.do_rpc(req,
851	opts.url, opts.transport, cert, opts.trusted,
852	serialize_only=opts.serialize_only,
853	tracefile=opts.tracefile)
854	except self.RPCException, e:
855	exit_with_fault(\
856	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
857	except RuntimeError, e:
858	sys.exit("Error processing RPC: %s" % e)
859
860
861	if resp_dict.has_key('vtopo'):
862	self.gen_image(resp_dict['vtopo'],
863	len(resp_dict['vtopo'].get('node', [])),
864	file, fmt, opts.neato, opts.labels, opts.pixels)
865	else:
866	sys.exit("Bad response. %s" % e.message)
867
868	class ns_image(image):
869	def __init__(self, op='Ns2Split'):
870	"""
871	Null constructor
872	"""
873
874	image.__init__(self, 'Ns2Split')
875
876	def generate_topo_dict(self, splitout):
877	class topo_parse:
878	"""
879	Parse the topology XML and create the dats structure. This class
880	is copied from federation.experiment_control.
881	"""
882	def __init__(self):
883	# Typing of the subelements for data conversion
884	self.str_subelements = ('vname', 'vnode', 'ips', 'ip', 'member')
885	self.int_subelements = ( 'bandwidth',)
886	self.float_subelements = ( 'delay',)
887	# The final data structure
888	self.nodes = [ ]
889	self.lans = [ ]
890	self.topo = { \
891	'node': self.nodes,\
892	'lan' : self.lans,\
893	}
894	self.element = { } # Current element being created
895	self.chars = "" # Last text seen
896
897	def end_element(self, name):
898	# After each sub element the contents is added to the current
899	# element or to the appropriate list.
900	if name == 'node':
901	self.nodes.append(self.element)
902	self.element = { }
903	elif name == 'lan':
904	self.lans.append(self.element)
905	self.element = { }
906	elif name in self.str_subelements:
907	self.element[name] = self.chars
908	self.chars = ""
909	elif name in self.int_subelements:
910	self.element[name] = int(self.chars)
911	self.chars = ""
912	elif name in self.float_subelements:
913	self.element[name] = float(self.chars)
914	self.chars = ""
915
916	def found_chars(self, data):
917	self.chars += data.rstrip()
918
919
920	tp = topo_parse();
921	parser = xml.parsers.expat.ParserCreate()
922	parser.EndElementHandler = tp.end_element
923	parser.CharacterDataHandler = tp.found_chars
924
925	m = re.search('^#\s+Begin\s+Vtopo\s$(.)^#\s+End\s+Vtopo', splitout,
926	re.MULTILINE \| re.DOTALL)
927	if m:
928	str = m.group(1)
929	else:
930	sys.exit("Badly formatted split")
931
932	parser.Parse(str)
933
934	return tp.topo
935
936	def __call__(self):
937	"""
938	The control flow. Compose the request and print the response.
939	"""
940	access_keys = []
941	# Process the options using the customized option parser defined above
942	parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
943	self.add_x509_cert)
944
945	(opts, args) = parser.parse_args()
946
947	if opts.trusted:
948	if ( not os.access(opts.trusted, os.R_OK) ) :
949	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
950
951	if opts.debug > 0: opts.tracefile=sys.stderr
952
953	(user, cert) = self.get_user_info([])
954
955	if opts.cert != None: cert = opts.cert
956
957	if cert == None:
958	sys.exit("No certificate given (--cert) or found")
959
960	if os.access(cert, os.R_OK):
961	fid = fedid(file=cert)
962	else:
963	sys.exit("Cannot read certificate (%s)" % cert)
964
965	if opts.file:
966	exp_desc = ""
967	try:
968	f = open(opts.file, 'r')
969	for line in f:
970	exp_desc += line
971	f.close()
972	except IOError:
973	sys.exit("Cannot read description file (%s)" %opts.file)
974	else:
975	sys.exit("Must specify an experiment description (--file)")
976
977	if not opts.master:
978	opts.master="dummy"
979
980
981	req = {
982	'description': { 'ns2description': exp_desc },
983	'master': opts.master,
984	'include_fedkit': opts.fedkit,
985	'include_gatewaykit': opts.gatewaykit,
986	}
987
988
989	if opts.format and opts.outfile:
990	fmt = opts.format
991	file = opts.outfile
992	elif not opts.format and opts.outfile:
993	fmt = opts.outfile[-3:]
994	if fmt not in ("png", "jpg", "dot", "svg"):
995	sys.exit("Unexpected file type and no format specified")
996	file = opts.outfile
997	elif opts.format and not opts.outfile:
998	fmt = opts.format
999	file = None
1000	else:
1001	fmt="dot"
1002	file = None
1003
1004	try:
1005	resp_dict = self.do_rpc(req,
1006	opts.url, opts.transport, cert, opts.trusted,
1007	serialize_only=opts.serialize_only,
1008	tracefile=opts.tracefile)
1009	except self.RPCException, e:
1010	exit_with_fault(\
1011	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1012	except RuntimeError, e:
1013	sys.exit("Error processing RPC: %s" % e)
1014
1015
1016	if resp_dict.has_key('output'):
1017	if len(resp_dict['output']) < 1:
1018	sys.exit("Bad response: could not split")
1019	topo = self.generate_topo_dict(resp_dict['output'])
1020	self.gen_image(topo, len(topo.get('node', [])), file, fmt,
1021	opts.neato, opts.labels, opts.pixels)
1022	else:
1023	sys.exit("Bad response. %s" % e.message)
1024
1025	class topdl_image(image):
1026	def __init__(self, op='Ns2Split'):
1027	"""
1028	Null constructor
1029	"""
1030
1031	image.__init__(self, 'Ns2Split')
1032
1033	@staticmethod
1034	def gen_dot_topo(t, labels, dotfile):
1035	lans = [ s for s in t.substrates if len(s.interfaces) != 2]
1036	links = [ s for s in t.substrates if len(s.interfaces) == 2]
1037
1038	i = 0
1039	for n in t.elements:
1040	if n.name:
1041	print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n.name[0]
1042	else:
1043	print >>dotfile, \
1044	'\t"unnamed_node%d" [shape=box,style=filled,\\' % i
1045	i += 1
1046	print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
1047
1048	# Encode the lans and the links
1049	for l in lans:
1050	print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l.name
1051	print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
1052	for i in l.interfaces:
1053	ip = i.get_attribute('ip4_address')
1054	if labels and ip:
1055	print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
1056	(l.name, i.element.name[0], ip)
1057	else:
1058	print >>dotfile, '\t"%s" -- "%s"' % \
1059	(l.name, i.element.name[0])
1060
1061	for l in links:
1062	s, d = l.interfaces[0:2]
1063	sip = s.get_attribute('ip4_address')
1064	dip = s.get_attribute('ip4_address')
1065	if labels and sip and dip:
1066	print >>dotfile, \
1067	('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
1068	'headlabel="%s"]') % \
1069	(s.element.name[0], d.element.name[0], l.name,
1070	sip, dip)
1071	else:
1072	print >>dotfile, '\t"%s" -- "%s" ' % \
1073	(s.element.name[0], d.element.name[0])
1074	def __call__(self):
1075	"""
1076	The control flow. Compose the request and print the response.
1077	"""
1078	access_keys = []
1079	# Process the options using the customized option parser defined above
1080	parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
1081	self.add_x509_cert)
1082
1083	(opts, args) = parser.parse_args()
1084
1085	if opts.trusted:
1086	if ( not os.access(opts.trusted, os.R_OK) ) :
1087	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1088
1089	if opts.debug > 0: opts.tracefile=sys.stderr
1090
1091	(user, cert) = self.get_user_info([])
1092
1093	if opts.cert != None: cert = opts.cert
1094
1095	if cert == None:
1096	sys.exit("No certificate given (--cert) or found")
1097
1098	if os.access(cert, os.R_OK):
1099	fid = fedid(file=cert)
1100	else:
1101	sys.exit("Cannot read certificate (%s)" % cert)
1102
1103	if opts.file:
1104	exp_desc = ""
1105	try:
1106	top = topdl.topology_from_xml(file=opts.file, top="experiment")
1107	except IOError:
1108	sys.exit("Cannot read description file (%s)" % opts.file)
1109	else:
1110	sys.exit("Must specify an experiment description (--file)")
1111
1112	if not opts.master:
1113	opts.master="dummy"
1114
1115
1116	if opts.format and opts.outfile:
1117	fmt = opts.format
1118	file = opts.outfile
1119	elif not opts.format and opts.outfile:
1120	fmt = opts.outfile[-3:]
1121	if fmt not in ("png", "jpg", "dot", "svg"):
1122	sys.exit("Unexpected file type and no format specified")
1123	file = opts.outfile
1124	elif opts.format and not opts.outfile:
1125	fmt = opts.format
1126	file = None
1127	else:
1128	fmt="dot"
1129	file = None
1130
1131	self.gen_image(top, len(top.elements), file, fmt, opts.neato,
1132	opts.labels, opts.pixels)
1133
1134	class terminate(fedd_rpc):
1135	def __init__(self):
1136	"""
1137	Termination request
1138	"""
1139
1140	fedd_rpc.__init__(self, "Terminate")
1141
1142	def __call__(self):
1143	"""
1144	The control flow. Compose the request and print the response.
1145	"""
1146	# Process the options using the customized option parser defined above
1147	parser = fedd_terminate_opts()
1148
1149	(opts, args) = parser.parse_args()
1150
1151	(user, cert) = self.get_user_info([])
1152	if opts.trusted:
1153	if ( not os.access(opts.trusted, os.R_OK) ) :
1154	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1155
1156	if opts.debug > 0: opts.tracefile=sys.stderr
1157
1158	if opts.cert != None: cert = opts.cert
1159
1160	if cert == None:
1161	sys.exit("No certificate given (--cert) or found")
1162
1163	if os.access(cert, os.R_OK):
1164	fid = fedid(file=cert)
1165	else:
1166	sys.exit("Cannot read certificate (%s)" % cert)
1167
1168	if opts.exp_name and opts.exp_certfile:
1169	sys.exit("Only one of --experiment_cert and " +\
1170	"--experiment_name permitted")
1171
1172	if opts.print_log and opts.logfile:
1173	sys.exit("Only one of --logfile and --print_log is permitted")
1174	elif opts.print_log:
1175	out = sys.stdout
1176	elif opts.logfile:
1177	try:
1178	out = open(opts.logfile, "w")
1179	except IOError,e:
1180	sys.exit("Cannot open logfile: %s" %e)
1181	else:
1182	out = None
1183
1184	exp_id = None
1185
1186	if opts.exp_certfile:
1187	exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
1188
1189	if opts.exp_name:
1190	exp_id = { 'localname' : opts.exp_name }
1191
1192	if not exp_id:
1193	sys.exit("Must give one of --experiment_cert and " +\
1194	"--experiment_name");
1195
1196	req = { 'experiment': exp_id, 'force': opts.force }
1197
1198	try:
1199	resp_dict = self.do_rpc(req,
1200	opts.url, opts.transport, cert, opts.trusted,
1201	serialize_only=opts.serialize_only,
1202	tracefile=opts.tracefile)
1203	except self.RPCException, e:
1204	exit_with_fault(\
1205	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1206	except RuntimeError, e:
1207	print e
1208	sys.exit("Error processing RPC: %s" % e)
1209
1210	if out:
1211	log = resp_dict.get('deallocationLog', None)
1212	if log:
1213	print >>out, log
1214	out.close()
1215	else:
1216	out.close()
1217	sys.exit("No log returned")
1218
1219	class create(fedd_rpc):
1220	def __init__(self):
1221	fedd_rpc.__init__(self, "Create")
1222	def __call__(self):
1223	access_keys = []
1224	# Process the options using the customized option parser defined above
1225	parser = fedd_create_opts(access_keys, self.add_ssh_key,
1226	self.add_x509_cert)
1227
1228	(opts, args) = parser.parse_args()
1229
1230	if opts.trusted:
1231	if ( not os.access(opts.trusted, os.R_OK) ) :
1232	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1233
1234	if not opts.project :
1235	parser.error('--project is required')
1236
1237	if opts.debug > 0: opts.tracefile=sys.stderr
1238
1239	(user, cert) = self.get_user_info(access_keys)
1240
1241	if opts.user: user = opts.user
1242
1243	if opts.cert != None: cert = opts.cert
1244
1245	if cert == None:
1246	sys.exit("No certificate given (--cert) or found")
1247
1248	if os.access(cert, os.R_OK):
1249	fid = fedid(file=cert)
1250	if opts.use_fedid == True:
1251	user = fid
1252	else:
1253	sys.exit("Cannot read certificate (%s)" % cert)
1254
1255	if opts.file:
1256	exp_desc = ""
1257	try:
1258	f = open(opts.file, 'r')
1259	for line in f:
1260	exp_desc += line
1261	f.close()
1262	except IOError:
1263	sys.exit("Cannot read description file (%s)" %opts.file)
1264	else:
1265	sys.exit("Must specify an experiment description (--file)")
1266
1267	if not opts.master:
1268	sys.exit("Must specify a master testbed (--master)")
1269
1270	out_certfile = opts.out_certfile
1271
1272	msg = {
1273	'experimentdescription': { 'ns2description': exp_desc },
1274	'master': opts.master,
1275	'exportProject': { 'localname': opts.project },
1276	'user' : [ {\
1277	'userID': pack_id(user), \
1278	'access': [ { a.type: a.buf } for a in access_keys]\
1279	} ]
1280	}
1281
1282	if opts.exp_name:
1283	msg['experimentID'] = { 'localname': opts.exp_name }
1284
1285	if opts.debug > 1: print >>sys.stderr, msg
1286
1287	try:
1288	resp_dict = self.do_rpc(msg,
1289	opts.url, opts.transport, cert, opts.trusted,
1290	serialize_only=opts.serialize_only,
1291	tracefile=opts.tracefile)
1292	except self.RPCException, e:
1293	exit_with_fault(\
1294	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1295	except RuntimeError, e:
1296	sys.exit("Error processing RPC: %s" % e)
1297
1298	if opts.debug > 1: print >>sys.stderr, resp_dict
1299
1300	ea = resp_dict.get('experimentAccess', None)
1301	if out_certfile and ea and ea.has_key('X509'):
1302	try:
1303	f = open(out_certfile, "w")
1304	print >>f, ea['X509']
1305	f.close()
1306	except IOError:
1307	sys.exit('Could not write to %s' % out_certfile)
1308	eid = resp_dict.get('experimentID', None)
1309	if eid:
1310	for id in eid:
1311	for k in id.keys():
1312	print "%s: %s" % (k, id[k])
1313	st = resp_dict.get('experimentStatus', None)
1314	if st:
1315	print "status: %s" % st
1316
1317	class split(fedd_rpc):
1318	def __init__(self):
1319	fedd_rpc.__init__(self, "Ns2Split")
1320	def __call__(self):
1321	access_keys = []
1322	# Process the options using the customized option parser defined above
1323	parser = fedd_split_opts(access_keys, self.add_ssh_key,
1324	self.add_x509_cert)
1325
1326	(opts, args) = parser.parse_args()
1327
1328	if opts.trusted:
1329	if ( not os.access(opts.trusted, os.R_OK) ) :
1330	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1331
1332	if opts.debug > 0: opts.tracefile=sys.stderr
1333
1334	(user, cert) = self.get_user_info(access_keys)
1335
1336	if opts.cert != None: cert = opts.cert
1337
1338	if cert == None:
1339	sys.exit("No certificate given (--cert) or found")
1340
1341	if os.access(cert, os.R_OK):
1342	fid = fedid(file=cert)
1343	if opts.use_fedid == True:
1344	user = fid
1345	else:
1346	sys.exit("Cannot read certificate (%s)" % cert)
1347
1348	if opts.file:
1349	exp_desc = ""
1350	try:
1351	f = open(opts.file, 'r')
1352	for line in f:
1353	exp_desc += line
1354	f.close()
1355	except IOError:
1356	sys.exit("Cannot read description file (%s)" %opts.file)
1357	else:
1358	sys.exit("Must specify an experiment description (--file)")
1359
1360	if not opts.master:
1361	sys.exit("Must specify a master testbed (--master)")
1362
1363	out_certfile = opts.out_certfile
1364
1365	msg = {
1366	'description': { 'ns2description': exp_desc },
1367	'master': opts.master,
1368	'include_fedkit': opts.fedkit,
1369	'include_gatewaykit': opts.gatewaykit,
1370	}
1371
1372	if opts.debug > 1: print >>sys.stderr, msg
1373
1374	try:
1375	resp_dict = self.do_rpc(msg,
1376	opts.url, opts.transport, cert, opts.trusted,
1377	serialize_only=opts.serialize_only,
1378	tracefile=opts.tracefile)
1379	except self.RPCException, e:
1380	exit_with_fault(\
1381	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1382	except RuntimeError, e:
1383	sys.exit("Error processing RPC: %s" % e)
1384
1385	if opts.debug > 1: print >>sys.stderr, resp_dict
1386
1387	out = resp_dict.get('output', None)
1388
1389	for line in out.splitlines():
1390	print "%s" % line
1391
1392	class access(fedd_rpc):
1393	def __init__(self):
1394	fedd_rpc.__init__(self, "RequestAccess")
1395
1396	def print_response_as_testbed(self, resp, label, out=sys.stdout):
1397	"""Print the response as input to the splitter script"""
1398
1399	e = resp['emulab']
1400	p = e['project']
1401	fields = {
1402	"Boss": e['boss'],
1403	"OpsNode": e['ops'],
1404	"Domain": e['domain'],
1405	"FileServer": e['fileServer'],
1406	"EventServer": e['eventServer'],
1407	"Project": unpack_id(p['name'])
1408	}
1409	if (label != None): print >> out, "[%s]" % label
1410
1411	for l, v in fields.iteritems():
1412	print >>out, "%s: %s" % (l, v)
1413
1414	for u in p['user']:
1415	print >>out, "User: %s" % unpack_id(u['userID'])
1416
1417	for a in e['fedAttr']:
1418	print >>out, "%s: %s" % (a['attribute'], a['value'])
1419
1420	def __call__(self):
1421	access_keys = []
1422	node_descs = []
1423	proj = None
1424
1425	# Process the options using the customized option parser defined above
1426	parser = fedd_access_opts(access_keys, node_descs, self.add_ssh_key,
1427	self.add_x509_cert, self.add_node_desc)
1428
1429	(opts, args) = parser.parse_args()
1430
1431	if opts.testbed == None:
1432	parser.error("--testbed is required")
1433
1434	if opts.trusted:
1435	if ( not os.access(opts.trusted, os.R_OK) ) :
1436	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1437
1438	if opts.debug > 0: opts.tracefile=sys.stderr
1439
1440	(user, cert) = self.get_user_info(access_keys)
1441
1442	if opts.user: user = opts.user
1443
1444	if opts.cert != None: cert = opts.cert
1445
1446	if cert == None:
1447	sys.exit("No certificate given (--cert) or found")
1448
1449	if os.access(cert, os.R_OK):
1450	fid = fedid(file=cert)
1451	if opts.use_fedid == True:
1452	user = fid
1453	else:
1454	sys.exit("Cannot read certificate (%s)" % cert)
1455
1456	msg = {
1457	'allocID': pack_id('test alloc'),
1458	'destinationTestbed': pack_id(opts.testbed),
1459	'serviceAccess' : [ { a.type: a.buf } for a in access_keys ],
1460	'createAccess' : [ { a.type: a.buf } for a in access_keys ],
1461	}
1462
1463	if len(node_descs) > 0:
1464	msg['resources'] = {
1465	'node': [
1466	{
1467	'image': n.image ,
1468	'hardware': n.hardware,
1469	'count': n.count,
1470	} for n in node_descs],
1471	}
1472
1473	if opts.project != None:
1474	if not opts.anonymous and user != None:
1475	msg['project'] = {
1476	'name': pack_id(opts.project),
1477	'user': [ { 'userID': pack_id(user) } ],
1478	}
1479	else:
1480	msg['project'] = { 'name': pack_id(opts.project) }
1481	else:
1482	if not opts.anonymous and user != None:
1483	msg['user'] = [ { 'userID': pack_id(user) } ]
1484	else:
1485	msg['user'] = [];
1486
1487	if opts.debug > 1: print >>sys.stderr, msg
1488
1489	try:
1490	resp_dict = self.do_rpc(msg,
1491	opts.url, opts.transport, cert, opts.trusted,
1492	serialize_only=opts.serialize_only,
1493	tracefile=opts.tracefile)
1494	except self.RPCException, e:
1495	exit_with_fault(\
1496	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1497	except RuntimeError, e:
1498	sys.exit("Error processing RPC: %s" % e.message)
1499
1500	if opts.debug > 1: print >>sys.stderr, resp_dict
1501	self.print_response_as_testbed(resp_dict, opts.label)
1502
1503	# Keep requesting experiment status and printing updates to the log until the
1504	# experiment is done being created.
1505	class spew_log(fedd_rpc):
1506	def __init__(self):
1507	"""
1508	Init the superclass
1509	"""
1510
1511	fedd_rpc.__init__(self, 'Info')
1512
1513	def __call__(self):
1514	"""
1515	The control flow. Compose the request and print the response.
1516	"""
1517	# Process the options using the customized option parser defined above
1518	parser = fedd_spew_opts()
1519
1520	(opts, args) = parser.parse_args()
1521
1522	if opts.trusted:
1523	if ( not os.access(opts.trusted, os.R_OK) ) :
1524	sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
1525
1526	if opts.debug > 0: opts.tracefile=sys.stderr
1527
1528	(user, cert) = self.get_user_info([])
1529
1530	if opts.cert != None: cert = opts.cert
1531
1532	if cert == None:
1533	sys.exit("No certificate given (--cert) or found")
1534
1535	if os.access(cert, os.R_OK):
1536	fid = fedid(file=cert)
1537	else:
1538	sys.exit("Cannot read certificate (%s)" % cert)
1539
1540	if opts.exp_name and opts.exp_certfile:
1541	sys.exit("Only one of --experiment_cert and " +\
1542	"--experiment_name permitted");
1543
1544	if opts.exp_certfile:
1545	exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
1546
1547	if opts.exp_name:
1548	exp_id = { 'localname' : opts.exp_name }
1549
1550	if opts.logfile:
1551	try:
1552	out = open(opts.logfile, "w")
1553	except IOError,e:
1554	sys.exit("Cannot open logfile: %s" %e)
1555	else:
1556	out = sys.stdout
1557
1558	req = { 'experiment': exp_id }
1559
1560	status = "starting"
1561	log = ""
1562	log_offset = 0
1563	update = opts.update
1564	while status == 'starting':
1565	try:
1566	resp_dict = self.do_rpc(req,
1567	opts.url, opts.transport, cert, opts.trusted,
1568	serialize_only=opts.serialize_only,
1569	tracefile=opts.tracefile)
1570	except self.RPCException, e:
1571	exit_with_fault(\
1572	{'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
1573	except RuntimeError, e:
1574	sys.exit("Error processing RPC: %s" % e)
1575
1576	status = resp_dict.get('experimentStatus', None)
1577	log = resp_dict.get('allocationLog', None)
1578	if not status:
1579	sys.exit("No status in Info response??")
1580	if log:
1581	if len(log) > log_offset:
1582	print >>out, log[log_offset:],
1583	out.flush()
1584	log_offset = len(log)
1585	if status == 'starting':
1586	time.sleep(update)
1587
1588	print >>out
1589	print >>out, status
1590	out.close()
1591
1592
1593	cmds = {\
1594	'create': create(),\
1595	'split': split(),\
1596	'access': access(),\
1597	'vtopo': vtopo(),\
1598	'vis': vis(),\
1599	'info': exp_data(),\
1600	'multiinfo': multi_exp_data(),\
1601	'multistatus': multi_status(),\
1602	'image': image(),\
1603	'ns_image': ns_image(),\
1604	'status': status(),\
1605	'terminate': terminate(),\
1606	'spewlog': spew_log(),\
1607	'topdl_image': topdl_image(),\
1608	}
1609
1610	operation = cmds.get(sys.argv[1], None)
1611	if operation:
1612	del sys.argv[1]
1613	operation()
1614	else:
1615	if sys.argv[1] == '--help':
1616	sys.exit(\
1617	'''Only context sensitive help is available. For one of the commands:
1618
1619	%s
1620
1621	type
1622	%s command --help
1623
1624	to get help, e.g., %s create --help
1625	''' % (", ".join(cmds.keys()), sys.argv[0], sys.argv[0]))
1626	else:
1627	sys.exit("Bad command: %s. Valid ones are: %s" % \
1628	(sys.argv[1], ", ".join(cmds.keys())))
1629

Note: See TracBrowser for help on using the repository browser.

Download in other formats: