3772. Recovering from Glacier2 / Ice router session failure.

4 files changed, 531 insertions, 97 deletions

diff --git a/cpp/src/Glacier2/Application.cpp b/cpp/src/Glacier2/Application.cpp
new file mode 100644
index 00000000000..ac5b1dd9f8a
--- /dev/null
+++ b/cpp/src/Glacier2/Application.cpp
@@ -0,0 +1,426 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Glacier2/Application.h>
+#include <IceUtil/IceUtil.h>
+#include <IceUtil/ArgVector.h>
+
+using namespace std;
+using namespace Ice;
+    
+Ice::ObjectAdapterPtr Glacier2::Application::_adapter;
+Glacier2::RouterPrx Glacier2::Application::_router;
+Glacier2::SessionPrx Glacier2::Application::_session;
+bool Glacier2::Application::_createdSession = false;
+
+namespace
+{
+
+class SessionPingThread : virtual public IceUtil::Shared
+{
+    
+public:
+    
+    virtual void done() = 0;
+};
+typedef IceUtil::Handle<SessionPingThread> SessionPingThreadPtr;
+
+class AMI_Router_refreshSessionI : public Glacier2::AMI_Router_refreshSession
+{
+
+public:
+
+    AMI_Router_refreshSessionI(Glacier2::Application* app, const SessionPingThreadPtr& pinger) :
+        _app(app),
+        _pinger(pinger)
+    {
+    }
+    
+    void
+    ice_response()
+    {
+    }
+
+    void
+    ice_exception(const Ice::Exception& ex)
+    {
+        // Here the session has gone. The thread
+        // terminates, and we notify the
+        // application that the session has been
+        // destroyed.
+        _pinger->done();
+        _app->sessionDestroyed();
+    }
+
+private:
+        
+    Glacier2::Application* _app;
+    SessionPingThreadPtr _pinger;
+};
+
+class SessionPingThreadI : virtual public IceUtil::Thread, virtual public SessionPingThread
+{
+    
+public:
+    
+    SessionPingThreadI(Glacier2::Application* app, const Glacier2::RouterPrx& router, long period) :
+        _app(app),
+        _router(router),
+        _period(period),
+        _done(false)
+    {
+    }
+
+    void
+    run()
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        while(true)
+        {
+            _router->refreshSession_async(new AMI_Router_refreshSessionI(_app, this));
+
+            if(!_done)
+            {
+                _monitor.timedWait(IceUtil::Time::seconds((int)_period));
+            }
+            if(_done)
+            {
+                break;
+            }
+        }
+    }
+
+    void
+    done()
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        if(!_done)
+        {
+            _done = true;
+            _monitor.notify();
+        }
+    }
+
+private:
+    
+    Glacier2::Application* _app;
+    Glacier2::RouterPrx _router;
+    long _period;
+    bool _done;
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+};
+typedef IceUtil::Handle<SessionPingThreadI> SessionPingThreadIPtr;
+
+}
+
+string
+Glacier2::RestartSessionException::ice_name() const
+{
+    return "RestartSessionException";
+}
+
+Exception*
+Glacier2::RestartSessionException::ice_clone() const
+{
+    return new RestartSessionException(*this);
+}
+
+void
+Glacier2::RestartSessionException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ObjectAdapterPtr
+Glacier2::Application::objectAdapter()
+{
+    if(!_adapter)
+    {
+        // TODO: Depending on the resolution of
+        // http://bugzilla/bugzilla/show_bug.cgi?id=4264 the OA
+        // name could be an empty string.
+        _adapter = communicator()->createObjectAdapterWithRouter(IceUtil::generateUUID(), router());
+        _adapter->activate();
+    }
+    return _adapter;
+}
+
+Ice::ObjectPrx
+Glacier2::Application::addWithUUID(const Ice::ObjectPtr& servant)
+{
+    return objectAdapter()->add(servant, createCallbackIdentity(IceUtil::generateUUID()));
+}
+
+Ice::Identity
+Glacier2::Application::createCallbackIdentity(const string& name)
+{
+    Ice::Identity id;
+    id.name = name;
+    id.category = categoryForClient();
+    return id;
+}
+
+std::string
+Glacier2::Application::categoryForClient()
+{
+    if(!_router)
+    {
+        SessionNotExistException ex;
+        throw ex;
+    }
+    return router()->getCategoryForClient();
+}
+
+int
+Glacier2::Application::doMain(int argc, char* argv[], const Ice::InitializationData& initData)
+{
+    // Set the default properties for all Glacier2 applications.
+    initData.properties->setProperty("Ice.ACM.Client", "0");
+    initData.properties->setProperty("Ice.RetryIntervals", "-1");
+
+    bool restart;
+    int ret = 0;
+    do
+    {
+        // A copy of the initialization data and the string seq
+        // needs to be passed to doMainInternal, as these can be
+        // changed by the application.
+        Ice::InitializationData id(initData);
+        id.properties = id.properties->clone();
+        Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
+
+        restart = doMain(args, id, ret);
+    }
+    while(restart);
+    return ret;
+}
+
+bool
+Glacier2::Application::doMain(Ice::StringSeq& args, const Ice::InitializationData& initData, int& status)
+{
+    // Reset internal state variables from Ice.Application. The
+    // remainder are reset at the end of this method.
+    IceInternal::_callbackInProgress = false;
+    IceInternal::_destroyed = false;
+    IceInternal::_interrupted = false;
+
+    bool restart = false;
+    status = 0;
+
+    SessionPingThreadIPtr ping;
+    try
+    {
+        IceInternal::_communicator = Ice::initialize(args, initData);
+        _router = Glacier2::RouterPrx::uncheckedCast(communicator()->getDefaultRouter());
+        
+        if(!_router)
+        {
+            Error out(getProcessLogger());
+            out << IceInternal::_appName << ": no glacier2 router configured";
+            status = 1;
+        }
+        else
+        {
+            //
+            // The default is to destroy when a signal is received.
+            //
+            if(IceInternal::_signalPolicy == Ice::HandleSignals)
+            {
+                destroyOnInterrupt();
+            }
+
+            // If createSession throws, we're done.
+            try
+            {
+                _session = createSession();
+                _createdSession = true;
+            }
+            catch(const Ice::LocalException& ex)
+            {
+                Error out(getProcessLogger());
+                out << IceInternal::_appName << ": " << ex;
+                status = 1;
+            }
+
+            if(_createdSession)
+            {
+                ping = new SessionPingThreadI(this, _router, (long)_router->getSessionTimeout() / 2);
+                ping->start();
+                IceUtilInternal::ArgVector a(args);
+                status = runWithSession(a.argc, a.argv);
+            }
+        }
+    }
+    // We want to restart on those exceptions which indicate a
+    // break down in communications, but not those exceptions that
+    // indicate a programming logic error (ie: marshal, protocol
+    // failure, etc).
+    catch(const RestartSessionException&)
+    {
+        restart = true;
+    }
+    catch(const Ice::ConnectionRefusedException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        restart = true;
+    }
+    catch(const Ice::ConnectionLostException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        restart = true;
+    }
+    catch(const Ice::UnknownLocalException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        restart = true;
+    }
+    catch(const Ice::RequestFailedException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        restart = true;
+    }
+    catch(const Ice::TimeoutException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        restart = true;
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": " << ex;
+        status = 1;
+    }
+    catch(const std::exception& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": std::exception " << ex;
+        status = 1;
+    }
+    catch(const std::string& ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": c++ exception " << ex;
+        status = 1;
+    }
+    catch(const char* ex)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": char* exception " << ex;
+        status = 1;
+    }
+    catch(...)
+    {
+        Error out(getProcessLogger());
+        out << IceInternal::_appName << ": unknow exception ";
+        status = 1;
+    }
+
+    //
+    // Don't want any new interrupt and at this point (post-run),
+    // it would not make sense to release a held signal to run
+    // shutdown or destroy.
+    //
+    if(IceInternal::_signalPolicy == HandleSignals)
+    {
+        ignoreInterrupt();
+    }
+
+    {
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        while(IceInternal::_callbackInProgress)
+        {
+            IceInternal::_condVar->wait(lock);
+        }
+        if(IceInternal::_destroyed)
+        {
+            IceInternal::_communicator = 0;
+        }
+        else
+        {
+            IceInternal::_destroyed = true;
+            //
+            // And _communicator != 0, meaning will be destroyed
+            // next, _destroyed = true also ensures that any
+            // remaining callback won't do anything
+            //
+        }
+        IceInternal::_application = 0;
+    }
+
+    if(!ping)
+    {
+        ping->done();
+        while(true)
+        {
+            ping->getThreadControl().join();
+            break;
+        }
+        ping = 0;
+    }
+
+    if(_createdSession && _router)
+    {
+        try
+        {
+            _router->destroySession();
+        }
+        catch(const Ice::ConnectionLostException&)
+        {
+            // Expected: the router closed the connection.
+        }
+        catch(const Glacier2::SessionNotExistException&)
+        {
+            // This can also occur.
+        }
+        catch(const exception& ex)
+        {
+            // Not expected.
+            Error out(getProcessLogger());
+            out << "unexpected exception when destroying the session " << ex;
+        }
+        _router = 0;
+    }
+
+    if(IceInternal::_communicator)
+    {
+        try
+        {
+            IceInternal::_communicator->destroy();
+        }
+        catch(const Ice::LocalException& ex)
+        {
+            Error out(getProcessLogger());
+            out << IceInternal::_appName << ": " << ex;
+            status = 1;
+        }
+        catch(const exception& ex)
+        {
+            Error out(getProcessLogger());
+            out << "unknown exception " << ex;
+            status = 1;
+        }
+        IceInternal::_communicator = 0;
+    }
+
+
+    // Reset internal state. We cannot reset the Application state
+    // here, since _destroyed must remain true until we re-run
+    // this method.
+    _adapter = 0;
+    _router = 0;
+    _session = 0;
+    _createdSession = false;
+
+    return restart;
+}
diff --git a/cpp/src/Glacier2/Makefile b/cpp/src/Glacier2/Makefile
index f936fc95556..db08d6d3dda 100644
--- a/cpp/src/Glacier2/Makefile
+++ b/cpp/src/Glacier2/Makefile
@@ -21,7 +21,8 @@ TARGETS         = $(LIBTARGETS) $(ROUTER)
 OBJS		= PermissionsVerifier.o \
 		  Router.o \
 		  SSLInfo.o \
