service.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */


#ifndef NL_SERVICE_H
#define NL_SERVICE_H

//
// Includes
//

#include "nel/misc/types_nl.h"

#if defined(NL_OS_WINDOWS) && defined(_WINDOWS)
#   define NOMINMAX
#   include <windows.h>
#endif

#include "nel/misc/config_file.h"
#include "nel/misc/entity_id.h"
#include "nel/misc/variable.h"
#include "nel/misc/command.h"
#include "nel/misc/entity_id.h"
#include "nel/misc/cpu_time_stat.h"
#include "nel/misc/sstring.h"

#include "unified_network.h"

#include <string>
#include <vector>

namespace NLMISC
{
    class CWindowDisplayer;
}


namespace NLNET
{

class CCallbackServer;
class IServiceUpdatable;


//
// Macros
//


#if defined(NL_OS_WINDOWS) && defined(_WINDOWS)
#define NLNET_SERVICE_MAIN(__ServiceClassName, __ServiceShortName, __ServiceLongName, __ServicePort, __ServiceCallbackArray, __ConfigDir, __LogDir) \
 \
int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) \
{ \
    NLMISC::CApplicationContext serviceContext; \
    __ServiceClassName *scn = new __ServiceClassName; \
    scn->setArgs (lpCmdLine); \
    createDebug(NULL,!scn->haveLongArg("nolog"));\
    scn->setCallbackArray (__ServiceCallbackArray, sizeof(__ServiceCallbackArray)/sizeof(__ServiceCallbackArray[0])); \
    sint retval = scn->main (__ServiceShortName, __ServiceLongName, __ServicePort, __ConfigDir, __LogDir, __DATE__" "__TIME__); \
    delete scn; \
    return retval; \
}

#else
#define NLNET_SERVICE_MAIN(__ServiceClassName, __ServiceShortName, __ServiceLongName, __ServicePort, __ServiceCallbackArray, __ConfigDir, __LogDir) \
 \
int main(int argc, const char **argv) \
{ \
    NLMISC::CApplicationContext serviceContext; \
    __ServiceClassName *scn = new __ServiceClassName; \
    scn->setArgs (argc, argv); \
    createDebug(NULL,!scn->haveLongArg("nolog"));\
    scn->setCallbackArray (__ServiceCallbackArray, sizeof(__ServiceCallbackArray)/sizeof(__ServiceCallbackArray[0])); \
    sint retval = scn->main (__ServiceShortName, __ServiceLongName, __ServicePort, __ConfigDir, __LogDir, __DATE__" "__TIME__); \
    delete scn; \
    return retval; \
}

#endif

#define DEFAULT_SHARD_ID 666


//
// Typedefs
//

//typedef uint16 TServiceId;

typedef bool (*TRequestClosureClearanceCallback) ();

//
// Variables provided to application and unused in the NeL library itself.
//

extern TUnifiedCallbackItem EmptyCallbackArray[1];


//
// Classes
//

class IService
{
public:

    // @{

    virtual void            commandStart () {}

    virtual void            init () {}

    virtual bool            update () { return true; }

    virtual void            release () {}



    // @{

    static IService                 *getInstance ();

    static bool                     isServiceInitialized() { return _Instance != NULL; }

    const std::string               &getServiceShortName () const { return _ShortName; };

    const std::string               &getServiceLongName () const { return _LongName; };

    const std::string               &getServiceAliasName () const { return _AliasName; };

    std::string                     getServiceUnifiedName () const;

    TServiceId                      getServiceId () const { return _SId; }

    const std::string               &getHostName() const        { return _HostName; }

    sint                            getExitStatus () const { return _ExitStatus; }

    uint32                          getLaunchingDate () const;

    bool                            getDontUseNS() const { return _DontUseNS; };

    bool                            getDontUseAES() const { return _DontUseAES; };

    const NLMISC::CVectorSString    &getArgs () const { return _Args; }

    bool                            haveArg (char argName) const;

    std::string                     getArg (char argName) const;

    bool                            haveLongArg (const char* argName) const;

    std::string                     getLongArg (const char* argName) const;

    /*uint64                            getEntityId (uint8 type)
    {
        return NLMISC::CEntityId::getNewEntityId( type ).getRawId();
    }*/

    CCallbackNetBase::TRecordingState   getRecordingState() const { return _RecordingState; }




    // @{

    void                    setExitStatus (sint exitStatus) { _ExitStatus = exitStatus; }

    void                    exit (sint code = 0x10);

    void                    setUpdateTimeout (NLMISC::TTime timeout) { /*if (timeout>1.0) nlerror ("IServer::setUpdateTimeout is now a double in SECOND and not ms");*/ _UpdateTimeout = timeout; }


    //@name Service status management methods
    void                    setCurrentStatus(const std::string &status);
    void                    clearCurrentStatus(const std::string &status);
    void                    addStatusTag(const std::string &statusTag);
    void                    removeStatusTag(const std::string &statusTag);
    std::string             getFullStatus() const;

    // @{

    NLMISC::CConfigFile ConfigFile;

    // use to display result of command (on file and windows displayer) **without** filter
    NLMISC::CLog CommandLog;



    // @{

    sint main (const char *serviceShortName, const char *serviceLongName, uint16 servicePort, const char *configDir, const char *logDir, const char *compilationDate);

