Context Navigation

-                      rc49d81b
+                      r16a23a6
     default_type = type_ssh
     def __init__(self, buf=None, type=None, file=None):
         self.buf = buf
         if type != None: self.type = type
         else: self.type = access_method.default_type
         if file != None:
             self.readfile(file)
+        self.buf = buf
+        if type != None: self.type = type
+        else: self.type = access_method.default_type
+        if file != None:
+            self.readfile(file)
     def readfile(self, file, type=None):
         f = open(file, "r")
         self.buf = f.read();
         f.close()
         if type == None:
             if self.type == None:
                 self.type = access_method.default_type
         else:
             self.type = type;
+        f = open(file, "r")
+        self.buf = f.read();
+        f.close()
+        if type == None:
+            if self.type == None:
+                self.type = access_method.default_type
+        else:
+            self.type = type;
 class node_desc:
     def __init__(self, image, hardware, count=1):
         if getattr(image, "__iter__", None) == None:
             if image == None: self.image = [ ]
             else: self.image = [ image ]
         else:
             self.image = image
         if getattr(hardware, "__iter__", None) == None:
             if hardware == None: self.hardware = [ ]
             else: self.hardware = [ hardware ]
         else:
             self.hardware = hardware
         if count != None: self.count = int(count)
         else: self.count = 1
+        if getattr(image, "__iter__", None) == None:
+            if image == None: self.image = [ ]
+            else: self.image = [ image ]
+        else:
+            self.image = image
+        if getattr(hardware, "__iter__", None) == None:
+            if hardware == None: self.hardware = [ ]
+            else: self.hardware = [ hardware ]
+        else:
+            self.hardware = hardware
+        if count != None: self.count = int(count)
+        else: self.count = 1
 class fedd_client_opts(OptionParser):
     """Encapsulate option processing in this class, rather than in main"""
     def __init__(self):
         OptionParser.__init__(self, usage="%prog [opts] (--help for details)",
                 version="0.1")
         self.add_option("-c","--cert", action="store", dest="cert",
                 type="string", help="my certificate file")
         self.add_option("-d", "--debug", action="count", dest="debug",
                 default=0, help="Set debug.  Repeat for more information")
         self.add_option("-s", "--serializeOnly", action="store_true",
                 dest="serialize_only", default=False,
                 help="Print the SOAP request that would be sent and exit")
         self.add_option("-T","--trusted", action="store", dest="trusted",
                 type="string", help="Trusted certificates (required)")
         self.add_option("-u", "--url", action="store", dest="url",
                 type="string",default="https://localhost:23235",
                 help="URL to connect to (default %default)")
         self.add_option("-x","--transport", action="store", type="choice",
                 choices=("xmlrpc", "soap"), default="soap",
                 help="Transport for request (xmlrpc|soap) (Default: %default)")
         self.add_option("--trace", action="store_const", dest="tracefile",
                 const=sys.stderr, help="Print SOAP exchange to stderr")
+        OptionParser.__init__(self, usage="%prog [opts] (--help for details)",
+                version="0.1")
+        self.add_option("-c","--cert", action="store", dest="cert",
+                type="string", help="my certificate file")
+        self.add_option("-d", "--debug", action="count", dest="debug",
+                default=0, help="Set debug.  Repeat for more information")
+        self.add_option("-s", "--serializeOnly", action="store_true",
+                dest="serialize_only", default=False,
+                help="Print the SOAP request that would be sent and exit")
+        self.add_option("-T","--trusted", action="store", dest="trusted",
+                type="string", help="Trusted certificates (required)")
+        self.add_option("-u", "--url", action="store", dest="url",
+                type="string",default="https://localhost:23235",
+                help="URL to connect to (default %default)")
+        self.add_option("-x","--transport", action="store", type="choice",
+                choices=("xmlrpc", "soap"), default="soap",
+                help="Transport for request (xmlrpc|soap) (Default: %default)")
+        self.add_option("--trace", action="store_const", dest="tracefile",
+                const=sys.stderr, help="Print SOAP exchange to stderr")
 class fedd_create_opts(fedd_client_opts):
     def __init__(self, access_keys, add_key_callback=None,
             add_cert_callback=None):
         fedd_client_opts.__init__(self)
         self.add_option("-e", "--experiment_cert", dest="out_certfile",
                 type="string", help="output certificate file")
         self.add_option("-E", "--experiment_name", dest="exp_name",
                 type="string", help="Suggested experiment name")
         self.add_option("-F","--useFedid", action="store_true",
                 dest="use_fedid", default=False,
                 help="Use a fedid derived from my certificate as user identity")
         self.add_option("-f", "--file", dest="file",
                 help="experiment description file")
         self.add_option("-p", "--project", action="store", dest="project",
                 type="string",
                 help="Project to export from master")
         if add_key_callback:
             self.add_option("-k", "--ssh_key", action="callback",
                     type="string", callback=add_key_callback,
                     callback_args=(access_keys,),
                     help="ssh key for access (can be supplied more than once")
         if add_cert_callback:
             self.add_option("-K", "--x509Key", action="callback",
                     type="string", callback=add_cert_callback,
                     callback_args=(access_keys,),
                     help="X509 certificate for access " + \
                         "(can be supplied more than once")
         self.add_option("-m", "--master", dest="master",
                 help="Master testbed in the federation")
         self.add_option("-U", "--username", action="store", dest="user",
                 type="string", help="Use this username instead of the uid")
+            add_cert_callback=None):
+        fedd_client_opts.__init__(self)
+        self.add_option("-e", "--experiment_cert", dest="out_certfile",
+                type="string", help="output certificate file")
+        self.add_option("-E", "--experiment_name", dest="exp_name",
+                type="string", help="Suggested experiment name")
+        self.add_option("-F","--useFedid", action="store_true",
+                dest="use_fedid", default=False,
+                help="Use a fedid derived from my certificate as user identity")
+        self.add_option("-f", "--file", dest="file",
+                help="experiment description file")
+        self.add_option("-p", "--project", action="store", dest="project",
+                type="string",
+                help="Project to export from master")
+        if add_key_callback:
+            self.add_option("-k", "--ssh_key", action="callback",
+                    type="string", callback=add_key_callback,
+                    callback_args=(access_keys,),
+                    help="ssh key for access (can be supplied more than once")
+        if add_cert_callback:
+            self.add_option("-K", "--x509Key", action="callback",
+                    type="string", callback=add_cert_callback,
+                    callback_args=(access_keys,),
+                    help="X509 certificate for access " + \
+                        "(can be supplied more than once")
+        self.add_option("-m", "--master", dest="master",
+                help="Master testbed in the federation")
+        self.add_option("-U", "--username", action="store", dest="user",
+                type="string", help="Use this username instead of the uid")
 class fedd_split_opts(fedd_create_opts):
     def __init__(self, access_keys, add_key_callback=None,
             add_cert_callback=None):
         fedd_create_opts.__init__(self, access_keys, add_key_callback,
                 add_cert_callback)
         self.add_option('-t','--fedkit', action='store_true', dest='fedkit',
                 default=False,
                 help="get output suitable for federation kit install")
         self.add_option('-G','--gatewaykit', action='store_true',
                 dest='gatewaykit', default=False,
                 help="get output suitable for federation gateway kit install")
+            add_cert_callback=None):
+        fedd_create_opts.__init__(self, access_keys, add_key_callback,
+                add_cert_callback)
+        self.add_option('-t','--fedkit', action='store_true', dest='fedkit',
+                default=False,
+                help="get output suitable for federation kit install")
+        self.add_option('-G','--gatewaykit', action='store_true',
+                dest='gatewaykit', default=False,
+                help="get output suitable for federation gateway kit install")
 class fedd_access_opts(fedd_create_opts):
     def __init__(self, access_keys, node_descs, add_key_callback=None,
             add_cert_callback=None, add_node_callback=None):
         fedd_create_opts.__init__(self, access_keys, add_key_callback,
                 add_cert_callback)
         self.add_option("-a","--anonymous", action="store_true",
                 dest="anonymous", default=False,
                 help="Do not include a user in the request")
         self.add_option("-l","--label", action="store", dest="label",
                 type="string", help="Label for output")
         if add_node_callback:
             self.add_option("-n", "--node", action="callback", type="string",
                     callback=add_node_callback, callback_args=(node_descs,),
                     help="Node description: image:hardware[:count]")
         self.add_option("-t", "--testbed", action="store", dest="testbed",
                 type="string",
                 help="Testbed identifier (URI) to contact (required)")
+            add_cert_callback=None, add_node_callback=None):
+        fedd_create_opts.__init__(self, access_keys, add_key_callback,
+                add_cert_callback)
+        self.add_option("-a","--anonymous", action="store_true",
+                dest="anonymous", default=False,
+                help="Do not include a user in the request")
+        self.add_option("-l","--label", action="store", dest="label",
+                type="string", help="Label for output")
+        if add_node_callback:
+            self.add_option("-n", "--node", action="callback", type="string",
+                    callback=add_node_callback, callback_args=(node_descs,),
+                    help="Node description: image:hardware[:count]")
+        self.add_option("-t", "--testbed", action="store", dest="testbed",
+                type="string",
+                help="Testbed identifier (URI) to contact (required)")
 class fedd_exp_data_opts(fedd_client_opts):
     def __init__(self):
         fedd_client_opts.__init__(self)
         self.add_option("-e", "--experiment_cert", dest="exp_certfile",
                 type="string", help="experiment certificate file")
         self.add_option("-E", "--experiment_name", dest="exp_name",
                 type="string", help="human readable experiment name")
         self.add_option("--data", dest="data", default=[],
                 action="append", type="choice",
                 choices=("id", "federant", "vtopo", "vis", "log", "status"),
                 help="data to extract")
