path: root/gcsdk/gcbase.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include "stdafx.h"
#include "gcbase.h"
#include "tier1/interface.h"
#include "tier0/minidump.h"
#include "tier0/icommandline.h"
#include "gcjob.h"
#include "sqlaccess/schemaupdate.h"
#include "gcsystemmsgs.h"
#include "rtime.h"
#include "msgprotobuf.h"
#include "gcsdk_gcmessages.pb.h"
#include "gcsdk/gcparalleljobfarm.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

namespace GCSDK
{

//----------------------------------------------------------------------
// Emit groups
//----------------------------------------------------------------------
DECLARE_GC_EMIT_GROUP( g_EGHTTPRequest, http_request );

CGCBase *g_pGCBase = NULL;

// Thread pool size convar
static void OnConVarChangeJobMgrThreadPoolSize( IConVar *pConVar, const char *pOldString, float flOldValue );
GCConVar jobmgr_threadpool_size( "jobmgr_threadpool_size", "-1", 0,
                                 "Maximum threads in the job manager thread pool. Values <= 0 mean number_logical_cpus - this.",
                                 OnConVarChangeJobMgrThreadPoolSize );

static uint32 GetThreadPoolSizeFromConVar()
{
	int nVal = jobmgr_threadpool_size.GetInt();
	int nRet = ( nVal > 0 ) ? nVal : GetCPUInformation()->m_nLogicalProcessors + nVal;
	return (uint32)Clamp( nRet, 1, INT_MAX );
}

static void OnConVarChangeJobMgrThreadPoolSize( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	if ( GGCBase()->GetIsShuttingDown() )
		return;

	GGCBase()->GetJobMgr().SetThreadPoolSize( GetThreadPoolSizeFromConVar() );
}

GCConVar cv_concurrent_start_playing_limit( "concurrent_start_playing_limit", "1000" );
GCConVar cv_logon_surge_start_playing_limit( "logon_surge_start_playing_limit", "2000" );
GCConVar cv_logon_surge_request_session_jobs( "logon_surge_request_session_jobs", "1000" );
GCConVar cv_webapi_throttle_job_threshold( "webapi_throttle_job_threshold", "2000", 0, "If the job count exceeds this threshold, reject low-priority webapi jobs" );
GCConVar enable_startplaying_gameserver_creation_spew( "enable_startplaying_gameserver_creation_spew", "0" );
// Enable the restore-version-from-memcache machinery. Disabled because it assumes reloading an SOCache is
// deterministic, which is no longer true for us, resulting in clients with stale versions believing themselves to be in
// sync.
//
// This probably needs a look -- ideally we'd delineate deterministic objects that can be assumed to remain in sync in
// GC reboots, and dynamic objects that cannot.
//
// Note that we already removed hacks for this in player groups and started using lazy-loaded objects in SOCaches that
// violate the assumptions this was making, so re-enabling it requires work. We probably really want to split type
// caches into deterministic-between-GC-reboots and not, and resend based on said flag.
GCConVar socache_persist_version_via_memcached( "socache_persist_version_via_memcached", "0" );

static GCConVar cv_assert_minidump_window( "assert_minidump_window", "28800", 0, "Size of the minidump window in seconds. Each unique assert will dump at most assert_max_minidumps_in_window times in this many seconds" );
static GCConVar cv_assert_max_minidumps_in_window( "assert_max_minidumps_in_window", "5", 0, "The amount of times each unique assert will write a dump in assert_minidump_window seconds" );

static GCConVar cv_debug_steam_startplaying( "cv_debug_steam_startplaying", "0", 0, "Turn this ON to debug the stream of startplaying messages we get from Steam" );

static GCConVar temp_list_mismatched_replies( "temp_list_mismatched_replies", "0", "When set to 1, this report all replies that fail because the incoming message didn't expect a response. Temporary to help track down some failed state" );

static GCConVar writeback_queue_max_accumulate_time( "writeback_queue_max_accumulate_time", "10", 0, "The maximum amount of time in seconds that the writeback queue will accumulate database writes before performing queries. This is the time *before* the queries are executed, which is unbounded." );
static GCConVar writeback_queue_max_caches( "writeback_queue_max_caches", "0", 0, "The maximum amount of caches to write back in a single transaction. Set to zero to remove this restriction." );
static GCConVar geolocation_spewlevel( "geolocation_spewlevel", "4", 0, "Spewlevel to use for geolocation debug spew" );
static GCConVar geolocation_loglevel( "geolocation_loglevel", "4", 0, "Spewlevel to use for geolocation debug spew" );

extern GCConVar max_user_messages_per_second;

// There is also a GCConVar writeback_delay to control how frequently we do writebacks.

// !KLUDGE! Temp shim.  Will get rid of this when we bring over the real gcinterface stuff from DOTA.
CGCInterface g_GCInterface;
CGCInterface *GGCInterface() { return &g_GCInterface; }
CSteamID CGCInterface::ConstructSteamIDForClient( AccountID_t unAccountID ) const
{
	return CSteamID( unAccountID, GetUniverse(), k_EAccountTypeIndividual );
}


//-----------------------------------------------------------------------------
// Purpose: Overrides the spew func used by Msg and DMsg to print to the console
//-----------------------------------------------------------------------------
SpewRetval_t ConsoleSpewFunc( SpewType_t type, const tchar *pMsg )
{
	const char *fmt = ( sizeof( tchar ) == sizeof( char ) ) ? "%hs" : "%ls";
	switch (type )
	{
		default:
		case SPEW_MESSAGE:
		case SPEW_LOG:
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, fmt, pMsg );
			break;
		case SPEW_WARNING:
			EmitWarning( SPEW_CONSOLE, SPEW_ALWAYS, fmt, pMsg );
			break;
		case SPEW_ASSERT:
			if ( ThreadInMainThread() && ( g_pJobCur != NULL ) )
			{
				fmt = ( sizeof( tchar ) == sizeof( char ) ) ? "[Job %s] %hs" : "[Job %s] %ls";
				EmitError( SPEW_CONSOLE, fmt, g_pJobCur->GetName(), pMsg );
			}
			else
			{
				EmitError( SPEW_CONSOLE, fmt, pMsg );
			}
			break;
		case SPEW_ERROR:
			EmitError( SPEW_CONSOLE, fmt, pMsg );
			break;
	}

	if ( type == SPEW_ASSERT )
	{
#ifndef WIN32
		// Non-win32
		bool bRaiseOnAssert = getenv( "RAISE_ON_ASSERT" ) || !!CommandLine()->FindParm( "-raiseonassert" );
#elif defined( _DEBUG )
		// Win32 debug
		bool bRaiseOnAssert = true;
#else
		// Win32 release
		bool bRaiseOnAssert = !!CommandLine()->FindParm( "-raiseonassert" );
#endif

		return bRaiseOnAssert ? SPEW_DEBUGGER : SPEW_CONTINUE;
	}
	else if ( type == SPEW_ERROR )
		return SPEW_ABORT;
	else
		return SPEW_CONTINUE;
}


class CGCShutdownJob : public CGCJob
{
public:
	CGCShutdownJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob()
	{
		m_pGC->SetIsShuttingDown();

		// Log off all of the game servers and users, so that if something
		// in the log off dirties caches they can be written back
		CUtlVector<CSteamID> vecIDsToStop;
		for( CGCGSSession **ppSession = m_pGC->GetFirstGSSession(); ppSession != NULL; ppSession = m_pGC->GetNextGSSession( ppSession ) )
		{
			vecIDsToStop.AddToTail( (*ppSession)->GetSteamID() );
		}

		FOR_EACH_VEC( vecIDsToStop, i )
		{
			m_pGC->YieldingStopGameserver( vecIDsToStop[i] );
			ShouldNotHoldAnyLocks();
		}

		vecIDsToStop.RemoveAll();

		for( CGCUserSession **ppSession = m_pGC->GetFirstUserSession(); ppSession != NULL; ppSession = m_pGC->GetNextUserSession( ppSession ) )
		{
			vecIDsToStop.AddToTail( (*ppSession)->GetSteamID() );
		}

		FOR_EACH_VEC( vecIDsToStop, i )
		{
			m_pGC->YieldingStopPlaying( vecIDsToStop[i] );
			ShouldNotHoldAnyLocks();
		}

		// wait for jobs to finish (except this one!)
		const int kMaxIterations = 100;
		int cIter = 0;
		while ( cIter++ < kMaxIterations && m_pGC->GetJobMgr().CountJobs() > 1 )
		{
			BYieldingWaitOneFrame();
		}

		m_pGC->YieldingGracefulShutdown();
		GGCHost()->ShutdownComplete();

		return false; 
	}

};


class CPreTestSetupJob : public CGCJob
{
public:
	CPreTestSetupJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::CNetPacket *pNetPacket )
	{
		CGCMsg<MsgGCEmpty_t> msg( pNetPacket );
		m_pGC->YieldingPreTestSetup();

		return true; 
	}
};

GC_REG_JOB( CGCBase, CPreTestSetupJob, "CPreTestSetupJob", k_EGCMsgPreTestSetup, k_EServerTypeGC );

static void SpewSerializedKeyValues( const byte *pubVarData, uint32 cubVarData )
{
	if ( pubVarData == NULL || cubVarData == 0 )
	{
		EmitInfo( SPEW_GC, 1, 1, "  No KV data\n" );
		return;
	}
	char szLine[512] = "";
	for ( uint32 i = 0 ; i < cubVarData ; ++i )
	{
		char szByteVal[32];
		V_sprintf_safe( szByteVal, "%02X", pubVarData[ i ] );
		if ( i % 32 )
		{
			V_strcat_safe( szLine, ", " );
			V_strcat_safe( szLine, szByteVal );
		}
		else
		{
			if ( szLine[0] )
				EmitInfo( SPEW_GC, 1, 1, "  %s\n", szLine );
			V_strcpy_safe( szLine, szByteVal );
		}
	}
	if ( szLine[0] )
		EmitInfo( SPEW_GC, 1, 1, "  %s\n", szLine );
	KeyValuesAD pkvDetails( "SessionDetails" );
	CUtlBuffer buf;
	buf.Put( pubVarData, cubVarData );
	if( pkvDetails->ReadAsBinary( buf ) )
	{
		FOR_EACH_VALUE( pkvDetails, v )
		{
			EmitInfo( SPEW_GC, 1, 1, "  %s = %s\n", v->GetName(), v->GetString( NULL, "??" ) );
		}
	}
	else
	{
		EmitInfo( SPEW_GC, 1, 1, "  KV data failed parse\n" );
	}
}

class CStartPlayingJob : public CGCJob
{
public:
	CStartPlayingJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		CGCMsg<MsgGCStartPlaying_t> msg( pNetPacket );

		// @note Tom Bui/Joe Ludwig: This can happen for PS3 Steam accounts
		if ( !msg.Body().m_steamID.IsValid() )
			return true;

		if ( cv_debug_steam_startplaying.GetBool() )
		{
			netadr_t serverAdr( msg.Body().m_unServerAddr, msg.Body().m_usServerPort );
			EmitInfo( SPEW_GC, 1, 1, "Received StartPlaying( user = %s, GS = %s @ %s )\n", msg.Body().m_steamID.Render(), msg.Body().m_steamIDGS.Render(), serverAdr.ToString() );
			SpewSerializedKeyValues( msg.PubVarData(), msg.CubVarData() );
		}
		m_pGC->QueueStartPlaying( msg.Body().m_steamID, msg.Body().m_steamIDGS, msg.Body().m_unServerAddr, msg.Body().m_usServerPort, msg.PubVarData(), msg.CubVarData() );

		return true; 
	}
};

GC_REG_JOB(CGCBase, CStartPlayingJob, "CStartPlayingJob", k_EGCMsgStartPlaying, k_EServerTypeGC);

class CExecuteStartPlayingJob : public CGCJob
{
public:
	CExecuteStartPlayingJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( )
	{
		m_pGC->YieldingExecuteNextStartPlaying();
		return true; 
	}
};


class CStopPlayingJob : public CGCJob
{
public:
	CStopPlayingJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		CGCMsg<MsgGCStopSession_t> msg( pNetPacket );

		// @note Tom Bui/Joe Ludwig: This can happen for PS3 Steam accounts
		if ( !msg.Body().m_steamID.IsValid() )
			return true;

		if ( cv_debug_steam_startplaying.GetBool() )
		{
			EmitInfo( SPEW_GC, 1, 1, "Received StopPlaying( user = %s )\n", msg.Body().m_steamID.Render() );
		}

		m_pGC->YieldingStopPlaying( msg.Body().m_steamID );

		return true; 
	}
};

GC_REG_JOB(CGCBase, CStopPlayingJob, "CStopPlayingJob", k_EGCMsgStopPlaying, k_EServerTypeGC);

class CStartGameserverJob : public CGCJob
{
public:
	CStartGameserverJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		CGCMsg<MsgGCStartGameserver_t> msg( pNetPacket );
		m_pGC->QueueStartPlaying( msg.Body().m_steamID, CSteamID(), msg.Body().m_unServerAddr, msg.Body().m_usServerPort, msg.PubVarData(), msg.CubVarData() );

		return true; 
	}
};

GC_REG_JOB(CGCBase, CStartGameserverJob, "CStartGameserverJob", k_EGCMsgStartGameserver, k_EServerTypeGC);

class CStopGameserverJob : public CGCJob
{
public:
	CStopGameserverJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		CGCMsg<MsgGCStopSession_t> msg( pNetPacket );
		m_pGC->YieldingStopGameserver( msg.Body().m_steamID );

		return true; 
	}
};

GC_REG_JOB(CGCBase, CStopGameserverJob, "CStopGameserverJob", k_EGCMsgStopGameserver, k_EServerTypeGC);

class CGetSystemStatsJob : public CGCJob
{
public:
	CGetSystemStatsJob( CGCBase *pGC ) : CGCJob( pGC ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		CProtoBufMsg<CGCMsgGetSystemStats> msg( pNetPacket );

		CProtoBufMsg<CGCMsgGetSystemStatsResponse> msgResponse( k_EGCMsgGetSystemStatsResponse );
		msgResponse.Body().set_gc_app_id( m_pGC->GetAppID() );

		// @note Tom Bui: we don't support dynamic stats yet, but once we do, we can use the KV stuff
		m_pGC->SystemStats_Update( msgResponse.Body() );

		//		KVPacker packer;
		//		KeyValuesAD pKVStats( "GCStats" );
		//		CUtlBuffer buffer;
		//		if ( packer.WriteAsBinary( pKVStats, buffer ) )
		//		{			
		//			msgResponse.Body().set_stats_kv( buffer.Base(), buffer.TellPut() );			
		//		}
		return m_pGC->BSendSystemMessage( msgResponse );
	}
};

GC_REG_JOB(CGCBase, CGetSystemStatsJob, "CGetSystemStatsJob", k_EGCMsgGetSystemStats, k_EServerTypeGC);

//-----------------------------------------------------------------------------
class CGCJobAccountVacStatusChange : public CGCJob
{
public:
	CGCJobAccountVacStatusChange( CGCBase *pGC ) : CGCJob( pGC )	{}

	bool BYieldingRunJobFromMsg( IMsgNetPacket *pNetPacket )
	{
		CProtoBufMsg<CMsgGCHAccountVacStatusChange> msg( pNetPacket );
		
		if ( GGCBase()->GetAppID() != msg.Body().app_id() )
			return true;

		CSteamID steamID( msg.Body().steam_id() );
		bool bIsVacBanned = msg.Body().is_banned_now();

		// Fetch app details, but force them to be re-loaded
		bool bForceReload = true;
		const CAccountDetails *pAccountDetails = GGCBase()->YieldingGetAccountDetails( steamID, bForceReload );

		// Account details is up to date so just return
		if ( pAccountDetails && bIsVacBanned != pAccountDetails->BIsVacBanned() )
		{
			EmitWarning( SPEW_GC, 2, "VAC status didn't update for %s afetr receiving VacStatusChange and the force reloading the account details\n", steamID.Render() );
		}
		return true;
	}
};
GC_REG_JOB( CGCBase, CGCJobAccountVacStatusChange, "CGCJobAccountVacStatusChange", k_EGCMsgGCAccountVacStatusChange, k_EServerTypeGC );

//-----------------------------------------------------------------------------
class CGCJobAccountPhoneNumberChange : public CGCJob
{
public:
	CGCJobAccountPhoneNumberChange( CGCBase *pGC ) : CGCJob( pGC )	{}

	bool BYieldingRunJobFromMsg( IMsgNetPacket *pNetPacket )
	{
		CProtoBufMsg<CMsgGCHAccountPhoneNumberChange> msg( pNetPacket );

		if ( GGCBase()->GetAppID() != msg.Body().appid() )
			return true;

		CSteamID steamID( msg.Body().steamid() );
		CScopedSteamIDLock scopedLock( steamID );
		if ( !scopedLock.BYieldingPerformLock( __FILE__, __LINE__ ) )
		{
			EmitError( SPEW_GC, __FUNCTION__ ": Failed to lock steamid %s\n", steamID.Render() );
			return true;
		}

		bool bHasPhoneVerified = msg.Body().is_verified();
		bool bIsPhoneIdentifying = msg.Body().is_identifying();

		// Fetch app details, but force them to be re-loaded
		bool bForceReload = true;
		const CAccountDetails *pAccountDetails = GGCBase()->YieldingGetAccountDetails( steamID, bForceReload );

		// Account details is up to date so just return
		if ( pAccountDetails && ( bHasPhoneVerified != pAccountDetails->BIsPhoneVerified() ||
		                          bIsPhoneIdentifying != pAccountDetails->BIsPhoneIdentifying() ) )
		{
			EmitWarning( SPEW_GC, 2, "Phone status didn't update for %s afetr receiving PhoneNumberChange and force reloading the account details\n",
			             steamID.Render() );
		}

		GGCBase()->YldOnAccountPhoneVerificationChange( steamID );

		EmitInfo( SPEW_GC, 5, 5, "AccountPhoneVerificationChange for %s\n", steamID.Render() );

		return true;
	}
};
GC_REG_JOB( CGCBase, CGCJobAccountPhoneNumberChange, "CGCJobAccountPhoneNumberChange", k_EGCMsgAccountPhoneNumberChange, k_EServerTypeGC );

//-----------------------------------------------------------------------------
class CGCJobAccountTwoFactorChange : public CGCJob
{
public:
	CGCJobAccountTwoFactorChange( CGCBase *pGC ) : CGCJob( pGC )	{}