-		  Session.o
+		  Session.o \
+          Application.o
 
 ROBJS		= Blobject.o \
 		  ClientBlobject.o \
diff --git a/cpp/src/Glacier2/Makefile.mak b/cpp/src/Glacier2/Makefile.mak
index 4d6b204ed0b..1243667d97a 100644
--- a/cpp/src/Glacier2/Makefile.mak
+++ b/cpp/src/Glacier2/Makefile.mak
@@ -19,7 +19,8 @@ TARGETS         = $(LIBNAME) $(DLLNAME) $(ROUTER)
 OBJS		= PermissionsVerifier.obj \

 		  Router.obj \

 		  SSLInfo.obj \

-		  Session.obj

+		  Session.obj \

+          Application.obj

 

 ROBJS		= Blobject.obj \

 		  ClientBlobject.obj \

@@ -43,7 +44,7 @@ SDIR		= $(slicedir)\Glacier2
 

 !include $(top_srcdir)\config\Make.rules.mak

 

-CPPFLAGS	= -I.. $(CPPFLAGS) -DWIN32_LEAN_AND_MEAN

+CPPFLAGS	= -I.. $(CPPFLAGS) -DGLACIER2_API_EXPORTS -DWIN32_LEAN_AND_MEAN

 LINKWITH 	= $(LIBS) $(OPENSSL_LIBS) glacier2$(LIBSUFFIX).lib icessl$(LIBSUFFIX).lib

 !if "$(BCPLUSPLUS)" != "yes"

 LINKWITH	= $(LINKWITH) ws2_32.lib

