ryzom/server/src/pd_lib/pd_server_utils.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 #include "pd_server_utils.h"
  18 #include "pd_lib.h"
  19
  20 #include <nel/misc/path.h>
  21 #include <nel/misc/debug.h>
  22 #include <nel/net/service.h>
  23
  24 #include <nel/misc/i_xml.h>
  25 #include <nel/misc/o_xml.h>
  26 #include <nel/misc/file.h>
  27
  28 #include <time.h>
  29
  30 #include "db_reference_file.h"
  31
  32 using namespace NLMISC;
  33 using namespace NLNET;
  34 using namespace std;
  35
  36
  37 /*
  38  * Load a Reference index file
  39  */
  40 bool    CRefIndex::load(const string& filename)
  41 {
  42         CIFile          reffile;
  43         CIXml           ixml;
  44
  45         if (!reffile.open(filename) || !ixml.init(reffile))
  46                 return false;
  47
  48         try
  49         {
  50                 serial(ixml);
  51         }
  52         catch (const Exception&)
  53         {
  54                 return false;
  55         }
  56
  57         return true;
  58 }
  59
  60 /*
  61  * Load a Reference index file
  62  */
  63 bool    CRefIndex::load()
  64 {
  65         string  rootpath = getRootPath();
  66         if (rootpath.empty())
  67                 return false;
  68
  69         return load(rootpath+"ref");
  70 }
  71
  72 /*
  73  * Save a Reference index file
  74  */
  75 bool    CRefIndex::save(const string& filename)
  76 {
  77         COFile          reffile;
  78         COXml           oxml;
  79
  80         if (!reffile.open(filename) || !oxml.init(&reffile))
  81                 return false;
  82
  83         try
  84         {
  85                 serial(oxml);
  86         }
  87         catch (const Exception&)
  88         {
  89                 return false;
  90         }
  91
  92         return true;
  93 }
  94
  95 /*
  96  * Save a Reference index file
  97  */
  98 bool    CRefIndex::save()
  99 {
 100         string  path = getPath();
 101         if (path.empty())
 102                 return false;
 103
 104         return checkDirectory(path) && save(path+"ref");
 105 }
 106
 107 /*
 108  * Set As Valid Reference
 109  */
 110 bool    CRefIndex::setAsValidRef()
 111 {
 112         string  rootpath = getRootPath();
 113         if (rootpath.empty())
 114                 return false;
 115
 116         return save(rootpath+"ref");
 117 }
 118
 119
 120 /*
 121  * Build next Reference index file
 122  */
 123 bool    CRefIndex::buildNext()
 124 {
 125         if (!load())
 126                 Index = 0;
 127         else
 128                 ++Index;
 129
 130         setup();
 131
 132         if (!setupDirectory())
 133                 return false;
 134
 135         if (!save())
 136                 return false;
 137
 138         return true;
 139 }
 140
 141 /*
 142  * Get next Reference index file
 143  */
 144 void    CRefIndex::getNext()
 145 {
 146         ++Index;
 147
 148         setup();
 149 }
 150
 151
 152
 153 /*
 154  * Get (and setup if needed) database root path
 155  */
 156 std::string     CRefIndex::getRootPath()
 157 {
 158         string  path = getNominalRootPath();
 159
 160         if (!CFile::isExists(path) || !CFile::isDirectory(path))
 161         {
 162                 if (!CFile::createDirectoryTree(path))
 163                 {
 164                         nlwarning("getRootPath(): unable to create save path '%s'", path.c_str());
 165                         return string("");
 166                 }
 167
 168                 if (!CFile::setRWAccess(path))
 169                 {
 170                         nlwarning("getRootPath(): failure, can't set RW access to path '%s', can't start.", path.c_str());
 171                         return string("");
 172                 }
 173         }
 174
 175         return path;
 176 }
 177
 178
 179 /*
 180  * Get Nominal Root Path
 181  */
 182 std::string     CRefIndex::getNominalRootPath()
 183 {
 184         return RY_PDS::CPDSLib::getRootDirectory(DatabaseId);
 185 }
 186
 187
 188 /*
 189  * Get reference path
 190  */
 191 std::string     CRefIndex::getPath()
 192 {
 193         return NLMISC::CPath::standardizePath(getRootPath() + Path);
 194 }
 195
 196
 197
 198
 199 /*
 200  * Setup reference directory
 201  */
 202 bool    CRefIndex::setupDirectory()
 203 {
 204         string  rootpath = getRootPath();
 205         if (rootpath.empty())
 206                 return false;
 207
 208         string  path = NLMISC::CPath::standardizePath(rootpath + Path);
 209
 210         if (!checkDirectory(path))
 211         {
 212                 nlwarning("CRefIndex::setupDirectory(): failed, can't check directory '%s'", path.c_str());
 213                 return false;
 214         }
 215
 216         if (!checkDirectory(getHoursUpdatePath()))
 217         {
 218                 nlwarning("CRefIndex::setupDirectory(): failed, can't check subdirectory '%s'", getHoursUpdatePath().c_str());
 219                 return false;
 220         }
 221
 222         if (!checkDirectory(getMinutesUpdatePath()))
 223         {
 224                 nlwarning("CRefIndex::setupDirectory(): failed, can't check subdirectory '%s'", getMinutesUpdatePath().c_str());
 225                 return false;
 226         }
 227
 228         if (!checkDirectory(getSecondsUpdatePath()))
 229         {
 230                 nlwarning("CRefIndex::setupDirectory(): failed, can't check subdirectory '%s'", getSecondsUpdatePath().c_str());
 231                 return false;
 232         }
 233
 234         if (!checkDirectory(getLogPath()))
 235         {
 236                 nlwarning("CRefIndex::setupDirectory(): failed, can't check subdirectory '%s'", getLogPath().c_str());
 237                 return false;
 238         }
 239
 240         return true;
 241 }
 242
 243 /*
 244  * Check directory
 245  */
 246 bool    CRefIndex::checkDirectory(const std::string& path)
 247 {
 248         if (!CFile::isExists(path))
 249         {
 250                 if (!CFile::createDirectoryTree(path))
 251                 {
 252                         nlwarning("CRefIndex::checkDirectory(): failed, can't create directory '%s'", path.c_str());
 253                         return false;
 254                 }
 255
 256                 if (!CFile::setRWAccess(path))
 257                 {
 258                         nlwarning("CRefIndex::checkDirectory(): failed, can't set RW access to directory '%s'", path.c_str());
 259                         return false;
 260                 }
 261         }
 262         else if (!CFile::isDirectory(path))
 263         {
 264                 nlwarning("CRefIndex::checkDirectory(): failed, directory '%s' is already a file", path.c_str());
 265                 return false;
 266         }
 267
 268         return true;
 269 }
 270
 271
 272 /*
 273  * Set Time stamp
 274  */
 275 void    CRefIndex::setTimestamp()
 276 {
 277         Timestamp.setToCurrent();
 278 }
 279
 280
 281
 282 /*
 283  * Get Seconds update path
 284  */
 285 std::string     CRefIndex::getSecondsUpdatePath()
 286 {
 287         return getRootPath() + "seconds/";
 288 }
 289
 290 /*
 291  * Get Minutes update path
 292  */
 293 std::string     CRefIndex::getMinutesUpdatePath()
 294 {
 295         return getRootPath() + "minutes/";
 296 }
 297
 298 /*
 299  * Get Hours update path
 300  */
 301 std::string     CRefIndex::getHoursUpdatePath()
 302 {
 303         return getRootPath() + "hours/";
 304 }
 305
 306 /*
 307  * Get Log path
 308  */
 309 std::string     CRefIndex::getLogPath()
 310 {
 311         return getRootPath() + "logs/";
 312 }
 313
 314
 315
 316
 317 /*
 318  * Constructor
 319  */
 320 CDatabaseState::CDatabaseState()
 321 {
 322         Id = 0xffffffff;
 323         LastUpdateId = (0-1);
 324         CurrentIndex = 0;
 325 }
 326
 327 /*
 328  * Serial method
 329  */
 330 void    CDatabaseState::serial(NLMISC::IStream& s)
 331 {
 332         s.xmlPush("database_state");
 333
 334         s.serialCheck(NELID("DBST"));
 335         uint    version = s.serialVersion(0);
 336
 337         s.xmlPush("name");
 338         s.serial(Name);
 339         s.xmlPop();
 340
 341         s.xmlPush("id");
 342         s.serial(Id);
 343         s.xmlPop();
 344
 345         s.xmlPush("lastupdateid");
 346         s.serial(LastUpdateId);
 347         s.xmlPop();
 348
 349         s.xmlPush("currentindex");
 350         s.serial(CurrentIndex);
 351         s.xmlPop();
 352
 353         s.xmlPush("endtimestamp");
 354         if (s.isReading())
 355         {
 356                 std::string     ts;
 357                 s.serial(ts);
 358                 EndTimestamp.fromString(ts.c_str());
 359         }
 360         else
 361         {
 362                 std::string     ts = EndTimestamp.toString();
 363                 s.serial(ts);
 364         }
 365         s.xmlPop();
 366
 367         s.xmlPop();
 368 }
 369
 370 /*
 371  * Save State
 372  */
 373 bool    CDatabaseState::save(CRefIndex& ref)
 374 {
 375         COFile          f;
 376         COXml           oxml;
 377
 378         string          filename = fileName(ref);
 379
 380         if (!f.open(filename) || !oxml.init(&f))
 381                 return false;
 382
 383         try
 384         {
 385                 serial(oxml);
 386         }
 387         catch (const Exception&)
 388         {
 389                 return false;
 390         }
 391
 392         return true;
 393 }
 394
 395 /*
 396  * Load State
 397  */
 398 bool    CDatabaseState::load(CRefIndex& ref, bool usePrevious)
 399 {
 400         return load(ref.getRootPath(), usePrevious);
 401 }
 402
 403
 404 /*
 405  * Load State
 406  */
 407 bool    CDatabaseState::load(const std::string& rootpath, bool usePrevious)
 408 {
 409         CIFile          f;
 410         CIXml           ixml;
 411
 412         string          filename = CPath::standardizePath(rootpath);
 413         if (usePrevious)
 414                 filename += "previous_state";
 415         else
 416                 filename += "state";
 417
 418         if (!f.open(filename) || !ixml.init(f))
 419                 return false;
 420
 421         try
 422         {
 423                 serial(ixml);
 424         }
 425         catch (const Exception&)
 426         {
 427                 return false;
 428         }
 429
 430         return true;
 431 }
 432
 433 /*
 434  * State exists in path
 435  */
 436 bool    CDatabaseState::exists(const std::string& rootpath)
 437 {
 438         string          filename = CPath::standardizePath(rootpath) + "state";
 439         return CFile::fileExists(filename);
 440 }
 441
 442
 443 uint64  CMixedStreamFile::_ReadBytes = 0;
 444 uint64  CMixedStreamFile::_WrittenBytes = 0;