DOOM-3-BFG

sys_lobby_migrate.cpp (18032B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 #pragma hdrstop
 #include "../idlib/precompiled.h"
 #include "sys_lobby.h"
 
 idCVar net_migration_debug( "net_migration_debug", "0", CVAR_BOOL, "debug" ); 
 idCVar net_migration_disable( "net_migration_disable", "0", CVAR_BOOL, "debug" ); 
 idCVar net_migration_forcePeerAsHost( "net_migration_forcePeerAsHost", "-1", CVAR_INTEGER, "When set to >-1, it forces that peer number to be the new host during migration" );
 
 
 /*
 ========================
 idLobby::IsBetterHost
 ========================
 */
 bool idLobby::IsBetterHost( int ping1, lobbyUserID_t userId1, int ping2, lobbyUserID_t userId2 ) {
 	if ( lobbyType == TYPE_PARTY ) {
 		return userId1 < userId2;			// Only use user id for party, since ping doesn't matter
 	}
 
 	if ( ping1 < ping2 ) {
 		// Better ping wins
 		return true;
 	} else if ( ping1 == ping2 && userId1 < userId2 ) {
 		// User id is tie breaker
 		return true;
 	}
 
 	return false;
 }
 
 /*
 ========================
 idLobby::FindMigrationInviteIndex
 ========================
 */
 int idLobby::FindMigrationInviteIndex( lobbyAddress_t & address ) {
 	if ( migrationInfo.state == MIGRATE_NONE ) {
 		return -1;
 	}
 
 	for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
 		if ( migrationInfo.invites[i].address.Compare( address, true ) ) {
 			return i;
 		}
 	}
 
 	return -1;
 }
 
 /*
 ========================
 idLobby::UpdateHostMigration
 ========================
 */
 void idLobby::UpdateHostMigration() {
 	
 	int time = Sys_Milliseconds();
 
 	// If we are picking a new host, then update that
 	if ( migrationInfo.state == MIGRATE_PICKING_HOST ) {
 		const int MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS = 20;		// FIXME: set back to 5 // Give other hosts 5 seconds
 
 		if ( time - migrationInfo.migrationStartTime > session->GetTitleStorageInt( "MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS", MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS ) * 1000 ) {
 			// Just become the host if we haven't heard from a host in awhile
 			BecomeHost();
 		} else {
 			return;
 		}
 	}
 
 	// See if we are a new migrated host that needs to invite the original members back
 	if ( migrationInfo.state != MIGRATE_BECOMING_HOST ) {
 		return;
 	}
 
 	if ( lobbyBackend == NULL || lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		return;
 	}
 
 	if ( state != STATE_IDLE ) {
 		return;
 	}
 
 	if ( !IsHost() ) {
 		return;
 	}
 
 	const int MIGRATION_TIMEOUT_IN_SECONDS		= 30; // FIXME: setting to 30 for dev purposes. 10 seems more reasonable. Need to make unloading game / loading lobby async
 	const int MIGRATION_INVITE_TIME_IN_SECONDS	= 2;
 
 	if ( migrationInfo.invites.Num() == 0 || time - migrationInfo.migrationStartTime > session->GetTitleStorageInt( "MIGRATION_TIMEOUT_IN_SECONDS", MIGRATION_TIMEOUT_IN_SECONDS ) * 1000 ) {
 		// Either everyone acked, or we timed out, just keep who we have, and stop sending invites
 		EndMigration();
 		return;
 	}
 
 	// Send invites to anyone who hasn't responded
 	for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
 		if ( time - migrationInfo.invites[i].lastInviteTime < session->GetTitleStorageInt( "MIGRATION_INVITE_TIME_IN_SECONDS", MIGRATION_INVITE_TIME_IN_SECONDS ) * 1000 ) {
 			continue;		// Not enough time passed
 		}
 
 		// Mark the time
 		migrationInfo.invites[i].lastInviteTime = time;
 
 		byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 		idBitMsg outmsg( buffer, sizeof( buffer ) );
 
 		// Have lobbyBackend fill out msg with connection info
 		lobbyConnectInfo_t connectInfo = lobbyBackend->GetConnectInfo();
 		connectInfo.WriteToMsg( outmsg );
 
 		// Let them know whether or not this was from in game
 		outmsg.WriteBool( migrationInfo.persistUntilGameEndsData.wasMigratedGame );
 
 		NET_VERBOSE_PRINT( "NET: Sending migration invite to %s\n", migrationInfo.invites[i].address.ToString() );
 		
 		// Send the migration invite
 		SendConnectionLess( migrationInfo.invites[i].address, OOB_MIGRATE_INVITE, outmsg.GetReadData(), outmsg.GetSize() ); 
 	}
 }
 
 /*
 ========================
 idLobby::BuildMigrationInviteList
 ========================
 */
 void idLobby::BuildMigrationInviteList( bool inviteOldHost ) {
 	migrationInfo.invites.Clear();
 
 	// Build a list of addresses we will send invites to (gather all unique remote addresses from the session user list)
 	for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
 		lobbyUser_t * user = GetLobbyUser( i );
 
 		if ( !verify( user != NULL ) ) {
 			continue;
 		}
 
 		if ( user->IsDisconnected() ) {
 			continue;
 		}
 
 		if ( IsSessionUserIndexLocal( i ) ) {
 			migrationInfo.ourPingMs = user->pingMs;
 			migrationInfo.ourUserId = user->lobbyUserID;
 			migrationInfo.persistUntilGameEndsData.ourGameData = user->migrationGameData;
 			NET_VERBOSE_PRINT( "^2NET: Migration game data for local user is index %d \n", user->migrationGameData );
 
 			continue;		// Only interested in remote users
 		}
 
 		if ( !inviteOldHost && user->peerIndex == -1 ) {
 			continue;		// Don't invite old host if told not to do so
 		}
 
 		if ( FindMigrationInviteIndex( user->address ) == -1 ) {
 			migrationInvite_t invite;
 			invite.address			= user->address;
 			invite.pingMs			= user->pingMs;
 			invite.userId			= user->lobbyUserID;
 			invite.migrationGameData = user->migrationGameData;
 			invite.lastInviteTime	= 0;
 
 			NET_VERBOSE_PRINT( "^2NET: Migration game data for user %s is index %d \n", user->gamertag, user->migrationGameData );
 
 			migrationInfo.invites.Append( invite );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::PickNewHost
 ========================
 */
 void idLobby::PickNewHost( bool forceMe, bool inviteOldHost ) {
 	if ( IsHost() ) {
 		idLib::Printf( "PickNewHost: Already host of session %s\n", GetLobbyName() );
 		return;
 	}
 
 	sessionCB->PrePickNewHost( *this, forceMe, inviteOldHost );
 }
 
 /*
 ========================
 idLobby::PickNewHostInternal
 ========================
 */
 void idLobby::PickNewHostInternal( bool forceMe, bool inviteOldHost ) {
 
 	if ( migrationInfo.state == MIGRATE_PICKING_HOST ) {
 		return;		// Already picking new host
 	}
 
 	idLib::Printf( "PickNewHost: Started picking new host %s.\n", GetLobbyName() );
 
 	if ( IsHost() ) {
 		idLib::Printf( "PickNewHost: Already host of session %s\n", GetLobbyName() );
 		return;
 	}
 
 	// Find the user with the lowest ping
 	int bestUserIndex			= -1;
 	int bestPingMs				= 0;
 	lobbyUserID_t bestUserId;
 
 	for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
 		lobbyUser_t * user = GetLobbyUser( i );
 
 		if ( !verify( user != NULL ) ) {
 			continue;
 		}
 
 		if ( user->IsDisconnected() ) {
 			continue;
 		}
 
 		if ( user->peerIndex == -1 ) {
 			continue;		// Don't try and pick old host
 		}
 
 		if ( bestUserIndex == -1 || IsBetterHost( user->pingMs, user->lobbyUserID, bestPingMs, bestUserId ) ) {
 			bestUserIndex	= i;
 			bestPingMs		= user->pingMs;
 			bestUserId		= user->lobbyUserID;
 		}
 
 		if ( user->peerIndex == net_migration_forcePeerAsHost.GetInteger() ) {
 			bestUserIndex	= i;
 			bestPingMs		= user->pingMs;
 			bestUserId		= user->lobbyUserID;
 			break;
 		}
 	}
 
 	// Remember when we first started picking a new host
 	migrationInfo.state						= MIGRATE_PICKING_HOST;
 	migrationInfo.migrationStartTime		= Sys_Milliseconds();	
 
 	migrationInfo.persistUntilGameEndsData.wasMigratedGame = sessionCB->GetState() == idSession::INGAME;
 
 	if ( bestUserIndex == -1 ) {	// This can happen if we call PickNewHost on an lobby that was Shutdown
 		NET_VERBOSE_PRINT( "MIGRATION: PickNewHost was called on an lobby that was Shutdown\n" );
 		BecomeHost();
 		return;
 	}
 
 	NET_VERBOSE_PRINT( "MIGRATION: Chose user index %d (%s) for new host\n", bestUserIndex, GetLobbyUser( bestUserIndex )->gamertag );
 
 	bool bestWasLocal = IsSessionUserIndexLocal( bestUserIndex );		// Check before shutting down the lobby
 	migrateMsgFlags = parms.matchFlags;						// Save off match parms 
 
 	// Build invite list
 	BuildMigrationInviteList( inviteOldHost );
 
 	// If the best user is on this machine, then we become the host now, otherwise, wait for a new host to contact us
 	if ( forceMe || bestWasLocal ) {
 		BecomeHost();
 	}
 }
 
 /*
 ========================
 idLobby::BecomeHost
 ========================
 */
 void idLobby::BecomeHost() {
 
 	if ( !verify( migrationInfo.state == MIGRATE_PICKING_HOST ) ) {
 		idLib::Printf( "BecomeHost: Must be called from PickNewHost.\n" );
 		EndMigration();
 		return;
 	}
 
 	if ( IsHost() ) {
 		idLib::Printf( "BecomeHost: Already host of session.\n" );
 		EndMigration();
 		return;
 	}
 
 	if ( !sessionCB->BecomingHost( *this ) ) {
 		EndMigration();
 		return;
 	}
 
 	idLib::Printf( "BecomeHost: Sending %i invites on %s.\n", migrationInfo.invites.Num(), GetLobbyName() );
 
 	migrationInfo.state					= MIGRATE_BECOMING_HOST;
 	migrationInfo.migrationStartTime	= Sys_Milliseconds();
 
 	if ( lobbyBackend == NULL ) {
 		// If we don't have a lobbyBackend, then just create one
 		Shutdown();
 		StartCreating();
 		return;
 	}
 
 	// Shutdown the current lobby, but keep the lobbyBackend (we'll migrate it)
 	Shutdown( true );
 
 	// Migrate the lobbyBackend to host
 	lobbyBackend->BecomeHost( migrationInfo.invites.Num() );
 
 	// Wait for it to complete
 	SetState( STATE_CREATE_LOBBY_BACKEND );
 }
 
 /*
 ========================
 idLobby::EndMigration
 This gets called when we are done migrating, and invites will no longer be sent out.
 ========================
 */
 void idLobby::EndMigration() {
 	if ( migrationInfo.state == MIGRATE_NONE ) {
 		idLib::Printf( "idSessionLocal::EndMigration: Not migrating.\n" );
 		return;
 	}
 
 	sessionCB->MigrationEnded( *this );
 	
 	if ( lobbyBackend != NULL ) {
 		lobbyBackend->FinishBecomeHost();
 	}
 
 	migrationInfo.state = MIGRATE_NONE;
 	migrationInfo.invites.Clear();
 }
 
 /*
 ========================
 idLobby::ResetAllMigrationState
 This will reset all state related to host migration. Should be called
 at match end so our next game is not treated as a migrated game
 ========================
 */
 void idLobby::ResetAllMigrationState() {
 	migrationInfo.state = MIGRATE_NONE;
 	migrationInfo.invites.Clear();
 	migrationInfo.persistUntilGameEndsData.Clear();
 
 	migrateMsgFlags		= 0;
 
 	common->Dialog().ClearDialog( GDM_MIGRATING );
 	common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
 	common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
 }
 
 /*
 ========================
 idLobby::GetMigrationGameData
 This will setup the passed in idBitMsg to either read or write from the global migration game data buffer
 ========================
 */
 bool idLobby::GetMigrationGameData( idBitMsg &msg, bool reading ) {
 	if ( reading ) {
 		if ( !IsMigratedStatsGame() || !migrationInfo.persistUntilGameEndsData.wasMigratedHost ) {
 			// This was not a migrated session, we have no migration data
 			return false;
 		}
 		msg.InitRead( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
 	} else {
 		migrationInfo.persistUntilGameEndsData.hasGameData = true;
 		memset( migrationInfo.persistUntilGameEndsData.gameData, 0, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
 		msg.InitWrite( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
 	}
 
 	return true;
 }
 
 /*
 ========================
 idLobby::GetMigrationGameDataUser
 This will setup the passed in idBitMsg to either read or write from the user's migration game data buffer
 ========================
 */
 bool idLobby::GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg & msg, bool reading ) {
 	const int userNum = GetLobbyUserIndexByID( lobbyUserID );
 
 	if ( !verify( userNum >=0 && userNum < MAX_PLAYERS ) ) {
 		return false;
 	}
 
 	lobbyUser_t * u = GetLobbyUser( userNum );
 	if ( u != NULL ) {
 		if ( reading ) {
 
 			if ( !IsMigratedStatsGame() || !migrationInfo.persistUntilGameEndsData.wasMigratedHost ) {
 				// This was not a migrated session, we have no migration data
 				return false;
 			}
 
 			if ( u->migrationGameData >= 0 && u->migrationGameData < MAX_PLAYERS ) {
 				msg.InitRead( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ 0 ] ) );
 			} else {
 				// We don't have migration data for this user
 				idLib::Warning( "No migration data for user %d in a migrated game (%d)", userNum, u->migrationGameData );
 				return false;
 			}
 		} else {
 			// Writing
 			migrationInfo.persistUntilGameEndsData.hasGameData = true;
 			u->migrationGameData = userNum;
 			memset( migrationInfo.persistUntilGameEndsData.gameDataUser[ userNum ], 0, sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[0] ) );
 			msg.InitWrite( migrationInfo.persistUntilGameEndsData.gameDataUser[ userNum ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[0] ) );
 			
 		}
 		return true;
 	}
 	return false;
 }
 
 /*
 ========================
 idLobby::HandleMigrationGameData
 ========================
 */
 void idLobby::HandleMigrationGameData( idBitMsg & msg ) {
 	// Receives game migration data from the server. Just save off the raw data. If we ever become host we'll let the game code read
 	// that chunk in (we can't do anything with it now anyways: we don't have entities or any server code to read it in to)
 	migrationInfo.persistUntilGameEndsData.hasGameData = true;
 
 	// Reset each user's migration game data. If we don't receive new data for them in this msg, we don't want to use the old data
 	for ( int i=0; i < GetNumLobbyUsers(); i++ ) {
 		lobbyUser_t * u = GetLobbyUser( i );
 		if ( u != NULL ) {
 			u->migrationGameData = -1;
 		}
 	}
 	
 	msg.ReadData( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
 	int numUsers = msg.ReadByte();
 	int dataIndex=0;
 	for ( int i=0; i < numUsers; i++ ) {
 		lobbyUserID_t lobbyUserID;
 		lobbyUserID.ReadFromMsg( msg );
 		lobbyUser_t * user = GetLobbyUser( GetLobbyUserIndexByID( lobbyUserID ) );
 		if ( user != NULL ) {
 
 			NET_VERBOSE_PRINT( "NET:    Got migration data[%d] for user %s\n", dataIndex, user->gamertag );
 
 			user->migrationGameData = dataIndex;
 			msg.ReadData( migrationInfo.persistUntilGameEndsData.gameDataUser[ dataIndex ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ dataIndex ] ) );
 			dataIndex++;			
 		}
 	}
 }
 
 /*
 ========================
 idLobby::SendMigrationGameData
 ========================
 */
 void idLobby::SendMigrationGameData() {
 	if ( net_migration_disable.GetBool() ) {
 		return;
 	}
 
 	if ( sessionCB->GetState() != idSession::INGAME ) {
 		return;
 	}
 
 	if ( !migrationInfo.persistUntilGameEndsData.hasGameData ) {
 		// Haven't been given any migration game data yet
 		return;
 	}
 
 	const int now = Sys_Milliseconds();
 	if ( nextSendMigrationGameTime > now ) {
 		return;
 	}
 
 	byte	packetData[ idPacketProcessor::MAX_MSG_SIZE ];
 	idBitMsg msg( packetData, sizeof(packetData) );
 
 	// Write global data
 	msg.WriteData( &migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
 	msg.WriteByte( GetNumLobbyUsers() );
 
 	// Write user data
 	for ( int userIndex = 0; userIndex < GetNumLobbyUsers(); ++userIndex ) {
 		lobbyUser_t * u = GetLobbyUser( userIndex );
 		if ( u->IsDisconnected() || u->migrationGameData < 0 ) {
 			continue;
 		}
 
 		u->lobbyUserID.WriteToMsg( msg );
 		msg.WriteData( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ] ) );
 	}
 
 	// Send to 1 peer
 	for ( int i=0; i < peers.Num(); i++ ) {
 		int peerToSend = ( nextSendMigrationGamePeer + i ) % peers.Num();
 
 		if ( peers[ peerToSend ].IsConnected() && peers[ peerToSend ].loaded ) {
 			if ( peers[ peerToSend ].packetProc->NumQueuedReliables() > idPacketProcessor::MAX_RELIABLE_QUEUE / 2 ) {
 				// This is kind of a hack for development so we don't DC clients by sending them too many reliable migration messages
 				// when they aren't responding. Doesn't seem like a horrible thing to have in a shipping product but is not necessary.
 				NET_VERBOSE_PRINT("NET: Skipping reliable game migration data msg because client reliable queue is > half full\n");
 
 			} else {
 				if ( net_migration_debug.GetBool() ) {
 					idLib::Printf( "NET: Sending migration game data to peer %d. size: %d\n", peerToSend, msg.GetSize() );
 				}
 				QueueReliableMessage( peerToSend, RELIABLE_MIGRATION_GAME_DATA, msg.GetReadData(), msg.GetSize() );
 			}
 			break;
 		}
 	}
 	
 	// Increment next send time / next send peer
 	nextSendMigrationGamePeer++;
 	if ( nextSendMigrationGamePeer >= peers.Num() ) {
 		nextSendMigrationGamePeer = 0;
 	}
 
 	nextSendMigrationGameTime = now + MIGRATION_GAME_DATA_INTERVAL_MS;
 }