public void ToLaunchGameRequestEnvironmentVariablesInvalid()
{
LaunchParams parameters = ValidParams;
parameters.GameletEnvironmentVars = " =asd ;=;v=a ;v=;2V==;v= ==bb ; ; ";
parameters.Rgp = false;
parameters.RenderDoc = false;
parameters.VulkanDriverVariant = string.Empty;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(4));
Assert.That(status.AllMessages.Count, Is.EqualTo(4));
Assert.That(
status.WarningMessages.Count(
m => m.Contains("Invalid format of environment variable")), Is.EqualTo(2));
Assert.That(status.WarningMessages.Count(m => m.Contains("is set multiple times.")),
Is.EqualTo(1));
Assert.That(status.WarningMessages.Count(m => m.Contains("edit the setting")),
Is.EqualTo(1));
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "v", " ==bb" },
{ "2V", "=" }
}));
}
protected override void _Start()
{
if (LaunchParams.Contains("connect"))
{
DevConsole.ExecuteLine($"net.connect {LaunchParams.CommandLine.Arguments["connect"][0]}");
}
}
public void ToLaunchGameRequestEnvironmentVariablesOverride()
{
LaunchParams parameters = ValidParams;
parameters.RenderDoc = false;
parameters.VulkanDriverVariant = "test_variant";
parameters.Rgp = true;
parameters.GameletEnvironmentVars =
"GGP_DEV_VK_DRIVER_VARIANT=otherVariant;RGP_DEBUG_LOG_FILE=my/path.log";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(3));
Assert.That(status.AllMessages.Count, Is.EqualTo(3));
Assert.That(status.WarningMessages[0].Contains("overrides the setting variable"));
Assert.That(status.WarningMessages[1].Contains("overrides the setting variable"));
Assert.That(status.WarningMessages[2].Contains("edit the setting"));
Assert.IsNotNull(request);
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "GGP_DEV_VK_DRIVER_VARIANT", "otherVariant" },
{ "GGP_INTERNAL_LOAD_RGP", "1" },
{ "RGP_DEBUG_LOG_FILE", "my/path.log" },
{ "LD_PRELOAD", "librgpserver.so" },
}));
}
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);
}
}
ConfigStatus ParseParamsCustomParameters(LaunchParams parameters,
IDictionary <string, string> queryParams)
{
ConfigStatus status = ParseParamsCmd(parameters, queryParams);
return(status.Merge(ParseParamsVars(parameters, queryParams)));
}
ConfigStatus ParseParamsCmd(LaunchParams parameters,
IDictionary <string, string> queryParams)
{
if (!queryParams.ContainsKey(QueryParamMapping.Cmd))
{
return(ConfigStatus.OkStatus());
}
string queryParamsCmd = queryParams[QueryParamMapping.Cmd];
if (string.IsNullOrWhiteSpace(parameters.Cmd))
{
parameters.Cmd = queryParamsCmd;
return(ConfigStatus.OkStatus());
}
// The cmd is valid only if the binary name is the same as in
// the project output.
string settingsBinaryName =
parameters.Cmd.Split(' ').First(s => !string.IsNullOrEmpty(s));
string queryBinaryName =
queryParamsCmd.Split(' ').FirstOrDefault(s => !string.IsNullOrEmpty(s));
if (queryBinaryName != settingsBinaryName)
{
return(ConfigStatus.ErrorStatus(
ErrorStrings.InvalidBinaryName(settingsBinaryName, queryBinaryName)));
}
parameters.Cmd = queryParamsCmd;
return(ConfigStatus.OkStatus());
}
public void ParseToParametersAllQueryParameters()
{
LaunchParams parameters = ShallowCopy(ValidParams);
Dictionary <string, string> queryParams = AllValidQueryParams;
int expectedOutQueryParametersCount = queryParams.Count;
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(queryParams.Count, Is.EqualTo(expectedOutQueryParametersCount));
Assert.That(parameters.Account, Is.EqualTo("some_account"));
Assert.That(parameters.ApplicationName, Is.EqualTo("test/app"));
Assert.That(parameters.Cmd, Is.EqualTo(" some_bin arg2"));
Assert.That(parameters.Debug, Is.EqualTo(true));
Assert.That(parameters.GameletEnvironmentVars,
Is.EqualTo("Var1=1;vAR2=3;ParamsVar=val"));
Assert.That(parameters.GameletName, Is.EqualTo("test/gamelet"));
Assert.That(parameters.PoolId, Is.EqualTo("test_pool"));
Assert.That(parameters.RenderDoc, Is.EqualTo(false));
Assert.That(parameters.Rgp, Is.EqualTo(true));
Assert.That(parameters.SdkVersion, Is.EqualTo("1"));
Assert.That(parameters.VulkanDriverVariant, Is.EqualTo("test_variant"));
Assert.That(parameters.SurfaceEnforcementMode,
Is.EqualTo(SurfaceEnforcementSetting.Warn));
Assert.That(parameters.TestAccount,
Is.EqualTo("organizations/organization_id/" +
"projects/project_id/testAccounts/gamer#1234"));
Assert.That(parameters.QueryParams, Is.EqualTo(""));
}
public ConfigStatus ParseToParameters(IDictionary <string, string> queryParams,
LaunchParams parameters)
{
ConfigStatus status = AssignValues(parameters, queryParams);
return(status.Merge(ParseParamsCustomParameters(parameters, queryParams)));
}
public bool Verify(string query)
{
var parsed = !string.IsNullOrEmpty(query)
? LaunchParams.Parse(query).ParsedQuery
: null;
return(parsed != null && Verify(parsed));
}
protected override void _Initialize()
{
if (LaunchParams.Contains("logconsole"))
{
_writeLog = true;
DevConsole.OnMessageLogged += FSConsole_OnMessageLogged;
}
}
public void ToLaunchGameRequestValidParams()
{
LaunchParams parameters = ValidParams;
parameters.GameletEnvironmentVars =
" Var1=test_V=a==l; vaR2=47 ; var3 = ; var1 =";
parameters.RenderDoc = false;
parameters.Rgp = false;
parameters.VulkanDriverVariant = string.Empty;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.Parent, Is.EqualTo(parameters.TestAccount));
Assert.That(request.GameletName, Is.EqualTo(parameters.GameletName));
Assert.That(request.ApplicationName, Is.EqualTo(parameters.ApplicationName));
Assert.That(request.ExecutablePath, Is.EqualTo("some_bin"));
Assert.That(request.CommandLineArguments, Is.EqualTo(new [] { "arg1" }));
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "Var1", "test_V=a==l" },
{ "vaR2", "47" },
{ "var3 ", string.Empty },
{ "var1 ", string.Empty }
}));
Assert.That(request.SurfaceEnforcementMode,
Is.EqualTo(parameters.SurfaceEnforcementMode));
Assert.That(request.Debug, Is.EqualTo(parameters.Debug));
// Assert another parameters values are default.
Assert.That(request.EnablePipelineCacheSourceUpload, Is.EqualTo(null));
Assert.That(request.EnableRetroactiveFrameDump, Is.EqualTo(null));
Assert.That(request.StreamQualityPreset, Is.EqualTo(StreamQualityPreset.Undefined));
Assert.That(request.AddInstanceCompatibilityRequirements.Length, Is.EqualTo(0));
Assert.That(request.RemoveInstanceCompatibilityRequirements.Length, Is.EqualTo(0));
Assert.That(request.DeepLinkParamsIdGameData, Is.EqualTo(null));
Assert.That(request.EnableGameRealtimePriority, Is.EqualTo(null));
Assert.That(request.EnforceProductionRam, Is.EqualTo(null));
Assert.That(request.GameStateName, Is.EqualTo(null));
Assert.That(request.ReleaseName, Is.EqualTo(null));
Assert.That(request.MountDynamicContent, Is.EqualTo(null));
Assert.That(request.MountUploadedPipelineCache, Is.EqualTo(null));
Assert.That(request.OverrideAudioChannelMode, Is.EqualTo(ChannelMode.Unspecified));
Assert.That(request.OverrideClientResolution, Is.EqualTo(VideoResolution.Unspecified));
Assert.That(request.OverrideDisplayPixelDensity, Is.EqualTo(null));
Assert.That(request.OverrideDynamicRange, Is.EqualTo(DynamicRange.Unspecified));
Assert.That(request.OverridePreferredCodec, Is.EqualTo(Codec.Unspecified));
Assert.That(request.PackageName, Is.EqualTo(null));
Assert.That(request.StartForwardFrameDump, Is.EqualTo(null));
Assert.That(request.StreamerFixedFps, Is.EqualTo(null));
Assert.That(request.StreamerFixedResolution, Is.EqualTo(VideoResolution.Unspecified));
Assert.That(request.StreamerMaximumBandWidthKbps, Is.EqualTo(null));
Assert.That(request.StreamerMinimumBandWidthKbps, Is.EqualTo(null));
Assert.That(request.EnableDeveloperResumeOffer, Is.EqualTo(false));
}
string ExecutablePath(LaunchParams parameters)
{
if (string.IsNullOrWhiteSpace(parameters.Cmd))
{
return(string.Empty);
}
string executableName = parameters.Cmd.Split(' ').First(s => !string.IsNullOrEmpty(s));
return(executableName);
}
ConfigStatus ParseParamsVars(LaunchParams parameters,
IDictionary <string, string> queryParams)
{
if (queryParams.ContainsKey(QueryParamMapping.Vars))
{
// The last occurrence of the an environment variable wins.
parameters.GameletEnvironmentVars = parameters.GameletEnvironmentVars + ";" +
queryParams[QueryParamMapping.Vars];
}
return(ConfigStatus.OkStatus());
}
public void Setup()
{
_gameletClient = Substitute.For <IGameletClient>();
_cancelableTaskFactory = Substitute.For <CancelableTask.Factory>();
_gameLaunchBeHelper = Substitute.For <IGameLaunchBeHelper>();
_metrics = Substitute.For <IMetrics>();
_actionRecorder = Substitute.For <ActionRecorder>(_metrics);
_dialogUtil = Substitute.For <IDialogUtil>();
_launcher = Substitute.For <IChromeClientsLauncher>();
_params = new LaunchParams();
_launcher.LaunchParams.Returns(_params);
}
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);
}
public IVsiGameLaunch CreateLaunch(LaunchParams launchParams)
{
IAction action = _actionRecorder.CreateToolAction(ActionType.GameLaunchCreate);
CreateLaunchResult launchRes = null;
ICancelableTask launchTask = _cancelableTaskFactory.Create(
TaskMessages.LaunchingGame,
async task => { launchRes = await CreateLaunchAsync(launchParams, task, action); });
try
{
if (!launchTask.RunAndRecord(action))
{
Trace.WriteLine("Launching a game has been canceled by user.");
return(null);
}
}
catch (ConfigurationException e)
{
_dialogUtil.ShowError(e.Message);
return(null);
}
catch (CloudException e)
{
string message = $"{ErrorStrings.CouldNotStartTheGame}{Environment.NewLine}" +
$"{e.Message}{Environment.NewLine}{Environment.NewLine}{ErrorStrings.SeeLogs}";
_dialogUtil.ShowError(message);
return(null);
}
if (!string.IsNullOrWhiteSpace(launchRes.WarningMessage))
{
_dialogUtil.ShowWarning(launchRes.WarningMessage);
}
if (!string.IsNullOrWhiteSpace(launchRes.SdkCompatibilityMessage))
{
bool showAgain = _dialogUtil.ShowOkNoMoreDisplayWarning(
launchRes.SdkCompatibilityMessage, new[]
{
"Tools", "Options", "Stadia SDK", "Game launch",
"SDK incompatibility warning"
});
if (!showAgain)
{
_vsiService.Options.AddSdkVersionsToHide(launchParams.GameletSdkVersion,
launchParams.SdkVersion,
launchParams.GameletName);
}
}
return(launchRes.GameLaunch);
}
public void ToLaunchGameRequestParentNoTestAccount()
{
LaunchParams parameters = ValidParams;
parameters.TestAccount = " ";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.Parent, Is.EqualTo("organizations/-/players/me"));
}
ConfigStatus CommandLineArguments(LaunchParams parameters,
out string[] args)
{
args = new string[0];
if (string.IsNullOrWhiteSpace(parameters.Cmd))
{
return(ConfigStatus.OkStatus());
}
args = parameters.Cmd.Trim().Split(' ').Where(s => !string.IsNullOrEmpty(s)).Skip(1)
.ToArray();
return(ConfigStatus.OkStatus());
}
public void ToLaunchGameRequestCommandArgumentsValid(string cmd, string[] expectedOutput)
{
LaunchParams parameters = ValidParams;
parameters.Cmd = cmd;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.CommandLineArguments, Is.EqualTo(expectedOutput));
}
static void Main(string[] args)
{
if (args.Length != 0)
{
LaunchParams.Load(args);
Application.Run(new InventorViewerForm());
}
else
{
LaunchParams.Defaults();
Application.Run(new StandaloneViewerForm());
}
}
public void ParseParamsCmdSuccess(string cmdValue)
{
LaunchParams parameters = ShallowCopy(ValidParams);
var queryParams = new Dictionary <string, string>
{
{ "cmd", cmdValue }
};
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(parameters.Cmd, Is.EqualTo(cmdValue));
}
private static LaunchParams ParseOptions(string[] args)
{
var p = new LaunchParams();
foreach (string arg in args)
{
if (arg == "/settings" || arg == "--settings" || arg == "-s")
{
p.LaunchMode = LaunchMode.Settings;
}
}
return(p);
}
public void ToLaunchGameRequestEmptyExecutable()
{
LaunchParams parameters = ValidParams;
parameters.Cmd = " ";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.ExecutablePath, Is.EqualTo(string.Empty));
Assert.That(request.CommandLineArguments.Length, Is.EqualTo(0));
}
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));
}
public void SetUp()
{
_backgroundProcessFactory = Substitute.For <BackgroundProcess.Factory>();
_launchParams = new LaunchParams();
_sdkConfig = new SdkConfig();
var sdkConfigFactory = Substitute.For <SdkConfig.Factory>();
sdkConfigFactory.LoadOrDefault().Returns(c => _sdkConfig);
var chromeLauncher = new ChromeLauncher(_backgroundProcessFactory);
_chromeClientsLauncher =
new ChromeClientsLauncher(sdkConfigFactory, _launchParams, chromeLauncher);
_logSpy = new LogSpy();
_logSpy.Attach();
}
public void ParseParamsVars(string varsValue)
{
LaunchParams parameters = ShallowCopy(ValidParams);
string previousVars = parameters.GameletEnvironmentVars;
var queryParams = new Dictionary <string, string>
{
{ "vars", varsValue }
};
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(parameters.GameletEnvironmentVars.Contains(previousVars));
Assert.That(parameters.GameletEnvironmentVars.Contains(varsValue));
}
public void ToLaunchGameRequestNotSupportedTestAccounts(StadiaEndpoint endpoint)
{
LaunchParams parameters = ValidParams;
parameters.Endpoint = endpoint;
parameters.TestAccount = "a/b/c";
parameters.TestAccountGamerName = "gamer#1234";
ConfigStatus status =
_parametersConverter.ToLaunchGameRequest(parameters, out LaunchGameRequest _);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessage,
Does.Contain("Test accounts are not supported by any player endpoint"));
Assert.That(status.WarningMessage, Does.Contain("gamer#1234"));
}
public void ToLaunchGameRequestNotSupportedQueryParams(StadiaEndpoint endpoint)
{
LaunchParams parameters = ValidParams;
parameters.Endpoint = endpoint;
parameters.QueryParams = "a=42&vars=valid=1";
ConfigStatus status =
_parametersConverter.ToLaunchGameRequest(parameters, out LaunchGameRequest _);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessage,
Does.Contain("are not supported by any player endpoint"));
Assert.That(status.WarningMessage, Does.Contain("a=42"));
Assert.That(status.WarningMessage, Does.Not.Contain("vars=valid=1"));
}
public void ParseParamsCmdFail(string cmdValue)
{
LaunchParams parameters = ShallowCopy(ValidParams);
var queryParams = new Dictionary <string, string>
{
{ "cmd", cmdValue }
};
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsErrorLevel, Is.EqualTo(true));
Assert.That(status.ErrorMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
Assert.That(status.ErrorMessages[0].Contains("invalid binary name"));
Assert.That(status.ErrorMessages[0].Contains("Expected: 'some_bin'"));
Assert.That(parameters.Cmd, Is.EqualTo("some_bin arg1"));
}
ConfigStatus AddFlagsEnvironmentVariables(
LaunchParams parameters, IDictionary <string, string> variables)
{
ConfigStatus status = ConfigStatus.OkStatus();
var flagEnvironmentVariables = new Dictionary <string, string>();
if (!string.IsNullOrWhiteSpace(parameters.VulkanDriverVariant))
{
flagEnvironmentVariables.Add("GGP_DEV_VK_DRIVER_VARIANT",
parameters.VulkanDriverVariant);
}
if (parameters.RenderDoc)
{
flagEnvironmentVariables.Add("ENABLE_VULKAN_RENDERDOC_CAPTURE", "1");
flagEnvironmentVariables.Add("RENDERDOC_TEMP", "/mnt/developer/ggp");
flagEnvironmentVariables.Add("RENDERDOC_DEBUG_LOG_FILE", "/var/game/RDDebug.log");
}
if (parameters.Rgp)
{
flagEnvironmentVariables.Add("GGP_INTERNAL_LOAD_RGP", "1");
flagEnvironmentVariables.Add("RGP_DEBUG_LOG_FILE", "/var/game/RGPDebug.log");
}
foreach (string key in flagEnvironmentVariables.Keys)
{
if (variables.ContainsKey(key))
{
status.AppendWarning(ErrorStrings.EnvironmentVariableOverride(key));
continue;
}
variables.Add(key, flagEnvironmentVariables[key]);
}
if (parameters.Rgp)
{
if (!variables.ContainsKey("LD_PRELOAD"))
{
variables.Add("LD_PRELOAD", string.Empty);
}
variables["LD_PRELOAD"] += (string.IsNullOrEmpty(variables["LD_PRELOAD"])
? string.Empty
: ":") + "librgpserver.so";
}
return(status);
}
