Changeset c922f23 for fedd

Timestamp:

Nov 19, 2008 7:24:16 PM (16 years ago)

Author:

Ted Faber <faber@…>

Branches:

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

Children:

058f58e

Parents:

dab4d56

Message:

Start the move to unified service calling routines

Location:

fedd

Files:

• fedd_access.py (modified) (4 diffs)
• fedd_util.py (modified) (3 diffs)

fedd/fedd_access.py

@@ -51 +51 @@
             "dynamic_projects_cert_pwd", "dynamic_projects_trusted_certs")
     id_list_attrs = ("restricted",)
+
+    proxy_request, proxy_xmlrpc_request = make_service_callers('RequestAccess', 
+            'getfeddPortType', RequestAccessRequestMessage,
+            'RequestAccessRequestBody')
 
     def __init__(self, config=None):
@@ -387 +391 @@
             self.log.warning(("[read_state]: No saved state: " + \
                     "Unpickling failed: %s") % e)
-
-
-    def proxy_xmlrpc_request(self, dt, req):
-        """Send an XMLRPC proxy request.  Called if the SOAP RPC fails"""
-
-        # No retry loop here.  Proxy servers must correctly authenticate
-        # themselves without help
-        try:
-            ctx = fedd_ssl_context(self.proxy_cert_file, 
-                    self.proxy_trusted_certs, password=self.proxy_cert_pwd)
-        except SSL.SSLError:
-            raise service_error(service_error.server_config,
-                    "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 = strip_unicode(copy.deepcopy(req))
-        
-        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.Fault, f:
-            se = service_error(None, f.faultString, f.faultCode)
-            raise se
-        except xmlrpclib.Error, e:
-            raise service_error(service_error.proxy, 
-                    "Remote XMLRPC Fault: %s" % e)
-        
-        if resp[0].has_key('RequestAccessResponseBody'):
-            return resp[0]['RequestAccessResponseBody']
-        else:
-            raise service_error(service_error.proxy, 
-                    "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.
-        """
-        # No retry loop here.  Proxy servers must correctly authenticate
-        # themselves without help
-        try:
-            ctx = fedd_ssl_context(self.proxy_cert_file, 
-                    self.proxy_trusted_certs, password=self.proxy_cert_pwd)
-        except SSL.SSLError:
-            raise service_error(service_error.server_config, 
-                    "Server certificates misconfigured")
-
-        loc = feddServiceLocator();
-        port = loc.getfeddPortType(dt,
-                transport=M2Crypto.httpslib.HTTPSConnection, 
-                transdict={ 'ssl_context' : ctx })
-
-        # Reconstruct the full request message
-        msg = RequestAccessRequestMessage()
-        msg.set_element_RequestAccessRequestBody(
-                pack_soap(msg, "RequestAccessRequestBody", req))
-        try:
-            resp = port.RequestAccess(msg)
-        except ZSI.ParseException, e:
-            raise service_error(service_error.proxy,
-                    "Bad format message (XMLRPC??): %s" %
-                    str(e))
-        r = unpack_soap(resp)
-
-        if r.has_key('RequestAccessResponseBody'):
-            return r['RequestAccessResponseBody']
-        else:
-            raise service_error(service_error.proxy,
-                    "Bad proxy response")
 
     def permute_wildcards(self, a, p):
@@ -779 +701 @@
             try:
                 # Proxy the request using SOAP
-                return self.proxy_request(dt, req)
+                self.log.debug("Sending proxy message to %s" % dt)
+                resp = self.proxy_request(dt, req, feddServiceLocator,
+                        self.proxy_cert_file, self.proxy_cert_pwd,
+                        self.proxy_trusted_certs)
+                if resp.has_key('RequestAccessResponseBody'):
+                    return resp['RequestAccessResponseBody']
+                elif resp.has_key('Fedd_FaultBody'):
+                    raise service_error(resp['FeddFaultBody']['code'],
+                            resp['FeddFaultBody']['desc'])
             except service_error, e:
                 if e.code == service_error.proxy: p_fault = None
@@ -791 +721 @@
             # out.
             if p_fault == None:
-                return self.proxy_xmlrpc_request(dt, req)
+                resp = self.proxy_xmlrpc_request(dt, req, self.proxy_cert_file,
+                    self.proxy_cert_pwd, self.proxy_trusted_certs)
+                if resp.has_key('RequestAccessResponseBody'):
+                    return resp['RequestAccessResponseBody']
             else:
                 # Build the fault

fedd/fedd_util.py

@@ -5 +5 @@
 import tempfile
 import logging
+import copy
 
 from M2Crypto import SSL, X509, EVP
+from M2Crypto.m2xmlrpclib import SSL_Transport
+import M2Crypto.httpslib
 from pyasn1.codec.der import decoder
 
-from xmlrpclib import Binary
+from fedd_services import *
+from fedd_internal_services import *
+from service_error import *
+from xmlrpclib import ServerProxy, dumps, loads, Fault, Error, Binary
 
 
@@ -413 +419 @@
         decap_fedids = (('fedid', lambda x: fedid(bits=x.data)),)
 
-        #p = decapsulate_binaries(params[0], input_binaries)
         p = apply_to_tags(params[0], decap_fedids)
         msg = method(p, fid)
 
         if msg != None:
-            return encapsulate_binaries({ body_name: msg }, ('fedid',))
+            return make_unicode(encapsulate_binaries({ body_name: msg }, ('fedid',)))
         else:
             return None
@@ -424 +429 @@
     return handler
 
+def make_service_callers(service_name, port_name, request_message, 
+        request_body_name):
+
+    def call_xmlrpc_service(self, url, req, cert_file=None, cert_pwd=None, 
+            trusted_certs=None):
+        """Send an XMLRPC request.  """
+        decap_fedids = (('fedid', lambda x: fedid(bits=x.data)),)
+
+        # No retry loop here.  Proxy servers must correctly authenticate
+        # themselves without help
+        try:
+            ctx = fedd_ssl_context(cert_file, trusted_certs, password=cert_pwd)
+        except SSL.SSLError:
+            raise service_error(service_error.server_config,
+                    "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 url to a basic string
+        # if it isn't one already.
+        r = strip_unicode(copy.deepcopy(req))
+        url = str(url)
+        
+        transport = SSL_Transport(ctx)
+        port = ServerProxy(url, transport=transport)
+        try:
+            remote_method = getattr(port, service_name, None)
+            resp = remote_method(encapsulate_binaries({ request_body_name: r},
+                ('fedid',)))
+        except Fault, f:
+            raise service_error(None, f.faultString, f.faultCode)
+        except Error, e:
+            raise service_error(service_error.proxy, 
+                    "Remote XMLRPC Fault: %s" % e)
+
+        return apply_to_tags(resp, decap_fedids) 
+
+    def call_soap_service(self, url, req, loc_const, cert_file=None, cert_pwd=None, 
+            trusted_certs=None):
+        """
+        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.
+        """
+        # No retry loop here.  Proxy servers must correctly authenticate
+        # themselves without help
+        try:
+            ctx = fedd_ssl_context(cert_file, trusted_certs, password=cert_pwd)
+        except SSL.SSLError:
+            raise service_error(service_error.server_config, 
+                    "Server certificates misconfigured")
+
+        loc = loc_const()
+        get_port = getattr(loc, port_name, None)
+        if not get_port:
+            raise service_error(service_error.internal, 
+                    "Cannot get port %s from locator" % port_name)
+        port = get_port(url,
+                transport=M2Crypto.httpslib.HTTPSConnection, 
+                transdict={ 'ssl_context' : ctx })
+        remote_method = getattr(port, service_name, None)
+        if not remote_method:
+            raise service_error(service_error.internal,
+                    "Cannot get service from SOAP port")
+
+        # Reconstruct the full request message
+        msg = request_message()
+        set_element = getattr(msg, "set_element_%s" % request_body_name, None)
+        if not set_element:
+            raise service_error(service_error.internal,
+                    "Cannot get element setting method for %s" % \
+                            request_body_name)
+        set_element(pack_soap(msg, request_body_name, req))
+        try:
+            resp = remote_method(msg)
+        except ZSI.ParseException, e:
+            raise service_error(service_error.proxy,
+                    "Bad format message (XMLRPC??): %s" %
+                    str(e))
+        r = unpack_soap(resp)
+        return r
+
+    return (call_soap_service, call_xmlrpc_service)
 
 def set_log_level(config, sect, log):