private ProcessArgumentBuilder GetArguments(
IEnumerable <FilePath> sourceFiles,
FilePath outputFile,
DotCoverMergeSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Merge");
// Set configuration file if exists.
GetConfigurationFileArgument(settings).CopyTo(builder);
// Set the Source files.
var source = string.Join(";", sourceFiles.Select(s => s.MakeAbsolute(_environment).FullPath));
builder.AppendSwitch("/Source", "=", source.Quote());
// Set the Output file.
outputFile = outputFile.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputFile.FullPath.Quote());
// Get Global settings
GetArguments(settings).CopyTo(builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(
ICakeContext context,
Action <ICakeContext> action,
DotCoverAnalyseSettings settings,
FilePath outputPath)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Analyse");
// Set configuration file if exists.
GetConfigurationFileArgument(settings).CopyTo(builder);
// Get Target executable arguments
GetTargetArguments(context, action).CopyTo(builder);
// Set the output file.
outputPath = outputPath.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote());
// Set the report type, don't include the default value
if (settings.ReportType != DotCoverReportType.XML)
{
builder.AppendSwitch("/ReportType", "=", settings.ReportType.ToString());
}
// Get Coverage arguments
GetCoverageArguments(settings).CopyTo(builder);
// Get base arguments
GetArguments(settings).CopyTo(builder);
return(builder);
}
/// <summary>
/// Appends the SpecFlowSettings arguments to builder.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="builder">The argument builder.</param>
protected void AppendArguments(
SpecFlowSettings settings,
ProcessArgumentBuilder builder)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (builder == null)
{
throw new ArgumentNullException("builder");
}
// Set the out file.
if (settings.Out != null)
{
var outFile = settings.Out.MakeAbsolute(_environment);
builder.AppendSwitch("/out", ":", outFile.FullPath.Quote());
}
// Set the xslt file.
if (settings.XsltFile != null)
{
var xsltFile = settings.XsltFile.MakeAbsolute(_environment);
builder.AppendSwitch("/xsltFile", ":", xsltFile.FullPath.Quote());
}
}
private ProcessArgumentBuilder GetArguments(
FilePath sourceFile,
FilePath outputFile,
DotCoverReportSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Report");
// Set the Source file.
sourceFile = sourceFile.MakeAbsolute(_environment);
builder.AppendSwitch("/Source", "=", sourceFile.FullPath.Quote());
// Set the Output file.
outputFile = outputFile.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputFile.FullPath.Quote());
// Set the report type, don't include the default value
if (settings.ReportType != DotCoverReportType.XML)
{
builder.AppendSwitch("/ReportType", "=", settings.ReportType.ToString());
}
// Get Global settings
GetArguments(settings).CopyTo(builder);
return(builder);
}
private void AppendLogLevel(ProcessArgumentBuilder args, LibManVerbosity verbosity)
{
const string @switch = "--verbosity";
const string separator = " ";
if (verbosity == LibManVerbosity.Default && CakeVerbosityLevel.HasValue)
{
verbosity = CakeToLibManLogLevelConverter(CakeVerbosityLevel.Value);
}
switch (verbosity)
{
case LibManVerbosity.Default:
break;
case LibManVerbosity.Normal:
args.AppendSwitch(@switch, separator, "normal");
break;
case LibManVerbosity.Detailed:
args.AppendSwitch(@switch, separator, "detailed");
break;
case LibManVerbosity.Quiet:
args.AppendSwitch(@switch, separator, "quiet");
break;
}
}
private ProcessArgumentBuilder GetArguments(
DotCoverContext context,
DotCoverCoverSettings settings,
FilePath outputPath)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Cover");
// The target application to call.
builder.AppendSwitch("/TargetExecutable", "=", context.FilePath.FullPath.Quote());
// The arguments to the target application.
var arguments = context.Settings?.Arguments?.Render();
if (!string.IsNullOrWhiteSpace(arguments))
{
arguments = arguments.Replace("\"", "\\\"");
builder.AppendSwitch("/TargetArguments", "=", arguments.Quote());
}
// Set the output file.
outputPath = outputPath.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote());
// Set common Coverage settings
settings.ToArguments(_environment).CopyTo(builder);
return(builder);
}
private static void AddSwitchArguments(ProcessArgumentBuilder builder, AppPackagerSettings settings)
{
builder.AppendSwitch(settings.Localized, "l");
builder.AppendSwitch(settings.OverwriteOutput, "o");
builder.AppendSwitch(settings.PreventOverwriteOutput, "no");
builder.AppendSwitch(settings.SkipSemanticValidation, "nv");
builder.AppendSwitch(settings.EnableVerboseLogging, "v");
}
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 TextArgument(item.Value)));
}
}
// Enable output
if (settings.EnableOutput.HasValue)
{
builder.Append(settings.EnableOutput.Value ? "/O+" : "/O-");
}
// Output directory
if (settings.OutputDirectory != null)
{
builder.AppendSwitch("/O", string.Empty, settings.OutputDirectory.MakeAbsolute(_environment).FullPath);
}
// Output base file name
if (!string.IsNullOrEmpty(settings.OutputBaseFilename))
{
builder.AppendSwitch("/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.Append(scriptFile.MakeAbsolute(_environment).FullPath);
return(builder);
}
/// <summary>
/// Builds the complete arguments for invoking newman
/// </summary>
/// <param name="args">The argument builder.</param>
public void Build(ProcessArgumentBuilder args)
{
if (EnvironmentFile != null)
{
args.AppendSwitchQuoted(ArgumentNames.Environment, EnvironmentFile.FullPath);
}
if (GlobalVariablesFile != null)
{
args.AppendSwitchQuoted(ArgumentNames.Globals, GlobalVariablesFile.FullPath);
}
if (!string.IsNullOrWhiteSpace(Folder))
{
args.AppendSwitchQuoted(ArgumentNames.Folder, Folder);
}
if (ExportEnvironmentPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportEnvironment, ExportEnvironmentPath.FullPath);
}
if (ExportGlobalsPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportGlobals, ExportGlobalsPath.FullPath);
}
if (ExportCollectionPath != null)
{
args.AppendSwitchQuoted(ArgumentNames.ExportCollection, ExportCollectionPath.FullPath);
}
if (RequestTimeout != default(int))
{
args.AppendSwitch(ArgumentNames.RequestTimeout, RequestTimeout.ToString());
}
if (DisableStrictSSL)
{
args.Append(ArgumentNames.Insecure);
}
if (IgnoreRedirects)
{
args.Append(ArgumentNames.IgnoreRedirects);
}
if (RequestDelay != default(int))
{
args.AppendSwitch(ArgumentNames.RequestDelay, RequestDelay.ToString());
}
if (ExitOnFirstFailure)
{
args.Append(ArgumentNames.Bail);
}
if (Reporters.Any())
{
args.AppendSwitch(ArgumentNames.Reporters,
string.Join(",", Reporters.Keys.Select(k => k.Trim())));
foreach (var reporter in Reporters)
{
reporter.Value?.RenderOptions(args);
}
}
}
private ProcessArgumentBuilder GetArguments(
OpenCoverContext context,
OpenCoverSettings settings,
FilePath outputPath)
{
var builder = new ProcessArgumentBuilder();
// The target application to call.
builder.AppendSwitch("-target", ":", context.FilePath.FullPath.Quote());
// The arguments to the target application.
if (context.Settings != null && context.Settings.Arguments != null)
{
var arguments = context.Settings.Arguments.Render();
if (!string.IsNullOrWhiteSpace(arguments))
{
arguments = arguments.Replace("\"", "\\\"");
builder.AppendSwitch("-targetargs", ":", arguments.Quote());
}
}
// Filters
if (settings.Filters.Count > 0)
{
var filters = string.Join(" ", settings.Filters);
builder.AppendSwitch("-filter", ":", filters.Quote());
}
// Exclude by attribute
if (settings.ExcludedAttributeFilters.Count > 0)
{
var filters = string.Join(";", settings.ExcludedAttributeFilters);
builder.AppendSwitch("-excludebyattribute", ":", filters.Quote());
}
// Exclude by file
if (settings.ExcludedFileFilters.Count > 0)
{
var filters = string.Join(";", settings.ExcludedFileFilters);
builder.AppendSwitch("-excludebyfile", ":", filters.Quote());
}
if (settings.SkipAutoProps)
{
builder.Append("-skipautoprops");
}
builder.AppendSwitch("-register", ":", settings.Register);
if (settings.ReturnTargetCodeOffset != null)
{
builder.AppendSwitch("-returntargetcode", ":", settings.ReturnTargetCodeOffset.Value.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
// Set the output file.
outputPath = outputPath.MakeAbsolute(_environment);
builder.AppendSwitch("-output", ":", outputPath.FullPath.Quote());
return(builder);
}
/// <summary>
/// Applies the settings to the process arguments ready for execution.
/// </summary>
/// <param name="args">The builder to apply the settings to.</param>
protected override void EvaluateCore(ProcessArgumentBuilder args)
{
base.EvaluateCore(args);
if (AutoWatch)
{
args.Append("--auto-watch");
}
if (NoAutoWatch)
{
args.Append("--no-auto-watch");
}
if (Detached)
{
args.Append("--detached");
}
if (SingleRun)
{
args.Append("--single-run");
}
if (NoSingleRun)
{
args.Append("--no-single-run");
}
if (CaptureTimeout.HasValue)
{
args.AppendSwitch("--capture-timeout", CaptureTimeout.Value.ToString());
}
if (ReportSlowerThan.HasValue)
{
args.AppendSwitch("--report-slower-than", ReportSlowerThan.Value.ToString());
}
if (Reporters != null && Reporters.Count > 0)
{
args.AppendSwitch("--reporters", string.Join(",", Reporters.Select(_ => _.ToString().ToLower())));
}
if (Browsers != null && Browsers.Count > 0)
{
args.AppendSwitch("--browsers", string.Join(",", Browsers));
}
}
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);
}
}
}
internal static ProcessArgumentBuilder GetMSTestArguments(this SpecFlowContext context,
FilePath projectFile,
ICakeEnvironment environment)
{
var builder = new ProcessArgumentBuilder();
builder.Append("mstestexecutionreport");
// Set the project file
builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath);
var arguments = context.RenderArguments();
// Set the test result
var testResultMatch = Regex.Match(arguments, "\\/resultsfile:\\s*((?:\".+?\"|[^\\s]+))", RegexOptions.IgnoreCase);
if (testResultMatch.Success && testResultMatch.Groups[1].Success)
{
builder.AppendSwitch("/testResult", ":", testResultMatch.Groups[1].Value);
}
else
{
throw new CakeException("MSTest must contain argument \"/resultsfile:<filename>\"");
}
return(builder);
}
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);
}
/// <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);
}
public static void AppendSwitch(this ProcessArgumentBuilder builder, bool include, string text)
{
if (include)
{
builder.AppendSwitch("/", text);
}
}
private ProcessArgumentBuilder GetArguments(
ICakeContext context,
Action <ICakeContext> action,
DotCoverCoverSettings settings,
FilePath outputPath)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Cover");
// Set configuration file if exists.
GetConfigurationFileArgument(settings).CopyTo(builder);
// Get Target executable arguments
GetTargetArguments(context, action).CopyTo(builder);
// Set the output file.
outputPath = outputPath.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote());
// Get Coverage arguments
GetCoverageArguments(settings).CopyTo(builder);
// Get base arguments
GetArguments(settings).CopyTo(builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(
IEnumerable <Uri> hosts,
CurlDownloadSettings settings)
{
var arguments = new ProcessArgumentBuilder();
arguments.AppendSettings(settings);
if (settings.OutputPaths != null)
{
foreach (var arg in JoinHostsAndOutputPaths(hosts, settings.OutputPaths))
{
arguments.Append(arg);
}
}
else
{
foreach (var host in hosts)
{
arguments.AppendSwitch("-O", host.AbsoluteUri);
}
}
return(arguments);
}
internal static ProcessArgumentBuilder GetXUnitArguments(this SpecFlowContext context,
FilePath projectFile,
ICakeEnvironment environment)
{
var builder = new ProcessArgumentBuilder();
builder.Append("nunitexecutionreport");
// Set the project file
builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath);
var arguments = RenderArguments(context);
// Set the xml test result
var xmlTestResultMatch = Regex.Match(arguments, "-nunit\\s+((?:\".+?\"|.*))", RegexOptions.IgnoreCase);
if (xmlTestResultMatch.Success && xmlTestResultMatch.Groups[1].Success)
{
builder.AppendSwitch("/xmlTestResult", ":", xmlTestResultMatch.Groups[1].Value);
}
else
{
throw new CakeException("XUnit2 must contain argument \"-nunit <filename>\"");
}
return(builder);
}
internal static ProcessArgumentBuilder GetNUnitArguments(this SpecFlowContext context,
FilePath projectFile,
ICakeEnvironment environment)
{
var builder = new ProcessArgumentBuilder();
builder.Append("nunitexecutionreport");
// Set the project file
builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath);
var arguments = context.RenderArguments();
// Set the xml test result
var xmlTestResultMatch = Regex.Match(arguments, "\"--result=([^;]+);format=nunit2", RegexOptions.IgnoreCase);
if (xmlTestResultMatch.Success && xmlTestResultMatch.Groups[1].Success)
{
builder.AppendSwitch("/xmlTestResult", ":", xmlTestResultMatch.Groups[1].Value.Quote());
}
else
{
throw new CakeException("NUnit3 must contain argument \"--result=<filename>;format=nunit2\"");
}
// Set the test output
var testOutputMatch = Regex.Match(arguments, "\"--out=([^\"]+)\"", RegexOptions.IgnoreCase);
if (testOutputMatch.Success && testOutputMatch.Groups[1].Success)
{
builder.AppendSwitch("/testOutput", ":", testOutputMatch.Groups[1].Value.Quote());
}
else
{
throw new CakeException("NUnit3 must contain argument \"--out=<filename>\"");
}
// Check for labels switch
var testLabelsMatch = Regex.Match(arguments, "--labels=All", RegexOptions.IgnoreCase);
if (!testLabelsMatch.Success)
{
throw new CakeException("NUnit3 must contain argument \"--labels=All\"");
}
return(builder);
}
internal static ProcessArgumentBuilder AppendSwitch(this ProcessArgumentBuilder builder, string @switch, IEnumerable <string> values)
{
foreach (var type in values.Select(s => s.Trim()))
{
builder.AppendSwitch(@switch, type);
}
return(builder);
}
internal static ProcessArgumentBuilder ToArguments(this DotCoverSettings settings, ICakeEnvironment environment)
{
var builder = new ProcessArgumentBuilder();
// TargetWorkingDir
if (settings.TargetWorkingDir != null)
{
builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(environment).FullPath.Quote());
}
// Scope
if (settings.Scope.Count > 0)
{
var scope = string.Join(";", settings.Scope);
builder.AppendSwitch("/Scope", "=", scope.Quote());
}
// Filters
if (settings.Filters.Count > 0)
{
var filters = string.Join(";", settings.Filters);
builder.AppendSwitch("/Filters", "=", filters.Quote());
}
// Filters
if (settings.AttributeFilters.Count > 0)
{
var attributeFilters = string.Join(";", settings.AttributeFilters);
builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote());
}
// DisableDefaultFilters
if (settings.DisableDefaultFilters)
{
builder.Append("/DisableDefaultFilters");
}
// LogFile
if (settings.LogFile != null)
{
var logFilePath = settings.LogFile.MakeAbsolute(environment);
builder.AppendSwitch("/LogFile", "=", logFilePath.FullPath.Quote());
}
return(builder);
}
/// <summary>
/// Get arguments from coverage settings.
/// </summary>
/// <param name="settings">The settings.</param>
/// <returns>The process arguments.</returns>
protected ProcessArgumentBuilder GetCoverageArguments(DotCoverCoverageSettings settings)
{
var builder = new ProcessArgumentBuilder();
// TargetWorkingDir
if (settings.TargetWorkingDir != null)
{
builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(_environment).FullPath.Quote());
}
// Scope
if (settings.Scope.Count > 0)
{
var scope = string.Join(";", settings.Scope);
builder.AppendSwitch("/Scope", "=", scope.Quote());
}
// Filters
if (settings.Filters.Count > 0)
{
var filters = string.Join(";", settings.Filters);
builder.AppendSwitch("/Filters", "=", filters.Quote());
}
// AttributeFilters
if (settings.AttributeFilters.Count > 0)
{
var attributeFilters = string.Join(";", settings.AttributeFilters);
builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote());
}
// Filters
if (settings.ProcessFilters.Count > 0)
{
var processFilters = string.Join(";", settings.ProcessFilters);
builder.AppendSwitch("/ProcessFilters", "=", processFilters.Quote());
}
// DisableDefaultFilters
if (settings.DisableDefaultFilters)
{
builder.Append("/DisableDefaultFilters");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(
DotCoverContext context,
DotCoverCoverSettings settings,
FilePath outputPath)
{
var builder = new ProcessArgumentBuilder();
builder.Append("Cover");
// The target application to call.
builder.AppendSwitch("/TargetExecutable", "=", context.FilePath.FullPath.Quote());
// The arguments to the target application.
var arguments = context.Settings?.Arguments?.Render();
if (!string.IsNullOrWhiteSpace(arguments))
{
arguments = arguments.Replace("\"", "\\\"");
builder.AppendSwitch("/TargetArguments", "=", arguments.Quote());
}
// Set the output file.
outputPath = outputPath.MakeAbsolute(_environment);
builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote());
// TargetWorkingDir
if (settings.TargetWorkingDir != null)
{
builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(_environment).FullPath.Quote());
}
// Scope
if (settings.Scope.Count > 0)
{
var scope = string.Join(";", settings.Scope);
builder.AppendSwitch("/Scope", "=", scope.Quote());
}
// Filters
if (settings.Filters.Count > 0)
{
var filters = string.Join(";", settings.Filters);
builder.AppendSwitch("/Filters", "=", filters.Quote());
}
// Filters
if (settings.AttributeFilters.Count > 0)
{
var attributeFilters = string.Join(";", settings.AttributeFilters);
builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote());
}
// DisableDefaultFilters
if (settings.DisableDefaultFilters)
{
builder.Append("/DisableDefaultFilters");
}
return(builder);
}
/// <summary>
/// Adds common commandline arguments.
/// </summary>
/// <param name="builder">Process argument builder to update.</param>
/// <param name="settings">The settings.</param>
/// <returns>Returns <see cref="ProcessArgumentBuilder"/> updated with common commandline arguments.</returns>
private ProcessArgumentBuilder AppendCommonArguments(ProcessArgumentBuilder builder, TSettings settings)
{
if (!string.IsNullOrEmpty(settings.Namespace))
{
builder.AppendSwitch("--namespace", "=", settings.Namespace);
}
return(builder);
}
internal static void AppendDownloadToCurrentDirectory(
this ProcessArgumentBuilder arguments,
IEnumerable <Uri> hosts)
{
foreach (var host in hosts)
{
arguments.AppendSwitch("-O", host.AbsoluteUri);
}
}
/// <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);
}
private static ProcessArgumentBuilder BuildArguments(KnifeSettings settings)
{
var builder = new ProcessArgumentBuilder();
foreach (var kvp in settings.Options.Where(x => x.Key.StartsWith("--")))
{
builder.AppendSwitch(kvp.Key, kvp.Value);
}
return(builder);
}
private static ProcessArgumentBuilder BuildArguments(NamedPipeSettings settings)
{
var builder = new ProcessArgumentBuilder();
foreach (var kvp in settings.PipeServerArguments)
{
builder.AppendSwitch(kvp.Key, kvp.Value);
}
return(builder);
}
