|| || || || || || || ||

---

Manager4Windows.h

Go to the documentation of this file.

#ifndef Impala_Process_Manager4Windows_h
#define Impala_Process_Manager4Windows_h

#include <map>
#include <strstream>

#include <windows.h>

#include "Basis/ILog.h"
#include "Basis/String.h"

#include "Process/Manager.h"

namespace Impala
{
namespace Process
{

/********************************************************************
 Instances of this class are able of starting and 
 controlling processes on the Windows platform(s).

 Note that this class is in itself not thread-safe!
*********************************************************************/

class Manager4Windows : public Manager
{

public:

    Manager4Windows()
    {
        ILOG_DEBUG("Creating instance");
    }

    virtual ~Manager4Windows()
    {
        std::map<int, ProcessData>::iterator iter = mProcesses.begin();
        while (iter != mProcesses.end())
        {
            int handle = iter->first;
            Kill(handle);
            iter++;
        }
        ILOG_DEBUG("Destroying instance");
    }

    int Create(const std::string& cmdLine, std::string application)
    {
        STARTUPINFO startupInfo;
        ZeroMemory(&startupInfo, sizeof(startupInfo));
        startupInfo.cb = sizeof(startupInfo);

        PROCESS_INFORMATION procInfo;
        ZeroMemory(&procInfo, sizeof(procInfo));

        //std::ostrstream osAppl;
        //if (application != NULL)
        //{
        //    osAppl << application << std::ends;
        //}

        std::ostrstream osCmdLine;
        osCmdLine << cmdLine << std::ends;

        int rc = ::CreateProcess((application.empty() ? NULL : application.c_str()), osCmdLine.str(), NULL, NULL, false, CREATE_NEW_CONSOLE, NULL, NULL, &startupInfo, &procInfo);

        osCmdLine.freeze(false); // prevents mem leak

        if (rc == 0)
        {
            DWORD err = GetLastError();
            ILOG_ERROR("Failed to create process (code " + MakeString(err) + ")");
            return 0;
        }

        // find free handle
        int handle = 0;
        std::map<int, ProcessData>::const_iterator iter;
        do
        {
             iter = mProcesses.find(++handle);
        } while (iter != mProcesses.end());

        ProcessData data;
        data.winHandle = procInfo.hProcess;
        data.stateCode = STATE_RUNNING;
        mProcesses[handle] = data;
        return handle;
    }

    int GetManagedProcessCount() const
    {
        return mProcesses.size();
    }

    bool IsRunning(int handle)
    {
        return (GetState(handle) == STATE_RUNNING);
    }

    bool IsTerminated(int handle)
    {
        return !IsRunning(handle);
    }

    void Sleep(int sec)
    {
        ::Sleep(sec * 1000); //millisec's
    }

    //int WaitFor(int handle)
    //{
    //    HANDLE winHandle = GetWinHandle(handle);

    //    while (mProcesses[handle].stateCode == STATE_RUNNING)
    //    {
    //        if (AssessProcessState(winHandle, handle))
    //        {
    //            Sleep(Manager::WAIT_INTERVAL_SEC);
    //        }
    //        else
    //        {
    //            int ec = GetWinExitCode(winHandle, handle);
    //            if (ec == 0)
    //                mProcesses[handle].stateCode = STATE_TERM_SUCCESS;
    //            else
    //            {
    //                ILOG_ERROR("process has unexpected exit code: " << ec);
    //                mProcesses[handle].stateCode = STATE_TERM_ERROR;
    //            }
    //        }
    //    }

    //    return mProcesses[handle].stateCode;
    //}

    void Kill(int handle)
    {
        if (IsRunning(handle))
            Kill(GetWinHandle(handle), handle);
    }

    void Remove(int handle)
    {
        Kill(handle);
        mProcesses.erase(handle);
    }

    int GetState(int handle)
    {
        AssessProcessState(GetWinHandle(handle), handle);
        return mProcesses[handle].stateCode;
    }

    int GetExitCode(int handle)
    {
        if (IsRunning(handle))
        {
            // should have checked using IsRunning() first
            ILOG_ERROR("Process is still running; no exit code available yet");
            throw "process still running";
        }

        return (int) GetWinExitCode(GetWinHandle(handle), handle);
    }

private:

    HANDLE GetWinHandle(int handle)
    {
        std::map<int, ProcessData>::const_iterator iter = mProcesses.find(handle);
        if (iter == mProcesses.end())
        {
            ILOG_ERROR("Unknown process handle: " << handle);
            return NULL;
        }
        return mProcesses[handle].winHandle;
    }

    DWORD GetWinExitCode(HANDLE winHandle, int handle)
    {
        DWORD exitCode = NULL;
        if ( ! ::GetExitCodeProcess(winHandle, &exitCode))
        {
            DWORD err = ::GetLastError();
            ILOG_ERROR("Failed at retrieving exit code for process handle " << handle << 
                " (last error code " << err << "); attempting to kill the process");
            Kill(winHandle, handle);
        }
        //ILOG_DEBUG("exitCode (DWORD): " << exitCode);
        return exitCode;
    }

    void AssessProcessState(HANDLE winHandle, int handle)
    {
        if (mProcesses[handle].stateCode != STATE_RUNNING)
            return;

        DWORD exitCodeWin = GetWinExitCode(winHandle, handle);
        if (exitCodeWin == STILL_ACTIVE)
        {
            // note that we ignore the possibility of the process 
            // exiting with exactly this value!
            return;
        }

        if (exitCodeWin == 0)
            mProcesses[handle].stateCode = STATE_TERM_SUCCESS;
        else if (exitCodeWin <= MAX_NORMAL_EXIT_CODES)
            mProcesses[handle].stateCode = STATE_TERM_ERROR;
        else 
            mProcesses[handle].stateCode = STATE_TERM_ABNORMAL;
        return;
    }

    void Kill(HANDLE winHandle, int handle)
    {
        if (::TerminateProcess(winHandle, MAX_NORMAL_EXIT_CODES+1)) // might compromise global DLL data; see Platform SDK doc
        {
            mProcesses[handle].stateCode = STATE_TERM_ABNORMAL;
        }
        else
        {
            DWORD err = GetLastError();
            ILOG_ERROR("Failed to terminate process with handle " << handle << 
                " (erro code " << err << ")");
            mProcesses[handle].stateCode = STATE_UNKNOWN;
        }
    }

    typedef struct {HANDLE winHandle; int stateCode;} ProcessData;

    // Following value is very disputable: a process returning an exit code below
    // this value, is assumed to have terminated normally; values beyond it
    // are assumed to be exception values indicating abnormal process termination.
    static const int MAX_NORMAL_EXIT_CODES = 99;

    ILOG_VAR_DECL;

    std::map<int, ProcessData> mProcesses;

}; // class

ILOG_VAR_INIT(Manager4Windows, Impala.Process);

} // namespace 
} // namespace 

#endif

---