khanat-opennel-code/code/nelns/naming_service/naming_service.cpp
2016-02-18 11:55:58 +01:00

1155 lines
30 KiB
C++

// NeLNS - 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/>.
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif // HAVE_CONFIG_H
#ifndef NELNS_CONFIG
#define NELNS_CONFIG ""
#endif // NELNS_CONFIG
#ifndef NELNS_LOGS
#define NELNS_LOGS ""
#endif // NELNS_LOGS
//
// Includes
//
#include "nel/misc/types_nl.h"
#include <list>
#include <string>
#include "nel/misc/debug.h"
#include "nel/misc/command.h"
#include "nel/misc/variable.h"
#include "nel/misc/displayer.h"
#include "nel/net/callback_server.h"
#include "nel/net/service.h"
#include "nel/net/module_manager.h"
//
// Namespaces
//
using namespace std;
using namespace NLMISC;
using namespace NLNET;
NLMISC_COMMAND(test, "none", "none")
{
log.displayNL("Raw cmd line : '%s'", rawCommandString.c_str());
log.displayNL("Dumping %u parameters :", args.size());
for (uint i=0; i<args.size(); ++i)
{
log.displayNL(" %u : '%s'", i, args[i].c_str());
}
return true;
}
//
// Structures
//
struct CServiceEntry
{
CServiceEntry (TSockId sock, const vector<CInetAddress> &a, const string &n, TServiceId s) : SockId(sock), Addr(a), Name(n), SId (s), WaitingUnregistration(false) { }
TSockId SockId; // the connection between the service and the naming service
vector<CInetAddress> Addr; // address to send to the service who wants to lookup this service
// it s possible to have more than one addr, anyway, the naming service
// will send good address depending of the sub net address of the service
string Name; // name of the service
TServiceId SId; // id of the service
bool WaitingUnregistration; // true if this service is in unregistration process (wait other service ACK)
TTime WaitingUnregistrationTime; // time of the beginning of the inregistration process
list<TServiceId> WaitingUnregistrationServices; // list of service that we wait the answer
};
// Helper that emulates layer5's send()
//void sendToService( uint16 sid, CMessage& msgout );
// Helper that emulate layer5's getServiceName()
string getServiceName( TServiceId sid );
// Helper that returns the first address of a service
CInetAddress getHostAddress( TServiceId sid );
// Asks a service to stop and tell every one
void doUnregisterService (TServiceId sid);
/**
* Manager for services instances
* (Moved from the TICKS to the NS)
* Implementable with layer 5, here implemented in NS (layer 3)
* \author Olivier Cado
* \author Nevrax France
* \date 2003
*/
class CServiceInstanceManager
{
public:
/// Constructor
CServiceInstanceManager();
/** Add the name of a service which must not be duplicated
* If uniqueOnShard is true, only one service is allowed.
* If uniqueOnShard is false, one service is allowed by physical machine.
*/
void addUniqueService( const std::string& serviceName, bool uniqueOnShard )
{
_UniqueServices.insert( std::make_pair( serviceName, uniqueOnShard ) );
}
/// Check if a service is allowed to start (if so, add it)
bool queryStartService( const std::string& serviceName, TServiceId serviceId, const std::vector<NLNET::CInetAddress> &addr, string& reason );
/// Release a service instance
void releaseService( NLNET::TServiceId serviceId );
/// Display information
void displayInfo( NLMISC::CLog *log = NLMISC::InfoLog ) const;
/// Make all controlled services quit
void killAllServices();
private:
/// List of restricted services
std::map< std::string, bool > _UniqueServices;
/// List of granted (online) services
std::set< TServiceId > _OnlineServices;
};
CServiceInstanceManager *SIMInstance = NULL;
/*
* Constructor
*/
CServiceInstanceManager::CServiceInstanceManager()
{
nlassert( ! SIMInstance );
SIMInstance = this;
// Note: addCallbackArray() done in CRangeMirrorManager::init()
}
/*
* Check if a service is allowed to start. Answer with a GSTS (Grant Start Service) message
*/
bool CServiceInstanceManager::queryStartService( const std::string& serviceName, TServiceId serviceId, const vector<CInetAddress> &addr, string& reason )
{
bool grantStarting = true;
std::map< std::string, bool >::iterator ius = _UniqueServices.find( serviceName );
if ( ius != _UniqueServices.end() )
{
// Service is restricted
set< TServiceId >::iterator ios;
bool uniqueOnShard = (*ius).second;
for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
{
string name = getServiceName( *ios );
if ( name == serviceName )
{
if ( uniqueOnShard )
{
// Only one service by shard is allowed => deny
grantStarting = false;
reason = toString( "Service %s already found as %hu, must be unique on shard", serviceName.c_str(), ios->get() );
nlinfo( reason.c_str() );
break;
}
else
{
// Only one service by physical machine is allowed
// Implementation for layer5
//TSockId hostid1, hostid2;
/*CCallbackNetBase *cnb1 = CUnifiedNetwork::getInstance()->getNetBase( serviceId, hostid1 );
CCallbackNetBase *cnb2 = CUnifiedNetwork::getInstance()->getNetBase( *ios, hostid2 );
if ( cnb1->hostAddress( hostid1 ).internalIPAddress() == cnb2->hostAddress( hostid2 ).internalIPAddress() )*/
// Implementation for NS
if ( addr[0].internalIPAddress() == getHostAddress( *ios ).internalIPAddress() )
{
grantStarting = false;
reason = toString( "Service %s already found as %hu on same machine", serviceName.c_str(), ios->get() );
nlinfo( reason.c_str() );
break;
}
}
}
}
}
if ( grantStarting )
{
_OnlineServices.insert( serviceId );
}
return grantStarting;
}
/*
* Release a service instance
*/
void CServiceInstanceManager::releaseService( NLNET::TServiceId serviceId )
{
_OnlineServices.erase( serviceId ); // not a problem if not found
}
/*
* Display information
*/
void CServiceInstanceManager::displayInfo( NLMISC::CLog *log ) const
{
log->displayNL( "Restricted services:" );
std::map< std::string, bool >::const_iterator ius;
for ( ius=_UniqueServices.begin(); ius!=_UniqueServices.end(); ++ius )
{
log->displayNL( "%s -> only one per %s", (*ius).first.c_str(), (*ius).second?"shard":"machine" );
}
log->displayNL( "Online registered services:" );
std::set< TServiceId >::const_iterator ios;
for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
{
log->displayNL( "%s", CUnifiedNetwork::getInstance()->getServiceUnifiedName( *ios ).c_str() );
}
}
/*
* Make all controlled services quit
*/
void CServiceInstanceManager::killAllServices()
{
// Send to all known online services
std::set< TServiceId >::const_iterator ios;
for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
{
doUnregisterService( (TServiceId)(*ios) );
}
}
//
// Variables
//
list<CServiceEntry> RegisteredServices; /// List of all registred services
uint16 MinBasePort = 51000; /// Ports begin at 51000
uint16 MaxBasePort = 52000; /// (note: in this implementation there can be no more than 1000 services)
const TServiceId BaseSId(128); /// Allocated SIds begin at 128 (except for Agent Service)
const TTime UnregisterTimeout = 10000; /// After 10s we remove an unregister service if every server didn't ACK the message
CCallbackServer *CallbackServer = NULL;
//
// Functions
//
bool canAccess (const vector<CInetAddress> &addr, const CServiceEntry &entry, vector<CInetAddress> &accessibleAddr)
{
accessibleAddr.clear ();
if (entry.WaitingUnregistration)
return false;
for (uint i = 0; i < addr.size(); i++)
{
uint32 net = addr[i].internalNetAddress();
for (uint j = 0; j < entry.Addr.size(); j++)
{
if (net == entry.Addr[j].internalNetAddress())
{
accessibleAddr.push_back (entry.Addr[j]);
}
}
}
if (accessibleAddr.empty())
{
nldebug ("service %s-%hu is not accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (addr).c_str ());
}
else
{
nldebug ("service %s-%hu is accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (accessibleAddr).c_str ());
}
return !accessibleAddr.empty ();
}
void displayRegisteredServices (CLog *log = InfoLog)
{
log->displayNL ("Display the %d registered services :", RegisteredServices.size());
for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
TSockId id = (*it).SockId;
if (id == NULL)
{
log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), "<NULL>", "<NULL>", (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
for(uint i = 0; i < (*it).Addr.size(); i++)
log->displayNL (" '%s'", (*it).Addr[i].asString().c_str());
}
else
{
log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), (*it).SockId->asString().c_str(), CallbackServer->hostAddress((*it).SockId).asString().c_str(), (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
for(uint i = 0; i < (*it).Addr.size(); i++)
log->displayNL (" '%s'", (*it).Addr[i].asString().c_str());
}
}
log->displayNL ("End of the list");
}
list<CServiceEntry>::iterator effectivelyRemove (list<CServiceEntry>::iterator &it)
{
// remove the service from the registered service list
nlinfo ("Effectively remove the service %s-%hu", (*it).Name.c_str(), it->SId.get());
return RegisteredServices.erase (it);
}
/*
* Helper procedure for cbLookupAlternate and cbUnregister.
* Note: name is used for a LOGS.
*/
list<CServiceEntry>::iterator doRemove (list<CServiceEntry>::iterator it)
{
nldebug ("Unregister the service %s-%hu '%s'", (*it).Name.c_str(), it->SId.get(), (*it).Addr[0].asString().c_str());
// tell to everybody that this service is unregistered
CMessage msgout ("UNB");
msgout.serial ((*it).Name);
msgout.serial ((*it).SId);
vector<CInetAddress> accessibleAddress;
nlinfo ("Broadcast the Unregistration of %s-%hu to all registered services", (*it).Name.c_str(), it->SId.get());
for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
{
if (canAccess((*it).Addr, (*it3), accessibleAddress))
{
CallbackServer->send (msgout, (*it3).SockId);
//CNetManager::send ("NS", msgout, (*it3).SockId);
nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
}
}
// new system, after the unregistation broadcast, we wait ACK from all services before really remove
// the service, before, we tag the service as 'wait before unregister'
// if everybody didn't answer before the time out, we remove it
(*it).SockId = NULL;
(*it).WaitingUnregistration = true;
(*it).WaitingUnregistrationTime = CTime::getLocalTime();
// we remove all services awaiting his ACK because this service is down so it'll never ACK
for (list<CServiceEntry>::iterator itr = RegisteredServices.begin(); itr != RegisteredServices.end (); itr++)
{
for (list<TServiceId>::iterator itw = (*itr).WaitingUnregistrationServices.begin(); itw != (*itr).WaitingUnregistrationServices.end ();)
{
if ((*itw) == (*it).SId)
{
itw = (*itr).WaitingUnregistrationServices.erase (itw);
}
else
{
itw++;
}
}
}
string res;
for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
{
if (!(*it2).WaitingUnregistration)
{
(*it).WaitingUnregistrationServices.push_back ((*it2).SId);
res += toString((*it2).SId.get()) + " ";
}
}
nlinfo ("Before removing the service %s-%hu, we wait the ACK of '%s'", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
if ((*it).WaitingUnregistrationServices.empty())
{
return effectivelyRemove (it);
}
else
{
return ++it;
}
// Release from the service instance manager
SIMInstance->releaseService( (*it).SId );
}
void doUnregisterService (TServiceId sid)
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
// found it, remove it
doRemove (it);
return;
}
}
nlwarning ("Service %hu not found", sid.get());
}
void doUnregisterService (TSockId from)
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end ();)
{
if ((*it).SockId == from)
{
// it's possible that one "from" have more than one registred service, so we have to find in all the list
// found it, remove it
it = doRemove (it);
}
else
{
it++;
}
}
}
/*void doUnregisterService (const CInetAddress &addr)
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).Addr == addr)
{
// found it, remove it
doRemove (it);
return;
}
}
nlwarning ("Service %s not found", addr.asString().c_str());
}*/
/*
* Helper function for cbRegister.
* If alloc_sid is true, sid is ignored
* Returns false in case of failure of sid allocation or bad sid provided
* Note: the reply is included in this function, because it must be done before things such as syncUniTime()
*/
bool doRegister (const string &name, const vector<CInetAddress> &addr, TServiceId sid, TSockId from, CCallbackNetBase &netbase, bool reconnection = false)
{
// Find if the service is not already registered
string reason;
uint8 ok = true;
bool needRegister = true;
/*for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).Addr.asIPString() == addr.asIPString() )
{
// we already have a service on this address, remplace it if it's the same name
if ((*it).Name == name)
{
// it's the same service, replace it
(*it).SockId = from;
sid = (*it).SId;
nlinfo ("Replace the service %s", name.c_str());
}
else
{
nlwarning ("Try to register %s to %s but the service %s already on this address. ignore it!", name.c_str(), addr.asIPString().c_str(), (*it).Name.c_str());
ok = false;
}
needRegister = false;
break;
}
}*/
if (needRegister)
{
if (sid.get() == 0)
{
// we have to find a sid
sid = BaseSId;
bool found = false;
while (!found)
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
break;
}
}
if (it == RegisteredServices.end ())
{
// ok, we have an empty sid
found = true;
}
else
{
sid.set(sid.get()+1);
if (sid.get() == 0) // round the clock
{
nlwarning ("Service identifier allocation overflow");
ok = false;
break;
}
}
}
}
else
{
// we have to check that the user provided sid is available
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
nlwarning ("Sid %d already used by another service", sid.get());
ok = false;
break;
}
}
if (it != RegisteredServices.end ())
{
ok = true;
}
}
// if ok, register the service and send a broadcast to other people
if (ok)
{
// Check if the instance is allowed to start, according to the restriction in the config file
if ( SIMInstance->queryStartService( name, sid, addr, reason ) )
{
// add him in the registered list
RegisteredServices.push_back (CServiceEntry(from, addr, name, sid));
// tell to everybody but not him that this service is registered
if (!reconnection)
{
CMessage msgout ("RGB");
TServiceId::size_type s = 1;
msgout.serial (s);
msgout.serial (const_cast<string &>(name));
msgout.serial (sid);
// we need to send all addr to all services even if the service can't access because we use the address index
// to know which connection comes.
msgout.serialCont (const_cast<vector<CInetAddress> &>(addr));
nlinfo ("The service is %s-%d, broadcast the Registration to everybody", name.c_str(), sid.get());
vector<CInetAddress> accessibleAddress;
for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
{
// send only services that can be accessed and not itself
if ((*it3).SId != sid && canAccess(addr, (*it3), accessibleAddress))
{
CallbackServer->send (msgout, (*it3).SockId);
//CNetManager::send ("NS", msgout, (*it3).SockId);
nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
}
}
}
// set the sid only if it s ok
from->setAppId (sid.get());
}
else
{
// Reply "startup denied", and do not send registration to other services
ok = false;
}
}
// send the message to the service to say if it s ok or not
if (!reconnection)
{
// send the answer to the client
CMessage msgout ("RG");
msgout.serial (ok);
if (ok)
{
msgout.serial (sid);
// send him all services available (also itself)
TServiceId::size_type nb = 0;
vector<CInetAddress> accessibleAddress;
for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
{
// send only services that are available
if (canAccess(addr, (*it2), accessibleAddress))
nb++;
}
msgout.serial (nb);
for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
// send only services that are available
if (canAccess(addr, (*it), accessibleAddress))
{
msgout.serial ((*it).Name);
msgout.serial ((*it).SId);
msgout.serialCont ((*it).Addr);
}
}
}
else
{
msgout.serial( reason );
}
netbase.send (msgout, from);
netbase.flush (from);
}
}
//displayRegisteredServices ();
return ok!=0;
}
void checkWaitingUnregistrationServices ()
{
for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end ();)
{
if ((*it).WaitingUnregistration && ((*it).WaitingUnregistrationServices.empty() || CTime::getLocalTime() > (*it).WaitingUnregistrationTime + UnregisterTimeout))
{
if ((*it).WaitingUnregistrationServices.empty())
{
nlinfo ("Removing the service %s-%hu because all services ACKd the removal", (*it).Name.c_str(), (*it).SId.get());
}
else
{
string res;
for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
{
res += toString(it2->get()) + " ";
}
nlwarning ("Removing the service %s-%hu because time out occurs (service numbers %s didn't ACK)", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
}
it = effectivelyRemove (it);
}
else
{
it++;
}
}
}
/**
* Callback for service unregistration ACK. Mean that a service was ACK the unregistration broadcast
*/
static void cbACKUnregistration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
TServiceId sid;
msgin.serial (sid);
for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid && (*it).WaitingUnregistration)
{
for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
{
if (*it2 == TServiceId(uint16(from->appId())))
{
// remove the acked service
(*it).WaitingUnregistrationServices.erase (it2);
checkWaitingUnregistrationServices ();
return;
}
}
}
}
}
/**
* Callback for service registration when the naming service goes down and up (don't need to broadcast)
*/
static void cbResendRegisteration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
string name;
vector<CInetAddress> addr;
TServiceId sid;
msgin.serial (name);
msgin.serialCont (addr);
msgin.serial (sid);
doRegister (name, addr, sid, from, netbase, true);
}
/**
* Callback for service registration.
*
* Message expected : RG
* - Name of service to register (string)
* - Address of service (CInetAddress)
*
* Message emitted : RG
* - Allocated service identifier (TServiceId) or 0 if failed
*/
static void cbRegister (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
string name;
vector<CInetAddress> addr;
TServiceId sid;
msgin.serial (name);
msgin.serialCont (addr);
msgin.serial (sid);
doRegister (name, addr, sid, from, netbase);
}
/**
* Callback for service unregistration.
*
* Message expected : UNI
* - Service identifier (TServiceId)
*/
static void cbUnregisterSId (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
TServiceId sid;
msgin.serial( sid );
doUnregisterService (sid);
//displayRegisteredServices ();
}
/*
* Helper function for cbQueryPort
*
* \warning QueryPort + Registration is not atomic so more than one service could ask a port before register
*/
uint16 doAllocatePort (const CInetAddress &addr)
{
static uint16 nextAvailablePort = MinBasePort;
// check if nextavailableport is free
if (nextAvailablePort >= MaxBasePort) nextAvailablePort = MinBasePort;
bool ok;
do
{
ok = true;
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).Addr[0].port () == nextAvailablePort)
{
nextAvailablePort++;
ok = false;
break;
}
}
}
while (!ok);
return nextAvailablePort++;
}
/**
* Callback for port allocation
* Note: if a service queries a port but does not register itself to the naming service, the
* port will remain allocated and unused.
*
* Message expected : QP
* - Name of service to register (string)
* - Address of service (CInetAddress) (its port can be 0)
*
* Message emitted : QP
* - Allocated port number (uint16)
*/
static void cbQueryPort (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
// Allocate port
uint16 port = doAllocatePort (netbase.hostAddress (from));
// Send port back
CMessage msgout ("QP");
msgout.serial (port);
netbase.send (msgout, from);
nlinfo ("The service got port %hu", port);
}
/*
* Unregisters a service if it has not been done before.
* Note: this callback is called whenever someone disconnects from the NS.
* May be there are too many calls if many clients perform many transactional lookups.
*/
static void cbDisconnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
{
doUnregisterService (from);
//displayRegisteredServices ();
}
/*
* a service is connected, send him all services infos
*/
static void cbConnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
{
// we have to wait the registred services message to send all services because it this points, we can't know which sub net
// the service can use
//displayRegisteredServices ();
// set the appid with a bad id (-1)
from->setAppId (~0);
}
/*// returns the list of accessible services with a list of address
static void cbRegisteredServices(CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
vector<CInetAddress> addr;
msgin.serialCont (addr);
nlinfo ("New service ask me the available services, sending him all services available");
// send to the new service the list of all services that this service can access (depending of his sub net)
CMessage msgout ("RGB");
uint8 nb = 0;
vector<CInetAddress> accessibleAddress;
for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
{
// send only services that are available
if (canAccess(addr, (*it2), accessibleAddress))
nb++;
}
msgout.serial (nb);
for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
// send only services that are available
if (canAccess(addr, (*it), accessibleAddress))
{
msgout.serial ((*it).Name);
msgout.serial ((*it).SId);
msgout.serialCont (accessibleAddress);
}
}
CNetManager::send ("NS", msgout, from);
}*/
/*
* Helper that emulates layer5 send()
*/
/*void sendToService( uint16 sid, CMessage& msgout )
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
CallbackServer->send (msgout, (*it).SockId);
}
}
}*/
/*
* Helper that emulate layer5's getServiceName()
*/
string getServiceName( TServiceId sid )
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
return (*it).Name;
}
}
return ""; // not found
}
/*
* Helper that returns the first address of a service
*/
CInetAddress getHostAddress( TServiceId sid )
{
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).SId == sid)
{
return (*it).Addr[0];
}
}
return CInetAddress();
}
//
// Callback array
//
TCallbackItem CallbackArray[] =
{
{ "RG", cbRegister },
{ "RRG", cbResendRegisteration },
{ "QP", cbQueryPort },
{ "UNI", cbUnregisterSId },
{ "ACK_UNI", cbACKUnregistration },
// { "RS", cbRegisteredServices },
};
//
// Service
//
class CNamingService : public NLNET::IService
{
public:
/**
* Init
*/
void init()
{
// if a baseport is available in the config file, get it
CConfigFile::CVar *var;
if ((var = ConfigFile.getVarPtr ("BasePort")) != NULL)
{
uint16 newBasePort = var->asInt ();
nlinfo ("Changing the MinBasePort number from %hu to %hu", MinBasePort, newBasePort);
sint32 delta = MaxBasePort - MinBasePort;
nlassert (delta > 0);
MinBasePort = newBasePort;
MaxBasePort = MinBasePort + uint16 (delta);
}
// Parameters for the service instance manager
try
{
CConfigFile::CVar& uniqueServices = ConfigFile.getVar("UniqueOnShardServices");
for ( uint i=0; i!=uniqueServices.size(); ++i )
{
_ServiceInstances.addUniqueService( uniqueServices.asString(i), true );
}
}
catch(Exception &)
{}
try
{
CConfigFile::CVar& uniqueServicesM = ConfigFile.getVar("UniqueByMachineServices");
for ( uint i=0; i!=uniqueServicesM.size(); ++i )
{
_ServiceInstances.addUniqueService( uniqueServicesM.asString(i), false );
}
}
catch(Exception &)
{}
/*
// we don't try to associate message from client
CNetManager::getNetBase ("NS")->ignoreAllUnknownId (true);
// add the callback in case of disconnection
CNetManager::setConnectionCallback ("NS", cbConnect, NULL);
// add the callback in case of disconnection
CNetManager::setDisconnectionCallback ("NS", cbDisconnect, NULL);
*/
// DEBUG
// DebugLog->addDisplayer( new CStdDisplayer() );
vector<CInetAddress> v = CInetAddress::localAddresses();
nlinfo ("%d detected local addresses:", v.size());
for (uint i = 0; i < v.size(); i++)
{
nlinfo (" %d - '%s'",i, v[i].asString().c_str());
}
uint16 nsport = 50000;
if ((var = ConfigFile.getVarPtr ("NSPort")) != NULL)
{
nsport = var->asInt ();
}
CallbackServer = new CCallbackServer;
CallbackServer->init(nsport);
CallbackServer->addCallbackArray(CallbackArray, sizeof(CallbackArray)/sizeof(CallbackArray[0]));
CallbackServer->setConnectionCallback(cbConnect, NULL);
CallbackServer->setDisconnectionCallback(cbDisconnect, NULL);
}
/**
* Update
*/
bool update ()
{
checkWaitingUnregistrationServices ();
CallbackServer->update ();
return true;
}
void release()
{
if (CallbackServer != NULL)
delete CallbackServer;
CallbackServer = NULL;
}
private:
/// Service instance manager singleton
CServiceInstanceManager _ServiceInstances;
};
static const char* getCompleteServiceName(const IService* theService)
{
static std::string s;
s= "naming_service";
if (theService->haveLongArg("nsname"))
{
s+= "_"+theService->getLongArg("nsname");
}
if (theService->haveLongArg("fullnsname"))
{
s= theService->getLongArg("fullnsname");
}
return s.c_str();
}
static const char* getShortServiceName(const IService* theService)
{
static std::string s;
s= "NS";
if (theService->haveLongArg("shortnsname"))
{
s= theService->getLongArg("shortnsname");
}
return s.c_str();
}
//
/// Naming Service
//
NLNET_SERVICE_MAIN( CNamingService, getShortServiceName(scn), getCompleteServiceName(scn), 0, EmptyCallbackArray, NELNS_CONFIG, NELNS_LOGS)
//
// Commands
//
NLMISC_COMMAND (nsServices, "displays the list of all registered services", "")
{
if(args.size() != 0) return false;
displayRegisteredServices (&log);
return true;
}
NLMISC_COMMAND (kill, "kill a service and send an unregister broadcast to other service", "<ServiceShortName>|<ServiceId>")
{
if(args.size() != 1) return false;
// try with number
TServiceId sid(atoi(args[0].c_str()));
if(sid.get() == 0)
{
// not a number, try a name
list<CServiceEntry>::iterator it;
for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
{
if ((*it).Name == args[0])
{
sid = (*it).SId;
break;
}
}
if (it == RegisteredServices.end())
{
log.displayNL ("Bad service name or id '%s'", args[0].c_str());
return false;
}
}
doUnregisterService (sid);
return true;
}
NLMISC_DYNVARIABLE(uint32, NbRegisteredServices, "display the number of service that are registered in naming service")
{
if (get) *pointer = (uint32)RegisteredServices.size();
}
NLMISC_COMMAND( displayServiceInstances, "SIM: Display info on service instances", "" )
{
SIMInstance->displayInfo( &log );
return true;
}
NLMISC_COMMAND( killAllServices, "SIM: Make all the controlled services quit", "" )
{
SIMInstance->killAllServices();
return true;
}