isisicp.cpp

Go to the documentation of this file.

// isisicp.cpp : Implementation of WinMain


#include "stdafx.h"
#include "resource.h"
#include "isisicp_i.h"
#include "isisinstrumentcontrol.h"
#include "icputils.h"
#include "isisicp_extMC.h"

class CisisicpModule;


struct report_arg_t
{
        CisisicpModule* module;
        std::string filename;
        std::string logdir;
        HANDLE h;
        bool file_error;
        report_arg_t() : module(0), filename(""), logdir(""), h(INVALID_HANDLE_VALUE), file_error(false) {}
};


class CisisicpModule : public ATL::CAtlServiceModuleT< CisisicpModule, IDS_SERVICENAME >
        {
public :
        DECLARE_LIBID(LIBID_isisicpLib)
//      DECLARE_REGISTRY_APPID_RESOURCEID(IDR_ISISICP, "{792C8939-E7F1-46E0-8EF6-DAB7F8CDBC71}")
        DECLARE_REGISTRY_APPID_RESOURCEID(IDR_ISISICP, "{940B6DC7-2248-474D-B150-B3CC089F166A}") // this is the original number 
        HRESULT InitializeSecurity() throw()
        {
                // TODO : Call CoInitializeSecurity and provide the appropriate security settings for 
                // your service
                // Suggested - PKT Level Authentication, 
                // Impersonation Level of RPC_C_IMP_LEVEL_IDENTIFY 
                // and an appropiate Non NULL Security Descriptor.

                return S_OK;
        }
        HRESULT Start(int nShowCmd) throw();
        HRESULT OnStop();
        static int reportFunction(const DAEstatus_message& mess, void* arg);
        static int writeEventLog(int sev, const char* message, void* arg);
};


class ISISICPApp : public Poco::Util::Application
{
        int m_nShowCmd;
public:
        ISISICPApp(int nShowCmd) : Poco::Util::Application(), m_nShowCmd(nShowCmd) { }
    virtual int main(const std::vector<std::string>& args);
        void runApp()
        {
                run();
        }
protected:
        void initialize(Poco::Util::Application& self)
        {
                registerExtraLoggerChannels();
                if (loadAppConfig("isisicp") != 0)    // does equivalent job of default  loadConfiguration()
                {
//                      LogEventEx(ICP_MSG_ERROR, "Cannot load isisicp.default.properties", EVENTLOG_ERROR_TYPE);
                        throw std::exception("Cannot load isisicp.default.properties");
                }
                Application::initialize(self);
        }
};

CisisicpModule _AtlModule;
static ISISICPApp* the_app = NULL;

extern "C" int WINAPI _tWinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, 
                                                                LPTSTR lpCmdLine, int nShowCmd)
{
        int ret = 0;
        std::vector<std::string> args;
        args.push_back("isisicp.exe");
        the_app = new ISISICPApp(nShowCmd);
        the_app->init(args);
//      Poco::Thread main_thread;
//      Poco::RunnableAdapter<ISISICPApp> ra(*the_app, &ISISICPApp::runApp);
//      main_thread.start(ra);
//      main_thread.join();
        ret = the_app->run();
        delete the_app;
        the_app = 0;
        return ret;
}


int ISISICPApp::main(const std::vector<std::string>& args)
{
        return _AtlModule.WinMain(m_nShowCmd);
//      return EXIT_OK;
}