diff --git a/cpp/src/Ice/Application.cpp b/cpp/src/Ice/Application.cpp
index bf256c66f27..c7e41882fee 100644
--- a/cpp/src/Ice/Application.cpp
+++ b/cpp/src/Ice/Application.cpp
@@ -21,6 +21,21 @@ using namespace Ice;
 using namespace IceUtil;
 using namespace IceUtilInternal;
 
+
+//
+// static initializations.
+//
+Mutex* IceInternal::mutex = 0;
+
+bool IceInternal::_callbackInProgress = false;
+bool IceInternal::_destroyed = false;
+bool IceInternal::_interrupted = false;
+
+string IceInternal::_appName;
+CommunicatorPtr IceInternal::_communicator;
+SignalPolicy IceInternal::_signalPolicy = HandleSignals;
+auto_ptr<Cond> IceInternal::_condVar;
+Ice::Application* IceInternal::_application;
 //
 // _mutex and _condVar are used to synchronize the main thread and
 // the CtrlCHandler thread
@@ -29,34 +44,29 @@ using namespace IceUtilInternal;
 namespace
 {
 
-Mutex* mutex = 0;
-
 class Init
 {
 public:
 
     Init()
     {
-        mutex = new IceUtil::Mutex;
+        IceInternal::mutex = new IceUtil::Mutex;
     }
 
     ~Init()
     {
-        delete mutex;
-        mutex = 0;
+        delete IceInternal::mutex;
+        IceInternal::mutex = 0;
     }
 };
 
 Init init;
 
-auto_ptr<Cond> _condVar;
+
 
 //
 // Variables than can change while run() and communicator->destroy() are running!
 //
-bool _callbackInProgress = false;
-bool _destroyed = false;
-bool _interrupted = false;
 bool _released = false;
 CtrlCHandlerCallback _previousCallback = 0;
 
@@ -65,12 +75,8 @@ CtrlCHandlerCallback _previousCallback = 0;
 // before and after run(), and once communicator->destroy() has returned, we assume that 
 // only the main thread and CtrlCHandler threads are running.
 //
-string _appName;
-Application* _application;
-CommunicatorPtr _communicator;
 CtrlCHandler* _ctrlCHandler = 0;
 bool _nohup = false;
-SignalPolicy _signalPolicy = HandleSignals;
 
 }
 
