Decuple ConnectorThread from SocketAppender so that it is reusable.

socketappender.h: Move ConnectorThread out of SocketAppender.
Add new interface IConnectorThreadClient.

socketappender.cxx: Accommodate the move of ConnectorThread. Use IConnectorThreadClient
interface. Implement IConnectorThreadClient in SocketAppender.

Author: wilx

include/log4cplus/socketappender.h

@@ -38,6 +38,50 @@
 
 namespace log4cplus
 {
+
+
+#if ! defined (LOG4CPLUS_SINGLE_THREADED)
+
+namespace helpers
+{
+
+class LOG4CPLUS_EXPORT ConnectorThread;
+
+class LOG4CPLUS_EXPORT IConnectorThreadClient
+{
+protected:
+    virtual ~IConnectorThreadClient ();
+
+    virtual thread::Mutex const & ctcGetAccessMutex () const = 0;
+    virtual helpers::Socket & ctcGetSocket () = 0;
+    virtual helpers::Socket ctcConnect () = 0;
+    virtual void ctcSetConnected () = 0;
+
+    friend class LOG4CPLUS_EXPORT ConnectorThread;
+};
+
+
+class LOG4CPLUS_EXPORT ConnectorThread
+    : public thread::AbstractThread
+{
+public:
+    ConnectorThread (IConnectorThreadClient &);
+    virtual ~ConnectorThread ();
+    
+    virtual void run();
+    
+    void terminate ();
+    void trigger ();
+    
+protected:
+    IConnectorThreadClient & ctc;
+    thread::ManualResetEvent trigger_ev;
+    bool exit_flag;
+};
+
+} // namespace helpers
+
+#endif
 
 
 #ifndef UNICODE
@@ -98,7 +142,10 @@ namespace log4cplus
      *
      * </dl>
      */
-    class LOG4CPLUS_EXPORT SocketAppender : public Appender {
+    class LOG4CPLUS_EXPORT SocketAppender
+        : public Appender 
+        , protected virtual helpers::IConnectorThreadClient
+    {
     public:
       // Ctors
         SocketAppender(const log4cplus::tstring& host, unsigned short port, 
@@ -123,29 +170,13 @@ namespace log4cplus
         log4cplus::tstring serverName;
 
 #if ! defined (LOG4CPLUS_SINGLE_THREADED)
-        class LOG4CPLUS_EXPORT ConnectorThread;
-        friend class ConnectorThread;
-
-        class LOG4CPLUS_EXPORT ConnectorThread
-            : public thread::AbstractThread
-        {
-        public:
-            ConnectorThread (SocketAppender &);
-            virtual ~ConnectorThread ();
-
-            virtual void run();
-
-            void terminate ();
-            void trigger ();
-
-        protected:
-            SocketAppender & sa;
-            thread::ManualResetEvent trigger_ev;
-            bool exit_flag;
-        };
+        virtual thread::Mutex const & ctcGetAccessMutex () const;
+        virtual helpers::Socket & ctcGetSocket ();
+        virtual helpers::Socket ctcConnect ();
+        virtual void ctcSetConnected ();
 
         volatile bool connected;
-        helpers::SharedObjectPtr<ConnectorThread> connector;
+        helpers::SharedObjectPtr<helpers::ConnectorThread> connector;
 #endif
 
     private:

src/socketappender.cxx

@@ -34,27 +34,37 @@ int const LOG4CPLUS_MESSAGE_VERSION = 3;
 
 
 #if ! defined (LOG4CPLUS_SINGLE_THREADED)
-SocketAppender::ConnectorThread::ConnectorThread (
-    SocketAppender & socket_appender)
-    : sa (socket_appender)
+
+namespace helpers
+{
+
+IConnectorThreadClient::~IConnectorThreadClient ()
+{ }
+
+//
+//
+//
+
+ConnectorThread::ConnectorThread (
+    IConnectorThreadClient & client)
+    : ctc (client)
     , exit_flag (false)
 { }
 
 
-SocketAppender::ConnectorThread::~ConnectorThread ()
+ConnectorThread::~ConnectorThread ()
 { }
 
 
 void
-SocketAppender::ConnectorThread::run ()
+ConnectorThread::run ()
 {
     while (true)
     {
         trigger_ev.timed_wait (30 * 1000);
 
         helpers::getLogLog().debug (
-            LOG4CPLUS_TEXT("SocketAppender::ConnectorThread::run()")
-            LOG4CPLUS_TEXT("- running..."));
+            LOG4CPLUS_TEXT("ConnectorThread::run()- running..."));
 
         // Check exit condition as the very first thing.
 
@@ -67,16 +77,17 @@ SocketAppender::ConnectorThread::run ()
 
         // Do not try to re-open already open socket.
 
+        helpers::Socket & client_socket = ctc.ctcGetSocket ();
+        thread::Mutex const & client_access_mutex = ctc.ctcGetAccessMutex ();
         {
-            thread::MutexGuard guard (sa.access_mutex);
-            if (sa.socket.isOpen ())
+            thread::MutexGuard guard (client_access_mutex);
+            if (client_socket.isOpen ())
                 continue;
         }
 
         // The socket is not open, try to reconnect.
 
-        helpers::Socket new_socket (sa.host,
-            static_cast<unsigned short>(sa.port));
+        helpers::Socket new_socket (ctc.ctcConnect ());
         if (! new_socket.isOpen ())
         {
             helpers::getLogLog().error(
@@ -91,19 +102,19 @@ SocketAppender::ConnectorThread::run ()
             continue;
         }
 
-        // Connection was successful, move the socket into SocketAppender.
+        // Connection was successful, move the socket into client.
 
         {
-            thread::MutexGuard guard (sa.access_mutex);
-            sa.socket = new_socket;
-            sa.connected = true;
+            thread::MutexGuard guard (client_access_mutex);
+            client_socket = new_socket;
+            ctc.ctcSetConnected ();
         }
     }
 }
 
 
 void
-SocketAppender::ConnectorThread::terminate ()
+ConnectorThread::terminate ()
 {
     {
         thread::MutexGuard guard (access_mutex);
@@ -115,11 +126,13 @@ SocketAppender::ConnectorThread::terminate ()
 
 
 void
-SocketAppender::ConnectorThread::trigger ()
+ConnectorThread::trigger ()
 {
     trigger_ev.signal ();
 }
 
+} // namespace helpers
+
 #endif
 
 
@@ -155,10 +168,6 @@ SocketAppender::SocketAppender(const helpers::Properties & properties)
 
 SocketAppender::~SocketAppender()
 {
-#if ! defined (LOG4CPLUS_SINGLE_THREADED)
-    connector->terminate ();
-#endif
-
     destructorImpl();
 }
 
@@ -202,7 +211,7 @@ SocketAppender::initConnector ()
 {
 #if ! defined (LOG4CPLUS_SINGLE_THREADED)
     connected = true;
-    connector = new ConnectorThread (*this);
+    connector = new helpers::ConnectorThread (*this);
     connector->start ();
 #endif
 }
@@ -248,6 +257,34 @@ SocketAppender::append(const spi::InternalLoggingEvent& event)
 }
 
 
+thread::Mutex const &
+SocketAppender::ctcGetAccessMutex () const
+{
+    return access_mutex;
+}
+
+
+helpers::Socket &
+SocketAppender::ctcGetSocket ()
+{
+    return socket;
+}
+
+
+helpers::Socket
+SocketAppender::ctcConnect ()
+{
+    return helpers::Socket (host, static_cast<unsigned short>(port));
+}
+
+void
+SocketAppender::ctcSetConnected ()
+{
+    connected = true;
+}
+
+
+
 /////////////////////////////////////////////////////////////////////////////
 // namespace helpers methods
 /////////////////////////////////////////////////////////////////////////////