From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02980.html | 1896 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1896 insertions(+) create mode 100644 docs/doxygen/nel/a02980.html (limited to 'docs/doxygen/nel/a02980.html') diff --git a/docs/doxygen/nel/a02980.html b/docs/doxygen/nel/a02980.html new file mode 100644 index 00000000..9014bb43 --- /dev/null +++ b/docs/doxygen/nel/a02980.html @@ -0,0 +1,1896 @@ + + +NeL: NLNET::CNamingClient class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLNET::CNamingClient Class Reference

#include <naming_client.h> +

+

Detailed Description

+Client side of Naming Service. Allows to register/unregister services, and to lookup for a registered service.

+

Warning:
the Naming Service can be down, it will reconnect when up but if other services try to register during the NS is offline, it will cause bug
+
Author:
Olivier Cado

+Vianney Lecroart

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 58 of file naming_client.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Static Public Member Functions

void connect (const CInetAddress &addr, CCallbackNetBase::TRecordingState rec, const std::vector< CInetAddress > &addresses)
 Connect to the naming service.

bool connected ()
 Return true if the connection to the Naming Service was done.

void disconnect ()
 Close the connection to the naming service.

void displayRegisteredServices (NLMISC::CLog *log=NLMISC::DebugLog)
const std::list< CServiceEntry > & getRegisteredServices ()
std::string info ()
 Returns information about the naming connection (connected or not, which naming service and so on).

bool lookup (TServiceId sid, CInetAddress &addr)
 Same as lookup(const string&, CInetAddress&, uint16&).

bool lookup (const std::string &name, CInetAddress &addr)
void lookupAll (const std::string &name, std::vector< CInetAddress > &addresses)
bool lookupAlternate (const std::string &name, CInetAddress &addr)
bool lookupAndConnect (const std::string &name, CCallbackClient &sock)
uint16 queryServicePort ()
bool registerService (const std::string &name, const std::vector< CInetAddress > &addr, TServiceId &sid)
bool registerServiceWithSId (const std::string &name, const std::vector< CInetAddress > &addr, TServiceId sid)
void resendRegisteration (const std::string &name, const std::vector< CInetAddress > &addr, TServiceId sid)
void setRegistrationBroadcastCallback (TBroadcastCallback cb)
 You can link a callback if you want to know when a new service is registered (NULL to disable callback).

void setUnregistrationBroadcastCallback (TBroadcastCallback cb)
 You can link a callback if you want to know when a new service is unregistered (NULL to disable callback).

void unregisterAllServices ()
 Unregister all services registered by this client. You don't have to.

void unregisterService (TServiceId sid)
 Unregister a service from the naming service, service identifier.

void update ()
 Call it evenly.


Static Protected Member Functions

void checkThreadId ()

Static Protected Attributes

uint _ThreadId = 0xFFFFFFFF

Private Types

typedef std::map< TServiceId,
+ std::string > 		TRegServices
 Type of map of registered services.


Private Member Functions

 CNamingClient ()
 Constructor.

 ~CNamingClient ()
 Destructor.


Static Private Member Functions

void doReceiveLookupAnswer (const std::string &name, std::vector< CInetAddress > &addrs)
void find (TServiceId sid, std::vector< CInetAddress > &addrs)
void find (const std::string &name, std::vector< CInetAddress > &addrs)

Static Private Attributes

CCallbackClient * _Connection = NULL
TServiceId _MySId = 0
TRegServices _RegisteredServices
std::list< CServiceEntry > RegisteredServices
NLMISC::CMutex RegisteredServicesMutex

Friends

void cbRegisterBroadcast (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
void cbUnregisterBroadcast (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
+

Member Typedef Documentation

+

+ + + + +
+ + +
typedef std::map<TServiceId, std::string> NLNET::CNamingClient::TRegServices [private] +
+
+ + + + + +
+   + + +

+Type of map of registered services. +

+ +

+Definition at line 194 of file naming_client.h.

+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLNET::CNamingClient::CNamingClient (   )  [inline, private]
+
+ + + + + +
+   + + +

+Constructor. +

+ +

+Definition at line 200 of file naming_client.h. +

+

00200 {}
+
+

+ + + + +
+ + + + + + + + + +
NLNET::CNamingClient::~CNamingClient (   )  [inline, private]
+
+ + + + + +
+   + + +

+Destructor. +

+ +

+Definition at line 203 of file naming_client.h. +

+

00203 {}
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
void NLNET::CNamingClient::checkThreadId (   )  [static, protected]
+
+ + + + + +
+   + + +

+ +

+Definition at line 544 of file naming_client.cpp. +

+References nlerror. +

+Referenced by disconnect(), queryServicePort(), registerService(), registerServiceWithSId(), resendRegisteration(), unregisterAllServices(), unregisterService(), and update(). +

+

00545 {
+00546         if (getThreadId () != _ThreadId)
+00547         {
+00548                 nlerror ("You try to access to the CNamingClient with 2 differents thread (%d and %d)", _ThreadId, getThreadId());
+00549         }
+00550 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::connect ( const CInetAddress &  addr,
CCallbackNetBase::TRecordingState  rec,
const std::vector< CInetAddress > &  addresses
)  [static]
+
+ + + + + +
+   + + +

+Connect to the naming service. +

+ +

+Definition at line 239 of file naming_client.cpp. +

+References NLNET::CCallbackNetBase::addCallbackArray(), addr, NLNET::CCallbackClient::connect(), NLNET::CCallbackClient::connected(), NLNET::NamingClientCallbackArray, and nlassert. +

+

00240 {
+00241         nlassert (_Connection == NULL || _Connection != NULL && !_Connection->connected ());
+00242         _ThreadId = getThreadId ();
+00243 
+00244         if (_Connection == NULL)
+00245         {
+00246                 _Connection = new CCallbackClient( rec, "naming_client.nmr" );
+00247                 _Connection->addCallbackArray (NamingClientCallbackArray, sizeof (NamingClientCallbackArray) / sizeof (NamingClientCallbackArray[0]));
+00248         }
+00249 
+00250         _Connection->connect (addr);
+00251 
+00252 /*      // send the available addresses
+00253         CMessage msgout (_Connection->getSIDA(), "RS");
+00254         msgout.serialCont (const_cast<vector<CInetAddress>&>(addresses));
+00255         _Connection->send (msgout);
+00256         
+00257         // wait the message that contains all already connected services
+00258         FirstRegisteredBroadcast = false;
+00259         while (!FirstRegisteredBroadcast && _Connection->connected ())
+00260         {
+00261                 _Connection->update (-1);
+00262                 nlSleep (1);
+00263         }
+00264 */}
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CNamingClient::connected (   )  [inline, static]
+
+ + + + + +
+   + + +

+Return true if the connection to the Naming Service was done. +

+ +

+Definition at line 79 of file naming_client.h. +

+References NLNET::CCallbackClient::connected(). +

+Referenced by info(). +

+

00079 { return _Connection != NULL && _Connection->connected (); }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CNamingClient::disconnect (   )  [static]
+
+ + + + + +
+   + + +

+Close the connection to the naming service. +

+ +

+Definition at line 267 of file naming_client.cpp. +

+References checkThreadId(), NLNET::CCallbackClient::connected(), and NLNET::CCallbackClient::disconnect(). +

+

00268 {
+00269         checkThreadId ();
+00270         
+00271         if (_Connection != NULL)
+00272         {
+00273                 if (_Connection->connected ())
+00274                 {
+00275                         _Connection->disconnect ();
+00276                 }
+00277                 delete _Connection;
+00278                 _Connection = NULL;
+00279         }
+00280 
+00281         // we don't call unregisterAllServices because when the naming service will see the disconnection,
+00282         // it'll automatically unregister all services registered by this client.
+00283 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CNamingClient::displayRegisteredServices ( NLMISC::CLog *  log = NLMISC::DebugLog  )  [inline, static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 172 of file naming_client.h. +

+References RegisteredServices, RegisteredServicesMutex, uint, and uint16. +

+

00173         {
+00174                 RegisteredServicesMutex.enter ();
+00175                 log->displayNL ("Display the %d registered services :", RegisteredServices.size());
+00176                 for (std::list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
+00177                 {
+00178                         log->displayNL (" > %s-%hu %d addr", (*it).Name.c_str(), (uint16)(*it).SId, (*it).Addr.size());
+00179                         for(uint i = 0; i < (*it).Addr.size(); i++)
+00180                                 log->displayNL ("            '%s'", (*it).Addr[i].asString().c_str());
+00181                 }
+00182                 log->displayNL ("End of the list");
+00183                 RegisteredServicesMutex.leave ();
+00184         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::doReceiveLookupAnswer ( const std::string &  name,
std::vector< CInetAddress > &  addrs
)  [static, private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::find ( TServiceId  sid,
std::vector< CInetAddress > &  addrs
)  [inline, static, private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 220 of file naming_client.h. +

+References RegisteredServices, RegisteredServicesMutex, and NLNET::TServiceId. +

+

00221         {
+00222                 RegisteredServicesMutex.enter ();
+00223                 for (std::list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
+00224                         if (sid == (*it).SId)
+00225                                 addrs.push_back ((*it).Addr[0]);
+00226                 RegisteredServicesMutex.leave ();
+00227         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::find ( const std::string &  name,
std::vector< CInetAddress > &  addrs
)  [inline, static, private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 211 of file naming_client.h. +

+References RegisteredServices, and RegisteredServicesMutex. +

+Referenced by lookup(), lookupAll(), and lookupAlternate(). +

+

00212         {
+00213                 RegisteredServicesMutex.enter ();
+00214                 for (std::list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
+00215                         if (name == (*it).Name)
+00216                                 addrs.push_back ((*it).Addr[0]);
+00217                 RegisteredServicesMutex.leave ();
+00218         }
+
+

+ + + + +
+ + + + + + + + + +
const std::list<CServiceEntry>& NLNET::CNamingClient::getRegisteredServices (   )  [inline, static]
+
+ + + + + +
+   + + +

+Returns all registered services. +

+Definition at line 147 of file naming_client.h. +

+References RegisteredServices. +

+

00147 { return RegisteredServices; }
+
+

+ + + + +
+ + + + + + + + + +
string NLNET::CNamingClient::info (   )  [static]
+
+ + + + + +
+   + + +

+Returns information about the naming connection (connected or not, which naming service and so on). +

+ +

+Definition at line 285 of file naming_client.cpp. +

+References NLNET::CInetAddress::asString(), connected(), NLNET::CBufClient::remoteAddress(), and res. +

+

00286 {
+00287         string res;
+00288 
+00289         if (connected ())
+00290         {
+00291                 res = "connected to ";
+00292                 res += _Connection->remoteAddress().asString();
+00293         }
+00294         else
+00295         {
+00296                 res = "Not connected";
+00297         }
+00298 
+00299         return res;
+00300 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::lookup ( TServiceId  sid,
CInetAddress &  addr
)  [static]
+
+ + + + + +
+   + + +

+Same as lookup(const string&, CInetAddress&, uint16&). +

+ +

+Definition at line 448 of file naming_client.cpp. +

+References addr, NLNET::CCallbackClient::connected(), find(), nlassert, and NLNET::TServiceId. +

+

00449 {
+00450         nlassert (_Connection != NULL && _Connection->connected ());
+00451 
+00452         vector<CInetAddress> addrs;
+00453         find (sid, addrs);
+00454 
+00455         if (addrs.size()==0)
+00456                 return false;
+00457 
+00458         nlassert (addrs.size()==1);
+00459         addr = addrs[0];
+00460         
+00461         return true;
+00462 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::lookup ( const std::string &  name,
CInetAddress &  addr
)  [static]
+
+ + + + + +
+   + + +

+Returns true and the address of the specified service if it is found, otherwise returns false

Parameters:
+ + + + +
name [in] Short name of the service to find
addr [out] Address of the service
validitytime [out] After this number of seconds are elapsed, another lookup will be necessary before sending a message to the service
+
+
Returns:
true if all worked fine
+ +

+Definition at line 432 of file naming_client.cpp. +

+References addr, NLNET::CCallbackClient::connected(), find(), and nlassert. +

+

00433 {
+00434         nlassert (_Connection != NULL && _Connection->connected ());
+00435 
+00436         vector<CInetAddress> addrs;
+00437         find (name, addrs);
+00438 
+00439         if (addrs.size()==0)
+00440                 return false;
+00441 
+00442         nlassert (addrs.size()==1);
+00443         addr = addrs[0];
+00444 
+00445         return true;
+00446 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::lookupAll ( const std::string &  name,
std::vector< CInetAddress > &  addresses
)  [static]
+
+ + + + + +
+   + + +

+Returns all services corresponding to the specified short name. Ex: lookupAll ("AS", addresses); +

+Definition at line 494 of file naming_client.cpp. +

+References NLNET::CCallbackClient::connected(), find(), and nlassert. +

+

00495 {
+00496         nlassert (_Connection != NULL && _Connection->connected ());
+00497 
+00498         find (name, addrs);
+00499 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::lookupAlternate ( const std::string &  name,
CInetAddress &  addr
)  [static]
+
+ + + + + +
+   + + +

+Tells the Naming Service the specified address does not respond for the specified service, and returns true and another address for the service if available, otherwise returns false

Parameters:
+ + + + +
name [in] Short name of the service to find
addr [in/out] In: Address of the service that does not respond. Out: Alternative address
validitytime [out] After this number of seconds are elapsed, another lookup will be necessary before sending a message to the service
+
+
Returns:
true if all worked fine.
+ +

+Definition at line 465 of file naming_client.cpp. +

+References addr, NLNET::CCallbackClient::connected(), find(), nlassert, RegisteredServices, and RegisteredServicesMutex. +

+

00466 {
+00467         nlassert (_Connection != NULL && _Connection->connected ());
+00468 
+00469         // remove it from his local list
+00470         
+00471         RegisteredServicesMutex.enter ();
+00472         for (std::list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
+00473         {
+00474                 if ((*it).Addr[0] == addr)
+00475                 {
+00476                         RegisteredServices.erase (it);
+00477                         break;
+00478                 }
+00479         }
+00480         RegisteredServicesMutex.leave ();
+00481 
+00482         vector<CInetAddress> addrs;
+00483         find (name, addrs);
+00484 
+00485         if (addrs.size()==0)
+00486                 return false;
+00487 
+00488         nlassert (addrs.size()==1);
+00489         addr = addrs[0];
+00490 
+00491         return true;
+00492 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::lookupAndConnect ( const std::string &  name,
CCallbackClient &  sock
)  [static]
+
+ + + + + +
+   + + +

+Obtains a socket connected to a service providing the service name. In case of failure to connect, the method informs the Naming Service and tries to get another service.

Parameters:
+ + + + +
name [in] Short name of the service to find and connected
sock [out] The connected socket.
validitytime [out] After this number of seconds are elapsed, another lookup will be necessary before sending a message to the service.
+
+
Returns:
false if the service was not found.
+ +

+Definition at line 501 of file naming_client.cpp. +

+References NLNET::CInetAddress::asString(), NLNET::CCallbackClient::connect(), NLNET::CCallbackClient::connected(), nlassert, and nldebug. +

+

00502 {
+00503         nlassert (_Connection != NULL && _Connection->connected ());
+00504 
+00505         // look up for service
+00506         CInetAddress servaddr;
+00507         
+00508         // if service not found, return false
+00509         if (!CNamingClient::lookup (name, servaddr))
+00510                 return false;
+00511 
+00512         do
+00513         {
+00514                 try
+00515                 {
+00516                         // try to connect to the server
+00517                         sock.connect (servaddr);
+00518 
+00519                         // connection succeeded
+00520                         return true;
+00521                 }
+00522                 catch (ESocketConnectionFailed &e)
+00523                 {
+00524                         nldebug( "NC: Connection to %s failed: %s, tring another service if available", servaddr.asString().c_str(), e.what() );
+00525 
+00526                         // try another server and if service is not found, return false
+00527                         if (!CNamingClient::lookupAlternate (name, servaddr))
+00528                                 return false;
+00529                 }
+00530         }
+00531         while (true);
+00532 }
+
+

+ + + + +
+ + + + + + + + + +
uint16 NLNET::CNamingClient::queryServicePort (   )  [static]
+
+ + + + + +
+   + + +

+Requests the naming service to choose a port for the service

Returns:
An empty port number
+ +

+Definition at line 411 of file naming_client.cpp. +

+References checkThreadId(), NLNET::CCallbackClient::connected(), NLNET::CCallbackNetBase::getSIDA(), nlassert, nlinfo, NLMISC::nlSleep(), NLNET::QueryPort, NLNET::QueryPortPort, NLNET::CCallbackClient::send(), uint16, and NLNET::CCallbackClient::update(). +

+

00412 {
+00413         checkThreadId ();
+00414         nlassert (_Connection != NULL && _Connection->connected ());
+00415 
+00416         CMessage msgout (_Connection->getSIDA(), "QP");
+00417         _Connection->send (msgout);
+00418 
+00419         // wait the answer of the naming service "QP"
+00420         QueryPort = false;
+00421         while (!QueryPort)
+00422         {
+00423                 _Connection->update (-1);
+00424                 nlSleep (1);
+00425         }
+00426 
+00427         nlinfo ("NC: Received the answer of the query port (%hu)", QueryPortPort);
+00428 
+00429         return QueryPortPort;
+00430 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::registerService ( const std::string &  name,
const std::vector< CInetAddress > &  addr,
TServiceId &  sid
)  [static]
+
+ + + + + +
+   + + +

+Register a service within the naming service. Returns false if the registration failed. +

+Definition at line 302 of file naming_client.cpp. +

+References _MySId, _RegisteredServices, addr, checkThreadId(), NLNET::CCallbackClient::connected(), NLNET::CCallbackNetBase::getSIDA(), nlassert, nldebug, NLMISC::nlSleep(), nlwarning, NLNET::Reason, NLNET::Registered, NLNET::RegisteredSID, NLNET::RegisteredSuccess, NLNET::CCallbackClient::send(), NLMISC::CMemStream::serial(), NLMISC::CMemStream::serialCont(), NLNET::TServiceId, uint16, and NLNET::CCallbackClient::update(). +

+

00303 {
+00304         checkThreadId ();
+00305         nlassert (_Connection != NULL && _Connection->connected ());
+00306 
+00307         CMessage msgout (_Connection->getSIDA(), "RG");
+00308         msgout.serial (const_cast<std::string&>(name));
+00309         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
+00310         sid = 0;
+00311         msgout.serial (sid);
+00312         _Connection->send (msgout);
+00313 
+00314         // wait the answer of the naming service "RG"
+00315         Registered = false;
+00316         RegisteredSID = &sid;
+00317         while (!Registered)
+00318         {
+00319                 _Connection->update (-1);
+00320                 nlSleep (1);
+00321         }
+00322         if (RegisteredSuccess)
+00323         {
+00324                 _MySId = sid;
+00325                 _RegisteredServices.insert (make_pair (*RegisteredSID, name));
+00326                 nldebug ("NC: Registered service %s-%hu at %s", name.c_str(), (uint16)sid, addr[0].asString().c_str());
+00327         }
+00328         else
+00329         {
+00330                 nldebug ("NC: Naming service refused to register service %s at %s", name.c_str(), addr[0].asString().c_str());
+00331                 nlwarning ("NC: Startup denied: %s", Reason.c_str());
+00332                 Reason.clear();
+00333         }
+00334 
+00335         RegisteredSID = NULL;
+00336 
+00337         return RegisteredSuccess;
+00338 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLNET::CNamingClient::registerServiceWithSId ( const std::string &  name,
const std::vector< CInetAddress > &  addr,
TServiceId  sid
)  [static]
+
+ + + + + +
+   + + +

+Register a service within the naming service, using a specified service identifier. Returns false if the service identifier is unavailable i.e. the registration failed. +

+Definition at line 340 of file naming_client.cpp. +

+References _MySId, _RegisteredServices, addr, checkThreadId(), NLNET::CCallbackClient::connected(), NLNET::CCallbackNetBase::getSIDA(), nlassert, nldebug, nlerror, NLMISC::nlSleep(), NLNET::Registered, NLNET::RegisteredSID, NLNET::RegisteredSuccess, NLNET::CCallbackClient::send(), NLMISC::CMemStream::serial(), NLMISC::CMemStream::serialCont(), NLNET::TServiceId, uint16, and NLNET::CCallbackClient::update(). +

+

00341 {
+00342         checkThreadId ();
+00343         nlassert (_Connection != NULL && _Connection->connected ());
+00344 
+00345         CMessage msgout (_Connection->getSIDA(), "RG");
+00346         msgout.serial (const_cast<std::string&>(name));
+00347         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
+00348         msgout.serial (sid);
+00349         _Connection->send (msgout);
+00350 
+00351         // wait the answer of the naming service "RGI"
+00352         Registered = false;
+00353         RegisteredSID = &sid;
+00354         while (!Registered)
+00355         {
+00356                 _Connection->update (-1);
+00357                 nlSleep (1);
+00358         }
+00359         if (RegisteredSuccess)
+00360         {
+00361                 _MySId = sid;
+00362                 _RegisteredServices.insert (make_pair (*RegisteredSID, name));
+00363                 nldebug ("NC: Registered service with sid %s-%hu at %s", name.c_str(), (uint16)*RegisteredSID, addr[0].asString().c_str());
+00364         }
+00365         else
+00366         {
+00367                 nlerror ("NC: Naming service refused to register service with sid %s at %s", name.c_str(), addr[0].asString().c_str());
+00368         }
+00369 
+00370         return RegisteredSuccess == 1;
+00371 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLNET::CNamingClient::resendRegisteration ( const std::string &  name,
const std::vector< CInetAddress > &  addr,
TServiceId  sid
)  [static]
+
+ + + + + +
+   + + +

+If the NS is down and goes up, we have to send it again the registration. But in this case, the NS must not send a registration broadcast, so we have a special message +

+Definition at line 373 of file naming_client.cpp. +

+References addr, checkThreadId(), NLNET::CCallbackClient::connected(), NLNET::CCallbackNetBase::getSIDA(), nlassert, NLNET::CCallbackClient::send(), NLMISC::CMemStream::serial(), NLMISC::CMemStream::serialCont(), and NLNET::TServiceId. +

+

00374 {
+00375         checkThreadId ();
+00376         nlassert (_Connection != NULL && _Connection->connected ());
+00377 
+00378         CMessage msgout (_Connection->getSIDA(), "RRG");
+00379         msgout.serial (const_cast<std::string&>(name));
+00380         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
+00381         msgout.serial (sid);
+00382         _Connection->send (msgout);
+00383 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CNamingClient::setRegistrationBroadcastCallback ( TBroadcastCallback  cb  )  [static]
+
+ + + + + +
+   + + +

+You can link a callback if you want to know when a new service is registered (NULL to disable callback). +

+ +

+Definition at line 66 of file naming_client.cpp. +

+References NLNET::_RegistrationBroadcastCallback, and NLNET::TBroadcastCallback. +

+

00067 {
+00068         _RegistrationBroadcastCallback = cb;    
+00069 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CNamingClient::setUnregistrationBroadcastCallback ( TBroadcastCallback  cb  )  [static]
+
+ + + + + +
+   + + +

+You can link a callback if you want to know when a new service is unregistered (NULL to disable callback). +

+ +

+Definition at line 71 of file naming_client.cpp. +

+References NLNET::_UnregistrationBroadcastCallback, and NLNET::TBroadcastCallback. +

+

00072 {
+00073         _UnregistrationBroadcastCallback = cb;  
+00074 }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CNamingClient::unregisterAllServices (   )  [static]
+
+ + + + + +
+   + + +

+Unregister all services registered by this client. You don't have to. +

+ +

+Definition at line 398 of file naming_client.cpp. +

+References _RegisteredServices, checkThreadId(), NLNET::CCallbackClient::connected(), nlassert, NLNET::TServiceId, and unregisterService(). +

+

00399 {
+00400         checkThreadId ();
+00401         nlassert (_Connection != NULL && _Connection->connected ());
+00402 
+00403         while (!_RegisteredServices.empty())
+00404         {
+00405                 TRegServices::iterator irs = _RegisteredServices.begin();
+00406                 TServiceId sid = (*irs).first;
+00407                 unregisterService (sid);
+00408         }
+00409 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CNamingClient::unregisterService ( TServiceId  sid  )  [static]
+
+ + + + + +
+   + + +

+Unregister a service from the naming service, service identifier. +

+ +

+Definition at line 385 of file naming_client.cpp. +

+References _RegisteredServices, checkThreadId(), NLNET::CCallbackClient::connected(), NLNET::CCallbackNetBase::getSIDA(), nlassert, nldebug, NLNET::CCallbackClient::send(), NLMISC::CMemStream::serial(), and NLNET::TServiceId. +

+Referenced by unregisterAllServices(). +

+

00386 {
+00387         checkThreadId ();
+00388         nlassert (_Connection != NULL && _Connection->connected ());
+00389 
+00390         CMessage msgout (_Connection->getSIDA(), "UNI");
+00391         msgout.serial (sid);
+00392         _Connection->send (msgout);
+00393 
+00394         nldebug ("NC: Unregistering service %s-%hu", _RegisteredServices[sid].c_str(), sid);
+00395         _RegisteredServices.erase (sid);
+00396 }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CNamingClient::update (   )  [static]
+
+ + + + + +
+   + + +

+Call it evenly. +

+ +

+Definition at line 536 of file naming_client.cpp. +

+References checkThreadId(), NLNET::CCallbackClient::connected(), and NLNET::CCallbackClient::update(). +

+

00537 {
+00538         checkThreadId ();
+00539         // get message for naming service (new registration for example)
+00540         if (_Connection != NULL && _Connection->connected ())
+00541                 _Connection->update ();
+00542 }
+
+

Friends And Related Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void cbRegisterBroadcast ( CMessage &  msgin,
TSockId  from,
CCallbackNetBase &  netbase
)  [friend]
+
+ + + + + +
+   + + +

+ +

+Definition at line 119 of file naming_client.cpp. +

+

00120 {
+00121         TServiceId size;
+00122         string name;
+00123         TServiceId sid;
+00124         vector<CInetAddress> addr;
+00125 
+00126         msgin.serial (size);
+00127 
+00128         for (TServiceId i = 0; i < size; i++)
+00129         {
+00130                 msgin.serial (name);
+00131                 msgin.serial (sid);
+00132                 msgin.serialCont (addr);
+00133 
+00134                 // add it in the list
+00135 
+00136                 std::vector<CInetAddress> addrs;
+00137                 CNamingClient::find (sid, addrs);
+00138 
+00139                 if (addrs.size() == 0)
+00140                 {
+00141                         CNamingClient::RegisteredServicesMutex.enter ();
+00142                         CNamingClient::RegisteredServices.push_back (CNamingClient::CServiceEntry (name, sid, addr));
+00143                         CNamingClient::RegisteredServicesMutex.leave ();
+00144 
+00145                         nlinfo ("NC: Registration Broadcast of the service %s-%hu '%s'", name.c_str(), (uint16)sid, vectorCInetAddressToString(addr).c_str());
+00146 
+00147                         if (_RegistrationBroadcastCallback != NULL)
+00148                                 _RegistrationBroadcastCallback (name, sid, addr);
+00149                 }
+00150                 else if (addrs.size() == 1)
+00151                 {
+00152                         CNamingClient::RegisteredServicesMutex.enter ();
+00153                         for (std::list<CNamingClient::CServiceEntry>::iterator it = CNamingClient::RegisteredServices.begin(); it != CNamingClient::RegisteredServices.end (); it++)
+00154                         {
+00155                                 if (sid == (*it).SId)
+00156                                 {
+00157                                         (*it).Name = name;
+00158                                         (*it).Addr = addr;
+00159                                         break;
+00160                                 }
+00161                         }
+00162                         CNamingClient::RegisteredServicesMutex.leave ();
+00163                         nlinfo ("NC: Registration Broadcast (update) of the service %s-%hu '%s'", name.c_str(), (uint16)sid, addr[0].asString().c_str());
+00164                 }
+00165                 else
+00166                 {
+00167                         nlstop;
+00168                 }
+00169         }
+00170 
+00171 //      FirstRegisteredBroadcast = true;
+00172 
+00173         //CNamingClient::displayRegisteredServices ();
+00174 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void cbUnregisterBroadcast ( CMessage &  msgin,
TSockId  from,
CCallbackNetBase &  netbase
)  [friend]
+
+ + + + + +
+   + + +

+ +

+Definition at line 178 of file naming_client.cpp. +

+

00179 {
+00180         string name;
+00181         TServiceId sid;
+00182         vector<CInetAddress> addrs;
+00183 
+00184         msgin.serial (name);
+00185         msgin.serial (sid);
+00186 
+00187         // remove it in the list, if the service is not found, ignore it
+00188 
+00189         CNamingClient::RegisteredServicesMutex.enter ();
+00190         for (std::list<CNamingClient::CServiceEntry>::iterator it = CNamingClient::RegisteredServices.begin(); it != CNamingClient::RegisteredServices.end (); it++)
+00191         {
+00192                 if ((*it).SId == sid)
+00193                 {
+00194                         // check the structure
+00195                         nlassertex ((*it).Name == name, ("%s %s",(*it).Name.c_str(), name.c_str()));
+00196 
+00197                         addrs = (*it).Addr;
+00198 
+00199                         CNamingClient::RegisteredServices.erase (it);
+00200                         break;
+00201                 }
+00202         }
+00203         CNamingClient::RegisteredServicesMutex.leave ();
+00204 
+00205         nlinfo ("NC: Unregistration Broadcast of the service %s-%hu", name.c_str(), (uint16)sid);
+00206 
+00207         // send the ACK to the NS
+00208 
+00209         CMessage msgout (CNamingClient::_Connection->getSIDA(), "ACK_UNI");
+00210         msgout.serial (sid);
+00211         CNamingClient::_Connection->send (msgout);
+00212 
+00213         // oh my god, it s my sid! but i m alive, why this f*cking naming service want to kill me? ok, i leave it alone!
+00214         if(CNamingClient::_MySId == sid)
+00215         {
+00216                 nlwarning ("NC: Naming Service asked me to leave, I leave!");
+00217                 IService::getInstance()->exit();
+00218                 return;
+00219         }
+00220 
+00221         if (_UnregistrationBroadcastCallback != NULL)
+00222                 _UnregistrationBroadcastCallback (name, sid, addrs);
+00223 
+00224         //CNamingClient::displayRegisteredServices ();
+00225 }
+
+

Field Documentation

+

+ + + + +
+ + +
CCallbackClient * NLNET::CNamingClient::_Connection = NULL [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 52 of file naming_client.cpp.

+

+ + + + +
+ + +
TServiceId NLNET::CNamingClient::_MySId = 0 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 60 of file naming_client.cpp. +

+Referenced by registerService(), and registerServiceWithSId().

+

+ + + + +
+ + +
CNamingClient::TRegServices NLNET::CNamingClient::_RegisteredServices [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 53 of file naming_client.cpp. +

+Referenced by registerService(), registerServiceWithSId(), unregisterAllServices(), and unregisterService().

+

+ + + + +
+ + +
uint NLNET::CNamingClient::_ThreadId = 0xFFFFFFFF [static, protected] +
+
+ + + + + +
+   + + +

+

Todo:
ace: debug feature that we should remove one day before releasing the game
+ +

+Definition at line 58 of file naming_client.cpp.

+

+ + + + +
+ + +
std::list< CNamingClient::CServiceEntry > NLNET::CNamingClient::RegisteredServices [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 63 of file naming_client.cpp. +

+Referenced by displayRegisteredServices(), find(), getRegisteredServices(), and lookupAlternate().

+

+ + + + +
+ + +
NLMISC::CMutex NLNET::CNamingClient::RegisteredServicesMutex [static, private] +
+
+ + + + + +
+   + + +

+ +

+Referenced by displayRegisteredServices(), find(), and lookupAlternate().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 14:00:38 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1