Changeset 058f58e for fedd/fedd_client.py

Timestamp:

Nov 20, 2008 7:14:58 PM (15 years ago)

Author:

Ted Faber <faber@…>

Branches:

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

Children:

cfabc40

Parents:

c922f23

Message:

Unify the code for calling SOAP and XMLRPC services into a couple classes.
Before there were slightly different semantics everywhere.

Also make the handlers classes rather than the output of stub compiling
functions.

File:

• fedd/fedd_client.py (modified) (7 diffs)

fedd/fedd_client.py

@@ -21 +21 @@
 
 from fedd_util import fedid, fedd_ssl_context, pack_soap, unpack_soap, \
-        pack_id, unpack_id, encapsulate_binaries, decapsulate_binaries
+        pack_id, unpack_id, encapsulate_binaries, decapsulate_binaries, \
+        service_caller
+from service_error import *
 
 from optparse import OptionParser, OptionValueError
@@ -190 +192 @@
     def __init__(self, pre): 
         """
-        Specialize the class for the prc method
+        Specialize the class for the pre method
         """
         self.RequestMessage = globals()["%sRequestMessage" % pre]
@@ -197 +199 @@
         self.ResponseBody="%sResponseBody" % pre
         self.method = pre
+
+        method_call = getattr(feddServiceLocator().getfeddPortType(),
+                self.method, None)
+        if method_call:
+            # The pre method is a fedd external service
+            self.caller = service_caller(self.method, 'getfeddPortType', 
+                    feddServiceLocator, self.RequestMessage, self.RequestBody)
+        else:
+            # The pre method is a fedd internal service
+            self.caller = service_caller(self.method, 
+                    'getfeddInternalPortType', feddInternalServiceLocator,
+                    self.RequestMessage, self.RequestBody)
+
         self.RPCException = fedd_rpc.RPCException
 
@@ -265 +280 @@
 
         if transport == "soap":
-            loc = feddServiceLocator();
-            port = loc.getfeddPortType(url,
-                    transport=M2Crypto.httpslib.HTTPSConnection, 
-                    transdict={ 'ssl_context' : context },
-                    tracefile=tracefile)
-            method_call = getattr(port, self.method, None)
-
-            if not method_call:
-                loc = feddInternalServiceLocator();
-                port = loc.getfeddInternalPortType(url,
-                        transport=M2Crypto.httpslib.HTTPSConnection, 
-                        transdict={ 'ssl_context' : context },
-                        tracefile=tracefile)
-                method_call = getattr(port, self.method, None)
-                if not method_call:
-                    raise RuntimeError("Can't find method: %s" % self.method)
-
-            req = self.RequestMessage()
-
-            set_req = getattr(req, "set_element_%s" % self.RequestBody, None)
-            set_req(pack_soap(req, self.RequestBody, req_dict))
-
             if serialize_only:
                 sw = SoapWriter()
@@ -292 +285 @@
                 print str(sw)
                 sys.exit(0)
-
-            try:
-                method_call = getattr(port, self.method, None)
-                resp = method_call(req)
-            except ZSI.ParseException, e:
-                raise RuntimeError("Malformed response (XMLPRC?): %s" % e)
-            except ZSI.FaultException, e:
-                resp = e.fault.detail[0]
-
-            if resp:
-                resp_call = getattr(resp, "get_element_%s" %self.ResponseBody,
-                        None)
-                if resp_call: 
-                    resp_body = resp_call()
-                    if ( resp_body != None): 
-                        try:
-                            return unpack_soap(resp_body)
-                        except RuntimeError, e:
-                            raise RuntimeError("Bad response. %s" % e.message)
-                elif 'get_element_FeddFaultBody' in dir(resp): 
-                    resp_body = resp.get_element_FeddFaultBody()
-                    if resp_body != None: 
-                        try:
-                            fb = unpack_soap(resp_body)
-                        except RuntimeError, e:
-                            raise RuntimeError("Bad response. %s" % e.message)
-                        raise self.RPCException(fb)
-                else: 
-                    raise RuntimeError("No body in response!?")
-            else: 
-                raise RuntimeError("No response?!?")
+            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 })
         elif transport == "xmlrpc":
             if serialize_only:
@@ -328 +296 @@
                 print ser
                 sys.exit(0)
-
-            xtransport = SSL_Transport(context)
-            port = ServerProxy(url, transport=xtransport)
-
-            try:
-                method_call = getattr(port, self.method, None)
-                resp = method_call(
-                        encapsulate_binaries({ self.RequestBody: req_dict},\
-                            ('fedid',)))
-            except Error, e:
-                resp = { 'FeddFaultBody': \
-                        { 'errstr' : getattr(e, "faultCode", "No fault code"),
-                        'desc' : getattr(e, "faultString", "No fault string") }\
-                        }
-            if resp:
-                if resp.has_key(self.ResponseBody): 
-                    return decapsulate_binaries(resp[self.ResponseBody],
-                            ('fedid',))
-                elif resp.has_key('FeddFaultBody'):
-                    raise self.RPCException(resp['FeddFaultBody'])
-                else: 
-                    raise RuntimeError("No body in response!?")
-            else: 
-                raise RuntimeError("No response?!?")
+            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 })
+
         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??")
 
 # Querying experiment data follows the same control flow regardless of the
@@ -606 +562 @@
             for id in eid:
                 for k in id.keys():
-                    if k == 'fedid': print "%s: %s" % (k,fedid(bits=id[k]))
-                    else: print "%s: %s" % (k, id[k])
+                    print "%s: %s" % (k, id[k])
 
 class split(fedd_rpc):