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