Context Navigation

source: fedd/fedd_create_experiment.py @ 7a8d667

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

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

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

Download in other formats: