ZGPeerSettings.h

Go to the documentation of this file.

#ifndef ZGPeerSettings_h
#define ZGPeerSettings_h

#include "zg/ZGNameSpace.h"
#include "message/Message.h"

namespace zg_private
{
   class PZGHeartbeatThreadState;  // forward declaration
};

namespace zg
{

enum {
   PEER_TYPE_FULL_PEER = 0,  // a full peer is one that is able to become senior peer if necessary
   PEER_TYPE_JUNIOR_ONLY,    // a junior-only peer is one that wants to follow along as a junior peer but doesn't want to be senior
   NUM_PEER_TYPES
};

class ZGPeerSettings
{
public:
   ZGPeerSettings(const String & systemName, uint8 numDatabases, bool systemIsOnLocalhostOnly, uint16 peerType = PEER_TYPE_FULL_PEER)
      : _systemName(systemName)
      , _numDatabases(numDatabases)
      , _systemIsOnLocalhostOnly(systemIsOnLocalhostOnly)
      , _peerType(peerType)
      , _heartbeatsPerSecond(6)  // setting this at >5 avoids the great MacOS/X WiFi-PowerSave-on-200mS-idle problem
      , _heartbeatsBeforeFullyAttached(4)
      , _maxMissingHeartbeats(4)
      , _beaconsPerSecond(4)
      , _outgoingHeartbeatPacketIDCounter(0)
   {
      // empty
   }

   const String & GetSystemName()              const {return _systemName;}

   uint8 GetNumDatabases()                     const {return _numDatabases;}

   bool IsSystemOnLocalhostOnly()              const {return _systemIsOnLocalhostOnly;}

   const ConstMessageRef & GetPeerAttributes() const {return _optPeerAttributes;}

   uint16 GetPeerType()                        const {return _peerType;}

   uint32 GetHeartbeatsPerSecond()             const {return _heartbeatsPerSecond;}

   uint32 GetMaxNumMissingHeartbeats()         const {return _maxMissingHeartbeats;}

   uint32 GetHeartbeatsBeforeFullyAttached()   const {return _heartbeatsBeforeFullyAttached;}

   uint32 GetBeaconsPerSecond()                const {return _beaconsPerSecond;}

   void SetPeerAttributes(const ConstMessageRef & peerAttributes) {_optPeerAttributes = peerAttributes;}

   void SetHeartbeatsPerSecond(uint32 hps) {_heartbeatsPerSecond = hps;}

   void SetHeartbeatsBeforeFullyAttached(uint32 hb) {_heartbeatsBeforeFullyAttached = hb;}

   void SetMaxNumMissingHeartbeats(uint32 hb) {_maxMissingHeartbeats = hb;}

   void SetBeaconsPerSecond(uint32 bps) {_beaconsPerSecond = bps;}

   void SetMaximumUpdateLogSizeForDatabase(uint32 whichDB, uint64 maxNumBytes) {(void) _maxUpdateLogSizeBytes.PutOrRemove(whichDB, maxNumBytes);}

   uint64 GetMaximumUpdateLogSizeForDatabase(uint32 whichDB) const {return _maxUpdateLogSizeBytes.GetWithDefault(whichDB, 2*1024*1024);}

private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
   friend class zg_private::PZGHeartbeatThreadState;
#endif

   String _systemName;                 // Name of the ZG system we are to participate in
   uint8 _numDatabases;                // how many databases we want to maintain
   bool _systemIsOnLocalhostOnly;      // true iff we are simulating the system on a single host
   ConstMessageRef _optPeerAttributes; // optional user-specified descriptive attributes for this peer (should be small)
   uint16 _peerType;                   // PEER_TYPE_* value for this peer
   uint32 _heartbeatsPerSecond;        // how many heartbeats we should send per second (and expect to receive per second, from each peer)
   uint32 _heartbeatsBeforeFullyAttached;  // how many heartbeat-periods we should allow to elapse before declaring ourselves fully part of the system.
   uint32 _maxMissingHeartbeats;       // how many heartbeat-periods must go by without receiving a heartbeat from a peer, before we declare him offline
   uint32 _beaconsPerSecond;           // how many beacon-packets we should send out per second if we are the senior peer
   Hashtable<uint32, uint64> _maxUpdateLogSizeBytes;
   mutable uint32 _outgoingHeartbeatPacketIDCounter;
};

};  // end namespace zg

#endif