Linux multi-monitor fullscreen support

[ryzomcore.git] / nel / src / net / service.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This source file has been modified by the following contributors:
// Copyright (C) 2016-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "stdnet.h"

//
// Includes
//

#ifdef NL_OS_WINDOWS
// these defines is for IsDebuggerPresent(). it'll not compile on windows 95
// just comment this and the IsDebuggerPresent to compile on windows 95
#       include <direct.h>
#elif defined NL_OS_UNIX
#       include <unistd.h>
#endif

#include "nel/misc/config_file.h"
#include "nel/misc/displayer.h"
#include "nel/misc/mutex.h"
#include "nel/misc/window_displayer.h"
#include "nel/misc/gtk_displayer.h"
#include "nel/misc/win_displayer.h"
#include "nel/misc/path.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/report.h"
#include "nel/misc/system_info.h"
#include "nel/misc/timeout_assertion_thread.h"

#include "nel/net/naming_client.h"
#include "nel/net/service.h"
#include "nel/net/unified_network.h"
#include "nel/net/net_displayer.h"
#include "nel/net/email.h"
#include "nel/net/varpath.h"
#include "nel/net/admin.h"
#include "nel/net/module_manager.h"
#include "nel/net/transport_class.h"

#include "stdin_monitor_thread.h"


//
// Namespaces
//

using namespace std;
using namespace NLMISC;