+        fedd_client_opts.__init__(self)
+        self.add_option("-e", "--experiment_cert", dest="exp_certfile",
+                type="string", help="experiment certificate file")
+        self.add_option("-E", "--experiment_name", dest="exp_name",
+                type="string", help="human readable experiment name")
+        self.add_option("--data", dest="data", default=[],
+                action="append", type="choice",
+                choices=("id", "federant", "vtopo", "vis", "log", "status"),
+                help="data to extract")
 class fedd_terminate_opts(fedd_exp_data_opts):
     def __init__(self):
         fedd_exp_data_opts.__init__(self)
         self.add_option("--force", dest="force",
                 action="store_true", default=False,
                 help="Force termination if experiment is in strange state")
         self.add_option("--logfile", dest="logfile", default=None,
                 help="File to write log to")
         self.add_option("--print_log", dest="print_log", default=False,
                 action="store_true",
                 help="Print deallocation log to standard output")
+        fedd_exp_data_opts.__init__(self)
+        self.add_option("--force", dest="force",
+                action="store_true", default=False,
+                help="Force termination if experiment is in strange state")
+        self.add_option("--logfile", dest="logfile", default=None,
+                help="File to write log to")
+        self.add_option("--print_log", dest="print_log", default=False,
+                action="store_true",
+                help="Print deallocation log to standard output")
 class fedd_multi_exp_data_opts(fedd_client_opts):
     def __init__(self):
         fedd_client_opts.__init__(self)
         self.add_option("--data", dest="data", default=[],
                 action="append", type="choice",
                 choices=("id", "federant", "vtopo", "vis", "log", "status"),
                 help="data to extract")
+        fedd_client_opts.__init__(self)
+        self.add_option("--data", dest="data", default=[],
+                action="append", type="choice",
+                choices=("id", "federant", "vtopo", "vis", "log", "status"),
+                help="data to extract")
 class fedd_spew_opts(fedd_client_opts):
     def __init__(self):
         fedd_client_opts.__init__(self)
         self.add_option("-e", "--experiment_cert", dest="exp_certfile",
                 type="string", help="experiment name certificate file")
         self.add_option("-E", "--experiment_name", dest="exp_name",
                 type="string", help="human readable experiment name")
         self.add_option("--logfile", dest="logfile", default=None,
                 help="File to write log to")
         self.add_option('--update_time', dest='update', type='int', default=10,
                 help='how often to update the printed log')
+        fedd_client_opts.__init__(self)
+        self.add_option("-e", "--experiment_cert", dest="exp_certfile",
+                type="string", help="experiment name certificate file")
+        self.add_option("-E", "--experiment_name", dest="exp_name",
+                type="string", help="human readable experiment name")
+        self.add_option("--logfile", dest="logfile", default=None,
+                help="File to write log to")
+        self.add_option('--update_time', dest='update', type='int', default=10,
+                help='how often to update the printed log')
 class fedd_image_opts(fedd_exp_data_opts):
     def __init__(self):
         fedd_exp_data_opts.__init__(self)
         self.add_option("-o", "--output", dest="outfile", type="string",
                 help="output image file")
         self.add_option("-F", "--format", dest="format", type="choice",
                 choices=("jpg", "png", "dot", "svg"),
                 help="Output file format override")
         self.add_option("-P", "--program", dest="neato", default=None,
                 type="string",
                 help="Program compatible with dot (from graphviz) used to " + \
                         "render image")
         self.add_option('-L', "--labels", dest='labels', action='store_true',
                 default=True, help='Label nodes and edges')
         self.add_option('-A', "--no_labels", dest='labels',
                 default=True, action='store_false',
                 help='Label nodes and edges')
         self.add_option('-j','--pixels', dest="pixels", default=None,
                 type="int",
                 help="Size of output in pixels (diagrams are square")
+        fedd_exp_data_opts.__init__(self)
+        self.add_option("-o", "--output", dest="outfile", type="string",
+                help="output image file")
+        self.add_option("-F", "--format", dest="format", type="choice",
+                choices=("jpg", "png", "dot", "svg"),
+                help="Output file format override")
+        self.add_option("-P", "--program", dest="neato", default=None,
+                type="string",
+                help="Program compatible with dot (from graphviz) used to " + \
+                        "render image")
+        self.add_option('-L', "--labels", dest='labels', action='store_true',
+                default=True, help='Label nodes and edges')
+        self.add_option('-A', "--no_labels", dest='labels',
+                default=True, action='store_false',
+                help='Label nodes and edges')
+        self.add_option('-j','--pixels', dest="pixels", default=None,
+                type="int",
+                help="Size of output in pixels (diagrams are square")
 class fedd_ns_image_opts(fedd_split_opts):
     def __init__(self, access_keys, add_key_callback=None,
             add_cert_callback=None):
         fedd_split_opts.__init__(self, access_keys, add_key_callback,
                 add_cert_callback)
         self.add_option("-o", "--output", dest="outfile", type="string",
                 help="output image file")
         self.add_option("-Q", "--format", dest="format", type="choice",
                 choices=("jpg", "png", "dot", "svg"),
                 help="Output file format override")
         self.add_option("-P", "--program", dest="neato", default=None,
                 type="string",
                 help="Program compatible with dot (from graphviz) used to " + \
                         "render image")
         self.add_option('-L', "--labels", dest='labels', action='store_true',
                 default=True, help='Label nodes and edges')
         self.add_option('-A', "--no_labels", dest='labels',
                 default=True, action='store_false',
                 help='Label nodes and edges')
         self.add_option('-j','--pixels', dest="pixels", default=None,
                 type="int",
                 help="Size of output in pixels (diagrams are square")
+            add_cert_callback=None):
+        fedd_split_opts.__init__(self, access_keys, add_key_callback,
+                add_cert_callback)
+        self.add_option("-o", "--output", dest="outfile", type="string",
+                help="output image file")
+        self.add_option("-Q", "--format", dest="format", type="choice",
+                choices=("jpg", "png", "dot", "svg"),
+                help="Output file format override")
+        self.add_option("-P", "--program", dest="neato", default=None,
+                type="string",
+                help="Program compatible with dot (from graphviz) used to " + \
+                        "render image")
+        self.add_option('-L', "--labels", dest='labels', action='store_true',
+                default=True, help='Label nodes and edges')
+        self.add_option('-A', "--no_labels", dest='labels',
+                default=True, action='store_false',
+                help='Label nodes and edges')
+        self.add_option('-j','--pixels', dest="pixels", default=None,
+                type="int",
+                help="Size of output in pixels (diagrams are square")
 def exit_with_fault(dict, out=sys.stderr):
 …
     if dict.has_key('errstr'):
         codestr = "Error: %s" % dict['errstr']
+        codestr = "Error: %s" % dict['errstr']
     if dict.has_key('code'):
         if len(codestr) > 0 :
             codestr += " (%d)" % dict['code']
         else:
             codestr = "Error Code: %d" % dict['code']
+        if len(codestr) > 0 :
+            codestr += " (%d)" % dict['code']
+        else:
+            codestr = "Error Code: %d" % dict['code']
     print>>out, codestr
 …
 class fedd_rpc:
     class RPCException:
         def __init__(self, fb):
             self.desc = fb.get('desc', None)
             self.code = fb.get('code', -1)
             self.errstr = fb.get('errstr', None)
+        def __init__(self, fb):
+            self.desc = fb.get('desc', None)
+            self.code = fb.get('code', -1)
+            self.errstr = fb.get('errstr', None)
     def __init__(self, pre):
         """
         Specialize the class for the pre method
         """
         self.RequestBody="%sRequestBody" % pre
         self.ResponseBody="%sResponseBody" % pre
         self.method = pre
         self.caller = service_caller(self.method)
         self.RPCException = fedd_rpc.RPCException
+        """
+        Specialize the class for the pre method
+        """
+        self.RequestBody="%sRequestBody" % pre
+        self.ResponseBody="%sResponseBody" % pre
+        self.method = pre
+        self.caller = service_caller(self.method)
+        self.RPCException = fedd_rpc.RPCException
     def add_ssh_key(self, option, opt_str, value, parser, access_keys):
         try:
             access_keys.append(access_method(file=value,
                 type=access_method.type_ssh))
         except IOError, (errno, strerror):
             raise OptionValueError("Cannot generate sshPubkey from %s: "\
                     "%s (%d)" % (value,strerror,errno))
+        try:
+            access_keys.append(access_method(file=value,
+                type=access_method.type_ssh))
+        except IOError, (errno, strerror):
+            raise OptionValueError("Cannot generate sshPubkey from %s: "\
+                    "%s (%d)" % (value,strerror,errno))
     def add_x509_cert(self, option, opt_str, value, parser, access_keys):
         try:
             access_keys.append(access_method(file=value,
                 type=access_method.type_x509))
         except IOError, (errno, strerror):
             raise OptionValueError("Cannot read x509 cert from %s: %s (%d)" %
                     (value,strerror,errno))
