ryzom/server/src/patchman_service/spm_module_itf.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   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 // WARNING : this is a generated file, don't change it !
  19 /////////////////////////////////////////////////////////////////
  20
  21 #include "spm_module_itf.h"
  22
  23 namespace PATCHMAN
  24 {
  25
  26         /////////////////////////////////////////////////////////////////
  27         // WARNING : this is a generated file, don't change it !
  28         /////////////////////////////////////////////////////////////////
  29
  30
  31         const CServerPatchManagerSkel::TMessageHandlerMap &CServerPatchManagerSkel::getMessageHandlers() const
  32         {
  33                 static TMessageHandlerMap handlers;
  34                 static bool init = false;
  35
  36                 if (!init)
  37                 {
  38                         std::pair < TMessageHandlerMap::iterator, bool > res;
  39
  40                         res = handlers.insert(std::make_pair(std::string("SPM_REFRESH"), &CServerPatchManagerSkel::requestRefresh_skel));
  41                         // if this assert, you have a doubly message name in your interface definition !
  42                         nlassert(res.second);
  43
  44                         res = handlers.insert(std::make_pair(std::string("SPM_SETNEXT"), &CServerPatchManagerSkel::setInstallVersion_skel));
  45                         // if this assert, you have a doubly message name in your interface definition !
  46                         nlassert(res.second);
  47
  48                         res = handlers.insert(std::make_pair(std::string("SPM_SETLIVE"), &CServerPatchManagerSkel::setLaunchVersion_skel));
  49                         // if this assert, you have a doubly message name in your interface definition !
  50                         nlassert(res.second);
  51
  52                         res = handlers.insert(std::make_pair(std::string("SPM_STATE"), &CServerPatchManagerSkel::declareState_skel));
  53                         // if this assert, you have a doubly message name in your interface definition !
  54                         nlassert(res.second);
  55
  56                         res = handlers.insert(std::make_pair(std::string("SPM_VERSION_NAME"), &CServerPatchManagerSkel::declareVersionName_skel));
  57                         // if this assert, you have a doubly message name in your interface definition !
  58                         nlassert(res.second);
  59
  60                         res = handlers.insert(std::make_pair(std::string("SPM_SPA_EXEC"), &CServerPatchManagerSkel::executeCommandOnSPA_skel));
  61                         // if this assert, you have a doubly message name in your interface definition !
  62                         nlassert(res.second);
  63
  64                         res = handlers.insert(std::make_pair(std::string("SPM_SPA_EXEC_RESULT"), &CServerPatchManagerSkel::spaExecutedCommandResult_skel));
  65                         // if this assert, you have a doubly message name in your interface definition !
  66                         nlassert(res.second);
  67
  68                         init = true;
  69                 }
  70
  71                 return handlers;
  72         }
  73         bool CServerPatchManagerSkel::onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  74         {
  75                 const TMessageHandlerMap &mh = getMessageHandlers();
  76
  77                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  78
  79                 if (it == mh.end())
  80                 {
  81                         return false;
  82                 }
  83
  84                 TMessageHandler cmd = it->second;
  85                 (this->*cmd)(sender, message);
  86
  87                 return true;
  88         }
  89
  90
  91         void CServerPatchManagerSkel::requestRefresh_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  92         {
  93                 requestRefresh(sender);
  94         }
  95
  96         void CServerPatchManagerSkel::setInstallVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  97         {
  98                 NLMISC::CSString        domain;
  99                         nlRead(__message, serial, domain);
 100                 uint32  version;
 101                         nlRead(__message, serial, version);
 102                 setInstallVersion(sender, domain, version);
 103         }
 104
 105         void CServerPatchManagerSkel::setLaunchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 106         {
 107                 NLMISC::CSString        domain;
 108                         nlRead(__message, serial, domain);
 109                 uint32  version;
 110                         nlRead(__message, serial, version);
 111                 setLaunchVersion(sender, domain, version);
 112         }
 113
 114         void CServerPatchManagerSkel::declareState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 115         {
 116                 NLMISC::CSString        state;
 117                         nlRead(__message, serial, state);
 118                 declareState(sender, state);
 119         }
 120
 121         void CServerPatchManagerSkel::declareVersionName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 122         {
 123                 NLMISC::CSString        versionName;
 124                         nlRead(__message, serial, versionName);
 125                 uint32  clientVersion;
 126                         nlRead(__message, serial, clientVersion);
 127                 uint32  serverVersion;
 128                         nlRead(__message, serial, serverVersion);
 129                 declareVersionName(sender, versionName, clientVersion, serverVersion);
 130         }
 131
 132         void CServerPatchManagerSkel::executeCommandOnSPA_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 133         {
 134                 NLMISC::CSString        target;
 135                         nlRead(__message, serial, target);
 136                 NLMISC::CSString        commandline;
 137                         nlRead(__message, serial, commandline);
 138                 executeCommandOnSPA(sender, target, commandline);
 139         }
 140
 141         void CServerPatchManagerSkel::spaExecutedCommandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 142         {
 143                 NLMISC::CSString        originator;
 144                         nlRead(__message, serial, originator);
 145                 NLMISC::CSString        commandline;
 146                         nlRead(__message, serial, commandline);
 147                 NLMISC::CSString        result;
 148                         nlRead(__message, serial, result);
 149                 spaExecutedCommandResult(sender, originator, commandline, result);
 150         }
 151                 //
 152                 // Message sent by SPT module to request a refresh of state info etc
 153         void CServerPatchManagerProxy::requestRefresh(NLNET::IModule *sender)
 154         {
 155                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 156                 {
 157                         // immediate local synchronous dispatching
 158                         _LocalModuleSkel->requestRefresh(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
 159                 }
 160                 else
 161                 {
 162                         // send the message for remote dispatching and execution or local queing
 163                         NLNET::CMessage __message;
 164
 165                         buildMessageFor_requestRefresh(__message);
 166
 167                         _ModuleProxy->sendModuleMessage(sender, __message);
 168                 }
 169         }
 170                 //
 171                 // Message sent by SPT module to request a change of install version for a given domain
 172                 // This message is forwarded to all SPA modules of the given domain
 173         void CServerPatchManagerProxy::setInstallVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
 174         {
 175                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 176                 {
 177                         // immediate local synchronous dispatching
 178                         _LocalModuleSkel->setInstallVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
 179                 }
 180                 else
 181                 {
 182                         // send the message for remote dispatching and execution or local queing
 183                         NLNET::CMessage __message;
 184
 185                         buildMessageFor_setInstallVersion(__message, domain, version);
 186
 187                         _ModuleProxy->sendModuleMessage(sender, __message);
 188                 }
 189         }
 190                 //
 191                 // Message sent by SPT module to request a change of launch version for a given domain
 192                 // This message is forwarded to all SPA modules of the given domain
 193         void CServerPatchManagerProxy::setLaunchVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
 194         {
 195                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 196                 {
 197                         // immediate local synchronous dispatching
 198                         _LocalModuleSkel->setLaunchVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
 199                 }
 200                 else
 201                 {
 202                         // send the message for remote dispatching and execution or local queing
 203                         NLNET::CMessage __message;
 204
 205                         buildMessageFor_setLaunchVersion(__message, domain, version);
 206
 207                         _ModuleProxy->sendModuleMessage(sender, __message);
 208                 }
 209         }
 210                 //
 211                 // Message sent by RE / RR / SPA type modules to declare their states
 212                 // This message is forwarded to all connected SPT modules
 213         void CServerPatchManagerProxy::declareState(NLNET::IModule *sender, const NLMISC::CSString &state)
 214         {
 215                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 216                 {
 217                         // immediate local synchronous dispatching
 218                         _LocalModuleSkel->declareState(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), state);
 219                 }
 220                 else
 221                 {
 222                         // send the message for remote dispatching and execution or local queing
 223                         NLNET::CMessage __message;
 224
 225                         buildMessageFor_declareState(__message, state);
 226
 227                         _ModuleProxy->sendModuleMessage(sender, __message);
 228                 }
 229         }
 230                 //
 231                 // Message sent by SPT module to define a new named version
 232         void CServerPatchManagerProxy::declareVersionName(NLNET::IModule *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
 233         {
 234                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 235                 {
 236                         // immediate local synchronous dispatching
 237                         _LocalModuleSkel->declareVersionName(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), versionName, clientVersion, serverVersion);
 238                 }
 239                 else
 240                 {
 241                         // send the message for remote dispatching and execution or local queing
 242                         NLNET::CMessage __message;
 243
 244                         buildMessageFor_declareVersionName(__message, versionName, clientVersion, serverVersion);
 245
 246                         _ModuleProxy->sendModuleMessage(sender, __message);
 247                 }
 248         }
 249                 //
 250                 // Message sent by SPT module to request execution of a command on one or more modules
 251                 // Note that the 'target' parameter may be a wildcard
 252         void CServerPatchManagerProxy::executeCommandOnSPA(NLNET::IModule *sender, const NLMISC::CSString &target, const NLMISC::CSString &commandline)
 253         {
 254                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 255                 {
 256                         // immediate local synchronous dispatching
 257                         _LocalModuleSkel->executeCommandOnSPA(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), target, commandline);
 258                 }
 259                 else
 260                 {
 261                         // send the message for remote dispatching and execution or local queing
 262                         NLNET::CMessage __message;
 263
 264                         buildMessageFor_executeCommandOnSPA(__message, target, commandline);
 265
 266                         _ModuleProxy->sendModuleMessage(sender, __message);
 267                 }
 268         }
 269                 //
 270                 // Message sent by SPA with result of command issuued via executeCommandOnSPA()
 271         void CServerPatchManagerProxy::spaExecutedCommandResult(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
 272         {
 273                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 274                 {
 275                         // immediate local synchronous dispatching
 276                         _LocalModuleSkel->spaExecutedCommandResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), originator, commandline, result);
 277                 }
 278                 else
 279                 {
 280                         // send the message for remote dispatching and execution or local queing
 281                         NLNET::CMessage __message;
 282
 283                         buildMessageFor_spaExecutedCommandResult(__message, originator, commandline, result);
 284
 285                         _ModuleProxy->sendModuleMessage(sender, __message);
 286                 }
 287         }
 288
 289         // Message serializer. Return the message received in reference for easier integration
 290         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_requestRefresh(NLNET::CMessage &__message)
 291         {
 292                 __message.setType("SPM_REFRESH");
 293
 294
 295                 return __message;
 296         }
 297
 298         // Message serializer. Return the message received in reference for easier integration
 299         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_setInstallVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
 300         {
 301                 __message.setType("SPM_SETNEXT");
 302                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
 303                         nlWrite(__message, serial, version);
 304
 305
 306                 return __message;
 307         }
 308
 309         // Message serializer. Return the message received in reference for easier integration
 310         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_setLaunchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
 311         {
 312                 __message.setType("SPM_SETLIVE");
 313                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
 314                         nlWrite(__message, serial, version);
 315
 316
 317                 return __message;
 318         }
 319
 320         // Message serializer. Return the message received in reference for easier integration
 321         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_declareState(NLNET::CMessage &__message, const NLMISC::CSString &state)
 322         {
 323                 __message.setType("SPM_STATE");
 324                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (state));
 325
 326
 327                 return __message;
 328         }
 329
 330         // Message serializer. Return the message received in reference for easier integration
 331         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_declareVersionName(NLNET::CMessage &__message, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
 332         {
 333                 __message.setType("SPM_VERSION_NAME");
 334                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (versionName));
 335                         nlWrite(__message, serial, clientVersion);
 336                         nlWrite(__message, serial, serverVersion);
 337
 338
 339                 return __message;
 340         }
 341
 342         // Message serializer. Return the message received in reference for easier integration
 343         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_executeCommandOnSPA(NLNET::CMessage &__message, const NLMISC::CSString &target, const NLMISC::CSString &commandline)
 344         {
 345                 __message.setType("SPM_SPA_EXEC");
 346                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (target));
 347                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (commandline));
 348
 349
 350                 return __message;
 351         }
 352
 353         // Message serializer. Return the message received in reference for easier integration
 354         const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_spaExecutedCommandResult(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
 355         {
 356                 __message.setType("SPM_SPA_EXEC_RESULT");
 357                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (originator));
 358                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (commandline));
 359                         nlWrite(__message, serial, const_cast < NLMISC::CSString& > (result));
 360
 361
 362                 return __message;
 363         }
 364
 365         /////////////////////////////////////////////////////////////////
 366         // WARNING : this is a generated file, don't change it !
 367         /////////////////////////////////////////////////////////////////
 368
 369
 370         const CDeploymentConfigurationSynchroniserSkel::TMessageHandlerMap &CDeploymentConfigurationSynchroniserSkel::getMessageHandlers() const
 371         {
 372                 static TMessageHandlerMap handlers;
 373                 static bool init = false;
 374
 375                 if (!init)
 376                 {
 377                         std::pair < TMessageHandlerMap::iterator, bool > res;
 378
 379                         res = handlers.insert(std::make_pair(std::string("DEPCFG_REQUEST"), &CDeploymentConfigurationSynchroniserSkel::requestSync_skel));
 380                         // if this assert, you have a doubly message name in your interface definition !
 381                         nlassert(res.second);
 382
 383                         res = handlers.insert(std::make_pair(std::string("DEPCFG_SYNC"), &CDeploymentConfigurationSynchroniserSkel::sync_skel));
 384                         // if this assert, you have a doubly message name in your interface definition !
 385                         nlassert(res.second);
 386
 387                         init = true;
 388                 }
 389
 390                 return handlers;
 391         }
 392         bool CDeploymentConfigurationSynchroniserSkel::onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 393         {
 394                 const TMessageHandlerMap &mh = getMessageHandlers();
 395
 396                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 397
 398                 if (it == mh.end())
 399                 {
 400                         return false;
 401                 }
 402
 403                 TMessageHandler cmd = it->second;
 404                 (this->*cmd)(sender, message);
 405
 406                 return true;
 407         }
 408
 409
 410         void CDeploymentConfigurationSynchroniserSkel::requestSync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 411         {
 412                 requestSync(sender);
 413         }
 414
 415         void CDeploymentConfigurationSynchroniserSkel::sync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 416         {
 417                 NLNET::TBinBuffer       dataBlob;
 418                         nlRead(__message, serial, dataBlob);
 419                 sync(sender, dataBlob);
 420         }
 421                 //
 422                 // Request for a copy of another module's CDeploymentConfiguration singleton
 423         void CDeploymentConfigurationSynchroniserProxy::requestSync(NLNET::IModule *sender)
 424         {
 425                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 426                 {
 427                         // immediate local synchronous dispatching
 428                         _LocalModuleSkel->requestSync(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
 429                 }
 430                 else
 431                 {
 432                         // send the message for remote dispatching and execution or local queing
 433                         NLNET::CMessage __message;
 434
 435                         buildMessageFor_requestSync(__message);
 436
 437                         _ModuleProxy->sendModuleMessage(sender, __message);
 438                 }
 439         }
 440                 //
 441                 // A copy of the data from the CDeploymentConfiguration singleton
 442         void CDeploymentConfigurationSynchroniserProxy::sync(NLNET::IModule *sender, const NLNET::TBinBuffer &dataBlob)
 443         {
 444                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 445                 {
 446                         // immediate local synchronous dispatching
 447                         _LocalModuleSkel->sync(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), dataBlob);
 448                 }
 449                 else
 450                 {
 451                         // send the message for remote dispatching and execution or local queing
 452                         NLNET::CMessage __message;
 453
 454                         buildMessageFor_sync(__message, dataBlob);
 455
 456                         _ModuleProxy->sendModuleMessage(sender, __message);
 457                 }
 458         }
 459
 460         // Message serializer. Return the message received in reference for easier integration
 461         const NLNET::CMessage &CDeploymentConfigurationSynchroniserProxy::buildMessageFor_requestSync(NLNET::CMessage &__message)
 462         {
 463                 __message.setType("DEPCFG_REQUEST");
 464
 465
 466                 return __message;
 467         }
 468
 469         // Message serializer. Return the message received in reference for easier integration
 470         const NLNET::CMessage &CDeploymentConfigurationSynchroniserProxy::buildMessageFor_sync(NLNET::CMessage &__message, const NLNET::TBinBuffer &dataBlob)
 471         {
 472                 __message.setType("DEPCFG_SYNC");
 473                         nlWrite(__message, serial, const_cast < NLNET::TBinBuffer& > (dataBlob));
 474
 475
 476                 return __message;
 477         }
 478
 479 }