source-engine/public/gcsdk/msgprotobuf.h

//====== Copyright <EFBFBD> 1996-2004, Valve Corporation, All rights reserved. =======
//
// Purpose: 
//
//=============================================================================

#ifndef MSGPROTOBUF_H
#define MSGPROTOBUF_H
#ifdef _WIN32
#pragma once
#endif

#include "msgbase.h"
#include "gcmsg.h"
#include "tier0/tslist.h"

// eliminates a conflict with TYPE_BOOL in OSX
#ifdef TYPE_BOOL
#undef TYPE_BOOL
#endif

#pragma warning(push)
#pragma warning( disable:4512 )
#include <tier0/valve_minmax_off.h>
#include "steammessages.pb.h"
#include <tier0/valve_minmax_on.h>
#pragma warning(pop)


namespace GCSDK
{

//-----------------------------------------------------------------------------
// CProtoBufNetPacket
// Thin wrapper around raw CNetPacket which implements our IMsgNetPacket interface.
//-----------------------------------------------------------------------------
class CProtoBufNetPacket : public IMsgNetPacket
{
#ifdef GC
	DECLARE_CLASS_MEMPOOL( CProtoBufNetPacket );
#endif

public:
	CProtoBufNetPacket( CNetPacket *pNetPacket, GCProtoBufMsgSrc eReplyType, const CSteamID steamID, uint32 nGCDirIndex, MsgType_t msgType );

	//IMsgNetPacket

	virtual EMsgFormatType GetEMsgFormatType() const OVERRIDE { return k_EMsgFormatTypeProtocolBuffer; }
	virtual CNetPacket *GetCNetPacket() const OVERRIDE { return m_pNetPacket; }
	virtual uint8 *PubData() const OVERRIDE { return m_pNetPacket->PubData(); }
	virtual uint CubData() const OVERRIDE { return m_pNetPacket->CubData(); }

	virtual MsgType_t GetEMsg() const OVERRIDE { return m_msgType; }
	virtual JobID_t GetSourceJobID() const OVERRIDE { return m_pHeader->job_id_source(); }
	virtual JobID_t GetTargetJobID() const OVERRIDE { return m_pHeader->job_id_target(); }
	virtual void SetTargetJobID( JobID_t ulJobID ) OVERRIDE { m_pHeader->set_job_id_target( ulJobID ); }

	virtual CSteamID GetSteamID() const OVERRIDE { return m_steamID; }
	virtual void SetSteamID( CSteamID steamID ) OVERRIDE { m_steamID = steamID; }

	virtual AppId_t GetSourceAppID() const OVERRIDE { return m_pHeader->source_app_id(); };
	virtual void SetSourceAppID( AppId_t appId ) OVERRIDE { m_pHeader->set_source_app_id( appId ); }

	virtual bool BHasTargetJobName() const OVERRIDE { return m_pHeader->has_target_job_name(); }
	virtual const char *GetTargetJobName() const OVERRIDE { return m_pHeader->target_job_name().c_str(); }


	bool IsValid() const { return m_bIsValid; }
	ProtoBufMsgHeader_t &GetFixedHeader() const { return *( ( ProtoBufMsgHeader_t * )PubData() ); }
	CMsgProtoBufHeader *GetProtoHeader() const { return m_pHeader; }

	//called to obtain access to the body portion of the net packet associated with this message. Will return NULL if not in a valid state
	bool GetMsgBody( const uint8*& pubData, uint32& cubData ) const;

private:
	virtual ~CProtoBufNetPacket();

	CNetPacket *m_pNetPacket;
	CMsgProtoBufHeader *m_pHeader;
	CSteamID  m_steamID; 
	MsgType_t m_msgType;
	bool m_bIsValid;
};


//-----------------------------------------------------------------------------
// CProtoBufMsgBase - Base class for templated protobuf msgs. As much code is
//	in this class as possible to reduce template copy overhead
//-----------------------------------------------------------------------------
class CProtoBufMsgBase
{
public:
	// allows any kind of destination to be the target of an AsyncSend
	class IProtoBufSendHandler
	{
	public:
		virtual bool BAsyncSend( MsgType_t eMsg, const uint8 *pubMsgBytes, uint32 cubSize ) = 0;
	};

