public static LegacyGameInfo FromSessionHostHeartbeatInfo(SessionHostHeartbeatInfo heartbeatInfo, string legacyTitleId)
{
LegacyGameInfo result = new LegacyGameInfo();
result.NextBeatMilliseconds = heartbeatInfo.NextHeartbeatIntervalMs.ToString();
result.Operation = heartbeatInfo.Operation;
if (heartbeatInfo.SessionConfig != null)
{
if (heartbeatInfo.SessionConfig.LegacyAllocationInfo != null)
{
result.ClusterManifest = heartbeatInfo.SessionConfig.LegacyAllocationInfo.ClusterManifest;
}
else
{
string sessionIdString = heartbeatInfo.SessionConfig.SessionId.ToString();
result.ClusterManifest["sessionId"] = sessionIdString;
result.ClusterManifest["sessionUrl"] = new Uri(SessionDirectoryBaseUrl, sessionIdString).AbsoluteUri;
result.ClusterManifest["sessionCookie"] = heartbeatInfo.SessionConfig?.SessionCookie;
if (ulong.TryParse(legacyTitleId, out ulong titleIdLong) &&
LegacyTitleHelper.LegacyTitleMappings.TryGetValue(VmConfiguration.GetGuidFromTitleId(titleIdLong), out LegacyTitleDetails titleDetails))
{
result.ClusterManifest["gameVariantId"] = titleDetails.VariantId.ToString();
}
}
}
return(result);
}
public Task <IActionResult> ProcessHeartbeatV1(
string sessionHostId,
[FromBody] SessionHostHeartbeatInfo heartbeatRequest)
{
// To be removed once we update the new GSDK
return(ProcessHeartbeat(sessionHostId, heartbeatRequest));
}
public void TestIsStateSameForDifferentConnectedPlayers()
{
// Make an original heartbeat
SessionHostHeartbeatInfo original = CreateSessionHostHeartbeatInfo();
SessionHostHeartbeatInfo copy = CreateSessionHostHeartbeatInfo();
CopyState(original, copy);
Assert.IsTrue(original.IsStateSame(copy));
copy.CurrentPlayers = original.CurrentPlayers.Concat(GetConnectedPlayers()).ToList();
Assert.IsFalse(original.IsStateSame(copy));
}
public void TestIsStateSameForDifferentServerHealth()
{
SessionHostHeartbeatInfo original = CreateSessionHostHeartbeatInfo();
original.CurrentGameHealth = SessionHostHealth.Unhealthy;
SessionHostHeartbeatInfo copy = CreateSessionHostHeartbeatInfo();
CopyState(original, copy);
Assert.IsTrue(original.IsStateSame(copy));
copy.CurrentGameHealth = SessionHostHealth.Healthy;
Assert.IsFalse(original.IsStateSame(copy));
}
public void TestIsStateSameForDifferentServerState()
{
SessionHostHeartbeatInfo original = CreateSessionHostHeartbeatInfo();
original.CurrentGameState = SessionHostStatus.Active;
SessionHostHeartbeatInfo copy = CreateSessionHostHeartbeatInfo();
CopyState(original, copy);
Assert.IsTrue(original.IsStateSame(copy));
copy.CurrentGameState = SessionHostStatus.Terminating;
Assert.IsFalse(original.IsStateSame(copy));
}
public static void ProcessAgentResponse(SessionHostHeartbeatInfo heartBeat)
{
if (heartBeat.sessionConfig != null && !string.IsNullOrEmpty(heartBeat.sessionConfig.SessionCookie))
{
cookie = _jsonWrapper.DeserializeObject <SessionCookie>(heartBeat.sessionConfig.SessionCookie);
}
if (heartBeat.nextScheduledMaintenanceUtc != null)
{
if (OnMaintenance != null)
{
OnMaintenance.Invoke(heartBeat.nextScheduledMaintenanceUtc);
}
}
switch (heartBeat.operation)
{
case Operation.Continue:
//No Action Required.
break;
case Operation.Active:
//Transition Server State to Active.
CurrentState.currentGameState = SessionHostStatus.Active;
break;
case Operation.Terminate:
//Transition Server to a Termination state.
CurrentState.currentGameState = SessionHostStatus.Terminating;
if (OnShutDown != null)
{
OnShutDown.Invoke();
}
break;
default:
Debug.LogWarning("Unknown operation received" + heartBeat.operation);
break;
}
if (IsDebugging)
{
Debug.LogFormat("Operation: {0}, Maintenance:{1}, State: {2}", heartBeat.operation, heartBeat.nextScheduledMaintenanceUtc.ToString(), heartBeat.currentGameState);
}
}
public async Task <IActionResult> ProcessHeartbeat(string sessionHostId,
[FromBody] SessionHostHeartbeatInfo heartbeatRequest)
{
await Task.Delay(1);
SessionHostStatus currentGameState = heartbeatRequest.CurrentGameState;
Operation op = Operation.Continue;
SessionConfig config = null;
Console.WriteLine($"CurrentGameState: {heartbeatRequest.CurrentGameState}");
if (currentGameState == SessionHostStatus.Terminated || currentGameState == SessionHostStatus.Terminating)
{
HeartBeatsCount.TryRemove(sessionHostId, out _);
}
else if (HeartBeatsCount.TryGetValue(sessionHostId, out int numHeartBeats))
{
if (numHeartBeats >= Globals.Settings.NumHeartBeatsForTerminateResponse)
{
op = Operation.Terminate;
}
else if (numHeartBeats >= Globals.Settings.NumHeartBeatsForActivateResponse && currentGameState == SessionHostStatus.StandingBy)
{
op = Operation.Active;
config = Globals.SessionConfig;
}
HeartBeatsCount[sessionHostId]++;
}
else
{
HeartBeatsCount.TryAdd(sessionHostId, 1);
}
return(Ok(new SessionHostHeartbeatInfo
{
CurrentGameState = currentGameState,
NextHeartbeatIntervalMs = DefaultHeartbeatIntervalMs,
Operation = op,
SessionConfig = config
}));
}
public (bool sessionHostExists, SessionHostHeartbeatInfo response) TryProcessHeartbeat(string sessionHostId, SessionHostHeartbeatInfo heartbeatRequest)
{
return(false, heartbeatRequest);
}
private void CopyState(SessionHostHeartbeatInfo original, SessionHostHeartbeatInfo copy)
{
copy.CurrentGameState = original.CurrentGameState;
copy.CurrentPlayers = original.CurrentPlayers;
copy.CurrentGameHealth = original.CurrentGameHealth;
}
