ryzom/server/src/pd_lib/pd_server_utils.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 #ifndef RY_PD_SERVER_UTILS_H
  18 #define RY_PD_SERVER_UTILS_H
  19
  20 /*
  21  * Includes
  22  */
  23 #include <nel/misc/types_nl.h>
  24 #include <nel/misc/stream.h>
  25 #include <nel/misc/common.h>
  26 #include <nel/misc/bit_set.h>
  27 #include <nel/misc/variable.h>
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string>
  32
  33 #include "pd_utils.h"
  34 #include "timestamp.h"
  35
  36
  37 /**
  38  * CRefIndex, permanent info about the database
  39  * This class is not intended to be modified, only create when a valid
  40  * reference is ready
  41  * To store volatile data, see CDatabaseState.
  42  */
  43 class CRefIndex
  44 {
  45 public:
  46
  47         /// Database Id
  48         uint32          DatabaseId;
  49
  50         /// Numeral index of the reference
  51         uint32          Index;
  52
  53         /// Directory path of the reference, this MUST local path from root database path
  54         std::string     Path;
  55
  56         /// Timestamp, in the form 'YYYY.MM.DD.hh.mm.ss'
  57         //std::string   Timestamp;
  58         CTimestamp      Timestamp;
  59
  60         void            serial(NLMISC::IStream& s)
  61         {
  62                 s.xmlPush("reference");
  63
  64                 s.serialCheck(NELID("RIDX"));
  65                 uint    version = s.serialVersion(0);
  66
  67                 s.xmlPush("database");
  68                 s.serial(DatabaseId);
  69                 s.xmlPop();
  70
  71                 s.xmlPush("index");
  72                 s.serial(Index);
  73                 s.xmlPop();
  74
  75                 s.xmlPush("path");
  76                 s.serial(Path);
  77                 s.xmlPop();
  78
  79                 s.xmlPush("timestamp");
  80                 if (s.isReading())
  81                 {
  82                         std::string     ts;
  83                         s.serial(ts);
  84                         Timestamp.fromString(ts.c_str());
  85                 }
  86                 else
  87                 {
  88                         std::string     ts = Timestamp.toString();
  89                         s.serial(ts);
  90                 }
  91                 //s.serial(Timestamp);
  92                 s.xmlPop();
  93
  94                 s.xmlPop();
  95         }
  96
  97         /// Constructor
  98         CRefIndex(uint32 databaseId) : DatabaseId(databaseId), Index(0)
  99         {
 100                 setup();
 101         }
 102
 103         /// Setup
 104         void    setup()
 105         {
 106                 Path = "ref."+NLMISC::toString("%08X", Index);
 107                 setTimestamp();
 108         }
 109
 110         /**
 111          * Set Time stamp
 112          */
 113         void                    setTimestamp();
 114
 115
 116         /**
 117          * Load a Reference index file
 118          */
 119         bool                    load(const std::string& filename);
 120
 121         /**
 122          * Load a Reference index file
 123          */
 124         bool                    load();
 125
 126         /**
 127          * Save a Reference index file
 128          */
 129         bool                    save();
 130
 131         /**
 132          * Save a Reference index file
 133          */
 134         bool                    save(const std::string& filename);
 135
 136         /**
 137          * Build next Reference index file
 138          */
 139         bool                    buildNext();
 140
 141         /**
 142          * Get next Reference index file
 143          */
 144         void                    getNext();
 145
 146         /**
 147          * Get (and setup if needed) database root path
 148          */
 149         std::string             getRootPath();
 150
 151         /**
 152          * Get reference path
 153          */
 154         std::string             getPath();
 155
 156         /**
 157          * Set As Valid Reference
 158          */
 159         bool                    setAsValidRef();
 160
 161         /**
 162          * Get Nominal Root Path
 163          */
 164         std::string             getNominalRootPath();
 165
 166
 167         /**
 168          * Get Seconds update path
 169          */
 170         std::string             getSecondsUpdatePath();
 171
 172         /**
 173          * Get Minutes update path
 174          */
 175         std::string             getMinutesUpdatePath();
 176
 177         /**
 178          * Get Hours update path
 179          */
 180         std::string             getHoursUpdatePath();
 181
 182         /**
 183          * Get Log path
 184          */
 185         std::string             getLogPath();
 186
 187 private:
 188
 189         /**
 190          * Setup reference directory
 191          */
 192         bool                    setupDirectory();
 193
 194         /**
 195          * Check directory
 196          */
 197         bool                    checkDirectory(const std::string& path);
 198 };
 199
 200
 201
 202
 203 /**
 204  * CDatabaseState
 205  * This class contains 'volatile' state of the database
 206  * This class is update at each update, and written on HD at the end of update.
 207  * File on HD is used when database is checked at startup (and if it fails,
 208  * database should not be initialised unless maintenance fixes the problem)
 209  */
 210 class CDatabaseState
 211 {
 212 public:
 213
 214         /// Constructor
 215         CDatabaseState();
 216
 217         /// Database Name
 218         std::string                     Name;
 219
 220         /// Database Id
 221         uint32                          Id;
 222
 223         /// Last Update Id
 224         uint32                          LastUpdateId;
 225
 226         /// Current Valid Index
 227         uint32                          CurrentIndex;
 228
 229         /// End Database Update Timestamp
 230         CTimestamp                      EndTimestamp;
 231
 232
 233         /// Serial method
 234         void                            serial(NLMISC::IStream& s);
 235
 236         /// Save State
 237         bool                            save(CRefIndex& ref);
 238
 239         /// Load State
 240         bool                            load(CRefIndex& ref, bool usePrevious = false);
 241
 242         /// Load State
 243         bool                            load(const std::string& rootpath, bool usePrevious = false);
 244
 245         /// State exists in path
 246         static bool                     exists(const std::string& rootpath);
 247
 248
 249         /// Get state filename
 250         static std::string      fileName()                                      { return "state"; }
 251
 252         /// Get state filename
 253         static std::string      fileName(CRefIndex& ref)        { return ref.getRootPath()+"state"; }
 254
 255
 256 private:
 257
 258 };
 259
 260
 261
 262
 263
 264
 265
 266 class CMixedStreamFile : public NLMISC::IStream
 267 {
 268 public:
 269
 270         /// Constructor
 271         CMixedStreamFile() : NLMISC::IStream(false), _File(NULL)
 272         {
 273         }
 274
 275         /// Destructor
 276         virtual ~CMixedStreamFile()
 277         {
 278                 close();
 279         }
 280
 281         bool                            open(const char* filename, const char* mode = "rb")
 282         {
 283                 if (_File != NULL)
 284                         return false;
 285
 286                 _File = NLMISC::nlfopen(filename, mode);
 287                 if (_File == NULL)
 288                         return false;
 289
 290                 return true;
 291         }
 292
 293         virtual void            close()
 294         {
 295                 if (_File != NULL)
 296                         fclose(_File);
 297                 _File = NULL;
 298         }
 299
 300         void                            flush()
 301         {
 302                 if (_File != NULL)
 303                         fflush(_File);
 304         }
 305
 306 protected:
 307
 308         /// standard FILE handler
 309         FILE*                           _File;
 310
 311         bool                            readBuffer(void* buf, uint len)                                 { if (_File == NULL) return false; uint32 rb = (uint32)fread(buf, 1, len, _File); _ReadBytes += rb; return rb == len; }
 312         bool                            writeBuffer(const void* buf, uint len)                  { if (_File == NULL) return false; uint32 wb = (uint32)fwrite(buf, 1, len, _File); _WrittenBytes += wb; return wb == len; }
 313         bool                            readBuffer(void* buf, uint len, uint& readlen)  { if (_File == NULL) return false; readlen = (uint)fread(buf, 1, len, _File); return readlen == len; }
 314
 315         static uint64           _ReadBytes;
 316         static uint64           _WrittenBytes;
 317
 318         template<typename T>
 319         bool                            readValue(T& v)                                                                 { return readBuffer(&v, sizeof(v)); }
 320
 321         template<typename T>
 322         bool                            writeValue(const T& v)                                                  { return writeBuffer(&v, sizeof(v)); }
 323
 324 public:
 325
 326         virtual void            serialBuffer(uint8 *buf, uint len)
 327         {
 328                 if (_File == NULL)
 329                         throw NLMISC::EStream("CMixedStreamFile not opened");
 330
 331                 if (isReading())
 332                 {
 333                         if (!readBuffer(buf, len))
 334                                 throw NLMISC::EStream("file error "+NLMISC::toString(ferror(_File)));
 335                 }
 336                 else
 337                 {
 338                         if (!writeBuffer(buf, len))
 339                                 throw NLMISC::EStream("file error "+NLMISC::toString(ferror(_File)));
 340                 }
 341         }
 342
 343         virtual void            serialBit(bool &bit)
 344         {
 345                 if (isReading())
 346                 {
 347                         uint8   b;
 348                         serial(b);
 349                         bit = (b != 0);
 350                 }
 351                 else
 352                 {
 353                         uint8   b = bit;
 354                         serial(b);
 355                 }
 356         }
 357 };
 358
 359
 360
 361
 362 class CRowMapper
 363 {
 364 public:
 365
 366         /// Constructor
 367         CRowMapper();
 368
 369         /// Clear up mapper
 370         void                                    clear();
 371
 372         /// Set link
 373         void                                    link(CRowMapper* link)                          { _Link = link; }
 374
 375
 376         /// Key
 377         typedef uint64  TKey;
 378
 379
 380
 381         /**
 382          * Declares a row as allocated
 383          */
 384         bool                                    allocate(RY_PDS::TRowIndex row);
 385
 386         /**
 387          * Declares a row as deallocated
 388          */
 389         bool                                    deallocate(RY_PDS::TRowIndex row);
 390
 391         /**
 392          * Checks if a row is allocated
 393          */
 394         bool                                    allocated(RY_PDS::TRowIndex row) const;
 395
 396         /**
 397          * Get Number of Allocated rows
 398          */
 399         uint32                                  numAllocated() const                    { return _AllocatedRows; }
 400
 401         /**
 402          * Get Max row index used
 403          */
 404         RY_PDS::TRowIndex               maxRowIndex() const                             { return _RowState.size(); }
 405
 406         /**
 407          * Get Next Unalloocated row
 408          */
 409         RY_PDS::TRowIndex               nextUnallocatedRow() const;
 410
 411
 412
 413         /**
 414          * Map a key to an Row
 415          */
 416         bool                                    map(TKey key, const RY_PDS::CObjectIndex& index);
 417
 418         /**
 419          * Is Row Mapped
 420          */
 421         bool                                    isMapped(TKey key);
 422
 423         /**
 424          * Get Row from key
 425          */
 426         RY_PDS::CObjectIndex    get(TKey key) const;
 427
 428         /**
 429          * Unmap a key of an Row
 430          */
 431         bool                                    unmap(TKey key);
 432
 433         /**
 434          * Get Number of Mapped rows
 435          */
 436         uint32                                  numMapped() const                               { return (uint32)_KeyMap.size(); }
 437
 438
 439
 440 private:
 441
 442         /**
 443          * Bitset of allocated rows, each bit indicates if corresponding row is allocated
 444          */
 445         typedef NLMISC::CBitSet                                                 TRowState;
 446         TRowState               _RowState;
 447
 448         /// Total number of allocated rows
 449         uint32                  _AllocatedRows;
 450
 451         /// Key Hash
 452         class CKeyHash
 453         {
 454         public:
 455                 size_t  operator() (const TKey& key) const      { return ((uint32)key) ^ ((uint32)(key >> 32)); }
 456         };
 457
 458         typedef CHashMap<TKey, RY_PDS::CObjectIndex>    TKeyMap;
 459         TKeyMap                 _KeyMap;
 460
 461         /// Row Mapper link, in case of mapped table that inherit from another
 462         CRowMapper*             _Link;
 463 };
 464
 465
 466
 467
 468 /**
 469  * Debug/Log Interface
 470  */
 471 class CPDSLogger
 472 {
 473 public:
 474
 475         CPDSLogger() : _ParentLogger(NULL)                                      { }
 476
 477         void    setParentLogger(const CPDSLogger* parent)       { _ParentLogger = parent; }
 478
 479
 480         /**
 481          * Get Contextual Identifier String
 482          */
 483         std::string     getContextualIndentifier() const;
 484
 485 protected:
 486
 487         /**
 488          * Get Internal Logger Identifier
 489          * An identifier should ressemble like 'type:id', where type is the 'class'
 490          * of the logger, and id is a unique identifier of the instanciated object of 'class'
 491          */
 492         virtual std::string     getLoggerIdentifier() const = 0;
 493
 494 private:
 495
 496         /// Parent Logger
 497         const CPDSLogger*               _ParentLogger;
 498
 499 };
 500
 501 #define PDS_FULL_DEBUG_LEVEL    3
 502 #define PDS_NORMAL_DEBUG_LEVEL  2
 503 #define PDS_MINIMAL_DEBUG_LEVEL 1
 504 #define PDS_NO_DEBUG_LEVEL              0
 505
 506
 507 #define PDS_DEBUG_LEVEL                 PDS_FULL_DEBUG_LEVEL
 508
 509
 510 #define PDS_DEBUG_IN_L(obj, level)                                                      if (level <= 0 || !RY_PDS::PDVerbose || level > RY_PDS::PDVerboseLevel) {} else NLMISC::createDebug (), NLMISC::DebugLog->setPosition( __LINE__, __FILE__ ),    NLMISC::DebugLog->display("%s:", obj->getContextualIndentifier().c_str()),              NLMISC::DebugLog->displayNL
 511
 512 #define PDS_DEBUG_IN(obj)                                                                       PDS_DEBUG_IN_L(obj, PDS_DEBUG_LEVEL)
 513 #define PDS_INFO_IN(obj)                                                                        NLMISC::createDebug (), NLMISC::InfoLog->setPosition( __LINE__, __FILE__ ),             NLMISC::InfoLog->display("%s:", obj->getContextualIndentifier().c_str()),               NLMISC::InfoLog->displayNL
 514 #define PDS_WARNING_IN(obj)                                                                     NLMISC::createDebug (), NLMISC::WarningLog->setPosition( __LINE__, __FILE__ ),  NLMISC::WarningLog->display("%s:", obj->getContextualIndentifier().c_str()),    NLMISC::WarningLog->displayNL
 515
 516 #define PDS_DEBUG_L(level)      PDS_DEBUG_IN_L(this, level)
 517
 518 #define PDS_FULL_DEBUG          PDS_DEBUG_L(PDS_FULL_DEBUG_LEVEL)
 519 #define PDS_DEBUG                       PDS_DEBUG_L(PDS_DEBUG_LEVEL)
 520 #define PDS_INFO                        PDS_INFO_IN(this)
 521 #define PDS_WARNING                     PDS_WARNING_IN(this)
 522
 523 #define PDS_LOG_DEBUG(level)    if (level <= 0 || !RY_PDS::PDVerbose || level > RY_PDS::PDVerboseLevel) {} else nldebug
 524
 525
 526
 527 /*
 528  *
 529  */
 530
 531
 532 /*
 533  * Inlines
 534  */
 535
 536
 537 /*
 538  * Get Contextual Identifier String
 539  */
 540 inline std::string      CPDSLogger::getContextualIndentifier() const
 541 {
 542         if (_ParentLogger != NULL)
 543                 return _ParentLogger->getContextualIndentifier()+"|"+getLoggerIdentifier();
 544         else
 545                 return getLoggerIdentifier();
 546 }
 547
 548
 549
 550 /*
 551  * Constructor
 552  */
 553 inline CRowMapper::CRowMapper()
 554 {
 555         clear();
 556 }
 557
 558 /*
 559  * Clear up mapper
 560  */
 561 inline void     CRowMapper::clear()
 562 {
 563         _Link = NULL;
 564         _AllocatedRows = 0;
 565         _RowState.clearAll();
 566         _KeyMap.clear();
 567 }
 568
 569 /*
 570  * Declares a row as allocated
 571  */
 572 inline bool     CRowMapper::allocate(RY_PDS::TRowIndex row)
 573 {
 574         // check for room
 575         if (row >= _RowState.size())
 576                 _RowState.resizeNoReset(row+1);
 577
 578         // row already allocated?
 579         if (_RowState.get(row))
 580                 return false;
 581
 582         _RowState.set(row);
 583         ++_AllocatedRows;
 584
 585         return true;
 586 }
 587
 588 /*
 589  * Declares a row as deallocated
 590  */
 591 inline bool     CRowMapper::deallocate(RY_PDS::TRowIndex row)
 592 {
 593         // check bit not outside bitset
 594         if (row >= _RowState.size())
 595                 return false;
 596
 597         // row allocated?
 598         if (!_RowState.get(row))
 599                 return false;
 600
 601         _RowState.clear(row);
 602         --_AllocatedRows;
 603
 604         return true;
 605 }
 606
 607 /*
 608  * Checks if a row is allocated
 609  */
 610 inline bool     CRowMapper::allocated(RY_PDS::TRowIndex row) const
 611 {
 612         return row < _RowState.size() && _RowState.get(row);
 613 }
 614
 615
 616 /*
 617  * Get Next Unalloocated row
 618  */
 619 inline RY_PDS::TRowIndex        CRowMapper::nextUnallocatedRow() const
 620 {
 621         RY_PDS::TRowIndex       row;
 622
 623         // go through all rows till found a free row
 624         for (row=0; allocated(row); ++row)
 625                 ;
 626
 627         return row;
 628 }
 629
 630
 631
 632
 633 /*
 634  * Map a key to an Row
 635  */
 636 inline bool     CRowMapper::map(TKey key, const RY_PDS::CObjectIndex& index)
 637 {
 638         if (_Link != NULL)
 639         {
 640                 return _Link->map(key, index);
 641         }
 642
 643         if (_KeyMap.find(key) != _KeyMap.end())
 644         {
 645                 nlwarning("CRowMapper::map(): cannot map '%016" NL_I64 "X' to '%d', already mapped", key, index.toString().c_str());
 646                 return false;
 647         }
 648
 649         _KeyMap[key] = index;
 650
 651         return true;
 652 }
 653
 654 /*
 655  * Is Row Mapped
 656  */
 657 inline bool     CRowMapper::isMapped(TKey key)
 658 {
 659         if (_Link != NULL)
 660         {
 661                 return _Link->isMapped(key);
 662         }
 663
 664         return (_KeyMap.find(key) != _KeyMap.end());
 665 }
 666
 667 /*
 668  * Get Row from key
 669  */
 670 inline RY_PDS::CObjectIndex     CRowMapper::get(TKey key) const
 671 {
 672         if (_Link != NULL)
 673         {
 674                 return _Link->get(key);
 675         }
 676
 677         TKeyMap::const_iterator it = _KeyMap.find(key);
 678
 679         if (it == _KeyMap.end())
 680         {
 681                 PDS_LOG_DEBUG(1)("CRowMapper::get(): key '%016" NL_I64 "X' not mapped", key);
 682                 return RY_PDS::CObjectIndex::null();
 683         }
 684
 685         return (*it).second;
 686 }
 687
 688 /*
 689  * Unmap a key of an Row
 690  */
 691 inline bool     CRowMapper::unmap(TKey key)
 692 {
 693         if (_Link != NULL)
 694         {
 695                 return _Link->unmap(key);
 696         }
 697
 698         TKeyMap::iterator       it = _KeyMap.find(key);
 699
 700         if (it == _KeyMap.end())
 701         {
 702                 nlwarning("CRowMapper::unmap(): key '%016" NL_I64 "X' not mapped", key);
 703                 return false;
 704         }
 705
 706         _KeyMap.erase(it);
 707
 708         return true;
 709 }
 710
 711
 712 #endif //RY_PDS_LIB_H
 713
 714
 715