source: fedd/federation/local_emulab_segment.py @ 7aaa8dc

#!/usr/local/bin/python

import sys, os
import re

import tempfile
import subprocess
import logging 
import time
import signal

import util

from local_segment import local_segment
from federation.emulab_segment import emulab_segment


class start_segment(local_segment, emulab_segment):
    def __init__(self, log=None, keyfile=None, debug=False, boss=None,
            cert=None):
        local_segment.__init__(self, log=log, keyfile=keyfile, debug=debug)
        emulab_segment.__init__(self, boss=boss, cert=cert)

    def set_up_experiment_filespace(self, pid, eid, tmpdir):
        # Configuration directories on this machine
        proj_dir = "/proj/%s/exp/%s/tmp" % (pid, eid)
        softdir = "/proj/%s/software/%s" % (pid, eid)
        # Softwrae staging directory software dir
        lsoftdir = "%s/software" % tmpdir

        # Set up the experiment's file space
        if not self.cmd_with_timeout("/bin/rm -rf %s" % proj_dir):
            return False
        # Clear and create the software and configuration directories
        if not self.cmd_with_timeout("/bin/rm -rf %s/*" % softdir):
            return False
        if not self.cmd_with_timeout('mkdir -p %s' % proj_dir):
            return False
        if os.path.isdir(lsoftdir):
            if not self.cmd_with_timeout('mkdir -p %s' % softdir):
                return False

        try:
            for f in os.listdir(tmpdir):
                if not os.path.isdir("%s/%s" % (tmpdir, f)):
                    self.copy_file("%s/%s" % (tmpdir, f), 
                            "%s/%s" % (proj_dir, f))
            if os.path.isdir(lsoftdir):
                for f in os.listdir(lsoftdir):
                    if not os.path.isdir("%s/%s" % (lsoftdir, f)):
                        self.copy_file("%s/%s" % (lsoftdir, f), 
                                "%s/%s" % (softdir, f))
        except EnvironmentError, e:
            self.log.error("Error copying file: %s" %e)
            return False

        return True

    def __call__(self, parent, eid, pid, user, tclfile, tmpdir, timeout=0, 
            gid=None):
        """
        Start a sub-experiment on a federant.

        Get the current state, and terminate the experiment if it exists. The
        group membership of the experiment is difficult to determine or change,
        so start with a clean slate.  Create a new one and ship data
        and configs and start the experiment.  There are small ordering
        differences based on the initial state of the sub-experiment.
        """

        state = self.get_state(pid, eid)

        if state != 'none':
            self.terminate_exp(pid, eid)

        if not self.make_null_experiment(pid, eid, tmpdir, gid):
            return False

        if not self.set_up_experiment_filespace(pid, eid, tmpdir):
            return False

        # Put the file into a string to pass to emulab.
        try:
            tcl = "".join([ l for l in open(tclfile,"r")])
        except EnvironmentError, e:
            self.log.error("Can't read %s: %s" % (tclfile, e))
            return False
        
        # Stage the new configuration
        if not self.modify_exp(pid, eid, tcl):
            self.log.error("modify failed")
            return False

        if not self.swap_exp(pid, eid, 'in'):
            self.log.error("swap in failed")
            return False
        # Everything has gone OK.
        self.get_mapping(pid,eid)
        return True

class stop_segment(local_segment, emulab_segment):
    def __init__(self, log=None, keyfile=None, debug=False, boss=None, 
            cert=None):
        local_segment.__init__(self, log=log, keyfile=keyfile, debug=debug)
        emulab_segment.__init__(self, boss=boss, cert=cert)

    def __call__(self, parent, user, pid, eid, gid=None, terminate=False):
        """
        Stop a sub experiment by calling swapexp on the federant
        """

        self.log.info("[stop_segment]: Stopping %s" % eid)
        rv = False
        try:
            # Clean out tar files: we've gone over quota in the past
            self.cmd_with_timeout("rm -rf /proj/%s/software/%s" % (pid, eid))
            rv = self.swap_exp(pid, eid, 'out')
            if terminate:
                rv = self.terminate_exp(pid, eid)
        except self.cmd_timeout:
            rv = False
        return rv

class info_segment(local_segment, emulab_segment):
    def __init__(self, log=None, keyfile=None, debug=False, boss=None, 
            cert=None):
        local_segment.__init__(self, log=log, keyfile=keyfile, debug=debug)
        emulab_segment.__init__(self, boss=boss, cert=cert)

    def __call__(self, parent, user, pid, eid):
        self.log.info("[info_segment]: Getting info from %s" % eid)
        self.get_mapping(pid,eid)
        return True

class operation_segment(local_segment, emulab_segment):
    def __init__(self, log=None, keyfile=None, debug=False, boss=None, 
            cert=None):
        local_segment.__init__(self, log=log, keyfile=keyfile, debug=debug)
        emulab_segment.__init__(self, boss=boss, cert=cert)

    def __call__(self, parent, op, targets, param, top):
        for l, p in targets.items():
            self.log.info("[operation_segment]: Calling op on %s(%s)" % (l,p))
            self.do_operation(op, l, p, param, top)
        return True