namespace NLNET
{


//
// Constants
//

static const sint Signal[] = {
  SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM
};

static const char *SignalName[]=
{
  "SIGABRT", "SIGFPE", "SIGILL", "SIGINT", "SIGSEGV", "SIGTERM"
};

static const char* NegFiltersNames[] =
{
   "NegFiltersDebug",
   "NegFiltersInfo",
   "NegFiltersWarning",
   "NegFiltersAssert",
   "NegFiltersError",
   0
};


//
// Variables
//

TUnifiedCallbackItem EmptyCallbackArray[1] = { { "", NULL } };

// class static member
IService        *IService::_Instance = NULL;

static sint ExitSignalAsked = 0;

// services stat
CVariable<sint32> UserSpeedLoop ("nel", "UserSpeedLoop", "duration of the last user loop (in ms)", 10, false);
CVariable<sint32> NetSpeedLoop ("nel", "NetSpeedLoop", "duration of the last network loop (in ms)", 10, false);
/// The time passed in callback during the loop
CVariable<uint32> L5CallbackTime("nel", "L5CallbackTime", "Time passed in the L5 callback function in the last loop (in ms)", 0, 100 );
/// The number of L5 callback treated
CVariable<uint32> L5CallbackCount("nel", "L5CallbackCount", "The number of layer 5 callback received in the last loop", 0, 100 );

extern uint32 TotalCallbackCalled;
extern uint32 TimeInCallback;
uint32 LastTotalCallbackCalled = 0;
uint32 LastTimeInCallback = 0;



// this is the thread that initialized the signal redirection
// we'll ignore other thread signals
static size_t SignalisedThread;

static CFileDisplayer fd;
static CNetDisplayer commandDisplayer(false);
//static CLog commandLog;

static string CompilationDate;
static uint32 LaunchingDate;

static uint32 NbUserUpdate = 0;

string CompilationMode = nlMode;

//static bool Bench = false;

CVariable<bool> Bench ("nel", "Bench", "1 if benching 0 if not", 0, true);

// This produce an assertion in the thread if the update loop is too slow
static CTimeoutAssertionThread  MyTAT;
static void                                             UpdateAssertionThreadTimeoutCB(IVariable &var) { uint32 timeOut; fromString(var.toString(), timeOut); MyTAT.timeout(timeOut); }
static CVariable<uint32>                UpdateAssertionThreadTimeout("nel", "UpdateAssertionThreadTimeout", "in millisecond, timeout before thread assertion", 0, 0, true, UpdateAssertionThreadTimeoutCB);

// Flag to enable/disable the flushing of the sending queues when the service is shut down
// Default: false (matches the former behavior)
// Set it to true in services that need to send data on exit (for instance in their release() method)
CVariable<bool>                                 FlushSendingQueuesOnExit("nel", "FlushSendingQueuesOnExit",
        "Flag to enable/disable the flushing of the sending queues when the service is shut down", false, 0, true );

// If FlushSendingQueuesOnExit is on, only the sending queues to these specified services will be flushed
// Format: service short names separated by ':'
// Default: "" (all will be flushed if FlushSendingQueuesOnExit is on, none if it is off)
CVariable<string>                               NamesOfOnlyServiceToFlushSending("nel", "NamesOfOnlyServiceToFlushSending",
        "If FlushSendingQueuesOnExit is on, only the sending queues to these specified services will be flushed (ex: \"WS:LS\"; all will be flushed if empty string)", "", 0, true );


//
// Signals managing
//

// This function is called when a signal comes
static void sigHandler(int Sig)
{
        // redirect the signal for the next time
        signal(Sig, sigHandler);

        // find the signal
        for (int i = 0; i < (int)(sizeof(Signal)/sizeof(Signal[0])); i++)
        {
                if (Sig == Signal[i])
                {
                        if (getThreadId () != SignalisedThread)
                        {
                                nldebug ("SERVICE: Not the main thread (%u, %u) received the signal (%s, %d), ignore it", getThreadId (), SignalisedThread, SignalName[i],Sig);
                                return;
                        }
                        else
                        {
                                nlinfo ("SERVICE: Signal %s (%d) received", SignalName[i], Sig);
                                switch (Sig)
                                {
                                // Note: SIGKILL (9) and SIGSTOP (19) can't be trapped
                                case SIGINT  :
                                  if (IService::getInstance()->haveLongArg("nobreak"))
                                    {
                                      // ignore ctrl-c
                                      nlinfo("SERVICE: Ignoring ctrl-c");
                                      return;
                                    }
                                case SIGABRT :
                                case SIGILL  :
                                case SIGSEGV :
                                case SIGTERM :
                                // you should not call a function and system function like printf in a SigHandle because
                                // signal-handler routines are usually called asynchronously when an interrupt occurs.
                                if (ExitSignalAsked == 0)
                                {
                                        nlinfo ("SERVICE: Receive a signal that said that i must exit");
                                        ExitSignalAsked = Sig;
                                        return;
                                }
                                else
                                {
                                        nlinfo ("SERVICE: Signal already received, launch the brutal exit");
                                        exit (EXIT_FAILURE);
                                }
                                break;
                                }
                        }
                }
        }
        nlwarning ("SERVICE: Unknown signal received (%d)", Sig);
}

// Initialise the signal redirection
static void initSignal()
{
        SignalisedThread = getThreadId ();
#ifdef NL_DEBUG
        // in debug mode, we only trap the SIGINT signal (for ctrl-c handling)
        //signal(Signal[3], sigHandler);
        //nldebug("Signal : %s (%d) trapped", SignalName[3], Signal[3]);
#else
        // in release, redirect all signals
// don't redirect now because too hard to debug...
//      for (int i = 0; i < (int)(sizeof(Signal)/sizeof(Signal[0])); i++)
//      {
//              signal(Signal[i], sigHandler);
//              nldebug("Signal %s (%d) trapped", SignalName[i], Signal[i]);
//      }
//
        if (IService::getInstance()->haveLongArg("nobreak"))
        {
                signal(Signal[3], sigHandler);
        }
#endif
}

void cbDirectoryChanged (IVariable &var)
{
        IService *instance = IService::getInstance();

        // Convert to full path if required
        // (warning: ConvertSavesFilesDirectoryToFullPath, read from the config file, won't be ready for the initial variable assigments done before the config file has been loaded)
        string vp = var.toString();
        if ((var.getName() != "SaveFilesDirectory") || instance->ConvertSavesFilesDirectoryToFullPath.get())
        {
                vp = CPath::getFullPath(vp);
                var.fromString(vp);
        }
        nlinfo ("SERVICE: '%s' changed to '%s'", var.getName().c_str(), vp.c_str());

        // Update the running directory if needed
        if (var.getName() == "RunningDirectory")
        {
                CPath::setCurrentPath(vp);
        }

        // Call the callback if provided
        if (instance->_DirectoryChangedCBI)
                instance->_DirectoryChangedCBI->onVariableChanged(var);
}


//
// Service built-in callbacks
//

void cbReceiveShardId (CMessage& msgin, const string &serviceName, TServiceId serviceId)
{
        uint32 shardId;
        msgin.serial(shardId);

        if (IService::getInstance()->getDontUseNS())
        {
                // we don't use NS, so shard ID message don't concern us
                return;
        }

        if (serviceName != "WS")
        {
                nlwarning("SERVICE: received unauthorized R_SH_ID callback from service %s-%uh asking to set ShardId to %d", serviceName.c_str(), serviceId.get(), shardId);
                return;
        }

        nlinfo("SERVICE: ShardId is %u", shardId);
        IService::getInstance()->setShardId( shardId );
}

std::string IService::getServiceStatusString() const
{
        static string emptyString;

        return emptyString;
}


//
void IService::anticipateShardId( uint32 shardId )
{
        if ( ! ((_ShardId == DEFAULT_SHARD_ID) || (shardId == _ShardId)) )
                nlerror( "IService::anticipateShardId() overwrites %u with %u", _ShardId, shardId );
        _ShardId = shardId;
}

//
void IService::setShardId( uint32 shardId )
{
        if ( ! ((_ShardId == DEFAULT_SHARD_ID) || (shardId == _ShardId)) )
                nlwarning( "SERVICE: The shardId from the WS (%u) is different from the anticipated shardId (%u)", shardId, _ShardId );
        _ShardId = shardId;
}

TUnifiedCallbackItem builtinServiceCallbacks [] =
{
        { "R_SH_ID", cbReceiveShardId },
};



//
// Class implementation
//

// Ctor
IService::IService() :
        WindowDisplayer(0),
        WriteFilesDirectory("nel", "WriteFilesDirectory", "directory where to save generic shard information (packed_sheets for example)", ".", 0, true, cbDirectoryChanged),
        SaveFilesDirectory("nel", "SaveFilesDirectory", "directory where to save specific shard information (shard time for example)", ".", 0, true, cbDirectoryChanged),
        ConvertSavesFilesDirectoryToFullPath("nel", "ConvertSaveFilesDirectoryToFullPath", "If true (default), the provided SaveFilesDirectory will be converted to a full path (ex: saves -> /home/dir/saves)", true, 0, true ),
        ListeningPort("nel", "ListeningPort", "listening port for this service", 0, 0, true),
        _RecordingState(CCallbackNetBase::Off),
        _UpdateTimeout(100),
        _SId(0),
        _ExitStatus(0),
        _Initialized(false),
        ConfigDirectory("nel", "ConfigDirectory", "directory where config files are", ".", 0, true, cbDirectoryChanged),
        LogDirectory("nel", "LogDirectory", "directory where the service is logging", ".", 0, true, cbDirectoryChanged),
        RunningDirectory("nel", "RunningDirectory", "directory where the service is running on", ".", 0, true, cbDirectoryChanged),
        Version("nel", "Version", "Version of the shard", ""),
        _CallbackArray (0),
        _CallbackArraySize (0),
        _DontUseNS(false),
        _DontUseAES(false),
        _ResetMeasures(false),
        _ShardId(0),
        _ClosureClearanceStatus(CCMustRequestClearance),
        _RequestClosureClearanceCallback(NULL),
        _DirectoryChangedCBI(NULL)
{
        // Singleton
        _Instance = this;

        // register in the safe singleton registry
        INelContext::getInstance().setSingletonPointer("IService", this);
}

IService::~IService()
{
        // unregister the singleton
        INelContext::getInstance().releaseSingletonPointer("IService", this);
}


bool IService::haveArg (char argName) const
{
        for (uint32 i = 0; i < _Args.size(); i++)
        {
                if (_Args[i].size() >= 2 && _Args[i][0] == '-')
                {
                        if (_Args[i][1] == argName)
                        {
                                return true;
                        }
                }
        }
        return false;
}


string IService::getArg (char argName) const
{
        for (uint32 i = 0; i < _Args.size(); i++)
        {
                if (_Args[i].size() >= 2 && _Args[i][0] == '-')
                {
                        if (_Args[i][1] == argName)
                        {
                                /* Remove the first and last '"' :
                                -c"C:\Documents and Settings\toto.tmp"
                                will return :
                                C:\Documents and Settings\toto.tmp
                                */
                                uint begin = 2;
                                if (_Args[i].size() < 3)
                                        return "";
                                        //throw Exception ("Parameter '-%c' is malformed, missing content", argName);

                                if (_Args[i][begin] == '"')
                                        begin++;

                                // End
                                uint size = (uint)_Args[i].size();
                                if (size && _Args[i][size-1] == '"')
                                        size--;
                                size = (uint)(std::max((int)0, (int)size-(int)begin));
                                return _Args[i].substr(begin, size);
                        }
                }
        }
        throw Exception ("Parameter '-%c' is not found in command line", argName);
}


bool IService::haveLongArg (const char* argName) const
{
        for (uint32 i = 0; i < _Args.size(); i++)
        {
                if (_Args[i].left(2)=="--" && _Args[i].leftCrop(2).splitTo('=')==argName)
                {
                        return true;
                }
        }
        return false;
}


string IService::getLongArg (const char* argName) const
{
        for (uint32 i = 0; i < _Args.size(); i++)
        {
                if (_Args[i].left(2)=="--" && _Args[i].leftCrop(2).splitTo('=')==argName)
                {
                        NLMISC::CSString val= _Args[i].splitFrom('=');
                        if (!val.empty())
                        {
                                return val.unquoteIfQuoted();
                        }
                        if (i+1<_Args.size() && _Args[i+1].c_str()[0]!='-')
                        {
                                return _Args[i+1].unquoteIfQuoted();
                        }

                        return std::string();
                }
        }
        return std::string();
}


void IService::setArgs (const char *args)
{
        _Args.push_back ("<ProgramName>");

        string sargs (args);
        string::size_type pos1 = 0, pos2 = 0;

        do
        {
                // Look for the first non space character
                pos1 = sargs.find_first_not_of (" ", pos2);
                if (pos1 == string::npos) break;

                // Look for the first space or "
                pos2 = sargs.find_first_of (" \"", pos1);
                if (pos2 != string::npos)
                {
                        // " ?
                        if (sargs[pos2] == '"')
                        {
                                // Look for the final \"
                                pos2 = sargs.find_first_of ("\"", pos2+1);
                                if (pos2 != string::npos)
                                {
                                        // Look for the first space
                                        pos2 = sargs.find_first_of (" ", pos2+1);
                                }
                        }
                }

                // Compute the size of the string to extract
                string::difference_type length = (pos2 != string::npos) ? pos2-pos1 : string::npos;

                string tmp = sargs.substr (pos1, length);
                _Args.push_back (tmp);
        }
        while (pos2 != string::npos);
}

void IService::setArgs (int argc, const char **argv)
{
        for (sint i = 0; i < argc; i++)
        {
                _Args.push_back (argv[i]);
        }
}

void IService::setArgs(int argc, const wchar_t **argv)
{
        for (sint i = 0; i < argc; i++)
        {
                _Args.push_back(nlWideToUtf8(argv[i]));
        }
}

void cbLogFilter (CConfigFile::CVar &var)
{
        CLog *log = NULL;
        if (var.Name == "NegFiltersDebug")
        {
                log = DebugLog;
        }
        else if (var.Name == "NegFiltersInfo")
        {
                log = InfoLog;
        }
        else if (var.Name == "NegFiltersWarning")
        {
                log = WarningLog;
        }
        else if (var.Name == "NegFiltersAssert")
        {
                log = AssertLog;
        }
        else if (var.Name == "NegFiltersError")
        {
                log = ErrorLog;
        }
        else
        {
                nlstop;
        }

        nlinfo ("SERVICE: Updating %s from config file", var.Name.c_str());

        // remove all old filters from config file
        CConfigFile::CVar &oldvar = IService::getInstance()->ConfigFile.getVar (var.Name);
        for (uint j = 0; j < oldvar.size(); j++)
        {
                log->removeFilter (oldvar.asString(j).c_str());
        }

        // add all new filters from config file
        for (uint i = 0; i < var.size(); i++)
        {
                log->addNegativeFilter (var.asString(i).c_str());
        }
}

void cbExecuteCommands (CConfigFile::CVar &var)
{
        for (uint i = 0; i < var.size(); i++)
        {
                ICommand::execute (var.asString(i), IService::getInstance()->CommandLog);
        }
}



//
// The main function of the service
//

sint IService::main (const char *serviceShortName, const char *serviceLongName, uint16 servicePort, const char *configDir, const char *logDir, const char *compilationDate)
{
        bool userInitCalled = false;
        CConfigFile::CVar *var = NULL;

        IThread *timeoutThread = NULL;

        // a short name service can't be a number
        uint tmp;
        nlassert (!fromString(serviceShortName, tmp));

        try
        {
                createDebug();
                // init the module manager
                IModuleManager::getInstance();
                //
                // Init parameters
                //

                // at the very beginning, eventually wrote a file with the pid
                if (haveLongArg("writepid"))
                {
                        // use legacy C primitives
                        FILE *fp = nlfopen("pid.state", "wt");
                        if (fp)
                        {
                                fprintf(fp, "%u", getpid());
                                fclose(fp);
                        }
                }

                _ShortName = serviceShortName;
                CLog::setProcessName (_ShortName);

                // get the path where to run the service if any in the command line
                if (haveArg('A'))
                        RunningDirectory = CPath::standardizePath(getArg('A'));

                ConfigDirectory = CPath::standardizePath(configDir);
                LogDirectory = CPath::standardizePath(logDir);
                _LongName = serviceLongName;

                CompilationDate = compilationDate;

                LaunchingDate = CTime::getSecondsSince1970();

                ListeningPort = servicePort;

                // setDefaultEmailParams ("gw.nevrax.com", "", "cado@nevrax.com");


                //
                // Load the config file
                //

                // get the config file dir if any in the command line
                if (haveArg('C'))
                        ConfigDirectory = CPath::standardizePath(getArg('C'));

                string cfn = ConfigDirectory.c_str() + _LongName + ".cfg";
                if (!CFile::fileExists(ConfigDirectory.c_str() + _LongName + ".cfg"))
                {
                        // check if the default exists
                        if (!CFile::fileExists(ConfigDirectory.c_str() + _LongName + "_default.cfg"))
                        {
                                nlerror ("SERVICE: Neither the config file '%s' nor the default one can be found, can't launch the service", cfn.c_str());
                        }
                        else
                        {
                                // create the basic .cfg that link the default one
                                FILE *fp = nlfopen (cfn, "w");
                                if (fp == NULL)
                                {
                                        nlerror ("SERVICE: Can't create config file '%s'", cfn.c_str());
                                }
                                fprintf(fp, "// link the default config file for %s\n", _LongName.c_str());
                                fprintf(fp, "RootConfigFilename = \"%s_default.cfg\";\n", _LongName.c_str());
                                fclose (fp);
                        }
                }

                ConfigFile.load (cfn);

                // setup variable with config file variable
                IVariable::init (ConfigFile);

                if (ConfigFile.exists("DefaultEmailSMTP") && ConfigFile.exists("DefaultEmailTo"))
                        NLNET::setDefaultEmailParams(
                                ConfigFile.getVar("DefaultEmailSMTP").asString(),
                                ConfigFile.exists("DefaultEmailFrom")
                                ? ConfigFile.getVar("DefaultEmailFrom").asString()
                                : "service@opennel.org",
                                ConfigFile.getVar("DefaultEmailTo").asString());

                //
                // Set the shard Id
                //

                if ((var = ConfigFile.getVarPtr("NoWSShardId")) != NULL)
                {
                        _ShardId = var->asInt();
                }
                else
                {
                        // something high enough as default
                        _ShardId = DEFAULT_SHARD_ID;
                }

                if (haveArg('Z'))
                {
                        string s = IService::getInstance()->getArg('Z');
                        if (s == "u")
                        {
                                // do not release the module manager
                        }
                        else
                        {
                                // release the module manager
                                IModuleManager::getInstance().releaseInstance();
                        }

                        return 0;
                }

                // we have to call this again because the config file can changed this variable but the cmd line is more prioritary
                if (haveArg('A'))
                        RunningDirectory = CPath::standardizePath(getArg('A'));


                //
                // Init debug/log stuffs (must be first things otherwise we can't log if errors)
                //

                // get the log dir if any in the command line
                if (haveArg('L'))
                        LogDirectory = CPath::standardizePath(getArg('L'));

                changeLogDirectory (LogDirectory);

                bool noLog= (ConfigFile.exists ("DontLog")) && (ConfigFile.getVar("DontLog").asInt() == 1);
                noLog|=haveLongArg("nolog");
                if (!noLog)
                {
                        // we create the log with service name filename ("test_service_ALIAS.log" for example)
                        string logname = LogDirectory.toString() + _LongName;
                        if (haveArg('N'))
                                logname += "_" + toLowerAscii(getArg('N'));
                        logname += ".log";
                        fd.setParam (logname, false);

                        DebugLog->addDisplayer (&fd);
                        InfoLog->addDisplayer (&fd);
                        WarningLog->addDisplayer (&fd);
                        AssertLog->addDisplayer (&fd);
                        ErrorLog->addDisplayer (&fd);
                        CommandLog.addDisplayer (&fd, true);
                }

                bool dontUseStdIn= (ConfigFile.exists ("DontUseStdIn")) && (ConfigFile.getVar("DontUseStdIn").asInt() == 1);
                if (!dontUseStdIn)
                {
                        IStdinMonitorSingleton::getInstance()->init();
                }

                //
                // Init the hierarchical timer
                //

                CHTimer::startBench(false, true);
                CHTimer::endBench();

                //
                // Set the assert mode
                //

                if (ConfigFile.exists ("Assert"))
                        setAssert (ConfigFile.getVar("Assert").asInt() == 1);

                //
                // Set the update timeout if found in the cfg
                //
                if ((var = ConfigFile.getVarPtr("UpdateTimeout")) != NULL)
                {
                        _UpdateTimeout = var->asInt();
                }

                //
                // Set the negative filter from the config file
                //

                for(const char **name = NegFiltersNames; *name; name++)
                {
                        if ((var = ConfigFile.getVarPtr (*name)) != NULL)
                        {
                                ConfigFile.setCallback (*name, cbLogFilter);
                                cbLogFilter(*var);
                        }
                }

                ConfigFile.setCallback ("Commands", cbExecuteCommands);
                if ((var = ConfigFile.getVarPtr ("Commands")) != NULL)
                {
                        cbExecuteCommands(*var);
                }

                //
                // Command line start
                //
                commandStart ();

                //
                // Create the window if needed
                //

                if ((var = ConfigFile.getVarPtr ("WindowStyle")) != NULL)
                {
                        string disp = var->asString ();
#ifdef NL_USE_GTK
                        if (disp == "GTK")
                        {
                                WindowDisplayer = new CGtkDisplayer ("DEFAULT_WD");
                        }
#endif // NL_USE_GTK

#ifdef NL_OS_WINDOWS
                        if (disp == "WIN")
                        {
                                WindowDisplayer = new CWinDisplayer ("DEFAULT_WD");
                        }
#endif // NL_OS_WINDOWS

                        if (WindowDisplayer == NULL && disp != "NONE")
                        {
                                nlinfo ("SERVICE: Unknown value for the WindowStyle (should be GTK, WIN or NONE), use no window displayer");
                        }
                }

                vector <pair<string,uint> > displayedVariables;
                //uint speedNetLabel, speedUsrLabel, rcvLabel, sndLabel, rcvQLabel, sndQLabel, scrollLabel;
                if (WindowDisplayer != NULL)
                {
                        //
                        // Init window param if necessary
                        //

                        sint x=-1, y=-1, w=-1, h=-1, fs=10, history=-1;
                        bool iconified = false, ww = false;
                        string fn;

                        if ((var = ConfigFile.getVarPtr("XWinParam")) != NULL) x = var->asInt();
                        if ((var = ConfigFile.getVarPtr("YWinParam")) != NULL) y = var->asInt();
                        if ((var = ConfigFile.getVarPtr("WWinParam")) != NULL) w = var->asInt();
                        if ((var = ConfigFile.getVarPtr("HWinParam")) != NULL) h = var->asInt();
                        if ((var = ConfigFile.getVarPtr("HistoryWinParam")) != NULL) history = var->asInt();
                        if ((var = ConfigFile.getVarPtr("IWinParam")) != NULL) iconified = var->asInt() == 1;
                        if ((var = ConfigFile.getVarPtr("FontSize")) != NULL) fs = var->asInt();
                        if ((var = ConfigFile.getVarPtr("FontName")) != NULL) fn = var->asString();
                        if ((var = ConfigFile.getVarPtr("WordWrap")) != NULL) ww = var->asInt() == 1;

                        if (haveArg('I')) iconified = true;

                        WindowDisplayer->create (string("*INIT* ") + _ShortName + " " + _LongName, iconified, x, y, w, h, history, fs, fn, ww, &CommandLog);

                        DebugLog->addDisplayer (WindowDisplayer);
                        InfoLog->addDisplayer (WindowDisplayer);
                        WarningLog->addDisplayer (WindowDisplayer);
                        ErrorLog->addDisplayer (WindowDisplayer);
                        AssertLog->addDisplayer (WindowDisplayer);
                        CommandLog.addDisplayer(WindowDisplayer, true);

                        // adding default displayed variables
                        displayedVariables.push_back(make_pair(string("NetLop|NetSpeedLoop"), WindowDisplayer->createLabel ("NetLop")));
                        displayedVariables.push_back(make_pair(string("UsrLop|UserSpeedLoop"), WindowDisplayer->createLabel ("UsrLop")));
                        displayedVariables.push_back(make_pair(string("|Scroller"), WindowDisplayer->createLabel ("NeL Rulez")));

                        CConfigFile::CVar *v = ConfigFile.getVarPtr("DisplayedVariables");
                        if (v != NULL)
                        {
                                for (uint i = 0; i < v->size(); i++)
                                {
                                        displayedVariables.push_back(make_pair(v->asString(i), WindowDisplayer->createLabel (v->asString(i).c_str())));
                                }
                        }
                }

                nlinfo ("SERVICE: Starting Service '%s' using NeL (" __DATE__ " " __TIME__ ") compiled %s", _ShortName.c_str(), CompilationDate.c_str());
                nlinfo ("SERVICE: On OS: %s", CSystemInfo::getOS().c_str());

                setExitStatus (EXIT_SUCCESS);

                //
                // Redirect signal if needed (in release mode only)
                //

#ifdef NL_OS_WINDOWS
#       ifdef NL_NO_DEBUG
                initSignal();
#       else
                // don't install signal is the application is started in debug mode
                if (IsDebuggerPresent ())
                {
                        //nlinfo("Running with the debugger, don't redirect signals");
                        initSignal();
                }
                else
                {
                        //nlinfo("Running without the debugger, redirect SIGINT signal");
                        initSignal();
                }
#       endif
#else // NL_OS_UNIX
                initSignal();
#endif


                //
                // Ignore SIGPIPE (broken pipe) on unix system
                //

#ifdef NL_OS_UNIX
                // Ignore the SIGPIPE signal
                sigset_t SigList;
                bool IgnoredPipe = true;
                if (sigemptyset (&SigList) == -1)
                {
                        perror("sigemptyset()");
                        IgnoredPipe = false;
                }

                if (sigaddset (&SigList, SIGPIPE) == -1)
                {
                        perror("sigaddset()");
                        IgnoredPipe = false;
                }

                if (sigprocmask (SIG_BLOCK, &SigList, NULL) == -1)
                {
                        perror("sigprocmask()");
                        IgnoredPipe = false;
                }
                nldebug ("SERVICE: SIGPIPE %s", IgnoredPipe?"Ignored":"Not Ignored");
#endif // NL_OS_UNIX


                //
                // Initialize the network system
                //

                string localhost;
                try
                {
                        // Initialize WSAStartup and network stuffs
                        CSock::initNetwork();

                        // Get the localhost name
                        localhost = CInetAddress::localHost().hostName();
                }
                catch (const NLNET::ESocket &)
                {
                        localhost = "<UnknownHost>";
                }

                // Set the localhost name and service name to the logger
                CLog::setProcessName (localhost+"/"+_ShortName);
                nlinfo ("SERVICE: Host: %s", localhost.c_str());

                //
                // Initialize server parameters
                //

                // set the listen port if there are a port arg in the command line
                if (haveArg('P'))
                {
                        NLMISC::fromString(getArg('P'), ListeningPort);
                }

                // set the aes aliasname if present in cfg file
                CConfigFile::CVar *varAliasName= ConfigFile.getVarPtr("AESAliasName");
                if (varAliasName != NULL)
                {
                        _AliasName = varAliasName->asString();
                        nlinfo("SERVICE: Setting alias name to: '%s'",_AliasName.c_str());
                }

                // set the aes aliasname if is present in the command line
                if (haveArg('N'))
                {
                        _AliasName = getArg('N');
                        nlinfo("SERVICE: Setting alias name to: '%s'",_AliasName.c_str());
                }

                // Load the recording state from the config file
                if ((var = ConfigFile.getVarPtr ("Rec")) != NULL)
                {
                        string srecstate = toUpperAscii(var->asString());
                        if ( srecstate == "RECORD" )
                        {
                                _RecordingState = CCallbackNetBase::Record;
                                nlinfo( "SERVICE: Service recording messages" );
                        }
                        else if ( srecstate == "REPLAY" )
                        {
                                _RecordingState = CCallbackNetBase::Replay;
                                nlinfo( "SERVICE: Service replaying messages" );
                        }
                        else
                        {
                                _RecordingState = CCallbackNetBase::Off;
                        }
                }
                else
                {
                        // Not found
                        _RecordingState = CCallbackNetBase::Off;
                }

                // Load the default stream format
                if ((var = ConfigFile.getVarPtr ("StringMsgFormat")) != NULL)
                {
                        CMessage::setDefaultStringMode( var->asInt() == 1 );
                }
                else
                {
                        // Not found => binary
                        CMessage::setDefaultStringMode( false );
                }


                ///
                /// Layer5 Startup
                ///

                // get the sid
                if ((var = ConfigFile.getVarPtr ("SId")) != NULL)
                {
                        sint32 sid = var->asInt();
                        if (sid<=0 || sid>255)
                        {
                                nlwarning("SERVICE: Bad SId value in the config file, %d is not in [0;255] range", sid);
                                _SId.set(0);
                        }
                        else
                        {
                                _SId.set(static_cast<uint16>(sid));
                        }
                }
                else
                {
                        // ok, SId not found, use dynamic sid
                        _SId.set(0);
                }


                // look if we don't want to use NS
                if ((var = ConfigFile.getVarPtr ("DontUseNS")) != NULL)
                {
                        // if we set the value in the config file, get it
                        _DontUseNS = (var->asInt() == 1);
                }
                else
                {
                        // if not, we use ns only if service is not ns, ls, aes, as
                        _DontUseNS = false;
                }
                if (haveLongArg("nons"))
                {
                        // command line override
                        _DontUseNS = true;
                }

                //
                // Register all network associations (must be before the CUnifiedNetwork::getInstance()->init)
                //

                if ((var = ConfigFile.getVarPtr ("Networks")) != NULL)
                {
                        for (uint8 i = 0; i < var->size (); i++)
                                CUnifiedNetwork::getInstance()->addNetworkAssociation (var->asString(i), i);
                }

                if ((var = ConfigFile.getVarPtr ("DefaultNetworks")) != NULL)
                {
                        for (uint8 i = 0; i < var->size (); i++)
                                CUnifiedNetwork::getInstance()->addDefaultNetwork(var->asString(i));
                }

                // normal setup for the common services
                if (!_DontUseNS)
                {
                        bool ok = false;
                        while (!ok)
                        {
                                string LSAddr;

                                if (haveArg('B'))
                                {
                                        // if the naming service address is set on the command line, get it (overwrite the cfg)
                                        LSAddr = getArg('B');
                                }
                                else
                                {
                                        // else read the naming service address from the config file
                                        LSAddr = ConfigFile.getVar ("NSHost").asString();
                                }

                                // if there's no port to the NS, use the default one 50000
                                if (LSAddr.find(":") == string::npos)
                                        LSAddr += ":50000";

                                CInetAddress loc(LSAddr);
                                try
                                {
                                        // todo: check if app not closed by user, or you get stuck here

                                        if ( CUnifiedNetwork::getInstance()->init (&loc, _RecordingState, _ShortName, ListeningPort, _SId) )
                                        {
                                                ok = true;
                                        }
                                        else
                                        {
                                                nlinfo( "SERVICE: Exiting..." );
                                                beep( 880, 400 );
                                                beep( 440, 400 );
                                                beep( 220, 400 );

                                                // remove the stdin monitor thread
                                                IStdinMonitorSingleton::getInstance()->release(); // does nothing if not initialized

                                                // release the module manager
                                                IModuleManager::getInstance().releaseInstance();

                                                return 10;
                                        }
                                }
                                catch (const ESocketConnectionFailed &)
                                {
                                        nlinfo ("SERVICE: Could not connect to the Naming Service (%s). Retrying in a few seconds...", loc.asString().c_str());
                                        nlSleep (5000);
                                }
                        }
                }
                else
                {
                        CUnifiedNetwork::getInstance()->init(NULL, _RecordingState, _ShortName, ListeningPort, _SId);
                }

                // get the hostname for later use
                _HostName = CInetAddress::localHost().hostName();

                // At this point, the _SId must be ok if we use the naming service.
                // If it's 0, it means that we don't use NS and we left the other side server to find a sid for your connection

                if(!_DontUseNS)
                {
                        nlassert (_SId.get() != 0);
                }

                //
                // Connect to the local AES and send identification
                //

                // look if we don't want to use NS
                if ((var = ConfigFile.getVarPtr ("DontUseAES")) != NULL)
                {
                        // if we set the value in the config file, get it
                        _DontUseAES = var->asInt() == 1;
                }
                else
                {
                        // if not, we use aes only if service is not aes or as
                        _DontUseAES = false;
                }

                initAdmin (_DontUseAES);

                while (NLNET::CUnifiedNetwork::getInstance()->tryFlushAllQueues() != 0)
                {
                        nlSleep(10);
                }

                //
                // Add callback array
                //

                // add inner service callback array
                NLNET::CUnifiedNetwork::getInstance()->addCallbackArray(builtinServiceCallbacks, sizeof(builtinServiceCallbacks)/sizeof(builtinServiceCallbacks[0]));

                // add callback set in the NLNET_SERVICE_MAIN macro
                NLNET::CUnifiedNetwork::getInstance()->addCallbackArray(_CallbackArray, _CallbackArraySize);

                //
                // Now we have the service id, we can set the entites id generator
                //

                NLMISC::CEntityId::setServiceId(TServiceId8(_SId).get());

                // Set the localhost name and service name and the sid
                CLog::setProcessName (localhost+"/"+_ShortName+"-"+toString(_SId.get()));


                //
                // Add default pathes
                //

                if ((var = ConfigFile.getVarPtr ("IgnoredFiles")) != NULL)
                {
                        for (uint i = 0; i < var->size(); i++)
                        {
                                CPath::addIgnoredDoubleFile (var->asString(i));
                        }
                }

                if ((var = ConfigFile.getVarPtr ("Paths")) != NULL)
                {
                        for (uint i = 0; i < var->size(); i++)
                        {
                                CPath::addSearchPath (NLMISC::expandEnvironmentVariables(var->asString(i)), true, false);
                        }
                }

                if ((var = ConfigFile.getVarPtr ("PathsNoRecurse")) != NULL)
                {
                        for (uint i = 0; i < var->size(); i++)
                        {
                                CPath::addSearchPath (NLMISC::expandEnvironmentVariables(var->asString(i)), false, false);
                        }
                }

                // if we can, try to setup where to save files
                if (IService::getInstance()->haveArg('W'))
                {
                        // use the command line param if set (must be done after the config file has been loaded)
                        SaveFilesDirectory = IService::getInstance()->getArg('W');
                }

                CTransportClass::init();

                //
                // Call the user service init
                //

                userInitCalled = true; // the bool must be put *before* the call to init()

                setCurrentStatus("Initializing");
                init ();
                clearCurrentStatus("Initializing");


                //
                // Connects to the present services
                // WARNING: only after the user init() was called because the
                // addService may call up service callbacks.
                //

                CUnifiedNetwork::getInstance()->connect();

                //
                // Say to the AES that the service is ready
                //

                if (!_DontUseAES)
                {
                        // send the ready message (service init finished)
                        CMessage msgout ("SR");
                        CUnifiedNetwork::getInstance()->send("AES", msgout);
                }


                _Initialized = true;

                nlinfo ("SERVICE: Service initialized, executing StartCommands");

                //
                // Call the user command from the config file if any
                //
                string cmdRoot("StartCommands");
                vector<string>  posts;

                // add an empty string (for the common part of start commands)
                posts.push_back(string());

                if (IService::getInstance()->haveArg('S'))
                {
                        string s = IService::getInstance()->getArg('S');
                        posts.push_back(s);
                }

                CConfigFile::CVar *var;
                for (uint i=0; i<posts.size(); ++i)
                {
                        string varName = cmdRoot + posts[i];
                        if ((var = IService::getInstance()->ConfigFile.getVarPtr (varName)) != NULL)
                        {
                                for (uint i = 0; i < var->size(); i++)
                                {
                                        ICommand::execute (var->asString(i), CommandLog);
                                }
                        }
                }

                string str;
                CLog logDisplayVars;
                CLightMemDisplayer mdDisplayVars;
                logDisplayVars.addDisplayer (&mdDisplayVars);

                //
                // Activate the timeout assertion thread
                //

                timeoutThread = IThread::create(&MyTAT, 1024*4);
                timeoutThread->start();

                //
                // Set service ready
                //

                nlinfo ("SERVICE: Service ready");

                if (WindowDisplayer != NULL)
                        WindowDisplayer->setTitleBar (_ShortName + " " + _LongName + " " + Version.c_str());

                //
                // Call the user service update each loop and check files and network activity
                //

                TTime   checkCpuProcTime = 0;

                for(;;)
                {
                        MyTAT.activate();

                        if(Bench) CHTimer::startBench(false, true, false);

                        // count the amount of time to manage internal system
                        TTime bbefore = CTime::getLocalTime ();

                        // every second, check for CPU usage
                        if (bbefore - checkCpuProcTime > 1000)
                        {
                                checkCpuProcTime = bbefore;
                                _CPUUsageStats.peekMeasures();
                        }

                        // call the user update and exit if the user update asks it
                        {
                                H_AUTO(NLNETServiceUpdate);
                                if (!update ())
                                {
                                        CHTimer::endBench();
                                        break;
                                }
                        }

                        // deal with any input waiting from stdin
                        {
                                H_AUTO(NLNETStdinMonitorUpdate);
                                IStdinMonitorSingleton::getInstance()->update();
                        }

                        // if the launching mode is 'quit after the first update' we set the exit signal
                        if (haveArg('Q'))
                        {
                                // we use -100 so that the final return code ends as 0 (100+ExitSignalAsked) because
                                // otherwise we can't launch services with -Q in a makefile
                                ExitSignalAsked = -100;
                        }
                        NbUserUpdate++;

                        // count the amount of time to manage internal system
                        TTime before = CTime::getLocalTime ();

                        if (WindowDisplayer != NULL)
                        {
                                // update the window displayer and quit if asked
                                if (!WindowDisplayer->update ())
                                {
                                        nlinfo ("SERVICE: The window displayer was closed by user, need to quit");
                                        ExitSignalAsked = 1;
                                }
                        }

                        // stop the loop if the exit signal asked
                        if (ExitSignalAsked != 0)
                        {
                                if ( _RequestClosureClearanceCallback )
                                {
                                        if ( _ClosureClearanceStatus == CCClearedForClosure )
                                        {
                                                // Clearance has been granted
                                                CHTimer::endBench();
                                                break;
                                        }
                                        else if ( _ClosureClearanceStatus == CCMustRequestClearance )
                                        {
                                                if ( _RequestClosureClearanceCallback() )
                                                {
                                                        // Direct clearance
                                                        _ClosureClearanceStatus = CCClearedForClosure;
                                                        CHTimer::endBench();
                                                        break;
                                                }
                                                else
                                                {
                                                        // Delayed clearance
                                                        _ClosureClearanceStatus = CCWaitingForClearance;
                                                }
                                        }
                                        else if ( _ClosureClearanceStatus >= CCCallbackThenClose )
                                        {
                                                // Always direct closure, because we don't have a connection to the naming service anymore
                                                // But still call the callback
                                                _RequestClosureClearanceCallback();
                                                CHTimer::endBench();
                                                break;
                                        }
                                }
                                else
                                {
                                        // Immediate closure, no clearance needed
                                        CHTimer::endBench();
                                        break;
                                }
                        }

                        CConfigFile::checkConfigFiles ();

                        updateAdmin ();

                        CFile::checkFileChange();

                        // update updatable interface
                        set<IServiceUpdatable*>::iterator first(_Updatables.begin()), last(_Updatables.end());
                        for (; first != last; ++first)
                        {
                                IServiceUpdatable *updatable = *first;
                                updatable->serviceLoopUpdate();
                        }

                        // get and manage layer 5 messages
                        CUnifiedNetwork::getInstance()->update (_UpdateTimeout);


                        // update modules
                        IModuleManager::getInstance().updateModules();


                        // Allow direct closure if the naming service was lost
                        if ( _RequestClosureClearanceCallback )
                        {
                                if ( ! CNamingClient::connected() )
                                {
                                        if ( _ClosureClearanceStatus < CCCallbackThenClose )
                                                _ClosureClearanceStatus += CCCallbackThenClose; // change status but backup old value
                                }
                                else
                                {
                                        if ( _ClosureClearanceStatus >= CCCallbackThenClose )
                                                _ClosureClearanceStatus -= CCCallbackThenClose; // set the closure state back if the NS comes back
                                }
                        }

                        NetSpeedLoop = (sint32) (CTime::getLocalTime () - before);
                        UserSpeedLoop = (sint32) (before - bbefore);
                        L5CallbackTime = TimeInCallback - LastTimeInCallback;
                        LastTimeInCallback = TimeInCallback;
                        L5CallbackCount = TotalCallbackCalled - LastTotalCallbackCalled;
                        LastTotalCallbackCalled = TotalCallbackCalled;

                        if (WindowDisplayer != NULL)
                        {
                                static TTime lt = 0;
                                TTime ct = CTime::getLocalTime();
                                if(ct > lt+100)
                                {
                                        lt = ct;
                                        uint64 rcv, snd, rcvq, sndq;
                                        rcv = CUnifiedNetwork::getInstance()->getBytesReceived ();
                                        snd = CUnifiedNetwork::getInstance()->getBytesSent ();
                                        rcvq = CUnifiedNetwork::getInstance()->getReceiveQueueSize ();
                                        sndq = CUnifiedNetwork::getInstance()->getSendQueueSize ();

                                        for (uint i = 0; i < displayedVariables.size(); i++)
                                        {
                                                // it s a separator, do nothing
                                                if (displayedVariables[i].first.empty())
                                                        continue;

                                                // it s a command, do nothing
                                                if (displayedVariables[i].first[0] == '@')
                                                        continue;

                                                string dispName = displayedVariables[i].first;
                                                string varName = dispName;
                                                string::size_type pos = dispName.find("|");
                                                if (pos != string::npos)
                                                {
                                                        varName = displayedVariables[i].first.substr(pos+1);
                                                        dispName = displayedVariables[i].first.substr(0, pos);
                                                }

                                                if (dispName.empty())
                                                        str.clear();
                                                else
                                                        str = dispName + ": ";

                                                mdDisplayVars.clear ();
                                                ICommand::execute(varName, logDisplayVars, true);
                                                const std::deque<std::string>   &strs = mdDisplayVars.lockStrings();
                                                if (!strs.empty())
                                                {
                                                        str += strs[0].substr(0,strs[0].size()-1);
                                                }
                                                else
                                                {
                                                        str += "???";
                                                }
                                                mdDisplayVars.unlockStrings();
                                                WindowDisplayer->setLabel (displayedVariables[i].second, str);
                                        }

                                }

                        }

                        // nldebug ("SYNC: updatetimeout must be %d and is %d, sleep the rest of the time", _UpdateTimeout, delta);

                        CHTimer::endBench();

                        // Resetting the hierarchical timer must be done outside the top-level timer
                        if ( _ResetMeasures )
                        {
                                CHTimer::clear();
                                _ResetMeasures = false;
                        }

                        MyTAT.deactivate();
                }
        }
        catch (const EFatalError &)
        {
                // Somebody call nlerror, so we have to quit now, the message already display
                // so we don't have to to anything
                setExitStatus (EXIT_FAILURE);
        }
        catch (const ESocket &e)
        {
                // Catch NeL network exception to release the system cleanly            setExitStatus (EXIT_FAILURE);
                ErrorLog->displayNL( "NeL Exception in \"%s\": %s", _ShortName.c_str(), e.what() );
        }
        catch ( uint ) // SEH exceptions
        {
                ErrorLog->displayNL( "SERVICE: System exception" );
        }

        try
        {
                nlinfo ("SERVICE: Service starts releasing");

                //
                // Call the user service release() if the init() was called
                //

                if (userInitCalled)
                {
                        setCurrentStatus("Releasing");
                        release ();
                }

                CTransportClass::release();

                //
                // Delete all network connection (naming client also)
                //

                std::vector<std::string> namesOfOnlyServiceToFlushSendingV;
                explode( NamesOfOnlyServiceToFlushSending.get(), string(":"), namesOfOnlyServiceToFlushSendingV, true );
                CUnifiedNetwork::getInstance()->release (FlushSendingQueuesOnExit.get(), namesOfOnlyServiceToFlushSendingV);

                // warn the module layer that the application is about to close
                IModuleManager::getInstance().applicationExit();

//              // release the network
//              CSock::releaseNetwork ();
//
                //
                // Remove the window displayer
                //

                if (WindowDisplayer != NULL)
                {
                        DebugLog->removeDisplayer (WindowDisplayer);
                        InfoLog->removeDisplayer (WindowDisplayer);
                        WarningLog->removeDisplayer (WindowDisplayer);
                        ErrorLog->removeDisplayer (WindowDisplayer);
                        AssertLog->removeDisplayer (WindowDisplayer);
                        CommandLog.removeDisplayer (WindowDisplayer);

                        delete WindowDisplayer;
                        WindowDisplayer = NULL;
                }

                nlinfo ("SERVICE: Service released successfully");
        }
        catch (const EFatalError &)
        {
                // Somebody call nlerror, so we have to quit now, the message already display
                // so we don't have to to anything
                setExitStatus (EXIT_FAILURE);
        }

        // remove the stdin monitor thread
        IStdinMonitorSingleton::getInstance()->release(); // does nothing if not initialized

        // release the module manager
        IModuleManager::getInstance().releaseInstance();

        // release the network
        CSock::releaseNetwork ();

        // stop the timeout thread
        MyTAT.quit();
        if (timeoutThread != NULL)
        {
                timeoutThread->wait();
                delete timeoutThread;
        }

        CHTimer::display();
        CHTimer::displayByExecutionPath ();
        CHTimer::displayHierarchical(&CommandLog, true, 64);
        CHTimer::displayHierarchicalByExecutionPathSorted (&CommandLog, CHTimer::TotalTime, true, 64);

        nlinfo ("SERVICE: Service ends");

        return ExitSignalAsked?100+ExitSignalAsked:getExitStatus ();
}

void IService::exit (sint code)
{
        nlinfo ("SERVICE: Somebody called IService::exit(), I have to quit");
        ExitSignalAsked = code;
}

/// Push a new status on the status stack.
void IService::setCurrentStatus(const std::string &status)
{
        // remove the status if it is already in the stack
        _ServiceStatusStack.erase(std::remove(_ServiceStatusStack.begin(), _ServiceStatusStack.end(), status), _ServiceStatusStack.end());

        // insert the status on top of the stack
        _ServiceStatusStack.push_back(status);

}

/// Remove a status from the status stack. If this status is at top of stack, the next status become the current status
void IService::clearCurrentStatus(const std::string &status)
{
        // remove the status of the stack
        _ServiceStatusStack.erase(std::remove(_ServiceStatusStack.begin(), _ServiceStatusStack.end(), status), _ServiceStatusStack.end());
}

/// Add a tag in the status string
void IService::addStatusTag(const std::string &statusTag)
{
        _ServiveStatusTags.insert(statusTag);
}

/// Remove a tag from the status string
void IService::removeStatusTag(const std::string &statusTag)
{
        _ServiveStatusTags.erase(statusTag);
}

/// Get the current status with attached tags
std::string IService::getFullStatus() const
{
        string result;

        // get hold of the status at the top of the status stack
        if (!_ServiceStatusStack.empty())
        {
                result = _ServiceStatusStack.back();
        }

        // add status tags to the result so far
        set<string>::const_iterator first(_ServiveStatusTags.begin()), last(_ServiveStatusTags.end());
        for (; first != last; ++first)
        {
                if (first != _ServiveStatusTags.begin() || !result.empty())
                        result += " ";
                result += *first;
        }

        // return the result
        return result.empty()? "Online": result;
}


/*
 * Require to reset the hierarchical timer
 */
void IService::requireResetMeasures()
{
        _ResetMeasures = true;
}


/*
 *
 */
std::string IService::getServiceUnifiedName () const
{
        nlassert (!_ShortName.empty());
        string res;
        if (!_AliasName.empty())
        {
                res = _AliasName+"/";
        }
        res += _ShortName;
        if (_SId.get() != 0)
        {
                res += "-";
                res += toString (_SId.get());
        }
        return res;
}


/*
 * Returns the date of launch of the service. Unit: see CTime::getSecondsSince1970()
 */
uint32          IService::getLaunchingDate () const
{
        return LaunchingDate;
}


void IService::registerUpdatable(IServiceUpdatable *updatable)
{
        _Updatables.insert(updatable);
}

void IService::unregisterUpdatable(IServiceUpdatable *updatable)
{
        _Updatables.erase(updatable);
}

//
// Commands and Variables for controling all services
//

NLMISC_CATEGORISED_DYNVARIABLE(nel, string, LaunchingDate, "date of the launching of the program")
{
        nlunreferenced(human);
        if (get) *pointer = asctime (localtime ((time_t*)&LaunchingDate));
}

NLMISC_CATEGORISED_DYNVARIABLE(nel, string, Uptime, "time from the launching of the program")
{
        if (get)
        {
                if (human)
                        *pointer = secondsToHumanReadable (CTime::getSecondsSince1970() - LaunchingDate);
                else
                        *pointer = NLMISC::toString(CTime::getSecondsSince1970() - LaunchingDate);
        }
        else
        {
                NLMISC::fromString(*pointer, LaunchingDate);
                LaunchingDate = CTime::getSecondsSince1970() - LaunchingDate;
        }
}

NLMISC_CATEGORISED_VARIABLE(nel, string, CompilationDate, "date of the compilation");
NLMISC_CATEGORISED_VARIABLE(nel, string, CompilationMode, "mode of the compilation");

NLMISC_CATEGORISED_VARIABLE(nel, uint32, NbUserUpdate, "number of time the user IService::update() called");

NLMISC_CATEGORISED_DYNVARIABLE(nel, string, Scroller, "current size in bytes of the sent queue size")
{
        nlunreferenced(human);

        if (get)
        {
                // display the scroll text
                static string foo =     "Welcome to NeL Service! This scroll is used to see the update frequency of the main function and to see if the service is frozen or not. Have a nice day and hope you'll like NeL!!! "
                                                        "Welcome to NeL Service! This scroll is used to see the update frequency of the main function and to see if the service is frozen or not. Have a nice day and hope you'll like NeL!!! ";
                static int pos = 0;
                *pointer = foo.substr ((pos++)%(foo.size()/2), 10);
        }
}

NLMISC_CATEGORISED_COMMAND(nel, quit, "exit the service", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(quiet);
        nlunreferenced(human);

        if(args.size() != 0) return false;

        log.displayNL("User ask me with a command to quit");
        ExitSignalAsked = 0xFFFF;

        return true;
}

NLMISC_CATEGORISED_COMMAND(nel, brutalQuit, "exit the service brutally", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(log);
        nlunreferenced(quiet);
        nlunreferenced(human);

        if(args.size() != 0) return false;

        ::exit (0xFFFFFFFF);

        return true;
}


#ifdef MUTEX_DEBUG
NLMISC_CATEGORISED_COMMAND(nel, mutex, "display mutex values", "")
{
        if(args.size() != 0) return false;

        map<CFairMutex*,TMutexLocks>    acquiretimes = getNewAcquireTimes();

        map<CFairMutex*,TMutexLocks>::iterator im;
        for ( im=acquiretimes.begin(); im!=acquiretimes.end(); ++im )
        {
                log.displayNL( "%d %p %s: %.0f %.0f, called %u times th(%d, %d wait)%s", (*im).second.MutexNum, (*im).first, (*im).second.MutexName.c_str(),
                        CTime::cpuCycleToSecond((*im).second.TimeToEnter)*1000.0, CTime::cpuCycleToSecond((*im).second.TimeInMutex)*1000.0,
                        (*im).second.Nb, (*im).second.ThreadHavingTheMutex, (*im).second.WaitingMutex,
                        (*im).second.Dead?" DEAD":"");
        }

        return true;
}
#endif // MUTEX_DEBUG

NLMISC_CATEGORISED_COMMAND(nel, serviceInfo, "display information about this service", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(quiet);
        nlunreferenced(human);

        if(args.size() != 0) return false;

        log.displayNL ("Service %s '%s' using NeL (" __DATE__ " " __TIME__ ")", IService::getInstance()->getServiceLongName().c_str(), IService::getInstance()->getServiceUnifiedName().c_str());
        log.displayNL ("Service listening port: %d", IService::getInstance()->ListeningPort.get());
        log.displayNL ("Service running directory: '%s'", IService::getInstance()->RunningDirectory.c_str());
        log.displayNL ("Service log directory: '%s'", IService::getInstance()->LogDirectory.c_str());
        log.displayNL ("Service save files directory: '%s'", IService::getInstance()->SaveFilesDirectory.c_str());
        log.displayNL ("Service write files directory: '%s'", IService::getInstance()->WriteFilesDirectory.c_str());
        log.displayNL ("Service config directory: '%s' config filename: '%s.cfg'", IService::getInstance()->ConfigDirectory.c_str(), IService::getInstance()->_LongName.c_str());
        log.displayNL ("Service id: %hu", IService::getInstance()->_SId.get());
        log.displayNL ("Service update timeout: %dms", IService::getInstance()->_UpdateTimeout);
        log.displayNL ("Service %suse naming service", IService::getInstance()->_DontUseNS?"don't ":"");
        log.displayNL ("Service %suse admin executor service", IService::getInstance()->_DontUseAES?"don't ":"");
        log.displayNL ("NeL is compiled in %s mode", CompilationMode.c_str());

        log.displayNL ("Services arguments: %d args", IService::getInstance()->_Args.size ());
        for (uint i = 0; i < IService::getInstance()->_Args.size (); i++)
        {
                log.displayNL ("  argv[%d] = '%s'", i, IService::getInstance()->_Args[i].c_str ());
        }

        log.displayNL ("Naming service info: %s", CNamingClient::info().c_str());

        ICommand::execute ("services", log);

        return true;
}

NLMISC_CATEGORISED_COMMAND(nel, resetMeasures, "reset hierarchical timer", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(args);
        nlunreferenced(log);
        nlunreferenced(quiet);
        nlunreferenced(human);

        IService::getInstance()->requireResetMeasures();
        return true;
}

NLMISC_CATEGORISED_COMMAND(nel, getWinDisplayerInfo, "display the info about the pos and size of the window displayer", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(args);
        nlunreferenced(quiet);
        nlunreferenced(human);

        uint32 x,y,w,h;
        IService::getInstance()->WindowDisplayer->getWindowPos (x,y,w,h);
        log.displayNL ("Window Displayer : XWinParam = %d; YWinParam = %d; WWinParam = %d; HWinParam = %d;", x, y, w, h);
        return true;
}

NLMISC_CATEGORISED_COMMAND(nel, displayConfigFile, "display the variables of the default configfile", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(args);
        nlunreferenced(quiet);
        nlunreferenced(human);

        IService::getInstance()->ConfigFile.display (&log);
        return true;
}

NLMISC_CATEGORISED_COMMAND(nel, getUnknownConfigFileVariables, "display the variables from config file that are called but not present", "")
{
        nlunreferenced(rawCommandString);
        nlunreferenced(args);
        nlunreferenced(quiet);
        nlunreferenced(human);

        log.displayNL ("%d Variables not found in the configfile '%s'", IService::getInstance()->ConfigFile.UnknownVariables.size(), IService::getInstance()->ConfigFile.getFilename().c_str() );
        for (uint i = 0; i < IService::getInstance()->ConfigFile.UnknownVariables.size(); i++)
        {
                log.displayNL ("  %s", IService::getInstance()->ConfigFile.UnknownVariables[i].c_str());
        }
        return true;
}

// -1 = service is quitting
// 0 = service is not connected
// 1 = service is running
// 2 = service is launching
// 3 = service failed launching

NLMISC_CATEGORISED_DYNVARIABLE(nel, string, State, "Set this value to 0 to shutdown the service and 1 to start the service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)
        {
        }
        else
        {
                if (IService::getInstance()->getServiceShortName() == "AES" || IService::getInstance()->getServiceShortName() == "AS")
                {
                        nlinfo ("SERVICE: I can't set State=0 because I'm the admin and I should never quit");
                }
                else if (*pointer == "0" || *pointer == "2")
                {
                        // ok, we want to set the value to false, just quit
                        nlinfo ("SERVICE: User ask me with a command to quit using the State variable");
                        ExitSignalAsked = 0xFFFE;
                        IService *srv = IService::getInstance();
                        if( srv == NULL )
                        {
                                return;
                        }
                        srv->setCurrentStatus("Quitting");
                }
                else
                {
                        nlwarning ("SERVICE: Unknown value for State '%s'", (*pointer).c_str());
                }
        }

        // whether reading or writing, the internal value of the state variable should end up as the result of getFullStatus()
        IService *srv = IService::getInstance();
        if( srv == NULL )
        {
                return;
        }
        *pointer= srv->getFullStatus();
}


NLMISC_CATEGORISED_DYNVARIABLE(nel, uint32, ShardId, "Get value of shardId set for this particular service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)
        {
                *pointer = IService::getInstance()->getShardId();
        }
}


NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, CPULoad, "Get instant CPU load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPULoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, ProcessLoad, "Get instant CPU load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, CPUUserLoad, "Get instant CPU user load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUUserLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, CPUSytemLoad, "Get instant CPU system load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUSystemLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, CPUNiceLoad, "Get instant CPU nice processes load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUNiceLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, CPUIOWaitLoad, "Get instant CPU IO wait load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUIOWaitLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, ProcessUserLoad, "Get instant CPU user load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessUserLoad(); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, ProcessSystemLoad, "Get instant CPU system load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessSystemLoad(); }
}


NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanCPULoad, "Get instant CPU load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPULoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanProcessLoad, "Get instant CPU load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanCPUUserLoad, "Get instant CPU user load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUUserLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanCPUSytemLoad, "Get instant CPU system load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUSystemLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanCPUNiceLoad, "Get instant CPU nice processes load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUNiceLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanCPUIOWaitLoad, "Get instant CPU IO wait load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUIOWaitLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanProcessUserLoad, "Get instant CPU user load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessUserLoad(CCPUTimeStat::Mean); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, MeanProcessSystemLoad, "Get instant CPU system load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessSystemLoad(CCPUTimeStat::Mean); }
}



NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakCPULoad, "Get instant CPU load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPULoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakProcessLoad, "Get instant CPU load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakCPUUserLoad, "Get instant CPU user load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUUserLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakCPUSytemLoad, "Get instant CPU system load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUSystemLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakCPUNiceLoad, "Get instant CPU nice processes load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUNiceLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakCPUIOWaitLoad, "Get instant CPU IO wait load of the server")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getCPUIOWaitLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakProcessUserLoad, "Get instant CPU user load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessUserLoad(CCPUTimeStat::Peak); }
}

NLMISC_CATEGORISED_DYNVARIABLE(cpu, float, PeakProcessSystemLoad, "Get instant CPU system load of the process/service")
{
        nlunreferenced(human);
        // read or write the variable
        if (get)        { *pointer = IService::getInstance()->getCPUUsageStats().getProcessSystemLoad(CCPUTimeStat::Peak); }
}


} //NLNET