Ported xmlclient to subclass from Connectible

3 files changed, 36 insertions, 48 deletions

diff --git a/ipalib/backend.py b/ipalib/backend.py
index e286c5079..bb8d31012 100644
--- a/ipalib/backend.py
+++ b/ipalib/backend.py
@@ -36,26 +36,36 @@ class Backend(plugable.Plugin):
 
 
 class Connectible(Backend):
-    # Override in subclass:
-    connection_klass = None
-
     def connect(self, *args, **kw):
         """
         Create thread-local connection.
         """
         if hasattr(context, self.name):
             raise StandardError(
-                "connection 'context.%s' already exists in thread %r" % (
+                "connect: 'context.%s' already exists in thread %r" % (
                     self.name, threading.currentThread().getName()
                 )
             )
-        if not issubclass(self.connection_klass, Connection):
-            raise ValueError(
-                '%s.connection_klass must be a request.Connection subclass' % self.name
+        conn = self.create_connection(*args, **kw)
+        setattr(context, self.name, Connection(conn, self.disconnect))
+        assert self.conn is conn
+        self.info('Created connection context.%s' % self.name)
+
+    def create_connection(self, *args, **kw):
+        raise NotImplementedError('%s.create_connection()' % self.name)
+
+    def disconnect(self):
+        if not hasattr(context, self.name):
+            raise StandardError(
+                "disconnect: 'context.%s' does not exist in thread %r" % (
+                    self.name, threading.currentThread().getName()
+                )
             )
-        conn = self.connection_klass(*args, **kw)
-        setattr(context, self.name, conn)
-        assert self.conn is conn.conn
+        self.destroy_connection()
+        self.info('Destroyed connection context.%s' % self.name)
+
+    def destroy_connection(self):
+        raise NotImplementedError('%s.destroy_connection()' % self.name)
 
     def isconnected(self):
         """
diff --git a/ipalib/request.py b/ipalib/request.py
index 812e526d6..d2c39c911 100644
--- a/ipalib/request.py
+++ b/ipalib/request.py
@@ -26,7 +26,7 @@ import threading
 import locale
 import gettext
 from base import ReadOnly, lock
-from constants import OVERRIDE_ERROR
+from constants import OVERRIDE_ERROR, CALLABLE_ERROR
 
 
 # Thread-local storage of most per-request information
@@ -38,22 +38,15 @@ class Connection(ReadOnly):
     Base class for connection objects stored on `request.context`.
     """
 
-    def __init__(self, *args, **kw):
-        self.conn = self.create(*args, **kw)
+    def __init__(self, conn, disconnect):
+        self.conn = conn
+        if not callable(disconnect):
+            raise TypeError(
+               CALLABLE_ERROR % ('disconnect', disconnect, type(disconnect))
+            )
+        self.disconnect = disconnect
         lock(self)
 
-    def create(self, *args, **kw):
-        """
-        Create and return the connection (implement in subclass).
-        """
-        raise NotImplementedError('%s.create()' % self.__class__.__name__)
-
-    def close(self):
-        """
-        Close the connection (implement in subclass).
-        """
-        raise NotImplementedError('%s.close()' % self.__class__.__name__)
-
 
 def destroy_context():
     """
@@ -61,7 +54,7 @@ def destroy_context():
     """
     for (name, value) in context.__dict__.items():
         if isinstance(value, Connection):
-            value.close()
+            value.disconnect()
         delattr(context, name)
 
 
diff --git a/ipalib/rpc.py b/ipalib/rpc.py
index b6db683e3..a70b372bd 100644
--- a/ipalib/rpc.py
+++ b/ipalib/rpc.py
@@ -35,7 +35,7 @@ import threading
 import socket
 from xmlrpclib import Binary, Fault, dumps, loads, ServerProxy, SafeTransport
 import kerberos
-from ipalib.backend import Backend
+from ipalib.backend import Connectible
 from ipalib.errors2 import public_errors, PublicError, UnknownError, NetworkError
 from ipalib import errors2
 from ipalib.request import context
@@ -205,35 +205,26 @@ class KerbTransport(SafeTransport):
         return (host, extra_headers, x509)
 
 
-class xmlclient(Backend):
+class xmlclient(Connectible):
     """
     Forwarding backend plugin for XML-RPC client.
 
     Also see the `ipaserver.rpcserver.xmlserver` plugin.
     """
 
-    connection_name = 'xmlconn'
-
     def __init__(self):
         super(xmlclient, self).__init__()
         self.__errors = dict((e.errno, e) for e in public_errors)
 
-    def connect(self, ccache=None, user=None, password=None):
-        if hasattr(context, self.connection_name):
-            raise StandardError(
-                '%s.connect(): context.%s already exists in thread %r' % (
-                    self.name, self.connection_name, threading.currentThread().getName()
-                )
-            )
-        conn = ServerProxy(self.env.xmlrpc_uri,
+    def create_connection(self, ccache=None):
+        return ServerProxy(self.env.xmlrpc_uri,
             #transport=KerbTransport(),
             allow_none=True,
             encoding='UTF-8',
         )
-        setattr(context, self.connection_name, conn)
 
-    def get_connection(self):
-        return getattr(context, self.connection_name)
+    def destroy_connection(self):
+        pass
 
     def forward(self, name, *args, **kw):
         """
@@ -250,13 +241,7 @@ class xmlclient(Backend):
             raise ValueError(
                 '%s.forward(): %r not in api.Command' % (self.name, name)
             )
-        if not hasattr(context, 'xmlconn'):
-            raise StandardError(
-                '%s.forward(%r): need context.xmlconn in thread %r' % (
-                    self.name, name, threading.currentThread().getName()
-                )
-            )
-        command = getattr(context.xmlconn, name)
+        command = getattr(self.conn, name)
         params = args + (kw,)
         try:
             response = command(*xml_wrap(params))