public void Run(TerraformApplySettings settings)
{
var builder = new ProcessArgumentBuilder()
.Append("apply");
// Order of AutoApprove and Plan are important.
if (settings.AutoApprove)
{
builder.Append("-auto-approve");
}
// Use Plan if it exists.
if (settings.Plan != null)
{
builder.Append(settings.Plan.FullPath);
}
if (!string.IsNullOrEmpty(settings.InputVariablesFile))
{
builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}");
}
if (settings.InputVariables != null)
{
foreach (var inputVariable in settings.InputVariables)
{
builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}");
}
}
Run(settings, builder);
}
public void Run(TerraformPlanSettings settings)
{
var builder = new ProcessArgumentBuilder()
.Append("plan")
.Append($"-out={settings.OutFile}")
.Append("-detailed-exitcode");
if (settings.Parallelism > 0)
{
builder = builder.Append($"-parallelism={settings.Parallelism}");
}
if (settings.Destroy)
{
builder = builder.Append("-destroy");
}
if (!string.IsNullOrEmpty(settings.InputVariablesFile))
{
builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}");
}
if (settings.InputVariables != null)
{
foreach (var inputVariable in settings.InputVariables)
{
builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}");
}
}
Run(settings, builder);
}
/// <summary>
/// Evaluates the settings and writes them to <paramref name="args"/>.
/// </summary>
/// <param name="args">The argument builder into which the settings should be written.</param>
protected override void EvaluateCore(ProcessArgumentBuilder args)
{
const string separator = " ";
base.EvaluateCore(args);
if (string.IsNullOrWhiteSpace(Library))
{
throw new ArgumentNullException(nameof(Library), $"Missing required {nameof(Library)} property.");
}
args.Append(Library);
if (Destination != null)
{
args.AppendSwitchQuoted("--destination", separator, Destination.FullPath);
}
if (Provider != CdnProvider.Default)
{
args.AppendSwitch("--provider", separator, Provider.ToString());
}
foreach (var file in Files)
{
args.AppendSwitchQuoted("--files", separator, file.FullPath);
}
}
public void Run(TerraformApplySettings settings)
{
var builder = new ProcessArgumentBuilder()
.Append("apply");
// Order of AutoApprove and Plan are important.
if (settings.AutoApprove)
{
builder.Append("-auto-approve");
}
// Use Plan if it exists.
if (settings.Plan != null)
{
builder.AppendQuoted(settings.Plan.FullPath);
}
if (settings.Parallelism != default(int))
{
builder.AppendSwitch("-parallelism", "=", settings.Parallelism.ToString());
}
if (!string.IsNullOrWhiteSpace(settings.InputVariablesFile))
{
builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}");
}
foreach (var inputVariable in settings.InputVariables ?? new Dictionary <string, string>())
{
builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}");
}
Run(settings, builder);
}
internal static ProcessArgumentBuilder BuildForWindows(this AzCopySettings settings, string source, string destination)
{
var args = new ProcessArgumentBuilder();
args.AppendSwitchQuoted("/Source", ":", source);
args.AppendSwitchQuoted("/Dest", ":", destination);
args = settings.BuildWindowsArguments(args);
return(args);
}
internal static ProcessArgumentBuilder BuildForLinux(this AzCopySettings settings, string source, string destination)
{
var args = new ProcessArgumentBuilder();
args.AppendSwitchQuoted("--source", source);
args.AppendSwitchQuoted("--destination", destination);
args = settings.BuildLinuxArguments(args);
return(args);
}
private ProcessArgumentBuilder GetArguments(FilePath scriptFile, InnoSetupSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Defines (/Ddefine[=value]
if (settings.Defines != null)
{
foreach (var item in settings.Defines)
{
builder.Append(string.IsNullOrEmpty(item.Value)
? string.Format(CultureInfo.InvariantCulture, "/D{0}", item.Key)
: string.Format(CultureInfo.InvariantCulture, "/D{0}={1}", item.Key,
new QuotedArgument(new TextArgument(item.Value))));
}
}
// Enable output
if (settings.EnableOutput.HasValue)
{
builder.Append(settings.EnableOutput.Value ? "/O+" : "/O-");
}
// Output directory
if (settings.OutputDirectory != null)
{
builder.AppendSwitchQuoted("/O", string.Empty, settings.OutputDirectory.MakeAbsolute(_environment).FullPath);
}
// Output base file name
if (!string.IsNullOrEmpty(settings.OutputBaseFilename))
{
builder.AppendSwitchQuoted("/F", string.Empty, settings.OutputBaseFilename);
}
// Quiet mode
switch (settings.QuietMode)
{
case InnoSetupQuietMode.Off:
break;
case InnoSetupQuietMode.Quiet:
builder.Append("/Q");
break;
case InnoSetupQuietMode.QuietWithProgress:
builder.Append("/Qp");
break;
default:
throw new ArgumentOutOfRangeException();
}
// Quoted Script file
builder.AppendQuoted(scriptFile.MakeAbsolute(_environment).FullPath);
return(builder);
}
/// <summary>
/// Assemble the args to pass to sc.exe
/// </summary>
/// <param name="computer"></param>
/// <param name="settings"></param>
/// <returns></returns>
public ProcessArgumentBuilder CreateInstallArguments(string computer, InstallSettings settings)
{
ProcessArgumentBuilder args = new ProcessArgumentBuilder();
string pathArgs = "";
if (settings.Arguments != null)
{
pathArgs = settings.Arguments.Render();
}
this.SetFilePath(computer, settings);
if (!String.IsNullOrEmpty(settings.ServiceName))
{
args.AppendQuoted(settings.ServiceName);
}
if (String.IsNullOrEmpty(pathArgs))
{
args.AppendSwitchQuoted("binPath=", " ", settings.ExecutablePath.FullPath);
}
else
{
args.AppendSwitch("binPath=", " ", "'" + @"\""" + settings.ExecutablePath.FullPath + @"\"" " + pathArgs.Replace("\"", "\\\"") + "'");
}
if (!String.IsNullOrEmpty(settings.DisplayName))
{
args.AppendSwitchQuoted("DisplayName=", " ", settings.DisplayName);
}
if (!String.IsNullOrEmpty(settings.Dependencies))
{
args.AppendSwitchQuoted("depend=", " ", settings.Dependencies);
}
if (!String.IsNullOrEmpty(settings.StartMode))
{
args.AppendSwitchQuoted("start=", " ", settings.StartMode);
}
if (!String.IsNullOrEmpty(settings.Username))
{
args.AppendSwitchQuoted("obj=", " ", settings.Username);
}
if (!String.IsNullOrEmpty(settings.Password))
{
args.AppendSwitchQuotedSecret("password="******" ", settings.Password);
}
return(args);
}
internal static void AppendSettings(
this ProcessArgumentBuilder arguments,
CurlSettings settings)
{
if (settings.Verbose)
{
arguments.Append("--verbose");
}
if (settings.ProgressBar)
{
arguments.Append("--progress-bar");
}
if (settings.Username != null)
{
arguments.AppendSwitchQuoted(
"--user",
$"{settings.Username}:{settings.Password}");
}
if (settings.Insecure)
{
arguments.Append("--insecure");
}
if (settings.CaCertFile != null)
{
arguments.AppendSwitchQuoted(
"--cacert",
$"{settings.CaCertFile}");
}
if (settings.Headers != null)
{
foreach (var item in settings.Headers)
{
arguments.AppendSwitchQuoted(
"--header",
$"{item.Key}:{item.Value}");
}
}
if (settings.RequestCommand != null)
{
arguments.AppendSwitchQuoted(
"--request",
settings.RequestCommand.ToUpperInvariant());
}
if (settings.FollowRedirects)
{
arguments.Append("--location");
}
}
/// <summary>
/// Outputs the reporter-specific settings to include in the invocation
/// </summary>
/// <returns>A string to be appended to the run command.</returns>
public void RenderOptions(ProcessArgumentBuilder args)
{
if (OutputFile != null)
{
args.AppendSwitchQuoted(ReporterArgumentNames.Html.Export, OutputFile.FullPath);
}
if (TemplateFile != null)
{
args.AppendSwitchQuoted(ReporterArgumentNames.Html.Template, TemplateFile.FullPath);
}
}
private ProcessArgumentBuilder GetArguments(OpenshiftDeleterSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("delete");
if (!string.IsNullOrEmpty(settings.ObjectType))
{
builder.Append(settings.ObjectType);
}
if (!string.IsNullOrEmpty(settings.ObjectName))
{
builder.Append(settings.ObjectName);
}
if (!string.IsNullOrEmpty(settings.Label))
{
builder.AppendSwitchQuoted("--selector", "=", settings.Label);
}
if (settings.All)
{
builder.Append("--all");
}
// no need to specify "ignore-not-found" when the all option is set
if (settings.IgnoreNotFound && !settings.All)
{
builder.Append("--ignore-not-found");
}
return(builder);
}
private ProcessArgumentBuilder GetGradleArguments()
{
// USAGE: gradle [option...] [task...]
var args = new ProcessArgumentBuilder();
AppendLogLevel(args);
foreach (var property in _properties)
{
var prefix = property.PropertyType == GradleProperty.Type.System ? "-D" : "-P";
var key = prefix + property.Key;
if (property.SecretValue)
{
args.AppendSwitchQuotedSecret(key, "=", property.Value);
}
else
{
args.AppendSwitchQuoted(key, "=", property.Value);
}
}
foreach (var arg in _arguments)
{
args.Append(arg.Trim());
}
if (!string.IsNullOrWhiteSpace(_tasks))
{
args.Append(_tasks.Trim());
}
return(args);
}
private static void AddValue(ProcessArgumentBuilder builder, string key, string value, bool onlyAppendValue = false)
{
if (key.StartsWith("!", StringComparison.OrdinalIgnoreCase))
{
if (onlyAppendValue)
{
builder.AppendQuoted(value);
}
else
{
builder.AppendSwitchQuotedSecret(key.TrimStart('!'), " ", value);
}
}
else
{
if (onlyAppendValue)
{
builder.AppendQuoted(value);
}
else
{
builder.AppendSwitchQuoted(key, " ", value);
}
}
}
private static void AddValue(ProcessArgumentBuilder args, string key, string value)
{
var quote = value.IndexOfAny(new[] { ' ', '*' }) >= 0;
if (key.StartsWith("!", StringComparison.OrdinalIgnoreCase))
{
if (quote)
{
args.AppendSwitchQuotedSecret(key.TrimStart('!'), value);
}
else
{
args.AppendSwitchSecret(key.TrimStart('!'), value);
}
}
else
{
if (quote)
{
args.AppendSwitchQuoted(key, value);
}
else
{
args.AppendSwitch(key, value);
}
}
}
public void Run(TerraformInitSettings settings)
{
var builder =
new ProcessArgumentBuilder()
.Append("init");
if (settings.BackendConfigOverrides != null)
{
foreach (var pair in settings.BackendConfigOverrides)
{
// https://www.terraform.io/docs/commands/init.html#backend-config-value
builder.AppendSwitchQuoted("-backend-config", $"{pair.Key}={pair.Value}");
}
}
if (settings.ForceCopy)
{
builder.Append("-force-copy");
}
if (settings.ForceReconfigure)
{
builder.Append("-reconfigure");
}
Run(settings, builder);
}
private ProcessArgumentBuilder GetArguments(
FilePath coverageFile,
FilePath testProject,
CoverletSettings settings)
{
var argumentBuilder = new ProcessArgumentBuilder();
argumentBuilder.AppendQuoted(coverageFile.MakeAbsolute(_environment).FullPath);
argumentBuilder.AppendSwitchQuoted("--target", "dotnet");
argumentBuilder.AppendSwitchQuoted($"--targetargs", $"test {testProject.MakeAbsolute(_environment)} --no-build");
ArgumentsProcessor.ProcessToolArguments(settings, _environment, argumentBuilder, testProject);
return(argumentBuilder);
}
private ProcessArgumentBuilder GetArguments(CMakeBuildSettings settings)
{
var builder = new ProcessArgumentBuilder();
var binaryPath = settings.BinaryPath.MakeAbsolute(_environment);
builder.AppendSwitchQuoted("--build", binaryPath.FullPath);
// Generator
if (settings.CleanFirst)
{
builder.Append("--clean-first");
}
// Toolset
if (settings.Targets != null)
{
builder.AppendSwitch("--target", string.Join(",", settings.Targets));
}
// Options
if (settings.Options != null)
{
foreach (string option in settings.Options)
{
builder.AppendQuoted(option);
}
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath[] assemblies, FilePath outputPath, MonoApiInfoToolSettings settings)
{
var builder = new ProcessArgumentBuilder();
if (settings.GenerateAbi)
{
builder.Append("--abi");
}
if (settings.FollowForwarders)
{
builder.Append("--follow-forwarders");
}
if (settings.SearchPaths?.Length > 0)
{
foreach (var path in settings.SearchPaths)
{
builder.AppendSwitchQuoted("--search-directory", "=", path.MakeAbsolute(environment).FullPath);
}
}
if (settings.ResolvePaths?.Length > 0)
{
foreach (var path in settings.ResolvePaths)
{
builder.AppendSwitchQuoted("-r", "=", path.MakeAbsolute(environment).FullPath);
}
}
if (outputPath != null)
{
builder.AppendSwitchQuoted("-o", "=", outputPath.MakeAbsolute(environment).FullPath);
}
if (settings.GenerateContractApi)
{
builder.Append("--contract-api");
}
foreach (var assembly in assemblies)
{
builder.AppendQuoted(assembly.MakeAbsolute(environment).FullPath);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string packageId, DotNetCoreGlobalToolInstallSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("tool");
builder.Append("install");
builder.Append("-g");
if (settings.Version != null)
{
builder.AppendSwitchQuoted("--version", settings.Version);
}
if (settings.ConfigFile != null)
{
builder.AppendSwitchQuoted("--configfile", settings.ConfigFile);
}
if (settings.Source != null)
{
builder.AppendSwitchQuoted("--add-source", settings.Source);
}
if (settings.Framework != null)
{
builder.AppendSwitchQuoted("--framework", settings.Framework);
}
if (settings.DisableParallel)
{
builder.Append("--disable-parallel");
}
if (settings.IgnoreFailedSources)
{
builder.Append("--ignore-failed-sources");
}
if (settings.NoCache)
{
builder.Append("--no-cache");
}
builder.AppendQuoted(packageId);
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath solution, MSBuildSettings settings)
{
var builder = new ProcessArgumentBuilder();
// Set the maximum number of processors?
if (settings.MaxCpuCount != null)
{
builder.Append(settings.MaxCpuCount > 0 ? string.Concat("/m:", settings.MaxCpuCount) : "/m");
}
// Set the verbosity.
builder.Append(string.Format(CultureInfo.InvariantCulture, "/v:{0}", GetVerbosityName(settings.Verbosity)));
if (settings.NodeReuse != null)
{
builder.Append(string.Concat("/nr:", settings.NodeReuse.Value ? "true" : "false"));
}
// Got a specific configuration in mind?
if (!string.IsNullOrWhiteSpace(settings.Configuration))
{
// Add the configuration as a property.
builder.AppendSwitchQuoted("/p:Configuration", "=", settings.Configuration);
}
// Build for a specific platform?
if (settings.PlatformTarget.HasValue)
{
var platform = settings.PlatformTarget.Value;
bool isSolution = string.Equals(solution.GetExtension(), ".sln", StringComparison.OrdinalIgnoreCase);
builder.Append(string.Concat("/p:Platform=", GetPlatformName(platform, isSolution)));
}
// Got any properties?
if (settings.Properties.Count > 0)
{
foreach (var property in GetPropertyArguments(settings.Properties))
{
builder.Append(property);
}
}
// Got any targets?
if (settings.Targets.Count > 0)
{
var targets = string.Join(";", settings.Targets);
builder.Append(string.Concat("/target:", targets));
}
else
{
// Use default target.
builder.Append("/target:Build");
}
// Add the solution as the last parameter.
builder.AppendQuoted(solution.MakeAbsolute(_environment).FullPath);
return(builder);
}
/// <summary>
/// Quotes and appends the specified secret text to the argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="switch">The switch preceding the text.</param>
/// <param name="separator">The separator between the switch and argument</param>
/// <param name="argument">The secret argument to be appended.</param>
/// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns>
public static ProcessArgumentBuilder AppendQuotedSecret(this ProcessArgumentBuilder builder, string @switch, string separator, IProcessArgument argument)
{
if (builder != null)
{
builder.AppendSwitchQuoted(@switch, separator, new SecretArgument(argument));
}
return(builder);
}
internal static ProcessArgumentBuilder AppendSwitchQuoted(this ProcessArgumentBuilder builder, string @switch, IEnumerable <string> values)
{
foreach (var type in values.Select(s => s.Trim()))
{
builder.AppendSwitchQuoted(@switch, type);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(CodeCoverageSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append(settings.command.ToString());
builder.AppendSwitchQuoted($"/output", ":", settings.OutputPath);
builder.AppendQuoted(settings.CoveragePath);
return(builder);
}
public void Run(TerraformApplySettings settings)
{
var builder = new ProcessArgumentBuilder().Append("apply");
if (!string.IsNullOrEmpty(settings.InputVariablesFile))
{
builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}");
}
if (settings.InputVariables != null)
{
foreach (var inputVariable in settings.InputVariables)
{
builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}");
}
}
Run(settings, builder);
}
private ProcessArgumentBuilder GetArguments(FilePath sourceFilePath, TextTransformSettings settings)
{
var builder = new ProcessArgumentBuilder();
if (settings.OutputFile != null)
{
builder.Append("-out");
builder.AppendQuoted(settings.OutputFile.MakeAbsolute(_environment).FullPath);
}
if (!string.IsNullOrEmpty(settings.Assembly))
{
builder.Append("-r");
builder.Append(settings.Assembly);
}
if (!string.IsNullOrEmpty(settings.Namespace))
{
builder.Append("-u");
builder.Append(settings.Namespace);
}
if (settings.ReferencePath != null)
{
builder.Append("-P");
builder.AppendQuoted(settings.ReferencePath.MakeAbsolute(_environment).FullPath);
}
if (settings.IncludeDirectory != null)
{
builder.Append("-I");
builder.AppendQuoted(settings.IncludeDirectory.MakeAbsolute(_environment).FullPath);
}
if (settings.Class != null)
{
builder.AppendSwitchQuoted(
"--class",
"=",
settings.Class);
}
if (settings.Properties != null)
{
foreach (var property in settings.Properties)
{
builder.Append(
$"-p:{property.Key.Quote()}={property.Value.Quote()}");
}
}
builder.AppendQuoted(sourceFilePath.MakeAbsolute(_environment).FullPath);
return(builder);
}
/// <inheritdoc />
public void BuildArguments(ref ProcessArgumentBuilder builder)
{
if (SfxModule != null)
{
builder.AppendSwitchQuoted("-sfx", string.Empty, SfxModule.FullPath);
}
else
{
builder.Append("-sfx");
}
}
internal override ProcessArgumentBuilder Apply(ProcessArgumentBuilder builder)
{
builder = base.Apply(builder);
foreach (var kvp in Config ?? Enumerable.Empty <KeyValuePair <string, string> >())
{
builder.AppendSwitchQuoted("--config", $"{kvp.Key}={kvp.Value}");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath firstInfo, FilePath secondInfo, FilePath outputPath, MonoApiDiffToolSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.AppendSwitchQuoted("--output", "=", outputPath.MakeAbsolute(environment).FullPath);
builder.AppendQuoted(firstInfo.MakeAbsolute(environment).FullPath);
builder.AppendQuoted(secondInfo.MakeAbsolute(environment).FullPath);
return(builder);
}
internal void Evaluate(ProcessArgumentBuilder args)
{
if (GruntFile != null)
{
args.AppendSwitchQuoted("--gruntfile", GruntFile.FullPath);
}
if (!string.IsNullOrWhiteSpace(Arguments))
{
args.Append(Arguments);
}
EvaluateCore(args);
}
public void Run(TerraformDestroySettings settings)
{
var builder = new ProcessArgumentBuilder().Append("destroy");
if (settings.Force)
{
builder = builder.Append("-force");
}
if (!string.IsNullOrWhiteSpace(settings.InputVariablesFile))
{
builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}");
}
foreach (var inputVariable in settings.InputVariables ?? new Dictionary <string, string>())
{
builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}");
}
Run(settings, builder);
}
