Changeset 0a47d52 for fedd/fedd_proj.py

Timestamp:

Jul 1, 2008 10:39:43 AM (16 years ago)

Author:

Ted Faber <faber@…>

Branches:

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

Children:

bb3769a

Parents:

329f61d

Message:

XMLRPC proxy from SOAP and XML

File:

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

fedd/fedd_proj.py

@@ -6 +6 @@
 from ZSI import *
 from M2Crypto import SSL
+from M2Crypto.m2xmlrpclib import SSL_Transport
 from M2Crypto.SSL.SSLServer import SSLServer
 import M2Crypto.httpslib
@@ -15 +16 @@
 import subprocess
 import tempfile
+import copy
 
 from fedd_services import *
@@ -228 +230 @@
         os.unlink(projfile)
 
-    def proxy_request(self, dt, req):
-        """
-        Send req on to the real destination in dt and return the response
-
-        Req is just the requestType object.  This function re-wraps it.  It
-        also rethrows any faults.
-        """
+    
+    def strip_unicode(self, obj):
+        """Loosly de-unicode an object"""
+        if isinstance(obj, dict):
+            for k in obj.keys():
+                obj[k] = self.strip_unicode(obj[k])
+            return obj
+        elif isinstance(obj, basestring):
+            return str(obj)
+        elif getattr(obj, "__iter__", None):
+            return [ self.strip_unicode(x) for x in obj]
+        else:
+            return obj
+
+    def proxy_xmlrpc_request(self, dt, req):
+        """Send an XMLRPC proxy request.  Called if the SOAP RPC fails"""
         tc = self.proxy_trusted_certs or self.trusted_certs
 
@@ -244 +255 @@
             raise Fault(Fault.Server, "Server certificates misconfigured")
 
+        # Of all the dumbass things.  The XMLRPC library in use here won't
+        # properly encode unicode strings, so we make a copy of req with the
+        # unicode objects converted.  We also convert the destination testbed
+        # to a basic string if it isn't one already.
+        if isinstance(dt, str): url = dt
+        else: url = str(dt)
+
+        r = copy.deepcopy(req)
+        self.strip_unicode(r)
+        
+        transport = SSL_Transport(ctx)
+        port = xmlrpclib.ServerProxy(url, transport=transport)
+
+        # Reconstruct the full request message
+        try:
+            resp = port.RequestAccess(
+                    { "RequestAccessRequestBody": r})
+            resp, method = xmlrpclib.loads(resp)
+        except xmlrpclib.Error, e:
+            raise Fault(Fault.Server, "Remote XMLRPC Fault: %s" % e)
+        
+        if resp[0].has_key('RequestAccessResponseBody'):
+            return resp[0]['RequestAccessResponseBody']
+        else:
+            raise Fault(Fault.Server, "Bad proxy response")
+
+    def proxy_request(self, dt, req):
+        """
+        Send req on to the real destination in dt and return the response
+
+        Req is just the requestType object.  This function re-wraps it.  It
+        also rethrows any faults.
+        """
+        tc = self.proxy_trusted_certs or self.trusted_certs
+
+        # No retry loop here.  Proxy servers must correctly authenticate
+        # themselves without help
+        try:
+            ctx = fedd_ssl_context(self.cert_file, tc, password=self.cert_pwd)
+        except SSL.SSLError:
+            raise Fault(Fault.Server, "Server certificates misconfigured")
+
         loc = feddServiceLocator();
         port = loc.getfeddPortType(dt,
@@ -255 +308 @@
         try:
             resp = port.RequestAccess(msg)
+        except ZSI.ParseException, e:
+            raise Fault(Fault.Server, "Bad format message (XMLRPC??): %s" %
+                    str(e))
         except ZSI.FaultException, e:
             raise e.fault
@@ -423 +479 @@
             dt = unpack_id(req['destinationTestbed'])
         
-        print dt
-
         if dt == None or dt == self.testbed:
             # Request for this fedd
@@ -454 +508 @@
             return resp
         else:
-            # Proxy the request
-            return self.proxy_request(dt, req)
+            p_fault = None      # Any SOAP failure (sent unless XMLRPC works)
+            try:
+                # Proxy the request using SOAP
+                return self.proxy_request(dt, req)
+            except Fault, f:
+                p_fault = f
+          
+           
+            # This runs if SOAP failed
+            try:
+                return self.proxy_xmlrpc_request(dt, req)
+            except Fault:
+                # Both failed, return the SOAP error.  If somehow that
+                # exception is gone, return the XMLRPC one
+                if p_fault != None: raise p_fault
+                else: raise
 
     def soap_RequestAccess(self, ps, fid):