ryzom/server/src/backup_service/backup_service.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2014-2015  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "nel/misc/types_nl.h"
  21
  22 #include "nel/misc/path.h"
  23 #include "nel/misc/file.h"
  24 #include "nel/misc/algo.h"
  25 #include "nel/misc/time_nl.h"
  26 #include "nel/misc/sheet_id.h"
  27
  28 #include "game_share/backup_service_messages.h"
  29 #include "server_share/backup_service_itf.h"
  30 #include "server_share/handy_commands.h"
  31
  32 #include "backup_service.h"
  33 #include "web_connection.h"
  34
  35 #ifdef NL_OS_WINDOWS
  36 #       ifndef NL_COMP_MINGW
  37 #               define NOMINMAX
  38 #       endif
  39 #       include <windows.h>
  40 #endif // NL_OS_WINDOWS
  41
  42 // force admin module to link in
  43 extern void admin_modules_forceLink();
  44 void foo()
  45 {
  46         admin_modules_forceLink();
  47 }
  48
  49 //-------------------------------------------------------------------------------------------------
  50 // struct CBackupMsgSaveFile
  51 // For receiving only: first construct a CBackupMsgSaveFile object, then you have access to
  52 // the Filename and the stream
  53 //-------------------------------------------------------------------------------------------------
  54 struct CBackupMsgSaveFileRecv
  55 {
  56         // Constructor
  57         CBackupMsgSaveFileRecv( NLMISC::IStream& streamFrom )
  58         {
  59                 streamFrom.serial(FileName);
  60         }
  61
  62         // Filename
  63         std::string FileName;
  64 };
  65
  66
  67 extern CDirectoryRateStat       DirStats;
  68 extern NLMISC::CVariable<std::string> SaveShardRootGameShare;
  69
  70 using namespace NLNET;
  71 using namespace NLMISC;
  72 using namespace std;
  73
  74 void                                    cbReadState(IVariable&);
  75
  76 CVariable<std::string>  MasterBSHost("backup", "MasterBSHost", "Master backup Host address", "", 0, true);
  77 CVariable<bool>                 BSReadState("backup", "BSReadState", "Current read files state", false, 0, false, cbReadState);
  78 CVariable<uint16>               L3ListeningPort("backup", "L3ListeningPort", "Port used for layer 3 listen socket", 0, 0, true);
  79
  80 bool                                    MasterBSUp = false;
  81 bool                                    BSIsSlave = false;
  82 NLMISC::TTime                   LastMasterPing = 0;
  83 bool                                    PongReceived = false;
  84
  85 //-----------------------------------------------------------------------------
  86 static void cbConnection( const string &serviceName, NLNET::TServiceId serviceId, void *arg )
  87 {
  88         if (serviceName == "BS" && BSIsSlave && serviceId != IService::getInstance()->getServiceId())
  89         {
  90                 nlinfo("SLAVE BS: Master BS is up.");
  91                 MasterBSUp = true;
  92                 PongReceived = true;
  93
  94                 IService::getInstance()->clearCurrentStatus("WaitingMaster");
  95                 IService::getInstance()->removeStatusTag("WaitingMaster");
  96                 IService::getInstance()->addStatusTag("MasterRunning");
  97                 IService::getInstance()->removeStatusTag("MasterDown");
  98         }
  99
 100         // notify file manager a service connected
 101         CBackupService::getInstance()->FileManager.notifyServiceConnection(serviceId, serviceName);
 102
 103 } // cbConnection //
 104
 105
 106 //-----------------------------------------------------------------------------
 107 static void cbDisconnection( const string &serviceName, NLNET::TServiceId serviceId, void *arg )
 108 {
 109         if (serviceName == "BS" && !MasterBSHost.get().empty())
 110         {
 111                 nlwarning("SLAVE BS: MASTER BS IS DOWN!! File reading allowed!");
 112                 MasterBSUp = false;
 113                 BSReadState = true;
 114
 115                 IService::getInstance()->addStatusTag("MasterDown");
 116                 IService::getInstance()->removeStatusTag("MasterRunning");
 117         }
 118 } // cbDisconnection //
 119
 120 //-----------------------------------------------------------------------------
 121 void    cbReadState(IVariable& v)
 122 {
 123         if (!BSIsSlave)
 124                 return;
 125         CBackupService::getInstance()->FileManager.forbidStall(!BSReadState.get());
 126 }
 127
 128
 129
 130 //-----------------------------------------------------------------------------
 131 static void cbBSPing( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 132 {
 133         CMessage        msgout("BS_PONG");
 134         CUnifiedNetwork::getInstance()->send(serviceId, msgout);
 135 }
 136
 137 //-----------------------------------------------------------------------------
 138 static void cbBSPong( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 139 {
 140         // don't acknowledge my own pong
 141         if (serviceId == IService::getInstance()->getServiceId())
 142                 return;
 143
 144         PongReceived = true;
 145 }
 146
 147 CVariable<string>       StatDirFilter("Stats", "StatDirFilter", "filter of the backup files path to be used", "save_shard", 0, true);
 148
 149
 150 //-----------------------------------------------------------------------------
 151 // cbSaveFile
 152 //
 153 // message format:
 154 // - std::string: fileName
 155 // - remaining of the stream: fileData
 156 //
 157 static void cbSaveFile( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 158 {
 159         try
 160         {
 161                 CBackupMsgSaveFileRecv msg( msgin );
 162
 163                 CWriteFile*     access = new CWriteFile(msg.FileName, serviceId, 0, /*msg.Data*/msgin);
 164
 165                 access->FailureMode = CWriteFile::MajorFailureIfFileUnwritable | CWriteFile::MajorFailureIfFileUnbackupable;
 166                 access->BackupFile = false;
 167                 access->Append = false;
 168
 169                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 170         }
 171         catch (...)
 172         {
 173                 nlwarning("WARNING: caught exception in cbSaveFile()");
 174         }
 175
 176 }
 177
 178 //-----------------------------------------------------------------------------
 179 // cbAppendFile
 180 //
 181 // message format:
 182 // - std::string: fileName
 183 // - remaining of the stream: fileData
 184 //
 185 static void cbAppendFile( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 186 {
 187         try
 188         {
 189                 CBackupMsgSaveFileRecv msg( msgin );
 190
 191                 CWriteFile*     access = new CWriteFile(msg.FileName, serviceId, 0, /*msg.Data*/msgin);
 192
 193                 access->FailureMode = CWriteFile::MajorFailureIfFileUnwritable | CWriteFile::MajorFailureIfFileUnbackupable;
 194                 access->BackupFile = false;
 195                 access->Append = true;
 196
 197                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 198         }
 199         catch (...)
 200         {
 201                 nlwarning("WARNING: caught exception in cbAppendFile()");
 202         }
 203
 204 }
 205
 206 //-----------------------------------------------------------------------------
 207 // cbAppendFileCheck
 208 //
 209 // message format:
 210 // - std::string: fileName
 211 // - remaining of the stream: fileData
 212 //
 213 static void cbAppendFileCheck( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 214 {
 215         try
 216         {
 217                 CBackupMsgSaveFileRecv msg( msgin );
 218
 219                 CWriteFile*     access = new CWriteFile(msg.FileName, serviceId, 0, msgin);
 220
 221                 access->CreateDir = true;
 222                 access->FailureMode = CWriteFile::MajorFailureIfFileUnwritable | CWriteFile::MajorFailureIfFileUnbackupable;
 223                 access->BackupFile = false;
 224                 access->Append = true;
 225
 226                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 227         }
 228         catch (...)
 229         {
 230                 nlwarning("WARNING: caught exception in cbAppendFileCheck()");
 231         }
 232 }
 233
 234
 235
 236 //-----------------------------------------------------------------------------
 237 // cbLoadFile
 238
 239 static void cbLoadFile( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 240 {
 241         if (!BSReadState.get())
 242                 return;
 243
 244         try
 245         {
 246                 CBackupMsgRequestFile   msg;
 247                 msgin.serial(msg);
 248
 249                 CLoadFile*      access = new CLoadFile(msg.FileName, serviceId, msg.RequestId);
 250
 251                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 252         }
 253         catch (...)
 254         {
 255                 nlwarning("WARNING: caught exception in cbLoadFile()");
 256         }
 257 }
 258
 259 static void cbReadMode( CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 260 {
 261         // encode the read mode and return
 262         CMessage msgout("BS_READ_MODE");
 263         bool readMode = BSReadState.get();
 264         nlWrite(msgout, serial, readMode);
 265
 266         // send it back to sender
 267         netbase.send(msgout, from);
 268 }
 269
 270
 271 static void cbSyncLoadFile( CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 272 {
 273         if (!BSReadState.get())
 274                 return;
 275
 276         try
 277         {
 278                 CBackupMsgRequestFile   msg;
 279                 msgin.serial(msg);
 280
 281                 CLoadFile*      access = new CLoadFile(msg.FileName, TRequester(from, &netbase), msg.RequestId);
 282
 283                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 284         }
 285         catch (...)
 286         {
 287                 nlwarning("WARNING: caught exception in cbLoadFile()");
 288         }
 289 }
 290
 291
 292 //-----------------------------------------------------------------------------
 293 // cbDeleteFile
 294
 295 static void cbDeleteFile( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 296 {
 297         try
 298         {
 299                 std::string     fileToDelete;
 300                 msgin.serial(fileToDelete);
 301
 302                 CDeleteFile*    access = new CDeleteFile(fileToDelete, serviceId, 0);
 303
 304                 access->BackupFile = true;
 305
 306                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 307         }
 308         catch (...)
 309         {
 310                 nlwarning("WARNING: caught exception in cbDeleteFile()");
 311         }
 312 }
 313
 314
 315 //-----------------------------------------------------------------------------
 316 // cbDeleteFileNoBackup
 317
 318 static void cbDeleteFileNoBackup( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 319 {
 320         try
 321         {
 322                 std::string     fileToDelete;
 323                 msgin.serial(fileToDelete);
 324
 325                 CDeleteFile*    access = new CDeleteFile(fileToDelete, serviceId, 0);
 326
 327                 access->BackupFile = false;
 328
 329                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 330         }
 331         catch (...)
 332         {
 333                 nlwarning("WARNING: caught exception in cbDeleteFile()");
 334         }
 335
 336 }
 337
 338 //-----------------------------------------------------------------------------
 339 // cbSaveCheckFile
 340
 341 static void     cbSaveCheckFile( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 342 {
 343         try
 344         {
 345                 CBackupMsgSaveFileRecv msg( msgin );
 346
 347                 CWriteFile*     access = new CWriteFile(msg.FileName, serviceId, 0, /*msg.Data*/msgin);
 348
 349                 access->FailureMode = CWriteFile::MajorFailureIfFileUnwritable | CWriteFile::MajorFailureIfFileUnbackupable;
 350                 access->BackupFile = false;
 351                 access->Append = false;
 352                 access->CreateDir = true;
 353
 354                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 355         }
 356         catch (...)
 357         {
 358                 nlwarning("WARNING: caught exception in cbSaveFile()");
 359         }
 360
 361 /*
 362         if( CBackupService::getInstance()->getStall() == true )
 363         {
 364                 // stall shard
 365                 CBackupService::getInstance()->stallShard( std::string() );
 366                 return;
 367         }
 368
 369         CBackupMsgSaveFile msg;
 370
 371         {
 372                 H_AUTO(SaveCheckNetSerial);
 373                 msgin.serial(msg);
 374         }
 375         nlinfo("SAVE: Saving file '%s' size %u", msg.FileName.c_str(), msg.Data.length());
 376
 377
 378         std::string     path = CFile::getPath(msg.FileName);
 379
 380         if ((!CFile::isExists(path) || !CFile::isDirectory(path)) && (!CFile::createDirectoryTree(path) || !CFile::setRWAccess(path)))
 381         {
 382                 nlwarning("Can't check directory '%s' existence (to write file '%s'), shard stalled until problem are resolved !!!", path.c_str(), msg.FileName.c_str());
 383                 // stall shard
 384                 CBackupService::getInstance()->stallShard( msg.FileName );
 385                 return;
 386         }
 387
 388         try
 389         {
 390                 NLMISC::CFile::copyFile( msg.FileName + string(".backup"), msg.FileName );
 391         }
 392         catch(const Exception &e)
 393         {
 394                 nlwarning("Can't write file '%s' size %u : '%s', shard stalled until problem are resolved !!!", ( msg.FileName + string(".backup") ).c_str(), msg.Data.length(), e.what() );
 395                 // stall shard
 396                 CBackupService::getInstance()->stallShard( msg.FileName );
 397                 return;
 398         }
 399
 400         COFile f;
 401         {
 402                 H_AUTO(SaveCheckFileOpen);
 403                 if(!f.open(msg.FileName))
 404                 {
 405                         nlwarning("Can't open file '%s' size %u, shard stalled until problem are resolved !!!", msg.FileName.c_str(), msg.Data.length());
 406                         // stall shard
 407                         CBackupService::getInstance()->stallShard( msg.FileName );
 408                         return;
 409                 }
 410         }
 411
 412         try
 413         {
 414                 H_AUTO(SaveCheckFileSerial);
 415                 f.serialBuffer( (uint8*)msg.Data.buffer(), msg.Data.length() );
 416
 417                 DirStats.writeFile(msg.FileName, msg.Data.length());
 418         }
 419         catch(const Exception &e)
 420         {
 421                 nlwarning("Can't write file '%s' size %u : '%s', shard stalled until problem are resolved !!!", msg.FileName.c_str(), msg.Data.length(), e.what());
 422                 // stall shard
 423                 CBackupService::getInstance()->stallShard( msg.FileName );
 424         }
 425
 426         {
 427                 H_AUTO(SaveCheckFileClose);
 428                 f.close();
 429         }
 430 */
 431 }
 432
 433 //-----------------------------------------------------------------------------
 434 // cbGetFileClass
 435
 436 struct CClassResult
 437 {
 438         CClassResult() : Timestamp(0)   {}
 439         CClassResult(const std::string& file, uint32 stamp) : Timestamp(stamp), File(file)      {}
 440
 441         uint32          Timestamp;
 442         std::string     File;
 443
 444         bool    operator < (const CClassResult& b) const        { return Timestamp > b.Timestamp; }
 445 };
 446
 447
 448 static CMessage getFileClassImp( CMessage& msgin)
 449 {
 450         // retrieve the info from the input message
 451         CBackupMsgFileClass inMsg;
 452         msgin.serial(inMsg);
 453
 454         // setup the output message;
 455         CBackupMsgReceiveFileClass outMsg;
 456         outMsg.RequestId= inMsg.RequestId;
 457
 458         bool    hasWildcard = false;
 459
 460         {
 461                 H_AUTO(GetFileClass_CheckWildcard);
 462                 for (uint j=0; !hasWildcard && j<inMsg.Classes.size(); ++j)
 463                 {
 464                         const CBackupFileClass& fclass = inMsg.Classes[j];
 465
 466                         uint    k;
 467                         for (k=0; k<fclass.Patterns.size(); ++k)
 468                         {
 469                                 if (fclass.Patterns[k].find('*') != std::string::npos)
 470                                 {
 471                                         hasWildcard = true;
 472                                         break;
 473                                 }
 474                         }
 475                 }
 476         }
 477
 478         std::vector<std::vector<CClassResult> > classes;
 479
 480         classes.resize(inMsg.Classes.size());
 481
 482         if (hasWildcard)
 483         {
 484                 H_AUTO(GetFileClass_GetContent);
 485
 486                 std::vector<std::string>        files;
 487                 NLMISC::CPath::getPathContent(getBackupFileName(inMsg.Directory), false, false, true, files); // caution: it returns full path names
 488
 489                 for (uint i=0; i<files.size(); ++i)
 490                 {
 491                         uint32          fstamp = CFile::getFileModificationDate(files[i]);
 492                         std::string     fname = NLMISC::CFile::getFilename(files[i]);
 493
 494                         for (uint j=0; j<inMsg.Classes.size(); ++j)
 495                         {
 496                                 const CBackupFileClass& fclass = inMsg.Classes[j];
 497
 498                                 uint    k;
 499                                 for (k=0; k<fclass.Patterns.size(); ++k)
 500                                 {
 501                                         if (NLMISC::testWildCard(fname, fclass.Patterns[k]))
 502                                         {
 503                                                 classes[j].push_back(CClassResult(files[i], fstamp));
 504                                                 break;
 505                                         }
 506                                 }
 507
 508                                 if (k < fclass.Patterns.size())
 509                                         break;
 510                         }
 511                 }
 512         }
 513         else
 514         {
 515                 H_AUTO(GetFileClass_GetFiles);
 516
 517                 for (uint j=0; j<inMsg.Classes.size(); ++j)
 518                 {
 519                         const CBackupFileClass& fclass = inMsg.Classes[j];
 520
 521                         uint    k;
 522                         for (k=0; k<fclass.Patterns.size(); ++k)
 523                         {
 524                                 string  file = CPath::standardizePath(inMsg.Directory)+fclass.Patterns[k]; // relative filename
 525                                 string  rfile = getBackupFileName(file); // full filename
 526                                 if (CFile::isExists(rfile))
 527                                         classes[j].push_back(CClassResult(file, CFile::getFileModificationDate(rfile)));
 528                         }
 529                 }
 530         }
 531
 532         CFileDescriptionContainer&      fdc = outMsg.Fdc;
 533
 534         for (uint i=0; i<classes.size(); ++i)
 535         {
 536                 std::sort(classes[i].begin(), classes[i].end());
 537
 538                 for (uint j=0; j<classes[i].size(); ++j)
 539                 {
 540                         std::string     rfile = classes[i][j].File;
 541                         // if there's wildcard, the file is already full so we don't need to add again the backup path or we ll have "save_shard/save_shard/..." that is not valid
 542                         if (!CFile::isExists(rfile))
 543                                 rfile = getBackupFileName(classes[i][j].File);
 544                         fdc.addFile(classes[i][j].File, CFile::getFileModificationDate(rfile),CFile::getFileSize(rfile));
 545                 }
 546         }
 547         // In case something like getPathContent() has returned full paths, make paths relative to match the requested filenames
 548         fdc.stripFilename(SaveShardRootGameShare.get());
 549
 550         // compose the output message
 551         CMessage        msgout("BS_FILE_CLASS");
 552         msgout.serial(outMsg);
 553
 554         return msgout;
 555 }
 556
 557
 558 static void cbGetFileClass( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 559 {
 560         if (!BSReadState.get())
 561                 return;
 562
 563         CMessage msgOut = getFileClassImp(msgin);
 564
 565         // send the output message
 566         CUnifiedNetwork::getInstance()->send(serviceId, msgOut);
 567 }
 568
 569 static void cbSyncGetFileClass( CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 570 {
 571         if (!BSReadState.get())
 572                 return;
 573
 574         CMessage msgOut = getFileClassImp(msgin);
 575
 576         // send the output message
 577         netbase.send(msgOut, from);
 578 }
 579
 580
 581
 582 //-----------------------------------------------------------------------------
 583 // cbAppend
 584
 585 static void cbAppend( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 586 {
 587         try
 588         {
 589                 CBackupMsgAppend        inMsg;
 590                 msgin.serial(inMsg);
 591
 592                 std::string     append = inMsg.Append+'\n';
 593                 uint8*          data = (uint8*)(const_cast<char*>(append.c_str()));
 594                 uint            dataSize = (uint)append.size();
 595
 596                 CWriteFile*     access = new CWriteFile(inMsg.FileName, serviceId, 0, data, dataSize);
 597
 598                 access->FailureMode = CWriteFile::MajorFailureIfFileUnwritable;
 599                 access->BackupFile = false;
 600                 access->Append = true;
 601
 602                 CBackupService::getInstance()->FileManager.stackFileAccess(access);
 603         }
 604         catch (...)
 605         {
 606                 nlwarning("WARNING: caught exception in cbAppendFile()");
 607         }
 608 }
 609
 610
 611 //-----------------------------------------------------------------------------
 612 bool CBackupService::update()
 613 {
 614         TTime   ptime = CTime::getLocalTime();
 615         if (BSIsSlave && MasterBSUp && ptime - LastMasterPing > 60*1000)
 616         {
 617                 CMessage        msgout("BS_PING");
 618                 CUnifiedNetwork::getInstance()->send("BS", msgout);
 619                 PongReceived = false;
 620                 LastMasterPing = ptime;
 621         }
 622
 623         FileManager.update();
 624         updateWebConnection();
 625
 626         _CallbackServer->update();
 627
 628         if (BSReadState == true)
 629         {
 630                 IService::getInstance()->addStatusTag("ReadWrite");
 631                 IService::getInstance()->removeStatusTag("WriteOnly");
 632         }
 633         else
 634         {
 635                 IService::getInstance()->removeStatusTag("ReadWrite");
 636                 IService::getInstance()->addStatusTag("WriteOnly");
 637         }
 638
 639         return true;
 640 }
 641
 642
 643 //-----------------------------------------------------------------------------
 644 void CBackupService::release()
 645 {
 646         FileManager.release();
 647         releaseWebConnection();
 648         delete _CallbackServer;
 649 }
 650
 651
 652 //-----------------------------------------------------------------------------
 653 void CBackupService::stallShard( const std::string& fileName )
 654 {
 655 /*      CMessage msgOut("STALL_SHARD");
 656         std::string s = fileName;
 657         msgOut.serial( s );
 658         CUnifiedNetwork::getInstance()->send("EGS", msgOut );
 659         _SaveStall = true;
 660 */
 661         fileName.empty() ? nlwarning("BackupService are in stall mode !") : nlwarning("Backup service enter in stall mode when trying save file %s", fileName.c_str() );
 662 }
 663
 664
 665 void    CBackupService::onModuleDown(NLNET::IModuleProxy *proxy)
 666 {
 667 }
 668
 669
 670 //-----------------------------------------------------------------------------
 671 TUnifiedCallbackItem CbArray[]=
 672 {
 673         { "save_file",                  cbSaveFile },
 674         { "load_file",                  cbLoadFile },
 675         { "append_file",                cbAppendFile },
 676         { "append_file_check",  cbAppendFileCheck },
 677
 678         { "SAVE_CHECK_FILE",    cbSaveCheckFile },
 679         { "DELETE_FILE",                cbDeleteFile },
 680         { "DELETE_FILE_NO_BACKUP",              cbDeleteFileNoBackup },
 681
 682         { "GET_FILE_CLASS",             cbGetFileClass },
 683
 684         { "APPEND",                             cbAppend },
 685
 686         { "BS_PING",                    cbBSPing },
 687         { "BS_PONG",                    cbBSPong },
 688 };
 689
 690
 691 TCallbackItem cbSyncArray[] =
 692 {
 693         { "GET_READ_MODE",              cbReadMode      },              // TODO : implement me !
 694         { "load_file",                  cbSyncLoadFile  },
 695         { "GET_FILE_CLASS",             cbSyncGetFileClass      },
 696 };
 697
 698 //-----------------------------------------------------------------------------
 699 void CBackupService::init()
 700 {
 701         FileManager.init();
 702
 703         setUpdateTimeout(100);
 704         _SaveStall = false;
 705
 706         // set the connection and disconnection callbacks
 707         CUnifiedNetwork::getInstance()->setServiceUpCallback( string("*"), cbConnection, 0);
 708         CUnifiedNetwork::getInstance()->setServiceDownCallback( string("*"), cbDisconnection, 0);
 709
 710         CUnifiedNetwork::getInstance()->setServiceUpCallback( string("BS"), cbConnection, 0);
 711         CUnifiedNetwork::getInstance()->setServiceDownCallback( string("BS"), cbDisconnection, 0);
 712
 713         // Init the sheet Id
 714         CSheetId::init(false);
 715
 716         if (!MasterBSHost.get().empty())
 717         {
 718                 IService::getInstance()->addStatusTag("SlaveMode");
 719                 IService::getInstance()->setCurrentStatus("WaitingMaster");
 720
 721                 BSIsSlave = true;
 722                 FileManager.forbidStall();
 723                 // I'm a slave, try to contact master
 724                 string  host = MasterBSHost.get();
 725                 if (host.find (":") == string::npos)
 726                         host += ":49990";
 727
 728                 CUnifiedNetwork::getInstance()->addService ("BS", CInetAddress(host));
 729         }
 730
 731         // set the initial read state from the config file
 732         CConfigFile::CVar *readState = ConfigFile.getVarPtr("BSReadState");
 733         if (readState != NULL)
 734                 BSReadState = readState->asBool();
 735
 736
 737         initWebConnection();
 738
 739         _CallbackServer = new NLNET::CCallbackServer;
 740         _CallbackServer->addCallbackArray(cbSyncArray, sizeofarray(cbSyncArray));
 741         // open the layer 3 callback server if required
 742         if (L3ListeningPort != 0)
 743                 _CallbackServer->init(L3ListeningPort);
 744 }
 745
 746 static const char* getCompleteServiceName(const IService* theService, const char *defaultName)
 747 {
 748         static std::string s;
 749         s= defaultName;
 750
 751         if (theService->haveLongArg("name"))
 752         {
 753                 s+= "_"+theService->getLongArg("name");
 754         }
 755
 756         if (theService->haveLongArg("fullname"))
 757         {
 758                 s= theService->getLongArg("fullname");
 759         }
 760
 761         return s.c_str();
 762 }
 763
 764 static const char* getShortServiceName(const IService* theService, const char *defaultName)
 765 {
 766         static std::string s;
 767         s= defaultName;
 768
 769         if (theService->haveLongArg("shortname"))
 770         {
 771                 s= theService->getLongArg("shortname");
 772         }
 773
 774         return s.c_str();
 775 }
 776
 777 NLNET_SERVICE_MAIN( CBackupService, getShortServiceName(scn, "BS"), getCompleteServiceName(scn, "backup_service"), 49990, CbArray, "", "" )
 778
 779
 780 void    CDirectoryRateStat::clear()
 781 {
 782         TDirectoryMap::iterator first = _DirectoryMap.begin(), last = _DirectoryMap.end();
 783         for (; first != last; ++first)
 784                 (*first).second.clear();
 785 }
 786
 787 void    CDirectoryRateStat::readFile(const std::string& filename, uint32 filesize)
 788 {
 789         NLMISC::TTime   now = NLMISC::CTime::getLocalTime();
 790         if (filename.find("www") != std::string::npos)
 791         {
 792                 _DirectoryMap["www"].read(now, filesize);
 793         }
 794         else if (filename.find(StatDirFilter.get()) != std::string::npos)
 795         {
 796                 _DirectoryMap[NLMISC::CFile::getPath(filename)].read(now, filesize);
 797         }
 798 }
 799
 800 void    CDirectoryRateStat::writeFile(const std::string& filename, uint32 filesize)
 801 {
 802         NLMISC::TTime   now = NLMISC::CTime::getLocalTime();
 803         if (filename.find("www") != std::string::npos)
 804         {
 805                 _DirectoryMap["www"].write(now, filesize);
 806         }
 807         else if (filename.find(StatDirFilter.get()) != std::string::npos)
 808         {
 809                 _DirectoryMap[NLMISC::CFile::getPath(filename)].write(now, filesize);
 810         }
 811 }
 812
 813
 814 uint    CDirectoryRateStat::getMeanReadRate()
 815 {
 816         NLMISC::TTime   limit = NLMISC::CTime::getLocalTime()-60*1000;
 817         uint64  read = 0;
 818         TDirectoryMap::iterator first = _DirectoryMap.begin(), last = _DirectoryMap.end();
 819         for (; first != last; ++first)
 820         {
 821                 (*first).second.updateTime(limit);
 822                 read += (*first).second.ReadBytes;
 823         }
 824
 825         return (uint)(read / 60);
 826 }
 827
 828 uint    CDirectoryRateStat::getMeanWriteRate()
 829 {
 830         NLMISC::TTime   limit = NLMISC::CTime::getLocalTime()-60*1000;
 831         uint64  write = 0;
 832         TDirectoryMap::iterator first = _DirectoryMap.begin(), last = _DirectoryMap.end();
 833         for (; first != last; ++first)
 834         {
 835                 (*first).second.updateTime(limit);
 836                 write += (*first).second.WrittenBytes;
 837         }
 838
 839         return (uint)(write / 60);
 840 }
 841
 842 void    CDirectoryRateStat::display(NLMISC::CLog& log)
 843 {
 844         uint    pathsize = 0;
 845         TDirectoryMap::iterator first = _DirectoryMap.begin(), last = _DirectoryMap.end();
 846         for (; first != last; ++first)
 847                 if ((*first).first.size() > pathsize)
 848                         pathsize = (uint)(*first).first.size();
 849
 850         NLMISC::TTime   limit = NLMISC::CTime::getLocalTime()-60*1000;
 851
 852         std::string     format = "%-"+NLMISC::toString(pathsize)+"s %6s %10s %6s %10s";
 853         log.displayNL(format.c_str(), "directory", "rdfile", "read", "wrfile", "write");
 854         for (first=_DirectoryMap.begin(); first != last; ++first)
 855         {
 856                 (*first).second.updateTime(limit);
 857                 uint64  rdrate = (*first).second.ReadBytes/60;
 858                 uint64  wrrate = (*first).second.WrittenBytes/60;
 859                 log.displayNL(format.c_str(),
 860                         (*first).first.c_str(),
 861                         NLMISC::toString((*first).second.ReadFiles).c_str(),
 862                         (NLMISC::bytesToHumanReadable(uint32(rdrate))+"/s").c_str(),
 863                         NLMISC::toString((*first).second.WrittenFiles).c_str(),
 864                         (NLMISC::bytesToHumanReadable(uint32(wrrate))+"/s").c_str());
 865         }
 866 }
 867
 868
 869