public override ProcessAsyncOperation StartConsoleProcess(string command, string arguments, string workingDirectory, IDictionary <string, string> environmentVariables, string title, bool pauseWhenFinished) { ProbeTerminal(); //generate unique guid to derive application id for gnome terminal server var consoleGuid = Guid.NewGuid(); string exec = runner(command, arguments, workingDirectory, title, pauseWhenFinished, consoleGuid); var psi = new ProcessStartInfo(terminal_command, exec) { CreateNoWindow = true, UseShellExecute = false, }; if (environmentVariables != null) { foreach (var env in environmentVariables) { psi.EnvironmentVariables [env.Key] = env.Value; } } ProcessWrapper proc = new ProcessWrapper(); if (terminal_command.Contains("gnome-terminal")) { var parameter = String.Format("--app-id {0}", GenerateAppId(consoleGuid)); var terminalProcessStartInfo = new ProcessStartInfo("/usr/lib/gnome-terminal/gnome-terminal-server", parameter) { CreateNoWindow = true, UseShellExecute = false, }; proc.StartInfo = terminalProcessStartInfo; proc.Start(); proc.WaitForExit(500); //give the terminal server some warm up time Process.Start(psi); } else { proc.StartInfo = psi; proc.Start(); } return(proc.ProcessAsyncOperation); }
public string RunJobThread() { string output = null; try { var process = new ProcessWrapper(Command, Settings.Home, true, Settings.MailStdOut); Logger.Log("Starting job: " + Command); process.Start(); Logger.Debug($"Process started, waiting at most {Settings.Timeout} seconds"); process.WaitForEnd(Settings.Timeout * 1000); output = process.FetchResult(); Helper.SendMail("Cronical: Results from " + Command, output, Settings); } catch (Exception e) { var text = $"Failed to start process '{Command}': {e.Message}"; Logger.Error(text); Helper.SendMail("Cronical: Failed to start " + Command, text, Settings); } Logger.Debug("Job finished"); return(output); }
/// <summary> /// Starts the underlying process for the service app. /// </summary> private void StartProcess() { // only add the password when it's time to start the process. _process.StartInfo.Password = ServiceApp.Password.DecryptString(EntropyValue); bool hasError = false; try { // Update the version info here so that any issues with the app start are grouped together ServiceApp.RefreshAppVersion(); AddMessage("Starting service app", ServiceAppState.Unknown); _process.Start(); } catch (Exception e) { _log.Error(string.Format("Error starting service app {0}", ServiceApp.Name), e); AddMessage(e.Message, ServiceAppState.NotLoaded); hasError = true; } if (!hasError) { MonitorProcessCallback(); } }
private async Task InstallPlugins(CancellationToken cancellationToken = default(CancellationToken)) { foreach (var plugin in _settings.Plugins) { Info($"Installing plugin {plugin.Name}..."); var pluginInstallCommand = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)? Path.Combine(_settings.ElasticsearchHomePath.FullName, "bin\\elasticsearch-plugin.bat") : "bash"; using (var process = new ProcessWrapper( new DirectoryInfo(Path.Combine(_settings.ElasticsearchHomePath.FullName, "bin")), pluginInstallCommand, plugin.GetInstallCommand(), Info, startInfo => { if (startInfo.EnvironmentVariables.ContainsKey("JAVA_HOME")) { Info("Removing old JAVA_HOME and replacing with bundled JRE."); startInfo.EnvironmentVariables.Remove("JAVA_HOME"); } startInfo.EnvironmentVariables.Add("JAVA_HOME", _settings.JvmPath.FullName); } )) { await process.Start(cancellationToken).ConfigureAwait(false); Info($"Waiting for plugin {plugin.Name} install..."); process.WaitForExit(); } Info($"Plugin {plugin.Name} installed."); await Restart().ConfigureAwait(false); } }
public override IProcessAsyncOperation StartConsoleProcess(string command, string arguments, string workingDirectory, IDictionary <string, string> environmentVariables, string title, bool pauseWhenFinished) { string args = "/C \"title " + title + " && \"" + command + "\" " + arguments; if (pauseWhenFinished) { args += " & pause\""; } else { args += "\""; } var psi = new ProcessStartInfo("cmd.exe", args) { CreateNoWindow = false, WorkingDirectory = workingDirectory, UseShellExecute = false, }; foreach (var env in environmentVariables) { psi.EnvironmentVariables [env.Key] = env.Value; } ProcessWrapper proc = new ProcessWrapper(); proc.StartInfo = psi; proc.Start(); return(proc); }
private void Execute(DateTime date) { _log.Info($"Execute; {date} "); if (_itemsToRunOnNextMinute.Any()) { foreach (var cronDefinition in _itemsToRunOnNextMinute) { var processWrapper = new ProcessWrapper(); var t1 = Pharse.Tokenize(cronDefinition.ExecutePart); processWrapper.Start(t1, ""); } var nextItemToRun = _cronDefinitions .SelectMany(x => x.Value) .OrderBy(x => x.Expression.GetNextOccurrence(DateTime.UtcNow)) .FirstOrDefault(); if (nextItemToRun != null) { _log.Info( $"Next item to run at: {nextItemToRun.Expression.GetNextOccurrence(DateTime.UtcNow)}; " + $"Execute: {nextItemToRun.ExecutePart}"); } } var next = date.AddMinutes(1); ScheduleNext(next); }
public async Task Run(RunSynthesisPatcher settings, CancellationToken?cancel = null) { var repoPath = Path.GetDirectoryName(PathToSolution); if (Repository.IsValid(repoPath)) { using var repo = new Repository(repoPath); _output.OnNext($"Sha {repo.Head.Tip.Sha}"); } var internalSettings = new RunSynthesisMutagenPatcher() { DataFolderPath = settings.DataFolderPath, ExtraDataFolder = Path.Combine(PathToExtraDataBaseFolder, Name), GameRelease = settings.GameRelease, LoadOrderFilePath = settings.LoadOrderFilePath, OutputPath = settings.OutputPath, SourcePath = settings.SourcePath }; var args = Parser.Default.FormatCommandLine(internalSettings); using var process = ProcessWrapper.Start( new ProcessStartInfo("dotnet", $"run --project \"{PathToProject}\" --runtime win-x64 --no-build {args}"), cancel: cancel); using var outputSub = process.Output.Subscribe(_output); using var errSub = process.Error.Subscribe(_error); var result = await process.Start().ConfigureAwait(false); if (result != 0) { throw new CliUnsuccessfulRunException(result, "Error running solution patcher"); } }
public static async Task <Version> DotNetSdkVersion() { using var proc = ProcessWrapper.Start( new System.Diagnostics.ProcessStartInfo("dotnet", "--version")); List <string> outs = new List <string>(); using var outp = proc.Output.Subscribe(o => outs.Add(o)); List <string> errs = new List <string>(); using var errp = proc.Error.Subscribe(o => errs.Add(o)); var result = await proc.Start(); if (errs.Count > 0) { throw new ArgumentException($"{string.Join("\n", errs)}"); } if (outs.Count != 1) { throw new ArgumentException($"Unexpected messages:\n{string.Join("\n", outs)}"); } if (!Version.TryParse(outs[0], out var v)) { throw new ArgumentException($"Could not parse dotnet SDK version: {outs[0]}"); } return(v); }
private async Task StartProcess(CancellationToken cancellationToken = default(CancellationToken)) { var args = _settings.BuildCommandline(); _processWrapper = new ProcessWrapper(_settings.ElasticsearchHomePath, Path.Combine(_settings.JvmPath.FullName, "bin/java.exe"), args, Info); await _processWrapper.Start(cancellationToken).ConfigureAwait(false); }
public void FactMethodName() { var ss = @"eo.exe -clients=client1,client2 -waitTime=10 -SeriesMode=2"; var t1 = Pharse.Tokenize(ss); ProcessWrapper processWrapper = new ProcessWrapper(); processWrapper.Start(t1, ""); //var t = new ProcessWrapper("'SiteScrapera.exe\a\a\' -clients=client1,client2 -waitTime=10 -SeriesMode=2", "", false, false); }
public async Task RunPythonFile(string filename, string configFile) { var process = new ProcessWrapper(filename, "--config \"" + configFile + "\""); process.OutputDataReceived += (sender, eventArgs) => { if (!string.IsNullOrWhiteSpace(eventArgs.Data)) { string dataString = eventArgs.Data.Replace("\f", ""); dataString = dataString.TrimStart(); if (dataString.StartsWith("Epoch")) { string[] epochText = dataString.Split(' '); if (epochText.Length > 1) { string[] epochNumbers = epochText[1].Split('/'); bool epochDoneParsed = double.TryParse(epochNumbers[0], NumberStyles.Float, CultureInfo.InvariantCulture, out double epochDone); bool epochTotalParsed = double.TryParse(epochNumbers[1], NumberStyles.Float, CultureInfo.InvariantCulture, out double epochTotal); if (epochDoneParsed && epochTotalParsed) { _viewModel.Progress = 100 * epochDone / epochTotal; UpdateEta(); } } } _viewModel.ConsoleOutputText += dataString + "\n\n"; } }; process.ErrorDataReceived += (sender, eventArgs) => { if (eventArgs.Data != null && _showErrors) { _viewModel.ConsoleOutputText += eventArgs.Data + "\n\n"; } }; pythonAppId = process.Start(); await process.ExitedAsync(); pythonAppId = 0; RunAnnotationsButton.Visibility = Visibility.Visible; StopAnnotationsButton.Visibility = Visibility.Hidden; RunAnnotationsButton.IsEnabled = true; PredictRadioButton.IsEnabled = true; TrainRadioButton.IsEnabled = true; SelectAudioSourceButton.IsEnabled = true; SelectMateBookButton.IsEnabled = true; SelectOutputFolderButton.IsEnabled = true; WeightsFileButton.IsEnabled = true; _viewModel.Progress = 0.0; _viewModel.Progress2 = 0.0; }
public void TestStart_DefaultPath() { var wrapper = new ProcessWrapper("cmd /c cd", _path, false, true); wrapper.Start(); wrapper.WaitForEnd(5000); var result = wrapper.FetchResult().Trim(); Assert.AreEqual(Directory.GetCurrentDirectory().ToLower(), result.ToLower()); }
public void TestStart_RelativePath() { var wrapper = new ProcessWrapper("system32\\cmd /c cd", "c:\\windows", false, true); wrapper.Start(); wrapper.WaitForEnd(5000); var result = wrapper.FetchResult().Trim(); Assert.AreEqual("c:\\windows\\system32".ToLower(), result.ToLower()); }
private async Task StartProcess(CancellationToken cancellationToken = default(CancellationToken)) { var args = _settings.BuildCommandline(); var javaExecutable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? Path.Combine(_settings.JvmPath.FullName, "bin/java.exe") : "java"; _processWrapper = new ProcessWrapper(_settings.ElasticsearchHomePath, javaExecutable, args, Info); await _processWrapper.Start(cancellationToken).ConfigureAwait(false); }
public static async Task <IEnumerable <(string Package, string Requested, string Resolved, string Latest)> > NugetListingQuery(string projectPath, bool queryServer) { // Run restore first { using var restore = ProcessWrapper.Start( new ProcessStartInfo("dotnet", $"restore \"{projectPath}\"")); await restore.Start(); } bool on = false; List <string> lines = new List <string>(); List <string> errors = new List <string>(); using var process = ProcessWrapper.Start( new ProcessStartInfo("dotnet", $"list \"{projectPath}\" package{(queryServer ? " --outdated" : null)}")); using var outSub = process.Output.Subscribe(s => { if (s.Contains("Top-level Package")) { on = true; return; } if (!on) { return; } lines.Add(s); }); using var errSub = process.Error.Subscribe(s => errors.Add(s)); var result = await process.Start(); if (errors.Count > 0) { throw new ArgumentException($"Error while retrieving nuget listings: \n{string.Join("\n", errors)}"); } var ret = new List <(string Package, string Requested, string Resolved, string Latest)>(); foreach (var line in lines) { if (!TryParseLibraryLine( line, out var package, out var requested, out var resolved, out var latest)) { continue; } ret.Add((package, requested, resolved, latest)); } return(ret); }
public override IProcessAsyncOperation StartConsoleProcess ( string command, string arguments, string workingDirectory, IDictionary<string, string> environmentVariables, string title, bool pauseWhenFinished) { var proc = new ProcessWrapper { StartInfo = CreateConsoleStartInfo ( command, arguments, workingDirectory, environmentVariables, title, pauseWhenFinished ) }; proc.Start (); return proc; }
internal static void StartProgramTask(string fileNameWithArguments, object starter) { string fileName = ""; string arguments = ""; try { // Search for the extension. Take everything before as file name, and everything after as arguments. int iExt = -1; foreach (string ext in SupportedExtensions) { iExt = fileNameWithArguments.IndexOf(ext); if (iExt > -1) { fileName = fileNameWithArguments.Substring(0, iExt + ext.Length); arguments = fileNameWithArguments.Remove(0, fileName.Length).Trim(); break; } } // If program file is unsupported, skip execution and warn user. if (iExt == -1) { Logger.Instance.LogFormat(LogType.Warning, starter, Resources.ProgramNotSupported, fileNameWithArguments, string.Join(", ", SupportedExtensions)); return; } ProcessWrapper proc = new ProcessWrapper(); proc.FileName = fileName; proc.WorkingDirectory = Path.GetDirectoryName(fileName); proc.Arguments = arguments; proc.Start(); } catch (Exception ex) { Logger.Instance.LogFormat(LogType.Error, starter, Resources.ProgramStartFailed, fileNameWithArguments); Logger.Instance.LogException(starter, ex); } }
public void Start(string startupFile) { reader = new LanguageServiceResponseReader(ProcessResponse); var startInfo = new ProcessStartInfo { FileName = new NodePath().FileName, //Arguments = "--debug --no-lazy " + startupFile, Arguments = "\"" + startupFile + "\"", CreateNoWindow = true, RedirectStandardError = true, RedirectStandardOutput = true, UseShellExecute = false, RedirectStandardInput = true }; process = new ProcessWrapper(); process.StartInfo = startInfo; process.OutputStreamChanged += ProcessOutputStreamChanged; process.ErrorStreamChanged += ProcessErrorStreamChanged; process.Start(); }
public void Run() { CheckIsRunning(); switch (State) { case JobState.Starting: Logger.Warning($"Run: Service is already starting: '{Command}'"); return; case JobState.Running: Logger.Warning($"Run: Job is already running: '{Command}'"); return; case JobState.Stopping: Logger.Warning($"Run: Unable to start, job is stopping: '{Command}'"); return; } State = JobState.Starting; Process = new ProcessWrapper(Command, Settings.Home, false, false); try { Logger.Log("Starting service: " + Command); Process.Start(); Logger.Debug("Process started"); } catch (Exception e) { var text = $"Failed to start service '{Command}': {e.Message}"; Logger.Error(text); Helper.SendMail("Cronical: Failed to start service " + Command, text, Settings); } finally { State = CheckIsRunning() ? JobState.Running : JobState.Inactive; } }
public async Task Run(RunSynthesisPatcher settings, CancellationToken?cancel = null) { if (cancel?.IsCancellationRequested ?? false) { return; } var internalSettings = RunSynthesisMutagenPatcher.Factory(settings); internalSettings.ExtraDataFolder = PathToExtraData; var args = Parser.Default.FormatCommandLine(internalSettings); try { using ProcessWrapper process = ProcessWrapper.Start( new ProcessStartInfo(PathToExecutable, args) { WorkingDirectory = Path.GetDirectoryName(PathToExecutable) }, cancel); using var outputSub = process.Output.Subscribe(_output); using var errSub = process.Error.Subscribe(_error); var result = await process.Start(); if (result != 0) { throw new CliUnsuccessfulRunException( result, $"Process exited in failure: {process.StartInfo.FileName} {internalSettings}"); } } catch (Win32Exception ex) { throw new FileNotFoundException($"Could not find target CLI file: {PathToExecutable}", ex); } }
public override IProcessAsyncOperation StartConsoleProcess(string command, string arguments, string workingDirectory, IDictionary <string, string> environmentVariables, string title, bool pauseWhenFinished) { ProbeTerminal(); string exec = runner(command, arguments, workingDirectory, title, pauseWhenFinished); var psi = new ProcessStartInfo(terminal_command, exec) { CreateNoWindow = true, UseShellExecute = false, }; foreach (var env in environmentVariables) { psi.EnvironmentVariables [env.Key] = env.Value; } ProcessWrapper proc = new ProcessWrapper(); proc.StartInfo = psi; proc.Start(); return(proc); }
/// <summary> /// <see cref="IAgentRunnerProvider.RunAsync(AgentRunnerProviderArgs)"/> /// </summary> public Task RunAsync(AgentRunnerProviderArgs providerArgs) { var processWrapper = new ProcessWrapper(); this.backgroundTaskQueue.QueueAgentRun(new AgentRunnerProcess(providerArgs.Channel, processWrapper, async(CancellationToken token) => { try { if (!providerArgs.AllowSkip || !await providerArgs.SkipHandlerAsync(new AgentRunnerProviderResult { AgentRunner = providerArgs.AgentRunner, Channel = providerArgs.Channel, Command = providerArgs.Command, AgentRunnerType = providerArgs.AgentRunnerType, CancellationToken = token })) { await providerArgs.BeginHandlerAsync(new AgentRunnerProviderResult { AgentRunner = providerArgs.AgentRunner, Channel = providerArgs.Channel, Command = providerArgs.Command, CancellationToken = token }); processWrapper.Start(providerArgs.Command); var lineCount = 1; var script = providerArgs.AgentRunner.Agent.Script; while (!processWrapper.EndOfStream) { if (processWrapper.Stopped) { break; } token.ThrowIfCancellationRequested(); // Parse the terminal output one line var terminalLineOutput = processWrapper.TerminalLineOutput(); var scriptOutput = await this.scriptEngineService.TerminalOutputParseAsync(script, terminalLineOutput, lineCount++); await providerArgs.ParserOutputHandlerAsync(new AgentRunnerProviderResult { AgentRunner = providerArgs.AgentRunner, AgentRunnerType = providerArgs.AgentRunnerType, Channel = providerArgs.Channel, ScriptOutput = scriptOutput, LineCount = lineCount, TerminalLineOutput = terminalLineOutput, CancellationToken = token }); } } ; await providerArgs.EndHandlerAsync(new AgentRunnerProviderResult { AgentRunner = providerArgs.AgentRunner, Channel = providerArgs.Channel, AgentRunnerType = providerArgs.AgentRunnerType, Command = providerArgs.Command, Last = providerArgs.Last, CancellationToken = token }); } catch (Exception ex) { await providerArgs.ExceptionHandlerAsync(new AgentRunnerProviderResult { AgentRunner = providerArgs.AgentRunner, Channel = providerArgs.Channel, Last = providerArgs.Last, Command = providerArgs.Command, Exception = ex, CancellationToken = token }); } })); return(Task.CompletedTask); }