@@ -97,13 +103,13 @@ holdInterruptCallback(int signal)
 {
     CtrlCHandlerCallback callback = 0;
     {
-        IceUtil::Mutex::Lock lock(*mutex);
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
         while(!_released)
         {
-            _condVar->wait(lock);
+            IceInternal::_condVar->wait(lock);
         }
         
-        if(_destroyed)
+        if(IceInternal::_destroyed)
         {
             //
             // Being destroyed by main thread
@@ -124,8 +130,8 @@ static void
 destroyOnInterruptCallback(int signal)
 {
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        if(_destroyed)
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        if(IceInternal::_destroyed)
         {
             //
             // Being destroyed by main thread
@@ -137,16 +143,16 @@ destroyOnInterruptCallback(int signal)
             return;
         }
 
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
-        _destroyed = true;
+        assert(!IceInternal::_callbackInProgress);
+        IceInternal::_callbackInProgress = true;
+        IceInternal::_interrupted = true;
+        IceInternal::_destroyed = true;
     }
         
     try
     {
-        assert(_communicator != 0);
-        _communicator->destroy();
+        assert(IceInternal::_communicator != 0);
+        IceInternal::_communicator->destroy();
     }
     catch(const std::exception& ex)
     {
@@ -170,18 +176,18 @@ destroyOnInterruptCallback(int signal)
     }
 
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        _callbackInProgress = false;
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        IceInternal::_callbackInProgress = false;
     }
-    _condVar->signal();
+    IceInternal::_condVar->signal();
 }
 
 static void
 shutdownOnInterruptCallback(int signal)
 {
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        if(_destroyed)
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        if(IceInternal::_destroyed)
         {
             //
             // Being destroyed by main thread
@@ -193,15 +199,15 @@ shutdownOnInterruptCallback(int signal)
             return;
         }
 
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
+        assert(!IceInternal::_callbackInProgress);
+        IceInternal::_callbackInProgress = true;
+        IceInternal::_interrupted = true;
     }
 
     try
     {
-        assert(_communicator != 0);
-        _communicator->shutdown();
+        assert(IceInternal::_communicator != 0);
+        IceInternal::_communicator->shutdown();
     }
     catch(const std::exception& ex)
     {
@@ -225,18 +231,18 @@ shutdownOnInterruptCallback(int signal)
     }
 
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        _callbackInProgress = false;
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        IceInternal::_callbackInProgress = false;
     }