    void setArgs (int argc, const char **argv);

    void setArgs (const char *args);

    void setCallbackArray (TUnifiedCallbackItem *array, uint nbelem) { _CallbackArray = array; _CallbackArraySize = nbelem; }

    void requireResetMeasures();

    IService ();

    virtual ~IService ();




    void registerUpdatable(IServiceUpdatable *updatable);
    void unregisterUpdatable(IServiceUpdatable *updatable);

    NLMISC::CWindowDisplayer            *WindowDisplayer;

    NLMISC::CVariable<std::string>      WriteFilesDirectory;

    NLMISC::CVariable<std::string>      SaveFilesDirectory;

    NLMISC::CVariable<bool>             ConvertSavesFilesDirectoryToFullPath;

    void                                setDirectoryChangeCallback( NLMISC::IVariableChangedCallback *cbi ) { _DirectoryChangedCBI = cbi; }

    void                                setVersion (const std::string &version) { Version = version; }

    uint16                              getPort() { return ListeningPort; }

    // Warning: can take a moment to be received from the WS. The default value (when not received yet) is DEFAULT_SHARD_ID.
    uint32                              getShardId() const { return _ShardId; }

    const NLMISC::CCPUTimeStat&         getCPUUsageStats() const    { return _CPUUsageStats; }

    virtual std::string                 getServiceStatusString() const;

    void                                setClosureClearanceCallback( TRequestClosureClearanceCallback cb ) { _RequestClosureClearanceCallback = cb; }

    void                                clearForClosure() { _ClosureClearanceStatus = CCClearedForClosure; }

    void                                anticipateShardId( uint32 shardId );

private:

    // @{

    void                                setRecordingState( CCallbackNetBase::TRecordingState rec ) { _RecordingState = rec; }

    void                                setShardId( uint32 shardId );


    // @{

    NLMISC::CVectorSString              _Args;

    std::string                         _HostName;
    NLMISC::CVariable<uint16>           ListeningPort;

    CCallbackNetBase::TRecordingState   _RecordingState;

    std::string                         _ShortName;     // ie: "NS"
    std::string                         _LongName;      // ie: "naming_service"
    std::string                         _AliasName;     // this name is initialized by the admin executor service via the args

    static IService                     *_Instance;

    NLMISC::TTime                       _UpdateTimeout;

    TServiceId                          _SId;

    sint                                _ExitStatus;

    bool                                _Initialized;

    NLMISC::CVariable<std::string>      ConfigDirectory;

    NLMISC::CVariable<std::string>      LogDirectory;

    NLMISC::CVariable<std::string>      RunningDirectory;

    NLMISC::CVariable<std::string>      Version;

    TUnifiedCallbackItem                *_CallbackArray;
    uint                                _CallbackArraySize;

    bool                                _DontUseNS;
    bool                                _DontUseAES;

    bool                                _ResetMeasures;

    uint32                              _ShardId;

    NLMISC::CCPUTimeStat                _CPUUsageStats;

    std::set<IServiceUpdatable*>        _Updatables;

    //@name Service running status management
    std::vector<std::string>            _ServiceStatusStack;
    std::set<std::string>               _ServiveStatusTags;

    enum TClosureClearanceStatus { CCMustRequestClearance, CCWaitingForClearance, CCClearedForClosure, CCCallbackThenClose=256 };

    uint                                _ClosureClearanceStatus;

    TRequestClosureClearanceCallback    _RequestClosureClearanceCallback;

    NLMISC::IVariableChangedCallback*   _DirectoryChangedCBI;

    friend void serviceGetView (uint32 rid, const std::string &rawvarpath, std::vector<std::string> &vara, std::vector<std::string> &vala);
    friend void cbAESConnection (const std::string &serviceName, TServiceId sid, void *arg);
    friend struct nel_serviceInfoClass;
    friend struct nel_getWinDisplayerInfoClass;
    friend void cbDirectoryChanged (NLMISC::IVariable &var);
    friend void cbReceiveShardId (NLNET::CMessage& msgin, const std::string &serviceName, TServiceId serviceId);

    NLMISC_CATEGORISED_DYNVARIABLE_FRIEND(nel, State);
};


class IServiceUpdatable
{
public:
    IServiceUpdatable()
    {
        if (IService::isServiceInitialized())
        {
            IService::getInstance()->registerUpdatable(this);
        }
        else
        {
            nlwarning("IServiceUpdatable : IService is not initialized, IUpdatable will not be called");
        }
    }
    virtual ~IServiceUpdatable()
    {
        if (IService::isServiceInitialized())
        {
            IService *service = IService::getInstance();

            service->unregisterUpdatable(this);
        }
    }

    virtual void serviceLoopUpdate() =0;
};


inline IService *IService::getInstance()
{
    if (_Instance == NULL)
    {
        /* the nel context MUST be initialised */
        nlassertex(NLMISC::INelContext::isContextInitialised(), ("You are trying to access a safe singleton without having initialized a NeL context. The simplest correction is to add 'NLMISC::CApplicationContext myApplicationContext;' at the very begining of your application."));
        // try to retrieve the safe singleton pointer
        _Instance = reinterpret_cast<IService*>(NLMISC::INelContext::getInstance().getSingletonPointer("IService"));
    }
    return _Instance;
}



}; // NLNET

#endif // NL_SERVICE_H

/* End of service.h */