ryzom/server/src/patchman_service/administered_module.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 // includes
  19 //-----------------------------------------------------------------------------
  20
  21 #include "administered_module.h"
  22 #include "module_admin_itf.h"
  23 #include "patchman_tester.h"
  24 #include "patchman_constants.h"
  25
  26
  27 //-------------------------------------------------------------------------------------------------
  28 // namespaces
  29 //-------------------------------------------------------------------------------------------------
  30
  31 using namespace std;
  32 using namespace NLMISC;
  33 using namespace NLNET;
  34 using namespace PATCHMAN;
  35
  36
  37 //-----------------------------------------------------------------------------
  38 // methods CAdministeredModuleBase - ctors / dtors
  39 //-----------------------------------------------------------------------------
  40
  41 CAdministeredModuleBase::CAdministeredModuleBase()
  42 {
  43         _ErrorCount= 0;
  44         _Initialised= false;
  45 }
  46
  47 NLMISC::CSString CAdministeredModuleBase::init(const TParsedCommandLine &initInfo)
  48 {
  49         CAdministeredModuleBaseSkel::init(this);
  50         // prevent double initialialisation (given that we are using virtual inherritance,
  51         // this init can be called more than once for the same module)
  52         if (_Initialised)
  53                 return "";
  54         _Initialised= true;
  55
  56         // initialise the module base...
  57         CModuleBase::initModule(initInfo);
  58
  59         // initialise the state variables
  60         setStateVariable("State","Initialising");
  61         broadcastStateInfo();
  62
  63         return "";
  64 }
  65
  66
  67 //-----------------------------------------------------------------------------
  68 // methods CAdministeredModuleBase - hooks for methods that this interface implements and that must be called from the parent class
  69 //-----------------------------------------------------------------------------
  70
  71 void CAdministeredModuleBase::onModuleUp(IModuleProxy *module)
  72 {
  73         // if the module coming up is an SPM module then we call it 'dad'
  74         if (CSString(module->getModuleManifest()).contains(ManifestEntryIsAdministrator))
  75         {
  76                 _PatchManagers.insert(module);
  77                 registerProgress("ServerPatchManager Connected: "+module->getModuleName()+" ("+module->getModuleManifest()+")");
  78         }
  79 }
  80
  81 void CAdministeredModuleBase::onModuleDown(IModuleProxy *module)
  82 {
  83         // if the module going down is an SPM module then remove it from our lists
  84         if (_PatchManagers.find(module)!=_PatchManagers.end())
  85         {
  86                 _PatchManagers.erase(module);
  87                 registerProgress("ServerPatchManager Disconnected: "+module->getModuleName()+" ("+module->getModuleManifest()+")");
  88         }
  89 }
  90
  91 void CAdministeredModuleBase::onModuleUpdate()
  92 {
  93         H_AUTO(CAdministeredModuleBase_onModuleUpdate);
  94         // if the state has changed then broadcast the new state info
  95         if (_LastBroadcastState != getStateString())
  96         {
  97                 broadcastStateInfo();
  98         }
  99 }
 100
 101 //bool CAdministeredModuleBase::onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 102 //{
 103 //      return CAdministeredModuleBaseSkel::onDispatchMessage(sender,message);
 104 //}
 105
 106
 107 //-----------------------------------------------------------------------------
 108 // methods CAdministeredModuleBase - callbackf for treating module messages
 109 //-----------------------------------------------------------------------------
 110
 111 void CAdministeredModuleBase::executeCommand(NLNET::IModuleProxy *sender, const NLMISC::CSString &cmdline, const NLMISC::CSString &originator)
 112 {
 113         // create a displayer to gather the output of the command
 114         class SStringDisplayer: public IDisplayer
 115         {
 116         public:
 117                 CSString Data;
 118                 void doDisplay( const CLog::TDisplayInfo& args, const char *message)
 119                 {
 120                         Data += message;
 121                 }
 122         };
 123         CLog log;
 124         SStringDisplayer stringDisplayer;
 125         log.addDisplayer(&stringDisplayer);
 126
 127         // execute the command
 128         registerProgress(NLMISC::toString("exec '%s' (via '%s'): '%s'", originator.c_str(), sender->getModuleName().c_str(), cmdline.c_str()));
 129         ICommand::execute(this->getModuleName()+'.'+cmdline.strip(),log);
 130
 131         // send a reply message to the originating service
 132         CServerPatchManagerProxy manager(sender);
 133         manager.executedCommandResult(this,originator,cmdline,stringDisplayer.Data);
 134 }
 135
 136
 137 //-----------------------------------------------------------------------------
 138 // methods CAdministeredModuleBase - methods for managing state variables
 139 //-----------------------------------------------------------------------------
 140
 141 void CAdministeredModuleBase::registerError(const NLMISC::CSString& value) const
 142 {
 143         ++_ErrorCount;
 144         setStateVariable("Error",NLMISC::toString("[%d]",_ErrorCount)+value);
 145         nlwarning("%s: ERROR: %s",CModuleBase::getModuleName().c_str(),value.c_str());
 146 }
 147
 148 void CAdministeredModuleBase::registerProgress(const NLMISC::CSString& value) const
 149 {
 150         setStateVariable("Latest",value);
 151         nlinfo("%s: %s",CModuleBase::getModuleName().c_str(),value.c_str());
 152 }
 153
 154 void CAdministeredModuleBase::setStateVariable(const NLMISC::CSString& variableName, const NLMISC::CSString& value) const
 155 {
 156         // if the state variable is in fact unchanged then just drop out as there is nothing real to do
 157         if (_StateVariables[variableName] == value)
 158         {
 159                 return;
 160         }
 161
 162         // set the state variable value
 163         _StateVariables[variableName]= value;
 164 }
 165
 166 void CAdministeredModuleBase::appendStateVariable(const NLMISC::CSString& variableName, const NLMISC::CSString& value) const
 167 {
 168         // if the state variable is in fact unchanged then just drop out as there is nothing real to do
 169         if (value.empty())
 170         {
 171                 return;
 172         }
 173
 174         // if the state variable isn't currently empty then add a separating space before the new value
 175         if (!_StateVariables[variableName].empty())
 176         {
 177                 _StateVariables[variableName]+= ' ';
 178         }
 179
 180         // append the new value to the state variable
 181         _StateVariables[variableName]+= value;
 182 }
 183
 184 const NLMISC::CSString& CAdministeredModuleBase::getStateVariable(const NLMISC::CSString& variableName) const
 185 {
 186         // setup a static 'emptyString' to return a refference to if requested variables are not found
 187         static NLMISC::CSString emptyString;
 188
 189         return (_StateVariables.find(variableName)==_StateVariables.end())? emptyString: _StateVariables[variableName];
 190 }
 191
 192 NLMISC::CSString CAdministeredModuleBase::getStateString() const
 193 {
 194         // setup a result variable to build the output string in
 195         NLMISC::CSString result;
 196
 197         // add each variable to the result string in turn
 198         for (TStateVariables::iterator it= _StateVariables.begin(); it!=_StateVariables.end(); ++it)
 199         {
 200                 if (!result.empty())
 201                 {
 202                         result+=", ";
 203                 }
 204                 result+= it->first;
 205                 result+= "=";
 206                 result+= it->second.quoteIfNotAtomic();
 207         }
 208
 209         // all done so return the constructed string
 210         return result;
 211 }
 212
 213 void CAdministeredModuleBase::clearStateVariable(const NLMISC::CSString& variableName) const
 214 {
 215         _StateVariables.erase(variableName);
 216 }
 217
 218 void CAdministeredModuleBase::clearAllStateVariables() const
 219 {
 220         _StateVariables.clear();
 221 }
 222
 223 void CAdministeredModuleBase::broadcastStateInfo() const
 224 {
 225         // generate the state string that we need to dispatch to any listening modules
 226         CSString stateString= getStateString();
 227
 228         // send an update message to any connected SPM modules
 229         for (TPatchManagers::const_iterator it=_PatchManagers.begin(); it!=_PatchManagers.end(); ++it)
 230         {
 231                 CServerPatchManagerProxy spm(*it);
 232                 spm.declareState(const_cast<CAdministeredModuleBase*>(this),stateString);
 233         }
 234
 235         // after broadcasting the state info the 'state has changed' flag can be set to false
 236         _LastBroadcastState= stateString;
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 // class CAdministeredModuleWrapper
 241 //-----------------------------------------------------------------------------
 242
 243 CAdministeredModuleWrapper::CAdministeredModuleWrapper()
 244 {
 245         _AdministeredModuleBase= NULL;
 246 }
 247
 248 NLMISC::CSString CAdministeredModuleWrapper::init(CAdministeredModuleBase* administeredModuleBase)
 249 {
 250         _AdministeredModuleBase= administeredModuleBase;
 251         return CSString();
 252 }
 253
 254 void CAdministeredModuleWrapper::registerError(const NLMISC::CSString& value) const
 255 {
 256         if (_AdministeredModuleBase!=NULL)
 257         {
 258                 _AdministeredModuleBase->registerError(value);
 259         }
 260         else
 261         {
 262                 nlwarning("Error: %s",value.c_str());
 263         }
 264 }
 265
 266 void CAdministeredModuleWrapper::registerProgress(const NLMISC::CSString& value) const
 267 {
 268         if (_AdministeredModuleBase!=NULL)
 269         {
 270                 _AdministeredModuleBase->registerProgress(value);
 271         }
 272         else
 273         {
 274                 nlinfo("Latest: %s",value.c_str());
 275         }
 276 }
 277
 278 void CAdministeredModuleWrapper::setStateVariable(const NLMISC::CSString& variableName, const NLMISC::CSString& value) const
 279 {
 280         if (_AdministeredModuleBase!=NULL)
 281         {
 282                 _AdministeredModuleBase->setStateVariable(variableName,value);
 283         }
 284         else
 285         {
 286                 nldebug("Setting: %s = %s",variableName.c_str(),value.c_str());
 287         }
 288 }
 289
 290 void CAdministeredModuleWrapper::appendStateVariable(const NLMISC::CSString& variableName, const NLMISC::CSString& value) const
 291 {
 292         if (_AdministeredModuleBase!=NULL)
 293         {
 294                 _AdministeredModuleBase->appendStateVariable(variableName,value);
 295         }
 296         else
 297         {
 298                 nldebug("Appending: %s += %s",variableName.c_str(),value.c_str());
 299         }
 300 }
 301
 302 void CAdministeredModuleWrapper::clearStateVariable(const NLMISC::CSString& variableName) const
 303 {
 304         if (_AdministeredModuleBase!=NULL)
 305         {
 306                 _AdministeredModuleBase->clearStateVariable(variableName);
 307         }
 308         else
 309         {
 310                 nldebug("Clearing: %s",variableName.c_str());
 311         }
 312 }
 313
 314 void CAdministeredModuleWrapper::clearAllStateVariables() const
 315 {
 316         if (_AdministeredModuleBase!=NULL)
 317         {
 318                 _AdministeredModuleBase->clearAllStateVariables();
 319         }
 320         else
 321         {
 322                 nlinfo("Clearing all state variables...");
 323         }
 324 }
 325
 326 void CAdministeredModuleWrapper::broadcastStateInfo() const
 327 {
 328         if (_AdministeredModuleBase!=NULL)
 329         {
 330                 _AdministeredModuleBase->broadcastStateInfo();
 331         }
 332 }
 333