ryzom/server/src/backup_service/backup_service.h

   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
  19
  20 #ifndef BACKUP_SERVICE_H
  21 #define BACKUP_SERVICE_H
  22
  23
  24 // net
  25 #include "nel/misc/types_nl.h"
  26 #include "nel/misc/log.h"
  27 #include "nel/net/service.h"
  28 #include "nel/misc/variable.h"
  29
  30 // stl
  31 #include <string>
  32
  33 //
  34 #include "backup_file_access.h"
  35
  36
  37 /**
  38  * CBackupService
  39  *
  40  * \author Alain Saffray
  41  * \author Nevrax France
  42  * \date 2004
  43  */
  44 class CBackupService : public NLNET::IService
  45 {
  46 public :
  47         /**
  48          * init the service
  49          */
  50         void init();
  51
  52         /**
  53          * main loop
  54          */
  55         bool update();
  56
  57         /**
  58          * release
  59          */
  60         void release();
  61
  62         // stall shard
  63         void stallShard(const std::string& fileName);
  64
  65         /**
  66          * get Instance
  67          */
  68         static CBackupService * getInstance() { return (CBackupService *) NLNET::IService::getInstance(); }
  69
  70         /**
  71          * get stall, return true if we must not try to save file because previous pb are occurs
  72          */
  73         bool getStall() { return _SaveStall; }
  74
  75         /**
  76          * set stall mode
  77          */
  78         void setStall( bool stall ) { _SaveStall = stall; }
  79
  80         NLNET::IModule          *getBackupModule()      { return _BackupModule; };
  81
  82         void                            setBackupModule(NLNET::IModule *module) { _BackupModule = module; }
  83
  84         void            onModuleDown(NLNET::IModuleProxy *proxy);
  85
  86 public:
  87
  88
  89         CFileAccessManager      FileManager;
  90
  91 private:
  92
  93         bool            _SaveStall;
  94
  95         NLNET::TModulePtr               _BackupModule;
  96
  97         // A layer 3 server to serve synchronous file load
  98         NLNET::CCallbackServer  *_CallbackServer;
  99 };
 100
 101
 102 extern NLMISC::CVariable<std::string>   StatDirFilter;
 103
 104
 105 class CDirectoryRateStat
 106 {
 107 public:
 108
 109         CDirectoryRateStat()
 110         {
 111                 clear();
 112         }
 113
 114         void    clear();
 115
 116         void    readFile(const std::string& filename, uint32 filesize);
 117
 118         void    writeFile(const std::string& filename, uint32 filesize);
 119
 120         uint    getMeanReadRate();
 121
 122         uint    getMeanWriteRate();
 123
 124         void    display(NLMISC::CLog& log);
 125
 126 private:
 127
 128         struct CDirectory
 129         {
 130                 struct CFileQueueEntry
 131                 {
 132                         CFileQueueEntry(NLMISC::TTime time, uint32 size, const std::string& filename = "", uint32 duration = 0) : ActionTime(time), Size(size), Filename(filename), Duration(duration)  { }
 133                         NLMISC::TTime   ActionTime;
 134                         uint32                  Size;
 135                         std::string             Filename;
 136                         uint32                  Duration;
 137                 };
 138
 139                 typedef std::deque<CFileQueueEntry>     TFileQueue;
 140
 141                 // read stats
 142                 TFileQueue              ReadQueue;
 143                 uint64                  ReadBytes;
 144                 uint32                  ReadFiles;
 145
 146                 // write stats
 147                 TFileQueue              WrittenQueue;
 148                 uint64                  WrittenBytes;
 149                 uint32                  WrittenFiles;
 150
 151                 CDirectory()
 152                 {
 153                         clear();
 154                 }
 155
 156                 void    clear()
 157                 {
 158                         ReadBytes = 0;
 159                         ReadFiles = 0;
 160
 161                         WrittenBytes = 0;
 162                         WrittenFiles = 0;
 163                 }
 164
 165                 void    read(NLMISC::TTime now, uint32 filesize)
 166                 {
 167                         updateTime(now - 60*1000);
 168                         ReadBytes += filesize;
 169                         ++ReadFiles;
 170                         ReadQueue.push_back(CFileQueueEntry(now, filesize));
 171                 }
 172
 173                 void    write(NLMISC::TTime now, uint32 filesize)
 174                 {
 175                         updateTime(now - 60*1000);
 176                         WrittenBytes += filesize;
 177                         ++WrittenFiles;
 178                         WrittenQueue.push_back(CFileQueueEntry(now, filesize));
 179                 }
 180
 181                 void    updateTime(NLMISC::TTime limit)
 182                 {
 183                         while (!WrittenQueue.empty() && WrittenQueue.front().ActionTime < limit)
 184                         {
 185                                 WrittenBytes -= WrittenQueue.front().Size;
 186                                 --WrittenFiles;
 187                                 WrittenQueue.pop_front();
 188                         }
 189                         while (!ReadQueue.empty() && ReadQueue.front().ActionTime < limit)
 190                         {
 191                                 ReadBytes -= ReadQueue.front().Size;
 192                                 --ReadFiles;
 193                                 ReadQueue.pop_front();
 194                         }
 195                 }
 196         };
 197
 198
 199         // mapping to filtered directories
 200         typedef std::map<std::string, CDirectory>       TDirectoryMap;
 201         TDirectoryMap                                           _DirectoryMap;
 202
 203 };
 204
 205
 206
 207 #endif // BACKUP_SERVICE_H
 208
 209 /* End of backup_service.h */