Index: fedd/federation/experiment_control.py
===================================================================
--- fedd/federation/experiment_control.py	(revision fd556d1ae147804253b4b3c1c6e89d10300f650a)
+++ fedd/federation/experiment_control.py	(revision e19b75cab53978fffc86f1602d79dc317760b474)
@@ -345,5 +345,5 @@
         # Dispatch tables
         self.soap_services = {\
-                'Create': soap_handler('Create', self.new_create_experiment),
+                'Create': soap_handler('Create', self.create_experiment),
                 'Vtopo': soap_handler('Vtopo', self.get_vtopo),
                 'Vis': soap_handler('Vis', self.get_vis),
@@ -351,9 +351,9 @@
                 'MultiInfo': soap_handler('MultiInfo', self.get_multi_info),
                 'Terminate': soap_handler('Terminate', 
-                    self.new_terminate_experiment),
+                    self.terminate_experiment),
         }
 
         self.xmlrpc_services = {\
-                'Create': xmlrpc_handler('Create', self.new_create_experiment),
+                'Create': xmlrpc_handler('Create', self.create_experiment),
                 'Vtopo': xmlrpc_handler('Vtopo', self.get_vtopo),
                 'Vis': xmlrpc_handler('Vis', self.get_vis),
@@ -361,5 +361,5 @@
                 'MultiInfo': xmlrpc_handler('MultiInfo', self.get_multi_info),
                 'Terminate': xmlrpc_handler('Terminate',
-                    self.new_terminate_experiment),
+                    self.terminate_experiment),
         }
 
@@ -551,350 +551,4 @@
                     "open %s: %s" % (file, e))
         f.close()
