From 2848627d82951554359ca9d7e23fa0326c21f2e1 Mon Sep 17 00:00:00 2001 From: Narayan Desai Date: Wed, 9 Jan 2008 21:21:18 +0000 Subject: Replace bcfg2 proxy code with simplified code from Cobalt git-svn-id: https://svn.mcs.anl.gov/repos/bcfg/trunk/bcfg2@4226 ce84e21b-d406-0410-9b95-82705330c041 --- src/lib/Proxy.py | 188 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 src/lib/Proxy.py (limited to 'src/lib/Proxy.py') diff --git a/src/lib/Proxy.py b/src/lib/Proxy.py new file mode 100644 index 000000000..5bcc78ad1 --- /dev/null +++ b/src/lib/Proxy.py @@ -0,0 +1,188 @@ +"""RPC client access to cobalt components. + +Classes: +ComponentProxy -- an RPC client proxy to Cobalt components + +Functions: +load_config -- read configuration files +""" + +__revision__ = '$Revision: $' + +from ConfigParser import SafeConfigParser, NoSectionError +import logging, socket, urlparse, time, Bcfg2.tlslite.errors +from Bcfg2.tlslite.integration.XMLRPCTransport import XMLRPCTransport +import xmlrpclib +from xmlrpclib import _Method + +__all__ = [ + "ComponentProxy", "ComponentLookupError", "RetryMethod", + "register_component", "find_configured_servers", +] + +local_components = dict() +known_servers = dict() + +def register_component (component): + local_components[component.name] = component + + +class ComponentError (Exception): + + """Component error baseclass""" + + +class ComponentLookupError (ComponentError): + + """Unable to locate an address for the given component.""" + + +class ComponentOperationError (ComponentError): + + """Component Failure during operation""" + + +class RetryMethod(_Method): + """Method with error handling and retries built in""" + log = logging.getLogger('xmlrpc') + def __call__(self, *args): + max_retries = 4 + for retry in range(max_retries): + try: + return _Method.__call__(self, *args) + except xmlrpclib.ProtocolError: + self.log.error("Server failure: Protocol Error") + raise xmlrpclib.Fault(20, "Server Failure") + except socket.error: + pass + except Bcfg2.tlslite.errors.TLSFingerprintError, err: + self.log.error("Server fingerprint did not match") + errmsg = err.message.split() + self.log.error("Got %s expected %s" % (errmsg[3], errmsg[4])) + raise SystemExit, 1 + except: + self.log.error("Unknown failure", exc_info=1) + break + time.sleep(0.5) + raise xmlrpclib.Fault(20, "Server Failure") + +# sorry jon +xmlrpclib._Method = RetryMethod + +def ComponentProxy (component_name, defer=False, user=None, password=None, + fingerprint=None): + + """Constructs proxies to components. + + Arguments: + component_name -- name of the component to connect to + + Additional arguments are passed to the ServerProxy constructor. + """ + + if defer: + return DeferredProxy(component_name) + + if component_name in local_components: + return LocalProxy(local_components[component_name]) + elif component_name in known_servers: + url = known_servers[component_name] + elif component_name != "service-location": + try: + slp = ComponentProxy("service-location") + except ComponentLookupError: + raise ComponentLookupError(component_name) + try: + url = slp.locate(component_name) + except: + raise ComponentLookupError(component_name) + if not url: + raise ComponentLookupError(component_name) + else: + raise ComponentLookupError(component_name) + # process url + if user and password: + method, path = urlparse.urlparse(url)[:2] + newurl = "%s://%s:%s@%s" % (method, user, password, path) + else: + newurl = url + return xmlrpclib.ServerProxy(newurl, allow_none=True, + transport=XMLRPCTransport(x509Fingerprint=fingerprint)) + +class LocalProxy (object): + + """Proxy-like filter for inter-component communication. + + Used to access other components stored in local memory, + without having to transport across tcp/http. + + Dispatches method calls through the component's _dispatch + method to keep the interface between this and ServerProxy + consistent. + """ + + def __init__ (self, component): + self._component = component + + def __getattr__ (self, attribute): + return LocalProxyMethod(self, attribute) + + +class LocalProxyMethod (object): + + def __init__ (self, proxy, func_name): + self._proxy = proxy + self._func_name = func_name + + def __call__ (self, *args): + return self._proxy._component._dispatch(self._func_name, args) + + +class DeferredProxy (object): + + """Defering proxy object. + + Gets a new proxy when it can't connect to a component. + """ + + def __init__ (self, component_name): + self._component_name = component_name + + def __getattr__ (self, attribute): + return DeferredProxyMethod(self, attribute) + + +class DeferredProxyMethod (object): + + def __init__ (self, proxy, func_name): + self._proxy = proxy + self._func_name = func_name + + def __call__ (self, *args): + proxy = ComponentProxy(self._proxy._component_name, defer=False) + func = getattr(proxy, self._func_name) + return func(*args) + + +def find_configured_servers (config_files=None): + """Read associated config files into the module. + + Arguments: + config_files -- a list of paths to config files. + """ + if not config_files: + config_files = ['/etc/bcfg2.conf'] + config = SafeConfigParser() + config.read(config_files) + try: + components = config.options("components") + except NoSectionError: + return [] + known_servers.clear() + known_servers.update(dict([ + (component, config.get("components", component)) + for component in components + ])) + return known_servers.copy() + +find_configured_servers() -- cgit v1.2.3-1-g7c22