ProcessStartInfo StartInfoFrom(ProcessSettings settings)
{
var startInfo = new ProcessStartInfo(MonoExecutable, settings.Executable);
startInfo.WorkingDirectory = settings.Executable.Parent;
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
startInfo.UseShellExecute = false;
foreach (var variable in settings.EnvironmentVariables)
startInfo.EnvironmentVariables.Add(variable.Key, variable.Value);
return startInfo;
}
/// <summary>
/// Runs the tool using the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
public override void Run(CMakeBuildSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (settings.BinaryPath == null)
{
throw new ArgumentNullException(nameof(settings.BinaryPath));
}
var binaryPath = settings.BinaryPath.MakeAbsolute(_environment);
// Create the process settings.
var processSettings = new ProcessSettings
{
WorkingDirectory = binaryPath
};
this.Run(settings, this.GetArguments(settings), processSettings, null);
}
/// <summary>
/// Runs Git with specified settings.
/// </summary>
/// <param name="settings">Settings for running Git.</param>
/// <returns>Output of command.</returns>
public IEnumerable <string> RunCommand(GitRunnerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var args = new ProcessArgumentBuilder();
settings.Evaluate(args);
var processSettings = new ProcessSettings
{
WorkingDirectory = settings.WorkingDirectory,
Arguments = args.Render(),
RedirectStandardOutput = true,
};
var currentEncoding = Console.OutputEncoding;
Console.OutputEncoding = Encoding.UTF8;
try
{
IEnumerable <string> result = null;
this.Run(
settings,
null,
processSettings,
process =>
{
result = process.GetStandardOutput();
});
return(result?.ToList());
}
finally
{
Console.OutputEncoding = currentEncoding;
}
}
/// <summary>
/// Runs the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <exception cref="ArgumentNullException">settings.</exception>
public void Run(SevenZipSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var procSettings = new ProcessSettings
{
RedirectStandardOutput = true,
};
void AfterRun(IProcess p)
{
if (settings.Command is ICanParseOutput parseOutput)
{
parseOutput.SetRawOutput(p.GetStandardOutput());
}
}
Run(settings, GetArguments(settings), procSettings, AfterRun);
}
/// <summary>
/// Executes the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <returns>Returns the <see cref="NodeState"/> of the specified host</returns>
/// <exception cref="System.ArgumentNullException">Thrown when the settings are null</exception>
/// <exception cref="CakeException">Required setting HostName not specified.</exception>
public NodeState Execute(GetNodeStateSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (string.IsNullOrEmpty(settings.HostName))
{
throw new CakeException("Required setting HostName not specified.");
}
var builder = new ProcessArgumentBuilder();
builder.Append("GetNodeState");
builder.Append("--NonInteractive");
builder.Append("-Hostname");
builder.Append(settings.HostName);
var processSettings = new ProcessSettings {
RedirectStandardOutput = true
};
var result = NodeState.Unknown;
Action <IProcess> postProcessor = process =>
{
var lines = process.GetStandardOutput()?.ToList();
if (lines != null && lines.Any())
{
result = ParseResults(lines);
}
};
this.Run(settings, builder, processSettings, postProcessor);
return(result);
}
/// <summary>
/// Lists available packages with their versions
/// </summary>
/// <param name="packageId">The source package id. If it equals an empty string, it will match all packageIds</param>
/// <param name="settings">The settings</param>
/// <returns>A list of available packages</returns>
public IEnumerable <NuGetListItem> List(string packageId, NuGetListSettings settings)
{
if (packageId == null)
{
throw new ArgumentNullException(nameof(packageId));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var processSettings = new ProcessSettings
{
RedirectStandardOutput = true
};
IEnumerable <string> result = null;
Run(settings, GetHasArguments(packageId, settings), processSettings,
process => result = process.GetStandardOutput());
return(result.Select(line => ConvertToNuGetListItem(line)).ToList());
}
/// <summary>
/// Process the type with the provided settings.
/// </summary>
/// <param name="input"> The input to process. </param>
/// <param name="settings"> The settings to configure the process. </param>
/// <returns> The result of the type processing. </returns>
public string Process(string input, ProcessSettings settings)
{
switch (settings.Method)
{
case ProcessMethod.Trim:
return(input.Trim());
case ProcessMethod.TrimLeft:
return(input.TrimStart());
case ProcessMethod.TrimRight:
return(input.TrimEnd());
case ProcessMethod.LowerCase:
return(input.ToLower());
case ProcessMethod.UpperCase:
return(input.ToUpper());
default:
throw new NotImplementedException();
}
}
public static void UnityBuild(this ICakeContext context, Action <BuildSettings> buildSettingsAction)
{
var buildSettings = new BuildSettings();
buildSettingsAction(buildSettings);
var valid = buildSettings.ValidateArguments(context);
if (!valid)
{
throw new Exception("Invalid build settings");
}
var processArguments = buildSettings.GetProcessArguments(context);
var runner = new ProcessRunner(context.Environment, context.Log);
var settings = new ProcessSettings {
Arguments = processArguments
};
var process = runner.Start(buildSettings.Unity, settings);
process.WaitForExit();
}
/// <summary>
/// Runs the tool using a custom tool path and the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="toolPath">The tool path to use.</param>
/// <param name="processSettings">The process settings.</param>
/// <param name="postAction">If specified called after process exit.</param>
protected void Run(TSettings settings, ProcessArgumentBuilder arguments, FilePath toolPath,
ProcessSettings processSettings, Action <IProcess> postAction)
{
if (arguments == null && (processSettings?.Arguments == null))
{
throw new ArgumentNullException(nameof(arguments));
}
var process = RunProcess(settings, arguments, toolPath, processSettings);
// Wait for the process to exit.
process.WaitForExit();
// Post action specified?
postAction?.Invoke(process);
// Did an error occur?
if (process.GetExitCode() != 0)
{
const string message = "{0}: Process returned an error (exit code {1}).";
throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, GetToolName(), process.GetExitCode()));
}
}
/// <summary>
/// Execute an assembly using arguments and settings.
/// </summary>
/// <param name="projectPath">The target project path.</param>
/// <param name="command">The command to execute.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
public void Execute(FilePath projectPath, string command, ProcessArgumentBuilder arguments, DotNetCoreToolSettings settings)
{
if (projectPath == null)
{
throw new ArgumentNullException(nameof(projectPath));
}
if (string.IsNullOrWhiteSpace(command))
{
throw new ArgumentNullException(nameof(command));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var processSettings = new ProcessSettings();
processSettings.WorkingDirectory = projectPath.GetDirectory();
RunCommand(settings, GetArguments(command, arguments, settings), processSettings);
}
public ProcessRunnerFixture(bool windows = false)
{
var environment = windows
? FakeEnvironment.CreateWindowsEnvironment()
: FakeEnvironment.CreateUnixEnvironment();
environment.WorkingDirectory = "/Working";
Environment = environment;
FileSystem = new FakeFileSystem(Environment);
Log = Substitute.For <ICakeLog>();
Tools = Substitute.For <IToolLocator>();
Configuration = Substitute.For <ICakeConfiguration>();
ProcessFilePath = "/Program Files/Cake.exe";
ProcessSettings = new ProcessSettings();
FileSystem.CreateDirectory("/Working");
FileSystem.CreateDirectory("/Program Files");
FileSystem.CreateFile("/Program Files/Cake.exe", ClrAssemblyData);
MonoFile = FileSystem.CreateFile("/Program Files/mono.exe", NonClrAssemblyData);
Tools.Resolve("mono").Returns(file => MonoFile.Exists ? MonoFile.Path : null);
}
/// <summary>
/// Runs the tool using a custom tool path and the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processSettings">The process settings.</param>
/// <param name="postAction">If specified called after process exit.</param>
protected void Run(
TSettings settings,
ProcessArgumentBuilder arguments,
ProcessSettings processSettings,
Action <IProcess> postAction)
{
if (arguments == null && (processSettings?.Arguments == null))
{
throw new ArgumentNullException(nameof(arguments));
}
var process = RunProcess(settings, arguments, processSettings);
// Wait for the process to exit.
if (settings.ToolTimeout.HasValue)
{
if (!process.WaitForExit((int)settings.ToolTimeout.Value.TotalMilliseconds))
{
const string message = "Tool timeout ({0}): {1}";
throw new TimeoutException(string.Format(CultureInfo.InvariantCulture, message, settings.ToolTimeout.Value, GetToolName()));
}
}
else
{
process.WaitForExit();
}
// Post action specified?
(postAction ?? settings.PostAction)?.Invoke(process);
var exitCode = process.GetExitCode();
if (!settings.HandleExitCode?.Invoke(exitCode) ?? true)
{
ProcessExitCode(process.GetExitCode());
}
}
public void Run(TerraformShowSettings settings)
{
if (settings.PlanFile == null)
{
throw new ArgumentNullException(nameof(settings.PlanFile));
}
var arguments = new ProcessArgumentBuilder()
.Append("show")
.Append(settings.PlanFile.FullPath);
if (settings.OutputFormat == OutputFormat.PlainText)
{
arguments.Append("-no-color");
}
var processSettings = new ProcessSettings();
if (settings.OutFile != null)
{
processSettings.RedirectStandardOutput = true;
}
Run(settings, arguments, processSettings, x =>
{
if (settings.OutFile != null)
{
OutputFormatter formatter;
if (!_formatters.TryGetValue(settings.OutputFormat, out formatter))
{
formatter = _formatters[OutputFormat.PlainText];
}
File.WriteAllText(settings.OutFile.FullPath, formatter.FormatLines(x.GetStandardOutput()));
}
});
}
protected T Run <T>(TSettings settings, ProcessArgumentBuilder builder, Func <XDocument, T> deserializer)
{
T result = default(T);
ProcessSettings ps = new ProcessSettings {
RedirectStandardOutput = true,
};
if (Log.Verbosity != Verbosity.Diagnostic)
{
Log.Debug(Verbosity.Verbose, "Calling plastic with parameters: {0}", builder.RenderSafe());
}
Run(settings, builder, ps, (process) =>
{
var stdout = process.GetStandardOutput().ToList();
if (settings.ForcePrintingToLog && Log.Verbosity != Verbosity.Diagnostic)
{
PrintToStdout(stdout);
}
result = DeserializeXmlResponse(process, stdout, deserializer);
});
return(result);
}
public List <string> Run(TerraformEnvListSettings settings)
{
var builder =
new ProcessArgumentBuilder()
.Append("workspace")
.Append("list");
var processSettings = new ProcessSettings
{
RedirectStandardOutput = true
};
var result = new List <string>();
this.Run(settings, builder, processSettings, x =>
{
result = x.GetStandardOutput()
.Select(env => env.Replace("*", "").Trim())
.Where(env => !string.IsNullOrWhiteSpace(env))
.ToList();
});
return(result);
}
public void Should_Return_Settings_With_Correct_Arguments(string value, string expected)
{
var settings = new ProcessSettings().WithArguments(args => { args.Append(value); });
Assert.Equal(expected, settings.Arguments.Render());
}
public MoCSValidationProcess(ProcessSettings settings, IFileSystem fileSystem)
: base(settings, fileSystem)
{
InitializeProcesses();
}
/// <summary>
/// Initializes a new instance of the ContinuousIntegrationClientProcess for testing purposes
/// </summary>
/// <param name="settings"></param>
/// <param name="fileSystem"></param>
public MoCSValidationProcess(ProcessSettings settings, IFileSystem fileSystem, List <BaseProcess> processes) : base(settings, fileSystem)
{
_processes = processes;
InitializeProcesses();
}
public IProcess StartManagedProcess(ProcessSettings settings)
{
return new StandardProcess(Process.Start(StartInfoFrom(settings)));
}
/// <summary><p>ReportGenerator converts XML reports generated by OpenCover, PartCover, dotCover, Visual Studio, NCover or Cobertura into human readable reports in various formats.</p><p>The reports do not only show the coverage quota, but also include the source code and visualize which lines have been covered.</p><p>ReportGenerator supports merging several reports into one. It is also possible to pass one XML file containing several reports to ReportGenerator (e.g. a build log file).</p><p>The following <a href="https://github.com/danielpalme/ReportGenerator/wiki/Output-formats">output formats</a> are supported by ReportGenerator:<ul><li>HTML, HTMLSummary, HTMLInline, HTMLChart, <a href="https://en.wikipedia.org/wiki/MHTML">MHTML</a></li><li>XML, XMLSummary</li><li>Latex, LatexSummary</li><li>TextSummary</li><li>CsvSummary</li><li>PngChart</li><li>Badges</li><li><a href="https://github.com/danielpalme/ReportGenerator/wiki/Custom-reports">Custom reports</a></li></ul></p><p>Compatibility:<ul><li><a href="https://github.com/OpenCover/opencover">OpenCover</a></li><li><a href="https://github.com/sawilde/partcover.net4">PartCover 4.0</a></li><li><a href="http://sourceforge.net/projects/partcover">PartCover 2.2, 2.3</a></li><li><a href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html">dotCover</a> (/ReportType=DetailedXML)</li><li>Visual Studio (<a href="https://github.com/danielpalme/ReportGenerator/wiki/Visual-Studio-Coverage-Tools#vstestconsoleexe">vstest.console.exe</a>, <a href="https://github.com/danielpalme/ReportGenerator/wiki/Visual-Studio-Coverage-Tools#codecoverageexe">CodeCoverage.exe</a>)</li><li><a href="http://www.ncover.com/download/current">NCover</a> (tested version 1.5.8, other versions may not work)</li><li><a href="https://github.com/cobertura/cobertura">Cobertura</a></li><li>Mono (<a href="http://www.mono-project.com/docs/debug+profile/profile/profiler/#analyzing-the-profile-data">mprof-report</a>)</li></ul></p><p>For more details, visit the <a href="https://github.com/danielpalme/ReportGenerator">official website</a>.</p></summary>
public static void ReportGenerator(Configure <ReportGeneratorSettings> configurator = null, ProcessSettings processSettings = null)
{
var toolSettings = configurator.InvokeSafe(new ReportGeneratorSettings());
PreProcess(toolSettings);
var process = ProcessTasks.StartProcess(toolSettings, processSettings);
process.AssertZeroExitCode();
PostProcess(toolSettings);
}
/// <summary>
/// Runs the tool using a custom tool path and the specified settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processSettings">The process settings.</param>
/// <returns>The process that the tool is running under.</returns>
protected IProcess RunProcess(
TSettings settings,
ProcessArgumentBuilder arguments,
ProcessSettings processSettings)
{
if (arguments == null && (processSettings?.Arguments == null))
{
throw new ArgumentNullException(nameof(arguments));
}
// Should we customize the arguments?
if (settings.ArgumentCustomization != null)
{
arguments = settings.ArgumentCustomization(arguments);
}
// Get the tool name.
var toolName = GetToolName();
// Get the tool path.
var toolPath = GetToolPath(settings);
if (toolPath == null || !_fileSystem.Exist(toolPath))
{
const string message = "{0}: Could not locate executable.";
throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName));
}
// Get the working directory.
var workingDirectory = GetWorkingDirectory(settings);
if (workingDirectory == null)
{
const string message = "{0}: Could not resolve working directory.";
throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName));
}
// Create the process start info.
var info = processSettings ?? new ProcessSettings();
if (info.Arguments == null)
{
info.Arguments = arguments;
}
if (info.WorkingDirectory == null)
{
info.WorkingDirectory = workingDirectory.MakeAbsolute(_environment).FullPath;
}
if (info.EnvironmentVariables == null)
{
info.EnvironmentVariables = GetEnvironmentVariables(settings);
}
// Want to opt out of using a working directory?
info.NoWorkingDirectory = settings.NoWorkingDirectory;
// Configure process settings
settings.SetupProcessSettings?.Invoke(info);
// Run the process.
var process = _processRunner.Start(toolPath, info);
if (process == null)
{
const string message = "{0}: Process was not started.";
throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName));
}
return(process);
}
/// <summary><p>One of ReSharper's most notable features, code inspection, is available even without opening Visual Studio. InspectCode, a free command line tool requires a minimum of one parameter- your solution file- to apply all of ReSharper's inspections.</p><p>For more details, visit the <a href="https://www.jetbrains.com/help/resharper/InspectCode.html/">official website</a>.</p></summary>
public static void InspectCode(Configure <InspectCodeSettings> configurator = null, ProcessSettings processSettings = null)
{
var toolSettings = configurator.InvokeSafe(new InspectCodeSettings());
PreProcess(toolSettings);
var process = StartProcess(toolSettings, processSettings);
process.AssertZeroExitCode();
PostProcess(toolSettings);
}
public void Should_Return_Settings_With_Correct_Timeout(int value, int expected)
{
var settings = new ProcessSettings().SetTimeout(value);
Assert.Equal(expected, settings.Timeout);
}
public void Should_Return_Settings_With_Correct_Directory(string value, string expected)
{
var settings = new ProcessSettings().UseWorkingDirectory(value);
Assert.Equal(expected, settings.WorkingDirectory.FullPath);
}
/// <summary><p>One of ReSharper's most notable features, code inspection, is available even without opening Visual Studio. InspectCode, a free command line tool requires a minimum of one parameter- your solution file- to apply all of ReSharper's inspections.</p><p>For more details, visit the <a href="https://www.jetbrains.com/help/resharper/InspectCode.html/">official website</a>.</p></summary>
public static void InspectCode(string targetPath, string output, Configure <InspectCodeSettings> configurator = null, ProcessSettings processSettings = null)
{
configurator = configurator ?? (x => x);
InspectCode(targetPath, x => configurator(x).SetOutput(output));
}
public void Should_Return_Settings_With_Correct_Output(bool value, bool expected)
{
var settings = new ProcessSettings().SetRedirectStandardOutput(value);
Assert.Equal(expected, settings.RedirectStandardOutput);
}
/// <summary>
/// Process the type with the provided settings.
/// </summary>
/// <param name="input"> The input to process. </param>
/// <param name="settings"> The settings to configure the process. </param>
/// <returns> The result of the type processing. </returns>
public TimeSpan Process(TimeSpan input, ProcessSettings settings)
{
return(input);
}
/// <summary>
/// Runs the dotnet cli command using the specified settings and arguments.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processSettings">The processSettings.</param>
protected void RunCommand(TSettings settings, ProcessArgumentBuilder arguments, ProcessSettings processSettings)
{
// add arguments common to all commands last
AppendCommonArguments(arguments, settings);
Run(settings, arguments, processSettings, null);
}
public DateTime Process(DateTime input, ProcessSettings settings)
{
return(input);
}
/// <summary><p>One of ReSharper's most notable features, code inspection, is available even without opening Visual Studio. InspectCode, a free command line tool requires a minimum of one parameter- your solution file- to apply all of ReSharper's inspections.</p><p>For more details, visit the <a href="https://www.jetbrains.com/help/resharper/InspectCode.html/">official website</a>.</p></summary>
public static void InspectCode(string targetPath, Configure <InspectCodeSettings> configurator = null, ProcessSettings processSettings = null)
{
configurator = configurator ?? (x => x);
InspectCode(x => configurator(x).SetTargetPath(targetPath));
}
public ToolFixtureResult(FilePath toolPath, ProcessSettings process)
{
_toolPath = toolPath;
_args = process.Arguments.Render();
_process = process;
}
protected override ToolFixtureResult CreateResult(FilePath path, ProcessSettings process)
{
return(new ToolFixtureResult(path, process));
}
/// <summary><p>GitVersion is a tool to help you achieve Semantic Versioning on your project.</p><p>For more details, visit the <a href="http://gitversion.readthedocs.io/en/stable/">official website</a>.</p></summary>
public static GitVersion GitVersion(Configure <GitVersionSettings> configurator = null, ProcessSettings processSettings = null)
{
var toolSettings = configurator.InvokeSafe(new GitVersionSettings());
PreProcess(toolSettings);
var process = ProcessTasks.StartProcess(toolSettings, processSettings);
process.AssertZeroExitCode();
PostProcess(toolSettings);
return(GetResult(process, toolSettings, processSettings));
}