	// Receive constructor. We expect InitFromPacket will be called later
	CProtoBufMsgBase();
	// Send constructor. InitFromPacket must not be called later
	CProtoBufMsgBase( MsgType_t eMsgType );

	virtual ~CProtoBufMsgBase();

	bool InitFromPacket( IMsgNetPacket * pNetPacket );
	bool BAsyncSend( IProtoBufSendHandler & pSender ) const;
	bool BAsyncSendWithPreSerializedBody( IProtoBufSendHandler & pSender, const byte *pubBody, uint32 cubBody ) const;
	//free standing version to send a protobuff given a header and pre-serialized body. Primarily used for efficient message routing
	static bool BAsyncSendWithPreSerializedBody( IProtoBufSendHandler& sender, MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const byte* pubBody, uint32 cubBody );
	//similar to the above, but sends a protobuf object that will be serialized into the buffer
	static bool BAsyncSendProto( IProtoBufSendHandler& sender, MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const ::google::protobuf::Message& proto );

	CMsgProtoBufHeader		 &Hdr()				{ return *m_pProtoBufHdr; }
	const CMsgProtoBufHeader &Hdr() const		{ return *m_pProtoBufHdr; }
	const CMsgProtoBufHeader &ConstHdr() const	{ return *m_pProtoBufHdr; }

	MsgType_t	GetEMsg()			const		{ return m_eMsg & (~k_EMsgProtoBufFlag); }
	CSteamID	GetClientSteamID()	const		{ return CSteamID( m_pProtoBufHdr->client_steam_id() ); }
	JobID_t		GetJobIDTarget()	const		{ return m_pProtoBufHdr->job_id_target(); }
	JobID_t		GetJobIDSource()	const		{ return m_pProtoBufHdr->job_id_source(); }
	AppId_t		GetSourceAppID()	const		{ return m_pProtoBufHdr->source_app_id(); }
	bool		BIsExpectingReply()	const		{ return GetJobIDSource() != k_GIDNil; }

	void SetJobIDSource( JobID_t jobId )		{ m_pProtoBufHdr->set_job_id_source( jobId ); }
	void SetJobIDTarget( JobID_t jobId )		{ m_pProtoBufHdr->set_job_id_target( jobId ); }
	void SetSourceAppID( AppId_t appId )		{ m_pProtoBufHdr->set_source_app_id( appId ); }
	void ExpectingReply( JobID_t jobId )		{ SetJobIDSource( jobId ); }

	EResult		GetEResult() const { return (EResult)ConstHdr().eresult(); }
	void		SetEResult( EResult eResult ) { Hdr().set_eresult( eResult ); }
	const char *GetErrorMessage() const { return ConstHdr().error_message().c_str(); }
	void		SetErrorMessage( const char *pchErrorMessage ) { Hdr().set_error_message( pchErrorMessage ); }
	void		AppendErrorMessage( const char *pchErrorMessage ) { Hdr().mutable_error_message()->append( pchErrorMessage ); }

	// Must be implemented by subclasses. Returns the body. The templated subclasses have their
	// own body accessor that returns the body as the specific type
	virtual ::google::protobuf::Message *GetGenericBody() const = 0;

protected:

	// Mutex to use when registering a new pool type
	static CThreadMutex s_PoolRegMutex;

private:

	//utility function that handles allocating a memory pool big enough for the provided header and specified body
	//size and writing the header into the pool. This will return a pointer to the memory, as well as the header size.
	static uint8* AllocateMessageMemory( MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, uint32 cubBodySize, uint32* pCubTotalSizeOut );
	//called to free the memory returned by allocate message memory
	static void FreeMessageMemory( uint8* pMemory );
	
	// Pointer to an external net packet if we have one. If we have one then we will
	// not have allocated m_pProtoBufHdr ourselves
	CProtoBufNetPacket *m_pNetPacket;

	// Protobuf objects for extended pb based header
	CMsgProtoBufHeader *m_pProtoBufHdr;

	// Our message type
	MsgType_t m_eMsg;