+        try:
+            access_keys.append(access_method(file=value,
+                type=access_method.type_x509))
+        except IOError, (errno, strerror):
+            raise OptionValueError("Cannot read x509 cert from %s: %s (%d)" %
+                    (value,strerror,errno))
     def add_node_desc(self, option, opt_str, value, parser, node_descs):
         def none_if_zero(x):
             if len(x) > 0: return x
             else: return None
         params = map(none_if_zero, value.split(":"));
         if len(params) < 4 and len(params) > 1:
             node_descs.append(node_desc(*params))
         else:
             raise OptionValueError("Bad node description: %s" % value)
+        def none_if_zero(x):
+            if len(x) > 0: return x
+            else: return None
+        params = map(none_if_zero, value.split(":"));
+        if len(params) < 4 and len(params) > 1:
+            node_descs.append(node_desc(*params))
+        else:
+            raise OptionValueError("Bad node description: %s" % value)
     def get_user_info(self, access_keys):
         pw = pwd.getpwuid(os.getuid());
         try_cert=None
         user = None
         if pw != None:
             user = pw[0]
             try_cert = "%s/.ssl/emulab.pem" % pw[5];
             if not os.access(try_cert, os.R_OK):
                 try_cert = None
             if len(access_keys) == 0:
                 for k in ["%s/.ssh/id_rsa.pub", "%s/.ssh/id_dsa.pub",
                         "%s/.ssh/identity.pub"]:
                     try_key = k % pw[5];
                     if os.access(try_key, os.R_OK):
                         access_keys.append(access_method(file=try_key,
                             type=access_method.type_ssh))
                         break
         return (user, try_cert)
+        pw = pwd.getpwuid(os.getuid());
+        try_cert=None
+        user = None
+        if pw != None:
+            user = pw[0]
+            try_cert = "%s/.ssl/emulab.pem" % pw[5];
+            if not os.access(try_cert, os.R_OK):
+                try_cert = None
+            if len(access_keys) == 0:
+                for k in ["%s/.ssh/id_rsa.pub", "%s/.ssh/id_dsa.pub",
+                        "%s/.ssh/identity.pub"]:
+                    try_key = k % pw[5];
+                    if os.access(try_key, os.R_OK):
+                        access_keys.append(access_method(file=try_key,
+                            type=access_method.type_ssh))
+                        break
+        return (user, try_cert)
     def do_rpc(self, req_dict, url, transport, cert, trusted, tracefile=None,
             serialize_only=False):
         """
         The work of sending and parsing the RPC as either XMLRPC or SOAP
         """
         context = None
         while context == None:
             try:
                 context = fedd_ssl_context(cert, trusted)
             except Exception, e:
                 # Yes, doing this on message type is not ideal.  The string
                 # comes from OpenSSL, so check there is this stops working.
                 if str(e) == "bad decrypt":
                     print >>sys.stderr, "Bad Passphrase given."
                 else: raise
         if transport == "soap":
             if serialize_only:
                 print self.caller.serialize_soap(req_dict)
                 sys.exit(0)
             else:
                 try:
                     resp = self.caller.call_soap_service(url, req_dict,
                             context=context, tracefile=tracefile)
                 except service_error, e:
                     raise self.RPCException( {\
                             'code': e.code,
                             'desc': e.desc,
                             'errstr': e.code_string()\
                         })
         elif transport == "xmlrpc":
             if serialize_only:
                 ser = dumps((req_dict,))
                 print ser
                 sys.exit(0)
             else:
                 try:
                     resp = self.caller.call_xmlrpc_service(url, req_dict,
                             context=context, tracefile=tracefile)
                 except service_error, e:
                     raise self.RPCException( {\
                             'code': e.code,
                             'desc': e.desc,
                             'errstr': e.code_string()\
                         })
         else:
             raise RuntimeError("Unknown RPC transport: %s" % transport)
         if resp.has_key(self.ResponseBody):
             return resp[self.ResponseBody]
         else:
             raise RuntimeError("No body in response??")
+            serialize_only=False):
+        """
+        The work of sending and parsing the RPC as either XMLRPC or SOAP
+        """
+        context = None
+        while context == None:
+            try:
+                context = fedd_ssl_context(cert, trusted)
+            except Exception, e:
+                # Yes, doing this on message type is not ideal.  The string
+                # comes from OpenSSL, so check there is this stops working.
+                if str(e) == "bad decrypt":
+                    print >>sys.stderr, "Bad Passphrase given."
+                else: raise
+        if transport == "soap":
+            if serialize_only:
+                print self.caller.serialize_soap(req_dict)
+                sys.exit(0)
+            else:
+                try:
+                    resp = self.caller.call_soap_service(url, req_dict,
+                            context=context, tracefile=tracefile)
+                except service_error, e:
+                    raise self.RPCException( {\
+                            'code': e.code,
+                            'desc': e.desc,
+                            'errstr': e.code_string()\
+                        })
+        elif transport == "xmlrpc":
+            if serialize_only:
+                ser = dumps((req_dict,))
+                print ser
+                sys.exit(0)
+            else:
+                try:
+                    resp = self.caller.call_xmlrpc_service(url, req_dict,
+                            context=context, tracefile=tracefile)
+                except service_error, e:
+                    raise self.RPCException( {\
+                            'code': e.code,
+                            'desc': e.desc,
+                            'errstr': e.code_string()\
+                        })
+        else:
+            raise RuntimeError("Unknown RPC transport: %s" % transport)
+        if resp.has_key(self.ResponseBody):
+            return resp[self.ResponseBody]
+        else:
+            raise RuntimeError("No body in response??")
 class exp_data_base(fedd_rpc):
     def __init__(self, op='Info'):
         """
         Init the various conversions
         """
         fedd_rpc.__init__(self, op)
         # List of things one could ask for and what formatting routine is
         # called.
         self.params = {
                 'vis': ('vis', self.print_xml('vis')),
                 'vtopo': ('vtopo', self.print_xml('vtopo')),
                 'federant': ('federant', self.print_xml),
                 'id': ('experimentID', self.print_id),
                 'status': ('experimentStatus', self.print_string),
                 'log': ('allocationLog', self.print_string),
                 'access': ('experimentAccess', self.print_string),
+            }
+        """
+        Init the various conversions
+        """
+        fedd_rpc.__init__(self, op)
+        # List of things one could ask for and what formatting routine is
+        # called.
+        self.params = {
+                'vis': ('vis', self.print_xml('vis')),
+                'vtopo': ('vtopo', self.print_xml('vtopo')),
+                'federant': ('federant', self.print_xml),
+                'id': ('experimentID', self.print_id),
+                'status': ('experimentStatus', self.print_string),
+                'log': ('allocationLog', self.print_string),
+                'access': ('experimentAccess', self.print_string),
+            }
     # Utility functions
     def print_string(self, d, out=sys.stdout):
         print >>out, d
+        print >>out, d
     def print_id(self, d, out=sys.stdout):
         if d:
             for id in d:
                 for k in id.keys():
                     print >>out, "%s: %s" % (k, id[k])
+        if d:
+            for id in d:
+                for k in id.keys():
+                    print >>out, "%s: %s" % (k, id[k])
     class print_xml:
         """
         Print the retrieved data is a simple xml representation of the dict.
         """
         def __init__(self, top):
             self.xml = top
         def __call__(self, d, out=sys.stdout):
             str = "<%s>\n" % self.xml
             for t in ('node', 'lan'):
                 if d.has_key(t):
                     for x in d[t]:
                         str += "<%s>" % t
                         for k in x.keys():
                             str += "<%s>%s</%s>" % (k, x[k],k)
                         str += "</%s>\n" % t
             str+= "</%s>" % self.xml
             print >>out, str
+        """
+        Print the retrieved data is a simple xml representation of the dict.
+        """
+        def __init__(self, top):
+            self.xml = top
+        def __call__(self, d, out=sys.stdout):
+            str = "<%s>\n" % self.xml
+            for t in ('node', 'lan'):
+                if d.has_key(t):
+                    for x in d[t]:
+                        str += "<%s>" % t
+                        for k in x.keys():
+                            str += "<%s>%s</%s>" % (k, x[k],k)
+                        str += "</%s>\n" % t
+            str+= "</%s>" % self.xml
+            print >>out, str
 # Querying experiment data follows the same control flow regardless of the
 …
 class exp_data(exp_data_base):
     def __init__(self):
         exp_data_base.__init__(self, 'Info')
+        exp_data_base.__init__(self, 'Info')
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_exp_data_opts()
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.exp_name and opts.exp_certfile:
             sys.exit("Only one of --experiment_cert and " +\
                     "--experiment_name permitted");
         if opts.exp_certfile:
             exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
         if opts.exp_name:
             exp_id = { 'localname' : opts.exp_name }
         req = { 'experiment': exp_id }
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         for d in opts.data:
             key, output = self.params[d]
             try:
                 if resp_dict.has_key(key):
                     output(resp_dict[key])
             except RuntimeError, e:
                 sys.exit("Bad response. %s" % e.message)
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_exp_data_opts()
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.exp_name and opts.exp_certfile:
+            sys.exit("Only one of --experiment_cert and " +\
+                    "--experiment_name permitted");
+        if opts.exp_certfile:
+            exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
+        if opts.exp_name:
+            exp_id = { 'localname' : opts.exp_name }
+        req = { 'experiment': exp_id }
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        for d in opts.data:
+            key, output = self.params[d]
+            try:
+                if resp_dict.has_key(key):
+                    output(resp_dict[key])
+            except RuntimeError, e:
+                sys.exit("Bad response. %s" % e.message)
 class vtopo(exp_data):
 …
     """
     def __init__(self):
         exp_data.__init__(self)
+        exp_data.__init__(self)
     def __call__(self):
         sys.argv.append('--data=vtopo')
         exp_data.__call__(self)
+        sys.argv.append('--data=vtopo')
+        exp_data.__call__(self)
 …
     """
     def __init__(self):
         exp_data.__init__(self)
