Refactor implementation of Ice::Application in C++

1 files changed, 257 insertions, 295 deletions

diff --git a/cpp/src/Ice/Application.cpp b/cpp/src/Ice/Application.cpp
index a2b733053e0..976026dfe45 100644
--- a/cpp/src/Ice/Application.cpp
+++ b/cpp/src/Ice/Application.cpp
@@ -9,11 +9,15 @@
 
 #include <Ice/Application.h>
 #include <Ice/LoggerI.h>
-#include <IceUtil/Mutex.h>
+#include <Ice/LoggerUtil.h>
 #include <IceUtil/CtrlCHandler.h>
-#include <IceUtil/Cond.h>
 #include <IceUtil/ArgVector.h>
-#include <Ice/UniquePtr.h>
+
+#ifdef _WIN32
+const DWORD SIGHUP = CTRL_LOGOFF_EVENT;
+#else
+#   include <csignal>
+#endif
 
 using namespace std;
 using namespace Ice;
@@ -21,50 +25,23 @@ using namespace IceUtil;
 using namespace IceUtilInternal;
 
 //
-// static initializations.
+// static member initialization
 //
-Mutex* IceInternal::Application::mutex = 0;
+IceUtil::Mutex Ice::Application::_mutex;
+IceUtil::Cond Ice::Application::_condVar;
 
-bool IceInternal::Application::_callbackInProgress = false;
-bool IceInternal::Application::_destroyed = false;
-bool IceInternal::Application::_interrupted = false;
+bool Ice::Application::_callbackInProgress = false;
+bool Ice::Application::_destroyed = false;
+bool Ice::Application::_interrupted = false;
 
-string IceInternal::Application::_appName;
-CommunicatorPtr IceInternal::Application::_communicator;
-SignalPolicy IceInternal::Application::_signalPolicy = HandleSignals;
-Cond* IceInternal::Application::_condVar;
-Application* IceInternal::Application::_application;
-//
-// _mutex and _condVar are used to synchronize the main thread and
-// the CtrlCHandler thread
-//
+string Ice::Application::_appName;
+Ice::CommunicatorPtr Ice::Application::_communicator;
+Ice::SignalPolicy Ice::Application::_signalPolicy = Ice::HandleSignals;
+Ice::Application* Ice::Application::_application = 0;
 
 namespace
 {
 
-class Init
-{
-public:
-
-    Init()
-    {
-        IceInternal::Application::mutex = new IceUtil::Mutex;
-        IceInternal::Application::_condVar = new Cond();
-    }
-
-    ~Init()
-    {
-        delete IceInternal::Application::mutex;
-        IceInternal::Application::mutex = 0;
-        delete IceInternal::Application::_condVar;
-        IceInternal::Application::_condVar = 0;
-    }
-};
-
-Init init;
-
-
-
 //
 // Variables than can change while run() and communicator->destroy() are running!
 //
@@ -81,218 +58,9 @@ bool _nohup = false;
 
 }
 
-#ifdef _WIN32
-const DWORD SIGHUP = CTRL_LOGOFF_EVENT;
-#else
-#   include <csignal>
-#endif
-
-//
-// Compaq C++ defines signal() as a macro, causing problems with the _condVar->signal()
-// statement, which the compiler for some reason replaces by the macro.
-//
-#if defined (__digital__) && defined (__unix__)
-#   undef signal
-#endif
-
-//
-// CtrlCHandler callbacks.
-//
-
-static void
-holdInterruptCallback(int signal)
-{
-    CtrlCHandlerCallback callback = 0;
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        while(!_released)
-        {
-            IceInternal::Application::_condVar->wait(lock);
-        }
-
-        if(IceInternal::Application::_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        assert(_ctrlCHandler != 0);
-        callback = _ctrlCHandler->getCallback();
-    }
-
-    if(callback != 0)
-    {
-        callback(signal);
-    }
-}
-
-static void
-destroyOnInterruptCallback(int signal)
-{
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        if(IceInternal::Application::_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        if(_nohup && signal == static_cast<int>(SIGHUP))
-        {
-            return;
-        }
-
-        assert(!IceInternal::Application::_callbackInProgress);
-        IceInternal::Application::_callbackInProgress = true;
-        IceInternal::Application::_interrupted = true;
-        IceInternal::Application::_destroyed = true;
-    }
-
-    try
-    {
-        assert(IceInternal::Application::_communicator != 0);
-        IceInternal::Application::_communicator->destroy();
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << "(while destroying in response to signal " << signal << "): " << ex;
-    }
-    catch(const std::string& msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while destroying in response to signal " << signal << "): " << msg;
-    }
-    catch(const char* msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while destroying in response to signal " << signal << "): " << msg;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "(while destroying in response to signal " << signal << "): unknown exception";
-    }
-
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        IceInternal::Application::_callbackInProgress = false;
-    }
-    IceInternal::Application::_condVar->signal();
-}
-
-static void
-shutdownOnInterruptCallback(int signal)
-{
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        if(IceInternal::Application::_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        if(_nohup && signal == static_cast<int>(SIGHUP))
-        {
-            return;
-        }
-
-        assert(!IceInternal::Application::_callbackInProgress);
-        IceInternal::Application::_callbackInProgress = true;
-        IceInternal::Application::_interrupted = true;
-    }
-
-    try
-    {
-        assert(IceInternal::Application::_communicator != 0);
-        IceInternal::Application::_communicator->shutdown();
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << "(while shutting down in response to signal " << signal << "): std::exception: " << ex;
-    }
-    catch(const std::string& msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while shutting down in response to signal " << signal << "): " << msg;
-    }
-    catch(const char* msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while shutting down in response to signal " << signal << "): " << msg;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "(while shutting down in response to signal " << signal << "): unknown exception";
-    }
-
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        IceInternal::Application::_callbackInProgress = false;
-    }
-    IceInternal::Application::_condVar->signal();
-}
-
-static void
-callbackOnInterruptCallback(int signal)
-{
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        if(IceInternal::Application::_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        // For SIGHUP the user callback is always called. It can
-        // decide what to do.
-        assert(!IceInternal::Application::_callbackInProgress);
-        IceInternal::Application::_callbackInProgress = true;
-        IceInternal::Application::_interrupted = true;
-    }
-
-    try
-    {
-        assert(IceInternal::Application::_application != 0);
-        IceInternal::Application::_application->interruptCallback(signal);
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): std::exception: " << ex;
-    }
-    catch(const std::string& msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): " << msg;
-    }
-    catch(const char* msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): " << msg;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): unknown exception";
-    }
-
-    {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        IceInternal::Application::_callbackInProgress = false;
-    }
-    IceInternal::Application::_condVar->signal();
-}
-
 Ice::Application::Application(SignalPolicy signalPolicy)
 {
-    IceInternal::Application::_signalPolicy = signalPolicy;
+    Ice::Application::_signalPolicy = signalPolicy;
 }
 
 Ice::Application::~Application()
@@ -306,10 +74,10 @@ Ice::Application::main(int argc, char* argv[], const char* configFile)
     // We don't call the main below to avoid a deprecated warning
     //
 
-    IceInternal::Application::_appName = "";
+    _appName = "";
     if(argc > 0)
     {
-        IceInternal::Application::_appName = argv[0];
+        _appName = argv[0];
     }
 
     if(argc > 0 && argv[0] && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
@@ -367,12 +135,12 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initial
     if(argc > 0 && argv[0] && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
     {
         const bool convert = initializationData.properties ?
-                initializationData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
-                initializationData.properties->getProperty("Ice.StdErr").empty() : true;
+            initializationData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
+            initializationData.properties->getProperty("Ice.StdErr").empty() : true;
         setProcessLogger(ICE_MAKE_SHARED(LoggerI, argv[0], "", convert));
     }
 
-    if(IceInternal::Application::_communicator != 0)
+    if(_communicator != 0)
     {
         Error out(getProcessLogger());
         out << "only one instance of the Application class can be used";
@@ -400,17 +168,16 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initial
         out << "unknown exception";
         return EXIT_FAILURE;
     }
-    IceInternal::Application::_appName = initData.properties->getPropertyWithDefault("Ice.ProgramName",
-                                                                                 IceInternal::Application::_appName);
+    _appName = initData.properties->getPropertyWithDefault("Ice.ProgramName", _appName);
 
     //
     // Used by destroyOnInterruptCallback and shutdownOnInterruptCallback.
     //
     _nohup = initData.properties->getPropertyAsInt("Ice.Nohup") > 0;
 
-    IceInternal::Application::_application = this;
+    _application = this;
 
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         try
         {
@@ -479,27 +246,27 @@ Ice::Application::interruptCallback(int)
 const char*
 Ice::Application::appName()
 {
-    return IceInternal::Application::_appName.c_str();
+    return _appName.c_str();
 }
 
 CommunicatorPtr
 Ice::Application::communicator()
 {
-    return IceInternal::Application::_communicator;
+    return _communicator;
 }
 
 void
 Ice::Application::destroyOnInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                IceInternal::Application::_condVar->signal();
+                _condVar.signal();
             }
             _ctrlCHandler->setCallback(destroyOnInterruptCallback);
         }
@@ -514,15 +281,15 @@ Ice::Application::destroyOnInterrupt()
 void
 Ice::Application::shutdownOnInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                IceInternal::Application::_condVar->signal();
+                _condVar.signal();
             }
             _ctrlCHandler->setCallback(shutdownOnInterruptCallback);
         }
@@ -537,15 +304,15 @@ Ice::Application::shutdownOnInterrupt()
 void
 Ice::Application::ignoreInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                IceInternal::Application::_condVar->signal();
+                _condVar.signal();
             }
             _ctrlCHandler->setCallback(0);
         }
@@ -560,15 +327,15 @@ Ice::Application::ignoreInterrupt()
 void
 Ice::Application::callbackOnInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                IceInternal::Application::_condVar->signal();
+                _condVar.signal();
             }
             _ctrlCHandler->setCallback(callbackOnInterruptCallback);
         }
@@ -583,11 +350,11 @@ Ice::Application::callbackOnInterrupt()
 void
 Ice::Application::holdInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() != holdInterruptCallback)
             {
                 _previousCallback = _ctrlCHandler->getCallback();
@@ -607,11 +374,11 @@ Ice::Application::holdInterrupt()
 void
 Ice::Application::releaseInterrupt()
 {
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); // we serialize all the interrupt-setting
+            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 //
@@ -623,7 +390,7 @@ Ice::Application::releaseInterrupt()
 
                 _released = true;
                 _ctrlCHandler->setCallback(_previousCallback);
-                IceInternal::Application::_condVar->signal();
+                _condVar.signal();
             }
             // Else nothing to release.
         }
@@ -638,8 +405,8 @@ Ice::Application::releaseInterrupt()
 bool
 Ice::Application::interrupted()
 {
-    IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-    return IceInternal::Application::_interrupted;
+    Mutex::Lock lock(_mutex);
+    return _interrupted;
 }
 
 int
