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);
}