HRESULT CisisicpModule::Start(int nShowCmd) throw()
{
        struct tm* tm_struct;
        static char buffer[120];
        static report_arg_t params;
        time_t the_time;
        time(&the_time);
        tm_struct = localtime(&the_time);
        int i;
        unsigned flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
        flags &= ~_CRTDBG_LEAK_CHECK_DF;        // do not check leak on exit
        if (getenv("ISISICP_DEBUG_MEMORY") != NULL)
        {
                i = atoi(getenv("ISISICP_DEBUG_MEMORY"));
                flags |= _CRTDBG_LEAK_CHECK_DF;   // check leaks on program exit
                if (i > 0)
                {
                        flags |= _CRTDBG_DELAY_FREE_MEM_DF;  // keep freed memory to check
                        if (i == 1)
                        {
                                flags |= _CRTDBG_CHECK_ALWAYS_DF; // check every allocation
                        }
                        else
                        {
                                flags &= ~_CRTDBG_CHECK_ALWAYS_DF;
                                flags &= 0x0000FFFF;    // clear old frequency
                                flags |= (i << 16);
                        }
                }
                sprintf(buffer, "c:\\data\\log\\ICPmemory%lu.log", the_time);
                HANDLE hdebug = CreateFile(buffer, GENERIC_WRITE, FILE_SHARE_READ,
                                        defaultNoInheritHandles(), CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
                _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG /* | _CRTDBG_MODE_WNDW */ );
                _CrtSetReportFile( _CRT_WARN, hdebug );
                _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG /* | _CRTDBG_MODE_WNDW */ );
                _CrtSetReportFile( _CRT_ERROR, hdebug );
                _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG /* | _CRTDBG_MODE_WNDW */ );
                _CrtSetReportFile( _CRT_ASSERT, hdebug );
        }
        _CrtSetDbgFlag(flags);
//      _CrtSetAllocHook(MyAllocHook);
//      mkdir("c:\\data\\devel");

        TCHAR szPath[ MAX_PATH ];    
    GetModuleFileName( NULL, szPath, MAX_PATH );        // get the full path of isisicp.exe executable
        std::string icp_service_dir = szPath;
        icp_service_dir.erase(icp_service_dir.find_last_of("/\\"));  // strip off filename to get directory

        // event logging
        AddEventSource(m_szServiceName, (icp_service_dir+"\\isisicp_extMC.dll").c_str(), 0);

        params.module = this;
        params.logdir = the_app->config().getString("isisicp.logdir", "c:\\data\\log");
        setICPChannelReporter(reportFunction, &params);

        the_app->logger().information("********************* Starting *********************");

        // make sure only one ICP running
        Poco::NamedMutex proc_lock("ISISICP_PROCESS_LOCK");
        if ( !proc_lock.tryLock() )
        {
                std::string mess = Poco::format("Cannot launch ISISICP from %s (global mutex already held)", icp_service_dir);
                the_app->logger().fatal(mess);
                std::cerr << mess << std::endl;
                LogEventEx(ICP_MSG_ERROR, mess.c_str(), EVENTLOG_ERROR_TYPE);
                return E_FAIL;
        }

        // we need a console for some of the commands we spawn from the ICP e.g. end_of_run.cmd -> xcopy
        AllocConsole();
        SetConsoleTitle("ISISICP Debug Output");
        HWND con_win = GetConsoleWindow();
        if (con_win != NULL)
        {
                if (the_app->config().getBool("isisicp.hideconsole"))
                {
                        ShowWindow(con_win, SW_HIDE);
                }
                else
                {
                        ShowWindow(con_win, SW_MINIMIZE);
                }
        }
        // set process affinity mask to stop us grabbing all cpus on the system
        DWORD_PTR proc_affinity_mask, system_affinity_mask;
        if (GetProcessAffinityMask(GetCurrentProcess(), &proc_affinity_mask, &system_affinity_mask) != 0)
        {
                proc_affinity_mask = the_app->config().getInt("isisicp.processAffinityMask", proc_affinity_mask);
                proc_affinity_mask &= system_affinity_mask;  // it is an error to ask for more processors than are present on the system
                if ( (proc_affinity_mask != 0) && (SetProcessAffinityMask(GetCurrentProcess(), proc_affinity_mask) != 0) )
                {
                        the_app->logger().information("Set process CPU affinity mask to 0x" + Poco::NumberFormatter::formatHex(proc_affinity_mask));
                }
                else
                {
                        the_app->logger().error("cannot set process affinity");
                }
        }
        else
        {
                the_app->logger().error("cannot get process affinity");
        }
        // 
        InstrumentControlHolder::setDefaultArgs(the_app, icp_service_dir, reportFunction, writeEventLog, &params);
        CoInitializeEx(NULL, COINIT_MULTITHREADED);
        the_app->logger().information("Starting ISISICP");
        LogEventEx(ICP_MSG_INFORMATIONAL, "Starting ISISICP", EVENTLOG_INFORMATION_TYPE);
        return CAtlServiceModuleT<CisisicpModule,IDS_SERVICENAME>::Start(nShowCmd);
}