@@ -649,7 +416,7 @@ Ice::Application::doMain(int argc, char* argv[], const InitializationData& initD
 
     try
     {
-        IceInternal::Application::_interrupted = false;
+        _interrupted = false;
 
         //
         // If the process logger is the default logger, we now replace it with a
@@ -664,13 +431,13 @@ Ice::Application::doMain(int argc, char* argv[], const InitializationData& initD
             setProcessLogger(ICE_MAKE_SHARED(LoggerI, initData.properties->getProperty("Ice.ProgramName"), "", convert));
         }
 
-        IceInternal::Application::_communicator = initialize(argc, argv, initData);
-        IceInternal::Application::_destroyed = false;
+        _communicator = initialize(argc, argv, initData);
+        _destroyed = false;
 
         //
         // The default is to destroy when a signal is received.
         //
-        if(IceInternal::Application::_signalPolicy == HandleSignals)
+        if(_signalPolicy == HandleSignals)
         {
             destroyOnInterrupt();
         }
@@ -707,38 +474,38 @@ Ice::Application::doMain(int argc, char* argv[], const InitializationData& initD
     // it would not make sense to release a held signal to run
     // shutdown or destroy.
     //
-    if(IceInternal::Application::_signalPolicy == HandleSignals)
+    if(_signalPolicy == HandleSignals)
     {
         ignoreInterrupt();
     }
 
     {
-        IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex);
-        while(IceInternal::Application::_callbackInProgress)
+        Mutex::Lock lock(_mutex);
+        while(_callbackInProgress)
         {
-            IceInternal::Application::_condVar->wait(lock);
+            _condVar.wait(lock);
         }
-        if(IceInternal::Application::_destroyed)
+        if(_destroyed)
         {
-            IceInternal::Application::_communicator = 0;
+            _communicator = 0;
         }
         else
         {
-            IceInternal::Application::_destroyed = true;
+            _destroyed = true;
             //
             // And _communicator != 0, meaning will be destroyed
             // next, _destroyed = true also ensures that any
             // remaining callback won't do anything
             //
         }
-        IceInternal::Application::_application = 0;
+        _application = 0;
     }
 
-    if(IceInternal::Application::_communicator != 0)
+    if(_communicator != 0)
     {
         try
         {
-            IceInternal::Application::_communicator->destroy();
+            _communicator->destroy();
         }
         catch(const std::exception& ex)
         {
@@ -752,8 +519,203 @@ Ice::Application::doMain(int argc, char* argv[], const InitializationData& initD
             out << "unknown exception";
             status = EXIT_FAILURE;
         }
-        IceInternal::Application::_communicator = 0;
+        _communicator = 0;
     }
 
     return status;
 }
+
+//
+// CtrlCHandler callbacks.
+//
+
+void
+Ice::Application::holdInterruptCallback(int signal)
+{
+    CtrlCHandlerCallback callback = 0;
+    {
+        Mutex::Lock lock(_mutex);
+        while(!_released)
+        {
+            _condVar.wait(lock);
+        }
+
+        if(_destroyed)
+        {
+            //
+            // Being destroyed by main thread
+            //
+            return;
+        }
+        assert(_ctrlCHandler != 0);
+        callback = _ctrlCHandler->getCallback();
+    }
+
+    if(callback != 0)
+    {
+        callback(signal);
+    }
+}
+
+void
+Ice::Application::destroyOnInterruptCallback(int signal)
+{
+    {
+        Mutex::Lock lock(_mutex);
+        if(_destroyed)
+        {
+            //
+            // Being destroyed by main thread
+            //
+            return;
+        }
+        if(_nohup && signal == static_cast<int>(SIGHUP))
+        {
+            return;
+        }
+
+        assert(!_callbackInProgress);
+        _callbackInProgress = true;
+        _interrupted = true;
+        _destroyed = true;
+    }
+
+    try
+    {
+        assert(_communicator != 0);
+        _communicator->destroy();
+    }
+    catch(const std::exception& ex)
+    {
+        Error out(getProcessLogger());
+        out << "(while destroying in response to signal " << signal << "): " << ex;
+    }
+    catch(const std::string& msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while destroying in response to signal " << signal << "): " << msg;
+    }
+    catch(const char* msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while destroying in response to signal " << signal << "): " << msg;
+    }
+    catch(...)
+    {
+        Error out(getProcessLogger());
+        out << "(while destroying in response to signal " << signal << "): unknown exception";
+    }
+
+    {
+        Mutex::Lock lock(_mutex);
+        _callbackInProgress = false;
+    }
+    _condVar.signal();
+}
+
+void
+Ice::Application::shutdownOnInterruptCallback(int signal)
+{
+    {
+        Mutex::Lock lock(_mutex);
+        if(_destroyed)
+        {
+            //
+            // Being destroyed by main thread
+            //
+            return;
+        }
+        if(_nohup && signal == static_cast<int>(SIGHUP))
+        {
+            return;
+        }
+
+        assert(!_callbackInProgress);
+        _callbackInProgress = true;
+        _interrupted = true;
+    }
+
+    try
+    {
+        assert(_communicator != 0);
+        _communicator->shutdown();
+    }
+    catch(const std::exception& ex)
+    {
+        Error out(getProcessLogger());
+        out << "(while shutting down in response to signal " << signal << "): std::exception: " << ex;
+    }
+    catch(const std::string& msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while shutting down in response to signal " << signal << "): " << msg;
+    }
+    catch(const char* msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while shutting down in response to signal " << signal << "): " << msg;
+    }
+    catch(...)
+    {
+        Error out(getProcessLogger());
+        out << "(while shutting down in response to signal " << signal << "): unknown exception";
+    }
+
+    {
+        Mutex::Lock lock(_mutex);
+        _callbackInProgress = false;
+    }
+    _condVar.signal();
+}
+
+void
+Ice::Application::callbackOnInterruptCallback(int signal)
+{
+    {
+        Mutex::Lock lock(_mutex);
+        if(_destroyed)
+        {
+            //
+            // Being destroyed by main thread
+            //
+            return;
+        }
+        // For SIGHUP the user callback is always called. It can
+        // decide what to do.
+        assert(!_callbackInProgress);
+        _callbackInProgress = true;
+        _interrupted = true;
+    }
+
+    try
+    {
+        assert(_application != 0);
+        _application->interruptCallback(signal);
+    }
+    catch(const std::exception& ex)
+    {
+        Error out(getProcessLogger());
+        out << "(while interrupting in response to signal " << signal << "): std::exception: " << ex;
+    }
+    catch(const std::string& msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while interrupting in response to signal " << signal << "): " << msg;
+    }
+    catch(const char* msg)
+    {
+        Error out(getProcessLogger());
+        out << "(while interrupting in response to signal " << signal << "): " << msg;
+    }
+    catch(...)
+    {
+        Error out(getProcessLogger());
+        out << "(while interrupting in response to signal " << signal << "): unknown exception";
+    }
+
+    {
+        Mutex::Lock lock(_mutex);
+        _callbackInProgress = false;
+    }
+    _condVar.signal();
+}