nel/src/net/admin.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 //
  19 // Includes
  20 //
  21
  22 #include "stdnet.h"
  23
  24 #include "nel/net/service.h"
  25 #include "nel/net/admin.h"
  26 #include "nel/net/varpath.h"
  27
  28
  29 //
  30 // Namspaces
  31 //
  32
  33 using namespace std;
  34 using namespace NLMISC;
  35 using namespace NLNET;
  36
  37
  38 namespace NLNET {
  39
  40
  41 //
  42 // Structures
  43 //
  44
  45 struct CRequest
  46 {
  47         CRequest (uint32 id, TServiceId sid) : Id(id), NbWaiting(0), NbReceived(0), SId(sid)
  48         {
  49                 nldebug ("ADMIN: ++ NbWaiting %d NbReceived %d", NbWaiting, NbReceived);
  50                 Time = CTime::getSecondsSince1970 ();
  51         }
  52
  53         uint32                  Id;
  54         uint                    NbWaiting;
  55         uint32                  NbReceived;
  56         TServiceId                      SId;
  57         uint32                  Time;   // when the request was ask
  58
  59         TAdminViewResult Answers;
  60 };
  61
  62
  63 //
  64 // Variables
  65 //
  66
  67 TRemoteClientCallback RemoteClientCallback = 0;
  68
  69 vector<CAlarm> Alarms;
  70
  71 vector<CGraphUpdate> GraphUpdates;
  72
  73 // check alarms every 5 seconds
  74 const uint32 AlarmCheckDelay = 5;
  75
  76 vector<CRequest> Requests;
  77
  78 uint32 RequestTimeout = 4;      // in second
  79
  80
  81 //
  82 // Callbacks
  83 //
  84
  85 static void cbInfo (CMessage &msgin, const std::string &/* serviceName */, TServiceId /* sid */)
  86 {
  87         nlinfo ("ADMIN: Updating admin information");
  88
  89         vector<string> alarms;
  90         msgin.serialCont (alarms);
  91         vector<string> graphupdate;
  92         msgin.serialCont (graphupdate);
  93
  94         setInformation (alarms, graphupdate);
  95 }
  96
  97 static void cbServGetView (CMessage &msgin, const std::string &/* serviceName */, TServiceId sid)
  98 {
  99         uint32 rid;
 100         string rawvarpath;
 101
 102         msgin.serial (rid);
 103         msgin.serial (rawvarpath);
 104
 105         Requests.push_back (CRequest(rid, sid));
 106
 107         TAdminViewResult answer;
 108         // just send the view in async mode, don't retrieve the answer
 109         serviceGetView (rid, rawvarpath, answer, true);
 110         nlassert (answer.empty());
 111 }
 112
 113 static void cbExecCommand (CMessage &msgin, const std::string &/* serviceName */, TServiceId sid)
 114 {
 115         // create a displayer to gather the output of the command
 116         class CStringDisplayer: public IDisplayer
 117         {
 118         public:
 119                 void serial(NLMISC::IStream &stream)
 120                 {
 121                         stream.serial(_Data);
 122                 }
 123
 124         protected:
 125                 virtual void doDisplay( const CLog::TDisplayInfo& /* args */, const char *message)
 126                 {
 127                         _Data += message;
 128                 }
 129
 130                 std::string _Data;
 131         };
 132         CStringDisplayer stringDisplayer;
 133         IService::getInstance()->CommandLog.addDisplayer(&stringDisplayer);
 134
 135         // retreive the command from the input message and execute it
 136         string command;
 137         msgin.serial (command);
 138         nlinfo ("ADMIN: Executing command from network : '%s'", command.c_str());
 139         ICommand::execute (command, IService::getInstance()->CommandLog);
 140
 141         // unhook our displayer as it's work is now done
 142         IService::getInstance()->CommandLog.removeDisplayer(&stringDisplayer);
 143
 144         // send a reply message to the originating service
 145         CMessage msgout("EXEC_COMMAND_RESULT");
 146         stringDisplayer.serial(msgout);
 147         CUnifiedNetwork::getInstance()->send(sid, msgout);
 148 }
 149
 150
 151 // AES wants to know if i'm not dead, I have to answer faster as possible or i'll be killed
 152 static void cbAdminPing (CMessage &/* msgin */, const std::string &/* serviceName */, TServiceId sid)
 153 {
 154         // Send back a pong to say to the AES that I'm alive
 155         CMessage msgout("ADMIN_PONG");
 156         CUnifiedNetwork::getInstance()->send(sid, msgout);
 157 }
 158
 159 static void cbStopService (CMessage &/* msgin */, const std::string &serviceName, TServiceId sid)
 160 {
 161         nlinfo ("ADMIN: Receive a stop from service %s-%hu, need to quit", serviceName.c_str(), sid.get());
 162         IService::getInstance()->exit (0xFFFF);
 163 }
 164
 165
 166 void cbAESConnection (const string &/* serviceName */, TServiceId /* sid */, void * /* arg */)
 167 {
 168         // established a connection to the AES, identify myself
 169
 170         //
 171         // Sends the identification message with the name of the service and all commands available on this service
 172         //
 173
 174         nlinfo("cbAESConnection: Identifying self as: AliasName='%s' LongName='%s' PId=%u",
 175                 IService::getInstance()->_AliasName.c_str(),
 176                 IService::getInstance()->_LongName.c_str(),
 177                 getpid ());
 178         CMessage msgout ("SID");
 179         uint32 pid = getpid ();
 180         msgout.serial (IService::getInstance()->_AliasName, IService::getInstance()->_LongName, pid);
 181         ICommand::serialCommands (msgout);
 182         CUnifiedNetwork::getInstance()->send("AES", msgout);
 183
 184         if (IService::getInstance()->_Initialized)
 185         {
 186                 CMessage msgout2 ("SR");
 187                 CUnifiedNetwork::getInstance()->send("AES", msgout2);
 188         }
 189 }
 190
 191
 192 static void cbAESDisconnection (const std::string &serviceName, TServiceId sid, void * /* arg */)
 193 {
 194         nlinfo("Lost connection to the %s-%hu", serviceName.c_str(), sid.get());
 195 }
 196
 197
 198 static TUnifiedCallbackItem CallbackArray[] =
 199 {
 200         { "INFO",                       cbInfo },
 201         { "GET_VIEW",           cbServGetView },
 202         { "STOPS",                      cbStopService },
 203         { "EXEC_COMMAND",       cbExecCommand },
 204         { "ADMIN_PING",         cbAdminPing },
 205 };
 206
 207
 208 //
 209 // Functions
 210 //
 211
 212 void setRemoteClientCallback (TRemoteClientCallback cb)
 213 {
 214         RemoteClientCallback = cb;
 215 }
 216
 217
 218 //
 219 // Request functions
 220 //
 221
 222 static void addRequestWaitingNb (uint32 rid)
 223 {
 224         for (uint i = 0 ; i < Requests.size (); i++)
 225         {
 226                 if (Requests[i].Id == rid)
 227                 {
 228                         Requests[i].NbWaiting++;
 229                         nldebug ("ADMIN: ++ i %d rid %d NbWaiting+ %d NbReceived %d", i, Requests[i].Id, Requests[i].NbWaiting, Requests[i].NbReceived);
 230                         // if we add a waiting, reset the timer
 231                         Requests[i].Time = CTime::getSecondsSince1970 ();
 232                         return;
 233                 }
 234         }
 235         nlwarning ("ADMIN: addRequestWaitingNb: can't find the rid %d", rid);
 236 }
 237
 238 /*
 239 static void subRequestWaitingNb (uint32 rid)
 240 {
 241         for (uint i = 0 ; i < Requests.size (); i++)
 242         {
 243                 if (Requests[i].Id == rid)
 244                 {
 245                         Requests[i].NbWaiting--;
 246                         nldebug ("ADMIN: ++ i %d rid %d NbWaiting- %d NbReceived %d", i, Requests[i].Id, Requests[i].NbWaiting, Requests[i].NbReceived);
 247                         return;
 248                 }
 249         }
 250         nlwarning ("ADMIN: subRequestWaitingNb: can't find the rid %d", rid);
 251 }
 252 */
 253
 254 void addRequestAnswer (uint32 rid, const TAdminViewVarNames& varNames, const TAdminViewValues& values)
 255 {
 256         if (!varNames.empty() && varNames[0] == "__log")
 257         {       nlassert (varNames.size() == 1); }
 258         else
 259         {       nlassert (varNames.size() == values.size()); }
 260
 261         for (uint i = 0 ; i < Requests.size (); i++)
 262         {
 263                 if (Requests[i].Id == rid)
 264                 {
 265                         Requests[i].Answers.push_back (SAdminViewRow(varNames, values));
 266
 267                         Requests[i].NbReceived++;
 268                         nldebug ("ADMIN: ++ i %d rid %d NbWaiting %d NbReceived+ %d", i, Requests[i].Id, Requests[i].NbWaiting, Requests[i].NbReceived);
 269
 270                         return;
 271                 }
 272         }
 273         // we received an unknown request, forget it
 274         nlwarning ("ADMIN: Receive an answer for unknown request %d", rid);
 275 }
 276
 277 /*
 278 static bool emptyRequest (uint32 rid)
 279 {
 280         for (uint i = 0 ; i < Requests.size (); i++)
 281         {
 282                 if (Requests[i].Id == rid && Requests[i].NbWaiting != 0)
 283                 {
 284                         return false;
 285                 }
 286         }
 287         return true;
 288 }
 289 */
 290
 291 static void cleanRequest ()
 292 {
 293         uint32 currentTime = CTime::getSecondsSince1970 ();
 294
 295         for (uint i = 0 ; i < Requests.size ();)
 296         {
 297                 // timeout
 298                 if (currentTime >= Requests[i].Time+RequestTimeout)
 299                 {
 300                         nlwarning ("ADMIN: **** i %d rid %d -> Requests[i].NbWaiting (%d) != Requests[i].NbReceived (%d)", i, Requests[i].Id, Requests[i].NbWaiting, Requests[i].NbReceived);
 301                         Requests[i].NbWaiting = Requests[i].NbReceived;
 302                 }
 303
 304                 if (Requests[i].NbWaiting <= Requests[i].NbReceived)
 305                 {
 306                         // the request is over, send to the php
 307
 308                         CMessage msgout("VIEW");
 309                         msgout.serial (Requests[i].Id);
 310
 311                         for (uint j = 0; j < Requests[i].Answers.size (); j++)
 312                         {
 313                                 msgout.serialCont (Requests[i].Answers[j].VarNames);
 314                                 msgout.serialCont (Requests[i].Answers[j].Values);
 315                         }
 316
 317                         if (Requests[i].SId.get() == 0)
 318                         {
 319                                 nlinfo ("ADMIN: Receive an answer for the fake request %d with %d answers", Requests[i].Id, Requests[i].Answers.size ());
 320                                 for (uint j = 0; j < Requests[i].Answers.size (); j++)
 321                                 {
 322                                         uint k;
 323                                         for (k = 0; k < Requests[i].Answers[j].VarNames.size(); k++)
 324                                         {
 325                                                 InfoLog->displayRaw ("%-10s", Requests[i].Answers[j].VarNames[k].c_str());
 326                                         }
 327                                         InfoLog->displayRawNL("");
 328                                         for (k = 0; k < Requests[i].Answers[j].Values.size(); k++)
 329                                         {
 330                                                 InfoLog->displayRaw ("%-10s", Requests[i].Answers[j].Values[k].c_str());
 331                                         }
 332                                         InfoLog->displayRawNL("");
 333                                         InfoLog->displayRawNL("-------------------------");
 334                                 }
 335                         }
 336                         else
 337                         {
 338                                 nlinfo ("ADMIN: The request is over, send the result to AES");
 339                                 CUnifiedNetwork::getInstance ()->send (Requests[i].SId, msgout);
 340                         }
 341
 342                         // set to 0 to erase it
 343                         Requests[i].NbWaiting = 0;
 344                         nldebug ("ADMIN: ++ i %d rid %d NbWaiting0 %d NbReceived %d", i, Requests[i].Id, Requests[i].NbWaiting, Requests[i].NbReceived);
 345                 }
 346
 347                 if (Requests[i].NbWaiting == 0)
 348                 {
 349                         Requests.erase (Requests.begin ()+i);
 350                 }
 351                 else
 352                 {
 353                         i++;
 354                 }
 355         }
 356 }
 357
 358 // all remote command start with rc or RC
 359 bool isRemoteCommand(string &str)
 360 {
 361         if (str.size()<2) return false;
 362         return tolower(str[0]) == 'r' && tolower(str[1]) == 'c';
 363 }
 364
 365
 366 // this callback is used to create a view for the admin system
 367 void serviceGetView (uint32 rid, const string &rawvarpath, TAdminViewResult &answer, bool async)
 368 {
 369         string str;
 370         CLog logDisplayVars;
 371         CLightMemDisplayer mdDisplayVars;
 372         logDisplayVars.addDisplayer (&mdDisplayVars);
 373         mdDisplayVars.setParam (4096);
 374
 375         CVarPath varpath(rawvarpath);
 376
 377         if (varpath.empty())
 378                 return;
 379
 380         // special case for named command handler
 381         if (CCommandRegistry::getInstance().isNamedCommandHandler(varpath.Destination[0].first))
 382         {
 383                 varpath.Destination[0].first += "."+varpath.Destination[0].second;
 384                 varpath.Destination[0].second.clear();
 385         }
 386
 387         if (varpath.isFinal())
 388         {
 389                 TAdminViewVarNames varNames;
 390                 TAdminViewValues values;
 391
 392                 // add default row
 393                 varNames.push_back ("service");
 394                 values.push_back (IService::getInstance ()->getServiceUnifiedName());
 395
 396                 for (uint j = 0; j < varpath.Destination.size (); j++)
 397                 {
 398                         string cmd = varpath.Destination[j].first;
 399
 400                         // replace = with space to execute the command
 401                         string::size_type eqpos = cmd.find("=");
 402                         if (eqpos != string::npos)
 403                         {
 404                                 cmd[eqpos] = ' ';
 405                                 varNames.push_back(cmd.substr(0, eqpos));
 406                         }
 407                         else
 408                                 varNames.push_back(cmd);
 409
 410                         mdDisplayVars.clear ();
 411                         ICommand::execute(cmd, logDisplayVars, !ICommand::isCommand(cmd));
 412                         const std::deque<std::string>   &strs = mdDisplayVars.lockStrings();
 413
 414                         if (ICommand::isCommand(cmd))
 415                         {
 416                                 // we want the log of the command
 417                                 if (j == 0)
 418                                 {
 419                                         varNames.clear ();
 420                                         varNames.push_back ("__log");
 421                                         values.clear ();
 422                                 }
 423
 424                                 values.push_back ("----- Result from "+IService::getInstance()->getServiceUnifiedName()+" of command '"+cmd+"'\n");
 425                                 for (uint k = 0; k < strs.size(); k++)
 426                                 {
 427                                         values.push_back (strs[k]);
 428                                 }
 429                         }
 430                         else
 431                         {
 432
 433                                 if (!strs.empty())
 434                                 {
 435                                         str = strs[0].substr(0,strs[0].size()-1);
 436                                         // replace all spaces into udnerscore because space is a reserved char
 437                                         for (uint i = 0; i < str.size(); i++) if (str[i] == ' ') str[i] = '_';
 438                                 }
 439                                 else
 440                                 {
 441                                         str = "???";
 442                                 }
 443                                 values.push_back (str);
 444                                 nlinfo ("ADMIN: Add to result view '%s' = '%s'", varpath.Destination[j].first.c_str(), str.c_str());
 445                         }
 446                         mdDisplayVars.unlockStrings();
 447                 }
 448
 449                 if (!async)
 450                         answer.push_back (SAdminViewRow(varNames, values));
 451                 else
 452                 {
 453                         addRequestWaitingNb (rid);
 454                         addRequestAnswer (rid, varNames, values);
 455                 }
 456         }
 457         else
 458         {
 459                 // there s an entity in the varpath, manage this case
 460
 461                 TAdminViewVarNames *varNames=0;
 462                 TAdminViewValues *values=0;
 463
 464                 // varpath.Destination          contains the entity number
 465                 // subvarpath.Destination       contains the command name
 466
 467                 for (uint i = 0; i < varpath.Destination.size (); i++)
 468                 {
 469                         CVarPath subvarpath(varpath.Destination[i].second);
 470
 471                         for (uint j = 0; j < subvarpath.Destination.size (); j++)
 472                         {
 473                                 // set the variable name
 474                                 string cmd = subvarpath.Destination[j].first;
 475
 476                                 if (isRemoteCommand(cmd))
 477                                 {
 478                                         if (async && RemoteClientCallback != 0)
 479                                         {
 480                                                 // ok we have to send the request to another side, just send and wait
 481                                                 addRequestWaitingNb (rid);
 482                                                 RemoteClientCallback (rid, cmd, varpath.Destination[i].first);
 483                                         }
 484                                 }
 485                                 else
 486                                 {
 487                                         // replace = with space to execute the command
 488                                         string::size_type eqpos = cmd.find("=");
 489                                         if (eqpos != string::npos)
 490                                         {
 491                                                 cmd[eqpos] = ' ';
 492                                                 // add the entity
 493                                                 cmd.insert(eqpos, " "+varpath.Destination[i].first);
 494                                         }
 495                                         else
 496                                         {
 497                                                 // add the entity
 498                                                 cmd += " "+varpath.Destination[i].first;
 499                                         }
 500
 501                                         mdDisplayVars.clear ();
 502                                         ICommand::execute(cmd, logDisplayVars, true);
 503                                         const std::deque<std::string>   &strs = mdDisplayVars.lockStrings();
 504                                         for (uint k = 0; k < strs.size(); k++)
 505                                         {
 506                                                 const string &str = strs[k];
 507
 508                                                 string::size_type pos = str.find(" ");
 509                                                 if(pos == string::npos)
 510                                                         continue;
 511
 512                                                 string entity = str.substr(0, pos);
 513                                                 string value = str.substr(pos+1, str.size()-pos-2);
 514                                                 for (uint u = 0; u < value.size(); u++) if (value[u] == ' ') value[u] = '_';
 515
 516                                                 // look in the array if we already have something about this entity
 517
 518                                                 if (!async)
 519                                                 {
 520                                                         uint y;
 521                                                         for (y = 0; y < answer.size(); y++)
 522                                                         {
 523                                                                 if (answer[y].Values[1] == entity)
 524                                                                 {
 525                                                                         // ok we found it, just push_back new stuff
 526                                                                         varNames = &(answer[y].VarNames);
 527                                                                         values = &(answer[y].Values);
 528                                                                         break;
 529                                                                 }
 530                                                         }
 531                                                         if (y == answer.size ())
 532                                                         {
 533                                                                 answer.push_back (SAdminViewRow());
 534
 535                                                                 varNames = &(answer[answer.size()-1].VarNames);
 536                                                                 values = &(answer[answer.size()-1].Values);
 537
 538                                                                 // don't add service if we want an entity
 539                 // todo when we work on entity, we don't need service name and server so we should remove them and collapse all var for the same entity
 540                                                                 varNames->push_back ("service");
 541                                                                 string name = IService::getInstance ()->getServiceUnifiedName();
 542                                                                 values->push_back (name);
 543
 544                                                                 // add default row
 545                                                                 varNames->push_back ("entity");
 546                                                                 values->push_back (entity);
 547                                                         }
 548
 549                                                         varNames->push_back (cmd.substr(0, cmd.find(" ")));
 550                                                         values->push_back (value);
 551                                                 }
 552                                                 else
 553                                                 {
 554                                                         addRequestWaitingNb (rid);
 555
 556                                                         TAdminViewVarNames varNames;
 557                                                         TAdminViewValues values;
 558                                                         varNames.push_back ("service");
 559                                                         string name = IService::getInstance ()->getServiceUnifiedName();
 560                                                         values.push_back (name);
 561
 562                                                         // add default row
 563                                                         varNames.push_back ("entity");
 564                                                         values.push_back (entity);
 565
 566                                                         varNames.push_back (cmd.substr(0, cmd.find(" ")));
 567                                                         values.push_back (value);
 568
 569                                                         addRequestAnswer (rid, varNames, values);
 570                                                 }
 571                                                 nlinfo ("ADMIN: Add to result view for entity '%s', '%s' = '%s'", varpath.Destination[i].first.c_str(), subvarpath.Destination[j].first.c_str(), str.c_str());
 572                                         }
 573                                         mdDisplayVars.unlockStrings();
 574                                 }
 575                         }
 576                 }
 577         }
 578 }
 579
 580
 581 //
 582 // Alarms functions
 583 //
 584
 585 void sendAdminEmail (const char *format, ...)
 586 {
 587         char *text;
 588         NLMISC_CONVERT_VARGS (text, format, 4096);
 589
 590         time_t t = time (&t);
 591
 592         string str;
 593         str  = asctime (localtime (&t));
 594         str += " Server " + IService::getInstance()->getHostName();
 595         str += " service " + IService::getInstance()->getServiceUnifiedName();
 596         str += " : ";
 597         str += text;
 598
 599         CMessage msgout("ADMIN_EMAIL");
 600         msgout.serial (str);
 601         if(IService::getInstance ()->getServiceShortName()=="AES")
 602                 CUnifiedNetwork::getInstance ()->send ("AS", msgout);
 603         else
 604                 CUnifiedNetwork::getInstance ()->send ("AES", msgout);
 605
 606         nlinfo ("ADMIN: Forwarded email to AS with '%s'", str.c_str());
 607 }
 608
 609 void initAdmin (bool dontUseAES)
 610 {
 611         if (!dontUseAES)
 612         {
 613                 CUnifiedNetwork::getInstance()->setServiceUpCallback ("AES", cbAESConnection, NULL);
 614                 CUnifiedNetwork::getInstance()->setServiceDownCallback ("AES", cbAESDisconnection, NULL);
 615                 CUnifiedNetwork::getInstance()->addService ("AES", CInetAddress("localhost:49997"));
 616         }
 617         CUnifiedNetwork::getInstance()->addCallbackArray (CallbackArray, sizeof(CallbackArray)/sizeof(CallbackArray[0]));
 618 }
 619
 620
 621 void updateAdmin()
 622 {
 623         uint32 CurrentTime = CTime::getSecondsSince1970();
 624
 625
 626         //
 627         // check admin requests
 628         //
 629
 630         cleanRequest ();
 631
 632
 633         //
 634         // Check graph updates
 635         //
 636
 637         static uint32 lastGraphUpdateCheck = 0;
 638
 639         if (CurrentTime >= lastGraphUpdateCheck+1)
 640         {
 641                 string str;
 642                 CLog logDisplayVars;
 643                 CLightMemDisplayer mdDisplayVars;
 644                 logDisplayVars.addDisplayer (&mdDisplayVars);
 645
 646                 lastGraphUpdateCheck = CurrentTime;
 647
 648                 CMessage msgout ("GRAPH_UPDATE");
 649                 bool empty = true;
 650                 for (uint j = 0; j < GraphUpdates.size(); j++)
 651                 {
 652                         if (CurrentTime >= GraphUpdates[j].LastUpdate + GraphUpdates[j].Update)
 653                         {
 654                                 // have to send a new update for this var
 655                                 ICommand::execute(GraphUpdates[j].Name, logDisplayVars, true, false);
 656                                 const std::deque<std::string>   &strs = mdDisplayVars.lockStrings();
 657                                 sint32 val;
 658                                 if (strs.size() != 1)
 659                                 {
 660                                         nlwarning ("ADMIN: The graph update command execution not return exactly 1 line but %d", strs.size());
 661                                         for (uint i = 0; i < strs.size(); i++)
 662                                           nlwarning ("ADMIN: line %d: '%s'", i, strs[i].c_str());
 663                                         val = 0;
 664                                 }
 665                                 else
 666                                 {
 667                                         fromString(strs[0], val);
 668                                 }
 669                                 mdDisplayVars.unlockStrings ();
 670                                 mdDisplayVars.clear ();
 671
 672                                 string name = IService::getInstance()->getServiceAliasName();
 673                                 if (name.empty())
 674                                         name = IService::getInstance()->getServiceShortName();
 675
 676                                 if(empty)
 677                                         msgout.serial (CurrentTime);
 678
 679                                 msgout.serial (name);
 680                                 msgout.serial (GraphUpdates[j].Name);
 681                                 msgout.serial (val);
 682
 683                                 empty = false;
 684
 685                                 GraphUpdates[j].LastUpdate = CurrentTime;
 686                         }
 687                 }
 688
 689                 if(!empty)
 690                 {
 691                         if(IService::getInstance ()->getServiceShortName()=="AES")
 692                                 CUnifiedNetwork::getInstance ()->send ("AS", msgout);
 693                         else
 694                                 CUnifiedNetwork::getInstance ()->send ("AES", msgout);
 695                 }
 696         }
 697
 698
 699         //
 700         // Check alarms
 701         //
 702
 703         static uint32 lastAlarmsCheck = 0;
 704
 705         if (CurrentTime >= lastAlarmsCheck+AlarmCheckDelay)
 706         {
 707                 string str;
 708                 CLog logDisplayVars;
 709                 CLightMemDisplayer mdDisplayVars;
 710                 logDisplayVars.addDisplayer (&mdDisplayVars);
 711
 712                 lastAlarmsCheck = CTime::getSecondsSince1970();
 713
 714                 for (uint i = 0; i < Alarms.size(); )
 715                 {
 716                         mdDisplayVars.clear ();
 717                         ICommand::execute(Alarms[i].Name, logDisplayVars, true, false);
 718                         const std::deque<std::string>   &strs = mdDisplayVars.lockStrings();
 719
 720                         if (!strs.empty())
 721                         {
 722                                 str = strs[0].substr(0,strs[0].size()-1);
 723                         }
 724                         else
 725                         {
 726                                 str = "???";
 727                         }
 728
 729                         mdDisplayVars.unlockStrings();
 730
 731                         if (str == "???")
 732                         {
 733                                 // variable doesn't exist, remove it from alarms
 734                                 nlwarning ("ADMIN: Alarm problem: variable '%s' returns ??? instead of a good value", Alarms[i].Name.c_str());
 735                                 Alarms.erase (Alarms.begin()+i);
 736                         }
 737                         else
 738                         {
 739                                 // compare the value
 740                                 uint32 err = Alarms[i].Limit;
 741                                 uint32 val = humanReadableToBytes(str);
 742                                 if (Alarms[i].GT && val >= err)
 743                                 {
 744                                         if (!Alarms[i].Activated)
 745                                         {
 746                                                 nlinfo ("ADMIN: VARIABLE TOO BIG '%s' %u >= %u", Alarms[i].Name.c_str(), val, err);
 747                                                 Alarms[i].Activated = true;
 748                                                 sendAdminEmail ("Alarm: Variable %s is %u that is greater or equal than the limit %u", Alarms[i].Name.c_str(), val, err);
 749                                         }
 750                                 }
 751                                 else if (!Alarms[i].GT && val <= err)
 752                                 {
 753                                         if (!Alarms[i].Activated)
 754                                         {
 755                                                 nlinfo ("ADMIN: VARIABLE TOO LOW '%s' %u <= %u", Alarms[i].Name.c_str(), val, err);
 756                                                 Alarms[i].Activated = true;
 757                                                 sendAdminEmail ("Alarm: Variable %s is %u that is lower or equal than the limit %u", Alarms[i].Name.c_str(), val, err);
 758                                         }
 759                                 }
 760                                 else
 761                                 {
 762                                         if (Alarms[i].Activated)
 763                                         {
 764                                                 nlinfo ("ADMIN: variable is ok '%s' %u %s %u", Alarms[i].Name.c_str(), val, (Alarms[i].GT?"<":">"), err);
 765                                                 Alarms[i].Activated = false;
 766                                         }
 767                                 }
 768
 769                                 i++;
 770                         }
 771                 }
 772         }
 773 }
 774
 775 void setInformation (const vector<string> &alarms, const vector<string> &graphupdate)
 776 {
 777         uint i;
 778         sint tmp;
 779
 780         // add only commands that I understand
 781         Alarms.clear ();
 782         for (i = 0; i < alarms.size(); i+=3)
 783         {
 784                 CVarPath shardvarpath (alarms[i]);
 785                 if(shardvarpath.Destination.empty() || shardvarpath.Destination[0].second.empty())
 786                         continue;
 787                 CVarPath servervarpath (shardvarpath.Destination[0].second);
 788                 if(servervarpath.Destination.empty() || servervarpath.Destination[0].second.empty())
 789                         continue;
 790                 CVarPath servicevarpath (servervarpath.Destination[0].second);
 791                 if(servicevarpath.Destination.empty() || servicevarpath.Destination[0].second.empty())
 792                         continue;
 793
 794                 string name = servicevarpath.Destination[0].second;
 795
 796                 if (IService::getInstance()->getServiceUnifiedName().find(servicevarpath.Destination[0].first) != string::npos && ICommand::exists(name))
 797                 {
 798                         fromString(alarms[i+1], tmp);
 799                         nlinfo ("ADMIN: Adding alarm '%s' limit %d order %s (varpath '%s')", name.c_str(), tmp, alarms[i+2].c_str(), alarms[i].c_str());
 800                         Alarms.push_back(CAlarm(name, tmp, alarms[i+2]=="gt"));
 801                 }
 802                 else
 803                 {
 804                         if (IService::getInstance()->getServiceUnifiedName().find(servicevarpath.Destination[0].first) == string::npos)
 805                         {
 806                                 nlinfo ("ADMIN: Skipping alarm '%s' limit %d order %s (varpath '%s') (not for my service, i'm '%s')", name.c_str(), fromString(alarms[i+1], tmp) ? tmp:tmp, alarms[i+2].c_str(), alarms[i].c_str(), IService::getInstance()->getServiceUnifiedName().c_str());
 807                         }
 808                         else
 809                         {
 810                                 nlinfo ("ADMIN: Skipping alarm '%s' limit %d order %s (varpath '%s') (var not exist)", name.c_str(), fromString(alarms[i+1], tmp) ? tmp:tmp, alarms[i+2].c_str(), alarms[i].c_str());
 811                         }
 812                 }
 813         }
 814
 815         // do the same with graph update
 816         GraphUpdates.clear ();
 817         for (i = 0; i < graphupdate.size(); i+=2)
 818         {
 819                 CVarPath shardvarpath (graphupdate[i]);
 820                 if(shardvarpath.Destination.empty() || shardvarpath.Destination[0].second.empty())
 821                         continue;
 822                 CVarPath servervarpath (shardvarpath.Destination[0].second);
 823                 if(servervarpath.Destination.empty() || servervarpath.Destination[0].second.empty())
 824                         continue;
 825                 CVarPath servicevarpath (servervarpath.Destination[0].second);
 826                 if(servicevarpath.Destination.empty() || servicevarpath.Destination[0].second.empty())
 827                         continue;
 828
 829                 string VarName = servicevarpath.Destination[0].second;
 830                 string ServiceName = servicevarpath.Destination[0].first;
 831
 832                 if (ICommand::exists(VarName) && (ServiceName == "*" || IService::getInstance()->getServiceShortName() == ServiceName))
 833                 {
 834                         fromString(graphupdate[i+1], tmp);
 835                         nlinfo ("ADMIN: Adding graphupdate '%s' update %d (varpath '%s')", VarName.c_str(), tmp, graphupdate[i].c_str());
 836                         GraphUpdates.push_back(CGraphUpdate(VarName, tmp));
 837                 }
 838                 else
 839                 {
 840                         if (IService::getInstance()->getServiceShortName() != ServiceName)
 841                         {
 842                                 nlinfo ("ADMIN: Skipping graphupdate '%s' limit %d (varpath '%s') (not for my service, i'm '%s')", VarName.c_str(), fromString(graphupdate[i+1], tmp) ? tmp:tmp, graphupdate[i].c_str(), IService::getInstance()->getServiceUnifiedName().c_str());
 843                         }
 844                         else
 845                         {
 846                                 nlinfo ("ADMIN: Skipping graphupdate '%s' limit %d (varpath '%s') (var not exist)", VarName.c_str(), fromString(graphupdate[i+1], tmp) ? tmp:tmp, graphupdate[i].c_str());
 847                         }
 848                 }
 849         }
 850 }
 851
 852 //
 853 // Commands
 854 //
 855
 856 NLMISC_CATEGORISED_COMMAND(nel, displayInformation, "displays all admin information", "")
 857 {
 858         nlunreferenced(rawCommandString);
 859         nlunreferenced(args);
 860         nlunreferenced(quiet);
 861         nlunreferenced(human);
 862
 863         uint i;
 864
 865         log.displayNL("There're %d alarms:", Alarms.size());
 866         for (i = 0; i < Alarms.size(); i++)
 867         {
 868                 log.displayNL(" %d %s %d %s %s", i, Alarms[i].Name.c_str(), Alarms[i].Limit, (Alarms[i].GT?"gt":"lt"), (Alarms[i].Activated?"on":"off"));
 869         }
 870         log.displayNL("There're %d graphupdate:", GraphUpdates.size());
 871         for (i = 0; i < GraphUpdates.size(); i++)
 872         {
 873                 log.displayNL(" %d %s %d %d", i, GraphUpdates[i].Name.c_str(), GraphUpdates[i].Update, GraphUpdates[i].LastUpdate);
 874         }
 875         return true;
 876 }
 877
 878 NLMISC_CATEGORISED_COMMAND(nel, getView, "send a view and receive an array as result", "<varpath>")
 879 {
 880         nlunreferenced(rawCommandString);
 881         nlunreferenced(quiet);
 882         nlunreferenced(human);
 883
 884         if(args.size() != 1) return false;
 885
 886         TAdminViewResult answer;
 887         serviceGetView (0, args[0], answer);
 888
 889         log.displayNL("have %d answer", answer.size());
 890         for (uint i = 0; i < answer.size(); i++)
 891         {
 892                 log.displayNL("  have %d value", answer[i].VarNames.size());
 893
 894                 nlassert (answer[i].VarNames.size() == answer[i].Values.size());
 895
 896                 for (uint j = 0; j < answer[i].VarNames.size(); j++)
 897                 {
 898                         log.displayNL("    %s -> %s", answer[i].VarNames[j].c_str(), answer[i].Values[j].c_str());
 899                 }
 900         }
 901
 902         return true;
 903 }
 904
 905 } // NLNET