Changeset 19cc408 for fedd

Timestamp:

Oct 3, 2008 4:46:21 PM (16 years ago)

Author:

Ted Faber <faber@…>

Branches:

axis_example, compt_changes, info-ops, master, version-1.30, version-2.00, version-3.01, version-3.02

Children:

ea0a821

Parents:

01073f7

Message:

refactoring

Location:

fedd

Files:

• fedd.py (modified) (6 diffs)
• fedd_access.py (added)
• fedd_access_project.py (added)
• fedd_allocate_project.py (modified) (1 diff)
• fedd_config_file.py (added)
• fedd_deter_impl.py (added)
• fedd_experiment_control.py (moved) (moved from fedd/fedd_create_experiment.py) (5 diffs)
• fedd_proj.py (deleted)
• fedd_util.py (modified) (1 diff)

fedd/fedd.py

@@ -15 +15 @@
 
 from fedd_util import fedd_ssl_context, fedid
-from fedd_proj import new_feddservice
+from fedd_deter_impl import new_feddservice
+from service_error import *
 
 # The SSL server here is based on the implementation described at
@@ -27 +28 @@
         SSLServer.__init__(self, ME, handler, ssl_ctx)
         self.impl = impl
+        self.soap_methods = impl.get_soap_services()
+        self.xmlrpc_methods = impl.get_xmlrpc_services()
 
 class fedd_soap_handler(BaseHTTPRequestHandler):
     server_version = "ZSI/2.0 fedd/0.1 " + BaseHTTPRequestHandler.server_version
-
 
     def send_xml(self, text, code=200):
@@ -80 +82 @@
         if not self.check_method(ps): return
         try:
-            resp = self.server.impl.soap_dispatch(ps.body_root.localName, ps,
+            resp = self.soap_dispatch(ps.body_root.localName, ps,
                     fedid(cert=self.request.get_peer_cert()))
         except Fault, f:
@@ -91 +93 @@
             self.send_xml(str(sw))
 
+    def soap_dispatch(self, method, req, fid):
+        if self.server.soap_methods.has_key(method):
+            try:
+                return self.server.soap_methods[method](req, fid)
+            except service_error, e:
+                de = ns0.faultType_Def(
+                        (ns0.faultType_Def.schema,
+                            "FeddFaultBody")).pyclass()
+                de._code=e.code
+                de._errstr=e.code_string()
+                de._desc=e.desc
+                if  e.is_server_error():
+                    raise Fault(Fault.Server, e.code_string(), detail=de)
+                else:
+                    raise Fault(Fault.Client, e.code_string(), detail=de)
+        else:
+            raise Fault(Fault.Client, "Unknown method: %s" % method)
+
+
 class fedd_xmlrpc_handler(BaseHTTPRequestHandler):
     server_version = "ZSI/2.0 fedd/0.1 " + BaseHTTPRequestHandler.server_version
@@ -120 +141 @@
         if method != None:
             try:
-                resp = self.server.impl.xmlrpc_dispatch(method, params,
+                resp = self.xmlrpc_dispatch(method, params,
                             fedid(cert=self.request.get_peer_cert()))
                 data = xmlrpclib.dumps((resp,), encoding='UTF-8', 
@@ -129 +150 @@
         self.send_xml(data)
 
+
+    def xmlrpc_dispatch(self, method, req, fid):
+        if self.server.xmlrpc_methods.has_key(method):
+            try:
+                return self.server.xmlrpc_methods[method](req, fid)
+            except service_error, e:
+                raise xmlrpclib.Fault(e.code_string(), e.desc)
+        else:
+            raise xmlrpclib.Fault(100, "Unknown method: %s" % method)
 
 class fedd_opts(OptionParser):

fedd/fedd_allocate_project.py

@@ -16 +16 @@
 import subprocess
 import tempfile
-import copy
 
 from fedd_services import *

fedd/fedd_experiment_control.py

@@ -29 +29 @@
 from service_error import *
 
-class fedd_create_experiment_local:
+class fedd_experiment_control_local:
     scripts = ["fed_bootstrap", "federate.sh", "smbmount.FreeBSD.pl",
         "smbmount.Linux.pl", "make_hosts", "fed-tun.pl", "fed-tun.ucb.pl",
         "fed_evrepeater", "rc.accounts.patch"]
     
-    def __init__(self, 
-            cert_file=None,
-            cert_pwd=None,
-            exp_stem="fed-stem",
-            debug=False,
-            muxmax=2,
-            nthreads=2,
-            randomize_experiments=False,
-            scp_exec="/usr/bin/scp",
-            scripts_dir="./", 
-            splitter=None,
-            ssh_exec="/usr/bin/ssh",
-            ssh_identity_file=None,
-            ssh_keygen="/usr/bin/ssh-keygen",
-            ssh_pubkey_file=None,
-            ssh_type="rsa",
-            tbmap=None,
-            tclsh="/usr/local/bin/otclsh",
-            tcl_splitter="/usr/testbed/lib/ns2ir/parse.tcl",
-            trace_file=None,
-            trusted_certs=None,
-            ):
-        self.scripts = fedd_create_experiment_local.scripts
-        self.thread_with_rv = fedd_create_experiment_local.pooled_thread
-        self.thread_pool = fedd_create_experiment_local.thread_pool
-
-        self.cert_file = cert_file
-        self.cert_pwd = cert_pwd
-        self.exp_stem = exp_stem
-        self.debug = debug
-        self.muxmax = muxmax
-        self.nthreads = nthreads
-        self.randomize_experiments = randomize_experiments
-        self.scp_exec = scp_exec
-        self.scripts_dir = scripts_dir
-        self.splitter = splitter
-        self.ssh_exec=ssh_exec
-        self.ssh_keygen = ssh_keygen
-        self.ssh_identity_file = ssh_identity_file
-        self.ssh_type = ssh_type
-        self.state = { }
-        self.tclsh = tclsh
-        self.tcl_splitter = tcl_splitter
-        self.tbmap = tbmap
-        self.trace_file = trace_file
-        self.trusted_certs=trusted_certs
-
-        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";
-
-
-        if ssh_pubkey_file:
-            try:
-                f = open(ssh_pubkey_file, 'r')
-                self.ssh_pubkey = f.read()
-                f.close()
-            except IOError:
-                raise service_error(service_error.internal,
-                        "Cannot read sshpubkey")
-
-        # Confirm federation scripts in the right place
-        for s in self.scripts:
-            if not os.path.exists(self.scripts_dir + "/" + s):
-                raise service_error(service_error.server_config,
-                        "%s/%s not in local script dir" % (self.scripts_dir, s))
     class thread_pool:
         def __init__(self):
@@ -139 +67 @@
             self.changed.notifyAll()
             self.changed.release()
-
-
 
     class pooled_thread(Thread):
@@ -177 +103 @@
             if self.pdata:
                 self.pdata.terminate()
+
+    def __init__(self, config=None):
+        self.scripts = fedd_experiment_control_local.scripts
+        self.thread_with_rv = fedd_experiment_control_local.pooled_thread
+        self.thread_pool = fedd_experiment_control_local.thread_pool
+
+        self.cert_file = None
+        self.cert_pwd = None
+        self.trusted_certs = None
+
+        if config.create_experiment_cert_file:
+            self.cert_file = config.create_experiment_cert_file
+            self.cert_pwd = config.create_experiment_cert_pwd
+        if config.create_experiment_trusted_certs:
+            self.trusted_certs = config.create_experiment_trusted_certs
+
+        if config.proxy_cert_file:
+            if not self.cert_file:
+                self.cert_file = config.proxy_cert_file
+                self.cert_pwd = config.proxy_cert_pwd
+        if config.proxy_trusted_certs:
+            if not self.trusted_certs:
+                self.trusted_certs = config.proxy_trusted_certs
+
+        if config.cert_file:
+            if not self.cert_file:
+                self.cert_file = config.cert_file
+                self.cert_pwd = config.cert_pwd
+        if config.trusted_certs:
+            if not self.trusted_certs:
+                self.trusted_certs = config.trusted_certs
+
+        self.exp_stem = "fed-stem"
+        self.debug = config.create_debug
+        self.muxmax = 2
+        self.nthreads = 2
+        self.randomize_experiments = False
+        self.scp_exec = "/usr/bin/scp"
+        self.scripts_dir = "/users/faber/testbed/federation"
+        self.splitter = None
+        self.ssh_exec="/usr/bin/ssh"
+        self.ssh_keygen = "/usr/bin/ssh-keygen"
+        self.ssh_identity_file = None
+        # XXX
+        self.ssh_pubkey_file = "/users/faber/.ssh/id_rsa.pub"
+        self.ssh_type = "rsa"
+        self.state = { }
+        self.tclsh = "/usr/local/bin/otclsh"
+        self.tcl_splitter = "/usr/testbed/lib/ns2ir/parse.tcl"
+        self.tbmap = { 
+                'deter':'https://users.isi.deterlab.net:23235',
+                'emulab':'https://users.isi.deterlab.net:23236',
+                'ucb':'https://users.isi.deterlab.net:23237',
+                }
+        self.trace_file = sys.stderr
+
+        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";
+
+
+        if self.ssh_pubkey_file:
+            try:
+                f = open(self.ssh_pubkey_file, 'r')
+                self.ssh_pubkey = f.read()
+                f.close()
+            except IOError:
+                raise service_error(service_error.internal,
+                        "Cannot read sshpubkey")
+
+        # Confirm federation scripts in the right place
+        for s in self.scripts:
+            if not os.path.exists(self.scripts_dir + "/" + s):
+                raise service_error(service_error.server_config,
+                        "%s/%s not in local script dir" % (self.scripts_dir, s))
+
+        self.soap_handlers = {\
+                'Create': make_soap_handler(\
+                        CreateRequestMessage.typecode,
+                        getattr(self, "create_experiment"), 
+                        CreateResponseMessage,
+                        "CreateResponseBody"),
+                'Vtopo': make_soap_handler(\
+                        VtopoRequestMessage.typecode,
+                        getattr(self, "get_vtopo"),
+                        VtopoResponseMessage,
+                        "VtopoResponseBody"),
+                'Vis': make_soap_handler(\
+                        VisRequestMessage.typecode,
+                        getattr(self, "get_vis"),
+                        VisResponseMessage,
+                        "VisResponseBody"),
+                'Info': make_soap_handler(\
+                        InfoRequestMessage.typecode,
+                        getattr(self, "get_info"),
+                        InfoResponseMessage,
+                        "InfoResponseBody"),
+                'Terminate': make_soap_handler(\
+                        TerminateRequestMessage.typecode,
+                        getattr(self, "terminate_experiment"),
+                        TerminateResponseMessage,
+                        "TerminateResponseBody"),
+        }
+
+        self.xmlrpc_handlers = {\
+                'Create': make_xmlrpc_handler(\
+                        getattr(self, "create_experiment"), 
+                        "CreateResponseBody"),
+                'Vtopo': make_xmlrpc_handler(\
+                        getattr(self, "get_vtopo"),
+                        "VtopoResponseBody"),
+                'Vis': make_xmlrpc_handler(\
+                        getattr(self, "get_vis"),
+                        "VisResponseBody"),
+                'Info': make_xmlrpc_handler(\
+                        getattr(self, "get_info"),
+                        "InfoResponseBody"),
+                'Terminate': make_xmlrpc_handler(\
+                        getattr(self, "terminate_experiment"),
+                        "TerminateResponseBody"),
+        }
+
+    def get_soap_services(self):
+        return self.soap_handlers
+
+    def get_xmlrpc_services(self):
+        return self.xmlrpc_handlers
 
     def copy_file(self, src, dest, size=1024):
@@ -650 +709 @@
         # No retry loop here.  Proxy servers must correctly authenticate
         # themselves without help
+
         try:
             ctx = fedd_ssl_context(self.cert_file, 
@@ -666 +726 @@
         msg.set_element_RequestAccessRequestBody(
                 pack_soap(msg, "RequestAccessRequestBody", req))
+
         try:
             resp = port.RequestAccess(msg)

fedd/fedd_util.py

@@ -329 +329 @@
         if keypath: os.remove(keypath)
         if certpath: os.remove(certpath)
+
+
+def make_soap_handler(typecode, method, constructor, body_name):
+    """
+    Generate the handler code to unpack and pack SOAP requests and responses
+    and call the given method.
+
+    The code to decapsulate and encapsulate parameters encoded in SOAP is the
+    same modulo a few parameters.  This is basically a stub compiler for
+    calling a fedd service trhough a soap interface.  The parameters are the
+    typecode of the request parameters, the method to call (usually a bound
+    instance of a method on a fedd service providing class), the constructor of
+    a response packet and the name of the body element of that packet.  The
+    handler takes a ParsedSoap object (the request) and returns an instance of
+    the class created by constructor containing the response.  Failures of the
+    constructor or badly created constructors will result in None being
+    returned.
+    """
+    def handler(ps, fid):
+        req = ps.Parse(typecode)
+
+        msg = method(unpack_soap(req), fedid)
+
+        resp = constructor()
+        set_element = getattr(resp, "set_element_%s" % body_name, None)
+        if set_element and callable(set_element):
+            try:
+                set_element(pack_soap(resp, body_name, msg))
+                return resp
+            except (NameError, TypeError):
+                return None
+        else:
+            return None
+
+    return handler
+
+def make_xmlrpc_handler(method, body_name, input_binaries=('fedid',), 
+        output_binaries=('fedid',)):
+    """
+    Generate the handler code to unpack and pack SOAP requests and responses
+    and call the given method.
+
+    The code to marshall and unmarshall XMLRPC parameters to and from a fedd
+    service is largely the same.  This helper creates such a handler.  The
+    parameters are the method name, the name of the body struct that contains
+    the response asn the list of fields that are encoded as Binary objects in
+    the input and in the output.  A handler is created that takes the params
+    response from an xm,lrpclib.loads on the incoming rpc and a fedid and
+    responds with a hash representing the struct ro be returned to the other
+    side.  On error None is returned.
+    """
+    def handler(params, fid):
+        p = decapsulate_binaries(params[0], input_binaries)
+        msg = method(p, fedid)
+
+        if msg != None:
+            return encapsulate_binaries({ body_name: msg }, output_binaries)
+        else:
+            return None
+
+    return handler