Service.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
 
#ifndef ICE_SERVICE_H
#define ICE_SERVICE_H
 
#include <Ice/Initialize.h>
#include <Ice/LoggerUtil.h>
 
#ifdef _WIN32
#   include <winsvc.h>
#endif
 
namespace Ice
{

class ICE_API Service
{
public:
 
    Service();
    virtual ~Service();

    virtual bool shutdown();

    virtual void interrupt();

    int main(int argc, const char* const argv[], const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
 
#ifdef _WIN32
    int main(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
#endif

    int main(const StringSeq& args, const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);

    Ice::CommunicatorPtr communicator() const;

    static Service* instance();

    bool service() const;

    std::string name() const;

    bool checkSystem() const;
 
#ifdef _WIN32
    int run(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
            int version = ICE_INT_VERSION);
#endif

    int run(int argc, const char* const argv[], const InitializationData& initData = InitializationData(),
            int version = ICE_INT_VERSION);
 
#ifdef _WIN32

    void configureService(const std::string& name);

    static void setModuleHandle(HMODULE);
 
#else

    void configureDaemon(bool changeDirectory, bool closeFiles, const std::string& pidFile);
 
#endif

    virtual void handleInterrupt(int sig);
 
protected:

    virtual bool start(int argc, char* argv[], int& status) = 0;

    virtual void waitForShutdown();

    virtual bool stop();

    virtual Ice::CommunicatorPtr initializeCommunicator(int& argc, char* argv[], const InitializationData& initData,
                                                        int version);

    virtual void syserror(const std::string& msg);

    virtual void error(const std::string& msg);

    virtual void warning(const std::string& msg);

    virtual void trace(const std::string& msg);

    virtual void print(const std::string& msg);

    void enableInterrupt();

    void disableInterrupt();

    typedef LoggerOutput<Service, Service*, &Service::syserror> ServiceSysError;

    typedef LoggerOutput<Service, Service*, &Service::error> ServiceError;

    typedef LoggerOutput<Service, Service*, &Service::warning> ServiceWarning;

    typedef LoggerOutput<Service, Service*, &Service::trace> ServiceTrace;

    typedef LoggerOutput<Service, Service*, &Service::print> ServicePrint;
 
private:
 
    Ice::LoggerPtr _logger;
    Ice::CommunicatorPtr _communicator;
    bool _nohup;
    bool _service;
    std::string _name;
 
    static Service* _instance;
 
#ifdef _WIN32
 
    int runService(int, const char* const[], const InitializationData&);
    void terminateService(DWORD);
    bool waitForServiceState(SC_HANDLE, DWORD, SERVICE_STATUS&);
    void showServiceStatus(const std::string&, SERVICE_STATUS&);
 
    SERVICE_STATUS_HANDLE _statusHandle;
    std::vector<std::string> _serviceArgs;
    InitializationData _initData;
 
public:

    void serviceMain(int, const wchar_t* const[]);
    void control(int);
 
#else
 
    int runDaemon(int, char*[], const InitializationData&, int);
 
    bool _changeDirectory;
    bool _closeFiles;
    std::string _pidFile;
 
#endif
};
 
} // End of namespace Ice
 
#endif