-
-    class emulab_segment:
-        def __init__(self, log=None, keyfile=None, debug=False):
-            self.log = log or logging.getLogger(\
-                    'fedd.experiment_control.emulab_segment')
-            self.ssh_privkey_file = keyfile
-            self.debug = debug
-            self.ssh_exec="/usr/bin/ssh"
-            self.scp_exec = "/usr/bin/scp"
-            self.ssh_cmd_timeout = experiment_control_local.ssh_cmd_timeout
-
-        def scp_file(self, file, user, host, dest=""):
-            """
-            scp a file to the remote host.  If debug is set the action is only
-            logged.
-            """
-
-            scp_cmd = [self.scp_exec, '-o', 'IdentitiesOnly yes', 
-                    '-o', 'StrictHostKeyChecking yes', '-i', 
-                    self.ssh_privkey_file, file, 
-                    "%s@%s:%s" % (user, host, dest)]
-            rv = 0
-
-            try:
-                dnull = open("/dev/null", "w")
-            except IOError:
-                self.log.debug("[ssh_file]: failed to open " + \
-                        "/dev/null for redirect")
-                dnull = Null
-
-            self.log.debug("[scp_file]: %s" % " ".join(scp_cmd))
-            if not self.debug:
-                rv = call(scp_cmd, stdout=dnull, stderr=dnull, close_fds=True,
-                        close_fds=True)
-
-            return rv == 0
-
-        def ssh_cmd(self, user, host, cmd, wname=None, timeout=None):
-            """
-            Run a remote command on host as user.  If debug is set, the action
-            is only logged.  Commands are run without stdin, to avoid stray
-            SIGTTINs.
-            """
-            sh_str = ("%s -n -o 'IdentitiesOnly yes' -o " + \
-                    "'StrictHostKeyChecking yes' -i %s %s@%s %s") % \
-                    (self.ssh_exec, self.ssh_privkey_file, 
-                            user, host, cmd)
-
-            try:
-                dnull = open("/dev/null", "w")
-            except IOError:
-                self.log.debug("[ssh_cmd]: failed to open /dev/null " + \
-                        "for redirect")
-                dnull = Null
-
-            self.log.debug("[ssh_cmd]: %s" % sh_str)
-            if not self.debug:
-                if dnull:
-                    sub = Popen(sh_str, shell=True, stdout=dnull, stderr=dnull,
-                            close_fds=True)
-                else:
-                    sub = Popen(sh_str, shell=True,
-                            close_fds=True)
-                if timeout:
-                    i = 0
-                    rv = sub.poll()
-                    while i < timeout:
-                        if rv is not None: break
-                        else:
-                            time.sleep(1)
-                            rv = sub.poll()
-                            i += 1
-                    else:
-                        self.log.debug("Process exceeded runtime: %s" % sh_str)
-                        os.kill(sub.pid, signal.SIGKILL)
-                        raise self.ssh_cmd_timeout();
-                    return rv == 0
-                else:
-                    return sub.wait() == 0
-            else:
-                if timeout == 0:
-                    self.log.debug("debug timeout raised on %s " % sh_str)
-                    raise self.ssh_cmd_timeout()
-                else:
-                    return True
-
-    class start_segment(emulab_segment):
-        def __init__(self, log=None, keyfile=None, debug=False):
-            experiment_control_local.emulab_segment.__init__(self,
-                    log=log, keyfile=keyfile, debug=debug)
-
-        def create_config_tree(self, src_dir, dest_dir, script):
-            """
-            Append commands to script that will create the directory hierarchy
-            on the remote federant.
-            """
-
-            if os.path.isdir(src_dir):
-                print >>script, "mkdir -p %s" % dest_dir
-                print >>script, "chmod 770 %s" % dest_dir
-
-                for f in os.listdir(src_dir):
-                    if os.path.isdir(f):
-                        self.create_config_tree("%s/%s" % (src_dir, f), 
-                                "%s/%s" % (dest_dir, f), script)
-            else:
-                self.log.debug("[create_config_tree]: Not a directory: %s" \
-                        % src_dir)
-
-        def ship_configs(self, host, user, src_dir, dest_dir):
-            """
-            Copy federant-specific configuration files to the federant.
-            """
-            for f in os.listdir(src_dir):
-                if os.path.isdir(f):
-                    if not self.ship_configs(host, user, "%s/%s" % (src_dir, f), 
-                            "%s/%s" % (dest_dir, f)):
-                        return False
-                else:
-                    if not self.scp_file("%s/%s" % (src_dir, f), 
-                            user, host, dest_dir):
-                        return False
-            return True
-
-        def get_state(self, user, host, tb, pid, eid):
-            # command to test experiment state
-            expinfo_exec = "/usr/testbed/bin/expinfo"  
-            # Regular expressions to parse the expinfo response
-            state_re = re.compile("State:\s+(\w+)")
-            no_exp_re = re.compile("^No\s+such\s+experiment")
-            swapping_re = re.compile("^No\s+information\s+available.")
-            state = None    # Experiment state parsed from expinfo
-            # The expinfo ssh command.  Note the identity restriction to use
-            # only the identity provided in the pubkey given.
-            cmd = [self.ssh_exec, '-o', 'IdentitiesOnly yes', '-o', 
-                    'StrictHostKeyChecking yes', '-i', 
-                    self.ssh_privkey_file, "%s@%s" % (user, host), 
-                    expinfo_exec, pid, eid]
-
-            dev_null = None
-            try:
-                dev_null = open("/dev/null", "a")
-            except IOError, e:
-                self.log.error("[get_state]: can't open /dev/null: %s" %e)
-
-            if self.debug:
-                state = 'swapped'
-                rv = 0
-            else:
-                status = Popen(cmd, stdout=PIPE, stderr=dev_null,
-                        close_fds=True)
-                for line in status.stdout:
-                    m = state_re.match(line)
-                    if m: state = m.group(1)
-                    else:
-                        for reg, st in ((no_exp_re, "none"),
-                                (swapping_re, "swapping")):
-                            m = reg.match(line)
-                            if m: state = st
-                rv = status.wait()
-
-            # If the experiment is not present the subcommand returns a
-            # non-zero return value.  If we successfully parsed a "none"
-            # outcome, ignore the return code.
-            if rv != 0 and state != 'none':
-                raise service_error(service_error.internal,
-                        "Cannot get status of segment %s:%s/%s" % \
-                                (tb, pid, eid))
-            elif state not in ('active', 'swapped', 'swapping', 'none'):
-                raise service_error(service_error.internal,
-                        "Cannot get status of segment %s:%s/%s" % \
-                                (tb, pid, eid))
-            else: return state
-
-
-        def __call__(self, tb, eid, tbparams, tmpdir, timeout=0):
-            """
-            Start a sub-experiment on a federant.
-
-            Get the current state, modify or create as appropriate, ship data
-            and configs and start the experiment.  There are small ordering
-            differences based on the initial state of the sub-experiment.
-            """
-            # ops node in the federant
-            host = "%s%s" % (tbparams[tb]['host'], tbparams[tb]['domain'])
-            user = tbparams[tb]['user']     # federant user
-            pid = tbparams[tb]['project']   # federant project
-            # XXX
-            base_confs = ( "hosts",)
-            tclfile = "%s.%s.tcl" % (eid, tb)   # sub-experiment description
-            # Configuration directories on the remote machine
-            proj_dir = "/proj/%s/exp/%s/tmp" % (pid, eid)
-            tarfiles_dir = "/proj/%s/tarfiles/%s" % (pid, eid)
-            rpms_dir = "/proj/%s/rpms/%s" % (pid, eid)
-
-            state = self.get_state(user, host, tb, pid, eid)
-
-            self.log.debug("[start_segment]: %s: %s" % (tb, state))
-            self.log.info("[start_segment]:transferring experiment to %s" % tb)
-
-            if not self.scp_file("%s/%s/%s" % \
-                    (tmpdir, tb, tclfile), user, host):
-                return False
-            
-            if state == 'none':
-                # Create a null copy of the experiment so that we capture any
-                # logs there if the modify fails.  Emulab software discards the
-                # logs from a failed startexp
-                if not self.scp_file("%s/null.tcl" % tmpdir, user, host):
-                    return False
-                self.log.info("[start_segment]: Creating %s on %s" % (eid, tb))
-                timedout = False
-                try:
-                    if not self.ssh_cmd(user, host,
-                            ("/usr/testbed/bin/startexp -i -f -w -p %s " + 
-                            "-e %s null.tcl") % (pid, eid), "startexp",
-                            timeout=60 * 10):
-                        return False
-                except self.ssh_cmd_timeout:
-                    timedout = True
-
-                if timedout:
-                    state = self.get_state(user, host, tb, pid, eid)
-                    if state != "swapped":
-                        return False
-
-            
-            # Open up a temporary file to contain a script for setting up the
-            # filespace for the new experiment.
-            self.log.info("[start_segment]: creating script file")
-            try:
-                sf, scriptname = tempfile.mkstemp()
-                scriptfile = os.fdopen(sf, 'w')
-            except IOError:
-                return False
-
-            scriptbase = os.path.basename(scriptname)
-
-            # Script the filesystem changes
-            print >>scriptfile, "/bin/rm -rf %s" % proj_dir
-            # Clear and create the tarfiles and rpm directories
-            for d in (tarfiles_dir, rpms_dir):
-                print >>scriptfile, "/bin/rm -rf %s/*" % d
-                print >>scriptfile, "mkdir -p %s" % d
-            print >>scriptfile, 'mkdir -p %s' % proj_dir
-            self.create_config_tree("%s/%s" % (tmpdir, tb),
-                    proj_dir, scriptfile)
-            if os.path.isdir("%s/tarfiles" % tmpdir):
-                self.create_config_tree("%s/tarfiles" % tmpdir, tarfiles_dir,
-                        scriptfile)
-            if os.path.isdir("%s/rpms" % tmpdir):
-                self.create_config_tree("%s/rpms" % tmpdir, rpms_dir, 
-                        scriptfile)
-            print >>scriptfile, "rm -f %s" % scriptbase
-            scriptfile.close()
-
-            # Move the script to the remote machine
-            # XXX: could collide tempfile names on the remote host
-            if self.scp_file(scriptname, user, host, scriptbase):
-                os.remove(scriptname)
-            else:
-                return False
-
-            # Execute the script (and the script's last line deletes it)
-            if not self.ssh_cmd(user, host, "sh -x %s" % scriptbase):
-                return False
-
-            for f in base_confs:
-                if not self.scp_file("%s/%s" % (tmpdir, f), user, host,
-                        "%s/%s" % (proj_dir, f)):
-                    return False
-            if not self.ship_configs(host, user, "%s/%s" % (tmpdir, tb),
-                    proj_dir):
-                return False
-            if os.path.isdir("%s/tarfiles" % tmpdir):
-                if not self.ship_configs(host, user,
-                        "%s/tarfiles" % tmpdir, tarfiles_dir):
-                    return False
-            if os.path.isdir("%s/rpms" % tmpdir):
-                if not self.ship_configs(host, user,
-                        "%s/rpms" % tmpdir, tarfiles_dir):
-                    return False
-            # Stage the new configuration (active experiments will stay swapped
-            # in now)
-            self.log.info("[start_segment]: Modifying %s on %s" % (eid, tb))
-            try:
-                if not self.ssh_cmd(user, host,
-                        "/usr/testbed/bin/modexp -r -s -w %s %s %s" % \
-                                (pid, eid, tclfile),
-                        "modexp", timeout= 60 * 10):
-                    return False
-            except self.ssh_cmd_timeout:
-                self.log.error("Modify command failed to complete in time")
-                # There's really no way to see if this succeeded or failed, so
-                # if it hangs, assume the worst.
-                return False
-            # Active experiments are still swapped, this swaps the others in.
-            if state != 'active':
-                self.log.info("[start_segment]: Swapping %s in on %s" % \
-                        (eid, tb))
-                timedout = False
-                try:
-                    if not self.ssh_cmd(user, host,
-                            "/usr/testbed/bin/swapexp -w %s %s in" % (pid, eid),
-                            "swapexp", timeout=10*60):
-                        return False
-                except self.ssh_cmd_timeout:
-                    timedout = True
-               
-                # If the command was terminated, but completed successfully,
-                # report success.
-                if timedout:
-                    self.log.debug("[start_segment]: swapin timed out " +\
-                            "checking state")
-                    state = self.get_state(user, host, tb, pid, eid)
-                    self.log.debug("[start_segment]: state is %s" % state)
-                    return state == 'active'
-            # Everything has gone OK.
-            return True
-
-    class stop_segment(emulab_segment):
-        def __init__(self, log=None, keyfile=None, debug=False):
-            experiment_control_local.emulab_segment.__init__(self,
-                    log=log, keyfile=keyfile, debug=debug)
-
-        def __call__(self, tb, eid, tbparams):
-            """
-            Stop a sub experiment by calling swapexp on the federant
-            """
-            user = tbparams[tb]['user']
-            host = "%s%s" % (tbparams[tb]['host'], tbparams[tb]['domain'])
-            pid = tbparams[tb]['project']
-
-            self.log.info("[stop_segment]: Stopping %s on %s" % (eid, tb))
-            rv = False
-            try:
-                # Clean out tar files: we've gone over quota in the past
-                self.ssh_cmd(user, host, "rm -rf /proj/%s/rpms/%s" % (pid, eid))
-                self.ssh_cmd(user, host, "rm -rf /proj/%s/tarfiles/%s" % \
-                        (pid, eid))
-                rv = self.ssh_cmd(user, host,
-                        "/usr/testbed/bin/swapexp -w %s %s out" % (pid, eid))
-            except self.ssh_cmd_timeout:
-                rv = False
-            return rv
-
         
     def generate_ssh_keys(self, dest, type="rsa" ):