HRESULT CisisicpModule::OnStop()
{
        the_app->logger().information("Stopping ISISICP");
        LogEventEx(ICP_MSG_INFORMATIONAL, "Stopping ISISICP", EVENTLOG_INFORMATION_TYPE);
        return S_OK;
}

int CisisicpModule::reportFunction(const DAEstatus_message& mess, void* arg)
{
        static bool first_call = false;
        static char icp_log_file_template[240], icp_log_file[240];
        time_t the_time;
        time(&the_time);
        struct tm* tm_struct = localtime(&the_time);
        report_arg_t* params = (report_arg_t*)arg;
//      strftime(icp_log_file_template, sizeof(icp_log_file_template), "c:\\data\\log\\icp-%Y-%m-%d-%a-%%02d.log", tm_struct);
//      for(int i=0; i <= 99; i++)
//      {
//              _snprintf(icp_log_file, sizeof(icp_log_file), icp_log_file_template, i);
//              if (stat(icp_log_file, &stat_buffer) != 0)
//              {
//                      break; // file not found, so we can use the name
//              }
//      }
        sprintf(icp_log_file_template, "%s\\icp-%%Y-%%m-%%d-%%a.log", params->logdir.c_str());
        strftime(icp_log_file, sizeof(icp_log_file), icp_log_file_template, tm_struct);
        if (params->filename != icp_log_file)
        {
                if (params->h != INVALID_HANDLE_VALUE)
                {
                        CloseHandle(params->h);
                }
                params->filename = icp_log_file;
                params->h = createAppendFile(icp_log_file);
                if (params->h != INVALID_HANDLE_VALUE)
                {
                        params->file_error = false;
                }
                else
                {
                        params->module->LogEventEx(ICP_MSG_ERROR, "Cannot create ICP LOG file", EVENTLOG_ERROR_TYPE);
                        params->file_error = true;
                }
        }
        std::stringstream f;
        f << mess << "\r\n";
        appendToFileAsync(params->h, f.str().c_str());
#ifdef _DEBUG
        OutputDebugString(mess.str().c_str());
        OutputDebugString("\n");
#endif /* _DEBUG */
//      if (mess >= SEV_ERROR)
//      {
//              params->module->LogEventEx(ICP_MSG_ERROR, mess.str().c_str(), EVENTLOG_ERROR_TYPE);
//      }
        return S_OK;
}

int CisisicpModule::writeEventLog(int sev, const char* message, void* arg)
{
        report_arg_t* params = (report_arg_t*)arg;
        switch(sev)
        {
                case SEV_INFO:
                case SEV_DEBUG:
                        params->module->LogEventEx(ICP_MSG_INFORMATIONAL, message, EVENTLOG_INFORMATION_TYPE);
                        break;

                case SEV_ERROR:
                case SEV_FATAL:
                        params->module->LogEventEx(ICP_MSG_ERROR, message, EVENTLOG_ERROR_TYPE);
                        break;

                case SEV_OK:
                        params->module->LogEventEx(ICP_MSG_SUCCESS, message, EVENTLOG_SUCCESS);
                        break;

                case SEV_WARNING:
                        params->module->LogEventEx(ICP_MSG_WARNING, message, EVENTLOG_WARNING_TYPE);
                        break;

                default:
                        params->module->LogEventEx(ICP_MSG_INFORMATIONAL, message, EVENTLOG_INFORMATION_TYPE);
                        break;
        }
        return 0;
}