ZGPeerSession.h

Go to the documentation of this file.

#ifndef ZGPeerSession_h
#define ZGPeerSession_h

#include "reflector/StorageReflectSession.h"
#include "system/DetectNetworkConfigChangesSession.h"  // for INetworkConfigChangesTarget

#include "zg/INetworkTimeProvider.h"
#include "zg/ZGPeerID.h"
#include "zg/ZGPeerSettings.h"
#include "zg/ZGStdinSession.h"               // for ITextCommandReceiver

#include "zg/private/PZGBeaconData.h"
#include "zg/private/PZGDatabaseState.h"
#include "zg/private/PZGDatabaseUpdate.h"
#include "zg/private/PZGUpdateBackOrderKey.h"

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

namespace zg
{

class ZGPeerSession : public StorageReflectSession, public ITextCommandReceiver, public INetworkConfigChangesTarget, public INetworkTimeProvider
{
public:
   ZGPeerSession(const ZGPeerSettings & peerSettings);

   virtual status_t AttachedToServer();

   virtual void AboutToDetachFromServer();

   virtual void EndSession();

   virtual uint64 GetPulseTime(const PulseArgs & args);

   virtual void Pulse(const PulseArgs & args);

   virtual bool IsReadyForTextCommands() const {return _iAmFullyAttached;}

   virtual bool TextCommandReceived(const String & text);

   bool IAmTheSeniorPeer() const;

   const ZGPeerSettings & GetPeerSettings() const {return _peerSettings;}

   virtual void NetworkInterfacesChanged(const Hashtable<String, Void> & optInterfaceNames) {(void) optInterfaceNames;}

   virtual void ComputerIsAboutToSleep() {_iAmFullyAttached = false;}  // we'll re-fully-attach after we wake up again

   virtual void ComputerJustWokeUp() {/* empty */}

   bool IAmFullyAttached() const {return _iAmFullyAttached;}

   virtual void LocalSeniorPeerStatusChanged();

   const ZGPeerID & GetLocalPeerID() const {return _localPeerID;}

   const ZGPeerID & GetSeniorPeerID() const {return _seniorPeerID;}

   virtual uint64 GetNetworkTime64() const {return _iAmFullyAttached ? GetNetworkTime64ForRunTime64(GetRunTime64()) : 0;}

   virtual uint64 GetRunTime64ForNetworkTime64(uint64 networkTime64TimeStamp) const {return (networkTime64TimeStamp==MUSCLE_TIME_NEVER)?MUSCLE_TIME_NEVER:(networkTime64TimeStamp-GetToNetworkTimeOffset());}

   virtual uint64 GetNetworkTime64ForRunTime64(uint64 runTime64TimeStamp) const {return (runTime64TimeStamp==MUSCLE_TIME_NEVER)?MUSCLE_TIME_NEVER:(runTime64TimeStamp+GetToNetworkTimeOffset());}

   virtual int64 GetToNetworkTimeOffset() const;

   const Hashtable<ZGPeerID, ConstMessageRef> & GetOnlinePeers() const {return _onlinePeers;}

   bool IsPeerOnline(const ZGPeerID & peerID) const;

   uint64 GetEstimatedLatencyToPeer(const ZGPeerID & peerID) const;

protected:
   status_t RequestResetDatabaseStateToDefault(uint32 whichDatabase);

   status_t RequestReplaceDatabaseState(uint32 whichDatabase, const MessageRef & newDatabaseStateMsg);

   status_t RequestUpdateDatabaseState(uint32 whichDatabase, const MessageRef & databaseUpdateMsg);

   virtual void MessageReceivedFromGateway(const MessageRef & msg, void * userData);

   virtual void ResetLocalDatabaseToDefault(uint32 whichDatabase, uint32 & dbChecksum) = 0;

   virtual ConstMessageRef SeniorUpdateLocalDatabase(uint32 whichDatabase, uint32 & dbChecksum, const ConstMessageRef & seniorDoMsg) = 0;

   virtual status_t JuniorUpdateLocalDatabase(uint32 whichDatabase, uint32 & dbChecksum, const ConstMessageRef & juniorDoMsg) = 0;

   virtual MessageRef SaveLocalDatabaseToMessage(uint32 whichDatabase) const = 0;

   virtual status_t SetLocalDatabaseFromMessage(uint32 whichDatabase, uint32 & dbChecksum, const ConstMessageRef & newDBStateMsg) = 0;

   virtual uint32 CalculateLocalDatabaseChecksum(uint32 whichDatabase) const = 0;

   virtual String GetLocalDatabaseContentsAsString(uint32 whichDatabase) const;

   virtual void PeerHasComeOnline(const ZGPeerID & peerID, const ConstMessageRef & peerInfo);

   virtual void PeerHasGoneOffline(const ZGPeerID & peerID, const ConstMessageRef & peerInfo);

   virtual void SeniorPeerChanged(const ZGPeerID & oldSeniorPeerID, const ZGPeerID & newSeniorPeerID);

   status_t SendMulticastUserMessageToAllPeers(const MessageRef & msg);

   status_t SendUnicastUserMessageToAllPeers(const MessageRef & msg);

   status_t SendUnicastUserMessageToPeer(const ZGPeerID & destinationPeerID, const MessageRef & msg);

   void PrintDatabaseStateInfo(int32 whichDatabase = -1) const;

   void PrintDatabaseUpdateLog(int32 whichDatabase = -1) const;

private:
   void ScheduleSetBeaconData();
   void ShutdownChildSessions();
   status_t SendRequestToSeniorPeer(uint32 whichDatabase, uint32 whatCode, const MessageRef & userMsg);
   status_t HandleDatabaseUpdateRequest(const ZGPeerID & fromPeerID, const MessageRef & msg, bool isMessageMeantForSeniorPeer);
   status_t SendDatabaseUpdateViaMulticast(const zg_private::ConstPZGDatabaseUpdateRef  & dbUp);
   status_t RequestBackOrderFromSeniorPeer(const zg_private::PZGUpdateBackOrderKey & ubok);
   zg_private::ConstPZGBeaconDataRef GetNewSeniorBeaconData() const;

   // These methods are called from the PZGNetworkIOSession code
   void MessageReceivedFromPeer(const ZGPeerID & peerID, const MessageRef & msg);
   void BeaconDataChanged(const zg_private::ConstPZGBeaconDataRef & beaconData);
   void BackOrderResultReceived(const zg_private::PZGUpdateBackOrderKey & ubok, const zg_private::ConstPZGDatabaseUpdateRef & optUpdateData);
   zg_private::ConstPZGDatabaseUpdateRef GetDatabaseUpdateByID(uint32 whichDatabase, uint64 updateID) const;

   const ZGPeerSettings _peerSettings;

   const ZGPeerID _localPeerID;
   ZGPeerID _seniorPeerID;

   AbstractReflectSessionRef _networkIOSession;
   bool _iAmFullyAttached;

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
   friend class zg_private::PZGDatabaseState;
   friend class zg_private::PZGNetworkIOSession;
#endif

   Queue<zg_private::PZGDatabaseState> _databases;
   bool _setBeaconDataPending;

   Hashtable<ZGPeerID, ConstMessageRef> _onlinePeers;
};
DECLARE_REFTYPES(ZGPeerSession);

};  // end namespace zg

#endif