source: fedd/fedd_split.py @ 72ed6e4

#!/usr/local/bin/python

import os,sys

from ZSI import *
from M2Crypto import SSL
from M2Crypto.SSL.SSLServer import SSLServer
import M2Crypto.httpslib

import xml.parsers.expat

import re
import random
import string
import subprocess
import tempfile
import copy
import pickle

import traceback

from threading import *

from subprocess import *

from fedd_services import *
from fedd_internal_services import *
from fedd_util import *
import parse_detail
from service_error import *

import logging

class nullHandler(logging.Handler):
    def emit(self, record): pass

fl = logging.getLogger("fedd.experiment_control")
fl.addHandler(nullHandler())

class fedd_split_local:
    def __init__(self, config=None):
        """
        Intialize the various attributes, most from the config object
        """
        self.debug = config.create_debug
        self.log = logging.getLogger("fedd.splitter")
        self.tclsh = "/usr/local/bin/otclsh"
        self.tcl_splitter = "/usr/testbed/lib/ns2ir/parse.tcl"
        self.trace_file = sys.stderr

        # Dispatch tables
        self.soap_services = {\
                'Ns2Split': make_soap_handler(\
                        Ns2SplitRequestMessage.typecode,
                        getattr(self, "run_splitter"), 
                        Ns2SplitResponseMessage,
                        "Ns2SplitResponseBody"),
        }

        self.xmlrpc_services = {\
                'Ns2Split': make_xmlrpc_handler(\
                        getattr(self, "run_splitter"), 
                        "Ns2SplitResponseBody"),
        }

    def run_splitter(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.
        """
        try:
            tmpdir = tempfile.mkdtemp(prefix="split-")
        except IOError:
            raise service_error(service_error.internal, "Cannot create tmp dir")

        tclfile = tmpdir + "/experiment.tcl"
        pid = "dummy"
        gid = "dummy"

        req = req.get('Ns2SplitRequestBody', None)
        if not req:
            raise service_error(service_error.req,
                    "Bad request format (no Ns2SplitRequestBody)")
        # 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")

        master = req.get('master', None)
        if master == None:
            raise service_error(service_error.req, "No master testbed label")
        
        
        tclcmd = [self.tclsh, self.tcl_splitter, '-s', '-x', 
            str(self.muxmax), '-m', master, pid, gid, eid, tclfile]
        tclparser = Popen(tclcmd, stdout=PIPE)

        # Package up the split data
        for line in tclparser.stdout:
            out += line

        # 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)

        resp = { 'output' : out }

        return resp