nel/src/net/naming_client.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 //
  18 // Includes
  19 //
  20
  21 #include "stdnet.h"
  22
  23 #include "nel/net/naming_client.h"
  24 #include "nel/net/callback_client.h"
  25 #include "nel/net/service.h"
  26
  27
  28 //
  29 // Namespaces
  30 //
  31
  32 using namespace std;
  33 using namespace NLMISC;
  34
  35
  36 namespace NLNET {
  37
  38 //
  39 // Variables
  40 //
  41
  42 CCallbackClient *CNamingClient::_Connection = NULL;
  43 CNamingClient::TRegServices CNamingClient::_RegisteredServices;
  44
  45 static TBroadcastCallback _RegistrationBroadcastCallback = NULL;
  46 static TBroadcastCallback _UnregistrationBroadcastCallback = NULL;
  47
  48 TServiceId CNamingClient::_MySId(0);
  49
  50 std::list<CNamingClient::CServiceEntry> CNamingClient::RegisteredServices;
  51 NLMISC::CMutex CNamingClient::RegisteredServicesMutex("CNamingClient::RegisteredServicesMutex");
  52
  53 //
  54 //
  55 //
  56
  57 void CNamingClient::setRegistrationBroadcastCallback (TBroadcastCallback cb)
  58 {
  59         _RegistrationBroadcastCallback = cb;
  60 }
  61
  62 void CNamingClient::setUnregistrationBroadcastCallback (TBroadcastCallback cb)
  63 {
  64         _UnregistrationBroadcastCallback = cb;
  65 }
  66
  67 //
  68
  69 //
  70
  71 static bool Registered;
  72 static bool RegisteredSuccess;
  73 static TServiceId *RegisteredSID = NULL;
  74 static string Reason;
  75 void cbRegisterBroadcast (CMessage &msgin, TSockId from, CCallbackNetBase &netbase);
  76
  77 static void cbRegister (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
  78 {
  79         nlassert(RegisteredSID != NULL);
  80
  81         msgin.serial (RegisteredSuccess);
  82         if (RegisteredSuccess)
  83         {
  84                 msgin.serial (*RegisteredSID);
  85
  86                 // decode the registered services at the register process
  87                 cbRegisterBroadcast (msgin, from, netbase);
  88         }
  89         else
  90         {
  91                 msgin.serial( Reason );
  92         }
  93         Registered = true;
  94 }
  95
  96 //
  97
  98 static bool QueryPort;
  99 static uint16 QueryPortPort;
 100
 101 static void cbQueryPort (CMessage &msgin, TSockId /* from */, CCallbackNetBase &/* netbase */)
 102 {
 103         msgin.serial (QueryPortPort);
 104         QueryPort = true;
 105 }
 106
 107 //
 108
 109 //static bool FirstRegisteredBroadcast;
 110
 111 void cbRegisterBroadcast (CMessage &msgin, TSockId /* from */, CCallbackNetBase &/* netbase */)
 112 {
 113         TServiceId::size_type size;
 114         string name;
 115         TServiceId sid;
 116         vector<CInetAddress> addr;
 117
 118         msgin.serial (size);
 119
 120         for (TServiceId::size_type i = 0; i < size; i++)
 121         {
 122                 msgin.serial (name);
 123                 msgin.serial (sid);
 124                 msgin.serialCont (addr);
 125
 126                 // add it in the list
 127
 128                 std::vector<CInetAddress> addrs;
 129                 CNamingClient::find (sid, addrs);
 130
 131                 if (addrs.empty())
 132                 {
 133                         CNamingClient::RegisteredServicesMutex.enter ();
 134                         CNamingClient::RegisteredServices.push_back (CNamingClient::CServiceEntry (name, sid, addr));
 135                         CNamingClient::RegisteredServicesMutex.leave ();
 136
 137                         nlinfo ("NC: Registration Broadcast of the service %s-%hu '%s'", name.c_str(), sid.get(), vectorCInetAddressToString(addr).c_str());
 138
 139                         if (_RegistrationBroadcastCallback != NULL)
 140                                 _RegistrationBroadcastCallback (name, sid, addr);
 141                 }
 142                 else if (addrs.size() == 1)
 143                 {
 144                         CNamingClient::RegisteredServicesMutex.enter ();
 145                         for (std::list<CNamingClient::CServiceEntry>::iterator it = CNamingClient::RegisteredServices.begin(); it != CNamingClient::RegisteredServices.end (); it++)
 146                         {
 147                                 if (sid == (*it).SId)
 148                                 {
 149                                         (*it).Name = name;
 150                                         (*it).Addr = addr;
 151                                         break;
 152                                 }
 153                         }
 154                         CNamingClient::RegisteredServicesMutex.leave ();
 155                         nlinfo ("NC: Registration Broadcast (update) of the service %s-%hu '%s'", name.c_str(), sid.get(), addr[0].asString().c_str());
 156                 }
 157                 else
 158                 {
 159                         nlstop;
 160                 }
 161         }
 162
 163 //      FirstRegisteredBroadcast = true;
 164
 165         //CNamingClient::displayRegisteredServices ();
 166 }
 167
 168 //
 169
 170 void cbUnregisterBroadcast (CMessage &msgin, TSockId /* from */, CCallbackNetBase &/* netbase */)
 171 {
 172         string name;
 173         TServiceId sid;
 174         vector<CInetAddress> addrs;
 175
 176         msgin.serial (name);
 177         msgin.serial (sid);
 178
 179         // remove it in the list, if the service is not found, ignore it
 180
 181         CNamingClient::RegisteredServicesMutex.enter ();
 182         for (std::list<CNamingClient::CServiceEntry>::iterator it = CNamingClient::RegisteredServices.begin(); it != CNamingClient::RegisteredServices.end (); it++)
 183         {
 184                 CNamingClient::CServiceEntry &serviceEntry = *it;
 185                 if (serviceEntry.SId == sid)
 186                 {
 187                         // check the structure
 188                         nlassertex (serviceEntry.Name == name, ("%s %s",serviceEntry.Name.c_str(), name.c_str()));
 189
 190                         addrs = serviceEntry.Addr;
 191
 192                         CNamingClient::RegisteredServices.erase (it);
 193                         break;
 194                 }
 195         }
 196         CNamingClient::RegisteredServicesMutex.leave ();
 197
 198         nlinfo ("NC: Unregistration Broadcast of the service %s-%hu", name.c_str(), sid.get());
 199
 200         // send the ACK to the NS
 201
 202         CMessage msgout ("ACK_UNI");
 203         msgout.serial (sid);
 204         CNamingClient::_Connection->send (msgout);
 205
 206         // 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!
 207         if(CNamingClient::_MySId == sid)
 208         {
 209                 nlwarning ("NC: Naming Service asked me to leave, I leave!");
 210                 IService::getInstance()->exit();
 211                 return;
 212         }
 213
 214         if (_UnregistrationBroadcastCallback != NULL)
 215                 _UnregistrationBroadcastCallback (name, sid, addrs);
 216
 217         //CNamingClient::displayRegisteredServices ();
 218 }
 219
 220
 221 //
 222
 223 static TCallbackItem NamingClientCallbackArray[] =
 224 {
 225         { "RG", cbRegister },
 226         { "QP", cbQueryPort },
 227
 228         { "RGB", cbRegisterBroadcast },
 229         { "UNB", cbUnregisterBroadcast }
 230 };
 231
 232 void CNamingClient::connect( const CInetAddress &addr, CCallbackNetBase::TRecordingState rec, const vector<CInetAddress> &/* addresses */ )
 233 {
 234         nlassert (_Connection == NULL || (_Connection != NULL && !_Connection->connected ()));
 235
 236         if (_Connection == NULL)
 237         {
 238                 _Connection = new CCallbackClient( rec, "naming_client.nmr" );
 239                 _Connection->addCallbackArray (NamingClientCallbackArray, sizeof (NamingClientCallbackArray) / sizeof (NamingClientCallbackArray[0]));
 240         }
 241
 242         _Connection->connect (addr);
 243
 244 /*      // send the available addresses
 245         CMessage msgout ("RS");
 246         msgout.serialCont (const_cast<vector<CInetAddress>&>(addresses));
 247         _Connection->send (msgout);
 248
 249         // wait the message that contains all already connected services
 250         FirstRegisteredBroadcast = false;
 251         while (!FirstRegisteredBroadcast && _Connection->connected ())
 252         {
 253                 _Connection->update (-1);
 254                 nlSleep (1);
 255         }
 256 */}
 257
 258
 259 void CNamingClient::disconnect ()
 260 {
 261         if (_Connection != NULL)
 262         {
 263                 if (_Connection->connected ())
 264                 {
 265                         _Connection->disconnect ();
 266                 }
 267                 delete _Connection;
 268                 _Connection = NULL;
 269         }
 270
 271         // we don't call unregisterAllServices because when the naming service will see the disconnection,
 272         // it'll automatically unregister all services registered by this client.
 273 }
 274
 275 string CNamingClient::info ()
 276 {
 277         string res;
 278
 279         if (connected ())
 280         {
 281                 res = "connected to ";
 282                 res += _Connection->remoteAddress().asString();
 283         }
 284         else
 285         {
 286                 res = "Not connected";
 287         }
 288
 289         return res;
 290 }
 291
 292 bool CNamingClient::registerService (const std::string &name, const std::vector<CInetAddress> &addr, TServiceId &sid)
 293 {
 294         nlassert (_Connection != NULL && _Connection->connected ());
 295
 296         CMessage msgout ("RG");
 297         msgout.serial (const_cast<std::string&>(name));
 298         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
 299         sid.set(0);
 300         msgout.serial (sid);
 301         _Connection->send (msgout);
 302
 303         // wait the answer of the naming service "RG"
 304         Registered = false;
 305         RegisteredSID = &sid;
 306         while (!Registered)
 307         {
 308                 _Connection->update (-1);
 309                 nlSleep (1);
 310         }
 311         if (RegisteredSuccess)
 312         {
 313                 _MySId = sid;
 314                 _RegisteredServices.insert (make_pair (*RegisteredSID, name));
 315                 nldebug ("NC: Registered service %s-%hu at %s", name.c_str(), sid.get(), addr[0].asString().c_str());
 316         }
 317         else
 318         {
 319                 nldebug ("NC: Naming service refused to register service %s at %s", name.c_str(), addr[0].asString().c_str());
 320                 nlwarning ("NC: Startup denied: %s", Reason.c_str());
 321                 Reason.clear();
 322         }
 323
 324         RegisteredSID = NULL;
 325
 326         return RegisteredSuccess;
 327 }
 328
 329 bool CNamingClient::registerServiceWithSId (const std::string &name, const std::vector<CInetAddress> &addr, TServiceId sid)
 330 {
 331         nlassert (_Connection != NULL && _Connection->connected ());
 332
 333         CMessage msgout ("RG");
 334         msgout.serial (const_cast<std::string&>(name));
 335         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
 336         msgout.serial (sid);
 337         _Connection->send (msgout);
 338
 339         // wait the answer of the naming service "RGI"
 340         Registered = false;
 341         RegisteredSID = &sid;
 342         while (!Registered)
 343         {
 344                 _Connection->update (-1);
 345                 nlSleep (1);
 346         }
 347         if (RegisteredSuccess)
 348         {
 349                 _MySId = sid;
 350                 _RegisteredServices.insert (make_pair (*RegisteredSID, name));
 351                 nldebug ("NC: Registered service with sid %s-%hu at %s", name.c_str(), RegisteredSID->get(), addr[0].asString().c_str());
 352         }
 353         else
 354         {
 355                 nlerror ("NC: Naming service refused to register service with sid %s at %s", name.c_str(), addr[0].asString().c_str());
 356         }
 357
 358         return RegisteredSuccess == 1;
 359 }
 360
 361 void CNamingClient::resendRegisteration (const std::string &name, const std::vector<CInetAddress> &addr, TServiceId sid)
 362 {
 363         nlassert (_Connection != NULL && _Connection->connected ());
 364
 365         CMessage msgout ("RRG");
 366         msgout.serial (const_cast<std::string&>(name));
 367         msgout.serialCont (const_cast<vector<CInetAddress>&>(addr));
 368         msgout.serial (sid);
 369         _Connection->send (msgout);
 370 }
 371
 372 void CNamingClient::unregisterService (TServiceId sid)
 373 {
 374         nlassert (_Connection != NULL && _Connection->connected ());
 375
 376         CMessage msgout ("UNI");
 377         msgout.serial (sid);
 378         _Connection->send (msgout);
 379
 380         nldebug ("NC: Unregistering service %s-%hu", _RegisteredServices[sid].c_str(), sid.get());
 381         _RegisteredServices.erase (sid);
 382 }
 383
 384 void CNamingClient::unregisterAllServices ()
 385 {
 386         nlassert (_Connection != NULL && _Connection->connected ());
 387
 388         while (!_RegisteredServices.empty())
 389         {
 390                 TRegServices::iterator irs = _RegisteredServices.begin();
 391                 TServiceId sid = (*irs).first;
 392                 unregisterService (sid);
 393         }
 394 }
 395
 396 uint16 CNamingClient::queryServicePort ()
 397 {
 398         nlassert (_Connection != NULL && _Connection->connected ());
 399
 400         CMessage msgout ("QP");
 401         _Connection->send (msgout);
 402
 403         // wait the answer of the naming service "QP"
 404         QueryPort = false;
 405         while (!QueryPort)
 406         {
 407                 _Connection->update (-1);
 408                 nlSleep (1);
 409         }
 410
 411         nlinfo ("NC: Received the answer of the query port (%hu)", QueryPortPort);
 412
 413         return QueryPortPort;
 414 }
 415
 416 bool CNamingClient::lookup (const std::string &name, CInetAddress &addr)
 417 {
 418         nlassert (_Connection != NULL && _Connection->connected ());
 419
 420         vector<CInetAddress> addrs;
 421         find (name, addrs);
 422
 423         if (addrs.empty())
 424                 return false;
 425
 426         nlassert (addrs.size()==1);
 427         addr = addrs[0];
 428
 429         return true;
 430 }
 431
 432 bool CNamingClient::lookup (TServiceId sid, CInetAddress &addr)
 433 {
 434         nlassert (_Connection != NULL && _Connection->connected ());
 435
 436         vector<CInetAddress> addrs;
 437         find (sid, addrs);
 438
 439         if (addrs.empty())
 440                 return false;
 441
 442         nlassert (addrs.size()==1);
 443         addr = addrs[0];
 444
 445         return true;
 446 }
 447
 448 bool CNamingClient::lookupAlternate (const std::string &name, CInetAddress &addr)
 449 {
 450         nlassert (_Connection != NULL && _Connection->connected ());
 451
 452         // remove it from his local list
 453
 454         RegisteredServicesMutex.enter ();
 455         for (std::list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 456         {
 457                 if ((*it).Addr[0] == addr)
 458                 {
 459                         RegisteredServices.erase (it);
 460                         break;
 461                 }
 462         }
 463         RegisteredServicesMutex.leave ();
 464
 465         vector<CInetAddress> addrs;
 466         find (name, addrs);
 467
 468         if (addrs.empty())
 469                 return false;
 470
 471         nlassert (addrs.size()==1);
 472         addr = addrs[0];
 473
 474         return true;
 475 }
 476
 477 void CNamingClient::lookupAll (const std::string &name, std::vector<CInetAddress> &addrs)
 478 {
 479         nlassert (_Connection != NULL && _Connection->connected ());
 480
 481         find (name, addrs);
 482 }
 483
 484 bool CNamingClient::lookupAndConnect (const std::string &name, CCallbackClient &sock)
 485 {
 486         nlassert (_Connection != NULL && _Connection->connected ());
 487
 488         // look up for service
 489         CInetAddress servaddr;
 490
 491         // if service not found, return false
 492         if (!CNamingClient::lookup (name, servaddr))
 493                 return false;
 494
 495         for(;;)
 496         {
 497                 try
 498                 {
 499                         // try to connect to the server
 500                         sock.connect (servaddr);
 501
 502                         // connection succeeded
 503                         return true;
 504                 }
 505                 catch (const ESocketConnectionFailed &e)
 506                 {
 507                         nldebug( "NC: Connection to %s failed: %s, tring another service if available", servaddr.asString().c_str(), e.what() );
 508
 509                         // try another server and if service is not found, return false
 510                         if (!CNamingClient::lookupAlternate (name, servaddr))
 511                                 return false;
 512                 }
 513         }
 514 }
 515
 516
 517
 518 void CNamingClient::update ()
 519 {
 520         // get message for naming service (new registration for example)
 521         if (_Connection != NULL && _Connection->connected ())
 522                 _Connection->update ();
 523 }
 524
 525 //
 526 // Commands
 527 //
 528
 529 NLMISC_CATEGORISED_COMMAND(nel, services, "displays registered services", "")
 530 {
 531         nlunreferenced(rawCommandString);
 532         nlunreferenced(quiet);
 533         nlunreferenced(human);
 534
 535         if(args.size() != 0) return false;
 536
 537         CNamingClient::displayRegisteredServices (&log);
 538
 539         return true;
 540 }
 541
 542 } // NLNET