fixes for bugs 373, 374, 375

1 files changed, 325 insertions, 183 deletions

diff --git a/cpp/src/Ice/Service.cpp b/cpp/src/Ice/Service.cpp
index 6c12c64e808..021dada2d9a 100755
--- a/cpp/src/Ice/Service.cpp
+++ b/cpp/src/Ice/Service.cpp
@@ -44,13 +44,11 @@ ctrlCHandlerCallback(int sig)
 }
 
 #ifdef _WIN32
-extern "C"
-{
 
 //
 // Main function for Win32 service.
 //
-void
+void WINAPI
 Ice_Service_ServiceMain(DWORD argc, LPTSTR* argv)
 {
     Ice::Service* service = Ice::Service::instance();
@@ -61,7 +59,7 @@ Ice_Service_ServiceMain(DWORD argc, LPTSTR* argv)
 //
 // Win32 service control handler.
 //
-void
+void WINAPI
 Ice_Service_CtrlHandler(DWORD ctrl)
 {
     Ice::Service* service = Ice::Service::instance();
@@ -69,30 +67,69 @@ Ice_Service_CtrlHandler(DWORD ctrl)
     service->control(ctrl);
 }
 
-}
-
 namespace Ice
 {
 
-class ServiceStatusThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
+class ServiceStatusManager : public IceUtil::Monitor<IceUtil::Mutex>
 {
 public:
 
-    ServiceStatusThread(SERVICE_STATUS_HANDLE, SERVICE_STATUS*);
+    ServiceStatusManager(SERVICE_STATUS_HANDLE);
 
-    virtual void run();
+    //
+    // Start a thread to provide regular status updates to the SCM.
+    //
+    void startUpdate(DWORD);
 
-    void stop(DWORD, DWORD);
+    //
+    // Stop the update thread.
+    //
+    void stopUpdate();
+
+    //
+    // Change the service status and report it (once).
+    //
+    void changeStatus(DWORD, DWORD);
+
+    //
+    // Report the current status.
+    //
+    void reportStatus();
 
 private:
 
+    void run();
+
+    class StatusThread : public IceUtil::Thread
+    {
+    public:
+
+	StatusThread(ServiceStatusManager* manager) :
+	    _manager(manager)
+	{
+	}
+
+	virtual void run()
+	{
+	    _manager->run();
+	}
+
+    private:
+
+	ServiceStatusManager* _manager;
+    };
+    friend class StatusThread;
+
     SERVICE_STATUS_HANDLE _handle;
-    SERVICE_STATUS* _status;
+    SERVICE_STATUS _status;
+    IceUtil::ThreadPtr _thread;
     bool _stopped;
 };
-typedef IceUtil::Handle<ServiceStatusThread> ServiceStatusThreadPtr;
 
 }
+
+static Ice::ServiceStatusManager* serviceStatusManager;
+
 #endif
 
 Ice::Service::Service()
@@ -126,8 +163,7 @@ Ice::Service::shutdown()
 	catch(const CommunicatorDestroyedException&)
 	{
 	    //
-	    // Expected if the service communicator is being
-	    // destroyed.
+	    // Expected if the service communicator is being destroyed.
 	    //
 	}
 	catch(const Ice::Exception& ex)
@@ -136,6 +172,10 @@ Ice::Service::shutdown()
 	    ostr << "exception during shutdown:\n" << ex;
 	    warning(ostr.str());
 	}
+	catch(...)
+	{
+	    warning("unknown exception during shutdown");
+	}
     }
     return true;
 }
@@ -738,17 +778,13 @@ Ice::Service::startService(const string& name, const vector<string>& args)
         return EXIT_FAILURE;
     }
 
-    SERVICE_STATUS status;
-    DWORD oldCheckPoint;
-    DWORD startTickCount;
-    DWORD waitTime;
-
     trace("Service start pending.");
 
     //
-    // Get the initial status of the service.
+    // Wait until the service is started or an error is detected.
     //
-    if(!QueryServiceStatus(hService, &status))
+    SERVICE_STATUS status;
+    if(!waitForServiceState(hService, SERVICE_START_PENDING, status))
     {
         syserror("unable to query status of service `" + name + "'");
         CloseServiceHandle(hService);
@@ -756,64 +792,6 @@ Ice::Service::startService(const string& name, const vector<string>& args)
         return EXIT_FAILURE;
     }
 
-    //
-    // Save the tick count and initial checkpoint.
-    //
-    startTickCount = GetTickCount();
-    oldCheckPoint = status.dwCheckPoint;
-
-    //
-    // Loop until the service is started or an error is detected.
-    //
-    while(status.dwCurrentState == SERVICE_START_PENDING)
-    {
-        //
-        // Do not wait longer than the wait hint. A good interval is
-        // one tenth the wait hint, but no less than 1 second and no
-        // more than 10 seconds.
-        //
-
-        waitTime = status.dwWaitHint / 10;
-
-        if(waitTime < 1000)
-        {
-            waitTime = 1000;
-        }
-        else if(waitTime > 10000)
-        {
-            waitTime = 10000;
-        }
-
-        Sleep(waitTime);
-
-        //
-        // Check the status again.
-        //
-        if(!QueryServiceStatus(hService, &status))
-        {
-            break;
-        }
-
-        if(status.dwCheckPoint > oldCheckPoint)
-        {
-            //
-            // The service is making progress.
-            //
-            startTickCount = GetTickCount();
-            oldCheckPoint = status.dwCheckPoint;
-        }
-        else
-        {
-            if(GetTickCount() - startTickCount > status.dwWaitHint)
-            {
-                //
-                // No progress made within the wait hint.
-                //
-                break;
-            }
-        }
-    }
-
     CloseServiceHandle(hService);
     CloseServiceHandle(hSCM);
 
@@ -823,14 +801,7 @@ Ice::Service::startService(const string& name, const vector<string>& args)
     }
     else
     {
-        ostringstream ostr;
-        ostr << "Service failed to start." << endl
-             << "  Current state: " << status.dwCurrentState << endl
-             << "  Exit code: " << status.dwWin32ExitCode << endl
-             << "  Service specific exit code: " << status.dwServiceSpecificExitCode << endl
-             << "  Check point: " << status.dwCheckPoint << endl
-             << "  Wait hint: " << status.dwWaitHint;
-        trace(ostr.str());
+	showServiceStatus("Service failed to start.", status);
 	return EXIT_FAILURE;
     }
 
@@ -866,17 +837,31 @@ Ice::Service::stopService(const string& name)
         return EXIT_FAILURE;
     }
 
-    CloseServiceHandle(hSCM);
+    trace("Service stop pending.");
+
+    //
+    // Wait until the service is stopped or an error is detected.
+    //
+    if(!waitForServiceState(hService, SERVICE_STOP_PENDING, status))
+    {
+        syserror("unable to query status of service `" + name + "'");
+        CloseServiceHandle(hService);
+        CloseServiceHandle(hSCM);
+        return EXIT_FAILURE;
+    }
+
     CloseServiceHandle(hService);
+    CloseServiceHandle(hSCM);
 
-    ostringstream ostr;
-    ostr << "Stop request sent to service." << endl
-         << "  Current state: " << status.dwCurrentState << endl
-         << "  Exit code: " << status.dwWin32ExitCode << endl
-         << "  Service specific exit code: " << status.dwServiceSpecificExitCode << endl
-         << "  Check point: " << status.dwCheckPoint << endl
-         << "  Wait hint: " << status.dwWaitHint;
-    trace(ostr.str());
+    if(status.dwCurrentState == SERVICE_STOPPED)
+    {
+        trace("Service is stopped.");
+    }
+    else
+    {
+	showServiceStatus("Service failed to stop.", status);
+	return EXIT_FAILURE;
+    }
 
     return EXIT_SUCCESS;
 }
@@ -1085,7 +1070,7 @@ Ice::Service::runService(int argc, char* argv[])
 
     SERVICE_TABLE_ENTRY ste[] =
     {
-        { const_cast<char*>(_name.c_str()), (LPSERVICE_MAIN_FUNCTIONA)Ice_Service_ServiceMain },
+        { const_cast<char*>(_name.c_str()), Ice_Service_ServiceMain },
         { NULL, NULL },
     };
 
@@ -1102,24 +1087,152 @@ Ice::Service::runService(int argc, char* argv[])
 }
 
 void
-Ice::Service::serviceMain(int argc, char* argv[])
+Ice::Service::terminateService(DWORD exitCode)
 {
-    _ctrlCHandler = new IceUtil::CtrlCHandler;
+    serviceStatusManager->stopUpdate();
+    delete serviceStatusManager;
+    serviceStatusManager = 0;
+
+    SERVICE_STATUS status;
+
+    status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+    status.dwCurrentState = SERVICE_STOPPED;
+    status.dwControlsAccepted = 0;
+    if(exitCode != 0)
+    {
+	status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
+    }
+    else
+    {
+	status.dwWin32ExitCode = 0;
+    }
+    status.dwServiceSpecificExitCode = exitCode;
+    status.dwCheckPoint = 0;
+    status.dwWaitHint = 0;
+
+    SetServiceStatus(_statusHandle, &status);
+}
+
+bool
+Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVICE_STATUS& status)
+{
+    if(!QueryServiceStatus(hService, &status))
+    {
+	return false;
+    }
 
     //
-    // Initialize the service status.
+    // Save the tick count and initial checkpoint.
     //
-    _status.dwServiceType = SERVICE_WIN32;
-    _status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
-    _status.dwWin32ExitCode = 0;
-    _status.dwServiceSpecificExitCode = 0;
-    _status.dwCheckPoint = 0;
-    _status.dwWaitHint = 0;
+    DWORD startTickCount = GetTickCount();
+    DWORD oldCheckPoint = status.dwCheckPoint;
+
+    //
+    // Loop while the service is in the pending state.
+    //
+    while(status.dwCurrentState == pendingState)
+    {
+        //
+        // Do not wait longer than the wait hint. A good interval is
+        // one tenth the wait hint, but no less than 1 second and no
+        // more than 10 seconds.
+        //
+
+        DWORD waitTime = status.dwWaitHint / 10;
+
+        if(waitTime < 1000)
+        {
+            waitTime = 1000;
+        }
+        else if(waitTime > 10000)
+        {
+            waitTime = 10000;
+        }
+
+        Sleep(waitTime);
+
+        //
+        // Check the status again.
+        //
+        if(!QueryServiceStatus(hService, &status))
+        {
+            return false;
+        }
+
+        if(status.dwCheckPoint > oldCheckPoint)
+        {
+            //
+            // The service is making progress.
+            //
+            startTickCount = GetTickCount();
+            oldCheckPoint = status.dwCheckPoint;
+        }
+        else
+        {
+            if(GetTickCount() - startTickCount > status.dwWaitHint)
+            {
+                //
+                // No progress made within the wait hint.
+                //
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+void
+Ice::Service::showServiceStatus(const string& msg, SERVICE_STATUS& status)
+{
+    string state;
+    switch(status.dwCurrentState)
+    {
+    case SERVICE_STOPPED:
+	state = "STOPPED";
+	break;
+    case SERVICE_START_PENDING:
+	state = "START PENDING";
+	break;
+    case SERVICE_STOP_PENDING:
+	state = "STOP PENDING";
+	break;
+    case SERVICE_RUNNING:
+	state = "RUNNING";
+	break;
+    case SERVICE_CONTINUE_PENDING:
+	state = "CONTINUE PENDING";
+	break;
+    case SERVICE_PAUSE_PENDING:
+	state = "PAUSE PENDING";
+	break;
+    case SERVICE_PAUSED:
+	state = "PAUSED";
+	break;
+    default:
+	state = "UNKNOWN";
+	break;
+    }
+
+    ostringstream ostr;
+    ostr << msg << endl
+	 << "  Current state: " << state << endl
+	 << "  Exit code: " << status.dwWin32ExitCode << endl
+	 << "  Service specific exit code: " << status.dwServiceSpecificExitCode << endl
+	 << "  Check point: " << status.dwCheckPoint << endl
+	 << "  Wait hint: " << status.dwWaitHint;
+    trace(ostr.str());
+}
+
+void
+Ice::Service::serviceMain(int argc, char* argv[])
+{
+    _ctrlCHandler = new IceUtil::CtrlCHandler;
 
     //
     // Register the control handler function.
     //
-    _statusHandle = RegisterServiceCtrlHandler(argv[0], (LPHANDLER_FUNCTION)Ice_Service_CtrlHandler);
+    _statusHandle = RegisterServiceCtrlHandler(argv[0], Ice_Service_CtrlHandler);
     if(_statusHandle == (SERVICE_STATUS_HANDLE)0)
     {
         syserror("unable to register service control handler");
@@ -1127,14 +1240,13 @@ Ice::Service::serviceMain(int argc, char* argv[])
     }
 
     //
-    // Start a thread to periodically update the service's status with the
-    // service control manager (SCM). The SCM must receive periodic updates
-    // otherwise it assumes that initialization failed and terminates the
-    // service.
+    // Create the service status manager and start a thread to periodically
+    // update the service's status with the service control manager (SCM).
+    // The SCM must receive periodic updates otherwise it assumes that
+    // initialization failed and terminates the service.
     //
-    _status.dwCurrentState = SERVICE_START_PENDING;
-    ServiceStatusThreadPtr statusThread = new ServiceStatusThread(_statusHandle, &_status);
-    statusThread->start();
+    serviceStatusManager = new ServiceStatusManager(_statusHandle);
+    serviceStatusManager->startUpdate(SERVICE_START_PENDING);
 
     //
     // Merge the executable's arguments with the service's arguments.
@@ -1163,10 +1275,16 @@ Ice::Service::serviceMain(int argc, char* argv[])
     {
         delete[] args;
         ostringstream ostr;
-        ostr << ex;
+        ostr << "exception occurred while initializing a communicator:\n" << ex;
         error(ostr.str());
-        statusThread->stop(SERVICE_STOPPED, EXIT_FAILURE);
-        statusThread->getThreadControl().join();
+	terminateService(EXIT_FAILURE);
+        return;
+    }
+    catch(...)
+    {
+        delete[] args;
+        error("unknown exception occurred while initializing a communicator");
+	terminateService(EXIT_FAILURE);
         return;
     }
 
@@ -1188,11 +1306,10 @@ Ice::Service::serviceMain(int argc, char* argv[])
             trace("Service started successfully.");
 
             //
-            // Stop the status thread and set our current status to running.
+            // Change the current status from START_PENDING to RUNNING.
             //
-            statusThread->stop(SERVICE_RUNNING, NO_ERROR);
-            statusThread->getThreadControl().join();
-            statusThread = 0;
+	    serviceStatusManager->stopUpdate();
+	    serviceStatusManager->changeStatus(SERVICE_RUNNING, SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
 
             //
             // Wait for the service to be shut down.
@@ -1200,13 +1317,6 @@ Ice::Service::serviceMain(int argc, char* argv[])
             waitForShutdown();
 
             //
-            // Notify the service control manager that a stop is pending.
-            //
-            _status.dwCurrentState = SERVICE_STOP_PENDING;
-            statusThread = new ServiceStatusThread(_statusHandle, &_status);
-            statusThread->start();
-
-            //
             // Give the service a chance to clean up.
             //
             if(stop())
@@ -1236,91 +1346,123 @@ Ice::Service::serviceMain(int argc, char* argv[])
     {
     }
 
-    if(statusThread)
-    {
-        statusThread->stop(SERVICE_STOPPED, status);
-        statusThread->getThreadControl().join();
-    }
+    terminateService(status);
 }
 
 void
 Ice::Service::control(int ctrl)
 {
+    assert(serviceStatusManager);
+
     switch(ctrl)
     {
-        case SERVICE_CONTROL_INTERROGATE:
-        {
-            SERVICE_STATUS status = _status; // TODO: Small risk of race with ServiceStatusThread
-            if(!SetServiceStatus(_statusHandle, &status))
-            {
-                syserror("unable to set service status");
-            }
-            break;
-        }
-        case SERVICE_CONTROL_STOP:
-        {
-            //
-            // Shut down the service. The serviceMain method will update the service status.
-            //
-            shutdown();
-            break;
-        }
-        default:
-        {
-            ostringstream ostr;
-            ostr << "unrecognized service control code " << ctrl;
-            error(ostr.str());
-            break;
-        }
+    case SERVICE_CONTROL_SHUTDOWN:
+    case SERVICE_CONTROL_STOP:
+    {
+	serviceStatusManager->startUpdate(SERVICE_STOP_PENDING);
+	shutdown();
+	break;
+    }
+    default:
+    {
+	if(ctrl != SERVICE_CONTROL_INTERROGATE)
+	{
+	    ostringstream ostr;
+	    ostr << "unrecognized service control code " << ctrl;
+	    error(ostr.str());
+	}
+
+	serviceStatusManager->reportStatus();
+	break;
+    }
     }
 }
 
-Ice::ServiceStatusThread::ServiceStatusThread(SERVICE_STATUS_HANDLE handle, SERVICE_STATUS* status) :
-    _handle(handle), _status(status), _stopped(false)
+Ice::ServiceStatusManager::ServiceStatusManager(SERVICE_STATUS_HANDLE handle) :
+    _handle(handle), _stopped(false)
 {
+    _status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+    _status.dwControlsAccepted = 0;
+    _status.dwWin32ExitCode = 0;
+    _status.dwServiceSpecificExitCode = 0;
+    _status.dwCheckPoint = 0;
+    _status.dwWaitHint = 0;
 }
 
 void
-Ice::ServiceStatusThread::run()
+Ice::ServiceStatusManager::startUpdate(DWORD state)
 {
     Lock sync(*this);
 
-    IceUtil::Time delay = IceUtil::Time::milliSeconds(500);
-    _status->dwWaitHint = 1000;
+    assert(state == SERVICE_START_PENDING || state == SERVICE_STOP_PENDING);
+    assert(!_thread);
+
+    _status.dwCurrentState = state;
+    _status.dwControlsAccepted = 0; // Don't accept any other control messages while pending.
+
+    _stopped = false;
+
+    _thread = new StatusThread(this);
+    _thread->start();
+}
+
+void
+Ice::ServiceStatusManager::stopUpdate()
+{
+    IceUtil::ThreadPtr thread;
 
-    while(!_stopped)
     {
-        if(!SetServiceStatus(_handle, _status))
-        {
-            return;
-        }
+	Lock sync(*this);
 
-        timedWait(delay);
+	if(_thread)
+	{
+	    _stopped = true;
+	    notify();
+	    thread = _thread;
+	    _thread = 0;
+	}
+    }
 
-        _status->dwCheckPoint++;
+    if(thread)
+    {
+	thread->getThreadControl().join();
     }
+}
 
-    _status->dwCheckPoint = 0;
-    _status->dwWaitHint = 0;
-    SetServiceStatus(_handle, _status);
+void
+Ice::ServiceStatusManager::changeStatus(DWORD state, DWORD controlsAccepted)
+{
+    Lock sync(*this);
+
+    _status.dwCurrentState = state;
+    _status.dwControlsAccepted = controlsAccepted;
+
+    SetServiceStatus(_handle, &_status);
 }
 
 void
-Ice::ServiceStatusThread::stop(DWORD state, DWORD exitCode)
+Ice::ServiceStatusManager::reportStatus()
 {
     Lock sync(*this);
-    _status->dwCurrentState = state;
-    if(exitCode == 0)
-    {
-	_status->dwWin32ExitCode = 0;
-    }
-    else
+
+    SetServiceStatus(_handle, &_status);
+}
+
+void
+Ice::ServiceStatusManager::run()
+{
+    Lock sync(*this);
+
+    IceUtil::Time delay = IceUtil::Time::milliSeconds(1000);
+    _status.dwWaitHint = 2000;
+    _status.dwCheckPoint = 0;
+
+    while(!_stopped)
     {
-	_status->dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
+        _status.dwCheckPoint++;
+        SetServiceStatus(_handle, &_status);
+        timedWait(delay);
     }
-    _status->dwServiceSpecificExitCode = exitCode;
-    _stopped = true;
-    notify();
 }
 
 #else