	// Private and unimplemented. Implement these if you want to be able to copy
	// these objects.
	CProtoBufMsgBase( const CProtoBufMsgBase& );
	CProtoBufMsgBase& operator=( const CProtoBufMsgBase& );
};


//-----------------------------------------------------------------------------
// CProtoBufMsgMemoryPoolBase - Interface to allocation pools for each protobufmsg type
//-----------------------------------------------------------------------------
class CProtoBufMsgMemoryPoolBase
{
public:
	CProtoBufMsgMemoryPoolBase( uint32 unTargetLow, uint32 unTargetHigh );
	virtual ~CProtoBufMsgMemoryPoolBase();

	// Memory interface
	::google::protobuf::Message *Alloc();
	void Free( ::google::protobuf::Message *pMsg );

	// Stats
	uint32 GetEstimatedSize();
	uint32 GetAllocated()			{ return m_unAllocated; }
	uint32 GetFree()				{ return m_pTSQueueFreeObjects->Count(); }
	uint32 GetAllocHitCount()		{ return m_unAllocHitCounter; }
	uint32 GetAllocMissCount()		{ return m_unAllocMissCounter; }

	// To be overriden by the templated class
	virtual CUtlString GetName() = 0;

protected:
	// The actual memory management. Must be overriden by the templated class
	virtual google::protobuf::Message *InternalAlloc() = 0;
	virtual void InternalFree( google::protobuf::Message *pMsg ) = 0;
	
	// Called by the derived destructor to deallocate the outstanding messages
	bool PopItem( google::protobuf::Message **ppMsg );

private:
	CTSQueue<google::protobuf::Message *> *m_pTSQueueFreeObjects;

	// These counters are important to get correct, so interlocked in case of allocating on threads
	CInterlockedInt m_unAllocHitCounter;
	CInterlockedInt m_unAllocMissCounter;
	CInterlockedInt m_unAllocated;

	// Only set at construction, so not needed to be thread safe
	uint32 m_unTargetCountLow;
	uint32 m_unTargetCountHigh;
};

} // namespace GCDSK

// The rest of the file needs memdbgon because the code in the templates do actual allocation
#include "tier0/memdbgon.h"

namespace GCSDK
{

//-----------------------------------------------------------------------------
// CProtoBufMsgMemoryPool - Implementation for allocation pools for protobufmsgs.
// We create one of these per protobuf msg type, created on first construction of
// an object of that type.
//-----------------------------------------------------------------------------
template< typename PB_OBJECT_TYPE > 
class CProtoBufMsgMemoryPool : public CProtoBufMsgMemoryPoolBase
{
public:
	CProtoBufMsgMemoryPool()
		: CProtoBufMsgMemoryPoolBase( PB_OBJECT_TYPE::descriptor()->options().GetExtension( msgpool_soft_limit ), 
									  PB_OBJECT_TYPE::descriptor()->options().GetExtension( msgpool_hard_limit ) ) {}
	virtual ~CProtoBufMsgMemoryPool()
	{
		google::protobuf::Message *pObject = NULL;
		while ( PopItem( &pObject ) )
		{
			InternalFree( pObject );
		}
	}

	virtual CUtlString GetName() OVERRIDE
	{ 
		return PB_OBJECT_TYPE::default_instance().GetTypeName().c_str(); 
	}

private:
	virtual ::google::protobuf::Message *InternalAlloc()
	{
		PB_OBJECT_TYPE *pObject = (PB_OBJECT_TYPE *)malloc( sizeof( PB_OBJECT_TYPE ) );
		Construct( pObject );
		return pObject;
	}

	virtual void InternalFree( google::protobuf::Message *pMsg )
	{
		if ( NULL == pMsg )
		{
			Assert( NULL != pMsg );
			return;
		}

		PB_OBJECT_TYPE *pObject = (PB_OBJECT_TYPE *)pMsg;
		Destruct( pObject );
		FreePv( pObject );
	}
};


//-----------------------------------------------------------------------------
// CProtoBufMsgMemoryPoolMgr - Manages all the message pools for protobufmsgs.  
// Should have one global singleton instance of this which tracks all the pools
// for individual message types.
//-----------------------------------------------------------------------------
class CProtoBufMsgMemoryPoolMgr
{
public:
	CProtoBufMsgMemoryPoolMgr();
	~CProtoBufMsgMemoryPoolMgr();

	void RegisterPool( CProtoBufMsgMemoryPoolBase *pPool );
	void DumpPoolInfo();

	CMsgProtoBufHeader *AllocProtoBufHdr()					{ return (CMsgProtoBufHeader *)m_PoolHeaders.Alloc(); }
	void FreeProtoBufHdr( CMsgProtoBufHeader *pObject )		{ m_PoolHeaders.Free( pObject ); }

private:
	CProtoBufMsgMemoryPool<CMsgProtoBufHeader> m_PoolHeaders;
	CUtlVector< CProtoBufMsgMemoryPoolBase * > m_vecMsgPools;
};

extern CProtoBufMsgMemoryPoolMgr *GProtoBufMsgMemoryPoolMgr();


//-----------------------------------------------------------------------------
// CProtoBufPtrMsg
// Similar to a CProtoBufMsg, but the constructor simply takes in a pointer which is a
// pointer to the protobuf object that is being wrapped by a message. This memory is managed
// by the caller, this object does nothing to free the memory
//-----------------------------------------------------------------------------
class CProtoBufPtrMsg : public CProtoBufMsgBase
{
public:
	CProtoBufPtrMsg( google::protobuf::Message *pProto ) : m_pProtoBufBody( pProto )	{}

private:
	virtual google::protobuf::Message *GetGenericBody() const OVERRIDE { return m_pProtoBufBody; }

	// Protobuf object for the message body
	google::protobuf::Message *m_pProtoBufBody;

	// Private and unimplemented. Implement these if you want to be able to copy
	// these objects.
	CProtoBufPtrMsg( const CProtoBufPtrMsg& );
	CProtoBufPtrMsg& operator=( const CProtoBufPtrMsg& );
};


//-----------------------------------------------------------------------------
// CProtoBufMsg
// New style steam inter-server message class based on Google Protocol Buffers
// Handles a message with a header of type MsgHdr_t, a body of type T, and optional variable length data
//-----------------------------------------------------------------------------
template< typename PB_OBJECT_TYPE > 
class CProtoBufMsg : public CProtoBufMsgBase
{
private:
	static bool s_bRegisteredWithMemoryPoolMgr;
	static CProtoBufMsgMemoryPool< PB_OBJECT_TYPE > *s_pMemoryPool;

public:

	// Used to alloc a protobuf of this type from the pool. Can be used by functions
	// working with protobufs that aren't messages to take advantage of pooling
	static PB_OBJECT_TYPE *AllocProto()
	{
		// If we haven't done registration do so now
		// Called on construction of each object of this type, but only does work
		// once to setup memory pools for the class type.
		if ( !s_bRegisteredWithMemoryPoolMgr )
		{
			// Get the lock and make sure we still haven't
			s_PoolRegMutex.Lock();
			if ( !s_bRegisteredWithMemoryPoolMgr )
			{
				s_pMemoryPool = new CProtoBufMsgMemoryPool< PB_OBJECT_TYPE >();
				GProtoBufMsgMemoryPoolMgr()->RegisterPool( s_pMemoryPool );
				s_bRegisteredWithMemoryPoolMgr = true;
			}
			s_PoolRegMutex.Unlock();
		}

		return static_cast<PB_OBJECT_TYPE *>( s_pMemoryPool->Alloc() );
	}

	// Frees a protobuf allocated with AllocProto()
	static void FreeProto( PB_OBJECT_TYPE *pbObj )
	{
		s_pMemoryPool->Free( pbObj );
	}


	// Constructor for an empty message
	CProtoBufMsg( MsgType_t eMsg ) 
		: CProtoBufMsgBase( eMsg )
		, m_pProtoBufBody( NULL )
	{ 
		VPROF_BUDGET( "CProtoBufMsg::CProtoBufMsg( MsgType_t )", VPROF_BUDGETGROUP_OTHER_NETWORKING );
		m_pProtoBufBody = AllocProto();
	}

	// Constructor for an empty message responding to a client
	CProtoBufMsg( MsgType_t eMsg, CSteamID steamIDClient, int32 nSessionIDClient ) 
		: CProtoBufMsgBase( eMsg )
		, m_pProtoBufBody( NULL )
	{ 
		VPROF_BUDGET( "CProtoBufMsg::CProtoBufMsg( MsgType_t, CSteamID, int32 )", VPROF_BUDGETGROUP_OTHER_NETWORKING );

		m_pProtoBufBody = AllocProto();
		Hdr()->set_client_steam_id( steamIDClient.ConvertToUint64() );
		Hdr()->set_client_session_id( nSessionIDClient );
	}

	// Constructor from an incoming netpacket
	CProtoBufMsg( IMsgNetPacket *pNetPacket )
		: CProtoBufMsgBase()
		, m_pProtoBufBody( NULL )
	{
		m_pProtoBufBody = AllocProto();
		InitFromPacket( pNetPacket );
	}

	// constructor for use in catching replies or any other place where you have nothing to stuff in
	// the message at construct time
	CProtoBufMsg()
		: CProtoBufMsgBase()
		, m_pProtoBufBody( NULL )
	{
		m_pProtoBufBody = AllocProto();
	}

	// Constructor for replying to another protobuf message
	CProtoBufMsg( MsgType_t eMsg, const CProtoBufMsgBase & msgReplyingTo )
		: CProtoBufMsgBase( eMsg )
		, m_pProtoBufBody( NULL )
	{
		VPROF_BUDGET( "CProtoBufMsg::CProtoBufMsg( EMsg, CProtoBufMsgMemoryPoolBase )", VPROF_BUDGETGROUP_OTHER_NETWORKING );
		m_pProtoBufBody = AllocProto();

		// set up the actual reply
		SetJobIDTarget( msgReplyingTo.GetJobIDSource() );
	}

	// Destructor
	virtual ~CProtoBufMsg()
	{
		if ( m_pProtoBufBody )
		{
			FreeProto( m_pProtoBufBody );
			m_pProtoBufBody = NULL;
		}
	}

	// Accessors
	PB_OBJECT_TYPE &Body() { return *m_pProtoBufBody; }
	const PB_OBJECT_TYPE &Body() const { return *m_pProtoBufBody; }

private:
	virtual google::protobuf::Message *GetGenericBody() const OVERRIDE { return m_pProtoBufBody; }

	// Protobuf object for the message body
	PB_OBJECT_TYPE *m_pProtoBufBody;

	// Private and unimplemented. Implement these if you want to be able to copy
    // these objects.
    CProtoBufMsg( const CProtoBufMsg& );
    CProtoBufMsg& operator=( const CProtoBufMsg& );
};

// Statics
template< typename PB_OBJECT_TYPE > bool CProtoBufMsg< PB_OBJECT_TYPE>::s_bRegisteredWithMemoryPoolMgr = false;
template< typename PB_OBJECT_TYPE > CProtoBufMsgMemoryPool< PB_OBJECT_TYPE > *CProtoBufMsg< PB_OBJECT_TYPE>::s_pMemoryPool = NULL;


//-----------------------------------------------------------------------------
// Purpose: Wrapper class to handle alloc/free using the pool allocators
//-----------------------------------------------------------------------------
template <class TMsg>
class CProtoBufPoolObj
{
private:
	TMsg *m_pMsg;

private: // Disallow copying/assignment
	CProtoBufPoolObj( CProtoBufPoolObj const &x );
	CProtoBufPoolObj & operator = ( CProtoBufPoolObj const &x );

public:
	CProtoBufPoolObj()				{ m_pMsg = CProtoBufMsg<TMsg>::AllocProto(); }
	~CProtoBufPoolObj()				{ CProtoBufMsg<TMsg>::FreeProto( m_pMsg ); }

	operator TMsg & () { return *m_pMsg; }
};


} // namespace GCSDK

// memdbgon is only supposed to be on in cpp files, turn it off in case the next thing includes has a conflict with it
#include "tier0/memdbgoff.h"

#endif // MSGPROTOBUF_H