Context Navigation

source: fedd/fedd_create_experiment.py @ a8b42b5

axis_examplecompt_changesinfo-opsversion-1.30version-2.00version-3.01version-3.02

Last change on this file since a8b42b5 was a8b42b5, checked in by Ted Faber <faber@…>, 16 years ago
master testbed does not need a SeerControl? field
Property mode set to `100644`
File size: 42.6 KB

Line
1	#!/usr/local/bin/python
2
3	import os,sys
4
5	from ZSI import *
6	from M2Crypto import SSL
7	from M2Crypto.SSL.SSLServer import SSLServer
8	import M2Crypto.httpslib
9
10	import xml.parsers.expat
11
12	import re
13	import random
14	import string
15	import subprocess
16	import tempfile
17	import copy
18
19	import traceback
20
21	from threading import *
22
23	from subprocess import *
24
25	from fedd_services import *
26	from fedd_internal_services import *
27	from fedd_util import *
28	import parse_detail
29	from service_error import *
30
31	class fedd_create_experiment_local:
32	scripts = ["fed_bootstrap", "federate.sh", "smbmount.FreeBSD.pl",
33	"smbmount.Linux.pl", "make_hosts", "fed-tun.pl", "fed-tun.ucb.pl",
34	"fed_evrepeater", "rc.accounts.patch", "daemon.py",
35	"experiment-setup.py"]
36
37	def __init__(self,
38	cert_file=None,
39	cert_pwd=None,
40	exp_stem="fed-stem",
41	debug=False,
42	muxmax=2,
43	nthreads=2,
44	randomize_experiments=False,
45	scp_exec="/usr/bin/scp",
46	scripts_dir="./",
47	splitter=None,
48	ssh_exec="/usr/bin/ssh",
49	ssh_identity_file=None,
50	ssh_keygen="/usr/bin/ssh-keygen",
51	ssh_pubkey_file=None,
52	ssh_type="rsa",
53	tbmap=None,
54	tclsh="/usr/local/bin/otclsh",
55	tcl_splitter="/usr/testbed/lib/ns2ir/parse.tcl",
56	trace_file=None,
57	trusted_certs=None,
58	):
59	self.scripts = fedd_create_experiment_local.scripts
60	self.thread_with_rv = fedd_create_experiment_local.pooled_thread
61	self.thread_pool = fedd_create_experiment_local.thread_pool
62
63	self.cert_file = cert_file
64	self.cert_pwd = cert_pwd
65	self.exp_stem = exp_stem
66	self.debug = debug
67	self.muxmax = muxmax
68	self.nthreads = nthreads
69	self.randomize_experiments = randomize_experiments
70	self.scp_exec = scp_exec
71	self.scripts_dir = scripts_dir
72	self.splitter = splitter
73	self.ssh_exec=ssh_exec
74	self.ssh_keygen = ssh_keygen
75	self.ssh_identity_file = ssh_identity_file
76	self.ssh_type = ssh_type
77	self.state = { }
78	self.tclsh = tclsh
79	self.tcl_splitter = tcl_splitter
80	self.tbmap = tbmap
81	self.trace_file = trace_file
82	self.trusted_certs=trusted_certs
83
84	self.def_expstart = \
85	"sudo -H /bin/sh FEDDIR/fed_bootstrap >& /tmp/federate";
86	self.def_mexpstart = "sudo -H FEDDIR/make_hosts FEDDIR/hosts";
87	self.def_gwstart = \
88	"sudo -H FEDDIR/fed-tun.pl -f GWCONF>& /tmp/bridge.log";
89	self.def_mgwstart = \
90	"sudo -H FEDDIR/fed-tun.pl -f GWCONF >& /tmp/bridge.log";
91	self.def_gwimage = "FBSD61-TUNNEL2";
92	self.def_gwtype = "pc";
93
94
95	if ssh_pubkey_file:
96	try:
97	f = open(ssh_pubkey_file, 'r')
98	self.ssh_pubkey = f.read()
99	f.close()
100	except IOError:
101	raise service_error(service_error.internal,
102	"Cannot read sshpubkey")
103
104	# Confirm federation scripts in the right place
105	for s in self.scripts:
106	if not os.path.exists(self.scripts_dir + "/" + s):
107	raise service_error(service_error.server_config,
108	"%s/%s not in local script dir" % (self.scripts_dir, s))
109	class thread_pool:
110	def __init__(self):
111	self.changed = Condition()
112	self.started = 0
113	self.terminated = 0
114
115	def acquire(self):
116	self.changed.acquire()
117
118	def release(self):
119	self.changed.release()
120
121	def wait(self, timeout = None):
122	self.changed.wait(timeout)
123
124	def start(self):
125	self.changed.acquire()
126	self.started += 1
127	self.changed.notifyAll()
128	self.changed.release()
129
130	def terminate(self):
131	self.changed.acquire()
132	self.terminated += 1
133	self.changed.notifyAll()
134	self.changed.release()
135
136	def clear(self):
137	self.changed.acquire()
138	self.started = 0
139	self.terminated =0
140	self.changed.notifyAll()
141	self.changed.release()
142
143
144
145	class pooled_thread(Thread):
146	def __init__(self, group=None, target=None, name=None, args=(),
147	kwargs={}, pdata=None, trace_file=None):
148	Thread.__init__(self, group, target, name, args, kwargs)
149	self.rv = None
150	self.exception = None
151	self.target=target
152	self.args = args
153	self.kwargs = kwargs
154	self.pdata = pdata
155	self.trace_file = trace_file
156
157	def run(self):
158	if self.pdata:
159	self.pdata.start()
160
161	if self.target:
162	try:
163	self.rv = self.target(self.args, *self.kwargs)
164	except service_error, s:
165	self.exception = s
166	if self.trace_file:
167	print >>self.trace_file, "Thread exception: %s %s" % \
168	(s.code_string(), s.desc)
169
170	except:
171	self.exception = sys.exc_info()[1]
172	if self.trace_file:
173	print >>self.trace_file, \
174	"Unexpected thread exception: %s" % \
175	self.exception
176	print >>self.trace_file, "Trace: %s" % \
177	traceback.format_exc()
178	if self.pdata:
179	self.pdata.terminate()
180
181	def copy_file(self, src, dest, size=1024):
182	"""
183	Exceedingly simple file copy.
184	"""
185	s = open(src,'r')
186	d = open(dest, 'w')
187
188	buf = "x"
189	while buf != "":
190	buf = s.read(size)
191	d.write(buf)
192	s.close()
193	d.close()
194
195	def scp_file(self, file, user, host, dest=""):
196	"""
197	scp a file to the remote host.
198	"""
199
200	scp_cmd = [self.scp_exec, file, "%s@%s:%s" % (user, host, dest)]
201
202	trace = self.trace_file
203	if not trace:
204	try:
205	trace = open("/dev/null", "w")
206	except IOError:
207	raise service_error(service_error.internal,
208	"Cannot open /dev/null??");
209
210	if not self.debug:
211	rv = call(scp_cmd, stdout=trace, stderr=trace)
212	else:
213	if self.trace_file:
214	print >>self.trace_file, "debug [scp_file]: %s" % \
215	" ".join(scp_cmd)
216	rv = 0
217
218	return rv == 0
219
220	def ssh_cmd(self, user, host, cmd, wname=None):
221	sh_str = "%s %s@%s %s" % (self.ssh_exec, user, host, cmd)
222
223	trace = self.trace_file
224	if not trace:
225	try:
226	trace = open("/dev/null", "w")
227	except IOError:
228	raise service_error(service_error.internal,
229	"Cannot open /dev/null??");
230
231	if not self.debug:
232	sub = Popen(sh_str, shell=True, stdout=trace, stderr=trace)
233	return sub.wait() == 0
234	else:
235	if self.trace_file:
236	print >>self.trace_file,"debug [ssh_cmd]: %s" % sh_str
237	return True
238
239	def ship_scripts(self, host, user, dest_dir):
240	if self.ssh_cmd(user, host, "mkdir -p %s" % dest_dir):
241	for s in self.scripts:
242	if not self.scp_file("%s/%s" % (self.scripts_dir, s),
243	user, host, dest_dir):
244	return False
245	return True
246	else:
247	return False
248
249	def ship_configs(self, host, user, src_dir, dest_dir):
250	if not self.ssh_cmd(user, host, "mkdir -p %s" % dest_dir):
251	return False
252	if not self.ssh_cmd(user, host, "chmod 770 %s" % dest_dir):
253	return False
254
255	for f in os.listdir(src_dir):
256	if os.path.isdir(f):
257	if not self.ship_configs(host, user, "%s/%s" % (src_dir, f),
258	"%s/%s" % (dest_dir, f)):
259	return False
260	else:
261	if not self.scp_file("%s/%s" % (src_dir, f),
262	user, host, dest_dir):
263	return False
264	return True
265
266	def start_segment(self, tb, eid, tbparams, tmpdir, timeout=0):
267	host = "%s%s" % (tbparams[tb]['host'], tbparams[tb]['domain'])
268	user = tbparams[tb]['user']
269	pid = tbparams[tb]['project']
270	# XXX
271	base_confs = ( "hosts",)
272	tclfile = "%s.%s.tcl" % (eid, tb)
273	expinfo_exec = "/usr/testbed/bin/expinfo"
274	proj_dir = "/proj/%s/exp/%s/tmp" % (pid, eid)
275	tarfiles_dir = "/proj/%s/tarfiles/%s" % (pid, eid)
276	rpms_dir = "/proj/%s/rpms/%s" % (pid, eid)
277	state_re = re.compile("State:\s+(\w+)")
278	no_exp_re = re.compile("^No\s+such\s+experiment")
279	state = None
280	cmd = [self.ssh_exec, "%s@%s" % (user, host), expinfo_exec, pid, eid]
281
282
283	if self.trace_file:
284	print >>self.trace_file, "status request: %s" % " ".join(cmd)
285
286	if not self.trace_file:
287	try:
288	st_file = open("/dev/null", "w")
289	except IOError:
290	raise service_error(service_error.internal,
291	"Cannot open /dev/null!?")
292	else:
293	st_file = self.trace_file
294
295	status = Popen(cmd, stdout=PIPE, stderr=st_file)
296	for line in status.stdout:
297	m = state_re.match(line)
298	if m: state = m.group(1)
299	else:
300	m = no_exp_re.match(line)
301	if m: state = "none"
302	rv = status.wait()
303	# If the experiment is not present the subcommand returns a non-zero
304	# return value. If we successfully parsed a "none" outcome, ignore the
305	# return code.
306	if rv != 0 and state != "none":
307	raise service_error(service_error.internal,
308	"Cannot get status of segment %s:%s/%s" % (tb, pid, eid))
309	if self.trace_file:
310	print >>self.trace_file, "%s: %s" % (tb, state)
311	print >>self.trace_file, "transferring experiment to %s" % tb
312
313	if not self.scp_file("%s/%s/%s" % (tmpdir, tb, tclfile), user, host):
314	return False
315	# Clear the federation files
316	if not self.ssh_cmd(user, host,
317	"/bin/sh -c \"'/bin/rm -rf %s'\"" % proj_dir):
318	return False
319	if not self.ssh_cmd(user, host,
320	"/bin/sh -c \"'mkdir -p %s'\"" % proj_dir):
321	return False
322	# Clear and create the tarfiles and rpm directories
323	for d in (tarfiles_dir, rpms_dir):
324	if not self.ssh_cmd(user, host,
325	"/bin/sh -c \"'/bin/rm -rf %s/*'\"" % d):
326	return False
327	if not self.ssh_cmd(user, host, "mkdir -p %s" % d,
328	"create tarfiles"):
329	return False
330
331	if state == 'active':
332	# Remote experiment is active. Modify it.
333	for f in base_confs:
334	if not self.scp_file("%s/%s" % (tmpdir, f), user, host,
335	"%s/%s" % (proj_dir, f)):
336	return False
337	if not self.ship_scripts(host, user, proj_dir):
338	return False
339	if not self.ship_configs(host, user, "%s/%s" % (tmpdir, tb),
340	proj_dir):
341	return False
342	if os.path.isdir("%s/tarfiles" % tmpdir):
343	if not self.ship_configs(host, user,
344	"%s/tarfiles" % tmpdir, tarfiles_dir):
345	return False
346	if os.path.isdir("%s/rpms" % tmpdir):
347	if not self.ship_configs(host, user,
348	"%s/rpms" % tmpdir, tarfiles_dir):
349	return False
350	if self.trace_file:
351	print >>self.trace_file, "Modifying %s on %s" % (eid, tb)
352	if not self.ssh_cmd(user, host,
353	"/usr/testbed/bin/modexp -r -s -w %s %s %s" % \
354	(pid, eid, tclfile), "modexp"):
355	return False
356	return True
357	elif state == "swapped":
358	# Remote experiment swapped out. Modify it and swap it in.
359	for f in base_confs:
360	if not self.scp_file("%s/%s" % (tmpdir, f), user, host,
361	"%s/%s" % (proj_dir, f)):
362	return False
363	if not self.ship_scripts(host, user, proj_dir):
364	return False
365	if not self.ship_configs(host, user, "%s/%s" % (tmpdir, tb),
366	proj_dir):
367	return False
368	if os.path.isdir("%s/tarfiles" % tmpdir):
369	if not self.ship_configs(host, user,
370	"%s/tarfiles" % tmpdir, tarfiles_dir):
371	return False
372	if os.path.isdir("%s/rpms" % tmpdir):
373	if not self.ship_configs(host, user,
374	"%s/rpms" % tmpdir, tarfiles_dir):
375	return False
376	if self.trace_file:
377	print >>self.trace_file, "Modifying %s on %s" % (eid, tb)
378	if not self.ssh_cmd(user, host,
379	"/usr/testbed/bin/modexp -w %s %s %s" % (pid, eid, tclfile),
380	"modexp"):
381	return False
382	if self.trace_file:
383	print >>self.trace_file, "Swapping %s in on %s" % (eid, tb)
384	if not self.ssh_cmd(user, host,
385	"/usr/testbed/bin/swapexp -w %s %s in" % (pid, eid),
386	"swapexp"):
387	return False
388	return True
389	elif state == "none":
390	# No remote experiment. Create one. We do this in 2 steps so we
391	# can put the configuration files and scripts into the new
392	# experiment directories.
393
394	# Tarfiles must be present for creation to work
395	if os.path.isdir("%s/tarfiles" % tmpdir):
396	if not self.ship_configs(host, user,
397	"%s/tarfiles" % tmpdir, tarfiles_dir):
398	return False
399	if os.path.isdir("%s/rpms" % tmpdir):
400	if not self.ship_configs(host, user,
401	"%s/rpms" % tmpdir, tarfiles_dir):
402	return False
403	if self.trace_file:
404	print >>self.trace_file, "Creating %s on %s" % (eid, tb)
405	if not self.ssh_cmd(user, host,
406	"/usr/testbed/bin/startexp -i -f -w -p %s -e %s %s" % \
407	(pid, eid, tclfile), "startexp"):
408	return False
409	# After startexp the per-experiment directories exist
410	for f in base_confs:
411	if not self.scp_file("%s/%s" % (tmpdir, f), user, host,
412	"%s/%s" % (proj_dir, f)):
413	return False
414	if not self.ship_scripts(host, user, proj_dir):
415	return False
416	if not self.ship_configs(host, user, "%s/%s" % (tmpdir, tb),
417	proj_dir):
418	return False
419	if self.trace_file:
420	print >>self.trace_file, "Swapping %s in on %s" % (eid, tb)
421	if not self.ssh_cmd(user, host,
422	"/usr/testbed/bin/swapexp -w %s %s in" % (pid, eid),
423	"swapexp"):
424	return False
425	return True
426	else:
427	if self.trace_file:
428	print >>self.trace_file, "unknown state %s" % state
429	return False
430
431	def stop_segment(self, tb, eid, tbparams):
432	user = tbparams[tb]['user']
433	host = "%s%s" % (tbparams[tb]['host'], tbparams[tb]['domain'])
434	pid = tbparams[tb]['project']
435
436	if self.trace_file:
437	print >>self.trace_file, "Stopping %s on %s" % (eid, tb)
438	return self.ssh_cmd(user, host,
439	"/usr/testbed/bin/swapexp -w %s %s out" % (pid, eid))
440
441
442	def generate_ssh_keys(self, dest, type="rsa" ):
443	"""
444	Generate a set of keys for the gateways to use to talk.
445
446	Keys are of type type and are stored in the required dest file.
447	"""
448	valid_types = ("rsa", "dsa")
449	t = type.lower();
450	if t not in valid_types: raise ValueError
451
452	trace = self.trace_file
453	if not trace:
454	try:
455	trace = open("/dev/null", "w")
456	except IOError:
457	raise service_error(service_error.internal,
458	"Cannot open /dev/null??");
459
460	# May raise CalledProcessError
461	rv = call([self.ssh_keygen, '-t', t, '-N', '', '-f', dest],
462	stdout=trace, stderr=trace)
463	if rv != 0:
464	raise service_error(service_error.internal,
465	"Cannot generate nonce ssh keys. %s return code %d" \
466	% (self.ssh_keygen, rv))
467
468	def gentopo(self, str):
469	class topo_parse:
470	def __init__(self):
471	self.str_subelements = ('vname', 'vnode', 'ips', 'ip', 'member')
472	self.int_subelements = ( 'bandwidth',)
473	self.float_subelements = ( 'delay',)
474	self.nodes = [ ]
475	self.lans = [ ]
476	self.element = { }
477	self.topo = { \
478	'node': self.nodes,\
479	'lan' : self.lans,\
480	}
481	self.chars = ""
482
483	def end_element(self, name):
484	if name == 'node':
485	self.nodes.append(self.element)
486	self.element = { }
487	elif name == 'lan':
488	self.lans.append(self.element)
489	self.element = { }
490	elif name in self.str_subelements:
491	self.element[name] = self.chars
492	self.chars = ""
493	elif name in self.int_subelements:
494	self.element[name] = int(self.chars)
495	self.chars = ""
496	elif name in self.float_subelements:
497	self.element[name] = float(self.chars)
498	self.chars = ""
499
500	def found_chars(self, data):
501	self.chars += data.rstrip()
502
503
504	tp = topo_parse();
505	parser = xml.parsers.expat.ParserCreate()
506	parser.EndElementHandler = tp.end_element
507	parser.CharacterDataHandler = tp.found_chars
508
509	parser.Parse(str)
510
511	return tp.topo
512
513
514	def genviz(self, topo):
515	"""
516	Generate the visualization the virtual topology
517	"""
518
519	neato = "/usr/local/bin/neato"
520	# These are used to parse neato output and to create the visualization
521	# file.
522	vis_re = re.compile('^\s"?([\w\-]+)"?\s+\[.pos="(\d+),(\d+)"')
523	vis_fmt = "<node><name>%s</name><x>%s</x><y>%s</y><type>" + \
524	"%s</type></node>"
525
526	try:
527	# Node names
528	nodes = [ n['vname'] for n in topo['node'] ]
529	topo_lans = topo['lan']
530	except KeyError:
531	raise service_error(service_error.internal, "Bad topology")
532
533	lans = { }
534	links = { }
535
536	# Walk through the virtual topology, organizing the connections into
537	# 2-node connections (links) and more-than-2-node connections (lans).
538	# When a lan is created, it's added to the list of nodes (there's a
539	# node in the visualization for the lan).
540	for l in topo_lans:
541	if links.has_key(l['vname']):
542	if len(links[l['vname']]) < 2:
543	links[l['vname']].append(l['vnode'])
544	else:
545	nodes.append(l['vname'])
546	lans[l['vname']] = links[l['vname']]
547	del links[l['vname']]
548	lans[l['vname']].append(l['vnode'])
549	elif lans.has_key(l['vname']):
550	lans[l['vname']].append(l['vnode'])
551	else:
552	links[l['vname']] = [ l['vnode'] ]
553
554
555	# Open up a temporary file for dot to turn into a visualization
556	try:
557	df, dotname = tempfile.mkstemp()
558	dotfile = os.fdopen(df, 'w')
559	except IOError:
560	raise service_error(service_error.internal,
561	"Failed to open file in genviz")
562
563	# Generate a dot/neato input file from the links, nodes and lans
564	try:
565	print >>dotfile, "graph G {"
566	for n in nodes:
567	print >>dotfile, '\t"%s"' % n
568	for l in links.keys():
569	print >>dotfile, '\t"%s" -- "%s"' % tuple(links[l])
570	for l in lans.keys():
571	for n in lans[l]:
572	print >>dotfile, '\t "%s" -- "%s"' % (n,l)
573	print >>dotfile, "}"
574	dotfile.close()
575	except TypeError:
576	raise service_error(service_error.internal,
577	"Single endpoint link in vtopo")
578	except IOError:
579	raise service_error(service_error.internal, "Cannot write dot file")
580
581	# Use dot to create a visualization
582	dot = Popen([neato, '-Gstart=rand', '-Gepsilon=0.005', '-Gmaxiter=2000',
583	'-Gpack=true', dotname], stdout=PIPE)
584
585	# Translate dot to vis format
586	vis_nodes = [ ]
587	vis = { 'node': vis_nodes }
588	for line in dot.stdout:
589	m = vis_re.match(line)
590	if m:
591	vn = m.group(1)
592	vis_node = {'name': vn, \
593	'x': float(m.group(2)),\
594	'y' : float(m.group(3)),\
595	}
596	if vn in links.keys() or vn in lans.keys():
597	vis_node['type'] = 'lan'
598	else:
599	vis_node['type'] = 'node'
600	vis_nodes.append(vis_node)
601	rv = dot.wait()
602
603	os.remove(dotname)
604	if rv == 0 : return vis
605	else: return None
606
607
608	def get_access(self, tb, nodes, user, tbparam):
609	"""
610	Get access to testbed through fedd and set the parameters for that tb
611	"""
612
613	translate_attr = {
614	'slavenodestartcmd': 'expstart',
615	'slaveconnectorstartcmd': 'gwstart',
616	'masternodestartcmd': 'mexpstart',
617	'masterconnectorstartcmd': 'mgwstart',
618	'connectorimage': 'gwimage',
619	'connectortype': 'gwtype',
620	'tunnelcfg': 'tun',
621	'smbshare': 'smbshare',
622	}
623
624	# XXX multi-level access
625	uri = self.tbmap.get(tb, None)
626	if not uri:
627	raise service_error(serice_error.server_config,
628	"Unknown testbed: %s" % tb)
629
630	# The basic request
631	req = {\
632	'destinationTestbed' : { 'uri' : uri },
633	'user': user,
634	'allocID' : { 'localname': 'test' },
635	'access' : [ { 'sshPubkey' : self.ssh_pubkey } ]
636	}
637
638	# node resources if any
639	if nodes != None and len(nodes) > 0:
640	rnodes = [ ]
641	for n in nodes:
642	rn = { }
643	image, hw, count = n.split(":")
644	if image: rn['image'] = [ image ]
645	if hw: rn['hardware'] = [ hw ]
646	if count: rn['count'] = int(count)
647	rnodes.append(rn)
648	req['resources']= { }
649	req['resources']['node'] = rnodes
650
651	# No retry loop here. Proxy servers must correctly authenticate
652	# themselves without help
653	try:
654	ctx = fedd_ssl_context(self.cert_file,
655	self.trusted_certs, password=self.cert_pwd)
656	except SSL.SSLError:
657	raise service_error(service_error.server_config,
658	"Server certificates misconfigured")
659
660	loc = feddServiceLocator();
661	port = loc.getfeddPortType(uri,
662	transport=M2Crypto.httpslib.HTTPSConnection,
663	transdict={ 'ssl_context' : ctx })
664
665	# Reconstruct the full request message
666	msg = RequestAccessRequestMessage()
667	msg.set_element_RequestAccessRequestBody(
668	pack_soap(msg, "RequestAccessRequestBody", req))
669	try:
670	resp = port.RequestAccess(msg)
671	except ZSI.ParseException, e:
672	raise service_error(service_error.req,
673	"Bad format message (XMLRPC??): %s" %
674	str(e))
675	r = unpack_soap(resp)
676
677	if r.has_key('RequestAccessResponseBody'):
678	r = r['RequestAccessResponseBody']
679	else:
680	raise service_error(service_error.proxy,
681	"Bad proxy response")
682
683
684	e = r['emulab']
685	p = e['project']
686	tbparam[tb] = {
687	"boss": e['boss'],
688	"host": e['ops'],
689	"domain": e['domain'],
690	"fs": e['fileServer'],
691	"eventserver": e['eventServer'],
692	"project": unpack_id(p['name']),
693	"emulab" : e
694	}
695
696	for u in p['user']:
697	tbparam[tb]['user'] = unpack_id(u['userID'])
698
699	for a in e['fedAttr']:
700	if a['attribute']:
701	key = translate_attr.get(a['attribute'].lower(), None)
702	if key:
703	tbparam[tb][key]= a['value']
704
705	class current_testbed:
706	def __init__(self, eid, tmpdir):
707	self.begin_testbed = re.compile("^#\s+Begin\s+Testbed\s+\((\w+)\)")
708	self.end_testbed = re.compile("^#\s+End\s+Testbed\s+\((\w+)\)")
709	self.current_testbed = None
710	self.testbed_file = None
711
712	self.def_expstart = \
713	"sudo -H /bin/sh FEDDIR/fed_bootstrap >& /tmp/federate";
714	self.def_mexpstart = "sudo -H FEDDIR/make_hosts FEDDIR/hosts";
715	self.def_gwstart = \
716	"sudo -H FEDDIR/fed-tun.pl -f GWCONF>& /tmp/bridge.log";
717	self.def_mgwstart = \
718	"sudo -H FEDDIR/fed-tun.pl -f GWCONF >& /tmp/bridge.log";
719	self.def_gwimage = "FBSD61-TUNNEL2";
720	self.def_gwtype = "pc";
721
722	self.eid = eid
723	self.tmpdir = tmpdir
724
725	def __call__(self, line, master, allocated, tbparams):
726	# Capture testbed topology descriptions
727	if self.current_testbed == None:
728	m = self.begin_testbed.match(line)
729	if m != None:
730	self.current_testbed = m.group(1)
731	if self.current_testbed == None:
732	raise service_error(service_error.req,
733	"Bad request format (unnamed testbed)")
734	allocated[self.current_testbed] = \
735	allocated.get(self.current_testbed,0) + 1
736	tb_dir = "%s/%s" % (self.tmpdir, self.current_testbed)
737	if not os.path.exists(tb_dir):
738	try:
739	os.mkdir(tb_dir)
740	except IOError:
741	raise service_error(service_error.internal,
742	"Cannot create %s" % tb_dir)
743	try:
744	self.testbed_file = open("%s/%s.%s.tcl" %
745	(tb_dir, self.eid, self.current_testbed), 'w')
746	except IOError:
747	self.testbed_file = None
748	return True
749	else: return False
750	else:
751	m = self.end_testbed.match(line)
752	if m != None:
753	if m.group(1) != self.current_testbed:
754	raise service_error(service_error.internal,
755	"Mismatched testbed markers!?")
756	if self.testbed_file != None:
757	self.testbed_file.close()
758	self.testbed_file = None
759	self.current_testbed = None
760	elif self.testbed_file:
761	# Substitute variables and put the line into the local
762	# testbed file.
763	gwtype = tbparams[self.current_testbed].get('gwtype',
764	self.def_gwtype)
765	gwimage = tbparams[self.current_testbed].get('gwimage',
766	self.def_gwimage)
767	mgwstart = tbparams[self.current_testbed].get('mgwstart',
768	self.def_mgwstart)
769	mexpstart = tbparams[self.current_testbed].get('mexpstart',
770	self.def_mexpstart)
771	gwstart = tbparams[self.current_testbed].get('gwstart',
772	self.def_gwstart)
773	expstart = tbparams[self.current_testbed].get('expstart',
774	self.def_expstart)
775	project = tbparams[self.current_testbed].get('project')
776	line = re.sub("GWTYPE", gwtype, line)
777	line = re.sub("GWIMAGE", gwimage, line)
778	if self.current_testbed == master:
779	line = re.sub("GWSTART", mgwstart, line)
780	line = re.sub("EXPSTART", mexpstart, line)
781	else:
782	line = re.sub("GWSTART", gwstart, line)
783	line = re.sub("EXPSTART", expstart, line)
784	# XXX: does `` embed without doing enything else?
785	line = re.sub("GWCONF", "FEDDIR`hostname`.gw.conf", line)
786	line = re.sub("PROJDIR", "/proj/%s/" % project, line)
787	line = re.sub("EID", self.eid, line)
788	line = re.sub("FEDDIR", "/proj/%s/exp/%s/tmp/" % \
789	(project, self.eid), line)
790	print >>self.testbed_file, line
791	return True
792
793	class allbeds:
794	def __init__(self, get_access):
795	self.begin_allbeds = re.compile("^#\s+Begin\s+Allbeds")
796	self.end_allbeds = re.compile("^#\s+End\s+Allbeds")
797	self.in_allbeds = False
798	self.get_access = get_access
799
800	def __call__(self, line, user, tbparams):
801	# Testbed access parameters
802	if not self.in_allbeds:
803	if self.begin_allbeds.match(line):
804	self.in_allbeds = True
805	return True
806	else:
807	return False
808	else:
809	if self.end_allbeds.match(line):
810	self.in_allbeds = False
811	else:
812	nodes = line.split('\|')
813	tb = nodes.pop(0)
814	self.get_access(tb, nodes, user, tbparams)
815	return True
816
817	class gateways:
818	def __init__(self, eid, master, tmpdir, gw_pubkey,
819	gw_secretkey, copy_file):
820	self.begin_gateways = \
821	re.compile("^#\s+Begin\s+gateways\s+\((\w+)\)")
822	self.end_gateways = re.compile("^#\s+End\s+gateways\s+\((\w+)\)")
823	self.current_gateways = None
824	self.control_gateway = None
825	self.active_end = { }
826
827	self.eid = eid
828	self.master = master
829	self.tmpdir = tmpdir
830	self.gw_pubkey_base = gw_pubkey
831	self.gw_secretkey_base = gw_secretkey
832
833	self.copy_file = copy_file
834
835
836	def gateway_conf_file(self, gw, master, eid, pubkey, privkey,
837	active_end, tbparams, dtb, myname, desthost, type):
838	"""
839	Produce a gateway configuration file from a gateways line.
840	"""
841
842	sproject = tbparams[gw].get('project', 'project')
843	dproject = tbparams[dtb].get('project', 'project')
844	sdomain = ".%s.%s%s" % (eid, sproject,
845	tbparams[gw].get('domain', ".example.com"))
846	ddomain = ".%s.%s%s" % (eid, dproject,
847	tbparams[dtb].get('domain', ".example.com"))
848	boss = tbparams[master].get('boss', "boss")
849	fs = tbparams[master].get('fs', "fs")
850	event_server = "%s%s" % \
851	(tbparams[gw].get('eventserver', "event_server"),
852	tbparams[gw].get('domain', "example.com"))
853	remote_event_server = "%s%s" % \
854	(tbparams[dtb].get('eventserver', "event_server"),
855	tbparams[dtb].get('domain', "example.com"))
856	seer_control = "%s%s" % \
857	(tbparams[gw].get('control', "control"), sdomain)
858	remote_script_dir = "/proj/%s/exp/%s/tmp" % ( dproject, eid)
859	local_script_dir = "/proj/%s/exp/%s/tmp" % ( sproject, eid)
860	tunnel_cfg = tbparams[gw].get("tun", "false")
861
862	conf_file = "%s%s.gw.conf" % (myname, sdomain)
863	remote_conf_file = "%s%s.gw.conf" % (desthost, ddomain)
864
865	# translate to lower case so the `hostname` hack for specifying
866	# configuration files works.
867	conf_file = conf_file.lower();
868	remote_conf_file = remote_conf_file.lower();
869
870	if dtb == master:
871	active = "false"
872	elif gw == master:
873	active = "true"
874	elif active_end.has_key['%s-%s' % (dtb, gw)]:
875	active = "false"
876	else:
877	active_end['%s-%s' % (gw, dtb)] = 1
878	active = "true"
879
880	gwconfig = open("%s/%s/%s" % (self.tmpdir, gw, conf_file), "w")
881	print >>gwconfig, "Active: %s" % active
882	print >>gwconfig, "TunnelCfg: %s" % tunnel_cfg
883	print >>gwconfig, "BossName: %s" % boss
884	print >>gwconfig, "FsName: %s" % fs
885	print >>gwconfig, "EventServerName: %s" % event_server
886	print >>gwconfig, "RemoteEventServerName: %s" % remote_event_server
887	print >>gwconfig, "SeerControl: %s" % seer_control
888	print >>gwconfig, "Type: %s" % type
889	print >>gwconfig, "RemoteScriptDir: %s" % remote_script_dir
890	print >>gwconfig, "EventRepeater: %s/fed_evrepeater" % \
891	local_script_dir
892	print >>gwconfig, "RemoteExperiment: %s/%s" % (dproject, eid)
893	print >>gwconfig, "LocalExperiment: %s/%s" % (sproject, eid)
894	print >>gwconfig, "RemoteConfigFile: %s/%s" % \
895	(remote_script_dir, remote_conf_file)
896	print >>gwconfig, "Peer: %s%s" % (desthost, ddomain)
897	print >>gwconfig, "Pubkeys: %s/%s" % (local_script_dir, pubkey)
898	print >>gwconfig, "Privkeys: %s/%s" % (local_script_dir, privkey)
899	gwconfig.close()
900
901	return active == "true"
902
903	def __call__(self, line, allocated, tbparams):
904	# Process gateways
905	if not self.current_gateways:
906	m = self.begin_gateways.match(line)
907	if m:
908	self.current_gateways = m.group(1)
909	if allocated.has_key(self.current_gateways):
910	# This test should always succeed
911	tb_dir = "%s/%s" % (self.tmpdir, self.current_gateways)
912	if not os.path.exists(tb_dir):
913	try:
914	os.mkdir(tb_dir)
915	except IOError:
916	raise service_error(service_error.internal,
917	"Cannot create %s" % tb_dir)
918	else:
919	# XXX
920	print >>sys.stderr, \
921	"Ignoring gateways for unknown testbed %s" \
922	% self.current_gateways
923	self.current_gateways = None
924	return True
925	else:
926	return False
927	else:
928	m = self.end_gateways.match(line)
929	if m :
930	if m.group(1) != self.current_gateways:
931	raise service_error(service_error.internal,
932	"Mismatched gateway markers!?")
933	if self.control_gateway:
934	try:
935	cc = open("%s/%s/client.conf" %
936	(self.tmpdir, self.current_gateways), 'w')
937	print >>cc, "ControlGateway: %s" % \
938	self.control_gateway
939	if tbparams[self.master].has_key('smbshare'):
940	print >>cc, "SMBSHare: %s" % \
941	tbparams[self.master]['smbshare']
942	print >>cc, "ProjectUser: %s" % \
943	tbparams[self.master]['user']
944	print >>cc, "ProjectName: %s" % \
945	tbparams[self.master]['project']
946	cc.close()
947	except IOError:
948	raise service_error(service_error.internal,
949	"Error creating client config")
950	try:
951	cc = open("%s/%s/seer.conf" %
952	(self.tmpdir, self.current_gateways),
953	'w')
954	if self.current_gateways != self.master:
955	print >>cc, "ControlNode: %s" % \
956	self.control_gateway
957	print >>cc, "ExperimentID: %s/%s" % \
958	( tbparams[self.master]['project'], \
959	self.eid )
960	cc.close()
961	except IOError:
962	raise service_error(service_error.internal,
963	"Error creating seer config")
964	else:
965	if self.trace_file:
966	print >>sys.stderr, "No control gateway for %s" %\
967	self.current_gateways
968	self.current_gateways = None
969	else:
970	dtb, myname, desthost, type = line.split(" ")
971
972	if type == "control" or type == "both":
973	self.control_gateway = "%s.%s.%s%s" % (myname,
974	self.eid,
975	tbparams[self.current_gateways]['project'],
976	tbparams[self.current_gateways]['domain'])
977	try:
978	active = self.gateway_conf_file(self.current_gateways,
979	self.master, self.eid, self.gw_pubkey_base,
980	self.gw_secretkey_base,
981	self.active_end, tbparams, dtb, myname,
982	desthost, type)
983	except IOError, e:
984	raise service_error(service_error.internal,
985	"Failed to write config file for %s" % \
986	self.current_gateway)
987
988	gw_pubkey = "%s/keys/%s" % \
989	(self.tmpdir, self.gw_pubkey_base)
990	gw_secretkey = "%s/keys/%s" % \
991	(self.tmpdir, self.gw_secretkey_base)
992
993	pkfile = "%s/%s/%s" % \
994	( self.tmpdir, self.current_gateways,
995	self.gw_pubkey_base)
996	skfile = "%s/%s/%s" % \
997	( self.tmpdir, self.current_gateways,
998	self.gw_secretkey_base)
999
1000	if not os.path.exists(pkfile):
1001	try:
1002	self.copy_file(gw_pubkey, pkfile)
1003	except IOError:
1004	service_error(service_error.internal,
1005	"Failed to copy pubkey file")
1006
1007	if active and not os.path.exists(skfile):
1008	try:
1009	self.copy_file(gw_secretkey, skfile)
1010	except IOError:
1011	service_error(service_error.internal,
1012	"Failed to copy secretkey file")
1013	return True
1014
1015	class shunt_to_file:
1016	def __init__(self, begin, end, filename):
1017	self.begin = re.compile(begin)
1018	self.end = re.compile(end)
1019	self.in_shunt = False
1020	self.file = None
1021	self.filename = filename
1022
1023	def __call__(self, line):
1024	if not self.in_shunt:
1025	if self.begin.match(line):
1026	self.in_shunt = True
1027	try:
1028	self.file = open(self.filename, "w")
1029	except:
1030	self.file = None
1031	raise
1032	return True
1033	else:
1034	return False
1035	else:
1036	if self.end.match(line):
1037	if self.file:
1038	self.file.close()
1039	self.file = None
1040	self.in_shunt = False
1041	else:
1042	if self.file:
1043	print >>self.file, line
1044	return True
1045
1046	class shunt_to_list:
1047	def __init__(self, begin, end):
1048	self.begin = re.compile(begin)
1049	self.end = re.compile(end)
1050	self.in_shunt = False
1051	self.list = [ ]
1052
1053	def __call__(self, line):
1054	if not self.in_shunt:
1055	if self.begin.match(line):
1056	self.in_shunt = True
1057	return True
1058	else:
1059	return False
1060	else:
1061	if self.end.match(line):
1062	self.in_shunt = False
1063	else:
1064	self.list.append(line)
1065	return True
1066
1067	class shunt_to_string:
1068	def __init__(self, begin, end):
1069	self.begin = re.compile(begin)
1070	self.end = re.compile(end)
1071	self.in_shunt = False
1072	self.str = ""
1073
1074	def __call__(self, line):
1075	if not self.in_shunt:
1076	if self.begin.match(line):
1077	self.in_shunt = True
1078	return True
1079	else:
1080	return False
1081	else:
1082	if self.end.match(line):
1083	self.in_shunt = False
1084	else:
1085	self.str += line
1086	return True
1087
1088	def create_experiment(self, req, fid):
1089	try:
1090	tmpdir = tempfile.mkdtemp(prefix="split-")
1091	except IOError:
1092	raise service_error(service_error.internal, "Cannot create tmp dir")
1093
1094	gw_pubkey_base = "fed.%s.pub" % self.ssh_type
1095	gw_secretkey_base = "fed.%s" % self.ssh_type
1096	gw_pubkey = tmpdir + "/keys/" + gw_pubkey_base
1097	gw_secretkey = tmpdir + "/keys/" + gw_secretkey_base
1098	tclfile = tmpdir + "/experiment.tcl"
1099	tbparams = { }
1100
1101	pid = "dummy"
1102	gid = "dummy"
1103	# XXX
1104	fail_soft = False
1105
1106	try:
1107	os.mkdir(tmpdir+"/keys")
1108	except OSError:
1109	raise service_error(service_error.internal,
1110	"Can't make temporary dir")
1111
1112	req = req.get('CreateRequestBody', None)
1113	if not req:
1114	raise service_error(service_error.req,
1115	"Bad request format (no CreateRequestBody)")
1116	# The tcl parser needs to read a file so put the content into that file
1117	file_content=req.get('experimentdescription', None)
1118	if file_content:
1119	try:
1120	f = open(tclfile, 'w')
1121	f.write(file_content)
1122	f.close()
1123	except IOError:
1124	raise service_error(service_error.internal,
1125	"Cannot write temp experiment description")
1126	else:
1127	raise service_error(service_error.req, "No experiment description")
1128
1129	if req.has_key('experimentID') and \
1130	req['experimentID'].has_key('localname'):
1131	eid = req['experimentID']['localname']
1132	while (self.state.has_key(eid)):
1133	eid += random.choice(string.ascii_letters)
1134	else:
1135	eid = self.exp_stem
1136	for i in range(0,5):
1137	eid += random.choice(string.ascii_letters)
1138	while (self.state.has_key(eid)):
1139	eid = self.exp_stem
1140	for i in range(0,5):
1141	eid += random.choice(string.ascii_letters)
1142
1143	try:
1144	self.generate_ssh_keys(gw_secretkey, self.ssh_type)
1145	except ValueError:
1146	raise service_error(service_error.server_config,
1147	"Bad key type (%s)" % self.ssh_type)
1148
1149	user = req.get('user', None)
1150	if user == None:
1151	raise service_error(service_error.req, "No user")
1152
1153	master = req.get('master', None)
1154	if master == None:
1155	raise service_error(service_error.req, "No master testbed label")
1156
1157
1158	tclcmd = [self.tclsh, self.tcl_splitter, '-s', '-x',
1159	str(self.muxmax), '-m', master, pid, gid, eid, tclfile]
1160	tclparser = Popen(tclcmd, stdout=PIPE)
1161
1162	allocated = { }
1163	started = { }
1164
1165	parse_current_testbed = self.current_testbed(eid, tmpdir)
1166	parse_allbeds = self.allbeds(self.get_access)
1167	parse_gateways = self.gateways(eid, master, tmpdir,
1168	gw_pubkey_base, gw_secretkey_base, self.copy_file)
1169	parse_vtopo = self.shunt_to_string("^#\s+Begin\s+Vtopo",
1170	"^#\s+End\s+Vtopo")
1171	parse_hostnames = self.shunt_to_file("^#\s+Begin\s+hostnames",
1172	"^#\s+End\s+hostnames", tmpdir + "/hosts")
1173	parse_tarfiles = self.shunt_to_list("^#\s+Begin\s+tarfiles",
1174	"^#\s+End\s+tarfiles")
1175	parse_rpms = self.shunt_to_list("^#\s+Begin\s+rpms",
1176	"^#\s+End\s+rpms")
1177
1178	for line in tclparser.stdout:
1179	line = line.rstrip()
1180	if parse_current_testbed(line, master, allocated, tbparams):
1181	continue
1182	elif parse_allbeds(line, user, tbparams):
1183	continue
1184	elif parse_gateways(line, allocated, tbparams):
1185	continue
1186	elif parse_vtopo(line):
1187	continue
1188	elif parse_hostnames(line):
1189	continue
1190	elif parse_tarfiles(line):
1191	continue
1192	elif parse_rpms(line):
1193	continue
1194	else:
1195	raise service_error(service_error.internal,
1196	"Bad tcl parse? %s" % line)
1197
1198	vtopo = self.gentopo(parse_vtopo.str)
1199	if not vtopo:
1200	raise service_error(service_error.internal,
1201	"Failed to generate virtual topology")
1202
1203	vis = self.genviz(vtopo)
1204	if not vis:
1205	raise service_error(service_error.internal,
1206	"Failed to generate visualization")
1207
1208	# save federant information
1209	for k in allocated.keys():
1210	tbparams[k]['federant'] = {\
1211	'name': [ { 'localname' : eid} ],\
1212	'emulab': tbparams[k]['emulab'],\
1213	'master' : k == master,\
1214	}
1215
1216
1217	# Copy tarfiles and rpms needed at remote sites into a staging area
1218	try:
1219	for t in parse_tarfiles.list:
1220	if not os.path.exists("%s/tarfiles" % tmpdir):
1221	os.mkdir("%s/tarfiles" % tmpdir)
1222	self.copy_file(t, "%s/tarfiles/%s" % \
1223	(tmpdir, os.path.basename(t)))
1224	for r in parse_rpms.list:
1225	if not os.path.exists("%s/rpms" % tmpdir):
1226	os.mkdir("%s/rpms" % tmpdir)
1227	self.copy_file(r, "%s/rpms/%s" % \
1228	(tmpdir, os.path.basename(r)))
1229	except IOError, e:
1230	raise service_error(service_error.internal,
1231	"Cannot stage tarfile/rpm: %s" % e.strerror)
1232
1233	thread_pool_info = self.thread_pool()
1234	threads = [ ]
1235
1236	for tb in [ k for k in allocated.keys() if k != master]:
1237	# Wait until we have a free slot to start the next testbed load
1238	thread_pool_info.acquire()
1239	while thread_pool_info.started - \
1240	thread_pool_info.terminated >= self.nthreads:
1241	thread_pool_info.wait()
1242	thread_pool_info.release()
1243
1244	# Create and start a thread to start the segment, and save it to
1245	# get the return value later
1246	t = self.pooled_thread(target=self.start_segment,
1247	args=(tb, eid, tbparams, tmpdir, 0), name=tb,
1248	pdata=thread_pool_info, trace_file=self.trace_file)
1249	threads.append(t)
1250	t.start()
1251
1252	# Wait until all finish (the first clause of the while is to make sure
1253	# one starts)
1254	thread_pool_info.acquire()
1255	while thread_pool_info.started == 0 or \
1256	thread_pool_info.started > thread_pool_info.terminated:
1257	thread_pool_info.wait()
1258	thread_pool_info.release()
1259
1260	# If none failed, start the master
1261	failed = [ t.getName() for t in threads if not t.rv ]
1262
1263	if len(failed) == 0:
1264	if not self.start_segment(master, eid, tbparams, tmpdir):
1265	failed.append(master)
1266
1267	# If one failed clean up
1268	if len(failed) > 0:
1269	succeeded = [tb for tb in allocated.keys() if tb not in failed]
1270	if fail_soft:
1271	raise service_error(service_error.partial, \
1272	"Partial swap in on %s" % ",".join(succeeded))
1273	else:
1274	for tb in succeeded:
1275	self.stop_segment(tb, eid, tbparams)
1276	raise service_error(service_error.federant,
1277	"Swap in failed on %s" % ",".join(failed))
1278	else:
1279	if self.trace_file:
1280	print >>self.trace_file, "Experiment started"
1281
1282	# Generate an ID for the experiment (slice) and a certificate that the
1283	# allocator can use to prove they own it. We'll ship it back through
1284	# the encrypted connection.
1285	(expid, expcert) = generate_fedid("test", dir=tmpdir,
1286	trace=self.trace_file)
1287
1288	if self.trace_file:
1289	print >>self.trace_file, "removing %s" % tmpdir
1290
1291	# Walk up tmpdir, deleting as we go
1292	for path, dirs, files in os.walk(tmpdir, topdown=False):
1293	for f in files:
1294	os.remove(os.path.join(path, f))
1295	for d in dirs:
1296	os.rmdir(os.path.join(path, d))
1297	os.rmdir(tmpdir)
1298
1299	resp = { 'federant' : [ tbparams[tb]['federant'] \
1300	for tb in tbparams.keys() \
1301	if tbparams[tb].has_key('federant') ],\
1302	'vtopo': vtopo,\
1303	'vis' : vis,
1304	'experimentID' : [\
1305	{ 'fedid': copy.copy(expid) }, \
1306	{ 'localname': eid },\
1307	],\
1308	'experimentAccess': { 'X509' : expcert },\
1309	}
1310
1311	self.state[expid] = { 'federant' : [ tbparams[tb]['federant'] \
1312	for tb in tbparams.keys() \
1313	if tbparams[tb].has_key('federant') ],\
1314	'vtopo': vtopo,\
1315	'vis' : vis,
1316	'experimentID' : [\
1317	{ 'fedid': expid }, { 'localname': eid },\
1318	],\
1319	}
1320	self.state[eid] = self.state[expid]
1321	return resp
1322
1323	def get_vtopo(self, req, fid):
1324
1325	req = req.get('VtopoRequestBody', None)
1326	if not req:
1327	raise service_error(service_error.req,
1328	"Bad request format (no VtopoRequestBody)")
1329	exp = req.get('experiment', None)
1330	if exp:
1331	if exp.has_key('fedid'):
1332	key = fedid(bits=exp['fedid'])
1333	keytype = "fedid"
1334	elif exp.has_key('localname'):
1335	key = exp['localname']
1336	keytype = "localname"
1337	else:
1338	raise service_error(service_error.req, "Unknown lookup type")
1339	else:
1340	raise service_error(service_error.req, "No request?")
1341
1342	if self.state.has_key(key):
1343	return { 'experiment' : {keytype: key },\
1344	'vtopo': self.state[key]['vtopo'],\
1345	}
1346	else:
1347	raise service_error(service_error.req, "No such experiment")
1348
1349	def get_vis(self, req, fid):
1350
1351	req = req.get('VisRequestBody', None)
1352	if not req:
1353	raise service_error(service_error.req,
1354	"Bad request format (no VisRequestBody)")
1355	exp = req.get('experiment', None)
1356	if exp:
1357	if exp.has_key('fedid'):
1358	key = fedid(bits=exp['fedid'])
1359	keytype = "fedid"
1360	elif exp.has_key('localname'):
1361	key = exp['localname']
1362	keytype = "localname"
1363	else:
1364	raise service_error(service_error.req, "Unknown lookup type")
1365	else:
1366	raise service_error(service_error.req, "No request?")
1367
1368	if self.state.has_key(key):
1369	return { 'experiment' : {keytype: key },\
1370	'vis': self.state[key]['vis'],\
1371	}
1372	else:
1373	raise service_error(service_error.req, "No such experiment")
1374
1375	def get_info(self, req, fid):
1376
1377	req = req.get('InfoRequestBody', None)
1378	if not req:
1379	raise service_error(service_error.req,
1380	"Bad request format (no VisRequestBody)")
1381	exp = req.get('experiment', None)
1382	if exp:
1383	if exp.has_key('fedid'):
1384	key = fedid(bits=exp['fedid'])
1385	keytype = "fedid"
1386	elif exp.has_key('localname'):
1387	key = exp['localname']
1388	keytype = "localname"
1389	else:
1390	raise service_error(service_error.req, "Unknown lookup type")
1391	else:
1392	raise service_error(service_error.req, "No request?")
1393
1394	# The state may be massaged by the service function that called
1395	# get_info (e.g., encoded for XMLRPC transport) so send a copy of the
1396	# state.
1397	if self.state.has_key(key):
1398	return copy.deepcopy(self.state[key])
1399	else:
1400	raise service_error(service_error.req, "No such experiment")
1401
1402	if __name__ == '__main__':
1403	from optparse import OptionParser
1404
1405	parser = OptionParser()
1406	parser.add_option('-d', '--debug', dest='debug', default=False,
1407	action='store_true', help='print actions rather than take them')
1408	parser.add_option('-f', '--file', dest='tcl', help='tcl file to parse')
1409	parser.add_option('-m', '--master', dest='master',
1410	help='testbed label for matster testbd')
1411	parser.add_option('-t', '--trace', dest='trace', default=None,
1412	help='file to print intermediate messages to')
1413	parser.add_option('-T', '--trace-stderr', dest='trace',
1414	action='store_const',const=sys.stderr,
1415	help='file to print intermediate messages to')
1416	opts, args = parser.parse_args()
1417
1418	trace_file = None
1419	if opts.trace:
1420	try:
1421	trace_file = open(opts.trace, 'w')
1422	except IOError:
1423	print >>sys.stderr, "Can't open trace file"
1424
1425	if opts.debug:
1426	if not trace_file:
1427	trace_file = sys.stderr
1428
1429	if opts.tcl != None:
1430	try:
1431	f = open(opts.tcl, 'r')
1432	content = ''.join(f)
1433	f.close()
1434	except IOError, e:
1435	sys.exit("Can't read %s: %s" % (opts.tcl, e))
1436	else:
1437	sys.exit("Must specify a file name")
1438
1439	if not opts.master:
1440	sys.exit("Must supply master tb label (--master)");
1441
1442	obj = fedd_create_experiment_local(
1443	debug=opts.debug,
1444	scripts_dir="/users/faber/testbed/federation",
1445	cert_file="./fedd_client.pem", cert_pwd="faber",
1446	ssh_pubkey_file='/users/faber/.ssh/id_rsa.pub',
1447	trusted_certs="./cacert.pem",
1448	tbmap = {
1449	'deter':'https://users.isi.deterlab.net:23235',
1450	'emulab':'https://users.isi.deterlab.net:23236',
1451	'ucb':'https://users.isi.deterlab.net:23237',
1452	},
1453	trace_file=trace_file
1454	)
1455	rv = obj.create_experiment( {\
1456	'experimentdescription' : content,
1457	'master' : opts.master,
1458	'user': [ {'userID' : { 'localname' : 'faber' } } ],
1459	},
1460	None)
1461
1462	print rv

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

Download in other formats: