bool PromptToDeleteLaunch(GgpGrpc.Models.GameLaunch currentGameLaunch, List <Gamelet> gamelets, Gamelet selectedGamelet, ActionRecorder actionRecorder, string testAccount, string devAccount) { if (currentGameLaunch.GameLaunchState == GameLaunchState.IncompleteLaunch) { return(true); } bool thisInstance = selectedGamelet.Name == currentGameLaunch.GameletName; string instanceName = gamelets .SingleOrDefault(g => g.Name == currentGameLaunch.GameletName)?.DisplayName; bool okToStop = actionRecorder.RecordUserAction(ActionType.GameLaunchStopPrompt, () => _dialogUtil.ShowYesNo( ErrorStrings.LaunchExistsDialogText( thisInstance, instanceName, testAccount, devAccount), ErrorStrings.StopRunningGame)); if (!okToStop) { // Developer opted to not stop the existing launch. // Launch can not proceed. return(false); } return(true); }
// TODO: remove once the backend bug is fixed. /// <summary> /// Verifies that the current launch is in RunningGame state, otherwise aborts the attach /// process by throwing AttachException. /// </summary> void VerifyGameIsReady(IAction action) { // Either new launch api is disabled, or we didn't run the game and only have process // id to attach to. We don't match the game launch to the remote process id. if (_gameLaunch != null) { GgpGrpc.Models.GameLaunch state = _taskContext.Factory.Run(async() => await _gameLaunch.GetLaunchStateAsync(action)); if (state.GameLaunchState != GameLaunchState.RunningGame) { var devEvent = new DeveloperLogEvent { GameLaunchData = new GameLaunchData { LaunchId = _gameLaunch.LaunchId } }; string error = ErrorStrings.GameNotRunningDuringAttach; if (state.GameLaunchEnded != null) { devEvent.GameLaunchData.EndReason = (int)state.GameLaunchEnded.EndReason; error = LaunchUtils.GetEndReason(state.GameLaunchEnded, state.GameletName); } action.UpdateEvent(devEvent); throw new GameLaunchAttachException(VSConstants.E_FAIL, error); } } }
public void LaunchGameAbortsWhenLaunchEndedWhilePollingForPid() { var runningGame = new GgpGrpc.Models.GameLaunch { GameLaunchState = GameLaunchState.RunningGame }; var endedGame = new GgpGrpc.Models.GameLaunch { GameLaunchState = GameLaunchState.GameLaunchEnded, GameLaunchEnded = new GameLaunchEnded(EndReason.GameBinaryNotFound) }; _gameLaunch.GetLaunchStateAsync(Arg.Any <IAction>()) .Returns(Task.FromResult(runningGame), Task.FromResult(endedGame)); var launcherFactory = CreateLauncherFactory(true); var launcher = launcherFactory.Create(_debugEngine, LaunchOption.LaunchGame, "", _gameBinary, _gameBinary, _gameLaunch); _platformFactory.AddRunStatuses(false, false); Assert.ThrowsAsync <GameLaunchAttachException>(async() => await LaunchAsync(launcher), _binaryNotFound); CheckLldbListenerStops(); }
public Task <GgpGrpc.Models.GameLaunch> GetGameLaunchStateAsync(string gameLaunchName) { GgpGrpc.Models.GameLaunch launch = null; if (gameLaunchName.EndsWith("current")) { Gamelet instanceInUse = _instances.Find(i => i.State == GameletState.InUse); if (instanceInUse != null) { launch = _launchesByInstance[instanceInUse.Name]; } } else { launch = _launchesByInstance.Values.ToList().Find(l => l.Name == gameLaunchName); } if (launch == null) { var rpcException = new RpcException(new Status(StatusCode.NotFound, "no launch with the specified name found")); throw new CloudException("error getting launch status", rpcException); } return(Task.FromResult(launch)); }
public async Task GetLaunchStateAsyncTestAsync() { _target = GetGameLaunch(false); var action = Substitute.For <IAction>(); var gameLaunch = GetGameLaunch(); _gameletClient.GetGameLaunchStateAsync(_launchName, action) .Returns(Task.FromResult(gameLaunch)); GgpGrpc.Models.GameLaunch result = await _target.GetLaunchStateAsync(action); Assert.That(result, Is.EqualTo(gameLaunch)); }
public async Task GetCurrentGameLaunchSuccessAsync() { _paramsConverter.FullGameLaunchName(null, _testAccount).Returns(_fullLaunchName); GgpGrpc.Models.GameLaunch launch = GetLaunch(_gameLaunchName, GameLaunchState.ReadyToPlay); _gameletClient.GetGameLaunchStateAsync(_fullLaunchName, _action).Returns(launch); GgpGrpc.Models.GameLaunch resultLaunch = await _target.GetCurrentGameLaunchAsync(_testAccount, _action); Assert.That(resultLaunch, Is.EqualTo(launch)); await AssertActionNotRecordedAsync(); }
void SetupDeleteGameLaunch(string gameletName, GameLaunchState?deletedLaunchState, bool success) { GgpGrpc.Models.GameLaunch gameLaunch = deletedLaunchState.HasValue ? new GgpGrpc.Models.GameLaunch { GameLaunchState = deletedLaunchState.Value, GameletName = gameletName, Name = _launchName } : null; _gameLaunchBeHelper .DeleteLaunchAsync(_launchName, Arg.Any <ICancelable>(), Arg.Any <IAction>()).Returns( new DeleteLaunchResult(gameLaunch, success)); }
public async Task DeleteLaunchCanceledAsync() { _gameletClient.DeleteGameLaunchAsync(_gameLaunchName, _action).Returns( GetLaunch(_gameLaunchName, GameLaunchState.RunningGame)); GgpGrpc.Models.GameLaunch lastLaunch = GetLaunch(_gameLaunchName, GameLaunchState.GameLaunchEnded, EndReason.GameExitedWithSuccessfulCode); _gameletClient.GetGameLaunchStateAsync(_gameLaunchName, _action).Returns( GetLaunch(_gameLaunchName, GameLaunchState.RunningGame), GetLaunch(_gameLaunchName, GameLaunchState.RunningGame), lastLaunch); _cancelable.When(c => c.ThrowIfCancellationRequested()) .Do(callInfo => throw new TaskAbortedException(new Exception())); Assert.ThrowsAsync <TaskAbortedException>( () => _target.DeleteLaunchAsync(_gameLaunchName, _cancelable, _action)); await AssertActionNotRecordedAsync(); }
public async Task DeleteLaunchSuccessAsync() { _gameletClient.DeleteGameLaunchAsync(_gameLaunchName, _action).Returns( GetLaunch(_gameLaunchName, GameLaunchState.RunningGame)); GgpGrpc.Models.GameLaunch lastLaunch = GetLaunch(_gameLaunchName, GameLaunchState.GameLaunchEnded, EndReason.GameExitedWithSuccessfulCode); _gameletClient.GetGameLaunchStateAsync(_gameLaunchName, _action).Returns( GetLaunch(_gameLaunchName, GameLaunchState.RunningGame), GetLaunch(_gameLaunchName, GameLaunchState.RunningGame), lastLaunch); DeleteLaunchResult result = await _target.DeleteLaunchAsync(_gameLaunchName, _cancelable, _action); Assert.That(result.IsSuccessful, Is.EqualTo(true)); Assert.That(result.DeletedLaunch, Is.EqualTo(lastLaunch)); await AssertActionNotRecordedAsync(); }
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 async Task LaunchGamePollsForPidWhenGameIsRunningAsync() { var launch = new GgpGrpc.Models.GameLaunch { GameLaunchState = GameLaunchState.RunningGame }; _gameLaunch.GetLaunchStateAsync(Arg.Any <IAction>()).Returns(Task.FromResult(launch)); var launcherFactory = CreateLauncherFactory(true); var launcher = launcherFactory.Create(_debugEngine, LaunchOption.LaunchGame, "", _gameBinary, _gameBinary, _gameLaunch); _platformFactory.AddRunStatuses(false, false, true); var program = await LaunchAsync(launcher); Assert.That(program, Is.Not.Null); program.Stop(); }
// Polling statuses until we see RunningGame or GameLaunchEnded. IncompleteLaunch, // ReadyToPlay and DelayedLaunch are transitioning states. async Task PollForLaunchStatusAsync(ICancelable task, IAction action) { int maxPollCount = (_isDeveloperResumeOfferEnabled ? _pollingTimeoutResumeOfferMs : _pollingTimeoutMs) / _pollDelayMs; int currentPollCount = 0; var devEvent = new DeveloperLogEvent { GameLaunchData = new GameLaunchData { LaunchId = LaunchId } }; action.UpdateEvent(devEvent); while (++currentPollCount <= maxPollCount) { task.ThrowIfCancellationRequested(); GgpGrpc.Models.GameLaunch launch = await GetLaunchStateAsync(action); if (launch.GameLaunchState == GameLaunchState.RunningGame) { return; } if (launch.GameLaunchState == GameLaunchState.GameLaunchEnded) { string error = LaunchUtils.GetEndReason(launch.GameLaunchEnded, launch.GameletName); devEvent.GameLaunchData.EndReason = (int)launch.GameLaunchEnded.EndReason; action.UpdateEvent(devEvent); throw new GameLaunchFailError(error); } await Task.Delay(_pollDelayMs); } if (currentPollCount > maxPollCount) { throw new TimeoutException(ErrorStrings.LaunchEndedTimeout); } }
public async Task <DeleteLaunchResult> WaitUntilGameLaunchEndedAsync( string gameLaunchName, ICancelable task, IAction action) { GgpGrpc.Models.GameLaunch launch = await _gameletClient.GetGameLaunchStateAsync(gameLaunchName, action); int maxPollCount = _pollingTimeoutMs / _pollDelayMs; int currentPollCount = 0; while (launch.GameLaunchState != GameLaunchState.GameLaunchEnded && ++currentPollCount <= maxPollCount) { task.ThrowIfCancellationRequested(); await Task.Delay(_pollDelayMs); launch = await _gameletClient.GetGameLaunchStateAsync(gameLaunchName, action); } return(new DeleteLaunchResult( launch, launch.GameLaunchState == GameLaunchState.GameLaunchEnded)); }
bool StopGameLaunchIfPresent(TestAccount testAccount, string devAccount, List <Gamelet> gamelets, Gamelet selectedGamelet) { IAction getExistingAction = _actionRecorder.CreateToolAction(ActionType.GameLaunchGetExisting); ICancelableTask <GgpGrpc.Models.GameLaunch> currentGameLaunchTask = _cancelableTaskFactory.Create(TaskMessages.LookingForTheCurrentLaunch, async task => await _gameLaunchBeHelper .GetCurrentGameLaunchAsync( testAccount?.Name, getExistingAction)); if (!currentGameLaunchTask.RunAndRecord(getExistingAction)) { return(false); } GgpGrpc.Models.GameLaunch currentGameLaunch = currentGameLaunchTask.Result; if (currentGameLaunch == null) { return(true); } if (!PromptToDeleteLaunch(currentGameLaunch, gamelets, selectedGamelet, _actionRecorder, testAccount?.GamerStadiaName, devAccount)) { return(false); } IAction deleteAction = _actionRecorder.CreateToolAction(ActionType.GameLaunchDeleteExisting); ICancelableTask <DeleteLaunchResult> stopTask = _cancelableTaskFactory.Create( TaskMessages.WaitingForGameStop, async task => await _gameLaunchBeHelper.DeleteLaunchAsync( currentGameLaunch.Name, task, deleteAction)); return(stopTask.RunAndRecord(deleteAction) && stopTask.Result.IsSuccessful); }