@@ -1267,880 +921,6 @@
         else:
             raise service_error(service_error.protocol, "Bad splitter response")
-        
-    class current_testbed:
-        """
-        Object for collecting the current testbed description.  The testbed
-        description is saved to a file with the local testbed variables
-        subsittuted line by line.
-        """
-        def __init__(self, eid, tmpdir, fedkit, gatewaykit):
-            def tar_list_to_string(tl):
-                if tl is None: return None
-
-                rv = ""
-                for t in tl:
-                    rv += " %s PROJDIR/tarfiles/EID/%s" % \
-                            (t[0], os.path.basename(t[1]))
-                return rv
-
-
-            self.begin_testbed = re.compile("^#\s+Begin\s+Testbed\s+\((\w+)\)")
-            self.end_testbed = re.compile("^#\s+End\s+Testbed\s+\((\w+)\)")
-            self.current_testbed = None
-            self.testbed_file = None
-
-            self.def_expstart = \
-                    "sudo -H /bin/sh FEDDIR/fed_bootstrap >& /tmp/federate";
-            self.def_mexpstart = "sudo -H FEDDIR/make_hosts FEDDIR/hosts";
-            self.def_gwstart = \
-                    "sudo -H FEDDIR/fed-tun.pl -f GWCONF>& /tmp/bridge.log";
-            self.def_mgwstart = \
-                    "sudo -H FEDDIR/fed-tun.pl -f GWCONF >& /tmp/bridge.log";
-            self.def_gwimage = "FBSD61-TUNNEL2";
-            self.def_gwtype = "pc";
-            self.def_mgwcmd = '# '
-            self.def_mgwcmdparams = ''
-            self.def_gwcmd = '# '
-            self.def_gwcmdparams = ''
-
-            self.eid = eid
-            self.tmpdir = tmpdir
-            # Convert fedkit and gateway kit (which are lists of tuples) into a
-            # substituition string.
-            self.fedkit = tar_list_to_string(fedkit)
-            self.gatewaykit = tar_list_to_string(gatewaykit)
-
-        def __call__(self, line, master, allocated, tbparams):
-            # Capture testbed topology descriptions
-            if self.current_testbed == None:
-                m = self.begin_testbed.match(line)
-                if m != None:
-                    self.current_testbed = m.group(1)
-                    if self.current_testbed == None:
-                        raise service_error(service_error.req,
-                                "Bad request format (unnamed testbed)")
-                    allocated[self.current_testbed] = \
-                            allocated.get(self.current_testbed,0) + 1
-                    tb_dir = "%s/%s" % (self.tmpdir, self.current_testbed)
-                    if not os.path.exists(tb_dir):
-                        try:
-                            os.mkdir(tb_dir)
-                        except IOError:
-                            raise service_error(service_error.internal,
-                                    "Cannot create %s" % tb_dir)
-                    try:
-                        self.testbed_file = open("%s/%s.%s.tcl" %
-                                (tb_dir, self.eid, self.current_testbed), 'w')
-                    except IOError:
-                        self.testbed_file = None
-                    return True
-                else: return False
-            else:
-                m = self.end_testbed.match(line)
-                if m != None:
-                    if m.group(1) != self.current_testbed:
-                        raise service_error(service_error.internal, 
-                                "Mismatched testbed markers!?")
-                    if self.testbed_file != None: 
-                        self.testbed_file.close()
-                        self.testbed_file = None
-                    self.current_testbed = None
-                elif self.testbed_file:
-                    # Substitute variables and put the line into the local
-                    # testbed file.
-                    gwtype = tbparams[self.current_testbed].get(\
-                            'connectortype', self.def_gwtype)
-                    gwimage = tbparams[self.current_testbed].get(\
-                            'connectorimage', self.def_gwimage)
-                    mgwstart = tbparams[self.current_testbed].get(\
-                            'masterconnectorstartcmd', self.def_mgwstart)
-                    mexpstart = tbparams[self.current_testbed].get(\
-                            'masternodestartcmd', self.def_mexpstart)
-                    gwstart = tbparams[self.current_testbed].get(\
-                            'slaveconnectorstartcmd', self.def_gwstart)
-                    expstart = tbparams[self.current_testbed].get(\
-                            'slavenodestartcmd', self.def_expstart)
-                    project = tbparams[self.current_testbed].get('project')
-                    gwcmd = tbparams[self.current_testbed].get(\
-                            'slaveconnectorcmd', self.def_gwcmd)
-                    gwcmdparams = tbparams[self.current_testbed].get(\
-                            'slaveconnectorcmdparams', self.def_gwcmdparams)
-                    mgwcmd = tbparams[self.current_testbed].get(\
-                            'masterconnectorcmd', self.def_gwcmd)
-                    mgwcmdparams = tbparams[self.current_testbed].get(\
-                            'masterconnectorcmdparams', self.def_gwcmdparams)
-                    line = re.sub("GWTYPE", gwtype, line)
-                    line = re.sub("GWIMAGE", gwimage, line)
-                    if self.current_testbed == master:
-                        line = re.sub("GWSTART", mgwstart, line)
-                        line = re.sub("EXPSTART", mexpstart, line)
-                        # NB GWCMDPARAMS is a prefix of GWCMD, so expand first
-                        line = re.sub("GWCMDPARAMS", mgwcmdparams, line)
-                        line = re.sub("(#\s*)?GWCMD", mgwcmd, line)
-                    else:
-                        line = re.sub("GWSTART", gwstart, line)
-                        line = re.sub("EXPSTART", expstart, line)
-                        # NB GWCMDPARAMS is a prefix of GWCMD, so expand first
-                        line = re.sub("GWCMDPARAMS", gwcmdparams, line)
-                        line = re.sub("(#\s*)?GWCMD", gwcmd, line)
-                    #These expansions contain EID and PROJDIR.  NB these are
-                    # local fedkit and gatewaykit, which are strings.
-                    if self.fedkit:
-                        line = re.sub("FEDKIT", self.fedkit, line)
-                    if self.gatewaykit:
-                        line = re.sub("GATEWAYKIT", self.gatewaykit, line)
-                    line = re.sub("GWCONF", "FEDDIR`hostname`.gw.conf", line)
-                    line = re.sub("PROJDIR", "/proj/%s/" % project, line)
-                    line = re.sub("EID", self.eid, line)
-                    line = re.sub("FEDDIR", "/proj/%s/exp/%s/tmp/" % \
-                            (project, self.eid), line)
-                    print >>self.testbed_file, line
-                return True
-
-    class allbeds:
-        """
-        Process the Allbeds section.  Get access to each federant and save the
-        parameters in tbparams
-        """
-        def __init__(self, get_access):
-            self.begin_allbeds = re.compile("^#\s+Begin\s+Allbeds")
-            self.end_allbeds = re.compile("^#\s+End\s+Allbeds")
-            self.in_allbeds = False
-            self.get_access = get_access
-
-        def __call__(self, line, user, tbparams, master, export_project,
-                access_user):
-            # Testbed access parameters
-            if not self.in_allbeds:
-                if self.begin_allbeds.match(line):
-                    self.in_allbeds = True
-                    return True
-                else:
-                    return False
-            else:
-                if self.end_allbeds.match(line):
-                    self.in_allbeds = False
-                else:
-                    nodes = line.split('|')
-                    tb = nodes.pop(0)
-                    self.get_access(tb, nodes, user, tbparams, master,
-                            export_project, access_user)
-                return True
-
-    class gateways:
-        def __init__(self, eid, master, tmpdir, gw_pubkey,
-                gw_secretkey, copy_file, fedkit):
-            self.begin_gateways = \
-                    re.compile("^#\s+Begin\s+gateways\s+\((\w+)\)")
-            self.end_gateways = re.compile("^#\s+End\s+gateways\s+\((\w+)\)")
-            self.current_gateways = None
-            self.control_gateway = None
-            self.active_end = { }
-
-            self.eid = eid
-            self.master = master
-            self.tmpdir = tmpdir
-            self.gw_pubkey_base = gw_pubkey
-            self.gw_secretkey_base = gw_secretkey
-
-            self.copy_file = copy_file
-            self.fedkit = fedkit
-
-
-        def gateway_conf_file(self, gw, master, eid, pubkey, privkey,
-                active_end, tbparams, dtb, myname, desthost, type):
-            """
-            Produce a gateway configuration file from a gateways line. 
-            """
-
-            sproject = tbparams[gw].get('project', 'project')
-            dproject = tbparams[dtb].get('project', 'project')
-            sdomain = ".%s.%s%s" % (eid, sproject,
-                    tbparams[gw].get('domain', ".example.com"))
-            ddomain = ".%s.%s%s" % (eid, dproject,
-                    tbparams[dtb].get('domain', ".example.com"))
-            boss = tbparams[master].get('boss', "boss")
-            fs = tbparams[master].get('fs', "fs")
-            event_server = "%s%s" % \
-                    (tbparams[gw].get('eventserver', "event_server"),
-                            tbparams[gw].get('domain', "example.com"))
-            remote_event_server = "%s%s" % \
-                    (tbparams[dtb].get('eventserver', "event_server"),
-                            tbparams[dtb].get('domain', "example.com"))
-            seer_control = "%s%s" % \
-                    (tbparams[gw].get('control', "control"), sdomain)
-            tunnel_iface = tbparams[gw].get("tunnelinterface", None)
-
-            if self.fedkit:
-                remote_script_dir = "/usr/local/federation/bin"
-                local_script_dir = "/usr/local/federation/bin"
-            else:
-                remote_script_dir = "/proj/%s/exp/%s/tmp" % ( dproject, eid)
-                local_script_dir = "/proj/%s/exp/%s/tmp" % ( sproject, eid)
-
-            local_key_dir = "/proj/%s/exp/%s/tmp" % ( sproject, eid)
-            remote_conf_dir = "/proj/%s/exp/%s/tmp" % ( dproject, eid)
-            tunnel_cfg = tbparams[gw].get("tunnelcfg", "false")
-
-            conf_file = "%s%s.gw.conf" % (myname, sdomain)
-            remote_conf_file = "%s%s.gw.conf" % (desthost, ddomain)
-
-            # translate to lower case so the `hostname` hack for specifying
-            # configuration files works.
-            conf_file = conf_file.lower();
-            remote_conf_file = remote_conf_file.lower();
-
-            if dtb == master:
-                active = "false"
-            elif gw == master:
-                active = "true"
-            elif active_end.has_key('%s-%s' % (dtb, gw)):
-                active = "false"
-            else:
-                active_end['%s-%s' % (gw, dtb)] = 1
-                active = "true"
-
-            gwconfig = open("%s/%s/%s" % (self.tmpdir, gw, conf_file), "w")
-            print >>gwconfig, "Active: %s" % active
-            print >>gwconfig, "TunnelCfg: %s" % tunnel_cfg
-            if tunnel_iface:
-                print >>gwconfig, "Interface: %s" % tunnel_iface
-            print >>gwconfig, "BossName: %s" % boss
-            print >>gwconfig, "FsName: %s" % fs
-            print >>gwconfig, "EventServerName: %s" % event_server
-            print >>gwconfig, "RemoteEventServerName: %s" % remote_event_server
-            print >>gwconfig, "SeerControl: %s" % seer_control
-            print >>gwconfig, "Type: %s" % type
-            print >>gwconfig, "RemoteScriptDir: %s" % remote_script_dir
-            print >>gwconfig, "EventRepeater: %s/fed_evrepeater" % \
-                    local_script_dir
-            print >>gwconfig, "RemoteExperiment: %s/%s" % (dproject, eid)
-            print >>gwconfig, "LocalExperiment: %s/%s" % (sproject, eid)
-            print >>gwconfig, "RemoteConfigFile: %s/%s" % \
-                    (remote_conf_dir, remote_conf_file)
-            print >>gwconfig, "Peer: %s%s" % (desthost, ddomain)
-            print >>gwconfig, "Pubkeys: %s/%s" % (local_key_dir, pubkey)
-            print >>gwconfig, "Privkeys: %s/%s" % (local_key_dir, privkey)
-            gwconfig.close()
-
-            return active == "true"
-
-        def __call__(self, line, allocated, tbparams):
-            # Process gateways
-            if not self.current_gateways:
-                m = self.begin_gateways.match(line)
-                if m:
-                    self.current_gateways = m.group(1)
-                    if allocated.has_key(self.current_gateways):
-                        # This test should always succeed
-                        tb_dir = "%s/%s" % (self.tmpdir, self.current_gateways)
-                        if not os.path.exists(tb_dir):
-                            try:
-                                os.mkdir(tb_dir)
-                            except IOError:
-                                raise service_error(service_error.internal,
-                                        "Cannot create %s" % tb_dir)
-                    else:
-                        # XXX
-                        self.log.error("[gateways]: Ignoring gateways for " + \
-                                "unknown testbed %s" % self.current_gateways)
-                        self.current_gateways = None
-                    return True
-                else:
-                    return False
-            else:
-                m = self.end_gateways.match(line)
-                if m :
-                    if m.group(1) != self.current_gateways:
-                        raise service_error(service_error.internal,
-                                "Mismatched gateway markers!?")
-                    if self.control_gateway:
-                        try:
-                            cc = open("%s/%s/client.conf" %
-                                    (self.tmpdir, self.current_gateways), 'w')
-                            print >>cc, "ControlGateway: %s" % \
-                                    self.control_gateway
-                            if tbparams[self.master].has_key('smbshare'):
-                                print >>cc, "SMBSHare: %s" % \
-                                        tbparams[self.master]['smbshare']
-                            print >>cc, "ProjectUser: %s" % \
-                                    tbparams[self.master]['user']
-                            print >>cc, "ProjectName: %s" % \
-                                    tbparams[self.master]['project']
-                            print >>cc, "ExperimentID: %s/%s" % \
-                                    ( tbparams[self.master]['project'], \
-                                    self.eid )
-                            cc.close()
-                        except IOError:
-                            raise service_error(service_error.internal,
-                                    "Error creating client config")
-                        # XXX: This seer specific file should disappear
-                        try:
-                            cc = open("%s/%s/seer.conf" %
-                                    (self.tmpdir, self.current_gateways),
-                                    'w')
-                            if self.current_gateways != self.master:
-                                print >>cc, "ControlNode: %s" % \
-                                        self.control_gateway
-                            print >>cc, "ExperimentID: %s/%s" % \
-                                    ( tbparams[self.master]['project'], \
-                                    self.eid )
-                            cc.close()
-                        except IOError:
-                            raise service_error(service_error.internal,
-                                    "Error creating seer config")
-                    else:
-                        debug.error("[gateways]: No control gateway for %s" %\
-                                    self.current_gateways)
-                    self.current_gateways = None
-                else:
-                    dtb, myname, desthost, type = line.split(" ")
-
-                    if type == "control" or type == "both":
-                        self.control_gateway = "%s.%s.%s%s" % (myname, 
-                                self.eid, 
-                                tbparams[self.current_gateways]['project'],
-                                tbparams[self.current_gateways]['domain'])
-                    try:
-                        active = self.gateway_conf_file(self.current_gateways,
-                                self.master, self.eid, self.gw_pubkey_base,
-                                self.gw_secretkey_base,
-                                self.active_end, tbparams, dtb, myname,
-                                desthost, type)
-                    except IOError, e:
-                        raise service_error(service_error.internal,
-                                "Failed to write config file for %s" % \
-                                        self.current_gateway)
-            
-                    gw_pubkey = "%s/keys/%s" % \
-                            (self.tmpdir, self.gw_pubkey_base)
-                    gw_secretkey = "%s/keys/%s" % \
-                            (self.tmpdir, self.gw_secretkey_base)
-
-                    pkfile = "%s/%s/%s" % \
-                            ( self.tmpdir, self.current_gateways, 
-                                    self.gw_pubkey_base)
-                    skfile = "%s/%s/%s" % \
-                            ( self.tmpdir, self.current_gateways, 
-                                    self.gw_secretkey_base)
-
-                    if not os.path.exists(pkfile):
-                        try:
-                            self.copy_file(gw_pubkey, pkfile)
-                        except IOError:
-                            service_error(service_error.internal,
-                                    "Failed to copy pubkey file")
-
-                    if active and not os.path.exists(skfile):
-                        try:
-                            self.copy_file(gw_secretkey, skfile)
-                        except IOError:
-                            service_error(service_error.internal,
-                                    "Failed to copy secretkey file")
-                return True
-
-    class shunt_to_file:
-        """
-        Simple class to write data between two regexps to a file.
-        """
-        def __init__(self, begin, end, filename):
-            """
-            Begin shunting on a match of begin, stop on end, send data to
-            filename.
-            """
-            self.begin = re.compile(begin)
-            self.end = re.compile(end)
-            self.in_shunt = False
-            self.file = None
-            self.filename = filename
-
-        def __call__(self, line):
-            """
-            Call this on each line in the input that may be shunted.
-            """
-            if not self.in_shunt:
-                if self.begin.match(line):
-                    self.in_shunt = True
-                    try:
-                        self.file = open(self.filename, "w")
-                    except:
-                        self.file = None
-                        raise
-                    return True
-                else:
-                    return False
-            else:
-                if self.end.match(line):
-                    if self.file: 
-                        self.file.close()
-                        self.file = None
-                    self.in_shunt = False
-                else:
-                    if self.file:
-                        print >>self.file, line
-                return True
-
-    class shunt_to_list:
-        """
-        Same interface as shunt_to_file.  Data collected in self.list, one list
-        element per line.
-        """
-        def __init__(self, begin, end):
-            self.begin = re.compile(begin)
-            self.end = re.compile(end)
-            self.in_shunt = False
-            self.list = [ ]
-        
-        def __call__(self, line):
-            if not self.in_shunt:
-                if self.begin.match(line):
-                    self.in_shunt = True
-                    return True
-                else:
-                    return False
-            else:
-                if self.end.match(line):
-                    self.in_shunt = False
-                else:
-                    self.list.append(line)
-                return True
-
-    class shunt_to_string:
-        """
-        Same interface as shunt_to_file.  Data collected in self.str, all in
-        one string.
-        """
-        def __init__(self, begin, end):
-            self.begin = re.compile(begin)
-            self.end = re.compile(end)
-            self.in_shunt = False
-            self.str = ""
-        
-        def __call__(self, line):
-            if not self.in_shunt:
-                if self.begin.match(line):
-                    self.in_shunt = True
-                    return True
-                else:
-                    return False
-            else:
-                if self.end.match(line):
-                    self.in_shunt = False
-                else:
-                    self.str += line
-                return True
-
-    def allocate_resources(self, allocated, master, eid, expid, expcert, 
-            tbparams, tmpdir, alloc_log=None):
-        started = { }           # Testbeds where a sub-experiment started 
-                                # successfully
-
-        # XXX
-        fail_soft = False
-
-        log = alloc_log or self.log
-
-        thread_pool = self.thread_pool(self.nthreads)
-        threads = [ ]
-
-        for tb in [ k for k in allocated.keys() if k != master]:
-            # Create and start a thread to start the segment, and save it to
-            # get the return value later
-            thread_pool.wait_for_slot()
-            t  = self.pooled_thread(\
-                    target=self.start_segment(log=log,
-                        keyfile=self.ssh_privkey_file, debug=self.debug), 
-                    args=(tb, eid, tbparams, tmpdir, 0), name=tb,
-                    pdata=thread_pool, trace_file=self.trace_file)
-            threads.append(t)
-            t.start()
-
-        # Wait until all finish 
-        thread_pool.wait_for_all_done()
-
-        # If none failed, start the master
-        failed = [ t.getName() for t in threads if not t.rv ]
-
-        if len(failed) == 0:
-            starter = self.start_segment(log=log, 
-                    keyfile=self.ssh_privkey_file, debug=self.debug)
-            if not starter(master, eid, tbparams, tmpdir):
-                failed.append(master)
-
-        succeeded = [tb for tb in allocated.keys() if tb not in failed]
-        # If one failed clean up, unless fail_soft is set
-        if failed:
-            if not fail_soft:
-                thread_pool.clear()
-                for tb in succeeded:
-                    # Create and start a thread to stop the segment
-                    thread_pool.wait_for_slot()
-                    t  = self.pooled_thread(\
-                            target=self.stop_segment(log=log,
-                                keyfile=self.ssh_privkey_file,
-                                debug=self.debug), 
-                            args=(tb, eid, tbparams), name=tb,
-                            pdata=thread_pool, trace_file=self.trace_file)
-                    t.start()
-                # Wait until all finish
-                thread_pool.wait_for_all_done()
-
-                # release the allocations
-                for tb in tbparams.keys():
-                    self.release_access(tb, tbparams[tb]['allocID'])
-                # Remove the placeholder
-                self.state_lock.acquire()
-                self.state[eid]['experimentStatus'] = 'failed'
-                if self.state_filename: self.write_state()
-                self.state_lock.release()
-
-                #raise service_error(service_error.federant,
-                #    "Swap in failed on %s" % ",".join(failed))
-                log.error("Swap in failed on %s" % ",".join(failed))
-                return
-        else:
-            log.info("[start_segment]: Experiment %s active" % eid)
-
-        log.debug("[start_experiment]: removing %s" % tmpdir)
-
-        # Walk up tmpdir, deleting as we go
-        for path, dirs, files in os.walk(tmpdir, topdown=False):
-            for f in files:
-                os.remove(os.path.join(path, f))
-            for d in dirs:
-                os.rmdir(os.path.join(path, d))
-        os.rmdir(tmpdir)
-
-        # Insert the experiment into our state and update the disk copy
-        self.state_lock.acquire()
-        self.state[expid]['experimentStatus'] = 'active'
-        self.state[eid] = self.state[expid]
-        if self.state_filename: self.write_state()
-        self.state_lock.release()
-        return
-
-    def create_experiment(self, req, fid):
-        """
-        The external interface to experiment creation called from the
-        dispatcher.
-
-        Creates a working directory, splits the incoming description using the
-        splitter script and parses out the avrious subsections using the
-        lcasses above.  Once each sub-experiment is created, use pooled threads
-        to instantiate them and start it all up.
-        """
-
-        if not self.auth.check_attribute(fid, 'create'):
-            raise service_error(service_error.access, "Create access denied")
-
-        try:
-            tmpdir = tempfile.mkdtemp(prefix="split-")
-        except IOError:
-            raise service_error(service_error.internal, "Cannot create tmp dir")
-
-        gw_pubkey_base = "fed.%s.pub" % self.ssh_type
-        gw_secretkey_base = "fed.%s" % self.ssh_type
-        gw_pubkey = tmpdir + "/keys/" + gw_pubkey_base
-        gw_secretkey = tmpdir + "/keys/" + gw_secretkey_base
-        tclfile = tmpdir + "/experiment.tcl"
-        tbparams = { }
-        try:
-            access_user = self.accessdb[fid]
-        except KeyError:
-            raise service_error(service_error.internal,
-                    "Access map and authorizer out of sync in " + \
-                            "create_experiment for fedid %s"  % fid)
-
-        pid = "dummy"
-        gid = "dummy"
-        try:
-            os.mkdir(tmpdir+"/keys")
-        except OSError:
-            raise service_error(service_error.internal,
-                    "Can't make temporary dir")
-
-        req = req.get('CreateRequestBody', None)
-        if not req:
-            raise service_error(service_error.req,
-                    "Bad request format (no CreateRequestBody)")
-        # The tcl parser needs to read a file so put the content into that file
-        descr=req.get('experimentdescription', None)
-        if descr:
-            file_content=descr.get('ns2description', None)
-            if file_content:
-                try:
-                    f = open(tclfile, 'w')
-                    f.write(file_content)
-                    f.close()
-                except IOError:
-                    raise service_error(service_error.internal,
-                            "Cannot write temp experiment description")
-            else:
-                raise service_error(service_error.req, 
-                        "Only ns2descriptions supported")
-        else:
-            raise service_error(service_error.req, "No experiment description")
-
-        # Generate an ID for the experiment (slice) and a certificate that the
-        # allocator can use to prove they own it.  We'll ship it back through
-        # the encrypted connection.
-        (expid, expcert) = generate_fedid("test", dir=tmpdir, log=self.log)
-
-        if req.has_key('experimentID') and \
-                req['experimentID'].has_key('localname'):
-            overwrite = False
-            eid = req['experimentID']['localname']
-            # If there's an old failed experiment here with the same local name
-            # and accessible by this user, we'll overwrite it, otherwise we'll
-            # fall through and do the collision avoidance.
-            old_expid = self.get_experiment_fedid(eid)
-            if old_expid and self.check_experiment_access(fid, old_expid):
-                self.state_lock.acquire()
-                status = self.state[eid].get('experimentStatus', None)
-                if status and status == 'failed':
-                    # remove the old access attribute
-                    self.auth.unset_attribute(fid, old_expid)
-                    overwrite = True
-                    del self.state[eid]
-                    del self.state[old_expid]
-                self.state_lock.release()
-            self.state_lock.acquire()
-            while (self.state.has_key(eid) and not overwrite):
-                eid += random.choice(string.ascii_letters)
-            # Initial state
-            self.state[eid] = {
-                    'experimentID' : \
-                            [ { 'localname' : eid }, {'fedid': expid } ],
-                    'experimentStatus': 'starting',
-                    'experimentAccess': { 'X509' : expcert },
-                    'owner': fid,
-                    'log' : [],
-                }
-            self.state[expid] = self.state[eid]
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-        else:
-            eid = self.exp_stem
-            for i in range(0,5):
-                eid += random.choice(string.ascii_letters)
-            self.state_lock.acquire()
-            while (self.state.has_key(eid)):
-                eid = self.exp_stem
-                for i in range(0,5):
-                    eid += random.choice(string.ascii_letters)
-            # Initial state
-            self.state[eid] = {
-                    'experimentID' : \
-                            [ { 'localname' : eid }, {'fedid': expid } ],
-                    'experimentStatus': 'starting',
-                    'experimentAccess': { 'X509' : expcert },
-                    'owner': fid,
-                    'log' : [],
-                }
-            self.state[expid] = self.state[eid]
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-
-        try: 
-            # This catches exceptions to clear the placeholder if necessary
-            try:
-                self.generate_ssh_keys(gw_secretkey, self.ssh_type)
-            except ValueError:
-                raise service_error(service_error.server_config, 
-                        "Bad key type (%s)" % self.ssh_type)
-
-            user = req.get('user', None)
-            if user == None:
-                raise service_error(service_error.req, "No user")
-
-            master = req.get('master', None)
-            if not master:
-                raise service_error(service_error.req,
-                        "No master testbed label")
-            export_project = req.get('exportProject', None)
-            if not export_project:
-                raise service_error(service_error.req, "No export project")
-            
-            if self.splitter_url:
-                self.log.debug("Calling remote splitter at %s" % \
-                        self.splitter_url)
-                split_data = self.remote_splitter(self.splitter_url,
-                        file_content, master)
-            else:
-                tclcmd = [self.tclsh, self.tcl_splitter, '-s', '-x', 
-                    str(self.muxmax), '-m', master]
-
-                if self.fedkit:
-                    tclcmd.append('-k')
-
-                if self.gatewaykit:
-                    tclcmd.append('-K')
-
-                tclcmd.extend([pid, gid, eid, tclfile])
-
-                self.log.debug("running local splitter %s", " ".join(tclcmd))
-                # This is just fantastic.  As a side effect the parser copies
-                # tb_compat.tcl into the current directory, so that directory
-                # must be writable by the fedd user.  Doing this in the
-                # temporary subdir ensures this is the case.
-                tclparser = Popen(tclcmd, stdout=PIPE, close_fds=True, 
-                        cwd=tmpdir)
-                split_data = tclparser.stdout
-
-            allocated = { }         # Testbeds we can access
-            # Objects to parse the splitter output (defined above)
-            parse_current_testbed = self.current_testbed(eid, tmpdir,
-                    self.fedkit, self.gatewaykit)
-            parse_allbeds = self.allbeds(self.get_access)
-            parse_gateways = self.gateways(eid, master, tmpdir,
-                    gw_pubkey_base, gw_secretkey_base, self.copy_file,
-                    self.fedkit)
-            parse_vtopo = self.shunt_to_string("^#\s+Begin\s+Vtopo",
-                        "^#\s+End\s+Vtopo")
-            parse_hostnames = self.shunt_to_file("^#\s+Begin\s+hostnames",
-                        "^#\s+End\s+hostnames", tmpdir + "/hosts")
-            parse_tarfiles = self.shunt_to_list("^#\s+Begin\s+tarfiles",
-                    "^#\s+End\s+tarfiles")
-            parse_rpms = self.shunt_to_list("^#\s+Begin\s+rpms",
-                    "^#\s+End\s+rpms")
-
-            # Working on the split data
-            for line in split_data:
-                line = line.rstrip()
-                if parse_current_testbed(line, master, allocated, tbparams):
-                    continue
-                elif parse_allbeds(line, user, tbparams, master, export_project,
-                        access_user):
-                    continue
-                elif parse_gateways(line, allocated, tbparams):
-                    continue
-                elif parse_vtopo(line):
-                    continue
-                elif parse_hostnames(line):
-                    continue
-                elif parse_tarfiles(line):
-                    continue
-                elif parse_rpms(line):
-                    continue
-                else:
-                    raise service_error(service_error.internal, 
-                            "Bad tcl parse? %s" % line)
-            # Virtual topology and visualization
-            vtopo = self.gentopo(parse_vtopo.str)
-            if not vtopo:
-                raise service_error(service_error.internal, 
-                        "Failed to generate virtual topology")
-
-            vis = self.genviz(vtopo)
-            if not vis:
-                raise service_error(service_error.internal, 
-                        "Failed to generate visualization")
-
-            
-            # save federant information
-            for k in allocated.keys():
-                tbparams[k]['federant'] = {\
-                        'name': [ { 'localname' : eid} ],\
-                        'emulab': tbparams[k]['emulab'],\
-                        'allocID' : tbparams[k]['allocID'],\
-                        'master' : k == master,\
-                    }
-
-            self.state_lock.acquire()
-            self.state[eid]['vtopo'] = vtopo
-            self.state[eid]['vis'] = vis
-            self.state[expid]['federant'] = \
-                    [ tbparams[tb]['federant'] for tb in tbparams.keys() \
-                        if tbparams[tb].has_key('federant') ]
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-
-            # Copy tarfiles and rpms needed at remote sites into a staging area
-            try:
-                if self.fedkit:
-                    for t in self.fedkit:
-                        parse_tarfiles.list.append(t[1])
-                if self.gatewaykit:
-                    for t in self.gatewaykit:
-                        parse_tarfiles.list.append(t[1])
-                for t in parse_tarfiles.list:
-                    if not os.path.exists("%s/tarfiles" % tmpdir):
-                        os.mkdir("%s/tarfiles" % tmpdir)
-                    self.copy_file(t, "%s/tarfiles/%s" % \
-                            (tmpdir, os.path.basename(t)))
-                for r in parse_rpms.list:
-                    if not os.path.exists("%s/rpms" % tmpdir):
-                        os.mkdir("%s/rpms" % tmpdir)
-                    self.copy_file(r, "%s/rpms/%s" % \
-                            (tmpdir, os.path.basename(r)))
-                # A null experiment file in case we need to create a remote
-                # experiment from scratch
-                f = open("%s/null.tcl" % tmpdir, "w")
-                print >>f, """
-set ns [new Simulator]
-source tb_compat.tcl
-
-set a [$ns node]
-
-$ns rtproto Session
-$ns run 
-"""
-                f.close()
-
-            except IOError, e:
-                raise service_error(service_error.internal, 
-                        "Cannot stage tarfile/rpm: %s" % e.strerror)
-
-        except service_error, e:
-            # If something goes wrong in the parse (usually an access error)
-            # clear the placeholder state.  From here on out the code delays
-            # exceptions.  Failing at this point returns a fault to the remote
-            # caller. 
-            self.state_lock.acquire()
-            del self.state[eid]
-            del self.state[expid]
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-            raise e
-
-
-        # Start the background swapper and return the starting state.  From
-        # here on out, the state will stick around a while.
-
-        # Let users touch the state
-        self.auth.set_attribute(fid, expid)
-        self.auth.set_attribute(expid, expid)
-        # Override fedids can manipulate state as well
-        for o in self.overrides:
-            self.auth.set_attribute(o, expid)
-
-        # Create a logger that logs to the experiment's state object as well as
-        # to the main log file.
-        alloc_log = logging.getLogger('fedd.experiment_control.%s' % eid)
-        h = logging.StreamHandler(self.list_log(self.state[eid]['log']))
-        # XXX: there should be a global one of these rather than repeating the
-        # code.
-        h.setFormatter(logging.Formatter("%(asctime)s %(name)s %(message)s",
-                    '%d %b %y %H:%M:%S'))
-        alloc_log.addHandler(h)
-        
-        # Start a thread to do the resource allocation
-        t  = Thread(target=self.allocate_resources,
-                args=(allocated, master, eid, expid, expcert, tbparams, 
-                    tmpdir, alloc_log),
-                name=eid)
-        t.start()
-
-        rv = {
-                'experimentID': [
-                    {'localname' : eid }, { 'fedid': copy.copy(expid) }
-                ],
-                'experimentStatus': 'starting',
-                'experimentAccess': { 'X509' : expcert }
-            }
-
-        return rv
-
-    class new_start_segment:
+
+    class start_segment:
 	def __init__(self, debug=False, log=None, testbed="", cert_file=None,
 		cert_pwd=None, trusted_certs=None, caller=None):
