// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// 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 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 = fopen("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;

		// setReportEmailFunction ((void*)sendEmail);
		// 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 = fopen (cfn.c_str(), "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 += "_" + toLower(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 = toUpper(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 (var->asString(i), true, false);
			}
		}

		if ((var = ConfigFile.getVarPtr ("PathsNoRecurse")) != NULL)
		{
			for (uint i = 0; i < var->size(); i++)
			{
				CPath::addSearchPath (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 = "";
						else
							str = dispName + ": ";

						mdDisplayVars.clear ();
						ICommand::execute(varName, logDisplayVars, true);
						const std::deque<std::string>	&strs = mdDisplayVars.lockStrings();
						if (strs.size()>0)
						{
							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