ConfigStatus ParseLaunchRequestVulkanDriverVariant(LaunchGameRequest launchRequest,
IDictionary <string, string> queryParams)
{
ConfigStatus status = ConfigStatus.OkStatus();
if (queryParams.ContainsKey(QueryParamMapping.VulkanDriverVariant))
{
string driverVariant = "GGP_DEV_VK_DRIVER_VARIANT";
if (!launchRequest.EnvironmentVariablePairs.ContainsKey(driverVariant))
{
var allowedValues = new[] { "opt", "optprintasserts", "dbgtrapasserts" };
if (!allowedValues.Contains(queryParams[QueryParamMapping.VulkanDriverVariant]
.ToLower()))
{
status.AppendWarning(ErrorStrings.InvalidEnumValue(
QueryParamMapping.VulkanDriverVariant,
queryParams[QueryParamMapping.VulkanDriverVariant],
allowedValues));
}
else
{
launchRequest.EnvironmentVariablePairs.Add(
driverVariant,
queryParams[QueryParamMapping.VulkanDriverVariant].ToLower());
}
}
}
return(status);
}
ConfigStatus AddBoolEnvironmentVariable(LaunchGameRequest launchRequest,
IDictionary <string, string> queryParams,
string variableName, string queryParamName)
{
if (!queryParams.ContainsKey(queryParamName) ||
launchRequest.EnvironmentVariablePairs.ContainsKey(variableName))
{
return(ConfigStatus.OkStatus());
}
if (!bool.TryParse(queryParams[queryParamName], out bool isTrue))
{
if (!int.TryParse(queryParams[queryParamName], out int intVal) || intVal < 0 ||
intVal > 1)
{
return(ConfigStatus.WarningStatus(ErrorStrings.InvalidQueryParameterType(
queryParamName,
queryParams[queryParamName],
typeof(bool))));
}
isTrue = intVal == 1;
}
if (isTrue)
{
launchRequest.EnvironmentVariablePairs.Add(variableName, "1");
}
return(ConfigStatus.OkStatus());
}
public async Task <bool> SendPlayGame(int gameid)
{
if (IsDebugMode)
{
Logger.Debug($"Sent popper command to start playing game with id {gameid}");
return(true);
}
var request = new LaunchGameRequest();
request.id = gameid;
var response = await _api.MakeRequest <LaunchGameRequest, string>(request).ConfigureAwait(false);
if (response?.Success == true)
{
return(true);
}
else
{
//TODO Error handling???
Logger.Error($"Error launching game {gameid}, responded with {response?.Code} and {response?.Messsage}");
return(false);
}
}
public ConfigStatus ParseToLaunchRequest(
IDictionary <string, string> queryParams, LaunchGameRequest launchRequest)
{
ConfigStatus status = AssignValues(launchRequest, queryParams);
return(status.Merge(ParseLaunchRequestCustomParameters(launchRequest, queryParams)));
}
public void CreateLaunchSdkWarningSetting(ShowOption sdkShowOption, string[] versionsToHide,
bool showSdkWarning)
{
SetupSdkCompatibility(GameletSdkCompatibilityResult.NotCompatibleOutsideOfRange);
var launchRequest = new LaunchGameRequest();
SetupParamsParser(launchRequest, ConfigStatus.OkStatus());
var launchGameResponse = new LaunchGameResponse
{
GameLaunchName = _gameLaunchName, RequestId = launchRequest.RequestId
};
SetupGameLaunchApi(launchRequest, launchGameResponse);
_yetiVsiService.Options.SdkCompatibilityWarningOption.Returns(sdkShowOption);
_yetiVsiService.Options
.SdkVersionsAreHidden(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(false);
foreach (string versions in versionsToHide)
{
string gameletVersion = versions.Split('/')[0];
string localVersion = versions.Split('/')[1];
_yetiVsiService.Options
.SdkVersionsAreHidden(gameletVersion, localVersion, _gameletName).Returns(true);
}
IVsiGameLaunch result = _target.CreateLaunch(_launchParams);
Assert.That(result, Is.Not.Null);
_dialogUtil.DidNotReceiveWithAnyArgs().ShowError(default);
void ParseValueFailure(string paramName, bool launchRequest,
Dictionary <string, Tuple <string, ConfigStatus.ErrorLevel> >
invalidValues)
{
foreach (KeyValuePair <string, Tuple <string, ConfigStatus.ErrorLevel> > valuePair in
invalidValues)
{
string paramValue = valuePair.Key;
string messagePart = valuePair.Value.Item1;
ConfigStatus.ErrorLevel expectedErrorLevel = valuePair.Value.Item2;
var queryParams = new Dictionary <string, string>
{
{ paramName, paramValue }
};
LaunchGameRequest request = ShallowCopy(ValidRequest);
LaunchParams parameters = ShallowCopy(ValidParams);
ConfigStatus status = launchRequest
? _target.ParseToLaunchRequest(queryParams, request)
: _target.ParseToParameters(queryParams, parameters);
// Verify that corresponding message is populated.
Assert.That(status.SeverityLevel, Is.EqualTo(expectedErrorLevel));
Assert.That(status.MessagesByErrorLevel(expectedErrorLevel).Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages[0].Contains(messagePart));
object obj = launchRequest ? (object)request : parameters;
Type type = launchRequest
? typeof(LaunchGameRequest)
: typeof(LaunchParams);
object originObject = launchRequest ? (object)ValidRequest : ValidParams;
// Assert that all properties are unchanged.
AssertObjectPropertiesEqual(type, obj, originObject);
}
}
void CheckValidEnvVars(string paramName, string envVarName,
Dictionary <string, string> validEnvVarsValues)
{
foreach (KeyValuePair <string, string> validEnvVarsValue in validEnvVarsValues)
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
var queryParams = new Dictionary <string, string>
{
{ paramName, validEnvVarsValue.Key }
};
launchRequest.EnvironmentVariablePairs = new Dictionary <string, string>();
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsOk, Is.EqualTo(true));
if (validEnvVarsValue.Value == null)
{
Assert.That(!launchRequest.EnvironmentVariablePairs.Any());
}
else
{
Assert.That(launchRequest.EnvironmentVariablePairs, Is.EqualTo(
new Dictionary <string, string>
{
{ envVarName, validEnvVarsValue.Value }
}));
}
}
}
void CheckInvalidEnvVars(string paramName, string[] invalidEnvVarsValues,
string[] messageParts)
{
foreach (string paramVal in invalidEnvVarsValues)
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
var queryParams = new Dictionary <string, string>
{
{ paramName, paramVal }
};
launchRequest.EnvironmentVariablePairs = new Dictionary <string, string>();
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
foreach (string messagePart in messageParts)
{
Assert.That(
status.AllMessages[0].Contains(string.Format(messagePart, paramVal)));
}
Assert.That(!launchRequest.EnvironmentVariablePairs.Any());
}
}
public void ParseToRequestAllQueryParameters()
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
Dictionary <string, string> queryParams = AllValidQueryParams;
int expectedOutQueryParametersCount = queryParams.Count;
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(queryParams.Count, Is.EqualTo(expectedOutQueryParametersCount));
Assert.That(launchRequest.Parent, Is.EqualTo("Request_parent"));
Assert.That(launchRequest.GameletName, Is.EqualTo("Request_gamelet_name"));
Assert.That(launchRequest.ApplicationName, Is.EqualTo("params_app_name"));
Assert.That(launchRequest.ReleaseName, Is.EqualTo(null));
Assert.That(launchRequest.EnablePipelineCacheSourceUpload, Is.EqualTo(false));
Assert.That(launchRequest.EnableGameRealtimePriority, Is.EqualTo(true));
Assert.That(launchRequest.EnforceProductionRam, Is.EqualTo(false));
Assert.That(launchRequest.ExecutablePath, Is.EqualTo("Request_bin"));
Assert.That(launchRequest.CommandLineArguments,
Is.EqualTo(new[] { "Request_arg1", "--arg456" }));
Assert.That(launchRequest.EnvironmentVariablePairs,
Is.EqualTo(new Dictionary <string, string>
{
{ "Request_VAR1", "Some value" }
}));
Assert.That(launchRequest.SurfaceEnforcementMode,
Is.EqualTo(SurfaceEnforcementSetting.Warn));
Assert.That(launchRequest.Debug, Is.EqualTo(true));
Assert.That(launchRequest.MountUploadedPipelineCache, Is.EqualTo(true));
Assert.That(launchRequest.MountDynamicContent, Is.EqualTo(true));
Assert.That(launchRequest.GameStateName, Is.EqualTo("params_game_state_name"));
Assert.That(launchRequest.DeepLinkParamsIdGameData, Is.EqualTo(23475456543));
Assert.That(launchRequest.PackageName, Is.EqualTo("params_package_name"));
Assert.That(launchRequest.StreamerMinimumBandWidthKbps, Is.EqualTo(23));
Assert.That(launchRequest.StreamerMaximumBandWidthKbps, Is.EqualTo(8764));
Assert.That(launchRequest.StreamerFixedFps, Is.EqualTo(765));
Assert.That(launchRequest.OverrideClientResolution, Is.EqualTo(VideoResolution._720P));
Assert.That(launchRequest.OverrideDynamicRange, Is.EqualTo(DynamicRange.Sdr));
Assert.That(launchRequest.OverrideAudioChannelMode,
Is.EqualTo(ChannelMode.Surround51True));
Assert.That(launchRequest.StreamerFixedResolution, Is.EqualTo(VideoResolution._1440P));
Assert.That(launchRequest.OverrideDisplayPixelDensity, Is.EqualTo(9876));
Assert.That(launchRequest.StartForwardFrameDump, Is.EqualTo(false));
Assert.That(launchRequest.AddInstanceCompatibilityRequirements,
Is.EqualTo(new[] { "r1", "other" }));
Assert.That(launchRequest.RemoveInstanceCompatibilityRequirements,
Is.EqualTo(new[] { "5", "7", " 8" }));
Assert.That(launchRequest.OverridePreferredCodec, Is.EqualTo(Codec.Vp9));
Assert.That(launchRequest.EnableRetroactiveFrameDump, Is.EqualTo(true));
Assert.That(launchRequest.StreamQualityPreset,
Is.EqualTo(StreamQualityPreset.HighVisualQuality));
Assert.That(launchRequest.NetworkModel, Is.EqualTo("test - model"));
}
public ConfigStatus ToLaunchGameRequest(
LaunchParams parameters, out LaunchGameRequest request)
{
ConfigStatus status =
_queryParametersParser.ParametersToDictionary(
parameters.QueryParams, out IDictionary <string, string> parametersDict);
status = status.Merge(
_queryParametersParser.ParseToParameters(parametersDict, parameters));
ISdkConfig sdkConfig = _sdkConfigFactory.LoadGgpSdkConfigOrDefault();
status = status.Merge(
EnvironmentVariables(parameters, out IDictionary <string, string> envVariables));
status = status.Merge(CommandLineArguments(parameters, out string[] cmdArgs));
if ((parameters.Endpoint == StadiaEndpoint.PlayerEndpoint ||
parameters.Endpoint == StadiaEndpoint.AnyEndpoint) &&
!string.IsNullOrEmpty(parameters.TestAccount))
{
status.AppendWarning(
ErrorStrings.TestAccountsNotSupported(parameters.TestAccountGamerName));
parameters.TestAccount = null;
}
request = new LaunchGameRequest
{
Parent = Parent(sdkConfig, parameters),
GameletName = parameters.GameletName,
ApplicationName = parameters.ApplicationName,
ExecutablePath = ExecutablePath(parameters),
CommandLineArguments = cmdArgs,
EnvironmentVariablePairs = envVariables,
SurfaceEnforcementMode = parameters.SurfaceEnforcementMode,
Debug = parameters.Debug,
EnableDeveloperResumeOffer = parameters.Endpoint == StadiaEndpoint.AnyEndpoint
};
status = status.Merge(
_queryParametersParser.ParseToLaunchRequest(parametersDict, request));
status = status.Merge(
_queryParametersParser.GetFinalQueryString(parametersDict, out string queryString));
parameters.QueryParams = queryString;
if ((parameters.Endpoint == StadiaEndpoint.PlayerEndpoint ||
parameters.Endpoint == StadiaEndpoint.AnyEndpoint) &&
!string.IsNullOrEmpty(queryString))
{
status.AppendWarning(ErrorStrings.QueryParamsNotSupported(queryString));
}
return(status);
}
async Task <CreateLaunchResult> CreateLaunchAsync(LaunchParams launchParams,
ICancelable cancelable, IAction action)
{
Task <string> sdkCompatibilityTask = CheckSdkCompatibilityAsync(
launchParams.GameletName, launchParams.SdkVersion, launchParams.GameletSdkVersion,
action);
LaunchGameRequest launchRequest = null;
Task <ConfigStatus> parsingTask =
Task.Run(() => _launchGameParamsConverter.ToLaunchGameRequest(
launchParams, out launchRequest));
cancelable.ThrowIfCancellationRequested();
ConfigStatus parsingState = await parsingTask;
if (parsingState.IsErrorLevel)
{
// Critical error occurred while parsing the configuration.
// Launch can not proceed.
throw new ConfigurationException(parsingState.ErrorMessage);
}
cancelable.ThrowIfCancellationRequested();
string sdkCompatibilityMessage = await sdkCompatibilityTask;
cancelable.ThrowIfCancellationRequested();
var devEvent = new DeveloperLogEvent
{
GameLaunchData = new GameLaunchData {
RequestId = launchRequest.RequestId
}
};
// Updating the event to record the RequestId in case LaunchGameAsync throws exception.
action.UpdateEvent(devEvent);
LaunchGameResponse response =
await _gameletClient.LaunchGameAsync(launchRequest, action);
IVsiGameLaunch vsiLaunch =
_vsiLaunchFactory.Create(response.GameLaunchName,
launchRequest.EnableDeveloperResumeOffer);
devEvent.GameLaunchData.LaunchId = vsiLaunch.LaunchId;
action.UpdateEvent(devEvent);
parsingState.CompressMessages();
return(new CreateLaunchResult(vsiLaunch, parsingState.WarningMessage,
sdkCompatibilityMessage));
}
/// <summary>
/// Sets environment variables from query parameters.
/// Environment variables are prioritized in the following way:
/// <list type="number">
/// <item>
/// <description>
/// Query parameter 'vars' value.
/// </description>
/// </item>
/// <item>
/// <description>
/// 'Stadia Environment Variables' setting.
/// </description>
/// </item>
/// <item>
/// <description>
/// Other VSI settings(Rgp, RenderDoc, ...).
/// </description>
/// </item>
/// <item>
/// <description>
/// Other Query parameters(color_tools, enable_llpc_in_amdvlk, ...).
/// </description>
/// </item>
/// </list>
/// 3d and 4th points don't overlap, so they are actually together on the 3d place.
/// </summary>
/// <param name="launchRequest"></param>
/// <param name="queryParams"></param>
/// <returns></returns>
ConfigStatus ParseLaunchRequestCustomParameters(LaunchGameRequest launchRequest,
IDictionary <string, string> queryParams)
{
ConfigStatus status = AddBoolEnvironmentVariable(
launchRequest, queryParams, "ENABLE_VK_LAYER_VULKAN_COLOR_TOOLS",
QueryParamMapping.ColorTools);
status = status.Merge(
ParseLaunchRequestVulkanDriverVariant(launchRequest, queryParams));
status = status.Merge(AddBoolEnvironmentVariable(
launchRequest, queryParams, "GGP_VK_AMDVLK_USE_LLPC",
QueryParamMapping.EnableLlpcInAmdvlk));
status = status.Merge(AddBoolEnvironmentVariable(
launchRequest, queryParams,
"ENABLE_GOOGLE_PIPELINE_DATA_EXPORT_LAYER",
QueryParamMapping.EnablePipelineCacheSourceLayer));
return(status);
}
public async Task <LaunchGameResponse> LaunchGameAsync(LaunchGameRequest launchRequest)
{
var instance = await GetGameletByNameAsync(launchRequest.GameletName);
instance.State = GameletState.InUse;
var launch = new GgpGrpc.Models.GameLaunch
{
GameLaunchState = GameLaunchState.RunningGame,
GameletName = launchRequest.GameletName,
Name = Guid.NewGuid().ToString()
};
_launchesByInstance.Add(launch.GameletName, launch);
_lastLaunches?.Add(launchRequest);
return(new LaunchGameResponse {
GameLaunchName = launch.Name
});
}
public void CreateLaunchWarningMessages(GameletSdkCompatibilityResult?sdkResult,
string sdkWarning, string[] parserWarnings)
{
SetupSdkCompatibility(sdkResult);
var launchRequest = new LaunchGameRequest();
SetupParamsParser(launchRequest, GetStatus(parserWarnings, false));
var launchGameResponse = new LaunchGameResponse
{
GameLaunchName = _gameLaunchName, RequestId = launchRequest.RequestId
};
SetupGameLaunchApi(launchRequest, launchGameResponse);
SetupSdkWarningSetting();
IVsiGameLaunch result = _target.CreateLaunch(_launchParams);
Assert.That(result, Is.Not.Null);
_dialogUtil.DidNotReceiveWithAnyArgs().ShowError(Arg.Any <string>(), Arg.Any <string>());
if (string.IsNullOrEmpty(sdkWarning))
{
_dialogUtil.DidNotReceive()
.ShowOkNoMoreDisplayWarning(sdkWarning, Arg.Any <string[]>());
}
else
{
_dialogUtil.Received(1).ShowOkNoMoreDisplayWarning(sdkWarning, Arg.Any <string[]>());
}
if (parserWarnings.Any())
{
_dialogUtil.Received(1)
.ShowWarning(Arg.Is <string>(m => parserWarnings.All(m.Contains)));
}
Assert.That(_devEvent.GameLaunchData.RequestId, Is.EqualTo(launchRequest.RequestId));
Assert.That(_devEvent.GameLaunchData.LaunchId, Is.EqualTo(_gameLaunchId));
Assert.That(_devEvent.GameLaunchData.EndReason, Is.Null);
_action.Received(1).Record(Arg.Any <Func <bool> >());
}
void CheckVariablesDontOverride(string paramName, string envVarName,
IEnumerable <string> paramValues)
{
foreach (string paramVal in paramValues)
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
var queryParams = new Dictionary <string, string>
{
{ paramName, paramVal }
};
var envVars = new Dictionary <string, string>
{
{ envVarName, "DefaultValue" }
};
launchRequest.EnvironmentVariablePairs =
envVars.ToDictionary(v => v.Key, v => v.Value);
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(launchRequest.EnvironmentVariablePairs, Is.EqualTo(envVars));
}
}
void ParseValueSuccess <T>(string paramName, bool launchRequest, string propertyName,
Dictionary <string, T> validValues)
{
foreach (KeyValuePair <string, T> valuePair in validValues)
{
var queryParams = new Dictionary <string, string>
{
{ paramName, valuePair.Key }
};
LaunchGameRequest request = ShallowCopy(ValidRequest);
LaunchParams parameters = ShallowCopy(ValidParams);
ConfigStatus status = launchRequest
? _target.ParseToLaunchRequest(queryParams, request)
: _target.ParseToParameters(queryParams, parameters);
// Verify that value is valid.
Assert.That(status.IsOk, Is.EqualTo(true));
object obj = launchRequest ? (object)request : parameters;
Type type = launchRequest ? typeof(LaunchGameRequest)
: typeof(LaunchParams);
PropertyInfo property = type.GetProperty(propertyName);
var value = (T)property.GetValue(obj);
// Corresponding property is populated properly.
Assert.That(value, Is.EqualTo(valuePair.Value));
object originObject = launchRequest ? (object)ValidRequest : ValidParams;
// Assert that all other properties are unchanged.
foreach (PropertyInfo propertyInfo in type
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.GetSetMethod() != null))
{
if (propertyInfo != property)
{
Assert.That(propertyInfo.GetValue(obj),
Is.EqualTo(propertyInfo.GetValue(originObject)));
}
}
}
}
public Task <LaunchGameResponse> LaunchGameAsync(LaunchGameRequest launchRequest,
RpcRecorder recorder) =>
LaunchGameAsync(launchRequest);