	bool BYieldingRunJobFromMsg( IMsgNetPacket *pNetPacket )
	{
		CProtoBufMsg<CMsgGCHAccountTwoFactorChange> msg( pNetPacket );

		if ( GGCBase()->GetAppID() != msg.Body().appid() )
			return true;

		CSteamID steamID( msg.Body().steamid() );
		bool bHasTwoFactor = msg.Body().twofactor_enabled();

		// Fetch app details, but force them to be re-loaded
		bool bForceReload = true;
		const CAccountDetails *pAccountDetails = GGCBase()->YieldingGetAccountDetails( steamID, bForceReload );

		// Account details is up to date so just return
		if ( pAccountDetails && bHasTwoFactor != pAccountDetails->BIsTwoFactorAuthEnabled() )
		{
			EmitWarning( SPEW_GC, 2, "VAC status didn't update for %s afetr receiving VacStatusChange and the force reloading the account details\n", steamID.Render() );
		}

		GGCBase()->YldOnAccountTwoFactorChange( steamID );

		EmitInfo( SPEW_GC, 5, 5, "AccountTwoFactorChange for %s\n", steamID.Render() );

		return true;
	}
};
GC_REG_JOB( CGCBase, CGCJobAccountTwoFactorChange, "CGCJobAccountTwoFactorChange", k_EGCMsgAccountTwoFactorChange, k_EServerTypeGC );

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGCBase::CGCBase( )
: 	m_mapSOCache( ),
	m_rbtreeSOCachesBeingLoaded( DefLessFunc( CSteamID ) ),
	m_rbtreeSOCachesWithDirtyVersions( DefLessFunc( CSteamID ) ),
	m_hashUserSessions( k_nUserSessionRunInterval/ k_cMicroSecPerShellFrame ),
	m_hashGSSessions( k_nGSSessionRunInterval/ k_cMicroSecPerShellFrame ),
	m_hashSteamIDLocks( k_nLocksRunInterval / k_cMicroSecPerShellFrame ),
	m_bStartupComplete( false ),
	m_bIsShuttingDown( false ),
	m_bStartProfiling( false ),
	m_bStopProfiling( false ),
	m_bDumpVprofImbalances( false ),
	m_nStartPlayingJobCount( 0 ),
	m_nRequestSessionJobsActive( 0 ),
	m_nLogonSurgeFramesRemaining( k_nMillion * 10 / k_cMicroSecPerShellFrame ), // stay in "logon surge" mode for at least 10 seconds after boot.
	m_mapStartPlayingQueueIndexBySteamID( DefLessFunc( CSteamID ) ),
	m_MsgRateLimit( max_user_messages_per_second ),
	m_nStartupCompleteTime( CRTime::RTime32TimeCur() ),
	m_nInitTime( CRTime::RTime32TimeCur() ),
	m_jobidFlushInventoryCacheAccounts( k_GIDNil ),
	m_numFlushInventoryCacheAccountsLastScheduled( 0 )
{
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGCBase::~CGCBase()
{
}


//-----------------------------------------------------------------------------
// Purpose: Remembers the app ID and host
//-----------------------------------------------------------------------------
bool CGCBase::BInit( AppId_t unAppID, const char *pchAppPath, IGameCoordinatorHost *pHost )
{
	VPROF_BUDGET( "CGCBase::BInit", VPROF_BUDGETGROUP_STEAM );

// Make sure we can't deploy debug GCs outside the dev environment
#ifdef _DEBUG
	if ( pHost->GetUniverse() != k_EUniverseDev )
	{
		//pHost->EmitMessage( SPEW_GC, SPEW_ERROR, SPEW_ALWAYS, LOG_ALWAYS, 
		//	CFmtStr( "The GC for App %u is a debug binary. Shutting down.\n", unAppID ) );
		//return false;
		pHost->EmitMessage( SPEW_GC.GetName(), SPEW_WARNING, SPEW_ALWAYS, LOG_ALWAYS, 
			CFmtStr( "The GC for App %u is a debug binary.\n", unAppID ) );
	}
#endif

	m_JobMgr.SetThreadPoolSize( GetThreadPoolSizeFromConVar() );

	MsgRegistrationFromEnumDescriptor( EGCSystemMsg_descriptor(), GCSDK::MT_GC_SYSTEM );
	MsgRegistrationFromEnumDescriptor( EGCBaseClientMsg_descriptor(), GCSDK::MT_GC );
	MsgRegistrationFromEnumDescriptor( EGCToGCMsg_descriptor(), GCSDK::MT_GC_SYSTEM );

	m_unAppID = unAppID;
	m_pHost = pHost;
	m_sPath = pchAppPath;
	SetGCHost( pHost );

	g_pGCBase = this;

	SetMinidumpFilenamePrefix( CFmtStr("dumps\\gc%d", m_unAppID) );

	// Make sure the assert dialog doesn't come up and hang the process in production
	//SetAssertDialogDisabled( pHost->GetUniverse() != k_EUniverseDev );
	SetAssertFailedNotifyFunc( CGCBase::AssertCallbackFunc );

	// init the time very early so CRTime::RTime32TimeCur will return the right thing
	CRTime::UpdateRealTime();

	m_hashUserSessions.Init( k_cGCUserSessionInit, k_cBucketGCUserSession );
	m_hashGSSessions.Init( k_cGCGSSessionInit, k_cBucketGCGSSession );
	m_hashSteamIDLocks.Init( k_cGCLocksInit, k_cBucketGCLocks );

	m_OutputFuncPrev = GetSpewOutputFunc();
	SpewOutputFunc( &ConsoleSpewFunc );
	EmitInfo( SPEW_GC, 1, 1, "CGCBase::BInit( AppID=%d, appPath=%s, sPath=%s )\n", unAppID, pchAppPath, m_sPath.String() );

	if ( !OnInit() )
		return false;

	DbgVerify( g_theMessageList.BInit( ) );

	/* 
	// @note Tom Bui: we don't need dynamic stats...yet.
	// when we do, we'll need to specify the how the values are aggregated over all the same GCs
	// and how the values should be treated
	KeyValuesAD pKVStats( "GCStats" );
	SystemStats_Update( pKVStats );
	CUtlBuffer buffer;
	KVPacker packer;
	if ( packer.WriteAsBinary( pKVStats, buffer ) )
	{
		CProtoBufMsg< CGCMsgSystemStatsSchema > msg( GCSDK::k_EGCMsgSystemStatsSchema );
		msg.Body().set_gc_app_id( GetAppID() );
		msg.Body().set_schema_kv( buffer.Base(), buffer.TellPut() );
		BSendSystemMessage( msg );
	}
	*/

	return BSendWebApiRegistration();
}


//-----------------------------------------------------------------------------
// Purpose: Report back to the host that startup is complete
//-----------------------------------------------------------------------------
void CGCBase::SetStartupComplete( bool bSuccess )
{
	// !KLUDGE! Fatal error messages on startup frequently get lost in the
	// mass of messages.  Let's spray a big error message box if we fail
	// to startup.  Ideally, the cause of the failure will be
	// spewed just above this box.
	if ( !bSuccess )
	{
		EmitError( SPEW_GC, "^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n" );
		EmitError( SPEW_GC, "GC failed to startup.  Error mesage is probably directly above\n" );
		EmitError( SPEW_GC, "**************************************************************\n" );
	}

	m_nStartupCompleteTime = CRTime::RTime32TimeCur();
	m_bStartupComplete = true;
	GGCHost()->StartupComplete( bSuccess );
}
 
uint32 CGCBase::GetGCUpTime() const
{ 
	return CRTime::RTime32TimeCur() - m_nInitTime; 
}
 
//-----------------------------------------------------------------------------
// Purpose: Starts a job to perform graceful shutdown
//-----------------------------------------------------------------------------
void CGCBase::Shutdown()
{
	VPROF_BUDGET( "CGCBase::Shutdown", VPROF_BUDGETGROUP_STEAM );
	m_DumpHTTPErrorsSchedule.Cancel();

	CGCShutdownJob *pJob = new CGCShutdownJob( this );
	pJob->StartJob( NULL );
}


//-----------------------------------------------------------------------------
// Purpose: Cleans up the GC to prepare for shutdown
//-----------------------------------------------------------------------------
void CGCBase::Uninit( )
{
	VPROF_BUDGET( "CGCBase::Uninit", VPROF_BUDGETGROUP_STEAM );

	OnUninit();

	// clean up all of the sessions and caches here so we can be sure it happens before the memory pools go away at static destruction time
	for( CGCUserSession **ppSession = m_hashUserSessions.PvRecordFirst(); ppSession != NULL; ppSession = m_hashUserSessions.PvRecordNext( ppSession ) )
	{
		delete (*ppSession);
	}
	m_hashUserSessions.RemoveAll();
	for( CGCGSSession **ppSession = m_hashGSSessions.PvRecordFirst(); ppSession != NULL; ppSession = m_hashGSSessions.PvRecordNext( ppSession ) )
	{
		delete (*ppSession);
	}
	m_hashGSSessions.RemoveAll();
	FOR_EACH_MAP_FAST( m_mapSOCache, nIndex )
	{
		// Remove from map before deleting, to prevent some debug
		// code from getting tangled up
		CGCSharedObjectCache *pCache = m_mapSOCache[nIndex];
		m_mapSOCache[nIndex] = NULL;
		m_mapSOCache.RemoveAt( nIndex );
		delete pCache;
	}
	m_mapSOCache.RemoveAll();
	m_rbtreeSOCachesBeingLoaded.RemoveAll();
	m_rbtreeSOCachesWithDirtyVersions.RemoveAll();
	m_hashSteamIDLocks.RemoveAll();
	
	GSchemaFull().Uninit();
	SpewOutputFunc( m_OutputFuncPrev );
}

GCConVar cv_flush_inventory_cache_jobs( "cv_flush_inventory_cache_jobs", "20", 0, "The maximum number of jobs flushing inventory caches that can be in flight at once, zero to disable flushing" );
GCConVar cv_flush_inventory_cache_contextid( "cv_flush_inventory_cache_contextid", "2" /* k_EEconContextBackpack */, 0, "Which context id we flush for Steam web user-facing inventory" );
GCConVar cv_flush_inventory_cache_spew( "cv_flush_inventory_cache_spew", "0", 0, "Controls spew level for jobs flushing inventory cache (0=off; 1=summary; 2=verbose)" );
class CFlushInventoryCacheAccountsJob : public CGCJob, public IYieldingParallelFarmJobHandler
{
public:
	CFlushInventoryCacheAccountsJob( CGCBase *pGC, CUtlRBTree< AccountID_t, int32, CDefLess< AccountID_t > > &rbAccounts ) : CGCJob( pGC )
	{
		m_rbAccounts.Swap( rbAccounts );
	}

	virtual bool BYieldingRunGCJob() OVERRIDE
	{
		if ( !m_rbAccounts.Count() )
		return false;
		if ( cv_flush_inventory_cache_jobs.GetInt() <= 0 )
			return false;

		bool bShouldSpew = ( cv_flush_inventory_cache_spew.GetInt() >= 1 );
		uint32 msTimeStart = 0;
		int numAccountsWorkload = m_rbAccounts.Count();
		if ( bShouldSpew )
		{
			msTimeStart = Plat_MSTime();
		}

		{	// Run parallel processing of the workload
			int numJobs = numAccountsWorkload;
			numJobs = MIN( cv_flush_inventory_cache_jobs.GetInt(), numJobs );
			numJobs = MAX( 1, numJobs );

			( void ) BYieldingExecuteParallel( numJobs, "YieldingFlushInventoryCacheAccountsJob" );
		}

		if ( bShouldSpew )
		{
			EmitInfo( SPEW_GC, SPEW_ALWAYS, LOG_ALWAYS, "IEconService/FlushInventoryCache: Batch for %d accounts completed in %u ms\n",
				numAccountsWorkload, Plat_MSTime() - msTimeStart );
		}

		return true;
	}

		virtual bool BYieldingRunWorkload( int iJobSequenceCounter, bool *pbWorkloadCompleted ) OVERRIDE
	{
		if ( m_rbAccounts.Count() )
		{
			int32 idxElement = m_rbAccounts.FirstInorder();
			AccountID_t unAccountID = m_rbAccounts.Element( idxElement );
			m_rbAccounts.RemoveAt( idxElement );

			( void ) BYieldingFlushRequest( unAccountID );
		}

		if ( !m_rbAccounts.Count() )
		{
			*pbWorkloadCompleted = true;
		}

		return true;
	}

		bool BYieldingFlushRequest( AccountID_t unAccountID )
	{
		bool bShouldSpew = ( cv_flush_inventory_cache_spew.GetInt() >= 2 );
		uint32 msTimeStart = 0;
		if ( bShouldSpew )
		{
			msTimeStart = Plat_MSTime();
		}

		CSteamID steamID( GGCInterface()->ConstructSteamIDForClient( unAccountID ) );
		CSteamAPIRequest apiRequest( k_EHTTPMethodPOST, "IEconService", "FlushInventoryCache", 1 );
		apiRequest.SetPOSTParamUInt32( "appid", GGCBase()->GetAppID() );
		apiRequest.SetPOSTParamUInt64( "steamid", steamID.ConvertToUint64() );
		apiRequest.SetPOSTParamUInt32( "contextid", 2 );

		CHTTPResponse apiResponse;
		bool bSucceededQuery = m_pGC->BYieldingSendHTTPRequest( &apiRequest, &apiResponse );
		if ( !bSucceededQuery )
		{
			EmitErrorRatelimited( SPEW_GC, "IEconService/FlushInventoryCache: Web call did not get a response for %s.\n", steamID.Render() );
		}
		else if ( k_EHTTPStatusCode200OK != apiResponse.GetStatusCode() )
		{
			EmitErrorRatelimited( SPEW_GC, "IEconService/FlushInventoryCache: Web call got failure code %d for %s\n", apiResponse.GetStatusCode(), steamID.Render() );
			bSucceededQuery = false;
		}

		if ( bSucceededQuery )
		{
			// Have a valid response
			KeyValuesAD pKVResponse( "response" );
			pKVResponse->UsesEscapeSequences( true );
			if ( !pKVResponse->LoadFromBuffer( "webResponse", *apiResponse.GetBodyBuffer() ) )
			{
				EmitErrorRatelimited( SPEW_GC, "IEconService/FlushInventoryCache: Web call got code %d for %s, but failed to parse response\n", apiResponse.GetStatusCode(), steamID.Render() );
				bSucceededQuery = false;
			}
			else if ( !pKVResponse->GetBool( "success" ) )
			{
				// We got a response, and it's not success
				EmitErrorRatelimited( SPEW_GC, "IEconService/FlushInventoryCache: Web call got code %d for %s, but not success\n", apiResponse.GetStatusCode(), steamID.Render() );
				bSucceededQuery = false;
			}
		}

		if ( bShouldSpew )
		{
			EmitInfo( SPEW_GC, SPEW_ALWAYS, LOG_ALWAYS, "IEconService/FlushInventoryCache: Web call for %s %s in %u ms\n",
				steamID.Render(), bSucceededQuery ? "succeeded" : "failed", Plat_MSTime() - msTimeStart );
		}

		return bSucceededQuery;
	}

public:
	CUtlRBTree< AccountID_t, int32, CDefLess< AccountID_t > > m_rbAccounts;
};

//-----------------------------------------------------------------------------
// Purpose: Called every frame. Mostly updates times and pulses the job manager
//-----------------------------------------------------------------------------
bool CGCBase::BMainLoopOncePerFrame( uint64 ulLimitMicroseconds )
{
	// if we don't have a GCHost yet, don't do any work per frame
	if( !GGCHost() )
		return false;

#ifndef STEAM
	CRTime::UpdateRealTime();
#endif


#ifdef VPROF_ENABLED
	// Make sure we end the frame at the root node
	if ( !g_VProfCurrentProfile.AtRoot() && m_bDumpVprofImbalances )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "VProf not at root at end of frame. Stack:\n" );
	}

	for( int i = 0; !g_VProfCurrentProfile.AtRoot() && i < 100; i++ )
	{
		if ( m_bDumpVprofImbalances )
		{
			EmitWarning( SPEW_GC, SPEW_ALWAYS, "  %s\n", g_VProfCurrentProfile.GetCurrentNode()->GetName() );
		}
		g_VProfCurrentProfile.ExitScope();
	}

	g_VProfCurrentProfile.MarkFrame();

	if ( m_bStopProfiling || m_bStartProfiling )
	{
		while ( g_VProfCurrentProfile.IsEnabled() )
		{
			g_VProfCurrentProfile.Stop();
		}
		m_bStopProfiling = false;

		if ( m_bStartProfiling )
		{
			g_VProfCurrentProfile.Reset();
			g_VProfCurrentProfile.Start();
			m_bStartProfiling = false;
		}
	}
#endif

	VPROF_BUDGET( "Main Loop", VPROF_BUDGETGROUP_STEAM );

	CLimitTimer limitTimer;
	limitTimer.SetLimit( ulLimitMicroseconds );
	CJobTime::UpdateJobTime( k_cMicroSecPerShellFrame );

	bool bWorkRemaining = m_JobMgr.BFrameFuncRunSleepingJobs( limitTimer );

	//run all of our frame functions
	GFrameFunctionMgr().RunFrame( limitTimer );

	{
		VPROF_BUDGET( "Run Sessions", VPROF_BUDGETGROUP_STEAM );

		m_AccountDetailsManager.MarkFrame();
		m_hashUserSessions.StartFrameSchedule( true );
		m_hashGSSessions.StartFrameSchedule( true );
		m_hashSteamIDLocks.StartFrameSchedule( true );
		bool bUsersFinished = false, bGSFinished = false;
		while( !limitTimer.BLimitReached() && ( !bUsersFinished || !bGSFinished ) )
		{
			if( !bUsersFinished )
			{
				CGCUserSession **ppSession = m_hashUserSessions.PvRecordRun();
				if ( ppSession && *ppSession )
				{
					(*ppSession)->Run();
				}	
				else
				{
					bUsersFinished = true;
				}
				if ( m_hashUserSessions.BCompletedPass() )
				{
					FinishedMainLoopUserSweep();
				}
			}

			if( !bGSFinished )
			{
				CGCGSSession **ppSession = m_hashGSSessions.PvRecordRun();
				if ( ppSession && *ppSession )
				{
					(*ppSession)->Run();
				}	
				else
				{
					bGSFinished = true;
				}
			}
		}
	}

	{
		VPROF_BUDGET( "UpdateSOCacheVersions", VPROF_BUDGETGROUP_STEAM );
		UpdateSOCacheVersions();
	}

	if( m_llStartPlaying.Count() > 0 )
	{
		VPROF_BUDGET( "StartStartPlayingJobs", VPROF_BUDGETGROUP_STEAM );

		int nJobsNeeded = min( m_llStartPlaying.Count(), cv_concurrent_start_playing_limit.GetInt() - m_nStartPlayingJobCount );
		while( nJobsNeeded > 0 )
		{
			nJobsNeeded--;
			m_nStartPlayingJobCount++;

			CExecuteStartPlayingJob *pJob = new CExecuteStartPlayingJob( this );
			pJob->StartJob( NULL );
		}
	}

	// Decide if we should be in logon surge
	bool bShouldBeInlogonSurge = 
		m_llStartPlaying.Count() >= cv_logon_surge_start_playing_limit.GetInt();
		// This might be a good idea, but let's see what the real numbers are during logon surge.
		//|| m_nRequestSessionJobsActive >= cv_logon_surge_request_session_jobs.GetInt();

	// Check if we're already in logon surge, is it time to check if we should leave,
	// and should we dump our status periodically?
	const int k_nLogonSurgeFrameInterval = k_nMillion * 10 / k_cMicroSecPerShellFrame;
	if ( m_nLogonSurgeFramesRemaining > 0 )
	{

		// Currently in logon surge
		--m_nLogonSurgeFramesRemaining;
		if ( m_nLogonSurgeFramesRemaining == 0 )
		{

			// Time to check for leaving logon surge mode.
			// Should I flip the flag off?
			if ( bShouldBeInlogonSurge )
			{
				// We're still in logon surge.  Schedule another check
				// a few frames from now, and dump our status.
				m_nLogonSurgeFramesRemaining = k_nLogonSurgeFrameInterval;
				Dump();
			}
			else
			{
				// We're over the hump!
				EmitInfo( SPEW_GC, SPEW_ALWAYS, LOG_ALWAYS, "** LOGON SURGE COMPLETED **\n" );
			}
		}
	}
	else if ( bShouldBeInlogonSurge )
	{
		// We finished logon surge one, but now we are re-entering it.
		// This usually doesn't happen.  This is suspicious.
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "RE-ENTERING logon surge mode!\n" );
		m_nLogonSurgeFramesRemaining = k_nLogonSurgeFrameInterval;
	}
	else
	{
		// Not in logon surge.  make sure flag is slammed to zero
		m_nLogonSurgeFramesRemaining = 0;
	}

	// Flush inventory cache for accounts
	if ( m_rbFlushInventoryCacheAccounts.Count() && ( ( m_jobidFlushInventoryCacheAccounts == k_GIDNil ) ||
		!GetJobMgr().BJobExists( m_jobidFlushInventoryCacheAccounts ) ) )
	{
		m_numFlushInventoryCacheAccountsLastScheduled = m_rbFlushInventoryCacheAccounts.Count();
		m_jobidFlushInventoryCacheAccounts = StartNewJobDelayed( new CFlushInventoryCacheAccountsJob( this, m_rbFlushInventoryCacheAccounts ) )->GetJobID();
	}

	bool bSubRet = OnMainLoopOncePerFrame( limitTimer );
	return bWorkRemaining || bSubRet;
}

bool CGCBase::BShouldThrottleLowServiceLevelWebAPIJobs() const
{

	// Always throttle them during logon surge.
	if ( BIsInLogonSurge() )
		return true;

	// Check threshold
	if ( m_JobMgr.CountJobs() > cv_webapi_throttle_job_threshold.GetInt() )
		return true;

	// We are not too busy, we can service the request
	return false;
}


bool CGCBase::BMainLoopUntilFrameCompletion( uint64 ulLimitMicroseconds )
{
	VPROF_BUDGET( "Main Loop", VPROF_BUDGETGROUP_STEAM );

	CLimitTimer limitTimer;
	limitTimer.SetLimit( ulLimitMicroseconds );
	bool bRet = m_JobMgr.BFrameFuncRunYieldingJobs( limitTimer );

	bRet |= GSDOCache().BFrameFuncRunJobsUntilCompleted( limitTimer );
	bRet |= GSDOCache().BFrameFuncRunMemcachedQueriesUntilCompleted( limitTimer );
	bRet |= GSDOCache().BFrameFuncRunSQLQueriesUntilCompleted( limitTimer );
	bRet |= m_AccountDetailsManager.BExpireRecords( limitTimer );

	bool bSubRet = OnMainLoopUntilFrameCompletion( limitTimer );

	bRet |= GFrameFunctionMgr().RunFrameTick( limitTimer );

	{
		VPROF_BUDGET( "Expire locks", VPROF_BUDGETGROUP_STEAM );

		for ( CLock *pLock = m_hashSteamIDLocks.PvRecordRun(); NULL != pLock; pLock = m_hashSteamIDLocks.PvRecordRun() )
		{
			if ( !pLock->BIsLocked() && pLock->GetMicroSecondsSinceLock() > k_cMicroSecLockLifetime )
			{
				m_hashSteamIDLocks.Remove( pLock );
			}

			if ( limitTimer.BLimitReached() )
				return true;
		}
	}

	return bRet || bSubRet;
 }

//-----------------------------------------------------------------------------
// Purpose: Called when we get to the end of a user session Run() sweep, and
//			are about to start over with the first session in the list.
//-----------------------------------------------------------------------------
void CGCBase::FinishedMainLoopUserSweep()
{
	// Base class does nothing
}


//-----------------------------------------------------------------------------
// Purpose: Queues up a start playing request that we should process when we
//			get a chance.
//-----------------------------------------------------------------------------
void CGCBase::QueueStartPlaying( const CSteamID & steamID, const CSteamID & gsSteamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData )
{
	MEM_ALLOC_CREDIT_( "QueueStartPlaying" );

	Assert( steamID.BIndividualAccount() || steamID.BGameServerAccount() );
	Assert( steamID.IsValid() );

	// Should be one-to-one correspondence in these data structures
	Assert( (size_t)m_mapStartPlayingQueueIndexBySteamID.Count() == (size_t)m_llStartPlaying.Count() );

	// !FIXME! Here we really should check whether they already have a session.
	// if so, we've already gone through all the startplaying work and shouldn't
	// repeat it.  We might just need to kick the communications or make
	// sure they are on the right game server.

	// Check if we already have an entry in the queue for this guy.
	StartPlayingWork_t *pWork = NULL;
	int nMapIndex = m_mapStartPlayingQueueIndexBySteamID.Find( steamID );
	if ( nMapIndex != m_mapStartPlayingQueueIndexBySteamID.InvalidIndex() )
	{
		// We already have an entry for this guy, let's update this one, rather than creating a new one
		int nQueueIndex = m_mapStartPlayingQueueIndexBySteamID[ nMapIndex ];
		pWork = &m_llStartPlaying[ nQueueIndex ];

		// Sanity check data structures.  I'd use an assert,
		// but this is going live in an environment without
		// asserts enabled, so I need to use spew.
		if ( pWork->m_steamID == steamID )
		{
			// Don't leak user data, if we had any
			delete pWork->m_pVarData;
			pWork->m_pVarData = NULL;

//			// This could definitely happen occasionally, but if it happens with massive frequency,
//			// something is wrong
//			if ( gsSteamID == pWork->m_gsSteamID )
//			{
//				EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "Got StartPlaying message for %s, who was already in the startplaying queue for the same gameserver %s.\n", steamID.Render(), gsSteamID.Render() );
//			}
//			else
//			{
//				EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "Got StartPlaying message for %s, who was already in the startplaying queue; changing gameserver %s -> %s.\n", steamID.Render(), pWork->m_gsSteamID.Render(), gsSteamID.Render() );
//			}
		}
		else
		{
			EmitWarning( SPEW_GC, SPEW_ALWAYS, "Start playing queue corruption!  Map entry points to wrong queue entry!\n" );
			pWork = NULL;
			m_mapStartPlayingQueueIndexBySteamID.RemoveAt( nMapIndex );
		}
	}
	else
	{
//		EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "Got StartPlaying message for %s, new queue for gameserver %s.\n", steamID.Render(), gsSteamID.Render() );
	}

	// Need to create a new entry?
	if ( pWork == NULL )
	{
		// Create a new queue entry
		int nQueueIndex = m_llStartPlaying.AddToTail();
		pWork = &m_llStartPlaying[ nQueueIndex ];

		// Add it to the steam ID map, so we can locate this guy quickly in the future
		m_mapStartPlayingQueueIndexBySteamID.Insert( steamID, nQueueIndex );
	}

	// Fill in the queue entry with the latest details
	pWork->m_steamID = steamID;
	pWork->m_gsSteamID = gsSteamID;
	pWork->m_unServerAddr = unServerAddr;
	pWork->m_usServerPort = usServerPort;

	if( cubVarData )
	{
		pWork->m_pVarData = new CUtlBuffer;
		pWork->m_pVarData->Put( pubVarData, cubVarData );
	}
	else
	{
		pWork->m_pVarData = NULL;
	}

	// Should be one-to-one correspondence in these data structures
	Assert( (size_t)m_mapStartPlayingQueueIndexBySteamID.Count() == (size_t)m_llStartPlaying.Count() );
}

//-----------------------------------------------------------------------------
bool CGCBase::BRemoveStartPlayingQueueEntry( const CSteamID & steamID )
{
	int nMapIndex = m_mapStartPlayingQueueIndexBySteamID.Find( steamID );
	if ( nMapIndex == m_mapStartPlayingQueueIndexBySteamID.InvalidIndex() )
	{
		return false;
	}

	//EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "Removed startplaying queue entry for %s.\n", steamID.Render() );

	// Locate queue entry, make sure it matches, and remote it
	int nQueueIndex = m_mapStartPlayingQueueIndexBySteamID[ nMapIndex ];
	if ( m_llStartPlaying[ nQueueIndex ].m_steamID == steamID )
	{
		delete m_llStartPlaying[ nQueueIndex ].m_pVarData;
		m_llStartPlaying.Remove( nQueueIndex );
	}
	else
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Start playing queue corruption!  Map entry doesn't point to matching queue index (found while removing entry in BRemoveStartPlayingQueueEntry)!\n" );
	}

	// Remove from map
	m_mapStartPlayingQueueIndexBySteamID.RemoveAt( nQueueIndex );

	// Found and removed
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Pull the next startplaying job off the queue and executes it
//-----------------------------------------------------------------------------
void CGCBase::YieldingExecuteNextStartPlaying()
{
	// maybe we have nothing to do!
	if( m_llStartPlaying.Count() > 0 )
	{
		// Execute the entry at the head
		YieldingExecuteStartPlayingQueueEntryByIndex( m_llStartPlaying.Head() );
	}
	m_nStartPlayingJobCount--;
}

//-----------------------------------------------------------------------------
// Purpose: Executes a single entry from the start playing queue, given the linked list handle
//-----------------------------------------------------------------------------
void CGCBase::YieldingExecuteStartPlayingQueueEntryByIndex( int idxStartPlayingQueue )
{
	VPROF_BUDGET( "CGCBase::YieldingExecuteStartPlayingQueueEntryByIndex - LinkedList", VPROF_BUDGETGROUP_STEAM );
	// Remove the entry from the queue
	StartPlayingWork_t work = m_llStartPlaying[ idxStartPlayingQueue ];
	m_llStartPlaying.Remove( idxStartPlayingQueue );

	VPROF_BUDGET( "CGCBase::YieldingExecuteStartPlayingQueueEntryByIndex", VPROF_BUDGETGROUP_STEAM );
	// Remove it from the Steam ID map, too.
	int nMapIndex = m_mapStartPlayingQueueIndexBySteamID.Find( work.m_steamID );
	if ( nMapIndex == m_mapStartPlayingQueueIndexBySteamID.InvalidIndex() )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Start playing queue corruption!  Queue entry is not in map!\n" );
	}
	else if ( m_mapStartPlayingQueueIndexBySteamID[ nMapIndex ] != idxStartPlayingQueue )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Start playing queue corruption!  Map entry doesn't have proper queue index!\n" );
	}
	else
	{
		m_mapStartPlayingQueueIndexBySteamID.RemoveAt( nMapIndex );
	}

	// Do the work.
	if ( work.m_steamID.BIndividualAccount() )
	{
		YieldingStartPlaying( work.m_steamID, work.m_gsSteamID, work.m_unServerAddr, work.m_usServerPort, work.m_pVarData );
	}
	else if ( work.m_steamID.BGameServerAccount() )
	{
		const uint8 *pVarData = NULL;
		uint32 cubVarData = 0;
		if ( work.m_pVarData != NULL )
		{
			pVarData = (const uint8 *)work.m_pVarData->Base();
			cubVarData = work.m_pVarData->TellMaxPut();
		}
		YieldingStartGameserver( work.m_steamID, work.m_unServerAddr, work.m_usServerPort, pVarData, cubVarData );
	}
	else
	{
		AssertMsg1( false, "Bogus steam ID %s in start playing queue", work.m_steamID.Render() );
	}

	// Clean up
	delete work.m_pVarData;
}

void CGCBase::SetUserSessionDetails( CGCUserSession *pUserSession, KeyValues *pkvDetails )
{
	if( pkvDetails )
	{
		pUserSession->m_unIPPublic = pkvDetails->GetInt( "ip", 0 );
		pUserSession->m_osType = static_cast<EOSType>( pkvDetails->GetInt( "osType", k_eOSUnknown ) );
		pUserSession->m_bIsTestSession = pkvDetails->GetInt( "isTestSession", 0 ) != 0;
		pUserSession->m_bIsSecure = pkvDetails->GetInt( "secure", 0 ) != 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Does the real work when a player starts playing (inside a job)
//-----------------------------------------------------------------------------
void CGCBase::YieldingStartPlaying( const CSteamID & steamID, const CSteamID & gsSteamID, uint32 unServerAddr, uint16 usServerPort, CUtlBuffer *pVarData )
{
	VPROF_BUDGET( "CGCBase::YieldingStartPlaying", VPROF_BUDGETGROUP_STEAM );
	if ( m_bIsShuttingDown )
		return;

	if( !BYieldingLockSteamID( steamID, __FILE__, __LINE__ ) )
	{
		EmitError( SPEW_GC, "Failed to lock steamID %s in YieldingStartPlaying\n", steamID.Render() );
		return;
	}

	// if var data came with this StartPlaying message, parse it into a KV and stick it on the session
	KeyValues *pkvDetails = NULL;
	if( pVarData )
	{
		MEM_ALLOC_CREDIT_("StartPlaying - SessionDetails" );
		pkvDetails = new KeyValues( "SessionDetails" );
		if( !pkvDetails->ReadAsBinary( *pVarData ) )
		{
			EmitError( SPEW_GC, "Unable to parse session details for %s\n", steamID.Render() );
			pkvDetails->deleteThis();
			pkvDetails = NULL;
		}
	}

	CGCUserSession *pSession = FindUserSession( steamID );
	if( !pSession )
	{
		// Load their SO cache.  Remember, we already have their steam ID locked.
		VPROF_BUDGET( "CGCBase::YieldingStartPlaying - Load SOCache", VPROF_BUDGETGROUP_STEAM );
		CGCSharedObjectCache *pSOCache = YieldingFindOrLoadSOCache( steamID );
		if ( !pSOCache )
		{
			EmitError( SPEW_GC, "Failed to get cache for user %s\n", steamID.Render() );
			return;
		}

		// Create session of app-specific type
		VPROF_BUDGET( "CGCBase::YieldingStartPlaying - CreateUserSession", VPROF_BUDGETGROUP_STEAM );
		pSession = CreateUserSession( steamID, pSOCache );
		if ( !pSession )
		{
			EmitError( SPEW_GC, "Failed to create user session for %s\n", steamID.Render() );
			return;
		}

		VPROF_BUDGET( "CGCBase::YieldingStartPlaying - LRU Update", VPROF_BUDGETGROUP_STEAM );
		RemoveCacheFromLRU( pSOCache );

		CGCUserSession **ppSession = m_hashUserSessions.PvRecordInsert( steamID.ConvertToUint64() );
		*ppSession = pSession;

		SetUserSessionDetails( pSession, pkvDetails );

		// Do game-specific logic here.  Note that we're still holding the game server
		// lock...
		VPROF_BUDGET( "CGCBase::YieldingStartPlaying - Game-specific start playing", VPROF_BUDGETGROUP_STEAM );
		YieldingSessionStartPlaying( pSession );
	}
	else if ( pSession->BIsShuttingDown() )
	{
		pkvDetails->deleteThis();
		pkvDetails = NULL;
		return;
	}
	else
	{
		// Update secure flag, etc from KV details, if any
		SetUserSessionDetails( pSession, pkvDetails );
	}

	if ( pkvDetails )
	{
		pkvDetails->deleteThis();
		pkvDetails = NULL;
	}

	VPROF_BUDGET( "CGCBase::YieldingStartPlaying - Game Server binding", VPROF_BUDGETGROUP_STEAM );
	// Make sure the server exists and then try to join it
	if ( gsSteamID.IsValid() && gsSteamID.BGameServerAccount() && BYieldingLockSteamID( gsSteamID, __FILE__, __LINE__ ) )
	{

		// First, try to obtain a session through ordinary means, by validating
		// the session
		if ( YieldingGetLockedGSSession( gsSteamID, __FILE__, __LINE__ ) != NULL )
		{
			// Maintain lock balance
			UnlockSteamID( gsSteamID );
		}
		else
		{
			// Failed to get a session --- probably an AM is down.
			// This is hopefully relatively rare, as it's not ideal.
			// log it
			if ( enable_startplaying_gameserver_creation_spew.GetBool() )
			{
				netadr_t serverAdr( unServerAddr, usServerPort );
				EmitInfo( SPEW_GC, 2, LOG_ALWAYS, "Creating gameserver session %s @ %s as a result of user %s StartPlaying.\n", gsSteamID.Render(), serverAdr.ToString(), steamID.Render() );
			}
			YieldingFindOrCreateGSSession( gsSteamID, unServerAddr, usServerPort, NULL, 0 );
		}

		// Mark that we are joined to this server
		pSession->BSetServer( gsSteamID );

		// Done, clean up lock
		UnlockSteamID( gsSteamID );
	}
	else
	{
		// Steam was sometimes sending us messages with zero Steam ID, even when we're on a server.
		if ( cv_debug_steam_startplaying.GetBool() )
			EmitInfo( SPEW_GC, 1, 1, "YieldingStartPlaying ( user = %s ) with invalid GS steam ID %s, calling LeaveServer\n", steamID.Render(), gsSteamID.Render() );

		pSession->BLeaveServer();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Called when a player stops playing our game
//-----------------------------------------------------------------------------
void CGCBase::YieldingStopPlaying( const CSteamID & steamID )
{
	// Should be one-to-one correspondence in these data structures
	Assert( (size_t)m_mapStartPlayingQueueIndexBySteamID.Count() == (size_t)m_llStartPlaying.Count() );

	// Check if they have an entry in the startplaying queue, then get rid of it!
	BRemoveStartPlayingQueueEntry( steamID );

	if ( !BLockSteamIDImmediate( steamID ) )
	{
		CGCUserSession *pSession = FindUserSession( steamID );
		if ( !pSession )
		{
			return;
		}

		pSession->SetIsShuttingDown( true );
		if( !BYieldingLockSteamID( steamID, __FILE__, __LINE__ ) )
		{
			EmitError( SPEW_GC, "Unable to lock steamID %s in YieldingStopPlaying\n", steamID.Render() );
			return;
		}
	}

	CGCUserSession *pSession = FindUserSession( steamID );
	if( pSession )
	{
		pSession->BLeaveServer();
		YieldingSessionStopPlaying( pSession );
		if( pSession->GetSOCache() )
		{
			AddCacheToLRU( pSession->GetSOCache() );
		}
		m_hashUserSessions.Remove( steamID.ConvertToUint64() );
		delete pSession;
	}

	// Clean up lock.  Even if the session is gone and there's nothing
	// for the lock to protect, we need this to avoid spurious asserts that check
	// lock imbalance
	UnlockSteamID( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: Called when a gameserver stops running for our game
//-----------------------------------------------------------------------------
void CGCBase::YieldingStartGameserver( const CSteamID & steamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData )
{
	VPROF_BUDGET( "CGCBase::YieldingStartGameserver", VPROF_BUDGETGROUP_STEAM );
	if ( m_bIsShuttingDown )
		return;

	if( !BYieldingLockSteamID( steamID, __FILE__, __LINE__ ) )
	{
		EmitError( SPEW_GC, "Failed to lock steamID %s in YieldingStartGameserver\n", steamID.Render() );
		return;
	}

	YieldingFindOrCreateGSSession( steamID, unServerAddr, usServerPort, pubVarData, cubVarData );

	// Clean up
	UnlockSteamID( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: Called when a gameserver stops running for our game
//-----------------------------------------------------------------------------
void CGCBase::YieldingStopGameserver( const CSteamID & steamID )
{
	// Should be one-to-one correspondence in these data structures
	Assert( (size_t)m_mapStartPlayingQueueIndexBySteamID.Count() == (size_t)m_llStartPlaying.Count() );

	// Check if they have an entry in the startplaying queue, then get rid of it!
	BRemoveStartPlayingQueueEntry( steamID );

	if ( !BLockSteamIDImmediate( steamID ) )
	{
		CGCGSSession *pSession = FindGSSession( steamID );
		if ( !pSession )
		{
			return;
		}

		pSession->SetIsShuttingDown( true );
		if( !BYieldingLockSteamID( steamID, __FILE__, __LINE__ ) )
		{
			EmitError( SPEW_GC, "Unable to lock steamID %s in YieldingStopGameserver\n", steamID.Render() );
			return;
		}
	}
	
	CGCGSSession *pSession = FindGSSession( steamID );
	if( pSession )
	{
		pSession->RemoveAllUsers();
		YieldingSessionStopServer( pSession );
		if( pSession->GetSOCache() )
		{
			AddCacheToLRU( pSession->GetSOCache() );
		}
		m_hashGSSessions.Remove( steamID.ConvertToUint64() );
		delete pSession;
	}

	// Clean up lock.  Even if the session is gone and there's nothing
	// for the lock to protect, we need this to avoid spurious asserts that check
	// lock imbalance
	UnlockSteamID( steamID );
}

IMsgNetPacket *CreateIMsgNetPacket( GCProtoBufMsgSrc eReplyType, const CSteamID senderID, uint32 nGCDirIndex, uint32 unMsgType, void *pubData, uint32 cubData )
{
	VPROF_BUDGET( "CreateIMsgNetPacket", VPROF_BUDGETGROUP_STEAM );

	if( 0 != ( unMsgType & k_EMsgProtoBufFlag ) )
	{
		if ( cubData < sizeof( ProtoBufMsgHeader_t ) )
		{
			uint32 unMsgTypeNoFlag = unMsgType & (~k_EMsgProtoBufFlag);
			AssertMsg3( false, "Received packet %s(%u) from %s less than the minimum protobuf size", PchMsgNameFromEMsg( unMsgTypeNoFlag ), unMsgTypeNoFlag, senderID.Render() );
			return NULL;
		}

		// make a new packet for the message so we can dispatch it
		// The CNetPacket takes ownership of the buffer allocated above
		CNetPacket *pGCPacket = CNetPacketPool::AllocNetPacket();
		pGCPacket->Init( cubData );

		// copy the bits for the message over to the full size buffer
		Q_memcpy( pGCPacket->PubData(), pubData, cubData );

		CProtoBufNetPacket *pMsgNetPacket = new CProtoBufNetPacket( pGCPacket, eReplyType, senderID, nGCDirIndex, unMsgType & ( ~k_EMsgProtoBufFlag ) );

		// release the inner packet since the wrapper now has a ref to it
		pGCPacket->Release();

		if ( !pMsgNetPacket->IsValid() )
		{
			pMsgNetPacket->Release();
			return NULL;
		}
		
		return pMsgNetPacket;
	}
	else
	{
		//note that we do not currently support reply to GC messages through this pipeline
		AssertMsg( eReplyType != GCProtoBufMsgSrc_FromGC, "Warning: Encountered a message from GC to GC that was not of protobuff type, will be unable to reply to this message. Message type: %d", unMsgType );

		if ( cubData < sizeof( GCMsgHdrEx_t ) - sizeof( GCMsgHdr_t ) )
		{
			AssertMsg( false, "Received packet %s(%u) from %s less than the minimum struct size", PchMsgNameFromEMsg( unMsgType ), unMsgType, senderID.Render() );
			return NULL;
		}

		// Determine the size of the packet. sizeof(GCMsgHdr_t) was not sent as part of the data
		uint32 unFullSize = cubData + sizeof( GCMsgHdr_t );

		// make a new packet for the message so we can dispatch it
		// The CNetPacket takes ownership of the buffer allocated above
		CNetPacket *pGCPacket = CNetPacketPool::AllocNetPacket();
		pGCPacket->Init( unFullSize );

		//fill in our header and copy over the body
		uint8 *pFullPacket = pGCPacket->PubData();

		// get the header so we can fix it up
		GCMsgHdrEx_t *pHdr = (GCMsgHdrEx_t *)pFullPacket;
		//pHdr->m_nSrcGCDirIndex = nGCDirIndex;
		pHdr->m_eMsg = unMsgType;
		pHdr->m_ulSteamID = senderID.ConvertToUint64();

		// copy the bits for the message over to the full size buffer
		Q_memcpy( pFullPacket+sizeof(GCMsgHdr_t), pubData, cubData );

		
		CStructNetPacket *pMsgNetPacket = new CStructNetPacket( pGCPacket );

		// release the packet
		pGCPacket->Release();
		return pMsgNetPacket;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Processes an incoming message from the client by turning it into a 
//			CGCMsg and sending it on to a job.
//-----------------------------------------------------------------------------
void CGCBase::MessageFromClient( const CSteamID & senderID, uint32 unMsgType, void *pubData, uint32 cubData )
{
	VPROF_BUDGET( "CGCBase::MessageFromClient", VPROF_BUDGETGROUP_STEAM );
 
	// if we don't have a GCHost yet, we won't be able to do much with this message
	if( !GGCHost() )
		return;

	if ( OnMessageFromClient( senderID, unMsgType, pubData, cubData ) )
		return;

	// Rate limit messages from ordinary clients
	if ( senderID.IsValid() )
	{
		MsgType_t eMsg = unMsgType & ~k_EMsgProtoBufFlag;
		if ( m_MsgRateLimit.BIsRateLimited( senderID, eMsg ) )
		{
			g_RateLimitTracker.TrackRateLimitedMsg( senderID, eMsg );
			return;
		}
	}

	// !FIXME! DOTAMERGE
	uint32 nGCDirIndex = 0; // GetGCDirIndex()
	IMsgNetPacket *pMsgNetPacket = CreateIMsgNetPacket( GCProtoBufMsgSrc_FromSteamID, senderID, nGCDirIndex, unMsgType, pubData, cubData );
	if ( NULL == pMsgNetPacket )
		return;

	// dispatch the packet (some messages require special consideration) 
	switch( unMsgType )
	{
		case k_EGCMsgWGRequest:
			m_wgJobMgr.BHandleMsg( pMsgNetPacket );
			g_theMessageList.TallySendMessage( pMsgNetPacket->GetEMsg(), cubData );
			break;

		default:
			GetJobMgr().BRouteMsgToJob( this, pMsgNetPacket, JobMsgInfo_t( pMsgNetPacket->GetEMsg(), pMsgNetPacket->GetSourceJobID(), pMsgNetPacket->GetTargetJobID(), k_EServerTypeGC ) );
			g_theMessageList.TallySendMessage( pMsgNetPacket->GetEMsg(), cubData );
			break;
	}

	// release the packet
	pMsgNetPacket->Release();
}


//-----------------------------------------------------------------------------
// Purpose: Sends a message to the given SteamID
//-----------------------------------------------------------------------------
bool CGCBase::BSendGCMsgToClient( const CSteamID & steamIDTarget, const CGCMsgBase& msg )
{
	g_theMessageList.TallySendMessage( msg.Hdr().m_eMsg, msg.CubPkt() - sizeof(GCMsgHdr_t) );
	VPROF_BUDGET( "GCHost", VPROF_BUDGETGROUP_STEAM );
	{
		VPROF_BUDGET( "GCHost - SendMessageToClient", VPROF_BUDGETGROUP_STEAM );
		return m_pHost->BSendMessageToClient( m_unAppID, steamIDTarget, msg.Hdr().m_eMsg, msg.PubPkt() + sizeof(GCMsgHdr_t), msg.CubPkt() - sizeof(GCMsgHdr_t) );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Used to send protobuf system messages to a client
//-----------------------------------------------------------------------------
class CProtoBufClientSendHandler : public CProtoBufMsgBase::IProtoBufSendHandler
{
public:
	CProtoBufClientSendHandler( const CSteamID & steamIDTarget ) 
		: m_steamIDTarget( steamIDTarget ), m_cubSent( 0 ) {}
	virtual bool BAsyncSend( MsgType_t eMsg, const uint8 *pubMsgBytes, uint32 cubSize ) OVERRIDE
	{	
		m_cubSent = cubSize;
		// !FIXME! DOTAMERGE
		//return GGCInterface()->BProcessSystemMessage( eMsg | k_EMsgProtoBufFlag, pubMsgBytes, cubSize );
		g_theMessageList.TallySendMessage( eMsg & ~k_EMsgProtoBufFlag, cubSize );
		VPROF_BUDGET( "GCHost", VPROF_BUDGETGROUP_STEAM );
		{
			VPROF_BUDGET( "GCHost - SendMessageToClient (ProtoBuf)", VPROF_BUDGETGROUP_STEAM );
			return GGCHost()->BSendMessageToClient( GGCBase()->GetAppID(), m_steamIDTarget, eMsg | k_EMsgProtoBufFlag, pubMsgBytes, cubSize );
		}
	}
	uint32 GetCubSent() const { return m_cubSent; }
private:
	uint32 m_cubSent;
	CSteamID m_steamIDTarget;
};

//-----------------------------------------------------------------------------
// Purpose: Used to send protobuf system messages into the GC
//-----------------------------------------------------------------------------
class CProtoBufSystemSendHandler : public CProtoBufMsgBase::IProtoBufSendHandler
{
public:
	CProtoBufSystemSendHandler() 
		: m_cubSent( 0 ) {}
	virtual bool BAsyncSend( MsgType_t eMsg, const uint8 *pubMsgBytes, uint32 cubSize ) OVERRIDE
	{	
		m_cubSent = cubSize;
		// !FIXME! DOTAMERGE
		//return GGCInterface()->BProcessSystemMessage( eMsg | k_EMsgProtoBufFlag, pubMsgBytes, cubSize );
		g_theMessageList.TallySendMessage( eMsg & ~k_EMsgProtoBufFlag, cubSize );
		VPROF_BUDGET( "GCHost", VPROF_BUDGETGROUP_STEAM );
		{
			VPROF_BUDGET( "GCHost - SendMessageToSystem (ProtoBuf)", VPROF_BUDGETGROUP_STEAM );
			return GGCHost()->BSendMessageToClient( GGCBase()->GetAppID(), CSteamID(), eMsg | k_EMsgProtoBufFlag, pubMsgBytes, cubSize );
		}
	}
	uint32 GetCubSent() const { return m_cubSent; }
private:
	uint32 m_cubSent;
};


//-----------------------------------------------------------------------------
// Purpose: Sends a message to the given SteamID
//-----------------------------------------------------------------------------
bool CGCBase::BSendGCMsgToClient( const CSteamID & steamIDTarget, const CProtoBufMsgBase& msg )
{
	CProtoBufClientSendHandler sender( steamIDTarget );
	return msg.BAsyncSend( sender );
}


//-----------------------------------------------------------------------------
// Purpose: Sends a system message to the GC Host
//-----------------------------------------------------------------------------
bool CGCBase::BSendSystemMessage( const CGCMsgBase& msg, uint32 *pcubSent )
{
	uint32 cubSent = msg.CubPkt() - sizeof(GCMsgHdr_t);
	if ( NULL != pcubSent )
	{
		*pcubSent = cubSent;
	}

	// !FIXME! DOTAMERGE
	//return GGCInterface()->BProcessSystemMessage( msg.Hdr().m_eMsg, msg.PubPkt() + sizeof(GCMsgHdr_t), cubSent );
	return BSendGCMsgToClient( CSteamID(), msg );
}


//-----------------------------------------------------------------------------
// Purpose: Sends a system message to the GC Host
//-----------------------------------------------------------------------------
bool CGCBase::BSendSystemMessage( const CProtoBufMsgBase & msg, uint32 *pcubSent )
{
	CProtoBufSystemSendHandler sender;
	bool bRet = msg.BAsyncSend( sender );
	if ( NULL != pcubSent )
	{
		*pcubSent = sender.GetCubSent();
	}
	return bRet;
}

bool CGCBase::BSendSystemMessage( const ::google::protobuf::Message &msgOut, MsgType_t eSendMsg )
{
	CProtoBufSystemSendHandler sender;
	CMsgProtoBufHeader hdr;
	return CProtoBufMsgBase::BAsyncSendProto( sender, eSendMsg, hdr, msgOut );
}

//-----------------------------------------------------------------------------
// Purpose: send msgOut to the place that msgIn came from
//-----------------------------------------------------------------------------
bool CGCBase::BReplyToMessage( CGCMsgBase &msgOut, const CGCMsgBase &msgIn )
{
	// Don't reply if the source is not expecting it
	if ( !msgIn.BIsExpectingReply() )
		return true;

	msgOut.Hdr().m_JobIDTarget = msgIn.Hdr().m_JobIDSource;
	return BSendGCMsgToClient( msgIn.Hdr().m_ulSteamID, msgOut );
}


//-----------------------------------------------------------------------------
// Purpose: send msgOut to the place that msgIn came from
//-----------------------------------------------------------------------------
bool CGCBase::BReplyToMessage( CProtoBufMsgBase &msgOut, const CProtoBufMsgBase &msgIn )
{
	// Don't reply if the source is not expecting it
	if ( !msgIn.GetJobIDSource() )
		return true;

	msgOut.SetJobIDTarget( msgIn.GetJobIDSource() );
	return BSendGCMsgToClient( msgIn.GetClientSteamID(), msgOut );
}

//-----------------------------------------------------------------------------
// Purpose: Sends a message to the given SteamID
//-----------------------------------------------------------------------------
bool CGCBase::BSendGCMsgToClientWithPreSerializedBody( const CSteamID & steamIDTarget, MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const byte *pubBody, uint32 cubBody ) const
{
	CProtoBufClientSendHandler sender( steamIDTarget );
	return CProtoBufMsgBase::BAsyncSendWithPreSerializedBody( sender, eMsgType, hdr, pubBody, cubBody );
}

//-----------------------------------------------------------------------------
// Purpose: Sends a message that has already been packed to the system handler
//-----------------------------------------------------------------------------
bool CGCBase::BSendGCMsgToSystemWithPreSerializedBody( MsgType_t eMsgType, const CMsgProtoBufHeader& hdr, const byte *pubBody, uint32 cubBody ) const
{
	CProtoBufSystemSendHandler sender;
	return CProtoBufMsgBase::BAsyncSendWithPreSerializedBody( sender, eMsgType, hdr, pubBody, cubBody );
}

//-----------------------------------------------------------------------------
// Purpose: send msgOut to the place that msgIn came from
//-----------------------------------------------------------------------------
bool CGCBase::BReplyToMessageWithPreSerializedBody( MsgType_t eMsgType, const CProtoBufMsgBase &msgIn, const byte *pubBody, uint32 cubBody ) const
{
	// Don't reply if the source is not expecting it
	if ( !msgIn.GetJobIDSource() )
		return true;

	if( temp_list_mismatched_replies.GetBool() && !msgIn.BIsExpectingReply() )
	{
		EG_MSG( g_EGMessages, "Message %s was sent to client %s which did not expect a reply\n", PchMsgNameFromEMsg( eMsgType ), msgIn.GetClientSteamID().Render() );
	}

	CMsgProtoBufHeader hdr;
	hdr.set_job_id_target( msgIn.GetJobIDSource() );

	//is this a system message or a client message we are responding to?
	bool bSystemReply = ( msgIn.GetClientSteamID() == k_steamIDNil );

	if( bSystemReply )
	{
		return BSendGCMsgToSystemWithPreSerializedBody( eMsgType, hdr, pubBody, cubBody );
	}
	else
	{
		return BSendGCMsgToClientWithPreSerializedBody( msgIn.GetClientSteamID(), eMsgType, hdr, pubBody, cubBody );
	}
}

//-----------------------------------------------------------------------------
// Purpose: send msgOut to the place that msgIn came from
//-----------------------------------------------------------------------------

bool CGCBase::BYldSendMessageAndGetReply( const CSteamID &steamIDTarget, CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg )
{
	CJob& curJob = GJobCur();
	msgOut.ExpectingReply( curJob.GetJobID() );

	if ( !BSendGCMsgToClient( steamIDTarget, msgOut ) )
		return false;

	if( !curJob.BYieldingWaitForMsg( pMsgIn, eMsg, steamIDTarget ) )
		return false;

	return true;
}

//bool CGCBase::BYldSendGCMessageAndGetReply( int32 nGCDirIndex, CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg )
//{
//	CJob& curJob = GJobCur();
//	msgOut.ExpectingReply( curJob.GetJobID() );
//
//	if ( !BSendGCMessage( nGCDirIndex, msgOut ) )
//		return false;
//
//	if( !curJob.BYieldingWaitForMsg( pMsgIn, eMsg, CSteamID() ) )
//		return false;
//
//	return true;
//}

bool CGCBase::BYldSendSystemMessageAndGetReply( CGCMsgBase &msgOut, CGCMsgBase *pMsgIn, MsgType_t eMsg )
{
	CJob& curJob = GJobCur();
	msgOut.ExpectingReply( curJob.GetJobID() );

	if ( !BSendSystemMessage( msgOut ) )
		return false;

	if( !curJob.BYieldingWaitForMsg( pMsgIn, eMsg, CSteamID() ) )
		return false;

	return true;
}

bool CGCBase::BYldSendSystemMessageAndGetReply( CProtoBufMsgBase &msgOut, CProtoBufMsgBase *pMsgIn, MsgType_t eMsg )
{
	CJob& curJob = GJobCur();
	msgOut.ExpectingReply( curJob.GetJobID() );

	if ( !BSendSystemMessage( msgOut ) )
		return false;

	if( !curJob.BYieldingWaitForMsg( pMsgIn, eMsg, CSteamID() ) )
		return false;

	return true;
}

bool CGCBase::BYldSendSystemMessageAndGetReply( const ::google::protobuf::Message &msgSend, MsgType_t eSendMsg, ::google::protobuf::Message *pMsgResponse, MsgType_t eRespondMsg )
{
	CJob& curJob = GJobCur();

	CMsgProtoBufHeader hdr;
	hdr.set_job_id_source( curJob.GetJobID() );

	CProtoBufSystemSendHandler sender;
	CProtoBufMsgBase::BAsyncSendProto( sender, eSendMsg, hdr, msgSend );

	CProtoBufPtrMsg protoMsg( pMsgResponse );
	//return curJob.BYieldingWaitForMsg( &protoMsg, eRespondMsg, CSteamID() );
	return curJob.BYieldingWaitForMsg( &protoMsg, eRespondMsg ); // !FIXME! For some reason system replies are coming back with a universe and instance set (but account ID zero).
}


//-----------------------------------------------------------------------------
// Purpose: Creates a new session for the steam ID
//-----------------------------------------------------------------------------
CGCUserSession *CGCBase::CreateUserSession( const CSteamID & steamID, CGCSharedObjectCache *pSOCache ) const
{
	return new CGCUserSession( steamID, pSOCache );
}


//-----------------------------------------------------------------------------
// Purpose: Creates a new session for the steam ID
//-----------------------------------------------------------------------------
CGCGSSession *CGCBase::CreateGSSession( const CSteamID & steamID, CGCSharedObjectCache *pSOCache, uint32 unServerAddr, uint16 usServerPort ) const
{
	return new CGCGSSession( steamID, pSOCache, unServerAddr, usServerPort );
}


//-----------------------------------------------------------------------------
// Purpose: Locks the session for this steam ID and returns it.  Returns NULL
//			if the lock could not be granted or if the session could not be
//			found.
//-----------------------------------------------------------------------------
CGCUserSession *CGCBase::YieldingGetLockedUserSession( const CSteamID & steamID, const char *pszFilename, int nLineNum )
{
	if( !steamID.BIndividualAccount() )
		return NULL;

	if( !BYieldingLockSteamID( steamID, pszFilename, nLineNum ) )
		return NULL;

	CGCUserSession *pSession = FindUserSession( steamID );
	if( !pSession )
	{
		//EmitInfo( SPEW_GC, SPEW_ALWAYS, LOG_ALWAYS, "Unable to find session %s to lock it. Attempting to fetch it from the AM\n", steamID.Render() );
		pSession = (CGCUserSession *)YieldingRequestSession( steamID );
		if( !pSession )
		{
			UnlockSteamID( steamID );
		}
	}

	return pSession;
}

//-----------------------------------------------------------------------------
// Purpose: Checks if a user is in the start playing queue
//-----------------------------------------------------------------------------
bool CGCBase::BUserSessionPending( const CSteamID & steamID ) const
{
	int nStartPlayingMapIndex = m_mapStartPlayingQueueIndexBySteamID.Find( steamID );
	return ( nStartPlayingMapIndex != m_mapStartPlayingQueueIndexBySteamID.InvalidIndex() );
}

//-----------------------------------------------------------------------------
// Purpose: Returns the session for this steamID or NULL if that session could
//			not be found.
//-----------------------------------------------------------------------------
CGCUserSession *CGCBase::FindUserSession( const CSteamID & steamID ) const
{
	// we should only call this on individual ids
	if ( !steamID.IsValid() )
	{
		AssertMsg1( steamID.IsValid(), "CGCBase::FindUserSession was passed invalid Steam ID %s", steamID.Render() );
		return NULL;
	}
	if ( !steamID.BIndividualAccount() )
	{
		AssertMsg1( steamID.BIndividualAccount(), "CGCBase::FindUserSession was passed non-individual Steam ID %s", steamID.Render() );
		return NULL;
	}

	CGCUserSession **ppSession = m_hashUserSessions.PvRecordFind( steamID.ConvertToUint64() );
	if( ppSession )
	{
		(*ppSession)->MarkAccess();
		return *ppSession;
	}
	else
	{
		return NULL;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if the session associated with the steam id is online, false otherwise
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingIsOnline( const CSteamID & steamID )
{
	CGCMsg< MsgGCValidateSession_t > msg( k_EGCMsgValidateSession );
	msg.Body().m_ulSteamID = steamID.ConvertToUint64();
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
		return false;

	CGCMsg< MsgGCValidateSessionResponse_t > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgValidateSessionResponse ) )
	{
		EmitWarning( SPEW_GC, LOG_ALWAYS, "Didn't get reply from AM for %s in YieldingRequestSession\n", steamID.Render() );
		return false;
	}

	return msgReply.Body().m_bOnline;
}


//-----------------------------------------------------------------------------
// Purpose: Looks up a session from the AM for the provided steam ID.
//-----------------------------------------------------------------------------
template <typename T >
class CScopedIncrement
{
public:
	inline CScopedIncrement( T & counter) : m_counter(counter) { ++m_counter; }
	inline ~CScopedIncrement() { --m_counter; }
private:
	T &m_counter;
};

CGCSession *CGCBase::YieldingRequestSession( const CSteamID & steamID )
{
	AssertRunningJob();
	if( !steamID.BIndividualAccount() && !steamID.BGameServerAccount() )
		return NULL;
	Assert( IsSteamIDUnlockedOrLockedByCurJob( steamID ) );

	// Check if we already have info in the logon queue for this SteamID
	int nStartPlayingMapIndex = m_mapStartPlayingQueueIndexBySteamID.Find( steamID );
	if ( nStartPlayingMapIndex != m_mapStartPlayingQueueIndexBySteamID.InvalidIndex() )
	{

		// Sanity
		int idxStartPlayingQueue = m_mapStartPlayingQueueIndexBySteamID[ nStartPlayingMapIndex ];
		Assert( m_llStartPlaying[ idxStartPlayingQueue ].m_steamID == steamID );

		// Pull the logon out of the queue and execute it NOW
		YieldingExecuteStartPlayingQueueEntryByIndex( idxStartPlayingQueue );

		// Now return the session that was created, if any
		return FindUserOrGSSession( steamID );
	}

	CGCMsg< MsgGCValidateSession_t > msg( k_EGCMsgValidateSession );
	msg.Body().m_ulSteamID = steamID.ConvertToUint64();
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
		return NULL;

	CScopedIncrement<int> increment( m_nRequestSessionJobsActive );

	CGCMsg< MsgGCValidateSessionResponse_t > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgValidateSessionResponse ) )
	{
		EmitWarning( SPEW_GC, LOG_ALWAYS, "Didn't get reply from AM for %s in YieldingRequestSession\n", steamID.Render() );
		return NULL;
	}

	if( steamID.BIndividualAccount() )
	{
		if( msgReply.Body().m_bOnline )
		{
			CUtlBuffer bufVarData;
			if( msgReply.CubVarData() )
			{
				bufVarData.Put( msgReply.PubVarData(), msgReply.CubVarData() );
			}

			// Check if they have an entry in the startplaying queue, then get rid of it!
			// They data we just received is the most up-to-date we have.  We should
			// prefer this data over anything in the queue for sure.
			BRemoveStartPlayingQueueEntry( steamID );

			YieldingStartPlaying( steamID, msgReply.Body().m_ulSteamIDGS, msgReply.Body().m_unServerAddr, msgReply.Body().m_usServerPort, msgReply.CubVarData() ? &bufVarData : NULL );
			return FindUserSession( steamID );
		}
		else
		{
			//EmitWarning( SPEW_GC, LOG_ALWAYS, "Reply from AM is logging off %s in YieldingRequestSession\n", steamID.Render() );
			YieldingStopPlaying( steamID );
			return NULL;
		}
	}
	else 
	{
		if( msgReply.Body().m_bOnline )
		{
			YieldingStartGameserver( steamID, msgReply.Body().m_unServerAddr, msgReply.Body().m_usServerPort, msgReply.PubVarData(), msgReply.CubVarData() );
			return FindGSSession( steamID );
		}
		else
		{
			//EmitWarning( SPEW_GC, LOG_ALWAYS, "Reply from AM is stopping %s in YieldingRequestSession\n", steamID.Render() );
			YieldingStopGameserver( steamID );
			return NULL;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Send outgoing HTTP request to some other server. Probably a WebAPI
//			request to steam itself, but it could be a request on a more
//			remote server.
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingSendHTTPRequest( const CHTTPRequest *pRequest, CHTTPResponse *pResponse )
{
	if ( !pRequest || !pResponse )
	{
		AssertMsg( false, "Bad parameters for BYieldingSendHTTPRequest" );
		return false;
	}

	CMsgHttpResponse msgResponse;
	if( !BYldSendSystemMessageAndGetReply( pRequest->GetProtoObj(), k_EGCMsgSendHTTPRequest, &msgResponse, k_EGCMsgSendHTTPRequestResponse ) )
	{
		ReportHTTPError( CFmtStr( "No response to HTTP system message for %s", pRequest->GetURL() ), CGCEmitGroup::kMsg_Error );
		return false;
	}

	if ( !msgResponse.has_status_code() )
	{
		ReportHTTPError( CFmtStr( "No status code on HTTP response for %s", pRequest->GetURL() ), CGCEmitGroup::kMsg_Error );
		return false;
	}

	//log the result of this request
	if( msgResponse.status_code() != k_EHTTPStatusCode200OK )
	{
		ReportHTTPError( CFmtStr( "Invalid status code %u for %s", msgResponse.status_code(), pRequest->GetURL() ), CGCEmitGroup::kMsg_Warning );
	}
	else
	{
		ReportHTTPError( CFmtStr( "Success status code for %s", pRequest->GetURL() ), CGCEmitGroup::kMsg_Verbose );
	}

	pResponse->DeserializeFromProtoBuf( msgResponse );
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Send an outgoing HTTP request and parse the result into KeyValues.
//-----------------------------------------------------------------------------
EResult CGCBase::YieldingSendHTTPRequestKV( const CHTTPRequest *pRequest, KeyValues *pKVResponse )
{
	CHTTPResponse apiResponse;
	if ( !BYieldingSendHTTPRequest( pRequest, &apiResponse ) )
	{
		EmitError( SPEW_GC, __FUNCTION__ ": web call to %s timed out\n", pRequest->GetURL() );
		return k_EResultTimeout;
	}

	if ( k_EHTTPStatusCode200OK != apiResponse.GetStatusCode() )
	{
		EmitError( SPEW_GC, __FUNCTION__ ": web call to %s got failure code %d\n", pRequest->GetURL(), apiResponse.GetStatusCode() );
		return k_EResultRemoteCallFailed;
	}

	pKVResponse->UsesEscapeSequences( true );
	if ( !pKVResponse->LoadFromBuffer( "webResponse", *apiResponse.GetBodyBuffer() ) )
	{
		EmitError( SPEW_GC, "Web call to %s could not parse response\n", pRequest->GetURL() );
		return k_EResultRemoteCallFailed;
	}

	return k_EResultOK;
}


//-----------------------------------------------------------------------------
// Purpose: Locks the session for this steam ID and returns it.  Returns NULL
//			if the lock could not be granted or if the session could not be
//			found.
//-----------------------------------------------------------------------------
CGCGSSession *CGCBase::YieldingGetLockedGSSession( const CSteamID & steamID, const char *pszFilename, int nLineNum )
{
	if( !steamID.BGameServerAccount() )
		return NULL;

	if( !BYieldingLockSteamID( steamID, pszFilename, nLineNum ) )
		return NULL;

	CGCGSSession *pSession = FindGSSession( steamID );
	if( !pSession )
	{
		pSession = (CGCGSSession *)YieldingRequestSession( steamID );
		if( !pSession )
		{
			UnlockSteamID( steamID );
		}
	}

	return pSession;
}

void CGCBase::ReportHTTPError( const char* pszError, CGCEmitGroup::EMsgLevel eLevel )
{
	//see if we can find a match
	int nIndex = m_HTTPErrors.Find( pszError );
	if( nIndex != m_HTTPErrors.InvalidIndex() )
	{
		//just increment our count
		m_HTTPErrors[ nIndex ]->m_nCount++;
		m_HTTPErrors[ nIndex ]->m_eSeverity = MIN( eLevel, m_HTTPErrors[ nIndex ]->m_eSeverity );
	}
	else
	{
		//add one
		SHTTPError* pError = new SHTTPError;
		pError->m_sStr = pszError;
		pError->m_nCount = 1;
		pError->m_eSeverity = eLevel;
		m_HTTPErrors.Insert( pError->m_sStr, pError );
	}

	if( !m_DumpHTTPErrorsSchedule.BIsScheduled() )
	{
		m_DumpHTTPErrorsSchedule.ScheduleMS( this, &CGCBase::DumpHTTPErrors, 1000 );
	}
}

void CGCBase::DumpHTTPErrors()
{
	FOR_EACH_MAP_FAST( m_HTTPErrors, nCurrError )
	{
		SHTTPError* pError = m_HTTPErrors[ nCurrError ];
		EG_EMIT( g_EGHTTPRequest, m_HTTPErrors[ nCurrError ]->m_eSeverity, "%s - %d times\n", pError->m_sStr.String(), pError->m_nCount );
		delete pError;
	}
	m_HTTPErrors.RemoveAll();
}

//-----------------------------------------------------------------------------
// Purpose: Returns the session for this steamID or NULL if that session could
//			not be found.
//-----------------------------------------------------------------------------
CGCGSSession *CGCBase::YieldingFindOrCreateGSSession( const CSteamID & steamID, uint32 unServerAddr, uint16 usServerPort, const uint8 *pubVarData, uint32 cubVarData )
{
	Assert( IsSteamIDLockedByJob( steamID, &GJobCur() ) );

	// If it's not a game server ID, then we shouldn't make a session for it.
	if( !steamID.BGameServerAccount() )
		return NULL;

	MEM_ALLOC_CREDIT_( "YieldingFindOrCreateGSSession" );

	// if var data came with this StartPlaying message, parse it into a KV and stick it on the session
	KeyValues *pkvDetails = NULL;
	if( pubVarData && cubVarData )
	{
		CUtlBuffer bufDetails;
		bufDetails.Put( pubVarData, cubVarData );
		pkvDetails = new KeyValues( "SessionDetails" );
		if( !pkvDetails->ReadAsBinary( bufDetails ) )
		{
			EmitError( SPEW_GC, "Unable to parse session details for %s\n", steamID.Render() );
			pkvDetails->deleteThis();
			pkvDetails = NULL;
		}
	}

//	// Since we might have to lock the session in some cases, let's just always grab the lock here,
//	// to keep things simpler.
//	if ( !BYieldingLockSteamID( steamID, __FILE__, __LINE__ ) )
//		return NULL;

	CGCGSSession *pSession = FindGSSession( steamID );
	CGCSharedObjectCache *pSOCache = NULL;
	if( !pSession )
	{
		pSOCache = YieldingFindOrLoadSOCache( steamID );

		// Did anybody create a session while we held the lock?
		// We hold the lock, and you must hold the lock to create
		// the session, so this race condition should be impossible
		pSession = FindGSSession( steamID );
		Assert( pSession == NULL );
	}
	if( !pSession )
	{

		// Create session of app-specific type
		pSession = CreateGSSession( steamID, pSOCache, unServerAddr, usServerPort );
		Assert( pSession );
		if ( !pSession )
		{
			AssertMsg1( false, "Failed creating GC GS session for %llu", steamID.ConvertToUint64() );
			if ( pkvDetails )
			{
				pkvDetails->deleteThis();
			}
			//UnlockSteamID( steamID ); // I like to clean up after myself
			return NULL;
		}
		RemoveCacheFromLRU( pSOCache );

		CGCGSSession **ppSession = m_hashGSSessions.PvRecordInsert( steamID.ConvertToUint64() );
		*ppSession = pSession;

		// Do game-specific work
		YieldingSessionStartServer( pSession );
	}
	else
	{
		if ( unServerAddr != 0 && usServerPort != 0 && ( unServerAddr != pSession->GetAddr() || usServerPort != pSession->GetPort() ) )
		{
			UpdateGSSessionAddress( pSession, unServerAddr, usServerPort );
		}
	}

	if( pkvDetails )
	{
		uint32 ip = pkvDetails->GetInt( "ip", 0 );
		if ( ip != 0 )
			pSession->m_unIPPublic = ip;
		pSession->m_osType = static_cast<EOSType>( pkvDetails->GetInt( "osType", k_eOSUnknown ) );
		pSession->m_bIsTestSession = pkvDetails->GetInt( "isTestSession", 0 ) != 0;
		pkvDetails->deleteThis();
	}

	//UnlockSteamID( steamID ); // I like to clean up after myself
	return pSession;
}

//-----------------------------------------------------------------------------
// Purpose: Called when a Session is moved to a different address.
//-----------------------------------------------------------------------------
void CGCBase::UpdateGSSessionAddress( CGCGSSession *pSession, uint32 unServerAddr, uint16 usServerPort )
{
	pSession->SetIPAndPort( unServerAddr, usServerPort );
}

//-----------------------------------------------------------------------------
// Purpose: Returns the session for this steamID or NULL if that session could
//			not be found.
//-----------------------------------------------------------------------------
CGCGSSession *CGCBase::FindGSSession( const CSteamID & steamID ) const
{
	// we should only call this on server ids
	if ( !steamID.IsValid() || steamID.GetAccountID() == 0 )
	{
		AssertMsg1( false, "CGCBase::FindGSSession was passed invalid Steam ID %s", steamID.Render() );
		return NULL;
	}
	if ( !steamID.BGameServerAccount() )
	{
		AssertMsg1( steamID.BGameServerAccount(), "CGCBase::FindGSSession was passed non-gameserver Steam ID %s", steamID.Render() );
		return NULL;
	}

	CGCGSSession **ppSession = m_hashGSSessions.PvRecordFind( steamID.ConvertToUint64() );
	if( ppSession )
	{
		(*ppSession)->MarkAccess();
		return *ppSession;
	}
	else
	{
		return NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Locate session from appropriate table, depending on if it's
//			an individual or gameserver ID
//-----------------------------------------------------------------------------
CGCSession *CGCBase::FindUserOrGSSession( const CSteamID & steamID ) const
{
	if ( steamID.BIndividualAccount() )
		return FindUserSession( steamID );
	if ( steamID.BGameServerAccount() )
		return FindGSSession( steamID );
	AssertMsg1( false, "CGCBase::FindUserOrGSSession, steam ID %s isn't an individual or a gameserver ID", steamID.Render() );
	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Wakes up the job waiting for this SQL result
//-----------------------------------------------------------------------------
void CGCBase::SQLResults( GID_t gidContextID )
{
	VPROF_BUDGET( "CGCBase::SQLResults", VPROF_BUDGETGROUP_STEAM );
	m_JobMgr.BResumeSQLJob( gidContextID );
}


//-----------------------------------------------------------------------------
// Purpose: Finds the cache in the map for a new session
//-----------------------------------------------------------------------------
CGCSharedObjectCache *CGCBase::FindSOCache( const CSteamID & steamID )
{
	CUtlMap< CSteamID, CGCSharedObjectCache *, int >::IndexType_t nCache = m_mapSOCache.Find( steamID );
	if( m_mapSOCache.IsValidIndex( nCache ) )
		return m_mapSOCache[nCache];
	else
		return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingLoadSOCache( CGCSharedObjectCache *pSOCache )
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGCBase::YieldingSOCacheLoaded( CGCSharedObjectCache *pSOCache )
{
	// remove it, so we don't stomp the copy in memcached
	m_rbtreeSOCachesWithDirtyVersions.Remove( pSOCache->GetOwner() );

	// stomp the version with the one we set in memcached previously if possible, otherwise, re-add it to the set
	if ( !BYieldingRetrieveCacheVersion( pSOCache ) )
	{
		m_rbtreeSOCachesWithDirtyVersions.InsertIfNotFound( pSOCache->GetOwner() );
	}	
}


//-----------------------------------------------------------------------------
// Purpose: Removes the cache for this steamID
//-----------------------------------------------------------------------------
void CGCBase::RemoveSOCache( const CSteamID & steamID )
{	
	CUtlMap< CSteamID, CGCSharedObjectCache *, int >::IndexType_t nCache = m_mapSOCache.Find( steamID );
	if( m_mapSOCache.IsValidIndex( nCache ) )
	{
		CGCSharedObjectCache *pSOCache = m_mapSOCache[nCache];
		pSOCache->RemoveAllSubscribers();

		if( pSOCache->BIsDatabaseDirty() )
		{
			EmitError( SPEW_GC, "Attempting to remove SO Cache %s while it was dirty. Adding to Writeback instead\n", steamID.Render() );
			pSOCache->DumpDirtyObjects();
			AddCacheToWritebackQueue( pSOCache );

			// adding the cache to the LRU list too, just so it will go away once writeback does its thing
			if( !m_listCachesToUnload.IsValidIndex( pSOCache->GetLRUHandle() ) )
			{
				AddCacheToLRU( pSOCache );
			}
		}
		else
		{
			RemoveCacheFromLRU(pSOCache);

			delete pSOCache;
			m_mapSOCache.RemoveAt( nCache );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Enqueues a flush instruction to Econ service for Web Inventory to update
//-----------------------------------------------------------------------------
void CGCBase::FlushInventoryCache( AccountID_t unAccountID )
{
	VPROF_BUDGET( "FlushInventoryCache - enqueue", VPROF_BUDGETGROUP_STEAM );
	m_rbFlushInventoryCacheAccounts.InsertIfNotFound( unAccountID );
}

//-----------------------------------------------------------------------------
// Purpose: Finds the cache in the map for a new session and locks it
//-----------------------------------------------------------------------------
bool CGCBase::UnloadUnusedCaches( uint32 unMaxCacheCount, CLimitTimer *pLimitTimer )
{
	VPROF_BUDGET( "UnloadUnusedCaches", VPROF_BUDGETGROUP_STEAM );

	uint32 unCachesUnloaded = 0;
	for( uint32 unCache = m_listCachesToUnload.Head(), unNextCache = m_listCachesToUnload.InvalidIndex(); unCache != m_listCachesToUnload.InvalidIndex(); unCache = unNextCache )
	{
		unNextCache = m_listCachesToUnload.Next( unCache );

		// only remove caches until we are under our limit
		if( (uint32)m_mapSOCache.Count() <= unMaxCacheCount )
			return false;

		// only loop until we need to stop consuming heartbeat time. We'll finish in later frames
		if( pLimitTimer && pLimitTimer->BLimitReached() )
			return true;

		CSteamID ownerID = m_listCachesToUnload[ unCache ];
		CGCSharedObjectCache *pSOCache = FindSOCache( ownerID );
		Assert( pSOCache );
		if( !pSOCache )
		{
			EmitError( SPEW_GC, "Cache for %s could not be found even though it is in the LRU list\n", ownerID.Render() );
			m_listCachesToUnload.Remove( unCache );
			continue;
		}

		// make sure there's no session using this cache
		if( ( ownerID.BIndividualAccount() && FindUserSession( ownerID ) ) 
			|| ( ownerID.BGameServerAccount() && FindGSSession( ownerID ) ) )
		{
			EmitError( SPEW_GC, "Cache for %s has a session even though it is in the LRU list\n", ownerID.Render() );
			Assert( pSOCache->GetLRUHandle() == unCache );
			if ( pSOCache->GetLRUHandle() != unCache )
			{
				EmitError( SPEW_GC, "Cache for %s has a different LRU handle than the one retrieved from the iterator! 0x%08x vs 0x%08x\n", ownerID.Render(), pSOCache->GetLRUHandle(), unCache );
			}

			RemoveCacheFromLRU( pSOCache );
			continue;
		}

		// Locked steam IDs mean someone is using the cache. 
		// Being in the writeback queue means that you haven't actually been unused for very long.
		// Just move on to the next one in those cases.
		if( IsSteamIDLocked( ownerID ) || pSOCache->GetInWriteback() )
			continue;

		// either count down by one or still in LRU?
		int iPreRemoveCount = m_listCachesToUnload.Count();

		// remove and delete the cache (which will remove it from the LRU list too.)
		RemoveSOCache( ownerID );
		unCachesUnloaded++;

		if ( iPreRemoveCount != m_listCachesToUnload.Count() + 1 &&
			 iPreRemoveCount != m_listCachesToUnload.Count() )
		{
			EmitError( SPEW_GC, "CGCBase::UnloadUnusedCaches() sanity check failed! List size changed dramatically removing 0x%08x; delta %i\n", unCache, iPreRemoveCount - m_listCachesToUnload.Count() );
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Does some sanity checks on the SO cache LRU
//-----------------------------------------------------------------------------
void CGCBase::VerifySOCacheLRU()
{
	CUtlRBTree<CSteamID, int> rbTreeUsersEncountered( 0, m_listCachesToUnload.Count(), DefLessFunc( CSteamID ) );

	for( uint32 unCache = m_listCachesToUnload.Head(), unNextCache = m_listCachesToUnload.InvalidIndex(); unCache != m_listCachesToUnload.InvalidIndex(); unCache = unNextCache )
	{
		unNextCache = m_listCachesToUnload.Next( unCache );
		CSteamID ownerID = m_listCachesToUnload[ unCache ];
		CGCSharedObjectCache *pSOCache = FindSOCache( ownerID );
		if ( !pSOCache )
		{
			EmitError( SPEW_GC, "CGCBase::UnloadUnusedCaches() sanity[0] check failed! Empty cache in list in slot 0x%08x\n", unCache );
			continue;
		}

		if ( pSOCache->GetLRUHandle() != unCache )
		{
			EmitError( SPEW_GC, "CGCBase::UnloadUnusedCaches() sanity[1] check failed! Cache entry mismatch [ 0x%08x vs 0x%08x ] (owner: %s)\n", pSOCache->GetLRUHandle(), unCache, pSOCache->GetOwner().Render() );
		}

		if ( !rbTreeUsersEncountered.IsValidIndex( rbTreeUsersEncountered.InsertIfNotFound( ownerID ) ) )
		{
			EmitError( SPEW_GC, "CGCBase::UnloadUnusedCaches() sanity[2] check failed! Duplicate entry in list for 0x%08x (owner: %s)\n", unCache, pSOCache->GetOwner().Render() );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Adds the cache to the LRU list
//-----------------------------------------------------------------------------
void CGCBase::AddCacheToLRU( CGCSharedObjectCache * pSOCache )
{
	Assert( pSOCache->GetLRUHandle() == m_listCachesToUnload.InvalidIndex() );
#if WITH_SOCACHE_LRU_DEBUGGING
	if ( pSOCache->GetLRUHandle() != m_listCachesToUnload.InvalidIndex() )
	{
		EmitError( SPEW_GC, "CGCBase::AddCacheToLRU() sanity[4] check failed! Adding SO Cache with existing LRU handle: 0x%08x\n", pSOCache->GetLRUHandle() );
	}
#endif
	
	// remove it just in case. Crashes are bad.
	RemoveCacheFromLRU( pSOCache );

#if WITH_SOCACHE_LRU_DEBUGGING
	Assert( pSOCache->GetLRUHandle() == m_listCachesToUnload.InvalidIndex() );
	if ( pSOCache->GetLRUHandle() != m_listCachesToUnload.InvalidIndex() )
	{
		EmitError( SPEW_GC, "CGCBase::AddCacheToLRU() sanity[5] check failed! Adding SO Cache with existing LRU handle: 0x%08x\n", pSOCache->GetLRUHandle() );
	}
#endif

	pSOCache->SetLRUHandle( m_listCachesToUnload.AddToTail( pSOCache->GetOwner() ) );
}


//-----------------------------------------------------------------------------
// Purpose: Removes the cache from the LRU list
//-----------------------------------------------------------------------------
void CGCBase::RemoveCacheFromLRU( CGCSharedObjectCache * pSOCache )
{
#if WITH_SOCACHE_LRU_DEBUGGING
	if ( m_listCachesToUnload.IsValidIndex( pSOCache->GetLRUHandle() ) == ( pSOCache->GetLRUHandle() == m_listCachesToUnload.InvalidIndex() ) )
	{
		EmitError( SPEW_GC, "CGCBase::RemoveCacheFromLRU() sanity[6] check failed! SO Cache has an invalid index, but IsValidIndex() is returning true: 0x%08x\n", pSOCache->GetLRUHandle() );
	}
#endif
	if( m_listCachesToUnload.IsValidIndex( pSOCache->GetLRUHandle() ) )
	{
		if( m_listCachesToUnload[ pSOCache->GetLRUHandle() ] != pSOCache->GetOwner() )
		{
			EmitError( SPEW_GC, "CGCBase::RemoveCacheFromLRU() Attempting to remove SOCache LRU index %d for %s, which really holds %s\n",
					   pSOCache->GetLRUHandle(), pSOCache->GetOwner().Render(), m_listCachesToUnload[ pSOCache->GetLRUHandle() ].Render() );
		}
		else
		{
			m_listCachesToUnload.Remove( pSOCache->GetLRUHandle() );
		}
	}
	pSOCache->SetLRUHandle( m_listCachesToUnload.InvalidIndex() );
}


//-----------------------------------------------------------------------------
// Purpose: Finds the cache in the map for a new session and locks it
//-----------------------------------------------------------------------------
CGCSharedObjectCache *CGCBase::YieldingGetLockedSOCache( const CSteamID &steamID, const char *pszFilename, int nLineNum )
{
	if( !BYieldingLockSteamID( steamID, pszFilename, nLineNum ) )
		return NULL;

	return YieldingFindOrLoadSOCache( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: Finds the cache in the map for a new session
//-----------------------------------------------------------------------------
CGCSharedObjectCache *CGCBase::YieldingFindOrLoadSOCache( const CSteamID &steamID )
{
	AssertRunningJob();

	if( !steamID.IsValid() )
	{
		AssertMsg1( false, "Unable to load SO cache for invalid steam ID %s", steamID.Render() );
		EmitError( SPEW_GC, "Unable to load SO cache for invalid steam ID %s (instance: %d)\n", steamID.Render(), steamID.GetUnAccountInstance() );
		return NULL;
	}

	// check to see if the SO cache is being loaded--if so, then we yield until it is done
	// the reason we are not just locking the steam id is because the current job may have
	// a lock on something else, and jobs can only have one lock active at a time.
	CJobTime timeStartedWaiting;
	timeStartedWaiting.SetToJobTime();
	while ( m_rbtreeSOCachesBeingLoaded.Find( steamID ) != m_rbtreeSOCachesBeingLoaded.InvalidIndex() )
	{

		// !TEST! Looks like we might have a bug where we're spinning here waiting forever.
		// Add a timeout just in case.
		if ( timeStartedWaiting.CServerMicroSecsPassed() > 180 * k_nMillion )
		{
			AssertMsg1( false, "Timed out waiting for SO cache %s to finish loading", steamID.Render() );
			return false;
		}
		GJobCur().BYieldingWaitOneFrame();
	}

	CGCSharedObjectCache *pSOCache = FindSOCache( steamID );
	if( !pSOCache )
	{
		m_rbtreeSOCachesBeingLoaded.Insert( steamID );
		pSOCache = CreateSOCache( steamID );
		CJobTime timeStartedLoading;
		timeStartedLoading.SetToJobTime();
		if( BYieldingLoadSOCache( pSOCache ) )
		{
			if ( FindSOCache( steamID ) != NULL )
			{
				EmitError( SPEW_GC, "HOLY FUCKING SHIT WE ARE DUPLICATING SO CACHES [%s]\n", steamID.Render() );
			}
			m_mapSOCache.Insert( steamID, pSOCache );

			float flSecondsToLoad = (float)timeStartedLoading.CServerMicroSecsPassed() / (float)k_nMillion;
			if ( flSecondsToLoad > 10.0f )
			{
				EmitInfo( SPEW_GC, 4, 1, "Loading of SO cache for %s took %.1fs\n", steamID.Render(), flSecondsToLoad );
			}

			//mark this cache as loaded so that it's version can change again
			pSOCache->SetDetectVersionChanges( false );

			CJobTime timeStartedNotify;
			timeStartedNotify.SetToJobTime();
			YieldingSOCacheLoaded( pSOCache );
			float flSecondsToNotify = (float)timeStartedNotify.CServerMicroSecsPassed() / (float)k_nMillion;
			if ( flSecondsToNotify > 10.0f )
			{
				EmitInfo( SPEW_GC, 1, 1, "YieldingSOCacheLoaded for %s took %.1fs\n", steamID.Render(), flSecondsToNotify );
			}

			AddCacheToLRU( pSOCache ); // in case the cache isn't about to be attached to a session
			m_rbtreeSOCachesBeingLoaded.Remove( steamID );
		}
		else
		{
			AssertMsg1( false, "Unable to load SO cache for %llu", steamID.ConvertToUint64() );
			EmitError( SPEW_GC, "Unable to load SO cache for %llu\n", steamID.ConvertToUint64() );
			delete pSOCache;
			m_rbtreeSOCachesBeingLoaded.Remove( steamID );
			return NULL;
		}
	}
	else
	{
		// if the cache is in the LRU, move it to the end of the list
		if( m_listCachesToUnload.IsValidIndex( pSOCache->GetLRUHandle() ) )
		{
			RemoveCacheFromLRU( pSOCache );
			AddCacheToLRU( pSOCache );
		}
	}

	return pSOCache;
}


//-----------------------------------------------------------------------------
// Purpose: Reloads the SO cache
//-----------------------------------------------------------------------------
void CGCBase::YieldingReloadCache( CGCSharedObjectCache *pSOCache )
{
	Assert( IsSteamIDLockedByJob( pSOCache->GetOwner(), &GJobCur() ) );
	if( !IsSteamIDLockedByJob( pSOCache->GetOwner(), &GJobCur() ) )
		return;

	// Flush all pending writes
	CSQLAccess sqlAccess;
	sqlAccess.BBeginTransaction( "CGCBase::YieldingReloadCache - Flush writes" );
	pSOCache->YieldingStageAllWrites( sqlAccess );
	if ( !sqlAccess.BCommitTransaction( true ) )
	{
		EmitError( SPEW_SHAREDOBJ, "%s: Unable to flush pending writes for %s, reload failed",
		           __FUNCTION__, pSOCache->GetOwner().Render() );
		return;
	}

	// load the data into a new cache
	CGCSharedObjectCache *pNewCache = CreateSOCache( pSOCache->GetOwner() );
	if( !BYieldingLoadSOCache( pNewCache ) )
	{
		EmitError( SPEW_SHAREDOBJ, "Unable to reload cache for %s because of a SQL error", pSOCache->GetOwner().Render() );
		return;
	}

	// process every object in the new cache and move it to the old one if necessary
	FOR_EACH_MAP_FAST( CSharedObject::GetFactories(), nType )
	{
		int nTypeID = CSharedObject::GetFactories().Key( nType );

		// remove all the old items of this type
		CSharedObjectTypeCache *pOldTypeCache = pSOCache->FindTypeCache( nTypeID );
		if( pOldTypeCache )
		{
			for( uint32 nCurrObj = 0; nCurrObj < pOldTypeCache->GetCount(); )
			{
				//not all objects should be deleted (for example lobbies/parties), so for those objects
				//don't delete and instead just skip over them
				if( pOldTypeCache->GetObject( nCurrObj )->BShouldDeleteByCache() )
				{
					pSOCache->RemoveObject( *pOldTypeCache->GetObject( nCurrObj ) );
				}
				else
				{
					nCurrObj++;
				}
			}
		}

		// add all the new objects of this type
		CSharedObjectTypeCache *pNewTypeCache = pNewCache->FindTypeCache( nTypeID );
		if( pNewTypeCache )
		{
			for( uint unObject = 0; unObject < pNewTypeCache->GetCount(); unObject++ )
			{
				pSOCache->AddObject( pNewTypeCache->GetObject( unObject ) );
			}
		}
	}

	// remove all the objects in the new cache
	pNewCache->RemoveAllObjectsWithoutDeleting();
	delete pNewCache;

	// if there's a session for this cache, tell it about the reload
	if( pSOCache->GetOwner().BIndividualAccount() )
	{
		CGCUserSession *pUserSession = FindUserSession( pSOCache->GetOwner() );
		if( pUserSession )
			pUserSession->YieldingSOCacheReloaded();
	}
	else if( pSOCache->GetOwner().BGameServerAccount() )
	{
		CGCGSSession *pGSSession = FindGSSession( pSOCache->GetOwner() );
		if( pGSSession )
			pGSSession->YieldingSOCacheReloaded();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Factory method to create a CGCSharedObjectCache
// Input  : &steamID - steamID that will own the CGCSharedObjectCache
// Output : Returns a new CGCSharedObjectCache
//-----------------------------------------------------------------------------
CGCSharedObjectCache *CGCBase::CreateSOCache( const CSteamID &steamID )
{
	return new CGCSharedObjectCache( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: yields until the lock on the specified steamID is taken
// Input  : &steamID - steamID to lock
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingLockSteamID( const CSteamID &steamID, const char *pszFilename, int nLineNum )
{
	AssertRunningJob();
	Assert( steamID.GetEAccountType() != k_EAccountTypePending );

	// lookup
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( !pLock )
	{
		// no lock yet, insert one
		pLock = m_hashSteamIDLocks.PvRecordInsert( steamID );
		pLock->SetName( steamID );
		pLock->SetLockSubType( steamID.GetAccountID() );
		if ( steamID.BIndividualAccount() )
		{
			pLock->SetLockType( k_nLockTypeIndividual );
		}
		else if ( steamID.BGameServerAccount() )
		{
			pLock->SetLockType( k_nLockTypeGameServer );
		}
		else
		{
			AssertMsg1( false, "Lock taken for unexpected steamID: %s", steamID.Render() );
		}
	}

	Assert( pLock );
	if ( !pLock )
	{
		EmitInfo( SPEW_GC, SPEW_ALWAYS, LOG_ALWAYS, "Unable to create lock for %s\n", steamID.Render() );
		return false;
	}

	return GJobCur()._BYieldingAcquireLock( pLock, pszFilename, nLineNum );
}


//-----------------------------------------------------------------------------
// Purpose: locks a pair of steam IDs, grabbing the highest account ID first
//			to satisfy the deadlock-avoidance code in the job system
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingLockSteamIDPair( const CSteamID &steamIDA, const CSteamID &steamIDB, const char *pszFilename, int nLineNum )
{
	if( steamIDA == steamIDB )
		return BYieldingLockSteamID( steamIDA, pszFilename, nLineNum );

	//
	// !FIXME! This is really not the correct sort criteron to use.  The correct
	//         criteria is to use the full lock priority.  For example,
	//         what if we pass a gameserver ID and a user ID.  The whole
	//         concept of locking two SteamID's is probably broken when we split up
	//         things on the GC, though, so this might not be worth fixing.
	//

	if( steamIDA.GetAccountID() < steamIDB.GetAccountID() )
	{
		if( !BYieldingLockSteamID( steamIDB, pszFilename, nLineNum ) )
			return false;
		if( !BYieldingLockSteamID( steamIDA, pszFilename, nLineNum ) )
		{
			UnlockSteamID( steamIDB );
			return false;
		}
	}
	else
	{
		if( !BYieldingLockSteamID( steamIDA, pszFilename, nLineNum ) )
			return false;
		if( !BYieldingLockSteamID( steamIDB, pszFilename, nLineNum ) )
		{
			UnlockSteamID( steamIDA );
			return false;
		}
	}
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: locks the specified steamID
// Input  : &steamID - steamID to unlock
//-----------------------------------------------------------------------------
bool CGCBase::BLockSteamIDImmediate( const CSteamID &steamID )
{
	AssertRunningJob();
	Assert( steamID.GetEAccountType() != k_EAccountTypePending );

	// lookup
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( pLock == NULL )
	{
		// no lock yet, insert one
		pLock = m_hashSteamIDLocks.PvRecordInsert( steamID );
		Assert( pLock != NULL );
		if ( pLock == NULL )
		{
			return false;
		}
		
		if ( steamID.BIndividualAccount() )
		{
			pLock->SetLockType( k_nLockTypeIndividual );
		}
		else if ( steamID.BGameServerAccount() )
		{
			pLock->SetLockType( k_nLockTypeGameServer );
		}
		else
		{
			AssertMsg1( false, "Lock taken for unexpected steamID: %s", steamID.Render() );
		}
		
		pLock->SetName( steamID );
		pLock->SetLockSubType( steamID.GetAccountID() );
	}

	return GJobCur().BAcquireLockImmediate( pLock );
}


//-----------------------------------------------------------------------------
// Purpose: unlocks the specified steamID
// Input  : &steamID - steamID to unlock
//-----------------------------------------------------------------------------
void CGCBase::UnlockSteamID( const CSteamID &steamID )
{
	AssertRunningJob();
	Assert( steamID.GetEAccountType() != k_EAccountTypePending );

	// lookup
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	Assert( pLock );
	if ( !pLock )
	{
		AssertMsg2( false, "UnlockSteamID( '%s' ) called by %s but unable to find lock in map", steamID.Render(), GJobCur().GetName() );
		return;
	}

	if ( pLock->GetJobLocking() != &GJobCur() )
	{
		AssertMsg2( false, "UnlockSteamID( '%s' ) called when job %s doesn't own the lock", steamID.Render(), GJobCur().GetName() );
		return;
	}

	GJobCur().ReleaseLock( pLock );
}


//-----------------------------------------------------------------------------
// Purpose: returns true if the specified steamID is locked
//-----------------------------------------------------------------------------
bool CGCBase::IsSteamIDLocked( const CSteamID &steamID )
{
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( pLock )
		return pLock->BIsLocked();

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: returns true if the specified steamID is locked by the specified job
//-----------------------------------------------------------------------------
bool CGCBase::IsSteamIDLockedByJob( const CSteamID &steamID, const CJob *pJob ) const
{
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( pLock )
		return ( pLock->GetJobLocking() == pJob );

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: returns true if the specified steamID is locked by the current job
//-----------------------------------------------------------------------------
bool CGCBase::IsSteamIDLockedByCurJob( const CSteamID &steamID ) const
{
	AssertRunningJob();

	return IsSteamIDLockedByJob( steamID, &GJobCur() );
}

//-----------------------------------------------------------------------------
// Purpose: returns true if the specified steamID is unlocked, or locked by the current job
//-----------------------------------------------------------------------------
bool CGCBase::IsSteamIDUnlockedOrLockedByCurJob( const CSteamID &steamID )
{
	AssertRunningJob();

	// lookup
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( !pLock )
	{
		// Unlocked
		return true;
	}

	// It is in the hash of locks and is locked return true only if it is locked by the current job
	if ( pLock->BIsLocked() )
	{
		return ( pLock->GetJobLocking() == &GJobCur() );
	}
	else
	{
		return true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: returns a pointer to the lock for the steamID, or NULL if none
//-----------------------------------------------------------------------------
const CLock *CGCBase::FindSteamIDLock( const CSteamID &steamID )
{
	// lookup
	return m_hashSteamIDLocks.PvRecordFind( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: returns a pointer to the job holding the lock for this steamID, NULL if none
//-----------------------------------------------------------------------------
CJob *CGCBase::PJobHoldingLock( const CSteamID &steamID )
{
	AssertRunningJob();

	// lookup
	CLock *pLock = m_hashSteamIDLocks.PvRecordFind( steamID );
	if ( !pLock || !pLock->BIsLocked() )
	{
		// Unlocked
		return NULL;
	}

	// Return the job holding the lock
	return pLock->GetJobLocking();
}


//-----------------------------------------------------------------------------
// Purpose: returns a pointer to the job holding the lock for this steamID, NULL if none
//-----------------------------------------------------------------------------
bool CGCBase::YieldingWritebackDirtyCaches( uint32 unSecondToDelayWrite )
{
	CSQLAccess sqlAccess;
	CUtlVector< CGCSharedObjectCache * > vecCachesWritten;
	uint32 unWrittenCount = 0;
	sqlAccess.BBeginTransaction( "CGCBase::YieldingWritebackDirtyCaches()" );
	RTime32 unFirstTimeToWrite = time( NULL ) - unSecondToDelayWrite;
	FOR_EACH_VEC( m_vecCacheWritebacks, nCache )
	{
		CGCSharedObjectCache *pSOCache = m_vecCacheWritebacks[ nCache ];

		// if this cache entered the writeback list too frequently, skip it for now
		if( unSecondToDelayWrite > 0 && pSOCache->GetWritebackTime() > unFirstTimeToWrite )
		{
			continue;
		}

		// if we can't get the lock for ourselves, catch it on the next time around
		if( !BLockSteamIDImmediate( pSOCache->GetOwner() ) )
		{
			continue;
		}

		unWrittenCount += pSOCache->YieldingStageAllWrites( sqlAccess );
		vecCachesWritten.AddToTail( pSOCache );
		m_vecCacheWritebacks.Remove( nCache );
		nCache--;

		// don't hog all the CPU. Yield and wait for the next frame if
		// we've been running for too long. Go ahead and write these
		// caches so we don't hold their locks forever though.
		if( GJobCur().GetMicrosecondsRun() > (uint64)(writeback_queue_max_accumulate_time.GetInt() * k_nThousand) ||
			( writeback_queue_max_caches.GetInt() > 0 && vecCachesWritten.Count() > writeback_queue_max_caches.GetInt() ) )
		{
			// We've spent enough time accumulating work. Time to run some SQL
			// queries.
			break;
		}
	}

	// Commit the transaction
	if( !sqlAccess.BCommitTransaction( true ) )
	{
		// the transaction failed.  Put those caches back on the TODO list
		EmitError( SPEW_GC, "CGCBase::YieldingWritebackDirtyCaches() - Writeback failed\n" );

		m_vecCacheWritebacks.AddMultipleToTail( vecCachesWritten.Count(), vecCachesWritten.Base() );
		FOR_EACH_VEC( vecCachesWritten, nCache )
		{
			CGCSharedObjectCache *pSOCache = vecCachesWritten[nCache];
			UnlockSteamID( pSOCache->GetOwner() );
		}
		return false;
	}
	else
	{
		// the transaction was successful. Tell those caches to forget their dirtiness
		FOR_EACH_VEC( vecCachesWritten, nCache )
		{
			CGCSharedObjectCache *pSOCache = vecCachesWritten[nCache];
			pSOCache->SetInWriteback( false );
			UnlockSteamID( pSOCache->GetOwner() );
		}
		return true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGCBase::AddCacheToWritebackQueue( CGCSharedObjectCache *pSOCache )
{
	Assert( pSOCache );
	if ( ( g_pJobCur != NULL ) && PJobHoldingLock( pSOCache->GetOwner() ) != g_pJobCur && !GGCBase()->BIsSOCacheBeingLoaded( pSOCache->GetOwner() ) )
	{
		AssertMsg2( false, "CGCBase::AddCacheToWritebackQueue called by job %s for %s, but job does not own lock", g_pJobCur->GetName(), pSOCache->GetOwner().Render() );
	}
	if( !pSOCache->GetInWriteback() )
	{
		m_vecCacheWritebacks.AddToTail( pSOCache );
		pSOCache->SetInWriteback( true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingRetrieveCacheVersion( CGCSharedObjectCache *pSOCache )
{
	if ( !socache_persist_version_via_memcached.GetBool() )
	{
		// We'll keep doing the updates, but fail to restore it if not requested.
		return false;
	}

	CFmtStr1024 key( "SOCacheVersionV2_%llu", pSOCache->GetOwner().ConvertToUint64() );

	GCMemcachedGetResult_t data;
	if ( !BYieldingMemcachedGet( key.Access(), data ) || !data.m_bKeyFound || sizeof( uint64 ) != data.m_bufValue.Count() )
	{
#ifdef _DEBUG
		EmitInfo( SPEW_CONSOLE, 3, 3, "SOCacheVersion - Failed to retrieve SO Cache version for: %s\n", pSOCache->GetOwner().Render() );
#endif
		return false;
	}

	//we have a memcached version, so make sure that our version matches what was stored in memcache
	uint64 unVersion = *( (uint64 *)data.m_bufValue.Base() );
	pSOCache->SetVersion( unVersion );
#ifdef _DEBUG
	EmitInfo( SPEW_CONSOLE, 3, 3, "SOCacheVersion::Load - Loaded version from memcached for %s (%llu)\n", pSOCache->GetOwner().Render(), pSOCache->GetVersion() );
#endif
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGCBase::AddCacheToVersionChangedList( CGCSharedObjectCache *pSOCache )
{
	m_rbtreeSOCachesWithDirtyVersions.InsertIfNotFound( pSOCache->GetOwner() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGCBase::UpdateSOCacheVersions()
{
	CUtlVector<CUtlString> vecSetKeys( 0, m_rbtreeSOCachesWithDirtyVersions.Count() );
	CUtlVector<GCMemcachedBuffer_t> vecSetValues( 0, m_rbtreeSOCachesWithDirtyVersions.Count() );
	CUtlBuffer bufData( 0, ( sizeof( uint64 ) * m_rbtreeSOCachesWithDirtyVersions.Count() ) + 1 );

	CUtlVector<CUtlString> vecDeleteKeys( 0, m_rbtreeSOCachesWithDirtyVersions.Count() );

	for ( int idx = 0; idx < m_rbtreeSOCachesWithDirtyVersions.MaxElement(); ++idx )
	{
		if ( !m_rbtreeSOCachesWithDirtyVersions.IsValidIndex( idx ) ) 
			continue;

		const CSteamID &steamID = m_rbtreeSOCachesWithDirtyVersions[idx];

		// if the SO Cache is being loaded, ignore
		if ( m_rbtreeSOCachesBeingLoaded.Find( steamID ) != m_rbtreeSOCachesBeingLoaded.InvalidIndex() )
			continue;

		CSharedObjectCache *pSOCache = FindSOCache( steamID );
		if ( pSOCache )
		{
			CUtlString &strKey = vecSetKeys[ vecSetKeys.AddToTail() ];
			strKey.Format( "SOCacheVersionV2_%llu", steamID.ConvertToUint64() );

			GCMemcachedBuffer_t &bufVal = vecSetValues[ vecSetValues.AddToTail() ];
			bufVal.m_pubData = (byte *)bufData.Base() + bufData.TellPut();
			bufVal.m_cubData = sizeof( uint64 );

			bufData.PutInt64( pSOCache->GetVersion() );

#ifdef _DEBUG
			EmitInfo( SPEW_CONSOLE, 3, 3, "SOCacheVersion - storing version in memcached for %s (%llu).\n", steamID.Render(), pSOCache->GetVersion() );
#endif
		}
		else
		{
			// SO Cache is gone, so to be safe, remove the cached version number from memcached
			CUtlString &strKey = vecDeleteKeys[ vecDeleteKeys.AddToTail() ];
			strKey.Format( "SOCacheVersionV2_%llu", steamID.ConvertToUint64() );

#ifdef _DEBUG
			EmitInfo( SPEW_CONSOLE, 3, 3, "SOCacheVersion - no SO Cache, removing version in memcached for %s.\n", steamID.Render() );
#endif
		}
	}

	if ( vecSetKeys.Count() > 0 )
	{
		BMemcachedSet( vecSetKeys, vecSetValues );
	}

	if ( vecDeleteKeys.Count() > 0 )
	{
		BMemcachedDelete( vecDeleteKeys );
	}

	m_rbtreeSOCachesWithDirtyVersions.RemoveAll();
}


//-----------------------------------------------------------------------------
// Purpose: Returns the publisher access key for Steam Web APIs. This is just
//	a stub and must be implimented by a child class if they want this 
//	funtionality.
//-----------------------------------------------------------------------------
const char *CGCBase::GetSteamAPIKey()
{
	AssertMsg( false, "GetWebAPIKey(): Implement me!" );
	EmitError( SPEW_CONSOLE, "GetWebAPIKey(): Implement me!\n" );

	return "InvalidKey";
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the protobuf object was stored successfully, false otherwise
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedSet( const char *pKey, const ::google::protobuf::Message &protoBufObj )
{
	// build key
	CUtlVector< CUtlString > vecKeys;
	int idx = vecKeys.AddToTail();
	vecKeys[idx].Set( pKey );

	// allocate buffer we will use to stuff into the memcached buffer
	CUtlVector< CGCBase::GCMemcachedBuffer_t > vecValues;
	uint32 unSize = protoBufObj.ByteSize();
	void *pvBuf = stackalloc( unSize );
	protoBufObj.SerializeWithCachedSizesToArray( (uint8*)pvBuf );

	// stuff the data into the memcached buffer
	CGCBase::GCMemcachedBuffer_t buffer;
	buffer.m_pubData = pvBuf;
	buffer.m_cubData = unSize;
	vecValues.AddToTail( buffer );

	return BMemcachedSet( vecKeys, vecValues );
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the memcached value stored via pKey was removed succesfully, false otherwise
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedDelete( const char *pKey )
{
	CUtlVector< CUtlString > vecKeys;
	int idx = vecKeys.AddToTail();
	vecKeys[idx].Set( pKey );
	return BMemcachedDelete( vecKeys );
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the protobuf object was retrieved from memcached successfully, false otherwise
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingMemcachedGet( const char *pKey, ::google::protobuf::Message &protoBufMsg )
{
	// build key
	CUtlVector< CUtlString > vecKeys;
	int idx = vecKeys.AddToTail();
	vecKeys[idx].Set( pKey );

	// get results
	CUtlVector< CGCBase::GCMemcachedGetResult_t > vecResults;
	if ( !BYieldingMemcachedGet( vecKeys, vecResults ) || vecResults.Count() != 1 || vecResults[0].m_bKeyFound == false )
	{
		return false;
	}
	if ( !protoBufMsg.ParseFromArray( vecResults[0].m_bufValue.Base(), vecResults[0].m_bufValue.Count() ) )
	{
		return false;
	}
	if ( !protoBufMsg.IsInitialized() )
	{
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Set the keys and values into memcached
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedSet( const CUtlVector<CUtlString> &vecKeys, const CUtlVector<GCMemcachedBuffer_t> &vecValues )
{
	Assert( vecKeys.Count() == vecValues.Count() );
	if ( vecKeys.Count() != vecValues.Count() )
		return false;

	CProtoBufMsg<CGCMsgMemCachedSet> msgRequest( k_EGCMsgMemCachedSet );
	for ( int i = 0; i < vecKeys.Count(); ++i )
	{
		CGCMsgMemCachedSet_KeyPair *keypair = msgRequest.Body().add_keys();
		keypair->set_name( vecKeys[i].String() );
		keypair->set_value( vecValues[i].m_pubData, vecValues[i].m_cubData );
	}

	if( !BSendSystemMessage( msgRequest ) )
		return false;

	// There is no reply to setting in memcached
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Overload for a single key/value
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedSet( const CUtlString &strKey, const CUtlBuffer &buf )
{
	CUtlVector<CUtlString> memcachedMemberKeys( 0, 1 );
	CUtlVector<CGCBase::GCMemcachedBuffer_t> memcachedMemberValues( 0, 1 );

	memcachedMemberKeys.AddToTail( strKey );

	CGCBase::GCMemcachedBuffer_t &memcachedBuffer = memcachedMemberValues[ memcachedMemberValues.AddToTail() ];
	memcachedBuffer.m_pubData = buf.Base();
	memcachedBuffer.m_cubData = buf.TellPut();

	return BMemcachedSet( memcachedMemberKeys, memcachedMemberValues );
}


//-----------------------------------------------------------------------------
// Purpose: Delete the keys in memcached
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedDelete( const CUtlVector<CUtlString> &vecKeys )
{
	CProtoBufMsg<CGCMsgMemCachedDelete> msgRequest( k_EGCMsgMemCachedDelete );
	for ( int i = 0; i < vecKeys.Count(); ++i )
	{
		msgRequest.Body().add_keys( vecKeys[i].String() );
	}

	if( !BSendSystemMessage( msgRequest ) )
		return false;

	// There is no reply to deleting in memcached
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Overload for a single key/value
//-----------------------------------------------------------------------------
bool CGCBase::BMemcachedDelete( const CUtlString &strKey )
{
	CUtlVector<CUtlString> vecKeys( 0, 1 );
	vecKeys.AddToTail( strKey );
	return BMemcachedDelete( vecKeys );
}


//-----------------------------------------------------------------------------
// Purpose: Get the key's values from memcached
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingMemcachedGet( const CUtlVector<CUtlString> &vecKeys, CUtlVector<GCMemcachedGetResult_t> &vecResults )
{
	CProtoBufMsg<CGCMsgMemCachedGet> msgRequest( k_EGCMsgMemCachedGet );
	for ( int i = 0; i < vecKeys.Count(); ++i )
	{
		msgRequest.Body().add_keys( vecKeys[i].String() );
	}
	msgRequest.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msgRequest ) )
		return false;

	CProtoBufMsg<CGCMsgMemCachedGetResponse> msgResponse;
	if( !GJobCur().BYieldingWaitForMsg( &msgResponse, k_EGCMsgMemCachedGetResponse ) )
	{
		EmitWarning( SPEW_GC, LOG_ALWAYS, "Didn't get reply from IS for BYieldingMemcachedGet\n" );
		return false;
	}

	Assert( msgRequest.Body().keys_size() == msgResponse.Body().values_size() );
	if ( msgRequest.Body().keys_size() != msgResponse.Body().values_size() )
	{
		EmitWarning( SPEW_GC, LOG_ALWAYS, "Mismatched reply from IS for BYieldingMemcachedGet, asked for %d keys, got %d back\n", (int)msgRequest.Body().keys_size(), (int)msgResponse.Body().values_size() );
		return false; // Doesn't match what we asked for!
	}

	vecResults.Purge();
	vecResults.EnsureCapacity( msgResponse.Body().values_size() );
	for ( int i = 0; i < msgResponse.Body().values_size(); ++i )
	{
		GCMemcachedGetResult_t &result = vecResults[ vecResults.AddToTail() ];
		result.m_bKeyFound = msgResponse.Body().values(i).found();
		if ( result.m_bKeyFound )
		{
			result.m_bufValue.Copy( &(*msgResponse.Body().values(i).value().begin()), msgResponse.Body().values(i).value().size() );
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Overload for a single key/value
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingMemcachedGet( const CUtlString &strKeys, GCMemcachedGetResult_t &result )
{
	CUtlVector<CUtlString> memcachedMemberKeys( 0, 1 );
	CUtlVector<GCMemcachedGetResult_t> memcachedResults;

	memcachedMemberKeys.AddToTail( strKeys );
	bool bRet = BYieldingMemcachedGet( memcachedMemberKeys, memcachedResults );
	if ( !bRet )
		return false;

	Assert( 1 == memcachedResults.Count() );
	if ( 1 != memcachedResults.Count() )
		return false;

	result.m_bKeyFound = memcachedResults[0].m_bKeyFound;
	result.m_bufValue.Swap( memcachedResults[0].m_bufValue );
	return true;
}


//-----------------------------------------------------------------------------
bool CGCBase::BYieldingGetIPLocations( CUtlVector<uint32> &vecIPs, CUtlVector<CIPLocationInfo> &infos )
{
	CProtoBufMsg<CGCMsgGetIPLocation> msgRequest( k_EGCMsgGetIPLocation );
	FOR_EACH_VEC( vecIPs, i )
	{
		msgRequest.Body().add_ips( vecIPs[i] );
	}

	msgRequest.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msgRequest ) )
		return false;

	// We don't need to worry about a reply mismatch in this case.  The message
	// has sufficient data so that we can match up the reply properly.
	GJobCur().ClearFailedToReceivedMsgType( k_EGCMsgGetIPLocationResponse );

	CProtoBufMsg<CGCMsgGetIPLocationResponse> msgResponse;
	if( !GJobCur().BYieldingWaitForMsg( &msgResponse, k_EGCMsgGetIPLocationResponse ) )
	{
		EmitWarning( SPEW_GC, LOG_ALWAYS, "Didn't get reply from IS for BYieldingGetIPLocation\n" );
		return false;
	}

	for ( int i = 0; i < msgResponse.Body().infos_size(); i++ )
	{
		infos.AddToTail( msgResponse.Body().infos( i ) );
	}

	return true;
}

//-----------------------------------------------------------------------------
bool CGCBase::BYieldingUpdateGeoLocation( CUtlVector<CSteamID> const &requestedVecSteamIds )
{
	CUtlVector<uint32> vecIPs;
	CUtlVector<CSteamID> vecSteamIds;

	FOR_EACH_VEC( requestedVecSteamIds, i )
	{
		const CSteamID memberSteamID = requestedVecSteamIds[i];
		CGCSession *pSession = FindUserOrGSSession( memberSteamID );
		if( pSession )
		{
			if ( !pSession->GetIPPublic() )
			{
				EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "BYieldingUpdateGeoLocation Session %s IP == 0, unable to retrieve\n", memberSteamID.Render() ) ;
				continue;
			}
			if ( !pSession->HasGeoLocation() )
			{
				vecIPs.AddToTail( pSession->GetIPPublic() );
				vecSteamIds.AddToTail( memberSteamID );
			}
		}
	}

	if (!vecIPs.Count())
		return true;

#define iptod(x) ((x)>>24&0xff), ((x)>>16&0xff), ((x)>>8&0xff), ((x)&0xff)

	FOR_EACH_VEC( vecIPs, i )
	{
		EmitInfo( SPEW_GC, geolocation_spewlevel.GetInt(), geolocation_loglevel.GetInt(), "BYieldingUpdateGeoLocation GetIPLocation[%d] = (%s,%u.%u.%u.%u)\n", i, vecSteamIds[i].Render(), iptod( vecIPs[i] ) ) ;
	}

	CUtlVector<CIPLocationInfo> infos;
	if ( BYieldingGetIPLocations( vecIPs, infos ) )
	{
		// The current IS has a bug where the IP will be blank/zero in the replies. If infos.Count() == vecIPs.Count() assume the order is correct
		if ( vecSteamIds.Count() == vecIPs.Count() && vecIPs.Count() == infos.Count() )
		{
			FOR_EACH_VEC( vecSteamIds, i )
			{
				CGCSession *pSession = FindUserOrGSSession( vecSteamIds[i] );
				if ( pSession )
				{
					EmitInfo( SPEW_GC, geolocation_spewlevel.GetInt(), geolocation_loglevel.GetInt(), "BYieldingUpdateGeoLocation[MATCHED] SetIPLocation[%s(%u.%u.%u.%u)] = (%6.3f,%6.3f)\n", pSession->GetSteamID().Render(), iptod( vecIPs[i] ), infos[i].latitude(), infos[i].longitude() );
					pSession->SetGeoLocation( infos[i].latitude(), infos[i].longitude() );
				}
			}
		}
		else
		{
			FOR_EACH_VEC( vecSteamIds, i )
			{
				FOR_EACH_VEC( infos, j )
				{
					if ( infos[j].ip() == vecIPs[i] )
					{
						CGCSession *pSession = FindUserOrGSSession( vecSteamIds[i] );
						if ( pSession )
						{
							EmitInfo( SPEW_GC, 4, LOG_ALWAYS, "BYieldingUpdateGeoLocation[SEARCHED] SetIPLocation[%s(%u.%u.%u.%u)] = (%6.3f,%6.3f)\n", pSession->GetSteamID().Render(), iptod( vecIPs[i] ), infos[j].latitude(), infos[j].longitude() );
							pSession->SetGeoLocation( infos[j].latitude(), infos[j].longitude() );
						}
					}
				}
			}
		}
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Populate the KeyValues with the stats
//-----------------------------------------------------------------------------
void CGCBase::SystemStats_Update( CGCMsgGetSystemStatsResponse &msgStats )
{
	msgStats.set_active_jobs( m_JobMgr.CountJobs() );
	msgStats.set_yielding_jobs( m_JobMgr.CountYieldingJobs() );
	msgStats.set_user_sessions( m_hashUserSessions.Count() );
	msgStats.set_game_server_sessions( m_hashGSSessions.Count() );
	msgStats.set_socaches( m_mapSOCache.Count() );
	msgStats.set_socaches_to_unload( m_listCachesToUnload.Count() );
	msgStats.set_socaches_loading( m_rbtreeSOCachesBeingLoaded.Count() );
	msgStats.set_writeback_queue( m_vecCacheWritebacks.Count() );
	msgStats.set_steamid_locks( m_hashSteamIDLocks.Count() );
	msgStats.set_logon_queue( m_llStartPlaying.Count() );
	msgStats.set_logon_jobs( m_nStartPlayingJobCount );
}


//-----------------------------------------------------------------------------
// Purpose: Returns the singleton GC object
//-----------------------------------------------------------------------------
CGCBase *GGCBase()
{
	return g_pGCBase;
}


//-----------------------------------------------------------------------------
// Purpose: Spews information about the active locks on the GC
//-----------------------------------------------------------------------------
int LockSortFunc( CLock  * const  *lhs, CLock * const  *rhs )
{
	return (*rhs)->GetWaitingCount() - (*lhs)->GetWaitingCount();
}

void CGCBase::DumpSteamIDLocks( bool bFull, int nMax )
{
	CUtlVector<CLock *> vecLocks;
	for( CLock *pLock = m_hashSteamIDLocks.PvRecordFirst(); NULL != pLock; pLock = m_hashSteamIDLocks.PvRecordNext( pLock ) )
	{
		if( pLock->BIsLocked() )
		{
			vecLocks.AddToTail( pLock );
		}
	}

	vecLocks.Sort( LockSortFunc );

	if( nMax > vecLocks.Count() || bFull )
	{
		nMax = vecLocks.Count();
	}

	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%d locks total. %d locked, %d displayed\n", m_hashSteamIDLocks.Count(), vecLocks.Count(), nMax );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Lock                     Holding Job            First Waiting Job      Wait Count  Lock Time\n" );

	for( int nLock = 0; nLock < nMax; nLock++ )
	{
		CLock *pLock = vecLocks[nLock];
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%-24s %-22s %-22s %-11d %d\n", 
			pLock->GetName(), 
			pLock->GetJobLocking() ? pLock->GetJobLocking()->GetName() : "--",
			pLock->GetJobWaitingQueueHead() ? pLock->GetJobWaitingQueueHead()->GetName() : "--",
			pLock->GetWaitingCount(),
			(int) ( pLock->GetMicroSecondsSinceLock() / k_nMillion ) );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Dumps informations about currently running jobs
//-----------------------------------------------------------------------------
void CGCBase::DumpJobs( const char *pszJobName, int nMax, int nPrintLocksMax ) const
{
	m_JobMgr.DumpJobs( pszJobName, nMax, nPrintLocksMax );
}


//-----------------------------------------------------------------------------
// Purpose: Dumps information about a specific job
//-----------------------------------------------------------------------------
void CGCBase::DumpJob( JobID_t jobID, int nPrintLocksMax ) const
{
	m_JobMgr.DumpJob( jobID, nPrintLocksMax );
}


//-----------------------------------------------------------------------------
// Purpose: Returns counts of core objects
//-----------------------------------------------------------------------------
int CGCBase::GetSOCacheCount() const
{
	return m_mapSOCache.Count();
}

bool CGCBase::IsSOCached( const CSharedObject *pObj, uint32 nTypeID ) const
{
	// OPT: If there are many caches, this is very slow - it would be faster have a ref count on the shared object to track this.
	// However this is debug only code.
#if defined( DEBUG )
	FOR_EACH_MAP_FAST( m_mapSOCache, i )
	{
		CGCSharedObjectCache *pCache = m_mapSOCache[ i ];
		if ( pCache->IsObjectCached( pObj, nTypeID ) )
		{
			return true;
		}
		if ( pCache->IsObjectDirty( pObj ) )
		{
			Assert( false );
			return true;
		}
	}
#else
	AssertMsg( false, "Calling IsSOCached() in release mode. This is a debug only function" );
#endif
	return false;
}

int CGCBase::GetUserSessionCount() const
{
	return m_hashUserSessions.Count();
}

int CGCBase::GetGSSessionCount() const
{
	return m_hashGSSessions.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Mark that we are shutting down
//-----------------------------------------------------------------------------
void CGCBase::SetIsShuttingDown()
{
	m_bIsShuttingDown = true;
	GetJobMgr().SetIsShuttingDown();
}

//-----------------------------------------------------------------------------
// Purpose: Sets whether we are profiling or not
//-----------------------------------------------------------------------------
void CGCBase::SetProfilingEnabled( bool bEnabled )
{
	if ( bEnabled )
	{
		m_bStartProfiling = true;
	}
	else
	{
		m_bStopProfiling = true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets whether to spew about vprof imbalances
//-----------------------------------------------------------------------------
void CGCBase::SetDumpVprofImbalances( bool bEnabled )
{
	m_bDumpVprofImbalances = bEnabled;
}


//-----------------------------------------------------------------------------
// Purpose: Returns whether we are spewing vprof imbalances
//-----------------------------------------------------------------------------
bool CGCBase::GetVprofImbalances()
{
	return m_bDumpVprofImbalances;
}


//-----------------------------------------------------------------------------
// Purpose: Returns a steam ID for a user-provided input. Works with accountID,
//			steam account name, or steam ID.
//-----------------------------------------------------------------------------
CSteamID CGCBase::YieldingGuessSteamIDFromInput( const char *pchInput )
{
	AssertRunningJob();

	if( !pchInput )
	{
		EmitError( SPEW_CONSOLE, "Invalid NULL string passed to YieldingGuessSteamIDFromInput\n" );
		return CSteamID();
	}

	EUniverse localUniverse = m_pHost->GetUniverse();

	// Is it a 64 bit Steam ID?
	if ( pchInput[0] >= '0' && pchInput[0] <= '9' )
	{
		CSteamID steamID( V_atoui64( pchInput ) );
		if ( steamID.IsValid() )
			return steamID;
	}

	// quoted 

	// See if it's a profile link. If it is, clip the SteamID from it.
	const char *pszProfilePrepend = "steamcommunity.com/profiles/";
	int iInputLen = Q_strlen(pchInput);
	int iProfilePrependLen = Q_strlen(pszProfilePrepend);
	const char *pszFound = NULL;
	if ( (pszFound = Q_stristr( pchInput, pszProfilePrepend )) != NULL )
	{
		if ( iInputLen > ((pszFound + iProfilePrependLen) - pchInput) )
		{
			CSteamID steamID;
			steamID.SetFromString( (pszFound + iProfilePrependLen), localUniverse );
			if ( steamID.IsValid() )
				return steamID;
		}
	}

	// See if it's an id link.
	const char *pszIDPrepend = "steamcommunity.com/id/";
	int iIDPrependLen = Q_strlen(pszIDPrepend);
	if ( (pszFound = Q_stristr( pchInput, pszIDPrepend )) != NULL )
	{
		if ( iInputLen > ((pszFound + iIDPrependLen) - pchInput) )
		{
			char szMaxURL[512];
			Q_strncpy( szMaxURL, (pszFound + iIDPrependLen), sizeof(szMaxURL) );

			// Trim off a trailing slash
			int iURLLen = Q_strlen(szMaxURL);
			if ( szMaxURL[iURLLen-1] == '/' || pchInput[iURLLen-1] == '\\' )
			{
				szMaxURL[iURLLen-1] = '\0';
			}

			CUtlVector< CSteamID > vecIDs;
			if ( BYieldingLookupAccount( k_EFindAccountTypeURL, szMaxURL, &vecIDs ) )
			{
				// Should only ever find a single account for a URL
				if ( vecIDs.Count() == 1 )
					return vecIDs[0];
			}
		}
	}

	CGCMsg< MsgGCEmpty_t > msg( k_EGCMsgLookupAccountFromInput );
	msg.AddStrData( pchInput );
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
	{
		EmitError( SPEW_CONSOLE, "Unable to query GCHost in YieldingGuessSteamIDFromInput\n" );
		return CSteamID();
	}

	CGCMsg< MsgGCLookupAccountResponse > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgGenericReply ) )
	{
		EmitError( SPEW_CONSOLE, "No response from GCHost in YieldingGuessSteamIDFromInput\n" );
		return CSteamID();
	}

	return CSteamID( msgReply.Body().m_ulSteamID );
}


//-----------------------------------------------------------------------------
// Purpose: Returns all matching Steam IDs for the specified query.
// Returns: true if a response was received from Steam. The list may still be
//			empty in that case.
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingLookupAccount( EAccountFindType eFindType, const char *pchInput, CUtlVector< CSteamID > *prSteamIDs )
{
	if ( eFindType == k_EFindAccountTypeURL )
	{
		CSteamAPIRequest apiRequest( k_EHTTPMethodGET, "ISteamUser", "ResolveVanityURL", 1 );
		apiRequest.SetGETParamString( "vanityurl", pchInput );

		KeyValuesAD kvAPIResponse( "response" );
		CUtlString sWebApiErrMsg;
		EResult eResult = YieldingSendWebAPIRequest( apiRequest, kvAPIResponse, sWebApiErrMsg, false );
		if ( k_EResultOK != eResult )
		{
			// Emit an error on the less-common errors
			if ( k_EResultNoMatch != eResult )
			{
				EmitError( SPEW_GC, "WebAPI error looking up vanity URL by GC.  %s\n", sWebApiErrMsg.String() );
			}

			return false;
		}

		prSteamIDs->AddToTail( CSteamID( kvAPIResponse->GetUint64( "steamid" ) ) );

		return true;
	}
	else
	{
		CProtoBufMsg< CMsgAMFindAccounts > msg( k_EGCMsgFindAccounts );
		msg.Body().set_search_type( eFindType );
		msg.Body().set_search_string( pchInput );
		msg.ExpectingReply( GJobCur().GetJobID() );

		if( !BSendSystemMessage( msg ) )
		{
			EmitError( SPEW_GC, "Unable to send GCMsgFindAccounts\n" );
			return false;
		}

		CProtoBufMsg< CMsgAMFindAccountsResponse > response;
		if( !GJobCur().BYieldingWaitForMsg( &response, k_EGCMsgGenericReply ) )
		{
			EmitError( SPEW_GC, "No response to GCMsgFindAccounts\n" );
			return false;
		}

		for( int i=0; i<response.Body().steam_id_size(); i++ )
		{
			prSteamIDs->AddToTail( CSteamID( response.Body().steam_id( i ) ) );
		}

		return true;
	}
}

GC_CON_COMMAND( gc_search_vanityurl, "Tests searching for an account by vanity URL" )
{
	CUtlVector< CSteamID > vecIDs;
	if ( GGCBase()->BYieldingLookupAccount( k_EFindAccountTypeURL, args[1], &vecIDs ) )
	{
		Msg( "Search success.\n" );
		FOR_EACH_VEC( vecIDs, i )
		{
			CSteamID result = vecIDs[i];
			Msg( "Result: %llu\n", result.ConvertToUint64() );
		}
	}
	else
	{
		Msg( "Search failure.\n" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Dumps a summary of the GC's status
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingRecordSupportAction( const CSteamID & actorID, const CSteamID & targetID, const char *pchData, const char *pchNote )
{
	CGCMsg< MsgGCRecordSupportAction_t > msgRecordSupportAction( k_EGCMsgRecordSupportAction );
	msgRecordSupportAction.Body().m_unAccountID = targetID.GetAccountID();
	msgRecordSupportAction.Body().m_unActorID = actorID.GetAccountID();
	msgRecordSupportAction.AddStrData( pchData );
	msgRecordSupportAction.AddStrData( pchNote );
	msgRecordSupportAction.ExpectingReply( GJobCur().GetJobID() );
	GGCBase()->BSendSystemMessage( msgRecordSupportAction );

	CGCMsg< MsgGCEmpty_t > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgGenericReply ) )
	{
		EmitError( SPEW_GC, "No reply received to support action message\n" );
		return false;
	}
	else
	{
		return true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Posts a steam alert to the alert alias for this GC's app.
//-----------------------------------------------------------------------------
void CGCBase::PostAlert( EAlertType eAlertType, bool bIsCritical, const char *pchAlertText, const CUtlVector< CUtlString > *pvecExtendedInfo, bool bAlsoSpew )
{
	CProtoBufMsg< CMsgNotifyWatchdog > msg( k_EGCMsgPostAlert );
	msg.Body().set_alert_type( eAlertType );
	msg.Body().set_critical( bIsCritical );

	if( !pvecExtendedInfo )
	{
		msg.Body().set_text( pchAlertText );
	}
	else
	{
		// put all the messages in one giant string and set that as the text

		// figure out how big "giant" is
		uint32 unSize = Q_strlen( pchAlertText ) + 2; // header + \n + null
		FOR_EACH_VEC( *pvecExtendedInfo, nLine )
		{
			unSize += pvecExtendedInfo->Element( nLine ).Length();
		}

		// walk the strings again to assemble the buffer
		CUtlBuffer bufMessage( 0, unSize, CUtlBuffer::TEXT_BUFFER );
		bufMessage.PutString( pchAlertText );
		bufMessage.PutString( "\n" );
		FOR_EACH_VEC( *pvecExtendedInfo, nLine )
		{
			bufMessage.PutString( pvecExtendedInfo->Element( nLine ).Get() );
		}

		msg.Body().set_text( (const char *)bufMessage.Base() );
	}

	if( bAlsoSpew )
	{
		EmitError( SPEW_GC, "%s", msg.Body().text().c_str() );
	}

	BSendSystemMessage( msg );
}


//-----------------------------------------------------------------------------
// Purpose: Fills the vector with all package IDs this account has a license to
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingGetAccountLicenses( const CSteamID & steamID, CUtlVector< PackageLicense_t > & vecPackages )
{
	CProtoBufMsg< CMsgAMGetLicenses > msg( k_EGCMsgGetLicenses );
	msg.Body().set_steamid( steamID.ConvertToUint64() );
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Unable to send GetAccountLicenses system message\n" );
		return false;
	}

	CProtoBufMsg< CMsgAMGetLicensesResponse > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgGenericReply ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Timeout waiting for GetAccountLicenses reply\n" );
		return false;
	}

	if( msgReply.Body().result() != k_EResultOK )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "GetAccountLicenses for %s failed with %d\n", steamID.Render(), msgReply.Body().result() );
		return false;
	}

	vecPackages.RemoveAll();
	vecPackages.EnsureCapacity( msgReply.Body().license_size() );

	for( int i=0; i < msgReply.Body().license_size(); i++ )
	{
		const CMsgPackageLicense &msgPackage = msgReply.Body().license( i );

		//skip packages that they directly don't own (they may be lent to them via library sharing, and we don't want to grant based on that).
		//we count account ID of zero as matching so we can deal with old Steam versions that didn't provide this field
		if( ( msgPackage.owner_id() != steamID.GetAccountID() ) && ( msgPackage.owner_id() != 0 ) )
			continue;

		PackageLicense_t package;
		package.m_unPackageID = msgPackage.package_id();
		package.m_rtimeCreated = msgPackage.time_created();
		vecPackages.AddToTail( package );
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Fills the vector with all package IDs this account has a license to
//-----------------------------------------------------------------------------
bool CGCBase::BYieldingAddFreeLicense( const CSteamID & steamID, uint32 unPackageID, uint32 unIPPublic, const char *pchStoreCountryCode )
{
	CProtoBufMsg< CMsgAMAddFreeLicense > msg( k_EGCMsgAddFreeLicense );
	msg.Body().set_steamid( steamID.ConvertToUint64() );
	msg.Body().set_packageid( unPackageID );
	if( unIPPublic )
		msg.Body().set_ip_public( unIPPublic );
	if( pchStoreCountryCode )
		msg.Body().set_store_country_code( pchStoreCountryCode );
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Unable to send GetAccountLicenses system message\n" );
		return false;
	}

	CProtoBufMsg< CMsgAMAddFreeLicenseResponse > msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgAddFreeLicenseResponse ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Timeout waiting for GetAccountLicenses reply\n" );
		return false;
	}

	if( msgReply.Body().eresult() != k_EResultOK )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "BYieldingAddFreeLicense for %s failed with %d\n", steamID.Render(), msgReply.Body().eresult() );
		return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Fills the vector with all package IDs this account has a license to
//-----------------------------------------------------------------------------
int CGCBase::YieldingGrantGuestPass( const CSteamID & steamID, uint32 unPackageID, uint32 unPassesToGrant, int32 nDaysToExpiration )
{
	CProtoBufMsg<CMsgAMGrantGuestPasses2> msg( k_EGCMsgGrantGuestPass );
	msg.Body().set_steam_id( steamID.ConvertToUint64() );
	msg.Body().set_package_id( unPackageID );
	msg.Body().set_passes_to_grant( unPassesToGrant );
	msg.Body().set_days_to_expiration( nDaysToExpiration );
	msg.ExpectingReply( GJobCur().GetJobID() );
	if( !BSendSystemMessage( msg ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Unable to send GrantGuestPass system message\n" );
		return 0;
	}

	CProtoBufMsg<CMsgAMGrantGuestPasses2Response> msgReply;
	if( !GJobCur().BYieldingWaitForMsg( &msgReply, k_EGCMsgGrantGuestPassResponse ) )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "Timeout waiting for GrantGuestPass reply\n" );
		return 0;
	}

	if( msgReply.Body().eresult() != k_EResultOK )
	{
		EmitWarning( SPEW_GC, SPEW_ALWAYS, "YieldingGrantGuestPass for %s failed with %d\n", steamID.Render(), msgReply.Body().eresult() );
		return 0;
	}

	return msgReply.Body().passes_granted();
}


//-----------------------------------------------------------------------------
// Purpose: Gets data for an account
//-----------------------------------------------------------------------------
const CAccountDetails *CGCBase::YieldingGetAccountDetails( const CSteamID & steamID, bool bForceReload )
{
	return m_AccountDetailsManager.YieldingGetAccountDetails( steamID, bForceReload );
}


//-----------------------------------------------------------------------------
// Purpose: Gets the current persona name for an account
//-----------------------------------------------------------------------------
const char *CGCBase::YieldingGetPersonaName( const CSteamID & steamID, const char *szUnknownName )
{
	const char *szPersonaName = m_AccountDetailsManager.YieldingGetPersonaName( steamID );
	return szPersonaName ? szPersonaName : szUnknownName;
}

//-----------------------------------------------------------------------------
// Purpose: Clears a persona name from the cache
//-----------------------------------------------------------------------------
void CGCBase::ClearCachedPersonaName( const CSteamID & steamID )
{
	m_AccountDetailsManager.ClearCachedPersonaName( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: Tells us to load the persona name for a user, but not wait on it
//-----------------------------------------------------------------------------
void CGCBase::PreloadPersonaName( const CSteamID & steamID )
{
	m_AccountDetailsManager.PreloadPersonaName( steamID );
}


//-----------------------------------------------------------------------------
// Purpose: Sends a message to the web API servers letting them know what the
//			methods and interfaces are for this GC.
//-----------------------------------------------------------------------------
bool CGCBase::BSendWebApiRegistration()
{
	// if we aren't initialized enough to have a GCHost, just skip this 
	// registration request. We'll register later in our init process.
	if( !m_pHost )
		return false;

	if( CGCWebAPIInterfaceMapRegistrar::VecInstance().Count() > 0 )
	{
		CGCMsg< MsgGCWebAPIRegisterInterfaces_t > msgWebRegistration( k_EGCMsgWebAPIRegisterInterfaces );
		msgWebRegistration.Body().m_cInterfaces = CGCWebAPIInterfaceMapRegistrar::VecInstance().Count();
		CUtlBuffer bufRegistrations;
		FOR_EACH_VEC( CGCWebAPIInterfaceMapRegistrar::VecInstance(), nInterface )
		{
			KeyValues *pkvInterface = CGCWebAPIInterfaceMapRegistrar::VecInstance()[ nInterface ]();
			Assert( pkvInterface );
			if( !pkvInterface )
				return false;

			KVPacker packer;
			packer.WriteAsBinary( pkvInterface, bufRegistrations );
			pkvInterface->deleteThis();
		}
		msgWebRegistration.AddVariableLenData( bufRegistrations.Base(), bufRegistrations.TellPut() );
		if( !BSendSystemMessage( msgWebRegistration ) )
			return false;
	}
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Dumps a summary of the GC's status
//-----------------------------------------------------------------------------
void CGCBase::Dump() const
{
	char rtimeBuf[k_RTimeRenderBufferSize];

	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "GC Status for %d: path=%s\n", m_unAppID, m_sPath.Get() );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tLogon Surge: %s\n", BIsInLogonSurge() ? "Yes" : "No" );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tStartPlaying: waiting=%d, jobs running=%d of %d\n", m_llStartPlaying.Count(), m_nStartPlayingJobCount, cv_concurrent_start_playing_limit.GetInt() );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tJobs: active=%d, yielding=%d\n", m_JobMgr.CountJobs(), m_JobMgr.CountYieldingJobs() );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tSessions: user=%d, gameserver=%d\n", m_hashUserSessions.Count(), m_hashGSSessions.Count() );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tCaches: %d (%d waiting to unload, %d currently loading, %s %d /+ %d)\n", m_mapSOCache.Count(), m_listCachesToUnload.Count(), m_rbtreeSOCachesBeingLoaded.Count(),
		( ( ( m_jobidFlushInventoryCacheAccounts == k_GIDNil ) || !m_JobMgr.BJobExists( m_jobidFlushInventoryCacheAccounts ) ) ? "last flushed" : "currently flushing" ),
		m_numFlushInventoryCacheAccountsLastScheduled, m_rbFlushInventoryCacheAccounts.Count() );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tWriteback Queue: %d (oldest: %s)\n", m_vecCacheWritebacks.Count(), m_vecCacheWritebacks.Count() > 0 ? CRTime::Render( m_vecCacheWritebacks[0]->GetWritebackTime(), rtimeBuf ) : "none" );
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tYieldingRequestSession: %d active\n", m_nRequestSessionJobsActive );
	m_AccountDetailsManager.Dump();
}


//-----------------------------------------------------------------------------
// Purpose: Dumps a summary of the GC's status
//-----------------------------------------------------------------------------
const char *CGCBase::GetCDNURL() const
{
	if( m_sCDNURL.IsEmpty() )
	{
		switch( m_pHost->GetUniverse() )
		{
		case k_EUniverseDev:
		case k_EUniverseBeta:
			m_sCDNURL.Format( "http://cdn.beta.steampowered.com/apps/%d/", GetAppID() );
			break;
		case k_EUniversePublic:
		default:
			m_sCDNURL.Format( "http://media.steampowered.com/apps/%d/", GetAppID() );
			break;
		}
	}

	return m_sCDNURL.Get();
}


//-----------------------------------------------------------------------------
// Purpose: Prints an assert to the console
//-----------------------------------------------------------------------------


void CGCBase::AssertCallbackFunc( const char *pchFile, int nLine, const char *pchMessage )
{
	if ( !ThreadInMainThread() ) // !KLUDGE!
	{
		EmitWarning( SPEW_GC, 4, "Thread assert %s(%d): %s\n", pchFile, nLine, pchMessage );
		return;
	}

	// Our spew handler should have already spewed this once, no need to spew it again
	//EmitError( SPEW_CONSOLE, "%s (%d): %s\n", V_GetFileName( pchFile ), nLine, pchMessage );
	if ( !Plat_IsInDebugSession() )
	{

		char rchCleanedJobName[48] = "";
		if ( ThreadInMainThread() && g_pJobCur != NULL )
		{
			const char *pszJobName = g_pJobCur->GetName();
			int l = 0;
			while ( l < sizeof(rchCleanedJobName)-1 )
			{
				char c = pszJobName[l];
				if ( c == '\0' )
					break;
				if ( !V_isalnum( c ) )
				{
					c = '_';
				}
				rchCleanedJobName[l] = c;
				++l;
			}
			rchCleanedJobName[l] = 0;
		}

		// Throttle writing of minidumps on a file / line / job basis
		CFmtStr sFileAndLine( "assert_%s(%d)%s%s",
			V_GetFileName( pchFile ),
			nLine,
			rchCleanedJobName[0] ? "_" : "",
			rchCleanedJobName
		);

		static CUtlDict< CCopyableUtlVector< RTime32 > > s_dictAsserts;

		int iDict = s_dictAsserts.Find( sFileAndLine.Access() );
		if ( !s_dictAsserts.IsValidIndex( iDict ) )
		{
			iDict = s_dictAsserts.Insert( sFileAndLine.Access() );
		}

		CCopyableUtlVector< RTime32 > &vecTimes = s_dictAsserts[iDict];

		int nStale = 0;
		while ( nStale < vecTimes.Count() && ( CRTime::RTime32TimeCur() - vecTimes[nStale] ) > (uint32)cv_assert_minidump_window.GetInt() )
		{
			nStale++;
		}
		vecTimes.RemoveMultipleFromHead( nStale );

		bool bWriteDump = ( vecTimes.Count() < cv_assert_max_minidumps_in_window.GetInt() );
		if ( bWriteDump )
		{
			vecTimes.AddToTail( CRTime::RTime32TimeCur() );

			CUtlString sCurJob;
			if ( ThreadInMainThread() && g_pJobCur != NULL )
			{
				sCurJob.Format( "[From job %s]\n", g_pJobCur->GetName() );
			}

			// Write the dump
			CUtlString sDumpComment;
			sDumpComment.Format( "%s%s%s(%d): %s",
				GGCBase()->GetIsShuttingDown() ? "[During shutdown]\n" : "", // Asserts during shutdown are much more often spurious.  Let's make it clear if a shutdown happens during shutdown
				sCurJob.String(), // The name of the current job name is often an incredibly useful piece of info.  If the dumps are not valid, this can narrow the search space immensely
				pchFile,
				nLine,
				pchMessage
			);
			SetMinidumpComment( sDumpComment.String() );
			WriteMiniDump( sFileAndLine.Access() );
			SetMinidumpComment( "" ); // just for grins
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Claims all the memory for the GC
//-----------------------------------------------------------------------------
void CGCBase::Validate( CValidator &validator, const char *pchName )
{
	VPROF_BUDGET( "CGCBase::Validate", VPROF_BUDGETGROUP_STEAM );

	// these are INSIDE the function instead of outside so the interface 
	// doesn't change
#ifdef DBGFLAG_VALIDATE
	VALIDATE_SCOPE();

	// Validate the global message list
	g_theMessageList.Validate( validator, "g_theMessageList" );

	// Validate the network global memory pool
	g_MemPoolMsg.Validate( validator, "g_MemPoolMsg" );

	CNetPacketPool::ValidateGlobals( validator );

	CJobMgr::ValidateStatics( validator, "CJobMgr" );
	CJob::ValidateStatics( validator, "CJob" );
	ValidateTempTextBuffers( validator );

	ValidateObj( m_JobMgr );
	ValidateObj( m_sPath );

	ValidateObj( m_hashUserSessions );
	for( CGCUserSession **ppSession = m_hashUserSessions.PvRecordFirst(); ppSession != NULL; ppSession = m_hashUserSessions.PvRecordNext( ppSession ) )
	{

		ValidatePtr( *ppSession );
	}
	ValidateObj( m_hashGSSessions );
	for( CGCGSSession **ppSession = m_hashGSSessions.PvRecordFirst(); ppSession != NULL; ppSession = m_hashGSSessions.PvRecordNext( ppSession ) )
	{
		ValidatePtr( *ppSession );
	}

	// validate the SQL access layer
	CRecordBase::ValidateStatics( validator, "CRecordBase" );
	GSchemaFull().Validate( validator, "GSchemaFull" );
	CRecordInfo::ValidateStatics( validator, "CRecordInfo" );
	CSharedObject::ValidateStatics( validator );

	OnValidate( validator, pchName );
#endif // DBGFLAG_VALIDATE
}

EResult YieldingSendWebAPIRequest( CSteamAPIRequest &request, KeyValues *pKVResponse, CUtlString &errMsg, bool b200MeansSuccess )
{
	CHTTPResponse apiResponse;
	if ( !GGCBase()->BYieldingSendHTTPRequest( &request, &apiResponse ) )
	{
		errMsg.Format( "Did not get a response" );
		return k_EResultTimeout;
	}

	if ( k_EHTTPStatusCode200OK != apiResponse.GetStatusCode() )
	{
		errMsg.Format( "HTTP status code %d", apiResponse.GetStatusCode() );

		//		if ( k_EResultOK != pKVResponse->GetInt( "result", k_EResultFail ) )
		//		{
		//			EmitError( SPEW_GC, "Web call to %s failed with error %d: %s\n", 
		//					   request.GetURL(),
		//					   pKVResponse->GetInt( "error/errorcode", k_EResultFail ), 
		//					   pKVResponse->GetString( "error/errordesc" ) );
		//			return pKVResponse->GetInt( "error/errorcode", k_EResultFail );
		//		}

		return k_EResultFail;
	}

	
	if ( apiResponse.GetBodyBuffer() )
	{
		pKVResponse->UsesEscapeSequences( true );
		if ( !pKVResponse->LoadFromBuffer( "webResponse", *apiResponse.GetBodyBuffer() ) )
		{
			errMsg.Format( "Failed to parse keyvalues result" );
			return k_EResultFail;
		}
	}

	if ( b200MeansSuccess )
	{
		return k_EResultOK;
	}

	int result = pKVResponse->GetInt( "success", -1 );
	if ( result < 0 )
	{
		errMsg = "Reply missing result code";
		return k_EResultFail;
	}
	errMsg = pKVResponse->GetString( "message", "" );
	if ( result != k_EResultOK && errMsg.IsEmpty() )
	{
		errMsg = "(Unknown error)";
	}
	return (EResult)result;
}

GC_CON_COMMAND( ip_geolocation, "<a.b.c.d> Perform geolocation lookup" )
{
	if ( args.ArgC() < 2 )
	{
		EmitError( SPEW_GC, "Pass at least one IP to lookup\n" );
		return;
	}

	// Get List of IP's to query
	CUtlVector<uint32> vecIPs;
	for ( int i = 1 ; i < args.ArgC() ; ++i )
	{
		netadr_t adr;
		adr.SetFromString( args[i] );
		if ( adr.GetIPHostByteOrder() == 0 )
		{
			EmitInfo( SPEW_GC, 1, 1, "%s is not a valid IP\n", args[i] );
		}
		else
		{
			vecIPs.AddToTail( adr.GetIPHostByteOrder() );
		}
	}
	if ( vecIPs.Count() <= 0 )
		return;

	// Do the query
	CUtlVector<CIPLocationInfo> vecInfos;
	vecInfos.SetCount( vecIPs.Count() );
	GGCBase()->BYieldingGetIPLocations( vecIPs, vecInfos );
	for ( int i = 0 ; i < vecInfos.Count() ; ++i )
	{
		netadr_t adr( vecInfos[i].ip(), 0 );
		EmitInfo( SPEW_GC, 1, 1, "%s:  %.1f, %.1f\n", adr.ToString( true ), vecInfos[i].latitude(), vecInfos[i].longitude() );
	}
}

} // namespace GCSDK