diff options
Diffstat (limited to 'public/gcsdk/gcbase.h')
| -rw-r--r-- | public/gcsdk/gcbase.h | 834 |
1 files changed, 834 insertions, 0 deletions
diff --git a/public/gcsdk/gcbase.h b/public/gcsdk/gcbase.h new file mode 100644 index 0000000..fbefbc0 --- /dev/null +++ b/public/gcsdk/gcbase.h @@ -0,0 +1,834 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef GCBASE_H +#define GCBASE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "gamecoordinator/igamecoordinator.h" +#include "gamecoordinator/igamecoordinatorhost.h" +#include "tier1/utlallocation.h" +#include "gcmsg.h" +#include "jobmgr.h" +#include "tier1/thash.h" +#include "tier1/UtlSortVector.h" +#include "http.h" +#include "language.h" +#include "accountdetails.h" +#include "gcsession.h" + +class CGCMsgGetSystemStatsResponse; + +extern EUniverse GetUniverse(); + +const int16 k_nLockTypeLobby = 3; +const int16 k_nLockTypeParty = 2; +const int16 k_nLockTypeIndividual = 1; +const int16 k_nLockTypeGameServer = 0; +const int16 k_nLockTypeGroupIDGeneration = -1; + // For one-off locks of specific resources. The specific game controls the subtype ordering. +const int16 k_nLockTypeGameMisc = -10; + +namespace GCSDK +{ +class CGCSession; +class CGCUserSession; +class CGCGSSession; +class CGCSharedObjectCache; +class CSharedObject; +class CAccountDetails; +class CScopedSteamIDLock; + +struct PackageLicense_t +{ + uint32 m_unPackageID; + RTime32 m_rtimeCreated; +}; + +#define SERVER_KEY_HASH 0x5a4f4944u + +class CGCBase : public IGameCoordinator +{ +public: + CGCBase( ); + virtual ~CGCBase(); + + // Hooks to extend the base behaviors of the IGameCoordinator interface + virtual bool OnInit() { return true; } + virtual bool OnMainLoopOncePerFrame( CLimitTimer &limitTimer ) { return false; } + virtual bool OnMainLoopUntilFrameCompletion( CLimitTimer &limitTimer ) { return false; } + virtual void OnUninit() {} + // returns true if this function handled the message + virtual bool OnMessageFromClient( const CSteamID & senderID, uint32 unMsgType, void *pubData, uint32 cubData ) { return false; } + virtual void OnValidate( CValidator &validator, const char *pchName ) {} + virtual const char *LocalizeToken( const char *pchToken, ELanguage eLanguage, bool bReturnTokenIfNotFound = true ) { return bReturnTokenIfNotFound ? pchToken : NULL; } + + virtual void YldOnAccountPhoneVerificationChange( CSteamID steamID ) {} + virtual void YldOnAccountTwoFactorChange( CSteamID steamID ) {} + + /// The main loop calls Run() on game servers and user sessions until a certain amount of time + /// is expired. Thus the user list is iterated, but the iteration is amortized over multiple frames. + /// this function is called when a sweep of the user sessions ends and a new one is about to begin. + virtual void FinishedMainLoopUserSweep(); + + // Life cycle management functions + + // Called to do any yielding initialization work before reporting as fully operational + virtual bool BYieldingFinishStartup() = 0; + + // Called to do any yielding work immediately after becoming full operational + virtual bool BYieldingPostStartup() = 0; + + // Call to report that we're fully operational + void SetStartupComplete( bool bSuccess ); + + // Called to do any yielding work before reporting as ready to shutdown + virtual void YieldingGracefulShutdown() = 0; + + + virtual CGCUserSession *CreateUserSession( const CSteamID & steamID, CGCSharedObjectCache *pSOCache ) const; + virtual CGCGSSession *CreateGSSession( const CSteamID & steamID, CGCSharedObjectCache *pSOCache, uint32 unServerAddr, uint16 usServerPort ) const; + virtual void YieldingSessionStartPlaying( CGCUserSession *pSession ) {} + virtual void YieldingSessionStopPlaying( CGCUserSession *pSession ) {} + virtual void YieldingSessionStartServer( CGCGSSession *pSession ) {} + virtual void YieldingSessionStopServer( CGCGSSession *pSession ) {} + virtual void YieldingSOCacheLoaded( CGCSharedObjectCache *pSOCache ); + virtual void UpdateGSSessionAddress( CGCGSSession *pSession, uint32 unServerAddr, uint16 usServerPort ); + + virtual void YieldingPreTestSetup() {} + + // cache management + CGCSharedObjectCache *YieldingGetLockedSOCache( const CSteamID &steamID, const char *pszFilename, int nLineNum ); + CGCSharedObjectCache *YieldingFindOrLoadSOCache( const CSteamID &steamID ); + CGCSharedObjectCache *FindSOCache( const CSteamID & steamID ); // non-yielding, but may return NULL if the cache exists but is not loaded + bool UnloadUnusedCaches( uint32 unMaxCacheCount, CLimitTimer *pLimitTimer = NULL ); + void YieldingReloadCache( CGCSharedObjectCache *pSOCache ); + virtual CGCSharedObjectCache *CreateSOCache( const CSteamID &steamID ); + void FlushInventoryCache( AccountID_t unAccountID ); + + CGCUserSession *YieldingGetLockedUserSession( const CSteamID & steamID, const char *pszFilename, int nLineNum ); + CGCUserSession *FindUserSession( const CSteamID & steamID ) const; + bool BUserSessionPending( const CSteamID & steamID ) const; + + CGCGSSession *YieldingGetLockedGSSession( const CSteamID & steamID, const char *pszFilename, int nLineNum ); + CGCGSSession *YieldingFindOrCreateGSSession( const CSteamID & steamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData ); + CGCGSSession *FindGSSession( const CSteamID & steamID ) const; + + /// Lookup the user or GS session, depending on whether the supplied + /// Steam ID is an individual or gameserver ID + CGCSession *FindUserOrGSSession( const CSteamID & steamID ) const; + + CGCSession *YieldingRequestSession( const CSteamID & steamID ); + bool BYieldingIsOnline( const CSteamID & steamID ); + bool BSendWebApiRegistration(); + + // Will return true, indicating the request was sent, a response was received, and the response had a valid + // status code, or false, indicating that there was a transport-layer problem -- the request timed out, or + // a response came back with an invalid status code, etc. All "false" return values are meant to indicate + // temporary errors. + bool BYieldingSendHTTPRequest( const CHTTPRequest *pRequest, CHTTPResponse *pResponse ); + + // Possible return values: + // k_EResultOK -- everything went fine and pkvResponse has been populated. + // k_EResultTimeout -- there was a temporary/transport-layer problem (see "BYieldingSendHTTPRequest"). + // These are temporary errors, or programming errors on our side. + // k_EResultRemoteCallFailed -- we didn't timeout but we got a bad, unparseable, or otherwise invalid response + // back and so we don't have data we can use. + // k_EResultFail -- something has gone catastrophically wrong and no forward progress can be + // expected to be made. May or may not ever be returned. + EResult YieldingSendHTTPRequestKV( const CHTTPRequest *pRequest, KeyValues *pkvResponse ); + + int GetSOCacheCount() const; + bool IsSOCached( const CSharedObject *pObj, uint32 nTypeID ) const; + + int GetUserSessionCount() const; + int GetGSSessionCount() const; + + void SetIsShuttingDown(); + bool GetIsShuttingDown() const { return m_bIsShuttingDown; } + + // Iterate over sessions + // WARNING: Don't yield between GetFirst*/GetNext*. Use caution when using + // these any time you might have tens of thousands of sessions to iterate through. + CGCUserSession **GetFirstUserSession() { return m_hashUserSessions.PvRecordFirst(); } + CGCUserSession **GetNextUserSession( CGCUserSession **pUserSession ) { return m_hashUserSessions.PvRecordNext( pUserSession ); } + CGCGSSession **GetFirstGSSession() { return m_hashGSSessions.PvRecordFirst(); } + CGCGSSession **GetNextGSSession( CGCGSSession **pGSSession ) { return m_hashGSSessions.PvRecordNext( pGSSession ); } + + AppId_t GetAppID() const { return m_unAppID; } + bool BIsStartupComplete() const { return m_bStartupComplete; } + CJobMgr &GetJobMgr() { return m_JobMgr; } + + CSteamID YieldingGuessSteamIDFromInput( const char *pchInput ); + bool BYieldingRecordSupportAction( const CSteamID & actorID, const CSteamID & targetID, const char *pchData, const char *pchNote ); + void PostAlert( EAlertType eAlertType, bool bIsCritical, const char *pchAlertText, const CUtlVector< CUtlString > *pvecExtendedInfo = NULL, bool bAlsoSpew = true ); + const CAccountDetails *YieldingGetAccountDetails( const CSteamID & steamID, bool bForceReload = false ); + const char *YieldingGetPersonaName( const CSteamID & steamID, const char *pchUnknownName = NULL ); + void PreloadPersonaName( const CSteamID & steamID ); + void ClearCachedPersonaName( const CSteamID & steamID ); + bool BYieldingGetAccountLicenses( const CSteamID & steamID, CUtlVector< PackageLicense_t > & vecPackages ); + bool BYieldingLookupAccount( EAccountFindType eFindType, const char *pchInput, CUtlVector< CSteamID > *prSteamIDs ); + bool BYieldingAddFreeLicense( const CSteamID & steamID, uint32 unPackageID, uint32 unIPPublic = 0, const char *pchStoreCountryCode = NULL ); + int YieldingGrantGuestPass( const CSteamID & steamID, uint32 unPackageID, uint32 unPassesToGrant = 1, int32 nDaysToExpiration = -1 ); + + bool BSendGCMsgToClient( const CSteamID & steamIDTarget, const CGCMsgBase& msg ); + bool BSendGCMsgToClient( const CSteamID & steamIDTarget, const CProtoBufMsgBase& msg ); + + //sends a message to the system (GCH or GC.exe) + bool BSendSystemMessage( const CGCMsgBase& msg, uint32 *pcubSent = NULL ); + bool BSendSystemMessage( const CProtoBufMsgBase& msg, uint32 *pcubSent = NULL ); + bool BSendSystemMessage( const ::google::protobuf::Message &msgOut, MsgType_t eSendMsg ); + + //utilities that will send a message and then wait for the specified reply. This will return false if no reply is sent in the default timeout, or the message or status + //don't match what is expected. This can only be called from within a job + bool BYldSendMessageAndGetReply( const CSteamID &steamIDTarget, CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg ); + //bool BYldSendGCMessageAndGetReply( int32 nGCDirIndex, CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg ); + bool BYldSendSystemMessageAndGetReply( CGCMsgBase &msgOut, CGCMsgBase *pMsgIn, MsgType_t eMsg ); + bool BYldSendSystemMessageAndGetReply( CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg ); + bool BYldSendSystemMessageAndGetReply( const ::google::protobuf::Message &msgSend, MsgType_t eSendMsg, ::google::protobuf::Message *pMsgResponse, MsgType_t eRespondMsg ); + + bool BReplyToMessage( CGCMsgBase &msgOut, const CGCMsgBase &msgIn ); + bool BReplyToMessage( CProtoBufMsgBase &msgOut, const CProtoBufMsgBase &msgIn ); + + //sending messages to clients or as responses with pre-serialized bodies so that the work to generate the message and body doesn't have to be done multiple times + bool BSendGCMsgToClientWithPreSerializedBody( const CSteamID & steamIDTarget, MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const byte *pubBody, uint32 cubBody ) const; + bool BSendGCMsgToSystemWithPreSerializedBody( MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const byte *pubBody, uint32 cubBody ) const; + bool BReplyToMessageWithPreSerializedBody( MsgType_t eMsgType, const CProtoBufMsgBase &msgIn, const byte *pubBody, uint32 cubBody ) const; + + const char *GetPath() const { return m_sPath; } + virtual const char *GetSteamAPIKey(); + + void QueueStartPlaying( const CSteamID & steamID, const CSteamID & gsSteamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData ); + void YieldingExecuteNextStartPlaying(); + bool BIsInLogonSurge() const { return m_nLogonSurgeFramesRemaining > 0; } + + /// Are we too busy to process any "low service level guarantee" WebAPI jobs? + bool BShouldThrottleLowServiceLevelWebAPIJobs() const; + + /// Removes the entry in the start playing queue for the specified + /// Steam ID, if one exists. Returns true if it was found + /// and removed, false if no entry existed + bool BRemoveStartPlayingQueueEntry( const CSteamID & steamID ); + + void YieldingStopPlaying( const CSteamID & steamID ); + void YieldingStopGameserver( const CSteamID & steamID ); + bool BIsSOCacheBeingLoaded( const CSteamID & steamID ) const { return m_rbtreeSOCachesBeingLoaded.Find( steamID ) != m_rbtreeSOCachesBeingLoaded.InvalidIndex(); } + + bool BYieldingLockSteamID( const CSteamID &steamID, const char *pszFilename, int nLineNum ); + bool BYieldingLockSteamIDPair( const CSteamID &steamIDA, const CSteamID &steamIDB, const char *pszFilename, int nLineNum ); + bool BLockSteamIDImmediate( const CSteamID &steamID ); + void UnlockSteamID( const CSteamID &steamID ); + bool IsSteamIDLocked( const CSteamID &steamID ); + bool IsSteamIDLockedByJob( const CSteamID &steamID, const CJob *pJob ) const; + bool IsSteamIDLockedByCurJob( const CSteamID &steamID ) const; + bool IsSteamIDUnlockedOrLockedByCurJob( const CSteamID &steamID ); + CJob *PJobHoldingLock( const CSteamID &steamID ); + + const CLock *FindSteamIDLock( const CSteamID &steamID ); + void DumpSteamIDLocks( bool bFull, int nMax = 10 ); + void DumpJobs( const char *pszJobName, int nMax, int nPrintLocksMax ) const; + void DumpJob( JobID_t jobID, int nPrintLocksMax ) const; + virtual void Dump() const; + void VerifySOCacheLRU(); + + void SetProfilingEnabled( bool bEnabled ); + void SetDumpVprofImbalances( bool bEnabled ); + bool GetVprofImbalances(); + + bool YieldingWritebackDirtyCaches( uint32 unSecondToDelayWrite ); + void AddCacheToWritebackQueue( CGCSharedObjectCache *pSOCache ); + + bool BYieldingRetrieveCacheVersion( CGCSharedObjectCache *pSOCache ); + void AddCacheToVersionChangedList( CGCSharedObjectCache *pSOCache ); + + const char *GetCDNURL() const; + + struct GCMemcachedBuffer_t + { + const void *m_pubData; + int m_cubData; + }; + + struct GCMemcachedGetResult_t + { + bool m_bKeyFound; // true if the key was found + CUtlAllocation m_bufValue; // the value of the key + }; + + // Memcached access + bool BMemcachedSet( const char *pKey, const ::google::protobuf::Message &protoBufObj ); + bool BMemcachedDelete( const char *pKey ); + bool BYieldingMemcachedGet( const char *pKey, ::google::protobuf::Message &protoBufObj ); + bool BMemcachedSet( const CUtlString &strKey, const CUtlBuffer &buf ); + bool BMemcachedSet( const CUtlVector<CUtlString> &vecKeys, const CUtlVector<GCMemcachedBuffer_t> &vecValues ); + bool BMemcachedDelete( const CUtlString &strKey ); + bool BMemcachedDelete( const CUtlVector<CUtlString> &vecKeys ); + bool BYieldingMemcachedGet( const CUtlString &strKey, GCMemcachedGetResult_t &result ); + bool BYieldingMemcachedGet( const CUtlVector<CUtlString> &vecKeys, CUtlVector<GCMemcachedGetResult_t> &vecResults ); + + // IP location + bool BYieldingGetIPLocations( CUtlVector<uint32> &vecIPs, CUtlVector<CIPLocationInfo> &infos ); + + /// Check if any of the sessions don't have geolocation info, then fetch + /// the info we can. The supplied SteamID's may refer to individuals or + /// game servers + bool BYieldingUpdateGeoLocation( CUtlVector<CSteamID> const &requestedVecSteamIds ); + + // Stats + virtual void SystemStats_Update( CGCMsgGetSystemStatsResponse &msgStats ); + + //called to determine the amount of uptime this GC has had + uint32 GetGCUpTime() const; + RTime32 GetGCInitTime() const { return m_nInitTime; } + +protected: + virtual bool BYieldingLoadSOCache( CGCSharedObjectCache *pSOCache ); + void RemoveSOCache( const CSteamID & steamID ); + + void AddCacheToLRU( CGCSharedObjectCache * pSOCache ); + void RemoveCacheFromLRU( CGCSharedObjectCache * pSOCache ); + + void SetStartupComplete() { m_bStartupComplete = true; } +private: + + static void AssertCallbackFunc( const char *pchFile, int nLine, const char *pchMessage ); + void UpdateSOCacheVersions(); + + // + // Create and initialize player / gameserver sessions. This should be called only from two places: + // - YieldingExecuteNextStartPlaying() + // - YieldingRequestSession(), which can be called ANY TIME we ask for a locked session but don't have one + // + void YieldingStartPlaying( const CSteamID & steamID, const CSteamID & gsSteamID, uint32 unServerAddr, uint16 usServerPort, CUtlBuffer *pVarData ); + void YieldingStartGameserver( const CSteamID & steamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData ); + + void YieldingExecuteStartPlayingQueueEntryByIndex( int idxStartPlayingQueue ); + + // Base behaviors of the IGameCoordinator interface. These are not overridable. + // They each call the On* version below, which is overridable by subclasses + virtual bool BInit( AppId_t unAppID, const char *pchAppPath, IGameCoordinatorHost *pHost ); + virtual bool BMainLoopOncePerFrame( uint64 ulLimitMicroseconds ); + virtual bool BMainLoopUntilFrameCompletion( uint64 ulLimitMicroseconds ); + virtual void Shutdown(); + virtual void Uninit(); + virtual void MessageFromClient( const CSteamID & senderID, uint32 unMsgType, void *pubData, uint32 cubData ); + virtual void Validate( CValidator &validator, const char *pchName ); + virtual void SQLResults( GID_t gidContextID ); + + static void SetUserSessionDetails( CGCUserSession *pUserSession, KeyValues *pkvDetails ); + + // Remembers the console spew func we overrode so we can restore it at uninit + SpewOutputFunc_t m_OutputFuncPrev; + + // profiling + bool m_bStartProfiling; + bool m_bStopProfiling; + bool m_bDumpVprofImbalances; + + //the time that the GC started so that we can compute uptime + RTime32 m_nInitTime; + RTime32 m_nStartupCompleteTime; + + // local job handling + CJobMgr m_JobMgr; + CGCWGJobMgr m_wgJobMgr; + + // session tracking + CTHash<CGCUserSession *, uint64> m_hashUserSessions; + CTHash<CGCGSSession *, uint64> m_hashGSSessions; + CUtlHashMapLarge< uint64, CGCGSSession* > m_mapGSSessionsByNetAddress; + + // Shared object caches + CUtlHashMapLarge<CSteamID, CGCSharedObjectCache *> m_mapSOCache; + CUtlVector< CGCSharedObjectCache * >m_vecCacheWritebacks; + CUtlLinkedList< CSteamID, uint32> m_listCachesToUnload; + CUtlRBTree<CSteamID, int > m_rbtreeSOCachesBeingLoaded; + CUtlRBTree<CSteamID, int > m_rbtreeSOCachesWithDirtyVersions; + CUtlRBTree< AccountID_t, int32, CDefLess< AccountID_t > > m_rbFlushInventoryCacheAccounts; + JobID_t m_jobidFlushInventoryCacheAccounts; + uint32 m_numFlushInventoryCacheAccountsLastScheduled; + + // steamID locks + CTHash<CLock, CSteamID> m_hashSteamIDLocks; + + // Account Details + CAccountDetailsManager m_AccountDetailsManager; + + // State + AppId_t m_unAppID; + CUtlString m_sPath; + IGameCoordinatorHost *m_pHost; + bool m_bStartupComplete; + bool m_bIsShuttingDown; + + struct StartPlayingWork_t + { + CSteamID m_steamID; + CSteamID m_gsSteamID; + uint32 m_unServerAddr; + uint16 m_usServerPort; + CUtlBuffer *m_pVarData; + }; + CUtlLinkedList< StartPlayingWork_t, int > m_llStartPlaying; + CUtlMap< CSteamID, int, int > m_mapStartPlayingQueueIndexBySteamID; + + /// Number of active jobs + int m_nStartPlayingJobCount; + + // URL to use for our app's CDN'd images + mutable CUtlString m_sCDNURL; + + /// Number of active jobs currently inside YieldingRequestSession + int m_nRequestSessionJobsActive; + + /// Number of frames to wait before checking to + /// see if we're done with logon surge. This will + /// be nonzero while in logon surge, and zero + /// if we're not in logon surge. + int m_nLogonSurgeFramesRemaining; + + //rate limiting system + CSteamIDRateLimit m_MsgRateLimit; + + //a map of the HTTP error messages so we can batch them up as they occur as they tend to be very spammy + void ReportHTTPError( const char* pszError, CGCEmitGroup::EMsgLevel eLevel ); + void DumpHTTPErrors(); + struct SHTTPError + { + CUtlString m_sStr; + uint32 m_nCount; + CGCEmitGroup::EMsgLevel m_eSeverity; + }; + CUtlHashMapLarge< const char*, SHTTPError*, CaseSensitiveStrEquals, MurmurHash3ConstCharPtr > m_HTTPErrors; + CScheduledFunction< CGCBase > m_DumpHTTPErrorsSchedule; +}; + +extern CGCBase *GGCBase(); + +// ---------------------------------------------------------------------------- +// BEGIN BLOCK OF PRE-TF-GC-SPLIT SCAFFOLDING +// ---------------------------------------------------------------------------- + +// Alright, here's why this mess is here: we (TF) are doing some work that depends +// on work that Dota has done, things like the SQL message queue, etc. We want to +// update our code so that it does the right thing and uses their functionaity so +// that they can then integrate our changes. +// +// TF is way out of date, though, and so rather than make that work, some of which +// has significant time pressure, dependent on a massive weeks-long integrate that +// we aren't sure is the right thing to do anyway, we're going to bring over their +// code as-is and then stub in implementations. +// +// This horrific template mess basically says "are we compiling in an environment +// with a spit GC?" (specifically, does CGCBase::GetGCType() exist?). If so, call +// into real implementations for things like GetGCGType(), etc. If not, feed back +// sane default values (ie., we're a master GC and there's only one of us). Doing +// this means that Dota can integrate our code and we can integrate Dota code and +// no callsites have to change. If/when TF *does* split our GC, things will silently +// update their implementation and then we can delete the scaffolding whenever. +template < class tBaseGCType > +struct IsSplitGC +{ + typedef char t_Yes[1]; + typedef char t_No[2]; + + template < typename T, T > + struct InternalTypeCheck; \ + + template < typename T > + static t_Yes& Test( InternalTypeCheck< uint32(), &T::GetGCType> * ); + + template < typename T > + static t_No& Test( ... ); + + enum { kValue = sizeof( Test<tBaseGCType>( NULL ) ) == sizeof( t_Yes ) }; +}; + +template < bool tTest, typename T > struct EnableIf { typedef T Type; }; +template < typename T > struct EnableIf< false, T > { }; + +#define SplitVsSingleGCImpl( returntype_, functionandparams_, splitgcimpl_, singlegcimpl_ ) \ + template < class tBaseGCType = CGCBase > typename EnableIf<IsSplitGC<tBaseGCType>::kValue, returntype_>::Type functionandparams_ { return splitgcimpl_; } \ + template < class tBaseGCType = CGCBase > typename EnableIf<!IsSplitGC<tBaseGCType>::kValue, returntype_>::Type functionandparams_ { return singlegcimpl_; } + +SplitVsSingleGCImpl( uint32, GGetGCType(), GGCBase()->GetGCType(), 0 ); +SplitVsSingleGCImpl( uint32, GGetGCCountForType( uint32 unGCType ), GDirectory()->GetGCCountForType( unGCType ), 1 ); +SplitVsSingleGCImpl( uint32, GGetGCInstance(), GGCBase()->GetDirInfo()->GetInstance(), 0 ); + +#undef SplitVsSingleGCImpl + +// ---------------------------------------------------------------------------- +// END BLOCK OF TEMPORARY PRE-INTEGRATE SCAFFOLDING +// ---------------------------------------------------------------------------- + +EResult YieldingSendWebAPIRequest( CSteamAPIRequest &request, KeyValues *pKVResponse, CUtlString &errMsg, bool b200MeansSuccess ); + +/// Scope object that remembers if a Steam ID is locked, and automatically unlocks it upon destruction +class CScopedSteamIDLock +{ +public: + + /// Create object without assigning SteamID + CScopedSteamIDLock() : m_steamID(), m_bLockedSuccesfully(false), m_iSavedLockCount(-1) {} + + /// Construct object to lock a particular steam ID + CScopedSteamIDLock( const CSteamID& steamID ) : m_steamID( steamID ), m_bLockedSuccesfully(false), m_iSavedLockCount(-1) {} + + /// Destructor performs an unlock, if we are holing a lock. That's pretty much the whole purpose of this class. + ~CScopedSteamIDLock() { Unlock(); } + + /// Return true if we're locked + bool IsLocked() const { return m_bLockedSuccesfully; } + + /// Lock the currently assigned Steam ID. (Set by constructor) + bool BYieldingPerformLock( const char *pszFilename, int nLineNumber ) + { + Assert( !m_bLockedSuccesfully ); + Unlock(); + + Assert( m_steamID.IsValid() ); + + m_bLockedSuccesfully = GGCBase()->BYieldingLockSteamID( m_steamID, pszFilename, nLineNumber ); + if ( m_bLockedSuccesfully ) + { + const CLock *pLock = GGCBase()->FindSteamIDLock( m_steamID ); + if ( pLock ) + { + m_iSavedLockCount = pLock->GetReferenceCount(); + } + else + { + Assert( pLock ); + } + } + return m_bLockedSuccesfully; + } + + /// Lock the specified Steam ID. + bool BYieldingPerformLock( const CSteamID &steamID, const char *pszFilename, int nLineNumber ) + { + + // Should not already be locked, but unlock just in case + Assert( !m_bLockedSuccesfully ); + Unlock(); + + // Attempt lock + m_steamID = steamID; + m_bLockedSuccesfully = GGCBase()->BYieldingLockSteamID( m_steamID, pszFilename, nLineNumber ); + if ( m_bLockedSuccesfully ) + { + const CLock *pLock = GGCBase()->FindSteamIDLock( m_steamID ); + if ( pLock ) + { + m_iSavedLockCount = pLock->GetReferenceCount(); + } + else + { + Assert( pLock ); + } + } + + // Report status + return m_bLockedSuccesfully; + } + + /// Mark us as already being locked. This is used when you already have a lock, and just want to use + /// the scoped class to do the unlock when you're done + void MarkLocked( const CSteamID &steamID ) + { + + // Should not already be locked, but unlock just in case + Assert( !m_bLockedSuccesfully ); + Unlock(); + + // Remember state + m_steamID = steamID; + m_bLockedSuccesfully = true; + const CLock *pLock = GGCBase()->FindSteamIDLock( m_steamID ); + if ( pLock ) + { + m_iSavedLockCount = pLock->GetReferenceCount(); + } + else + { + Assert( pLock ); + } + } + + /// Stop tracking that we're locking this object. This does *not* unlock anything -- Unlock does + /// that. This is for "we hit the end of our scope but now want to do something else with the + /// lock (ie., pass back to a caller)". This is like un-smarting a smart pointer. + void Release() + { + if ( m_bLockedSuccesfully ) + { + VerifyPreUnlock(); + m_bLockedSuccesfully = false; + m_iSavedLockCount = -1; + } + } + + /// Unlock the lock, if we are holding it. Usually this is not called directly, + /// we let the destructor do it. + void Unlock() + { + if ( m_bLockedSuccesfully ) + { + VerifyPreUnlock(); + GGCBase()->UnlockSteamID( m_steamID ); + m_bLockedSuccesfully = false; + m_iSavedLockCount = -1; + } + } + +private: + void VerifyPreUnlock() const + { + Assert( m_bLockedSuccesfully ); + + const CLock *pLock = GGCBase()->FindSteamIDLock( m_steamID ); + if ( pLock ) + { + AssertMsg1( m_iSavedLockCount == pLock->GetReferenceCount(), "Lock imbalance on %s detected by scope lock", pLock->GetName() ); + } + else + { + Assert( pLock ); + } + } + +private: + CSteamID m_steamID; + bool m_bLockedSuccesfully; + int m_iSavedLockCount; + +}; + +/// Scope object that remembers if a specific lock is taken, and releases it +class CScopedGenericLock +{ +public: + + /// Create object for specific lock SteamID + CScopedGenericLock( CLock &lock ) : m_pLock( &lock ), m_bLockedSuccesfully(false), m_iSavedLockCount(-1) {} + + /// Destructor performs an unlock, if we are holing a lock. That's pretty much the whole purpose of this class. + ~CScopedGenericLock() { Unlock(); } + + /// Return true if we're locked + bool IsLocked() const { return m_bLockedSuccesfully; } + + /// Lock the current lock. (Set by constructor) + bool BYieldingPerformLock( const char *pszFilename, int nLineNumber ) + { + Assert( !m_bLockedSuccesfully ); + Unlock(); + + Assert( m_pLock ); + + m_bLockedSuccesfully = GJobCur()._BYieldingAcquireLock( m_pLock, pszFilename, nLineNumber ); + if ( m_bLockedSuccesfully ) + { + m_iSavedLockCount = m_pLock->GetReferenceCount(); + } + return m_bLockedSuccesfully; + } + + /// Stop tracking that we're locking this object. This does *not* unlock anything -- Unlock does + /// that. This is for "we hit the end of our scope but now want to do something else with the + /// lock (ie., pass back to a caller)". This is like un-smarting a smart pointer. + void Release() + { + if ( m_bLockedSuccesfully ) + { + VerifyPreUnlock(); + m_bLockedSuccesfully = false; + m_iSavedLockCount = -1; + } + } + + /// Unlock the lock, if we are holding it. Usually this is not called directly, + /// we let the destructor do it. + void Unlock() + { + if ( m_bLockedSuccesfully ) + { + VerifyPreUnlock(); + if ( m_pLock->GetJobLocking() != &GJobCur() ) + { + AssertMsg( false, "CScopedGenericLock::Unlock called when job %s doesn't own the lock", GJobCur().GetName() ); + return; + } + + GJobCur().ReleaseLock( m_pLock ); + m_bLockedSuccesfully = false; + m_iSavedLockCount = -1; + } + } + +private: + void VerifyPreUnlock() const + { + Assert( m_bLockedSuccesfully ); + + AssertMsg1( m_iSavedLockCount == m_pLock->GetReferenceCount(), "Lock imbalance on %s detected by scope lock", m_pLock->GetName() ); + } + +private: + CLock *m_pLock; + bool m_bLockedSuccesfully; + int m_iSavedLockCount; + +}; + +class CTrustedHelper_AssertOnNonPublicUniverseFailures +{ +public: + void operator()( const bool bExpResult, const char *pszExp ) const + { + if ( GetUniverse() != k_EUniversePublic ) + { + AssertMsg1( bExpResult, "%s", pszExp ); + } + } +}; + +class CVerifyIfTrustedHelper +{ +public: + template < typename tTrustedCriteriaImpl > + CVerifyIfTrustedHelper( const tTrustedCriteriaImpl& CriteriaImpl, const bool bExpResult, const char *pszExp ) + { + CommonConstructor( CriteriaImpl, bExpResult, pszExp ); + } + + // Helper constructor so we can do VerifyIfTrusted( pSomePointer ) without getting a type- + // conversion-to-bool warning. + template < typename tTrustedCriteriaImpl > + CVerifyIfTrustedHelper( const tTrustedCriteriaImpl& CriteriaImpl, const void *pointer, const char *pszExp ) + { + CommonConstructor( CriteriaImpl, pointer != NULL, pszExp ); + } + + bool GetResult() const { return m_bExpResult; } + +private: + template < typename tTrustedCriteriaImpl > + void CommonConstructor( const tTrustedCriteriaImpl& CriteriaImpl, const bool bExpResult, const char *pszExp ) + { + m_bExpResult = bExpResult; + + CriteriaImpl( bExpResult, pszExp ); + } + + bool m_bExpResult; +}; + +// Examples of things that we don't want to assert on, even during testing: +// - we got a message from someone who didn't have a session. This could be a Steam +// problem, or we could be backlogged processing messages, or we could have an offline +// trade get processed in the background. +// - someone sent up a message involving an item that they don't own. (Same reasons as +// a missing session.) +// +// Examples of things that we do want to assert on internally, but not when running public: +// - our messages match contents fulfill criteria that the client specifies. ie., if we're +// passing up a "victim" and a "killer" Steam ID, they won't be identical. +// - our schema data is set up correctly. ie., necessary fields ("kill eater localization +// string") that we expect to fail a schema parse init for if they're absent are present. +// - our messages are coming from places that make sense. ie., a game server isn't sending +// messages we expect to get from a client, or we aren't getting a message from a client +// that we expect only to come from elsewhere in GC code. +#define VerifyIfTrusted( exp_ ) \ + CVerifyIfTrustedHelper( CTrustedHelper_AssertOnNonPublicUniverseFailures(), (exp_), #exp_ ).GetResult() + +// !KLUDGE! Shim to make it easier to merge over stuff from DOTA +class CGCInterface +{ +public: + CSteamID ConstructSteamIDForClient( AccountID_t unAccountID ) const; +}; +extern CGCInterface *GGCInterface(); + +} // namespace GCSDK + +struct CRatelimitedSpewController +{ +public: + CRatelimitedSpewController() : m_rtCooldownStart( 0 ), m_rtLastSpew( 0 ), m_numSpewed( 0 ), m_numSkipped( 0 ) {} + ~CRatelimitedSpewController() {} + + enum ERate_t + { + k_ERate_Skip = -1, // skip printing anything, rate limit too high + k_ERate_Print = 0, // print the full message + // default is to print how many messages total as well + }; + + int RegisterSpew(); + +private: + RTime32 m_rtCooldownStart; + RTime32 m_rtLastSpew; + int m_numSpewed; + int m_numSkipped; +}; + +#define EmitErrorRatelimited( SPEW_GROUP_ID, fmtstring, ... ) \ + static CRatelimitedSpewController s_spewcontroller; \ + int nspewcontroller = s_spewcontroller.RegisterSpew(); \ + switch ( nspewcontroller ) \ + { \ + case CRatelimitedSpewController::k_ERate_Skip: break; \ + default: \ + EmitError( SPEW_GROUP_ID, nspewcontroller \ + ? fmtstring "(... and %d more skipped)\n" \ + : fmtstring \ + , __VA_ARGS__ \ + , nspewcontroller \ + ); \ + break; \ + } \ + + +#define EmitInfoRatelimited( SPEW_GROUP_ID, ConsoleLevel, LogLevel, fmtstring, ... ) \ + static CRatelimitedSpewController s_spewcontroller; \ + int nspewcontroller = s_spewcontroller.RegisterSpew(); \ + switch ( nspewcontroller ) \ + { \ + case CRatelimitedSpewController::k_ERate_Skip: break; \ + default: \ + EmitInfo( SPEW_GROUP_ID, ConsoleLevel, LogLevel, nspewcontroller \ + ? fmtstring "(... and %d more skipped)\n" \ + : fmtstring \ + , __VA_ARGS__ \ + , nspewcontroller \ + ); \ + break; \ + } \ + + +#define EG_WARNING_RATELIMITED( SPEW_GROUP_ID, fmtstring, ... ) \ + static CRatelimitedSpewController s_spewcontroller; \ + int nspewcontroller = s_spewcontroller.RegisterSpew(); \ + switch ( nspewcontroller ) \ + { \ + case CRatelimitedSpewController::k_ERate_Skip: break; \ + default: \ + EG_WARNING( SPEW_GROUP_ID, nspewcontroller \ + ? fmtstring "(... and %d more skipped)\n" \ + : fmtstring \ + , __VA_ARGS__ \ + , nspewcontroller \ + ); \ + break; \ + } \ + + + +#endif // GCBASE_H |