@@ -2175,5 +955,5 @@
 
 
-    class new_terminate_segment:
+    class terminate_segment:
 	def __init__(self, debug=False, log=None, testbed="", cert_file=None,
 		cert_pwd=None, trusted_certs=None, caller=None):
@@ -2199,9 +979,7 @@
 			(self.testbed, e))
 		return False
-
-
     
 
-    def new_allocate_resources(self, allocated, master, eid, expid, expcert, 
+    def allocate_resources(self, allocated, master, eid, expid, expcert, 
             tbparams, topo, tmpdir, alloc_log=None, attrs=None):
         started = { }           # Testbeds where a sub-experiment started 
@@ -2233,5 +1011,5 @@
 
             t  = self.pooled_thread(\
-                    target=self.new_start_segment(log=log, debug=self.debug,
+                    target=self.start_segment(log=log, debug=self.debug,
 			testbed=tb, cert_file=self.cert_file,
 			cert_pwd=self.cert_pwd,
@@ -2261,5 +1039,5 @@
 		raise service_error(service_error.internal, 
 		    "No alloc id for testbed %s !?" % master)
-            starter = self.new_start_segment(log=log, debug=self.debug,
+            starter = self.start_segment(log=log, debug=self.debug,
 		    testbed=master, cert_file=self.cert_file,
 		    cert_pwd=self.cert_pwd, trusted_certs=self.trusted_certs,
@@ -2320,5 +1098,5 @@
 
 
-    def new_create_experiment(self, req, fid):
+    def create_experiment(self, req, fid):
         """
         The external interface to experiment creation called from the
@@ -2882,5 +1660,5 @@
 
         # Start a thread to do the resource allocation
-        t  = Thread(target=self.new_allocate_resources,
+        t  = Thread(target=self.allocate_resources,
                 args=(allocated, master, eid, expid, expcert, tbparams, 
                     topo, tmpdir, alloc_log, attrs),
@@ -3119,5 +1897,4 @@
         return rv
 
-
     def terminate_experiment(self, req, fid):
         """
@@ -3194,155 +1971,4 @@
                 if id.has_key('localname'): ids.append(id['localname'])
 
-            # Construct enough of the tbparams to make the stop_segment calls
-            # work
-            for fed in fed_exp.get('federant', []):
-                try:
-                    for e in fed['name']:
-                        eid = e.get('localname', None)
-                        if eid: break
-                    else:
-                        continue
-
-                    p = fed['emulab']['project']
-
-                    project = p['name']['localname']
-                    tb = p['testbed']['localname']
-                    user = p['user'][0]['userID']['localname']
-
-                    domain = fed['emulab']['domain']
-                    host  = fed['emulab']['ops']
-                    aid = fed['allocID']
-                except KeyError, e:
-                    continue
-                tbparams[tb] = {\
-                        'user': user,\
-                        'domain': domain,\
-                        'project': project,\
-                        'host': host,\
-                        'eid': eid,\
-                        'aid': aid,\
-                    }
-            fed_exp['experimentStatus'] = 'terminating'
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-
-            # Stop everyone.  NB, wait_for_all waits until a thread starts and
-            # then completes, so we can't wait if nothing starts.  So, no
-            # tbparams, no start.
-            if len(tbparams) > 0:
-                thread_pool = self.thread_pool(self.nthreads)
-                for tb in tbparams.keys():
-                    # Create and start a thread to stop the segment
-                    thread_pool.wait_for_slot()
-                    t  = self.pooled_thread(\
-                            target=self.stop_segment(log=dealloc_log,
-                                keyfile=self.ssh_privkey_file, debug=self.debug), 
-                            args=(tb, tbparams[tb]['eid'], tbparams), name=tb,
-                            pdata=thread_pool, trace_file=self.trace_file)
-                    t.start()
-                # Wait for completions
-                thread_pool.wait_for_all_done()
-
-            # release the allocations (failed experiments have done this
-            # already, and starting experiments may be in odd states, so we
-            # ignore errors releasing those allocations
-            try: 
-                for tb in tbparams.keys():
-                    self.release_access(tb, tbparams[tb]['aid'])
-            except service_error, e:
-                if status != 'failed' and not force:
-                    raise e
-
-            # Remove the terminated experiment
-            self.state_lock.acquire()
-            for id in ids:
-                if self.state.has_key(id): del self.state[id]
-
-            if self.state_filename: self.write_state()
-            self.state_lock.release()
-
-            return { 
-                    'experiment': exp , 
-                    'deallocationLog': "".join(dealloc_list),
-                    }
-        else:
-            # Don't forget to release the lock
-            self.state_lock.release()
-            raise service_error(service_error.req, "No saved state")
-
-    def new_terminate_experiment(self, req, fid):
-        """
-        Swap this experiment out on the federants and delete the shared
-        information
-        """
-        tbparams = { }
-        req = req.get('TerminateRequestBody', None)
-        if not req:
-            raise service_error(service_error.req,
-                    "Bad request format (no TerminateRequestBody)")
-        force = req.get('force', False)
-        exp = req.get('experiment', None)
-        if exp:
-            if exp.has_key('fedid'):
-                key = exp['fedid']
-                keytype = "fedid"
-            elif exp.has_key('localname'):
-                key = exp['localname']
-                keytype = "localname"
-            else:
-                raise service_error(service_error.req, "Unknown lookup type")
-        else:
-            raise service_error(service_error.req, "No request?")
-
-        self.check_experiment_access(fid, key)
-
-        dealloc_list = [ ]
-
-
-        # Create a logger that logs to the dealloc_list as well as to the main
-        # log file.
-        dealloc_log = logging.getLogger('fedd.experiment_control.%s' % key)
-        h = logging.StreamHandler(self.list_log(dealloc_list))
-        # XXX: there should be a global one of these rather than repeating the
-        # code.
-        h.setFormatter(logging.Formatter("%(asctime)s %(name)s %(message)s",
-                    '%d %b %y %H:%M:%S'))
-        dealloc_log.addHandler(h)
-
-        self.state_lock.acquire()
-        fed_exp = self.state.get(key, None)
-
-        if fed_exp:
-            # This branch of the conditional holds the lock to generate a
-            # consistent temporary tbparams variable to deallocate experiments.
-            # It releases the lock to do the deallocations and reacquires it to
-            # remove the experiment state when the termination is complete.
-
-            # First make sure that the experiment creation is complete.
-            status = fed_exp.get('experimentStatus', None)
-
-            if status:
-                if status in ('starting', 'terminating'):
-                    if not force:
-                        self.state_lock.release()
-                        raise service_error(service_error.partial, 
-                                'Experiment still being created or destroyed')
-                    else:
-                        self.log.warning('Experiment in %s state ' % status + \
-                                'being terminated by force.')
-            else:
-                # No status??? trouble
-                self.state_lock.release()
-                raise service_error(service_error.internal,
-                        "Experiment has no status!?")
-
-            ids = []
-            #  experimentID is a list of dicts that are self-describing
-            #  identifiers.  This finds all the fedids and localnames - the
-            #  keys of self.state - and puts them into ids.
-            for id in fed_exp.get('experimentID', []):
-                if id.has_key('fedid'): ids.append(id['fedid'])
-                if id.has_key('localname'): ids.append(id['localname'])
-
             # Collect the allocation/segment ids
             for fed in fed_exp.get('federant', []):
@@ -3369,5 +1995,5 @@
 		    uri = self.tbmap.get(tb, None)
                     t  = self.pooled_thread(\
-                            target=self.new_terminate_segment(log=dealloc_log,
+                            target=self.terminate_segment(log=dealloc_log,
 				testbed=tb,
 				cert_file=self.cert_file, 
