X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fclient%2Fsfaserverproxy.py;h=6c11ee0603779522fabef175bc46385c72e6f0ed;hb=2b8fb7af76b173ad4ad6583dbedbdf11a49f9549;hp=762ea380b0262c73d31de7bcefe9afedf917cc11;hpb=5404ec87098e28a160f3b53ccb751cd4086c7fa7;p=sfa.git diff --git a/sfa/client/sfaserverproxy.py b/sfa/client/sfaserverproxy.py index 762ea380..6c11ee06 100644 --- a/sfa/client/sfaserverproxy.py +++ b/sfa/client/sfaserverproxy.py @@ -1,17 +1,15 @@ # XMLRPC-specific code for SFA Client -# starting with 2.7.9 we need to turn off server verification -import ssl -ssl_needs_unverified_context = hasattr(ssl, '_create_unverified_context') +from sfa.util.ssl import simple_ssl_context -import xmlrpclib -from httplib import HTTPS, HTTPSConnection +import xmlrpc.client +import http.client try: from sfa.util.sfalogging import logger except: import logging - logger=logging.getLogger('sfaserverproxy') + logger = logging.getLogger('sfaserverproxy') ## # ServerException, ExceptionUnmarshaller @@ -19,14 +17,17 @@ except: # Used to convert server exception strings back to an exception. # from usenet, Raghuram Devarakonda + class ServerException(Exception): pass -class ExceptionUnmarshaller(xmlrpclib.Unmarshaller): + +class ExceptionUnmarshaller(xmlrpc.client.Unmarshaller): + def close(self): try: - return xmlrpclib.Unmarshaller.close(self) - except xmlrpclib.Fault, e: + return xmlrpc.client.Unmarshaller.close(self) + except xmlrpc.client.Fault as e: raise ServerException(e.faultString) ## @@ -34,36 +35,24 @@ class ExceptionUnmarshaller(xmlrpclib.Unmarshaller): # # A transport for XMLRPC that works on top of HTTPS -# python 2.7 xmlrpclib has changed its internal code -# it now calls 'getresponse' on the obj returned by make_connection -# while it used to call 'getreply' -# regardless of the version, httplib.HTTPS does implement getreply, -# while httplib.HTTPSConnection has getresponse -# so we create a dummy instance to check what's expected -need_HTTPSConnection=hasattr(xmlrpclib.Transport().make_connection('localhost'),'getresponse') +# targetting only python-2.7 we can get rid of some older code + + +class XMLRPCTransport(xmlrpc.client.Transport): -class XMLRPCTransport(xmlrpclib.Transport): - def __init__(self, key_file=None, cert_file=None, timeout=None): - xmlrpclib.Transport.__init__(self) - self.timeout=timeout + xmlrpc.client.Transport.__init__(self) + self.timeout = timeout self.key_file = key_file self.cert_file = cert_file - + def make_connection(self, host): # create a HTTPS connection object from a host descriptor # host may be a string, or a (host, x509-dict) tuple host, extra_headers, x509 = self.get_host_info(host) - if need_HTTPSConnection: - if not ssl_needs_unverified_context: - conn = HTTPSConnection(host, None, key_file = self.key_file, - cert_file = self.cert_file) - else: - conn = HTTPSConnection(host, None, key_file = self.key_file, - cert_file = self.cert_file, - context = ssl._create_unverified_context()) - else: - conn = HTTPS(host, None, key_file=self.key_file, cert_file=self.cert_file) + conn = http.client.HTTPSConnection( + host, None, key_file=self.key_file, + cert_file=self.cert_file, context=simple_ssl_context()) # Some logic to deal with timeouts. It appears that some (or all) versions # of python don't set the timeout after the socket is created. We'll do it @@ -86,40 +75,41 @@ class XMLRPCTransport(xmlrpclib.Transport): def getparser(self): unmarshaller = ExceptionUnmarshaller() - parser = xmlrpclib.ExpatParser(unmarshaller) + parser = xmlrpc.client.ExpatParser(unmarshaller) return parser, unmarshaller -class XMLRPCServerProxy(xmlrpclib.ServerProxy): + +class XMLRPCServerProxy(xmlrpc.client.ServerProxy): + def __init__(self, url, transport, allow_none=True, verbose=False): # remember url for GetVersion # xxx not sure this is still needed as SfaServerProxy has this too - self.url=url - if not ssl_needs_unverified_context: - xmlrpclib.ServerProxy.__init__(self, url, transport, allow_none=allow_none, - verbose=verbose) - else: - xmlrpclib.ServerProxy.__init__(self, url, transport, allow_none=allow_none, - verbose=verbose, - context=ssl._create_unverified_context()) + self.url = url + xmlrpc.client.ServerProxy.__init__( + self, url, transport, allow_none=allow_none, + context=simple_ssl_context(), verbose=verbose) def __getattr__(self, attr): - logger.debug ("xml-rpc %s method:%s" % (self.url, attr)) - return xmlrpclib.ServerProxy.__getattr__(self, attr) + logger.debug("xml-rpc %s method:%s" % (self.url, attr)) + return xmlrpc.client.ServerProxy.__getattr__(self, attr) + +# the object on which we can send methods that get sent over xmlrpc + -########## the object on which we can send methods that get sent over xmlrpc class SfaServerProxy: - def __init__ (self, url, keyfile, certfile, verbose=False, timeout=None): - self.url=url - self.keyfile=keyfile - self.certfile=certfile - self.verbose=verbose - self.timeout=timeout - # an instance of xmlrpclib.ServerProxy + def __init__(self, url, keyfile, certfile, verbose=False, timeout=None): + self.url = url + self.keyfile = keyfile + self.certfile = certfile + self.verbose = verbose + self.timeout = timeout + # an instance of xmlrpc.client.ServerProxy transport = XMLRPCTransport(keyfile, certfile, timeout) - self.serverproxy = XMLRPCServerProxy(url, transport, allow_none=True, verbose=verbose) + self.serverproxy = XMLRPCServerProxy( + url, transport, allow_none=True, verbose=verbose) - # this is python magic to return the code to run when + # this is python magic to return the code to run when # SfaServerProxy receives a method call # so essentially we send the same method with identical arguments # to the server_proxy object @@ -127,4 +117,3 @@ class SfaServerProxy: def func(*args, **kwds): return getattr(self.serverproxy, name)(*args, **kwds) return func -