-    _condVar->signal();
+    IceInternal::_condVar->signal();
 }
 
 static void
 callbackOnInterruptCallback(int signal)
 {
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        if(_destroyed)
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        if(IceInternal::_destroyed)
         {
             //
             // Being destroyed by main thread
@@ -245,15 +251,15 @@ callbackOnInterruptCallback(int signal)
         }
         // For SIGHUP the user callback is always called. It can
         // decide what to do.
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
+        assert(!IceInternal::_callbackInProgress);
+        IceInternal::_callbackInProgress = true;
+        IceInternal::_interrupted = true;
     }
 
     try
     {
-        assert(_application != 0);
-        _application->interruptCallback(signal);
+        assert(IceInternal::_application != 0);
+        IceInternal::_application->interruptCallback(signal);
     }
     catch(const std::exception& ex)
     {
@@ -277,15 +283,15 @@ callbackOnInterruptCallback(int signal)
     }
 
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        _callbackInProgress = false;
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        IceInternal::_callbackInProgress = false;
     }
-    _condVar->signal();
+    IceInternal::_condVar->signal();
 }
 
 Ice::Application::Application(SignalPolicy signalPolicy)
 {
-    _signalPolicy = signalPolicy;
+    IceInternal::_signalPolicy = signalPolicy;
 }
 
 Ice::Application::~Application()
@@ -342,7 +348,7 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initDat
         setProcessLogger(new LoggerI(argv[0], ""));
     }
 
-    if(_communicator != 0)
+    if(IceInternal::_communicator != 0)
     {
         Error out(getProcessLogger());
         out << "only one instance of the Application class can be used";
@@ -350,7 +356,7 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initDat
     }
     int status;
 
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         try
         {
@@ -361,7 +367,7 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initDat
             CtrlCHandler ctrCHandler;
             _ctrlCHandler = &ctrCHandler;
 
-            status = mainInternal(argc, argv, initData);
+            status = doMain(argc, argv, initData);
 
             //
             // Set _ctrlCHandler to 0 only once communicator->destroy() has completed.
@@ -377,7 +383,7 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initDat
     }
     else
     {
-        status = mainInternal(argc, argv, initData);
+        status = doMain(argc, argv, initData);
     }
    
     return status;
@@ -412,27 +418,27 @@ Ice::Application::interruptCallback(int)
 const char*
 Ice::Application::appName()
 {
-    return _appName.c_str();
+    return IceInternal::_appName.c_str();
 }
 
 CommunicatorPtr
 Ice::Application::communicator()
 {
-    return _communicator;
+    return IceInternal::_communicator;
 }
 
 void
 Ice::Application::destroyOnInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                _condVar->signal();
+                IceInternal::_condVar->signal();
             }
             _ctrlCHandler->setCallback(destroyOnInterruptCallback);
         }
@@ -447,15 +453,15 @@ Ice::Application::destroyOnInterrupt()
 void
 Ice::Application::shutdownOnInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                _condVar->signal();
+                IceInternal::_condVar->signal();
             }
             _ctrlCHandler->setCallback(shutdownOnInterruptCallback);
         }
@@ -470,15 +476,15 @@ Ice::Application::shutdownOnInterrupt()
 void
 Ice::Application::ignoreInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                _condVar->signal();
+                IceInternal::_condVar->signal();
             }
             _ctrlCHandler->setCallback(0);
         }
@@ -493,15 +499,15 @@ Ice::Application::ignoreInterrupt()
 void
 Ice::Application::callbackOnInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 _released = true;
-                _condVar->signal();
+                IceInternal::_condVar->signal();
             }
             _ctrlCHandler->setCallback(callbackOnInterruptCallback);
         }
@@ -516,11 +522,11 @@ Ice::Application::callbackOnInterrupt()
 void
 Ice::Application::holdInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() != holdInterruptCallback)
             {
                 _previousCallback = _ctrlCHandler->getCallback();
@@ -540,11 +546,11 @@ Ice::Application::holdInterrupt()
 void
 Ice::Application::releaseInterrupt()
 {
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         if(_ctrlCHandler != 0)
         {
-            IceUtil::Mutex::Lock lock(*mutex); // we serialize all the interrupt-setting
+            IceUtil::Mutex::Lock lock(*IceInternal::mutex); // we serialize all the interrupt-setting
             if(_ctrlCHandler->getCallback() == holdInterruptCallback)
             {
                 //
@@ -556,7 +562,7 @@ Ice::Application::releaseInterrupt()
             
                 _released = true;
                 _ctrlCHandler->setCallback(_previousCallback);
-                _condVar->signal();
+                IceInternal::_condVar->signal();
             }
             // Else nothing to release.
         }
@@ -571,24 +577,24 @@ Ice::Application::releaseInterrupt()
 bool
 Ice::Application::interrupted()
 {
-    IceUtil::Mutex::Lock lock(*mutex);
-    return _interrupted;
+    IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+    return IceInternal::_interrupted;
 }
 
 int
-Ice::Application::mainInternal(int argc, char* argv[], const InitializationData& initializationData)
+Ice::Application::doMain(int argc, char* argv[], const InitializationData& initializationData)
 {
     int status;
 
     try
     {
-        if(_condVar.get() == 0)
+        if(IceInternal::_condVar.get() == 0)
         {
-            _condVar.reset(new Cond);
+            IceInternal::_condVar.reset(new Cond);
         }
 
-        _interrupted = false;
-	_appName = argv[0] ? argv[0] : "";
+        IceInternal::_interrupted = false;
+        IceInternal::_appName = argv[0] ? argv[0] : "";
 
         //
         // We parse the properties here to extract Ice.ProgramName.
@@ -605,19 +611,19 @@ Ice::Application::mainInternal(int argc, char* argv[], const InitializationData&
             setProcessLogger(new LoggerI(initData.properties->getProperty("Ice.ProgramName"), ""));
         }
 
-        _application = this;
-        _communicator = initialize(argc, argv, initData);
-        _destroyed = false;
+        IceInternal::_application = this;
+        IceInternal::_communicator = initialize(argc, argv, initData);
+        IceInternal::_destroyed = false;
 
         //
         // Used by destroyOnInterruptCallback and shutdownOnInterruptCallback.
         //
-        _nohup = (_communicator->getProperties()->getPropertyAsInt("Ice.Nohup") > 0);
+        _nohup = (IceInternal::_communicator->getProperties()->getPropertyAsInt("Ice.Nohup") > 0);
     
         //
         // The default is to destroy when a signal is received.
         //
-        if(_signalPolicy == HandleSignals)
+        if(IceInternal::_signalPolicy == HandleSignals)
         {
             destroyOnInterrupt();
         }
@@ -654,38 +660,38 @@ Ice::Application::mainInternal(int argc, char* argv[], const InitializationData&
     // it would not make sense to release a held signal to run
     // shutdown or destroy.
     //
-    if(_signalPolicy == HandleSignals)
+    if(IceInternal::_signalPolicy == HandleSignals)
     {
         ignoreInterrupt();
     }
 
     {
-        IceUtil::Mutex::Lock lock(*mutex);
-        while(_callbackInProgress)
+        IceUtil::Mutex::Lock lock(*IceInternal::mutex);
+        while(IceInternal::_callbackInProgress)
         {
-            _condVar->wait(lock);
+            IceInternal::_condVar->wait(lock);
         }
-        if(_destroyed)
+        if(IceInternal::_destroyed)
         {
-            _communicator = 0;
+            IceInternal::_communicator = 0;
         }
         else
         {
-            _destroyed = true;
+            IceInternal::_destroyed = true;
             //
             // And _communicator != 0, meaning will be destroyed
             // next, _destroyed = true also ensures that any
             // remaining callback won't do anything
             //
         }
-        _application = 0;
+        IceInternal::_application = 0;
     }
 
-    if(_communicator != 0)
+    if(IceInternal::_communicator != 0)
     {  
         try
         {
-            _communicator->destroy();
+            IceInternal::_communicator->destroy();
         }
         catch(const std::exception& ex)
         {
@@ -699,7 +705,7 @@ Ice::Application::mainInternal(int argc, char* argv[], const InitializationData&
             out << "unknown exception";
             status = EXIT_FAILURE;
         }
-        _communicator = 0;
+        IceInternal::_communicator = 0;
     }
 
     return status;