nel/src/net/module_local_gateway.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 #include "stdnet.h"
  18 #include "nel/net/module_gateway.h"
  19 #include "nel/net/module.h"
  20 #include "nel/net/module_manager.h"
  21 #include "nel/net/module_socket.h"
  22 #include "nel/net/module_message.h"
  23
  24 using namespace std;
  25 using namespace NLMISC;
  26
  27
  28
  29 namespace NLNET
  30 {
  31
  32
  33         /** A simple gateway that interconnect module locally
  34          *      For testing purpose and simple case.
  35          */
  36         class CLocalGateway :
  37                 public CModuleBase,
  38                 public CModuleGateway,
  39                 public CModuleSocket
  40         {
  41                 // the proxy that represent this gateway
  42 //              TModuleGatewayProxyPtr          _ThisProxy;
  43
  44                 typedef CTwinMap<TModuleProxyPtr, TStringId>    TModuleProxies;
  45                 // The modules proxies
  46                 TModuleProxies          _ModuleProxies;
  47
  48
  49         public:
  50
  51                 CLocalGateway()
  52                 {
  53
  54                 }
  55
  56                 ~CLocalGateway()
  57                 {
  58                         // we need to unplug any plugged module
  59                         while (!_PluggedModules.getAToBMap().empty())
  60                         {
  61                                 _PluggedModules.getAToBMap().begin()->second->unplugModule(this);
  62                         }
  63
  64                         // must be done before the other destructors are called
  65                         unregisterSocket();
  66                         unregisterGateway();
  67                 }
  68
  69                 /***********************************************************
  70                  ** Gateway methods
  71                  ***********************************************************/
  72                 virtual const std::string &getGatewayName() const
  73                 {
  74                         return getModuleName();
  75                 }
  76                 virtual const std::string &getFullyQualifiedGatewayName() const
  77                 {
  78                         return getModuleFullyQualifiedName();
  79                 }
  80                 /// Return the gateway proxy of this gateway
  81 //              virtual TModuleGatewayProxyPtr &getGatewayProxy()
  82 //              {
  83 //                      nlassert(!_ThisProxy.isNull());
  84 //                      return _ThisProxy;
  85 //              }
  86
  87                 /// Create and bind to this gateway a new transport
  88                 virtual void createTransport(const std::string &/* transportClass */, const std::string &/* instanceName */)
  89                 {
  90                 }
  91                 /// Delete a transport (this will close any open route)
  92                 virtual void deleteTransport(const std::string &/* instanceName */)
  93                 {
  94                 }
  95
  96                 /// Activate/stop peer invisible mode on a transport
  97                 virtual void    setTransportPeerInvisible(const std::string &/* transportInstanceName */, bool /* peerInvisible */)
  98                 {
  99                         // unsupported
 100                         nlstop;
 101                 }
 102
 103                 /// Activate/stop firewalling mode on a transport
 104                 virtual void    setTransportFirewallMode(const std::string &/* transportInstanceName */, bool /* firewalled */)
 105                 {
 106                         // unsupported
 107                         nlstop;
 108                 }
 109
 110                 /// Send a command to a transport
 111                 virtual void transportCommand(const TParsedCommandLine &/* commandLine */)
 112                 {
 113                 }
 114                 virtual IGatewayTransport *getGatewayTransport(const std::string &/* transportName */) const
 115                 {
 116                         // there are no transport here
 117                         return NULL;
 118                 }
 119
 120                 virtual uint32  getTransportCount() const
 121                 {
 122                         return 0;
 123                 }
 124
 125                 virtual uint32  getRouteCount() const
 126                 {
 127                         return 0;
 128                 }
 129
 130                 virtual uint32 getReceivedPingCount() const
 131                 {
 132                         return 0;
 133                 }
 134
 135                 virtual void onRouteAdded(CGatewayRoute * /* route */)
 136                 {
 137                 }
 138
 139                 /// A route is removed by a transport
 140                 virtual void onRouteRemoved(CGatewayRoute * /* route */)
 141                 {
 142                 }
 143
 144                 /// A transport have received a message
 145                 virtual void onReceiveMessage(CGatewayRoute * /* from */, const CMessage &/* msgin */)
 146                 {
 147                 }
 148
 149                 virtual void createSecurityPlugin(const std::string &/* className */)
 150                 {
 151                 }
 152                 virtual void sendSecurityCommand(const TParsedCommandLine &/* command */)
 153                 {
 154                 }
 155                 virtual void removeSecurityPlugin()
 156                 {
 157                 }
 158
 159
 160 //              virtual  bool isGatewayServerOpen()
 161 //              {
 162 //                      return false;
 163 //              }
 164 //
 165 //              virtual CInetAddress getGatewayServerAddress()
 166 //              {
 167 //                      CInetAddress invalid;
 168 //
 169 //                      return invalid;
 170 //              }
 171 //              virtual void getGatewayClientList(std::vector<TModuleGatewayProxyPtr> gatewayList)
 172 //              {
 173 //                      return;
 174 //              }
 175 //              virtual void openGatewayServer(uint16 listeningPort)
 176 //              {
 177 //                      nlstop;
 178 //              }
 179 //              virtual void closeGatewayServer()
 180 //              {
 181 //                      nlstop;
 182 //              }
 183 //              virtual void shutdownGatewayServer()
 184 //              {
 185 //                      nlstop;
 186 //              }
 187 //              virtual void onGatewayServerOpen()
 188 //              {
 189 //              }
 190 //              virtual void onGatewayServerClose()
 191 //              {
 192 //              }
 193 //              virtual TModuleGatewayConstant onClientGatewayConnect(TModuleGatewayProxyPtr &clientGateway)
 194 //              {
 195 //                      return mgc_reject_connection;
 196 //              }
 197 //              virtual void onClientGatewayDisconnect(TModuleGatewayProxyPtr &clientGateway)
 198 //              {
 199 //              }
 200 //              virtual void getGatewayServerList(std::vector<TModuleGatewayProxyPtr> serverList)
 201 //              {
 202 //                      return;
 203 //              }
 204 //              virtual bool isGatewayConnected()
 205 //              {
 206 //                      return false;
 207 //              }
 208 //              virtual void connectGateway(CInetAddress serverAddress)
 209 //              {
 210 //                      nlstop;
 211 //              }
 212 //              virtual void disconnectGateway(TModuleGatewayProxyPtr &serverGateway)
 213 //              {
 214 //                      nlstop;
 215 //              }
 216 //              virtual void onGatewayConnection(const TModuleGatewayProxyPtr &serverGateway, TModuleGatewayConstant connectionResult)
 217 //              {
 218 //                      nlstop;
 219 //              }
 220 //              virtual void onGatewayDisconnection(const TModuleGatewayProxyPtr &serverGateway)
 221 //              {
 222 //                      nlstop;
 223 //              }
 224                 virtual void onAddModuleProxy(IModuleProxy *addedModule)
 225                 {
 226                         // always disclose module to local modules
 227                         discloseModule(addedModule);
 228                 }
 229                 virtual void onRemoveModuleProxy(IModuleProxy * /* removedModule */)
 230                 {
 231                 }
 232                 virtual void discloseModule(IModuleProxy *moduleProxy)
 233                 {
 234                         // check that the module is plugged here
 235                         nlassert(_ModuleProxies.getB(moduleProxy) != NULL);
 236
 237 //                      CModuleProxy *modProx = dynamic_cast<CModuleProxy *>(moduleProxy);
 238 //                      nlassert(modProx != NULL);
 239                         nlassert(moduleProxy->getModuleGateway() == this);
 240
 241                         // warn any plugged module
 242                         TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
 243                         for (; first != last; ++first)
 244                         {
 245                                 IModule *module = first->second;
 246                                 if (module->getModuleId() != moduleProxy->getForeignModuleId())
 247                                 {
 248                                         module->_onModuleUp(moduleProxy);
 249                                 }
 250                         }
 251                 }
 252                 virtual IModuleProxy *getPluggedModuleProxy(IModule * /* pluggedModule */)
 253                 {
 254                         return NULL;
 255                 }
 256
 257                 virtual uint32  getProxyCount() const
 258                 {
 259                         return (uint32)_ModuleProxies.getAToBMap().size();
 260                 }
 261
 262                 /// Fill a vector with the list of proxies managed here. The module are filled in ascending proxy id order.
 263                 virtual void    getModuleProxyList(std::vector<IModuleProxy*> &resultList) const
 264                 {
 265                         map<TModuleId, IModuleProxy*> index;
 266                         {
 267                                 TModuleProxies::TAToBMap::const_iterator first(_ModuleProxies.getAToBMap().begin()), last(_ModuleProxies.getAToBMap().end());
 268                                 for (; first != last; ++first)
 269                                 {
 270                                         index.insert(make_pair(first->first->getModuleProxyId(), first->first));
 271                                 }
 272                         }
 273
 274                         // now build the vector
 275                         map<TModuleId, IModuleProxy*>::iterator first(index.begin()), last(index.end());
 276                         for( ; first != last; ++first)
 277                         {
 278                                 resultList.push_back(first->second);
 279                         }
 280                 }
 281
 282
 283 //              virtual void onReceiveModuleMessage(TModuleGatewayProxyPtr &senderGateway, TModuleMessagePtr &message)
 284 //              {
 285 //              }
 286                 virtual void sendModuleProxyMessage(IModuleProxy * /* senderProxy */, IModuleProxy * /* addresseeProxy */, const CMessage &/* message */)
 287                 {
 288                 }
 289                 virtual void dispatchModuleMessage(IModuleProxy * /* senderProxy */, IModuleProxy * /* addresseeProxy */, const CMessage &/* message */)
 290                 {
 291                         nlstop;
 292 //                      TModuleId sourceId = message->getSenderModuleProxyId();
 293 //                      TModuleProxies::TAToBMap::const_iterator firstSource(_ModuleProxies.getAToBMap().begin()), lastSource(_ModuleProxies.getAToBMap().end());
 294 //                      for (; firstSource != lastSource && firstSource->first->getForeignModuleId() != sourceId; ++firstSource) {}
 295 //                      nlassert(  firstSource != lastSource );
 296 //
 297 //                      TPluggedModules::iterator first(_PluggedModules.begin()), last(_PluggedModules.end());
 298 //                      TModuleId destId = message->getAddresseeModuleProxyId();
 299 //                      for (; first != last && (*first)->getModuleId() != destId; ++first) {}
 300 //                      if (first != last)
 301 //                      {
 302 //                              (*first)->onProcessModuleMessage(firstSource->first, message);
 303 //                      }
 304                 }
 305                 /***********************************************************
 306                  ** Module methods
 307                  ***********************************************************/
 308                 bool    initModule(const TParsedCommandLine &initInfo)
 309                 {
 310                         bool ret = CModuleBase::initModule(initInfo);
 311
 312                         // in fact, this gateway is so simple, that it have no option !
 313
 314                         registerSocket();
 315                         registerGateway();
 316
 317                         return ret;
 318                 }
 319
 320                 std::string                     buildModuleManifest() const
 321                 {
 322                         return string();
 323                 }
 324
 325                 void                            onServiceUp(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
 326                 {
 327                 }
 328                 void                            onServiceDown(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
 329                 {
 330                 }
 331                 void                            onModuleUpdate()
 332                 {
 333                 }
 334                 void                            onApplicationExit()
 335                 {
 336                 }
 337                 void                            onModuleUp(IModuleProxy * /* moduleProxy */)
 338                 {
 339                 }
 340                 void                            onModuleDown(IModuleProxy * /* moduleProxy */)
 341                 {
 342                 }
 343                 bool                            onProcessModuleMessage(IModuleProxy * /* senderModuleProxy */, const CMessage &/* message */)
 344                 {
 345                         return false;
 346                 }
 347                 void                            onModuleSecurityChange(IModuleProxy * /* moduleProxy */)
 348                 {
 349                 }
 350                 void                            onModuleSocketEvent(IModuleSocket * /* moduleSocket */, TModuleSocketEvent /* eventType */)
 351                 {
 352                 }
 353
 354                 /***********************************************************
 355                  ** Socket methods
 356                  ***********************************************************/
 357
 358                 const std::string &getSocketName()
 359                 {
 360                         return getModuleName();
 361                 }
 362
 363                 void _sendModuleMessage(IModule *senderModule, TModuleId destModuleProxyId, const NLNET::CMessage &message)
 364                 {
 365                         TModuleProxies::TAToBMap::const_iterator first(_ModuleProxies.getAToBMap().begin()), last(_ModuleProxies.getAToBMap().end());
 366                         for (; first != last && first->first->getModuleProxyId() != destModuleProxyId; ++first) {}
 367                         if (first != last) {  first->first->sendModuleMessage(senderModule, message); return;}
 368                         throw EModuleNotReachable();
 369                 }
 370                 virtual void _broadcastModuleMessage(IModule * /* senderModule */, const NLNET::CMessage &/* message */)
 371                 {
 372                         nlstop;
 373                 }
 374
 375                 void onModulePlugged(IModule *pluggedModule)
 376                 {
 377                         // A module has just been plugged here, we need to disclose it to the
 378                         // other module, and disclose other module to it.
 379
 380                         // create a proxy for this module
 381                         IModuleProxy *modProx = IModuleManager::getInstance().createModuleProxy(
 382                                         this,
 383                                         NULL,   // the module is local, so there is no route
 384                                         0,              // the module is local, distance is 0
 385                                         pluggedModule,  // the module is local, so store the module pointer
 386                                         pluggedModule->getModuleClassName(),
 387                                         getGatewayName()+"/"+pluggedModule->getModuleFullyQualifiedName(),
 388                                         pluggedModule->getModuleManifest(),
 389 //                                      _ThisProxy,
 390                                         pluggedModule->getModuleId());
 391
 392                         // and store it
 393                         _ModuleProxies.add(modProx, CStringMapper::map(modProx->getModuleName()));
 394
 395                         // disclose the new module to other modules
 396                         discloseModule(modProx);
 397
 398                         // second, disclose already plugged proxy to the new one
 399                         {
 400                                 TModuleProxies::TAToBMap::const_iterator first(_ModuleProxies.getAToBMap().begin()), last(_ModuleProxies.getAToBMap().end());
 401                                 for (; first != last; ++first)
 402                                 {
 403                                         if (first->first->getModuleName() != pluggedModule->getModuleFullyQualifiedName())
 404                                                 pluggedModule->_onModuleUp(first->first);
 405                                 }
 406                         }
 407
 408
 409                 }
 410                 /// Called just after a module as been effectively unplugged from a socket
 411                 void                            onModuleUnplugged(IModule *unpluggedModule)
 412                 {
 413                         // remove the proxy info
 414                         TModuleProxies::TBToAMap::const_iterator it(_ModuleProxies.getBToAMap().find(CStringMapper::map(getGatewayName()+"/"+unpluggedModule->getModuleFullyQualifiedName())));
 415                         nlassert(it != _ModuleProxies.getBToAMap().end());
 416
 417                         IModuleProxy *modProx = it->second;
 418                         // warn all connected module that a module become unavailable
 419                         {
 420                                 TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
 421                                 for (; first != last; ++first)
 422                                 {
 423                                         IModule *module = first->second;
 424                                         if (module->getModuleFullyQualifiedName() != modProx->getModuleName())
 425                                                 module->_onModuleDown(it->second);
 426                                 }
 427                         }
 428
 429                         // warn the unplugged module that all plugged modules are become unavailable
 430                         {
 431                                 TModuleProxies::TAToBMap::const_iterator first(_ModuleProxies.getAToBMap().begin()), last(_ModuleProxies.getAToBMap().end());
 432                                 for (; first != last; ++first)
 433                                 {
 434                                         if (first->first->getModuleName() != unpluggedModule->getModuleFullyQualifiedName())
 435                                                 unpluggedModule->_onModuleDown(first->first);
 436                                 }
 437                         }
 438
 439                         TModuleId localProxyId = modProx->getModuleProxyId();
 440                         // remove reference to the proxy
 441                         _ModuleProxies.removeWithA(modProx);
 442
 443                         // release the module proxy
 444                         IModuleManager::getInstance().releaseModuleProxy(localProxyId);
 445
 446                 }
 447
 448                 void getModuleList(std::vector<IModuleProxy*> &resultList)
 449                 {
 450                         TModuleProxies::TAToBMap::const_iterator first(_ModuleProxies.getAToBMap().begin()), last(_ModuleProxies.getAToBMap().end());
 451                         for (; first != last; ++first)
 452                         {
 453                                 resultList.push_back(first->first);
 454                         }
 455                 }
 456
 457         };
 458
 459
 460         // register the module factory
 461         NLNET_REGISTER_MODULE_FACTORY(CLocalGateway, "LocalGateway");
 462
 463         void forceLocalGatewayLink()
 464         {
 465         }
 466
 467 } // namespace NLNET
 468