private async Task CollectResult(ProcessExecutionResult runResult) { if (!_waitedForExit && !runResult.TimedOut) { // mlaunch couldn't wait for exit for some reason. Let's assume the app exits when the test listener completes. _mainLog.WriteLine("Waiting for listener to complete, since mlaunch won't tell."); if (!await _listener.CompletionTask.TimeoutAfter(_timeout - _timeoutWatch.Elapsed)) { runResult.TimedOut = true; } } if (runResult.TimedOut) { _timedout = true; Success = false; _mainLog.WriteLine(TimeoutMessage, _timeout.TotalMinutes); } else if (runResult.Succeeded) { _mainLog.WriteLine(CompletionMessage); Success = true; } else { _mainLog.WriteLine(FailureMessage); Success = false; } }
public static ProcessExecutionResult ExecuteProcess(string workingDirectory, string filepath, string arguments) { ProcessExecutionResult result = new ProcessExecutionResult(); Process process = new Process(); process.StartInfo.FileName = filepath; process.StartInfo.Arguments = arguments; process.StartInfo.WorkingDirectory = workingDirectory; process.StartInfo.RedirectStandardError = true; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.UseShellExecute = false; StringBuilder testLogOut = new StringBuilder(); StringBuilder testLogErr = new StringBuilder(); ProcessListener listen = new ProcessListener(process); listen.StdOutNewLineReady += ((obj) => testLogOut.AppendLine("stdout:" + obj)); // Log StdOut listen.StdErrNewLineReady += ((obj) => testLogErr.AppendLine("stderror:" + obj)); // Log StdError process.Start(); listen.Begin(); process.WaitForExit(); result.StandardError = testLogErr.ToString(); result.StandardOutput = testLogOut.ToString(); listen.Dispose(); process.Dispose(); return(result); }
public ProcessExecutionResult Execute(string fileName, string inputData, int timeLimit, int memoryLimit) { var process = new DifferentUserProcessExecutor(fileName, Environment.UserDomainName, UserName, Password); process.SetTextToWrite(inputData); var executorInfo = process.Start(timeLimit, memoryLimit); var result = new ProcessExecutionResult { ReceivedOutput = executorInfo.StandardOutputContent, ErrorOutput = executorInfo.StandardErrorContent, ExitCode = process.Process.ExitCode, Type = ProcessExecutionResultType.Success, TimeWorked = process.Process.ExitTime - process.Process.StartTime, MemoryUsed = executorInfo.MaxMemoryUsed, PrivilegedProcessorTime = process.Process.PrivilegedProcessorTime, UserProcessorTime = process.Process.UserProcessorTime, }; if (executorInfo.ProcessKilledBecauseOfTimeLimit) { result.Type = ProcessExecutionResultType.TimeLimit; } if (!string.IsNullOrEmpty(executorInfo.StandardErrorContent)) { result.Type = ProcessExecutionResultType.RunTimeError; } return(result); }
public IProcessResponse <ImageConfig> Process(ProcessExecutionResult response) { if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "Empty response", new ImageConfig()); return(this); } if (response.ExitCode != 0) { Response = response.ToErrorResponse(new ImageConfig()); return(this); } var arr = response.StdOutAsArry; var sb = new StringBuilder(); for (var i = 1; i < arr.Length - 1; i++) { sb.AppendLine(arr[i]); } var container = sb.ToString(); Response = response.ToResponse(true, string.Empty, JsonConvert.DeserializeObject <ImageConfig>(container)); return(this); }
public static ProcessExecutionResult ExecuteProcess(string workingDirectory, string filepath, string arguments) { ProcessExecutionResult result = new ProcessExecutionResult(); Process process = new Process(); process.StartInfo.FileName = filepath; process.StartInfo.Arguments = arguments; process.StartInfo.WorkingDirectory = workingDirectory; process.StartInfo.RedirectStandardError = true; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.UseShellExecute = false; StringBuilder testLogOut = new StringBuilder(); StringBuilder testLogErr = new StringBuilder(); ProcessListener listen = new ProcessListener(process); listen.StdOutNewLineReady += ((obj) => testLogOut.AppendLine("stdout:" + obj)); // Log StdOut listen.StdErrNewLineReady += ((obj) => testLogErr.AppendLine("stderror:" + obj)); // Log StdError process.Start(); listen.Begin(); process.WaitForExit(); result.StandardError = testLogErr.ToString(); result.StandardOutput = testLogOut.ToString(); listen.Dispose(); process.Dispose(); return result; }
public IProcessResponse <Container> Process(ProcessExecutionResult response) { if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "Empty response", new Container()); return(this); } if (response.ExitCode != 0) { Response = response.ToErrorResponse(new Container()); return(this); } var arr = response.StdOutAsArry; var sb = new StringBuilder(); for (var i = 1; i < arr.Length - 1; i++) { sb.AppendLine(arr[i]); } var container = sb.ToString(); var obj = JsonConvert.DeserializeObject <Container>(container); obj.Name = TrimIfBeginsWithSlash(obj.Name); Response = response.ToResponse(true, string.Empty, obj); return(this); }
public IProcessResponse <string> Process(ProcessExecutionResult response) { Response = response.ExitCode != 0 ? response.ToErrorResponse(string.Empty) : response.ToResponse(true, string.Empty, string.Empty); return(this); }
private static void DisplayError(Exception ex, ProcessExecutionResult status) { IVsOutputWindowPane outputPane = Package.GetGlobalService(typeof(SVsGeneralOutputWindowPane)) as IVsOutputWindowPane; outputPane.Activate(); if (status == ProcessExecutionResult.AuthDenied) { outputPane.OutputString("Visual Studio restart operation was cancelled by the user." + Environment.NewLine); } else { StringBuilder sb = new StringBuilder(); sb.AppendLine("An exceptions has been trown while trying to start an elevated Visual Studio, see details below."); sb.AppendLine(ex.ToString()); string diagnostics = sb.ToString(); outputPane.OutputString(diagnostics); IVsActivityLog log = Package.GetGlobalService(typeof(SVsActivityLog)) as IVsActivityLog; log.LogEntry((uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR, "MidnightDevelopers.VsRestarter", diagnostics); } //EnvDTE.OutputWindow.OutputWindow.Parent.Activate(); }
private void ProcessTests( ProcessExecutionResult processExecutionResult, ExecutionContext executionContext, ExecutionResult result) { var jsonResult = JsonExecutionResult.Parse(processExecutionResult.ReceivedOutput, true, true); var index = 0; result.TestResults = new List <TestResult>(); foreach (var test in executionContext.Tests) { var testResult = new TestResult { Id = test.Id, TimeUsed = (int)processExecutionResult.TimeWorked.TotalMilliseconds, MemoryUsed = (int)processExecutionResult.MemoryUsed, }; if (jsonResult.PassingTestsIndexes.Contains(index)) { testResult.ResultType = TestRunResultType.CorrectAnswer; } else { testResult.ResultType = TestRunResultType.WrongAnswer; testResult.CheckerDetails = new CheckerDetails { Comment = "Test failed." }; } result.TestResults.Add(testResult); index++; } }
public IProcessResponse <IDictionary <string, string> > Process(ProcessExecutionResult response) { var dict = new Dictionary <string, string>(); if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "No data", (IDictionary <string, string>)dict); return(this); } var lines = response.StdOutAsArry; foreach (var line in lines) { if (line.StartsWith("export") || line.StartsWith("SET ")) { var idx = line.StartsWith("SET ") ? 4 : 8; var nv = line.Substring(idx, line.Length - idx).Split('='); var key = nv[0].Trim(); var value = nv[1].Trim(); dict.Add(key, 4 == idx ? value : value.Substring(1, value.Length - 2)); } } Response = response.ToResponse(true, string.Empty, (IDictionary <string, string>)dict); return(this); }
protected TestResult GetTestResult( ProcessExecutionResult processExecutionResult, TestContext test, IChecker checker) { var message = "Failing tests are not captured correctly. Please contact an Administrator."; var errorMatch = ErrorsInTestsRegex.Match(processExecutionResult.ReceivedOutput); var failedTestMatch = FailedTestsRegex.Match(processExecutionResult.ReceivedOutput); if (errorMatch.Success) { processExecutionResult.ErrorOutput = errorMatch.Groups[1].Value; processExecutionResult.Type = ProcessExecutionResultType.RunTimeError; } else if (failedTestMatch.Success) { message = failedTestMatch.Groups[1].Value; } else if (SuccessTestsRegex.IsMatch(processExecutionResult.ReceivedOutput)) { message = TestPassedMessage; } var testResult = this.CheckAndGetTestResult( test, processExecutionResult, checker, message); return(testResult); }
public IProcessResponse <IList <DockerImageRowResponse> > Process(ProcessExecutionResult response) { if (response.ExitCode != 0) { Response = response.ToErrorResponse((IList <DockerImageRowResponse>) new List <DockerImageRowResponse>()); return(this); } var list = new List <DockerImageRowResponse>(); foreach (var row in response.StdOutAsArry) { var items = row.Split(';'); if (items.Length != 3) { continue; } list.Add(new DockerImageRowResponse { Id = items[0].ToPlainId(), Name = items[1], Tags = new[] { items[2] } }); } Response = response.ToResponse(true, string.Empty, (IList <DockerImageRowResponse>)list); return(this); }
public IProcessResponse <IList <StackPsResponse> > Process(ProcessExecutionResult response) { var list = new List <StackPsResponse>(); var rows = response.StdOutAsArry; if (rows.Length > 0) { list.AddRange(from row in rows select row.Split(';') into s where s.Length == 3 select new StackPsResponse { Id = s[0], Stack = s[1].Split('_')[0], Name = s[1].Split('_')[1], Image = s[2].Split(':')[0], ImageVersion = s[2].Split(':')[1], Node = s[3], DesiredState = s[4], CurrentState = s[5], Error = s[6] ?? string.Empty, Ports = s[7] ?? string.Empty }); } Response = response.ToResponse(true, string.Empty, (IList <StackPsResponse>)list); return(this); }
public IProcessResponse <MachineConfiguration> Process(ProcessExecutionResult response) { if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "No response", new MachineConfiguration { AuthConfig = new MachineAuthConfig() }); return(this); } var j = JObject.Parse(response.StdOut); var str = j["HostOptions"]["AuthOptions"].ToString(); var ip = j["Driver"]["IPAddress"].Value <string>(); var authConfig = JsonConvert.DeserializeObject <MachineAuthConfig>(str); var config = new MachineConfiguration { AuthConfig = authConfig, IpAddress = string.IsNullOrEmpty(ip) ? IPAddress.None : IPAddress.Parse(ip), DriverName = j["DriverName"].Value <string>(), MemorySizeMb = j["Driver"]["Memory"].Value <int>(), Name = j["Name"].Value <string>(), RequireTls = j["HostOptions"]["EngineOptions"]["TlsVerify"].Value <bool>(), StorageSizeMb = j["Driver"]["DiskSize"].Value <int>(), CpuCount = j["Driver"]["CPU"].Value <int>(), StorePath = j["Driver"]["StorePath"].Value <string>() }; Response = response.ToResponse(true, string.Empty, config); return(this); }
protected TaskInfo StartMemorySamplingThread( IDisposable process, ProcessExecutionResult result) { var peakWorkingSetSize = default(long); var memorySamplingRunInBackgroundInfo = this.TasksService.RunWithInterval( MemoryIntervalBetweenTwoMemoryConsumptionRequests, () => { switch (process) { case RestrictedProcess restrictedProcess: { peakWorkingSetSize = restrictedProcess.PeakWorkingSetSize; break; } case System.Diagnostics.Process systemProcess: { if (systemProcess.HasExited) { return; } peakWorkingSetSize = systemProcess.PeakWorkingSet64; break; } } result.MemoryUsed = Math.Max(result.MemoryUsed, peakWorkingSetSize); }); return(memorySamplingRunInBackgroundInfo); }
private SetupResult ProcessDeviceErrorCode(ProcessExecutionResult status) { if (IsHealthyAndRunning(status)) { return(SetupResult.Success); } if (IsDriverUpdateRequired(status)) { _tapInstallRunner.Update(); return(SetupResult.Success); } if (IsDriverReinstallationRequired(status) && IsPcRestartRequired(status)) { _logger.Log("TapAdapterInstaller: Driver is reinstalling and requesting restart."); _tapInstallRunner.Reinstall(); return(SetupResult.RestartRequired); } if (IsDriverReinstallationRequired(status)) { _logger.Log("TapAdapterInstaller: Driver is reinstalling."); _tapInstallRunner.Reinstall(); return(SetupResult.Success); } _logger.Log($"TapAdapterInstaller: Installation failed. Status: {status}"); return(SetupResult.Failure); }
protected override IExecutionResult <TestResult> ExecuteAgainstTestsInput( IExecutionContext <TestsInputModel> executionContext) { var result = new ExecutionResult <TestResult> { IsCompiledSuccessfully = true }; var processExecutionResult = new ProcessExecutionResult { Type = ProcessExecutionResultType.Success, ReceivedOutput = executionContext.Code }; var checker = executionContext.Input.GetChecker(); foreach (var test in executionContext.Input.Tests) { var testResult = this.ExecuteAndCheckTest( test, processExecutionResult, checker, processExecutionResult.ReceivedOutput); result.Results.Add(testResult); } return(result); }
private static void UpdateExecutionTime(string timeMeasurementFilePath, ProcessExecutionResult processExecutionResult, int timeLimit) { if (File.Exists(timeMeasurementFilePath)) { long timeInNanoseconds; var timeMeasurementFileContent = File.ReadAllText(timeMeasurementFilePath); if (long.TryParse(timeMeasurementFileContent, out timeInNanoseconds)) { processExecutionResult.TimeWorked = TimeSpan.FromMilliseconds((double)timeInNanoseconds / 1000000); if (processExecutionResult.Type == ProcessExecutionResultType.TimeLimit && processExecutionResult.TimeWorked.TotalMilliseconds <= timeLimit) { // The time from the time measurement file is under the time limit processExecutionResult.Type = ProcessExecutionResultType.Success; } else if (processExecutionResult.Type == ProcessExecutionResultType.Success && processExecutionResult.TimeWorked.TotalMilliseconds > timeLimit) { processExecutionResult.Type = ProcessExecutionResultType.TimeLimit; } } File.Delete(timeMeasurementFilePath); } }
public IProcessResponse <string> Process(ProcessExecutionResult response) { var success = response.ExitCode == 0; Response = response.ToResponse(success, response.StdErr, $"ExitCode={response.ExitCode}"); return(this); }
public IProcessResponse <IList <NetworkRow> > Process(ProcessExecutionResult response) { if (response.ExitCode != 0) { Response = response.ToErrorResponse((IList <NetworkRow>) new List <NetworkRow>()); return(this); } if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "No response", (IList <NetworkRow>) new List <NetworkRow>()); return(this); } var result = new List <NetworkRow>(); foreach (var row in response.StdOutAsArry) { var items = row.Split(';'); if (items.Length < 4) { continue; } var created = DateTime.MinValue; var ipv6 = false; var intern = false; if (items.Length > 4) { bool.TryParse(items[4], out ipv6); } if (items.Length > 5) { bool.TryParse(items[5], out intern); } if (items.Length > 6) { var split = items[6].Split(" ".ToCharArray()); var normalizedStr = $"{split[0]} {split[1]} {split[2].Insert(3, ":")}"; DateTime.TryParse(normalizedStr, out created); } result.Add(new NetworkRow { Id = items[0], Name = items[1], Driver = items[2], Scope = items[3], IPv6 = ipv6, Internal = intern, Created = created }); } Response = response.ToResponse(true, string.Empty, (IList <NetworkRow>)result); return(this); }
public IProcessResponse <string> Process(ProcessExecutionResult response) { var success = response.StdOutAsArray.All( line => !line.StartsWith("Host does not exist") && !line.StartsWith("Incorrect Usage.")); Response = response.ToResponse(success, string.Empty, string.Empty); return(this); }
public IProcessResponse <string> Process(ProcessExecutionResult response) { var success = response.StdOutAsArry.All( line => !line.StartsWith("Error") && !line.StartsWith("Can't remove") && !line.StartsWith("Incorrect Usage.")); Response = response.ToResponse(success, string.Empty, string.Empty); return(this); }
/// <summary> /// Reads all tags from matroska file and parses the XML for the requested tags (<paramref name="tagsToExtract"/>). /// </summary> /// <param name="tagsToExtract">Dictionary with tag names as keys.</param> public void ReadTags(IDictionary <string, IList <string> > tagsToExtract) { ProcessExecutionResult executionResult = null; // Calling EnsureLocalFileSystemAccess not necessary; access for external process ensured by ExecuteWithResourceAccess var arguments = string.Format("tags \"{0}\"", _lfsra.LocalFileSystemPath); try { lock (MKVEXTRACT_THROTTLE_LOCK) executionResult = _lfsra.ExecuteWithResourceAccessAsync(_mkvExtractPath, arguments, _priorityClass).Result; } catch (AggregateException ae) { ae.Handle(e => { if (e is TaskCanceledException) { ServiceRegistration.Get <ILogger>().Warn("MatroskaInfoReader.ReadTags: External process aborted due to timeout: Executable='{0}', Arguments='{1}'", _mkvExtractPath, arguments); return(true); } return(false); }); } if (executionResult != null && executionResult.Success && !string.IsNullOrEmpty(executionResult.StandardOutput)) { XDocument doc = XDocument.Parse(executionResult.StandardOutput); foreach (string key in new List <string>(tagsToExtract.Keys)) { string[] parts = key.Split('.'); int? targetType = null; string tagName; if (parts.Length == 2) { targetType = int.Parse(parts[0]); tagName = parts[1]; } else { tagName = parts[0]; } var result = from simpleTag in GetTagsForTargetType(doc, targetType).Elements("Simple") let nameElement = simpleTag.Element("Name") let stringElement = simpleTag.Element("String") where nameElement != null && nameElement.Value == tagName && stringElement != null && !string.IsNullOrWhiteSpace(stringElement.Value) select stringElement.Value; var resultList = result.ToList(); if (resultList.Any()) { tagsToExtract[key] = resultList.ToList(); } } } }
private bool IsHealthyAndRunning(ProcessExecutionResult result) { var status = _outputParser.ParseInstallerStatus(result.Output); return(status == DriverState.DeviceExists && status != DriverState.DeviceIsDisabled && status != DriverState.DeviceIsStopped && status != DriverState.DeviceHasAProblem); }
public IProcessResponse <string> Process(ProcessExecutionResult response) { var arr = response.StdOutAsArry; Response = arr.Length == 0 ? response.ToResponse(false, "No line", string.Empty) : response.ToResponse(true, string.Empty, arr[0]); return(this); }
protected OutputResult GetOutputResult(ProcessExecutionResult processExecutionResult) => new OutputResult { TimeUsed = (int)processExecutionResult.TimeWorked.TotalMilliseconds, MemoryUsed = (int)processExecutionResult.MemoryUsed, ResultType = processExecutionResult.Type, Output = string.IsNullOrWhiteSpace(processExecutionResult.ErrorOutput) ? processExecutionResult.ReceivedOutput : processExecutionResult.ErrorOutput };
public static ProcessExecutionResult RunProcess(string fileName, string arguments = null, int timeout = default(int)) { var outputBuilder = new List<string>(); var errorOutputBuilder = new List<string>(); var startInfo = new ProcessStartInfo(fileName, arguments) { UseShellExecute = false, CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden, RedirectStandardError = true, RedirectStandardOutput = true, }; using (var process = new Process { StartInfo = startInfo }) { process.ErrorDataReceived += (sendingProcess, outLine) => { if (!string.IsNullOrEmpty(outLine.Data)) { errorOutputBuilder.Add(outLine.Data); } }; process.OutputDataReceived += (sendingProcess, outLine) => { if (!string.IsNullOrEmpty(outLine.Data)) { outputBuilder.Add(outLine.Data); } }; process.Start(); process.BeginErrorReadLine(); process.BeginOutputReadLine(); if (timeout != default(int)) { if (!process.WaitForExit(timeout)) { process.Kill(); throw new TimeoutException(); } } else { process.WaitForExit(); } var processExecutionResult = new ProcessExecutionResult { ExitCode = process.ExitCode, ErrorOutput = string.Join("\r\n", errorOutputBuilder), Output = string.Join("\r\n", outputBuilder), }; return processExecutionResult; } }
public async Task <(string deviceName, ProcessExecutionResult result)> InstallApp(string appPath, TestTarget target, string deviceName = null, CancellationToken cancellationToken = default) { if (target.IsSimulator()) { // We reset the simulator when running, so a separate install step does not make much sense. throw new InvalidOperationException("Installing to a simulator is not supported."); } if (!Directory.Exists(appPath)) { throw new DirectoryNotFoundException("Failed to find the app bundle directory"); } if (deviceName == null) { var device = await _deviceLoader.FindDevice(target.ToRunMode(), _mainLog, false, false); if (target.IsWatchOSTarget()) { deviceName = (await _deviceLoader.FindCompanionDevice(_mainLog, device)).Name; } else { deviceName = device.Name; } } if (deviceName == null) { throw new NoDeviceFoundException(); } var args = new MlaunchArguments(); for (int i = -1; i < _verbosity; i++) { args.Add(new VerbosityArgument()); } args.Add(new InstallAppOnDeviceArgument(appPath)); args.Add(new DeviceNameArgument(deviceName)); if (target.IsWatchOSTarget()) { args.Add(new DeviceArgument("ios,watchos")); } var totalSize = Directory.GetFiles(appPath, "*", SearchOption.AllDirectories).Select((v) => new FileInfo(v).Length).Sum(); _mainLog.WriteLine($"Installing '{appPath}' to '{deviceName}' ({totalSize / 1024.0 / 1024.0:N2} MB)"); ProcessExecutionResult result = await _processManager.ExecuteCommandAsync(args, _mainLog, TimeSpan.FromHours(1), cancellation_token : cancellationToken); return(deviceName, result); }
public IProcessResponse <IList <string> > Process(ProcessExecutionResult response) { if (response.ExitCode != 0) { Response = response.ToErrorResponse((IList <string>) new List <string>()); return(this); } Response = response.ToResponse(true, string.Empty, (IList <string>) new List <string>(response.StdOutAsArry)); return(this); }
private void FixReceivedOutput(ProcessExecutionResult processExecutionResult) { var output = processExecutionResult.ErrorOutput ?? string.Empty; if (TestsRegex.IsMatch(output)) { processExecutionResult.ReceivedOutput = output; processExecutionResult.ErrorOutput = string.Empty; processExecutionResult.Type = ProcessExecutionResultType.Success; } }
public IProcessResponse <MachineConfiguration> Process(ProcessExecutionResult response) { if (string.IsNullOrEmpty(response.StdOut)) { Response = response.ToResponse(false, "No response", new MachineConfiguration { AuthConfig = new MachineAuthConfig() }); return(this); } var j = JObject.Parse(response.StdOut); var str = j["HostOptions"]["AuthOptions"].ToString(); var ip = j["Driver"]["IPAddress"].Value <string>(); var authConfig = JsonConvert.DeserializeObject <MachineAuthConfig>(str); int memsize = 0; if (null != j["Driver"]["Memory"]) { memsize = j["Driver"]["Memory"].Value <int>(); } if (null != j["Driver"]["MemSize"]) { memsize = j["Driver"]["MemSize"].Value <int>(); } string hostname = string.Empty; if (!IPAddress.TryParse(ip, out var ipaddr)) { hostname = ip; ipaddr = IPAddress.None; } var config = new MachineConfiguration { AuthConfig = authConfig, IpAddress = ipaddr, Hostname = hostname, DriverName = null != j["DriverName"] ? j["DriverName"].Value <string>() : "unknown", MemorySizeMb = memsize, Name = null != j["Name"] ? j["Name"].Value <string>() : string.Empty, RequireTls = j["HostOptions"]["EngineOptions"]["TlsVerify"].Value <bool>(), StorageSizeMb = j["Driver"]["DiskSize"]?.Value <int>() ?? 0, CpuCount = j["Driver"]["CPU"]?.Value <int>() ?? 0, StorePath = j["Driver"]["StorePath"]?.Value <string>() ?? string.Empty }; Response = response.ToResponse(true, string.Empty, config); return(this); }
public IProcessResponse<string> Process(ProcessExecutionResult response) { var success = response.ExitCode == 0 || response.StdOutAsArray.All( line => !line.StartsWith("Error") && !line.StartsWith("Can't remove") && !line.StartsWith("Incorrect Usage.")); Response = response.ToResponse(success, "Error Creating Machine", string.Empty); return this; }
public void StartProcess(BenchEnvironment env, string cwd, string executable, string arguments, ProcessExitCallback cb, ProcessMonitoring monitoring) { if (IsDisposed) { throw new ObjectDisposedException(nameof(ConEmuExecutionHost)); } if (!IsPowerShellExecutionHostRunning) { backupHost.StartProcess(env, cwd, executable, arguments, cb, monitoring); return; } var collectOutput = (monitoring & ProcessMonitoring.Output) == ProcessMonitoring.Output; var response = SendCommand("exec", cwd, executable, arguments); AsyncManager.StartTask(() => { var exitCode = 999999; var transcriptPath = default(string); foreach (var l in response) { ParseExitCode(l, ref exitCode); ParseTranscriptPath(l, ref transcriptPath); } var output = default(string); if (collectOutput && transcriptPath != null && File.Exists(transcriptPath)) { output = File.ReadAllText(transcriptPath, Encoding.Default); File.Delete(transcriptPath); } var result = new ProcessExecutionResult(exitCode, output); cb(result); }); }