/// <summary>
/// Retrieves the login tokens for all active deployments that the player
/// can connect to via the anonymous authentication flow.
/// </summary>
/// <param name="workerType">The type of the worker that wants to connect.</param>
/// <param name="playerIdentityToken">The player identity token of the player that wants to connect.</param>
/// <returns>A list of all available login tokens and their deployments.</returns>
protected virtual List <LoginTokenDetails> GetDevelopmentLoginTokens(string workerType, string playerIdentityToken)
{
var result = DevelopmentAuthentication.CreateDevelopmentLoginTokensAsync(
RuntimeConfigDefaults.LocatorHost,
RuntimeConfigDefaults.AnonymousAuthenticationPort,
new LoginTokensRequest
{
WorkerType = workerType,
PlayerIdentityToken = playerIdentityToken,
UseInsecureConnection = false,
DurationSeconds = 120,
}
).Get();
if (!result.HasValue)
{
throw new AuthenticationFailedException("Did not receive any login tokens back.");
}
if (result.Value.Status != ConnectionStatusCode.Success)
{
throw new AuthenticationFailedException("Failed to retrieve any login tokens.\n" +
$"error code: {result.Value.Status}\nerror message: {result.Value.Error}");
}
return(result.Value.LoginTokens);
}
/// <summary>
/// Retrieves a development player identity token using development authentication.
/// </summary>
/// <returns>The player identity token string.</returns>
/// <exception cref="AuthenticationFailedException">Failed to get a development player identity token.</exception>
protected virtual string GetDevelopmentPlayerIdentityToken()
{
var result = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync(
LocatorHost,
LocatorPort,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationToken = DevAuthToken,
PlayerId = GetPlayerId(),
DisplayName = GetDisplayName(),
UseInsecureConnection = UseInsecureConnection,
}
).Get();
if (!result.HasValue)
{
throw new AuthenticationFailedException("Did not receive a player identity token.");
}
if (result.Value.Status.Code != ConnectionStatusCode.Success)
{
throw new AuthenticationFailedException("Failed to retrieve a player identity token.\n" +
$"error code: {result.Value.Status.Code}\nerror message: {result.Value.Status.Detail}");
}
return result.Value.PlayerIdentityToken;
}
/// <summary>
/// Retrieves the player identity token needed to generate a login token when using
/// the anonymous authentication flow.
/// </summary>
/// <param name="authToken">The authentication token that you generated.</param>
/// <param name="playerId">The id of the player that wants to connect.</param>
/// <param name="displayName">The display name of the player that wants to connect.</param>
/// <returns>The player identity token.</returns>
protected virtual string GetDevelopmentPlayerIdentityToken(string authToken, string playerId, string displayName)
{
var result = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync(
RuntimeConfigDefaults.LocatorHost,
RuntimeConfigDefaults.AnonymousAuthenticationPort,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationTokenId = authToken,
PlayerId = playerId,
DisplayName = displayName,
}
).Get();
if (!result.HasValue)
{
throw new AuthenticationFailedException("Did not receive a player identity token.");
}
if (result.Value.Status != ConnectionStatusCode.Success)
{
throw new AuthenticationFailedException("Failed to retrieve a player identity token.\n" +
$"error code: {result.Value.Status}\nerror message: {result.Value.Error}");
}
return(result.Value.PlayerIdentityToken);
}
private string GetPlayerIdentityToken(string developmentAuthToken, int retries = 0)
{
var playerIdentityTokenResponse = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync(
LocatorHost,
LocatorPort,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationTokenId = developmentAuthToken,
DisplayName = workerType,
PlayerId = workerType,
UseInsecureConnection = false,
}).Get();
if (playerIdentityTokenResponse.Status == ConnectionStatusCode.Success)
{
return(playerIdentityTokenResponse.PlayerIdentityToken);
}
if (retries < Utils.MaxRetries &&
(playerIdentityTokenResponse.Status == ConnectionStatusCode.Timeout || playerIdentityTokenResponse.Status == ConnectionStatusCode.NetworkError))
{
return(GetPlayerIdentityToken(developmentAuthToken, retries + 1));
}
throw new System.Exception($"Failed to retrieve player identity token: {playerIdentityTokenResponse.Status}\n{playerIdentityTokenResponse.Error}");
}
private static string GetDevelopmentPlayerIdentityToken(string host, ushort port, bool useInsecureConnection, string authToken, string playerId, string displayName)
{
using var pit = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync(
host, port,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationToken = authToken,
PlayerId = playerId,
DisplayName = displayName,
UseInsecureConnection = useInsecureConnection
});
var value = pit.Get();
if (!value.HasValue)
{
throw new AuthenticationException("Error received while retrieving a Player Identity Token: null result");
}
if (value.Value.Status.Code != ConnectionStatusCode.Success)
{
throw new AuthenticationException($"Error received while retrieving a Player Identity Token: {value.Value.Status.Detail}");
}
return(value.Value.PlayerIdentityToken);
}
public override void StartState()
{
pitResponse = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync(
RuntimeConfigDefaults.LocatorHost,
RuntimeConfigDefaults.AnonymousAuthenticationPort,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationToken = Blackboard.DevAuthToken,
PlayerId = Blackboard.PlayerName,
DisplayName = string.Empty,
}
);
}
public override void StartState()
{
loginTokensResponse = DevelopmentAuthentication.CreateDevelopmentLoginTokensAsync(
RuntimeConfigDefaults.LocatorHost,
RuntimeConfigDefaults.AnonymousAuthenticationPort,
new LoginTokensRequest
{
WorkerType = WorkerUtils.UnityClient,
PlayerIdentityToken = Blackboard.PlayerIdentityToken,
UseInsecureConnection = false,
DurationSeconds = 120,
}
);
}
public static string GetDevelopmentPlayerIdentityToken(string devAuthToken, string clientName)
{
var pitResponse = DevelopmentAuthentication.CreateDevelopmentPlayerIdentityTokenAsync("locator.improbable.io", 444,
new PlayerIdentityTokenRequest
{
DevelopmentAuthenticationToken = devAuthToken,
PlayerId = clientName,
DisplayName = clientName
}).Get();
if (pitResponse.Status.Code != ConnectionStatusCode.Success)
{
throw new Exception($"Failed to retrieve player identity token.\n" +
$"error code: {pitResponse.Status.Code}\n" +
$"error message: {pitResponse.Status.Detail}");
}
return(pitResponse.PlayerIdentityToken);
}
public static List <LoginTokenDetails> GetDevelopmentLoginTokens(string workerType, string pit)
{
var loginTokensResponse = DevelopmentAuthentication.CreateDevelopmentLoginTokensAsync(LOCATOR_HOST_NAME, LOCATOR_PORT,
new LoginTokensRequest
{
PlayerIdentityToken = pit,
WorkerType = workerType,
UseInsecureConnection = false,
DurationSeconds = 300
}).Get();
if (loginTokensResponse.Status.Code != ConnectionStatusCode.Success)
{
throw new Exception($"Failed to retrieve any login tokens.\n" +
$"error code: {loginTokensResponse.Status.Code}\n" +
$"error message: {loginTokensResponse.Status.Detail}");
}
return(loginTokensResponse.LoginTokens);
}
private List <LoginTokenDetails> GetLoginTokenDetails(string playerIdentityToken, int retries = 0)
{
var loginTokenDetailsResponse = DevelopmentAuthentication.CreateDevelopmentLoginTokensAsync(
LocatorHost,
LocatorPort,
new LoginTokensRequest
{
PlayerIdentityToken = playerIdentityToken,
UseInsecureConnection = false,
WorkerType = workerType,
}).Get();
if (loginTokenDetailsResponse.Status == ConnectionStatusCode.Success)
{
return(loginTokenDetailsResponse.LoginTokens);
}
else if (retries < Utils.MaxRetries &&
(loginTokenDetailsResponse.Status == ConnectionStatusCode.Timeout || loginTokenDetailsResponse.Status == ConnectionStatusCode.NetworkError))
{
return(GetLoginTokenDetails(playerIdentityToken, retries + 1));
}
throw new System.Exception($"Failed to retrieve player identity token: {loginTokenDetailsResponse.Status}\n{loginTokenDetailsResponse.Error}");
}
private static IEnumerable <LoginTokenDetails> GetDevelopmentLoginTokens(string host, ushort port, bool useInsecureConnection, string workerType, string pit)
{
using var tokens = DevelopmentAuthentication.CreateDevelopmentLoginTokensAsync(host, port,
new LoginTokensRequest
{
PlayerIdentityToken = pit,
WorkerType = workerType,
UseInsecureConnection = useInsecureConnection
});
var value = tokens.Get();
if (!value.HasValue)
{
throw new AuthenticationException("Error received while retrieving Login Tokens: null result");
}
if (value.Value.Status.Code != ConnectionStatusCode.Success)
{
throw new AuthenticationException($"Error received while retrieving Login Tokens: {value.Value.Status.Detail}");
}
return(value.Value.LoginTokens);
}