+        exp_data.__init__(self)
     def __call__(self):
         sys.argv.append('--data=vis')
         exp_data.__call__(self)
+        sys.argv.append('--data=vis')
+        exp_data.__call__(self)
 class status(exp_data):
 …
     """
     def __init__(self):
         exp_data.__init__(self)
+        exp_data.__init__(self)
     def __call__(self):
         sys.argv.append('--data=status')
         exp_data.__call__(self)
+        sys.argv.append('--data=status')
+        exp_data.__call__(self)
 class multi_exp_data(exp_data_base):
     def __init__(self):
         exp_data_base.__init__(self, 'MultiInfo')
+        exp_data_base.__init__(self, 'MultiInfo')
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_multi_exp_data_opts()
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         req = { }
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         exps = resp_dict.get('info', [])
         if exps:
             print '---'
             for exp in exps:
                 for d in opts.data:
                     key, output = self.params[d]
                     try:
                         if exp.has_key(key):
                             output(exp[key])
                     except RuntimeError, e:
                         sys.exit("Bad response. %s" % e.message)
                 print '---'
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_multi_exp_data_opts()
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        req = { }
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        exps = resp_dict.get('info', [])
+        if exps:
+            print '---'
+            for exp in exps:
+                for d in opts.data:
+                    key, output = self.params[d]
+                    try:
+                        if exp.has_key(key):
+                            output(exp[key])
+                    except RuntimeError, e:
+                        sys.exit("Bad response. %s" % e.message)
+                print '---'
 class multi_status(exp_data_base):
     def __init__(self):
         exp_data_base.__init__(self, 'MultiInfo')
+        exp_data_base.__init__(self, 'MultiInfo')
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_client_opts()
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         req = { }
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         for exp in resp_dict.get('info', []):
             out = []
             for eid in exp.get('experimentID', []):
                 if eid.has_key('localname'):
                     out.append(eid['localname'])
                     break
             else:
                 out.append("")
             for eid in exp.get('experimentID', []):
                 if eid.has_key('fedid'):
                     out.append("%s" % eid['fedid'])
                     break
             else:
                 out.append("")
             out.append(exp.get('experimentStatus', ""))
             for f in exp.get('federant', []):
                 if f.get('master', False):
                     em = f.get('emulab', None)
                     if em:
                         project = em.get('project', None)
                         if project:
                             tb = project.get('testbed', None)
                             if tb and tb.has_key('localname'):
                                 out.append(tb['localname'])
                             else:
                                 out.append("")
                             pn = project.get('name', None)
                             if pn and pn.has_key('localname'):
                                 out.append(pn['localname'])
                             else:
                                 out.append("")
                         else:
                             out.extend(("", ""))
                     else:
                         out.extend(("", ""))
                     break
             else:
                 out.extend(("",""))
             print ":".join(out)
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_client_opts()
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        req = { }
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        for exp in resp_dict.get('info', []):
+            out = []
+            for eid in exp.get('experimentID', []):
+                if eid.has_key('localname'):
+                    out.append(eid['localname'])
+                    break
+            else:
+                out.append("")
+            for eid in exp.get('experimentID', []):
+                if eid.has_key('fedid'):
+                    out.append("%s" % eid['fedid'])
+                    break
+            else:
+                out.append("")
+            out.append(exp.get('experimentStatus', ""))
+            for f in exp.get('federant', []):
+                if f.get('master', False):
+                    em = f.get('emulab', None)
+                    if em:
+                        project = em.get('project', None)
+                        if project:
+                            tb = project.get('testbed', None)
+                            if tb and tb.has_key('localname'):
+                                out.append(tb['localname'])
+                            else:
+                                out.append("")
+                            pn = project.get('name', None)
+                            if pn and pn.has_key('localname'):
+                                out.append(pn['localname'])
+                            else:
+                                out.append("")
+                        else:
+                            out.extend(("", ""))
+                    else:
+                        out.extend(("", ""))
+                    break
+            else:
+                out.extend(("",""))
+            print ":".join(out)
 class image(fedd_rpc):
     def __init__(self, op='Vtopo'):
         """
         Null constructor
         """
         fedd_rpc.__init__(self, op)
+        """
+        Null constructor
+        """
+        fedd_rpc.__init__(self, op)
     @staticmethod
     def gen_dot_topo(d, labels, dotfile):
         lans = { }
         links = { }
         for n in d.get('node', []):
             print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n['vname']
             print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
         # Collect lan members (we have to draw extra stuff for these)
         for n in d.get('lan', []):
             v = n['vname']
             m = n['member']
             i = n['ip']
             if m.find(':') != -1:
                 m = m[0:m.find(':')]
             if lans.has_key(v):
                 lans[v].append((m, i))
             elif links.has_key(v):
                 links[v].append((m, i))
                 if len(links[v]) > 2:
                     lans[v] = links[v]
                     del links[v]
             else:
                 links[v] = [(m, i)]
         # Encode the lans and the links
         for l in lans.keys():
             print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l
             print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
             for n in lans[l]:
                 if labels:
                     print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
                             (l, n[0], n[1])
                 else:
                     print >>dotfile, '\t"%s" -- "%s"' % (l, n[0])
         for k, l in links.items():
             if len(l) == 2:
                 if labels:
                     print >>dotfile, \
                             ('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
                             'headlabel="%s"]') % \
                             (l[0][0], l[1][0], k, l[0][1], l[1][1])
                 else:
                     print >>dotfile, '\t"%s" -- "%s" ' % (l[0][0], l[1][0])
+        lans = { }
+        links = { }
+        for n in d.get('node', []):
+            print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n['vname']
+            print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
+        # Collect lan members (we have to draw extra stuff for these)
+        for n in d.get('lan', []):
+            v = n['vname']
+            m = n['member']
+            i = n['ip']
+            if m.find(':') != -1:
+                m = m[0:m.find(':')]
+            if lans.has_key(v):
+                lans[v].append((m, i))
+            elif links.has_key(v):
+                links[v].append((m, i))
+                if len(links[v]) > 2:
+                    lans[v] = links[v]
+                    del links[v]
+            else:
+                links[v] = [(m, i)]
+        # Encode the lans and the links
+        for l in lans.keys():
+            print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l
+            print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
+            for n in lans[l]:
+                if labels:
+                    print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
+                            (l, n[0], n[1])
+                else:
+                    print >>dotfile, '\t"%s" -- "%s"' % (l, n[0])
+        for k, l in links.items():
+            if len(l) == 2:
+                if labels:
+                    print >>dotfile, \
+                            ('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
+                            'headlabel="%s"]') % \
+                            (l[0][0], l[1][0], k, l[0][1], l[1][1])
+                else:
+                    print >>dotfile, '\t"%s" -- "%s" ' % (l[0][0], l[1][0])
     def gen_image(self, d, nodes, file, fmt, neato, labels, pix=None):
         # Open up a temporary file for dot to turn into a visualization
         try:
             df, dotname = tempfile.mkstemp(prefix='fedd_client', suffix=".dot")
             dotfile = os.fdopen(df, 'w')
         except IOError:
             raise service_error(service_error.internal,
                     "Failed to open file in genviz")
         if not neato:
             for f in ['/usr/bin/neato', '/usr/local/bin/neato',
                     '/usr/bin/dot', '/usr/local/bin/dot']:
                 if os.access(f, os.X_OK):
                     neato = f
                     break
             else:
                 sys.exit("Cannot find graph rendering program")
         cmd = [neato, '-Gsplines=true']
         if fmt != 'dot': cmd.append('-T%s' % fmt)
         if file:
             cmd.append('-o')
             cmd.append(file)
         cmd.append(dotname)
         #nodes = d.get('node',[])
         if nodes < 10: size = 5
         elif nodes < 50: size = 10
         else: size = 18
         if pix:
             dpi = pix / size
         else:
             dpi = None
         print >>dotfile, "graph G {"
         if dpi:
             print >>dotfile, '\tgraph [size="%i,%i", dpi="%i", ratio=fill];' \
                     % (size, size, dpi)
         else:
             print >>dotfile, '\tgraph [size="%i,%i", ratio=fill];' \
                     % (size, size)
         if labels:
             print >>dotfile, '\tnode [fontname=arial,fontsize=9,label="\N"];'
             print >>dotfile, '\tedge [fontname=arial,fontsize=9];\n'
         else:
             print >>dotfile, '\tnode [label=""];'
         self.gen_dot_topo(d, labels, dotfile)
         print >>dotfile, "}"
         dotfile.close()
         # Redirect the drawing program stderr
         dev_null = open("/dev/null", "w")
         rv = subprocess.call(cmd, stderr=dev_null)
         os.remove(dotname)
         dev_null.close()
         if rv != 0:
             sys.exit("Error creating graph")
+        # Open up a temporary file for dot to turn into a visualization
+        try:
+            df, dotname = tempfile.mkstemp(prefix='fedd_client', suffix=".dot")
+            dotfile = os.fdopen(df, 'w')
+        except IOError:
+            raise service_error(service_error.internal,
+                    "Failed to open file in genviz")
+        if not neato:
+            for f in ['/usr/bin/neato', '/usr/local/bin/neato',
+                    '/usr/bin/dot', '/usr/local/bin/dot']:
+                if os.access(f, os.X_OK):
+                    neato = f
+                    break
+            else:
+                sys.exit("Cannot find graph rendering program")
+        cmd = [neato, '-Gsplines=true']
+        if fmt != 'dot': cmd.append('-T%s' % fmt)
+        if file:
+            cmd.append('-o')
+            cmd.append(file)
+        cmd.append(dotname)
+        #nodes = d.get('node',[])
+        if nodes < 10: size = 5
+        elif nodes < 50: size = 10
+        else: size = 18
+        if pix:
+            dpi = pix / size
+        else:
+            dpi = None
+        print >>dotfile, "graph G {"
+        if dpi:
+            print >>dotfile, '\tgraph [size="%i,%i", dpi="%i", ratio=fill];' \
+                    % (size, size, dpi)
+        else:
+            print >>dotfile, '\tgraph [size="%i,%i", ratio=fill];' \
+                    % (size, size)
+        if labels:
+            print >>dotfile, '\tnode [fontname=arial,fontsize=9,label="\N"];'
+            print >>dotfile, '\tedge [fontname=arial,fontsize=9];\n'
+        else:
+            print >>dotfile, '\tnode [label=""];'
+        self.gen_dot_topo(d, labels, dotfile)
+        print >>dotfile, "}"
+        dotfile.close()
+        # Redirect the drawing program stderr
+        dev_null = open("/dev/null", "w")
+        rv = subprocess.call(cmd, stderr=dev_null)
+        os.remove(dotname)
+        dev_null.close()
+        if rv != 0:
+            sys.exit("Error creating graph")
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_image_opts()
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.exp_name and opts.exp_certfile:
             sys.exit("Only one of --experiment_cert and " +\
                     "--experiment_name permitted");
         if opts.exp_certfile:
             exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
         if opts.exp_name:
             exp_id = { 'localname' : opts.exp_name }
         if opts.format and opts.outfile:
             fmt = opts.format
             file = opts.outfile
         elif not opts.format and opts.outfile:
             fmt = opts.outfile[-3:]
             if fmt not in ("png", "jpg", "dot", "svg"):
                 sys.exit("Unexpected file type and no format specified")
             file = opts.outfile
         elif opts.format and not opts.outfile:
             fmt = opts.format
             file = None
         else:
             fmt="dot"
             file = None
         req = { 'experiment': exp_id }
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         if resp_dict.has_key('vtopo'):
             self.gen_image(resp_dict['vtopo'],
                     len(resp_dict['vtopo'].get('node', [])),
                     file, fmt, opts.neato, opts.labels, opts.pixels)
         else:
             sys.exit("Bad response. %s" % e.message)
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_image_opts()
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.exp_name and opts.exp_certfile:
+            sys.exit("Only one of --experiment_cert and " +\
+                    "--experiment_name permitted");
+        if opts.exp_certfile:
+            exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
+        if opts.exp_name:
+            exp_id = { 'localname' : opts.exp_name }
+        if opts.format and opts.outfile:
+            fmt = opts.format
+            file = opts.outfile
+        elif not opts.format and opts.outfile:
+            fmt = opts.outfile[-3:]
+            if fmt not in ("png", "jpg", "dot", "svg"):
+                sys.exit("Unexpected file type and no format specified")
+            file = opts.outfile
+        elif opts.format and not opts.outfile:
+            fmt = opts.format
+            file = None
+        else:
+            fmt="dot"
+            file = None
+        req = { 'experiment': exp_id }
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        if resp_dict.has_key('vtopo'):
+            self.gen_image(resp_dict['vtopo'],
+                    len(resp_dict['vtopo'].get('node', [])),
+                    file, fmt, opts.neato, opts.labels, opts.pixels)
+        else:
+            sys.exit("Bad response. %s" % e.message)
 class ns_image(image):
     def __init__(self, op='Ns2Split'):
         """
         Null constructor
         """
         image.__init__(self, 'Ns2Split')
+        """
+        Null constructor
+        """
+        image.__init__(self, 'Ns2Split')
     def generate_topo_dict(self, splitout):
         class topo_parse:
             """
             Parse the topology XML and create the dats structure.  This class
             is copied from federation.experiment_control.
             """
             def __init__(self):
                 # Typing of the subelements for data conversion
                 self.str_subelements = ('vname', 'vnode', 'ips', 'ip', 'member')
                 self.int_subelements = ( 'bandwidth',)
                 self.float_subelements = ( 'delay',)
                 # The final data structure
                 self.nodes = [ ]
                 self.lans =  [ ]
                 self.topo = { \
                         'node': self.nodes,\
                         'lan' : self.lans,\
+                    }
                 self.element = { }  # Current element being created
                 self.chars = ""     # Last text seen
             def end_element(self, name):
                 # After each sub element the contents is added to the current
                 # element or to the appropriate list.
                 if name == 'node':
                     self.nodes.append(self.element)
                     self.element = { }
                 elif name == 'lan':
                     self.lans.append(self.element)
                     self.element = { }
                 elif name in self.str_subelements:
                     self.element[name] = self.chars
                     self.chars = ""
                 elif name in self.int_subelements:
                     self.element[name] = int(self.chars)
                     self.chars = ""
                 elif name in self.float_subelements:
                     self.element[name] = float(self.chars)
                     self.chars = ""
             def found_chars(self, data):
                 self.chars += data.rstrip()
         tp = topo_parse();
         parser = xml.parsers.expat.ParserCreate()
         parser.EndElementHandler = tp.end_element
         parser.CharacterDataHandler = tp.found_chars
         m = re.search('^#\s+Begin\s+Vtopo\s*$(.*)^#\s+End\s+Vtopo', splitout,
                 re.MULTILINE | re.DOTALL)
         if m:
             str = m.group(1)
         else:
             sys.exit("Badly formatted split")
         parser.Parse(str)
         return tp.topo
+        class topo_parse:
+            """
+            Parse the topology XML and create the dats structure.  This class
+            is copied from federation.experiment_control.
+            """
+            def __init__(self):
+                # Typing of the subelements for data conversion
+                self.str_subelements = ('vname', 'vnode', 'ips', 'ip', 'member')
+                self.int_subelements = ( 'bandwidth',)
+                self.float_subelements = ( 'delay',)
+                # The final data structure
+                self.nodes = [ ]
+                self.lans =  [ ]
+                self.topo = { \
+                        'node': self.nodes,\
+                        'lan' : self.lans,\
+                    }
+                self.element = { }  # Current element being created
+                self.chars = ""     # Last text seen
+            def end_element(self, name):
+                # After each sub element the contents is added to the current
+                # element or to the appropriate list.
+                if name == 'node':
+                    self.nodes.append(self.element)
+                    self.element = { }
+                elif name == 'lan':
+                    self.lans.append(self.element)
+                    self.element = { }
+                elif name in self.str_subelements:
+                    self.element[name] = self.chars
+                    self.chars = ""
+                elif name in self.int_subelements:
+                    self.element[name] = int(self.chars)
+                    self.chars = ""
+                elif name in self.float_subelements:
+                    self.element[name] = float(self.chars)
+                    self.chars = ""
+            def found_chars(self, data):
+                self.chars += data.rstrip()
+        tp = topo_parse();
+        parser = xml.parsers.expat.ParserCreate()
+        parser.EndElementHandler = tp.end_element
+        parser.CharacterDataHandler = tp.found_chars
+        m = re.search('^#\s+Begin\s+Vtopo\s*$(.*)^#\s+End\s+Vtopo', splitout,
+                re.MULTILINE | re.DOTALL)
+        if m:
+            str = m.group(1)
+        else:
+            sys.exit("Badly formatted split")
+        parser.Parse(str)
+        return tp.topo
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         access_keys = []
         # Process the options using the customized option parser defined above
         parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
                 self.add_x509_cert)
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.file:
             exp_desc = ""
             try:
                 f = open(opts.file, 'r')
                 for line in f:
                     exp_desc += line
                 f.close()
             except IOError:
                 sys.exit("Cannot read description file (%s)" %opts.file)
         else:
             sys.exit("Must specify an experiment description (--file)")
         if not opts.master:
             opts.master="dummy"
         req = {
                 'description': { 'ns2description': exp_desc },
                 'master': opts.master,
                 'include_fedkit': opts.fedkit,
                 'include_gatewaykit': opts.gatewaykit,
+                }
         if opts.format and opts.outfile:
             fmt = opts.format
             file = opts.outfile
         elif not opts.format and opts.outfile:
             fmt = opts.outfile[-3:]
             if fmt not in ("png", "jpg", "dot", "svg"):
                 sys.exit("Unexpected file type and no format specified")
             file = opts.outfile
         elif opts.format and not opts.outfile:
             fmt = opts.format
             file = None
         else:
             fmt="dot"
             file = None
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         if resp_dict.has_key('output'):
             if len(resp_dict['output']) < 1:
                 sys.exit("Bad response: could not split")
             topo = self.generate_topo_dict(resp_dict['output'])
             self.gen_image(topo, len(topo.get('node', [])), file, fmt,
                     opts.neato, opts.labels, opts.pixels)
         else:
             sys.exit("Bad response. %s" % e.message)
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        access_keys = []
+        # Process the options using the customized option parser defined above
+        parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
+                self.add_x509_cert)
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.file:
+            exp_desc = ""
+            try:
+                f = open(opts.file, 'r')
+                for line in f:
+                    exp_desc += line
+                f.close()
+            except IOError:
+                sys.exit("Cannot read description file (%s)" %opts.file)
+        else:
+            sys.exit("Must specify an experiment description (--file)")
+        if not opts.master:
+            opts.master="dummy"
+        req = {
+                'description': { 'ns2description': exp_desc },
+                'master': opts.master,
+                'include_fedkit': opts.fedkit,
+                'include_gatewaykit': opts.gatewaykit,
+                }
+        if opts.format and opts.outfile:
+            fmt = opts.format
+            file = opts.outfile
+        elif not opts.format and opts.outfile:
+            fmt = opts.outfile[-3:]
+            if fmt not in ("png", "jpg", "dot", "svg"):
+                sys.exit("Unexpected file type and no format specified")
+            file = opts.outfile
+        elif opts.format and not opts.outfile:
+            fmt = opts.format
+            file = None
+        else:
+            fmt="dot"
+            file = None
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        if resp_dict.has_key('output'):
+            if len(resp_dict['output']) < 1:
+                sys.exit("Bad response: could not split")
+            topo = self.generate_topo_dict(resp_dict['output'])
+            self.gen_image(topo, len(topo.get('node', [])), file, fmt,
+                    opts.neato, opts.labels, opts.pixels)
+        else:
+            sys.exit("Bad response. %s" % e.message)
 class topdl_image(image):
     def __init__(self, op='Ns2Split'):
         """
         Null constructor
         """
         image.__init__(self, 'Ns2Split')
+        """
+        Null constructor
+        """
+        image.__init__(self, 'Ns2Split')
     @staticmethod
     def gen_dot_topo(t, labels, dotfile):
         lans = [ s for s in t.substrates if len(s.interfaces) != 2]
         links = [ s for s in t.substrates if len(s.interfaces) == 2]
         i = 0
         for n in t.elements:
             if n.name:
                 print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n.name[0]
             else:
                 print >>dotfile, \
                         '\t"unnamed_node%d" [shape=box,style=filled,\\' % i
                 i += 1
             print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
         # Encode the lans and the links
         for l in lans:
             print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l.name
             print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
             for i in l.interfaces:
                 ip = i.get_attribute('ip4_address')
                 if labels and ip:
                     print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
                             (l.name, i.element.name[0], ip)
                 else:
                     print >>dotfile, '\t"%s" -- "%s"' % \
                             (l.name, i.element.name[0])
         for l in links:
             s, d = l.interfaces[0:2]
             sip = s.get_attribute('ip4_address')
             dip = d.get_attribute('ip4_address')
             if labels and sip and dip:
                 print >>dotfile, \
                         ('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
                         'headlabel="%s"]') % \
                         (s.element.name[0], d.element.name[0], l.name,
                             sip, dip)
             else:
                 print >>dotfile, '\t"%s" -- "%s" ' % \
                         (s.element.name[0], d.element.name[0])
+        lans = [ s for s in t.substrates if len(s.interfaces) != 2]
+        links = [ s for s in t.substrates if len(s.interfaces) == 2]
+        i = 0
+        for n in t.elements:
+            if n.name:
+                print >>dotfile, '\t"%s" [shape=box,style=filled,\\' % n.name[0]
+            else:
+                print >>dotfile, \
+                        '\t"unnamed_node%d" [shape=box,style=filled,\\' % i
+                i += 1
+            print >>dotfile, '\t\tcolor=black,fillcolor="#60f8c0",regular=1]'
+        # Encode the lans and the links
+        for l in lans:
+            print >>dotfile, '\t"%s" [shape=ellipse, style=filled,\\' % l.name
+            print >>dotfile,'\t\tcolor=black,fillcolor="#80c0f8",regular=1]'
+            for i in l.interfaces:
+                ip = i.get_attribute('ip4_address')
+                if labels and ip:
+                    print >>dotfile, '\t"%s" -- "%s" [headlabel="%s"]' % \
+                            (l.name, i.element.name[0], ip)
+                else:
+                    print >>dotfile, '\t"%s" -- "%s"' % \
+                            (l.name, i.element.name[0])
+        for l in links:
+            s, d = l.interfaces[0:2]
+            sip = s.get_attribute('ip4_address')
+            dip = d.get_attribute('ip4_address')
+            if labels and sip and dip:
+                print >>dotfile, \
+                        ('\t"%s" -- "%s" [label="%s",taillabel="%s",' + \
+                        'headlabel="%s"]') % \
+                        (s.element.name[0], d.element.name[0], l.name,
+                            sip, dip)
+            else:
+                print >>dotfile, '\t"%s" -- "%s" ' % \
+                        (s.element.name[0], d.element.name[0])
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         access_keys = []
         # Process the options using the customized option parser defined above
         parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
                 self.add_x509_cert)
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.file:
             exp_desc = ""
             try:
                 top = topdl.topology_from_xml(filename=opts.file,
                         top="experiment")
             except IOError:
                 sys.exit("Cannot read description file (%s)" % opts.file)
         else:
             sys.exit("Must specify an experiment description (--file)")
         if not opts.master:
             opts.master="dummy"
         if opts.format and opts.outfile:
             fmt = opts.format
             file = opts.outfile
         elif not opts.format and opts.outfile:
             fmt = opts.outfile[-3:]
             if fmt not in ("png", "jpg", "dot", "svg"):
                 sys.exit("Unexpected file type and no format specified")
             file = opts.outfile
         elif opts.format and not opts.outfile:
             fmt = opts.format
             file = None
         else:
             fmt="dot"
             file = None
         self.gen_image(top, len(top.elements), file, fmt, opts.neato,
                 opts.labels, opts.pixels)
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        access_keys = []
+        # Process the options using the customized option parser defined above
+        parser = fedd_ns_image_opts(access_keys, self.add_ssh_key,
+                self.add_x509_cert)
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.file:
+            exp_desc = ""
+            try:
+                top = topdl.topology_from_xml(filename=opts.file,
+                        top="experiment")
+            except IOError:
+                sys.exit("Cannot read description file (%s)" % opts.file)
+        else:
+            sys.exit("Must specify an experiment description (--file)")
+        if not opts.master:
+            opts.master="dummy"
+        if opts.format and opts.outfile:
+            fmt = opts.format
+            file = opts.outfile
+        elif not opts.format and opts.outfile:
+            fmt = opts.outfile[-3:]
+            if fmt not in ("png", "jpg", "dot", "svg"):
+                sys.exit("Unexpected file type and no format specified")
+            file = opts.outfile
+        elif opts.format and not opts.outfile:
+            fmt = opts.format
+            file = None
+        else:
+            fmt="dot"
+            file = None
+        self.gen_image(top, len(top.elements), file, fmt, opts.neato,
+                opts.labels, opts.pixels)
 class terminate(fedd_rpc):
     def __init__(self):
         """
         Termination request
         """
         fedd_rpc.__init__(self, "Terminate")
+        """
+        Termination request
+        """
+        fedd_rpc.__init__(self, "Terminate")
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_terminate_opts()
         (opts, args) = parser.parse_args()
         (user, cert) = self.get_user_info([])
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.exp_name and opts.exp_certfile:
             sys.exit("Only one of --experiment_cert and " +\
                     "--experiment_name permitted")
         if opts.print_log and opts.logfile:
             sys.exit("Only one of --logfile and --print_log is permitted")
         elif opts.print_log:
             out = sys.stdout
         elif opts.logfile:
             try:
                 out = open(opts.logfile, "w")
             except IOError,e:
                 sys.exit("Cannot open logfile: %s" %e)
         else:
             out = None
         exp_id = None
         if opts.exp_certfile:
             exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
         if opts.exp_name:
             exp_id = { 'localname' : opts.exp_name }
         if not exp_id:
             sys.exit("Must give one of --experiment_cert and " +\
                     "--experiment_name");
         req = { 'experiment': exp_id, 'force': opts.force }
         try:
             resp_dict = self.do_rpc(req,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             print e
             sys.exit("Error processing RPC: %s" % e)
         if out:
             log = resp_dict.get('deallocationLog', None)
             if log:
                 print >>out, log
                 out.close()
             else:
                 out.close()
                 sys.exit("No log returned")
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_terminate_opts()
+        (opts, args) = parser.parse_args()
+        (user, cert) = self.get_user_info([])
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.exp_name and opts.exp_certfile:
+            sys.exit("Only one of --experiment_cert and " +\
+                    "--experiment_name permitted")
+        if opts.print_log and opts.logfile:
+            sys.exit("Only one of --logfile and --print_log is permitted")
+        elif opts.print_log:
+            out = sys.stdout
+        elif opts.logfile:
+            try:
+                out = open(opts.logfile, "w")
+            except IOError,e:
+                sys.exit("Cannot open logfile: %s" %e)
+        else:
+            out = None
+        exp_id = None
+        if opts.exp_certfile:
+            exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
+        if opts.exp_name:
+            exp_id = { 'localname' : opts.exp_name }
+        if not exp_id:
+            sys.exit("Must give one of --experiment_cert and " +\
+                    "--experiment_name");
+        req = { 'experiment': exp_id, 'force': opts.force }
+        try:
+            resp_dict = self.do_rpc(req,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            print e
+            sys.exit("Error processing RPC: %s" % e)
+        if out:
+            log = resp_dict.get('deallocationLog', None)
+            if log:
+                print >>out, log
+                out.close()
+            else:
+                out.close()
+                sys.exit("No log returned")
 class create(fedd_rpc):
     def __init__(self):
         fedd_rpc.__init__(self, "Create")
+        fedd_rpc.__init__(self, "Create")
     def __call__(self):
         access_keys = []
         # Process the options using the customized option parser defined above
         parser = fedd_create_opts(access_keys, self.add_ssh_key,
                 self.add_x509_cert)
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if not opts.project :
             parser.error('--project is required')
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info(access_keys)
         if opts.user: user = opts.user
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
             if opts.use_fedid == True:
                 user = fid
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.file:
             exp_desc = ""
             try:
                 f = open(opts.file, 'r')
                 for line in f:
                     exp_desc += line
                 f.close()
             except IOError:
                 sys.exit("Cannot read description file (%s)" %opts.file)
         else:
             sys.exit("Must specify an experiment description (--file)")
         if not opts.master:
             sys.exit("Must specify a master testbed (--master)")
         out_certfile = opts.out_certfile
         msg = {
                 'experimentdescription': { 'ns2description': exp_desc },
                 'master': opts.master,
                 'exportProject': { 'localname': opts.project },
                 'user' : [ {\
                         'userID': pack_id(user), \
                         'access': [ { a.type: a.buf } for a in access_keys]\
                         } ]
+                }
         if opts.exp_name:
             msg['experimentID'] = { 'localname': opts.exp_name }
         if opts.debug > 1: print >>sys.stderr, msg
         try:
             resp_dict = self.do_rpc(msg,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         if opts.debug > 1: print >>sys.stderr, resp_dict
         ea = resp_dict.get('experimentAccess', None)
         if out_certfile and ea and ea.has_key('X509'):
             try:
                 f = open(out_certfile, "w")
                 print >>f, ea['X509']
                 f.close()
             except IOError:
                 sys.exit('Could not write to %s' %  out_certfile)
         eid = resp_dict.get('experimentID', None)
         if eid:
             for id in eid:
                 for k in id.keys():
                     print "%s: %s" % (k, id[k])
         st = resp_dict.get('experimentStatus', None)
         if st:
             print "status: %s" % st
+        access_keys = []
+        # Process the options using the customized option parser defined above
+        parser = fedd_create_opts(access_keys, self.add_ssh_key,
+                self.add_x509_cert)
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if not opts.project :
+            parser.error('--project is required')
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info(access_keys)
+        if opts.user: user = opts.user
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+            if opts.use_fedid == True:
+                user = fid
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.file:
+            exp_desc = ""
+            try:
+                f = open(opts.file, 'r')
+                for line in f:
+                    exp_desc += line
+                f.close()
+            except IOError:
+                sys.exit("Cannot read description file (%s)" %opts.file)
+        else:
+            sys.exit("Must specify an experiment description (--file)")
+        if not opts.master:
+            sys.exit("Must specify a master testbed (--master)")
+        out_certfile = opts.out_certfile
+        msg = {
+                'experimentdescription': { 'ns2description': exp_desc },
+                'master': opts.master,
+                'exportProject': { 'localname': opts.project },
+                'user' : [ {\
+                        'userID': pack_id(user), \
+                        'access': [ { a.type: a.buf } for a in access_keys]\
+                        } ]
+                }
+        if opts.exp_name:
+            msg['experimentID'] = { 'localname': opts.exp_name }
+        if opts.debug > 1: print >>sys.stderr, msg
+        try:
+            resp_dict = self.do_rpc(msg,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        if opts.debug > 1: print >>sys.stderr, resp_dict
+        ea = resp_dict.get('experimentAccess', None)
+        if out_certfile and ea and ea.has_key('X509'):
+            try:
+                f = open(out_certfile, "w")
+                print >>f, ea['X509']
+                f.close()
+            except IOError:
+                sys.exit('Could not write to %s' %  out_certfile)
+        eid = resp_dict.get('experimentID', None)
+        if eid:
+            for id in eid:
+                for k in id.keys():
+                    print "%s: %s" % (k, id[k])
+        st = resp_dict.get('experimentStatus', None)
+        if st:
+            print "status: %s" % st
 class split(fedd_rpc):
     def __init__(self):
         fedd_rpc.__init__(self, "Ns2Split")
+        fedd_rpc.__init__(self, "Ns2Split")
     def __call__(self):
         access_keys = []
         # Process the options using the customized option parser defined above
         parser = fedd_split_opts(access_keys, self.add_ssh_key,
                 self.add_x509_cert)
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info(access_keys)
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
             if opts.use_fedid == True:
                 user = fid
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.file:
             exp_desc = ""
             try:
                 f = open(opts.file, 'r')
                 for line in f:
                     exp_desc += line
                 f.close()
             except IOError:
                 sys.exit("Cannot read description file (%s)" %opts.file)
         else:
             sys.exit("Must specify an experiment description (--file)")
         if not opts.master:
             sys.exit("Must specify a master testbed (--master)")
         out_certfile = opts.out_certfile
         msg = {
                 'description': { 'ns2description': exp_desc },
                 'master': opts.master,
                 'include_fedkit': opts.fedkit,
                 'include_gatewaykit': opts.gatewaykit,
+                }
         if opts.debug > 1: print >>sys.stderr, msg
         try:
             resp_dict = self.do_rpc(msg,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e)
         if opts.debug > 1: print >>sys.stderr, resp_dict
         out = resp_dict.get('output', None)
         for line in out.splitlines():
             print "%s" % line
+        access_keys = []
+        # Process the options using the customized option parser defined above
+        parser = fedd_split_opts(access_keys, self.add_ssh_key,
+                self.add_x509_cert)
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info(access_keys)
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+            if opts.use_fedid == True:
+                user = fid
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.file:
+            exp_desc = ""
+            try:
+                f = open(opts.file, 'r')
+                for line in f:
+                    exp_desc += line
+                f.close()
+            except IOError:
+                sys.exit("Cannot read description file (%s)" %opts.file)
+        else:
+            sys.exit("Must specify an experiment description (--file)")
+        if not opts.master:
+            sys.exit("Must specify a master testbed (--master)")
+        out_certfile = opts.out_certfile
+        msg = {
+                'description': { 'ns2description': exp_desc },
+                'master': opts.master,
+                'include_fedkit': opts.fedkit,
+                'include_gatewaykit': opts.gatewaykit,
+                }
+        if opts.debug > 1: print >>sys.stderr, msg
+        try:
+            resp_dict = self.do_rpc(msg,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e)
+        if opts.debug > 1: print >>sys.stderr, resp_dict
+        out = resp_dict.get('output', None)
+        for line in out.splitlines():
+            print "%s" % line
 class access(fedd_rpc):
     def __init__(self):
         fedd_rpc.__init__(self, "RequestAccess")
+        fedd_rpc.__init__(self, "RequestAccess")
     def print_response_as_testbed(self, resp, label, out=sys.stdout):
         """Print the response as input to the splitter script"""
         e = resp['emulab']
         p = e['project']
         fields = {
                 "Boss": e['boss'],
                 "OpsNode": e['ops'],
                 "Domain": e['domain'],
                 "FileServer": e['fileServer'],
                 "EventServer": e['eventServer'],
                 "Project": unpack_id(p['name'])
+                }
         if (label != None): print >> out, "[%s]" % label
         for l, v in fields.iteritems():
             print >>out, "%s: %s" % (l, v)
         for u in p['user']:
             print >>out, "User: %s" % unpack_id(u['userID'])
         for a in e['fedAttr']:
             print >>out, "%s: %s" % (a['attribute'], a['value'])
+        """Print the response as input to the splitter script"""
+        e = resp['emulab']
+        p = e['project']
+        fields = {
+                "Boss": e['boss'],
+                "OpsNode": e['ops'],
+                "Domain": e['domain'],
+                "FileServer": e['fileServer'],
+                "EventServer": e['eventServer'],
+                "Project": unpack_id(p['name'])
+                }
+        if (label != None): print >> out, "[%s]" % label
+        for l, v in fields.iteritems():
+            print >>out, "%s: %s" % (l, v)
+        for u in p['user']:
+            print >>out, "User: %s" % unpack_id(u['userID'])
+        for a in e['fedAttr']:
+            print >>out, "%s: %s" % (a['attribute'], a['value'])
     def __call__(self):
         access_keys = []
         node_descs = []
         proj = None
         # Process the options using the customized option parser defined above
         parser = fedd_access_opts(access_keys, node_descs, self.add_ssh_key,
                 self.add_x509_cert, self.add_node_desc)
         (opts, args) = parser.parse_args()
         if opts.testbed == None:
             parser.error("--testbed is required")
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info(access_keys)
         if opts.user: user = opts.user
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
             if opts.use_fedid == True:
                 user = fid
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         msg = {
                 'allocID': pack_id('test alloc'),
                 'destinationTestbed': pack_id(opts.testbed),
                 'serviceAccess' : [ { a.type: a.buf } for a in access_keys ],
                 'createAccess' : [ { a.type: a.buf } for a in access_keys ],
+                }
         if len(node_descs) > 0:
             msg['resources'] = {
                     'node': [
+                        {
                             'image':  n.image ,
                             'hardware':  n.hardware,
                             'count': n.count,
                         } for n in node_descs],
+                    }
         if opts.project != None:
             if not opts.anonymous and user != None:
                 msg['project'] = {
                         'name': pack_id(opts.project),
                         'user': [ { 'userID': pack_id(user) } ],
+                        }
             else:
                 msg['project'] = { 'name': pack_id(opts.project) }
         else:
             if not opts.anonymous and user != None:
                 msg['user'] = [ { 'userID': pack_id(user) } ]
             else:
                 msg['user'] = [];
         if opts.debug > 1: print >>sys.stderr, msg
         try:
             resp_dict = self.do_rpc(msg,
                     opts.url, opts.transport, cert, opts.trusted,
                     serialize_only=opts.serialize_only,
                     tracefile=opts.tracefile)
         except self.RPCException, e:
             exit_with_fault(\
                     {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
         except RuntimeError, e:
             sys.exit("Error processing RPC: %s" % e.message)
         if opts.debug > 1: print >>sys.stderr, resp_dict
         self.print_response_as_testbed(resp_dict, opts.label)
+        access_keys = []
+        node_descs = []
+        proj = None
+        # Process the options using the customized option parser defined above
+        parser = fedd_access_opts(access_keys, node_descs, self.add_ssh_key,
+                self.add_x509_cert, self.add_node_desc)
+        (opts, args) = parser.parse_args()
+        if opts.testbed == None:
+            parser.error("--testbed is required")
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info(access_keys)
+        if opts.user: user = opts.user
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+            if opts.use_fedid == True:
+                user = fid
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        msg = {
+                'allocID': pack_id('test alloc'),
+                'destinationTestbed': pack_id(opts.testbed),
+                'serviceAccess' : [ { a.type: a.buf } for a in access_keys ],
+                'createAccess' : [ { a.type: a.buf } for a in access_keys ],
+                }
+        if len(node_descs) > 0:
+            msg['resources'] = {
+                    'node': [
+                        {
+                            'image':  n.image ,
+                            'hardware':  n.hardware,
+                            'count': n.count,
+                        } for n in node_descs],
+                    }
+        if opts.project != None:
+            if not opts.anonymous and user != None:
+                msg['project'] = {
+                        'name': pack_id(opts.project),
+                        'user': [ { 'userID': pack_id(user) } ],
+                        }
+            else:
+                msg['project'] = { 'name': pack_id(opts.project) }
+        else:
+            if not opts.anonymous and user != None:
+                msg['user'] = [ { 'userID': pack_id(user) } ]
+            else:
+                msg['user'] = [];
+        if opts.debug > 1: print >>sys.stderr, msg
+        try:
+            resp_dict = self.do_rpc(msg,
+                    opts.url, opts.transport, cert, opts.trusted,
+                    serialize_only=opts.serialize_only,
+                    tracefile=opts.tracefile)
+        except self.RPCException, e:
+            exit_with_fault(\
+                    {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+        except RuntimeError, e:
+            sys.exit("Error processing RPC: %s" % e.message)
+        if opts.debug > 1: print >>sys.stderr, resp_dict
+        self.print_response_as_testbed(resp_dict, opts.label)
 # Keep requesting experiment status and printing updates to the log until the
 …
 class spew_log(fedd_rpc):
     def __init__(self):
         """
         Init the superclass
         """
         fedd_rpc.__init__(self, 'Info')
+        """
+        Init the superclass
+        """
+        fedd_rpc.__init__(self, 'Info')
     def __call__(self):
         """
         The control flow.  Compose the request and print the response.
         """
         # Process the options using the customized option parser defined above
         parser = fedd_spew_opts()
         (opts, args) = parser.parse_args()
         if opts.trusted:
             if ( not os.access(opts.trusted, os.R_OK) ) :
                 sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
         if opts.debug > 0: opts.tracefile=sys.stderr
         (user, cert) = self.get_user_info([])
         if opts.cert != None: cert = opts.cert
         if cert == None:
             sys.exit("No certificate given (--cert) or found")
         if os.access(cert, os.R_OK):
             fid = fedid(file=cert)
         else:
             sys.exit("Cannot read certificate (%s)" % cert)
         if opts.exp_name and opts.exp_certfile:
             sys.exit("Only one of --experiment_cert and " +\
                     "--experiment_name permitted");
         if opts.exp_certfile:
             exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
         if opts.exp_name:
             exp_id = { 'localname' : opts.exp_name }
         if opts.logfile:
             try:
                 out = open(opts.logfile, "w")
             except IOError,e:
                 sys.exit("Cannot open logfile: %s" %e)
         else:
             out = sys.stdout
         req = { 'experiment': exp_id }
         status = "starting"
         log = ""
         log_offset = 0
         update = opts.update
         while status == 'starting':
             try:
                 resp_dict = self.do_rpc(req,
                         opts.url, opts.transport, cert, opts.trusted,
                         serialize_only=opts.serialize_only,
                         tracefile=opts.tracefile)
             except self.RPCException, e:
                 exit_with_fault(\
                         {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
             except RuntimeError, e:
                 sys.exit("Error processing RPC: %s" % e)
             status = resp_dict.get('experimentStatus', None)
             log = resp_dict.get('allocationLog', None)
             if not status:
                 sys.exit("No status in Info response??")
             if log:
                 if len(log) > log_offset:
                     print >>out, log[log_offset:],
                     out.flush()
                     log_offset = len(log)
             if status == 'starting':
                 time.sleep(update)
         print >>out
         print >>out, status
         out.close()
+        """
+        The control flow.  Compose the request and print the response.
+        """
+        # Process the options using the customized option parser defined above
+        parser = fedd_spew_opts()
+        (opts, args) = parser.parse_args()
+        if opts.trusted:
+            if ( not os.access(opts.trusted, os.R_OK) ) :
+                sys.exit("Cannot read trusted certificates (%s)" % opts.trusted)
+        if opts.debug > 0: opts.tracefile=sys.stderr
+        (user, cert) = self.get_user_info([])
+        if opts.cert != None: cert = opts.cert
+        if cert == None:
+            sys.exit("No certificate given (--cert) or found")
+        if os.access(cert, os.R_OK):
+            fid = fedid(file=cert)
+        else:
+            sys.exit("Cannot read certificate (%s)" % cert)
+        if opts.exp_name and opts.exp_certfile:
+            sys.exit("Only one of --experiment_cert and " +\
+                    "--experiment_name permitted");
+        if opts.exp_certfile:
+            exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
+        if opts.exp_name:
+            exp_id = { 'localname' : opts.exp_name }
+        if opts.logfile:
+            try:
+                out = open(opts.logfile, "w")
+            except IOError,e:
+                sys.exit("Cannot open logfile: %s" %e)
+        else:
+            out = sys.stdout
+        req = { 'experiment': exp_id }
+        status = "starting"
+        log = ""
+        log_offset = 0
+        update = opts.update
+        while status == 'starting':
+            try:
+                resp_dict = self.do_rpc(req,
+                        opts.url, opts.transport, cert, opts.trusted,
+                        serialize_only=opts.serialize_only,
+                        tracefile=opts.tracefile)
+            except self.RPCException, e:
+                exit_with_fault(\
+                        {'desc': e.desc, 'errstr': e.errstr, 'code': e.code})
+            except RuntimeError, e:
+                sys.exit("Error processing RPC: %s" % e)
+            status = resp_dict.get('experimentStatus', None)
+            log = resp_dict.get('allocationLog', None)
+            if not status:
+                sys.exit("No status in Info response??")
+            if log:
+                if len(log) > log_offset:
+                    print >>out, log[log_offset:],
+                    out.flush()
+                    log_offset = len(log)
+            if status == 'starting':
+                time.sleep(update)
+        print >>out
+        print >>out, status
+        out.close()
 cmds = {\
         'create': create(),\
         'split': split(),\
         'access': access(),\
         'vtopo': vtopo(),\
         'vis': vis(),\
         'info': exp_data(),\
         'multiinfo': multi_exp_data(),\
         'multistatus': multi_status(),\
         'image': image(),\
         'ns_image': ns_image(),\
         'status': status(),\
         'terminate': terminate(),\
         'spewlog': spew_log(),\
         'topdl_image': topdl_image(),\
+        'create': create(),\
+        'split': split(),\
+        'access': access(),\
+        'vtopo': vtopo(),\
+        'vis': vis(),\
+        'info': exp_data(),\
+        'multiinfo': multi_exp_data(),\
+        'multistatus': multi_status(),\
+        'image': image(),\
+        'ns_image': ns_image(),\
+        'status': status(),\
+        'terminate': terminate(),\
+        'spewlog': spew_log(),\
+        'topdl_image': topdl_image(),\
+    }
 …
 else:
     if sys.argv[1] == '--help':
         sys.exit(\
+        sys.exit(\
 '''Only context sensitive help is available.  For one of the commands:
 …
 ''' % (", ".join(cmds.keys()), sys.argv[0], sys.argv[0]))
     else:
         sys.exit("Bad command: %s.  Valid ones are: %s" % \
                 (sys.argv[1], ", ".join(cmds.keys())))
+        sys.exit("Bad command: %s.  Valid ones are: %s" % \
+                (sys.argv[1], ", ".join(cmds.keys())))

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 16a23a6

Legend:

fedd/fedd_client.py

Download in other formats: