path: root/replay/sv_publishtest.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//=======================================================================================//

#include "sv_publishtest.h"
#include "spew.h"
#include "replay/replayutils.h"
#include "replaysystem.h"
#include "sv_basejob.h"
#include "sv_fileservercleanup.h"
#include "tier1/convar.h"
#include "sv_filepublish.h"

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

//----------------------------------------------------------------------------------------

const char *g_pAcceptableFileserverProtocols[] = { "http", "https", NULL };
const char *g_pAcceptableOffloadProtocols[] = { "ftp", NULL };

//----------------------------------------------------------------------------------------

class CPublishTester
{
public:
	CPublishTester();
	~CPublishTester();

	bool Go();

private:
	bool Test_Emptyness( const char *pDescription, const char *pStr, bool bPrintResult );
	bool Test_Hostname( const char *pHostname, const char *pProtocolExample );
	bool Test_Protocol( const char *pDescription, const char *pProtocol, const char **pAcceptableProtocols );
	bool Test_Port( int nPort );
	bool Test_Path( const char *pDescription, const char *pPath, bool bForwardSlashesAllowed, bool bBackslashesAllowed );
	bool Test_LocalWebServerCVars();
	bool Test_IO( const char *pFilename );
	bool Test_FilePublish( const char *pFilename, bool bOffload );
	bool Test_PublishedFileDelete( const char *pFullFilename, const char *pFilename, bool bOffload );
	bool Test_WaitingForPlayersCVar();
	void PrintBaseUrlWarning();

	char		*m_pGarbageBuffer;
	CBaseJob	*m_pJob;
	CBaseJob	*m_pCleanerJob;
};

//----------------------------------------------------------------------------------------

#define GARBAGE_BUFFER_SIZE			( 1024 * 1000 )

CPublishTester::CPublishTester()
:	m_pGarbageBuffer( NULL ),
	m_pJob( NULL ),
	m_pCleanerJob( NULL )
{
	m_pGarbageBuffer = new char[ GARBAGE_BUFFER_SIZE ];
}

CPublishTester::~CPublishTester()
{
	delete [] m_pGarbageBuffer;
	
	if ( m_pJob )
	{
		m_pJob->Release();
	}

	if ( m_pCleanerJob )
	{
		m_pCleanerJob->Release();
	}
}

bool CPublishTester::Test_Hostname( const char *pHostname, const char *pProtocolExample )
{
	if ( !Test_Emptyness( "Hostname", pHostname, false ) )
		return false;

	if ( V_strstr( pHostname, "://" ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		CFmtStr fmtError( "Should not contain a protocol (e.g: %s)!", pProtocolExample );
		g_pBlockSpewer->PrintEventError( fmtError.Access() );
		return false;
	}

	// Test IP lookup
	char szIP[16];
	if ( !g_pEngine->NET_GetHostnameAsIP( pHostname, szIP, sizeof( szIP ) ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "DNS lookup failed!" );
		return false;
	}

	g_pBlockSpewer->PrintEventResult( true );
	g_pBlockSpewer->PrintEmptyLine();

	return true;
}

bool CPublishTester::Test_Emptyness( const char *pDescription, const char *pStr, bool bPrintResult )
{
	g_pBlockSpewer->PrintValue( pDescription, pStr );
	g_pBlockSpewer->PrintEventStartMsg( "Validating" );

	if ( V_strlen( pStr ) == 0 )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Empty!" );
		return false;
	}

	if ( bPrintResult )
	{
		g_pBlockSpewer->PrintEventResult( true );
		g_pBlockSpewer->PrintEmptyLine();
	}

	return true;
}

bool CPublishTester::Test_Port( int nPort )
{
	g_pBlockSpewer->PrintValue( "Port", Replay_va( "%i", nPort ) );
	g_pBlockSpewer->PrintEventStartMsg( "Validating" );

	if ( nPort < 0 || nPort > 65535 )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Port must be between 0 and 65535." );
		return false;
	}

	g_pBlockSpewer->PrintEventResult( true );
	g_pBlockSpewer->PrintEmptyLine();

	return true;
}

bool CPublishTester::Test_Path( const char *pDescription, const char *pPath, bool bForwardSlashesAllowed, bool bBackslashesAllowed )
{
	g_pBlockSpewer->PrintValue( pDescription, pPath );
	g_pBlockSpewer->PrintEventStartMsg( "Validating" );
	if ( V_strlen( pPath ) == 0 )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Empty path not allowed." );
		return false;
	}

	if ( !bBackslashesAllowed && V_strstr( pPath, "\\" ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Backslashes not allowed!" );
		return false;
	}

	if ( !bForwardSlashesAllowed && V_strstr( pPath, "/" ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Forward slashes not allowed!" );
		return false;
	}

	if ( V_strstr( pPath, "//" ) || V_strstr( pPath, "\\\\" ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "Double slash detected!" );
		return false;
	}

	if ( V_strstr( pPath, ".." ) )
	{
		g_pBlockSpewer->PrintEventResult( false );
		g_pBlockSpewer->PrintEventError( "\"..\" not allowed!" );
		return false;
	}

	g_pBlockSpewer->PrintEventResult( true );
	g_pBlockSpewer->PrintEmptyLine();

	return true;
}

bool CPublishTester::Test_Protocol( const char *pDescription, const char *pProtocol, const char **pAcceptableProtocols )
{
	g_pBlockSpewer->PrintValue( pDescription, pProtocol );
	g_pBlockSpewer->PrintEventStartMsg( "Validating" );

	// Test to see if the input protocol is acceptable
	bool bProtocolOK = false;
	int i = 0;
	while ( pAcceptableProtocols[ i ] )
	{
		if ( V_strcmp( pAcceptableProtocols[ i++ ], pProtocol ) == 0 )
		{
			bProtocolOK = true;
			break;
		}
	}

	// Protocol allowed?
	if ( !bProtocolOK )
	{
		g_pBlockSpewer->PrintEventResult( false );
		CFmtStr fmtError( "Must be one of the following (case-sensitive): " );
		i = 0;
		while ( pAcceptableProtocols[ i ] )
			fmtError.AppendFormat( "\"%s\" ", pAcceptableProtocols[ i++ ] );
		g_pBlockSpewer->PrintEventError( fmtError.Access() );
		return false;
	}

	g_pBlockSpewer->PrintEventResult( true );
	g_pBlockSpewer->PrintEmptyLine();

	return true;
}


bool CPublishTester::Test_LocalWebServerCVars()
{
	// NOTE: We use the raw cvar here as opposed to CServerReplayContext::GetLocalFileServerPath(),
	// which actually fixes slashes.  If the cvar is using incorrect slashes here for the given OS,
	// this test will fail with a specific error message.
	extern ConVar replay_local_fileserver_path;
	if ( !Test_Path( "Path", replay_local_fileserver_path.GetString(), IsPosix(), IsWindows() ) )
		return false;

	return true;
}

bool CPublishTester::Test_IO( const char *pFilename )
{
	g_pBlockSpewer->PrintTestHeader( "Testing File I/O" );

	// Print out temp directory so the context for this section is clear
	g_pBlockSpewer->PrintValue( "Temp path", SV_GetTmpDir() );
	g_pBlockSpewer->PrintEmptyLine();

	// Open the file
	FileHandle_t hTmpFile = g_pFullFileSystem->Open( pFilename, "wb+" );
	g_pBlockSpewer->PrintEventStartMsg( "Opening temp file" );
	if ( !hTmpFile )
	{
		g_pBlockSpewer->PrintEventResult( false );
		return false;
	}
	g_pBlockSpewer->PrintEventResult( true );

	// Write the file
	g_pBlockSpewer->PrintEventStartMsg( "Allocating test buffer" );	// Lie.
	if ( !m_pGarbageBuffer )
	{
		g_pBlockSpewer->PrintEventResult( false );
		return false;
	}
	g_pBlockSpewer->PrintEventResult( true );

	g_pBlockSpewer->PrintEventStartMsg( "Writing temp file" );
	if ( g_pFullFileSystem->Write( m_pGarbageBuffer, GARBAGE_BUFFER_SIZE, hTmpFile ) != GARBAGE_BUFFER_SIZE )
	{
		g_pBlockSpewer->PrintEventResult( false );
		return false;
	}
	g_pBlockSpewer->PrintEventResult( true );

	// Close the file
	g_pFullFileSystem->Close( hTmpFile );
	
	return true;
}

bool CPublishTester::Test_FilePublish( const char *pFilename, bool bOffload )
{
	g_pBlockSpewer->PrintTestHeader( "Testing file publisher" );
	g_pBlockSpewer->PrintValue( "Fileserver type", "Local Web server" );

	if ( !Test_LocalWebServerCVars() )
		return false;

	m_pJob = SV_CreateLocalPublishJob( pFilename );

	g_pBlockSpewer->PrintEmptyLine();

	// Run publish test
	if ( !m_pJob || !SV_RunJobToCompletion( m_pJob ) )
	{
		g_pBlockSpewer->PrintEventError( m_pJob->GetErrorStr() );
		return false;
	}

	return true;
}

bool CPublishTester::Test_PublishedFileDelete( const char *pFullFilename, const char *pFilename, bool bOffload )
{
	g_pBlockSpewer->PrintTestHeader( "Testing fileserver delete" );

	if ( bOffload )
	{
		// Delete the file from the tmp dir
		g_pFullFileSystem->RemoveFile( pFullFilename );
	}

	m_pCleanerJob = SV_CreateDeleteFileJob();
	IFileserverCleanerJob *pCleanerJobImp = SV_CastJobToIFileserverCleanerJob( m_pCleanerJob );
	pCleanerJobImp->AddFileForDelete( pFilename );
	if ( !m_pCleanerJob || !SV_RunJobToCompletion( m_pCleanerJob ) )
	{
		g_pBlockSpewer->PrintEventError( m_pCleanerJob->GetErrorStr() );
		return false;
	}

	return true;
}

bool CPublishTester::Test_WaitingForPlayersCVar()
{
	ConVarRef mp_waitingforplayers_cancel( "mp_waitingforplayers_cancel" );
	if ( mp_waitingforplayers_cancel.IsValid() && mp_waitingforplayers_cancel.GetBool() )
	{
		g_pBlockSpewer->PrintEventError( "mp_waitingforplayers_cancel must be 0 in order for replay to work!" );
		return false;
	}

	return true;
}

void CPublishTester::PrintBaseUrlWarning()
{
	g_pBlockSpewer->PrintEmptyLine();
	g_pBlockSpewer->PrintMsg( "If clients can't access the following URL via a Web" );
	g_pBlockSpewer->PrintMsg( "browser, they will not be able to download Replays." );
	g_pBlockSpewer->PrintEmptyLine();
	g_pBlockSpewer->PrintValue( "URL", Replay_GetDownloadURL() );
}

bool CPublishTester::Go()
{
	const bool bOffload = false;

	// Force anyone outside of Go() to use the block spewer until we're done.
	CSpewScope SpewScope( g_pBlockSpewer );

	g_pBlockSpewer->PrintMsg( "TESTING REPLAY SYSTEM CONFIGURATION..." );

	// Fileserver convars
	g_pBlockSpewer->PrintTestHeader( "Testing Fileserver ConVars (replay_fileserver_*)" );

	// Test replay_fileserver_protocol
	extern ConVar replay_fileserver_protocol;
	if ( !Test_Protocol( "Protocol", replay_fileserver_protocol.GetString(), g_pAcceptableFileserverProtocols ) )
		return false;

	extern ConVar replay_fileserver_host;
	if ( !Test_Hostname( replay_fileserver_host.GetString(), "\"http\" or \"https\"" ) )
		return false;

	extern ConVar replay_fileserver_port;
	if ( !Test_Port( replay_fileserver_port.GetInt() ) )
		return false;

	extern ConVar replay_fileserver_path;
	if ( !Test_Path( "Path", replay_fileserver_path.GetString(), true, false ) )
		return false;

	// Print out the base URL / warning
	PrintBaseUrlWarning();

	CFmtStr fmtTmpFilename( "testpublish_%i.tmp", (int)abs( rand() % 10000 ) );
	CFmtStr fmtTmpFilenameFullPath( "%s%s", SV_GetTmpDir(), fmtTmpFilename.Access() );
	const char *pFilename = fmtTmpFilenameFullPath.Access();

	// Test file I/O
	if ( !Test_IO( pFilename ) )
		return false;

	// Get out if necessary
	if ( !Test_FilePublish( pFilename, bOffload ) )
		return false;

	// Test delete from fileserver
	if ( !Test_PublishedFileDelete( pFilename, fmtTmpFilename.Access(), bOffload ) )
		return false;

	// Make sure mp_waitingforplayers_cancel isn't on or replay will be fucked.
	if ( !Test_WaitingForPlayersCVar() )
		return false;

	return true;
}

//----------------------------------------------------------------------------------------

bool SV_DoTestPublish()
{
	CPublishTester tester;
	return tester.Go();
}

//----------------------------------------------------------------------------------------