source: fedd/fedd_create_experiment.py @ c52c48d

axis_examplecompt_changesinfo-opsversion-1.30version-2.00version-3.01version-3.02
Last change on this file since c52c48d was c52c48d, checked in by Ted Faber <faber@…>, 16 years ago

add info and work with SEER attach

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