public void BuildArguments(ICakeContext context, ProcessArgumentBuilder builder) { if (NoGraphics) { builder.Append("-nographics"); } builder.Append(PlatformTarget == UnityPlatformTarget.x64 ? "-buildWindows64Player" : "-buildWindowsPlayer"); builder.AppendQuoted(_outputPath.MakeAbsolute(context.Environment).FullPath); }
/// <summary> /// 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 AppendSwitchSecret(this ProcessArgumentBuilder builder, string @switch, string separator, IProcessArgument argument) { builder?.Append(new SwitchArgument(@switch, new SecretArgument(argument), separator)); return(builder); }
/// <summary> /// Appends the specified secret text to the argument builder. /// </summary> /// <param name="builder">The builder.</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 AppendSecret(this ProcessArgumentBuilder builder, IProcessArgument argument) { builder?.Append(new SecretArgument(argument)); return(builder); }
/// <summary> /// Quotes and appends the specified argument to the argument builder. /// </summary> /// <param name="builder">The builder.</param> /// <param name="argument">The argument to be quoted and appended.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> public static ProcessArgumentBuilder AppendQuoted(this ProcessArgumentBuilder builder, IProcessArgument argument) { builder?.Append(new QuotedArgument(argument)); return(builder); }
/// <summary> /// Quotes and appends the specified text to the argument builder. /// </summary> /// <param name="builder">The builder.</param> /// <param name="text">The text to be quoted and appended.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> public static ProcessArgumentBuilder?AppendQuoted(this ProcessArgumentBuilder builder, string text) { builder?.Append(new QuotedArgument(new TextArgument(text))); return(builder); }
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, NUnitSettings settings) { var builder = new ProcessArgumentBuilder(); // Add the assemblies to build. foreach (var assemblyPath in assemblyPaths) { builder.AppendQuoted(assemblyPath.MakeAbsolute(_environment).FullPath); } if (settings.Framework != null) { builder.AppendQuoted("-framework:" + settings.Framework); } if (settings.Include != null) { builder.AppendQuoted("-include:" + settings.Include); } if (settings.Exclude != null) { builder.AppendQuoted("-exclude:" + settings.Exclude); } if (settings.Timeout.HasValue) { builder.Append("-timeout:" + settings.Timeout.Value); } // No shadow copy? if (!settings.ShadowCopy) { builder.Append("-noshadow"); } if (settings.NoLogo) { builder.Append("-nologo"); } if (settings.NoThread) { builder.Append("-nothread"); } if (settings.StopOnError) { builder.Append("-stoponerror"); } if (settings.Trace != null) { builder.Append("-trace:" + settings.Trace); } if (settings.OutputFile != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "-output:{0}", settings.OutputFile.MakeAbsolute(_environment).FullPath)); } if (settings.ErrorOutputFile != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "-err:{0}", settings.ErrorOutputFile.MakeAbsolute(_environment).FullPath)); } if (settings.ResultsFile != null && settings.NoResults) { throw new ArgumentException( GetToolName() + ": You can't specify both a results file and set NoResults to true."); } if (settings.ResultsFile != null) { builder.AppendQuoted( string.Format( CultureInfo.InvariantCulture, "-result:{0}", settings.ResultsFile.MakeAbsolute(_environment).FullPath)); } else if (settings.NoResults) { builder.AppendQuoted("-noresult"); } // don't include the default value if (settings.Process != NUnitProcessOption.Single) { builder.AppendQuoted("-process:" + settings.Process); } if (settings.UseSingleThreadedApartment) { builder.AppendQuoted("-apartment:STA"); } if (settings.AppDomainUsage != NUnitAppDomainUsage.Default) { builder.AppendQuoted("-domain:" + settings.AppDomainUsage); } return(builder); }
private ProcessArgumentBuilder GetArguments(FilePath packageFilePath, ChocolateyPushSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("push"); builder.AppendQuoted(packageFilePath.MakeAbsolute(_environment).FullPath); if (settings.Source != null) { builder.Append("-s"); builder.AppendQuoted(settings.Source); } if (settings.Timeout != null) { builder.Append("-t"); builder.Append(Convert.ToInt32(settings.Timeout.Value.TotalSeconds).ToString(CultureInfo.InvariantCulture)); } if (settings.ApiKey != null) { builder.Append("-k"); builder.AppendSecret(settings.ApiKey); } // Debug if (settings.Debug) { builder.Append("-d"); } // Verbose if (settings.Verbose) { builder.Append("-v"); } // Always say yes, so as to not show interactive prompt builder.Append("-y"); // Force if (settings.Force) { builder.Append("-f"); } // Noop if (settings.Noop) { builder.Append("--noop"); } // Limit Output if (settings.LimitOutput) { builder.Append("-r"); } // Execution Timeout if (settings.ExecutionTimeout != 0) { builder.Append("--execution-timeout"); builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture)); } // Cache Location if (!string.IsNullOrWhiteSpace(settings.CacheLocation)) { builder.Append("-c"); builder.AppendQuoted(settings.CacheLocation); } // Allow Unofficial if (settings.AllowUnofficial) { builder.Append("--allowunofficial"); } return(builder); }
private ProcessArgumentBuilder GetArguments(string name, string value, ChocolateyConfigSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("config"); builder.Append("set"); builder.Append("--name"); builder.AppendQuoted(name); builder.Append("--value"); builder.AppendQuoted(value); // Debug if (settings.Debug) { builder.Append("-d"); } // Verbose if (settings.Verbose) { builder.Append("-v"); } // Always say yes, so as to not show interactive prompt builder.Append("-y"); // Force if (settings.Force) { builder.Append("-f"); } // Noop if (settings.Noop) { builder.Append("--noop"); } // Limit Output if (settings.LimitOutput) { builder.Append("-r"); } // Execution Timeout if (settings.ExecutionTimeout != 0) { builder.Append("--execution-timeout"); builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture)); } // Cache Location if (!string.IsNullOrWhiteSpace(settings.CacheLocation)) { builder.Append("-c"); builder.AppendQuoted(settings.CacheLocation); } // Allow Unofficial if (settings.AllowUnofficial) { builder.Append("--allowunofficial"); } 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 detailed summary flag. if (settings.DetailedSummary.GetValueOrDefault()) { builder.Append("/ds"); } // Set the no console logger flag. if (settings.NoConsoleLogger.GetValueOrDefault()) { builder.Append("/noconlog"); } // 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.AppendSwitch("/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"); } if (settings.Loggers.Count > 0) { foreach (var logger in settings.Loggers) { var argument = GetLoggerArgument(logger); builder.Append(argument); } } // Got any file loggers? if (settings.FileLoggers.Count > 0) { var arguments = settings.FileLoggers.Select((logger, index) => { return(GetLoggerArgument(index, logger)); }); foreach (var argument in arguments) { builder.Append(argument); } } // Add the solution as the last parameter. builder.Append(solution.MakeAbsolute(_environment).FullPath); return(builder); }
private static void AppendMSBuildSwitch(this ProcessArgumentBuilder builder, string @switch) => builder.Append($"/{@switch}");
/// <summary> /// Adds MSBuild arguments /// </summary> /// <param name="builder">Argument builder.</param> /// <param name="settings">MSBuild settings to add.</param> /// <param name="environment">The environment.</param> /// <exception cref="InvalidOperationException">Throws if 10 or more file loggers specified.</exception> public static void AppendMSBuildSettings(this ProcessArgumentBuilder builder, DotNetCoreMSBuildSettings settings, ICakeEnvironment environment) { // Got any targets? if (settings.Targets.Any()) { if (settings.Targets.All(string.IsNullOrWhiteSpace)) { throw new ArgumentException("Specify the name of the target", nameof(settings.Targets)); } builder.AppendMSBuildSwitch("target", string.Join(";", settings.Targets)); } // Got any properties? foreach (var property in settings.Properties) { if (property.Value == null || property.Value.All(string.IsNullOrWhiteSpace)) { throw new ArgumentException("A property must have at least one non-empty value", nameof(settings.Properties)); } foreach (var value in property.Value) { if (string.IsNullOrWhiteSpace(value)) { continue; } builder.AppendMSBuildSwitch("property", $"{property.Key}={value.EscapeMSBuildPropertySpecialCharacters()}"); } } // Set the maximum number of processors? if (settings.MaxCpuCount.HasValue) { builder.AppendMSBuildSwitchWithOptionalValue("maxcpucount", settings.MaxCpuCount.Value, maxCpuCount => maxCpuCount > 0); } // use different version of msbuild? if (settings.ToolVersion.HasValue) { builder.AppendMSBuildSwitch("toolsversion", GetToolVersionValue(settings.ToolVersion.Value)); } // configure console logger? if (!settings.DisableConsoleLogger && settings.ConsoleLoggerSettings != null) { var arguments = GetLoggerSettings(settings.ConsoleLoggerSettings); if (arguments.Any()) { builder.AppendMSBuildSwitch("consoleloggerparameters", arguments); } } // disable console logger? if (settings.DisableConsoleLogger) { builder.AppendMSBuildSwitch("noconsolelogger"); } // Got any file loggers? if (settings.FileLoggers.Any()) { if (settings.FileLoggers.Count >= 10) { throw new InvalidOperationException("Too Many FileLoggers"); } var arguments = settings .FileLoggers .Select((logger, index) => GetLoggerArgument(index, logger, environment)) .Where(arg => !string.IsNullOrEmpty(arg)); foreach (var argument in arguments) { builder.Append(argument); } } // Use binary logging? if (settings.BinaryLogger != null && settings.BinaryLogger.Enabled) { string binaryOptions = null; if (!string.IsNullOrEmpty(settings.BinaryLogger.FileName)) { binaryOptions = settings.BinaryLogger.FileName; } if (settings.BinaryLogger.Imports != MSBuildBinaryLoggerImports.Unspecified) { if (!string.IsNullOrEmpty(binaryOptions)) { binaryOptions += ";"; } binaryOptions = binaryOptions + "ProjectImports=" + settings.BinaryLogger.Imports; } builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("binarylogger", binaryOptions); } // Got any distributed loggers? foreach (var distributedLogger in settings.DistributedLoggers) { builder.AppendMSBuildSwitch("distributedlogger", $"{GetLoggerValue(distributedLogger.CentralLogger)}*{GetLoggerValue(distributedLogger.ForwardingLogger)}"); } // use a file logger for each node? if (settings.DistributedFileLogger) { builder.AppendMSBuildSwitch("distributedfilelogger"); } // Got any loggers? foreach (var logger in settings.Loggers) { builder.AppendMSBuildSwitch("logger", GetLoggerValue(logger)); } var showWarningsAsError = settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Error || settings.WarningCodesAsError.Any(); var showWarningsAsMessages = settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Message || settings.WarningCodesAsMessage.Any(); // Treat all or some warnings as errors? if (showWarningsAsError) { builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("warnaserror", GetWarningCodes(settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Error, settings.WarningCodesAsError)); } // Treat all or some warnings as messages? if (showWarningsAsMessages) { builder.AppendMSBuildSwitchWithOptionalValueIfNotEmpty("warnasmessage", GetWarningCodes(settings.TreatAllWarningsAs == MSBuildTreatAllWarningsAs.Message, settings.WarningCodesAsMessage)); } // set project file extensions to ignore when searching for project file if (settings.IgnoreProjectExtensions.Any()) { builder.AppendMSBuildSwitch("ignoreprojectextensions", string.Join(",", settings.IgnoreProjectExtensions)); } // detailed summary? if (settings.DetailedSummary) { builder.AppendMSBuildSwitch("detailedsummary"); } // Include response files? foreach (var responseFile in settings.ResponseFiles) { builder.AppendSwitchQuoted("@", string.Empty, responseFile.MakeAbsolute(environment).FullPath); } // exclude auto response files? if (settings.ExcludeAutoResponseFiles) { builder.AppendMSBuildSwitch("noautoresponse"); } // don't output MSBuild logo? if (settings.NoLogo) { builder.AppendMSBuildSwitch("nologo"); } }
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, NUnit3Settings settings) { var builder = new ProcessArgumentBuilder(); // Add the assemblies to build. foreach (var assemblyPath in assemblyPaths) { builder.AppendQuoted(assemblyPath.MakeAbsolute(_environment).FullPath); } if (settings.Test != null) { builder.Append("--test=" + settings.Test); } if (settings.TestList != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--testlist={0}", settings.TestList.MakeAbsolute(_environment).FullPath)); } if (settings.Where != null) { builder.Append("--where \"" + settings.Where + "\""); } if (settings.Timeout.HasValue) { builder.Append("--timeout=" + settings.Timeout.Value); } if (settings.Seed.HasValue) { builder.Append("--seed=" + settings.Seed.Value); } if (settings.Workers.HasValue) { builder.Append("--workers=" + settings.Workers.Value); } if (settings.StopOnError) { builder.Append("--stoponerror"); } if (settings.SkipNonTestAssemblies) { builder.Append("--skipnontestassemblies"); } if (settings.Work != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--work={0}", settings.Work.MakeAbsolute(_environment).FullPath)); } if (settings.OutputFile != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--out={0}", settings.OutputFile.MakeAbsolute(_environment).FullPath)); } #pragma warning disable 0618 if (settings.ErrorOutputFile != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--err={0}", settings.ErrorOutputFile.MakeAbsolute(_environment).FullPath)); } if (settings.Full) { builder.Append("--full"); } #pragma warning restore 0618 if (HasResults(settings) && settings.NoResults) { throw new ArgumentException( GetToolName() + ": You can't specify both a results file and set NoResults to true."); } if (HasResults(settings)) { foreach (var result in settings.Results) { var resultString = new StringBuilder(result.FileName.MakeAbsolute(_environment).FullPath); if (result.Format != null) { resultString.AppendFormat(";format={0}", result.Format); } if (result.Transform != null) { resultString.AppendFormat(";transform={0}", result.Transform.MakeAbsolute(_environment).FullPath); } builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--result={0}", resultString)); } } else if (settings.NoResults) { builder.AppendQuoted("--noresult"); } if (settings.Labels != NUnit3Labels.Off) { builder.Append("--labels=" + settings.Labels); } if (settings.TeamCity) { builder.Append("--teamcity"); } if (settings.NoHeader) { builder.Append("--noheader"); } if (settings.NoColor) { builder.Append("--nocolor"); } #pragma warning disable 0618 if (settings.Verbose) { builder.Append("--verbose"); } #pragma warning restore 0618 if (settings.Configuration != null) { builder.AppendQuoted("--config=" + settings.Configuration); } if (settings.Framework != null) { builder.AppendQuoted("--framework=" + settings.Framework); } if (settings.X86) { builder.Append("--x86"); } if (settings.DisposeRunners) { builder.Append("--dispose-runners"); } if (settings.ShadowCopy) { builder.Append("--shadowcopy"); } if (settings.Agents.HasValue) { builder.Append("--agents=" + settings.Agents.Value); } // don't include the default value if (settings.Process != NUnit3ProcessOption.Multiple) { builder.Append("--process=" + settings.Process); } if (settings.AppDomainUsage != NUnit3AppDomainUsage.Default) { builder.Append("--domain=" + settings.AppDomainUsage); } if (settings.TraceLevel.HasValue) { builder.Append("--trace=" + settings.TraceLevel.Value.GetArgumentValue()); } if (settings.ConfigFile != null) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--configfile={0}", settings.ConfigFile.MakeAbsolute(_environment).FullPath)); } if (settings.Params != null && settings.Params.Count > 0) { foreach (var param in settings.Params) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "--params={0}={1}", param.Key, param.Value)); } } return(builder); }
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, GitReleaseManagerCreateSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("create"); builder.Append("-u"); builder.AppendQuoted(userName); builder.Append("-p"); builder.AppendQuotedSecret(password); builder.Append("-o"); builder.AppendQuoted(owner); builder.Append("-r"); builder.AppendQuoted(repository); // Milestone if (!string.IsNullOrWhiteSpace(settings.Milestone)) { builder.Append("-m"); builder.AppendQuoted(settings.Milestone); } // Name if (!string.IsNullOrWhiteSpace(settings.Name)) { builder.Append("-n"); builder.AppendQuoted(settings.Name); } // Input File Path if (settings.InputFilePath != null) { builder.Append("-i"); builder.AppendQuoted(settings.InputFilePath.MakeAbsolute(_environment).FullPath); } // Prerelease? if (settings.Prerelease) { builder.Append("-pre"); } // Assets if (!string.IsNullOrWhiteSpace(settings.Assets)) { builder.Append("-a"); builder.AppendQuoted(settings.Assets); } // Target Commitish if (!string.IsNullOrWhiteSpace(settings.TargetCommitish)) { builder.Append("-c"); builder.AppendQuoted(settings.TargetCommitish); } // Target Directory if (settings.TargetDirectory != null) { builder.Append("-d"); builder.AppendQuoted(settings.TargetDirectory.MakeAbsolute(_environment).FullPath); } // Log File Path if (settings.LogFilePath != null) { builder.Append("-l"); builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath); } return(builder); }
private ProcessArgumentBuilder GetArguments(string packageId, ChocolateyUpgradeSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("upgrade"); builder.Append(packageId); // Debug if (settings.Debug) { builder.Append("-d"); } // Verbose if (settings.Verbose) { builder.Append("-v"); } // Accept License if (settings.AcceptLicense) { builder.Append("--acceptLicense"); } // Always say yes, so as to not show interactive prompt builder.Append("-y"); // Force if (settings.Force) { builder.Append("-f"); } // Noop if (settings.Noop) { builder.Append("--noop"); } // Limit Output if (settings.LimitOutput) { builder.Append("-r"); } // Execution Timeout if (settings.ExecutionTimeout != 0) { builder.Append("--execution-timeout"); builder.Append(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture)); } // Cache Location if (!string.IsNullOrWhiteSpace(settings.CacheLocation)) { builder.Append("-c"); builder.Append(settings.CacheLocation); } // Allow Unofficial if (settings.AllowUnofficial) { builder.Append("--allowunofficial"); } // Package source if (!string.IsNullOrWhiteSpace(settings.Source)) { builder.Append("-s"); builder.Append(settings.Source); } // Version if (settings.Version != null) { builder.Append("--version"); builder.Append(settings.Version); } // Prerelease if (settings.Prerelease) { builder.Append("--pre"); } // Forcex86 if (settings.Forcex86) { builder.Append("--x86"); } // Install Arguments if (!string.IsNullOrWhiteSpace(settings.InstallArguments)) { builder.Append("--ia"); builder.Append(settings.InstallArguments); } // OverrideArguments if (settings.OverrideArguments) { builder.Append("-o"); } // NotSilent if (settings.NotSilent) { builder.Append("--notSilent"); } // Package Parameters if (!string.IsNullOrWhiteSpace(settings.PackageParameters)) { builder.Append("--params"); builder.Append(settings.PackageParameters); } // Allow Downgrade if (settings.AllowDowngrade) { builder.Append("--allowdowngrade"); } // Side by side installation if (settings.SideBySide) { builder.Append("-m"); } // Ignore Dependencies if (settings.IgnoreDependencies) { builder.Append("-i"); } // Skip PowerShell if (settings.SkipPowerShell) { builder.Append("-n"); } // Fail on Unfound if (settings.FailOnUnfound) { builder.Append("--failonunfound"); } // Fail on Not Installed if (settings.FailOnNotInstalled) { builder.Append("--failonnotinstalled"); } // User if (!string.IsNullOrWhiteSpace(settings.User)) { builder.Append("-u"); builder.Append(settings.User); } // Password if (!string.IsNullOrWhiteSpace(settings.Password)) { builder.Append("-p"); builder.Append(settings.Password); } // Ignore Checksums if (settings.IgnoreChecksums) { builder.Append("--ignorechecksums"); } return(builder); }
public void Run(FilePath apkFile, string apiKey, string devicesHash, string userEmail, DirectoryPath uitestAssemblies, TestCloudSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("submit"); builder.AppendQuoted(apkFile.MakeAbsolute(_cakeEnvironment).FullPath); builder.AppendQuotedSecret(apiKey); if (settings.Keystore != null) { builder.Append("keystore"); builder.AppendQuoted(settings.Keystore.MakeAbsolute(_cakeEnvironment).FullPath); builder.AppendQuoted(settings.KeystorePassword); builder.AppendQuoted(settings.KeystoreAlias); builder.AppendQuoted(settings.KeystoreAliasPassword); } builder.Append("--devices " + devicesHash); builder.Append("--series " + settings.Series); builder.Append("--locale"); builder.AppendQuoted(settings.Locale); builder.Append("--user"); builder.AppendQuoted(userEmail); builder.Append("--assembly-dir"); builder.AppendQuoted(uitestAssemblies.MakeAbsolute(_cakeEnvironment).FullPath); if (settings.NUnitXmlFile != null) { builder.Append("--nunit-xml"); builder.AppendQuoted(settings.NUnitXmlFile.MakeAbsolute(_cakeEnvironment).FullPath); } if (settings.Dsym != null) { builder.Append("--dsym"); builder.AppendQuoted(settings.Dsym.MakeAbsolute(_cakeEnvironment).FullPath); } if (settings.Categories != null) { foreach (var cat in settings.Categories) { builder.Append("--category"); builder.AppendQuoted(cat); } } if (!string.IsNullOrEmpty(settings.Fixture)) { builder.Append("--fixture"); builder.AppendQuoted(settings.Fixture); } if (!string.IsNullOrEmpty(settings.AppName)) { builder.Append("--app-name"); builder.AppendQuoted(settings.AppName); } if (settings.TestChunk) { builder.Append("--test-chunk"); } if (settings.TestFixture) { builder.Append("--test-fixture"); } Run(settings, builder); }
private ProcessArgumentBuilder GetArguments(DirectoryPath repositoryRootPath, GitLinkSettings settings) { var builder = new ProcessArgumentBuilder(); builder.AppendQuoted(repositoryRootPath.MakeAbsolute(_environment).FullPath); if (!string.IsNullOrWhiteSpace(settings.RepositoryUrl)) { builder.Append("-u"); builder.AppendQuoted(settings.RepositoryUrl); } if (!string.IsNullOrWhiteSpace(settings.SolutionFileName)) { builder.Append("-f"); builder.AppendQuoted(settings.SolutionFileName); } if (!string.IsNullOrWhiteSpace(settings.Configuration)) { builder.Append("-c"); builder.AppendQuoted(settings.Configuration); } if (!string.IsNullOrWhiteSpace(settings.Platform)) { builder.Append("-p"); builder.AppendQuoted(settings.Platform); } if (!string.IsNullOrWhiteSpace(settings.Branch)) { builder.Append("-b"); builder.AppendQuoted(settings.Branch); } if (settings.LogFilePath != null) { builder.Append("-l"); builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath); } if (!string.IsNullOrWhiteSpace(settings.ShaHash)) { builder.Append("-s"); builder.AppendQuoted(settings.ShaHash); } if (settings.PdbDirectoryPath != null) { builder.Append("-d"); builder.AppendQuoted(settings.PdbDirectoryPath.MakeAbsolute(_environment).FullPath); } if (settings.UsePowerShell) { builder.Append("-powershell"); } if (settings.ErrorsAsWarnings) { builder.Append("-errorsaswarnings"); } if (settings.SkipVerify) { builder.Append("-skipverify"); } if (settings.IsDebug) { builder.Append("-debug"); } return(builder); }
private ProcessArgumentBuilder GetArguments(IReadOnlyList <FilePath> assemblyPaths, XUnit2Settings settings) { var builder = new ProcessArgumentBuilder(); // Add the assemblies to test. foreach (var assembly in assemblyPaths) { builder.Append(assembly.MakeAbsolute(_environment).FullPath); } // No shadow copy? if (!settings.ShadowCopy) { builder.Append("-noshadow"); } // No app domain? if (settings.NoAppDomain) { builder.Append("-noappdomain"); } // Generate NUnit Style XML report? if (settings.NUnitReport) { var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths); var assemblyFilename = reportFileName.AppendExtension(".xml"); var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename); builder.Append("-nunit"); builder.Append(outputPath.FullPath); } // Generate HTML report? if (settings.HtmlReport) { var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths); var assemblyFilename = reportFileName.AppendExtension(".html"); var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename); builder.Append("-html"); builder.Append(outputPath.FullPath); } // Generate XML report? if (settings.XmlReport || settings.XmlReportV1) { var reportFileName = XUnitRunnerUtilities.GetReportFileName(assemblyPaths); var assemblyFilename = reportFileName.AppendExtension(".xml"); var outputPath = settings.OutputDirectory.MakeAbsolute(_environment).GetFilePath(assemblyFilename); builder.Append(settings.XmlReportV1 ? "-xmlv1" : "-xml"); builder.Append(outputPath.FullPath); } // parallelize test execution? if (settings.Parallelism != ParallelismOption.None) { builder.Append("-parallel " + settings.Parallelism.ToString().ToLowerInvariant()); } // max thread count for collection parallelization if (settings.MaxThreads.HasValue) { if (settings.MaxThreads.Value == 0) { builder.Append("-maxthreads unlimited"); } else { builder.Append("-maxthreads " + settings.MaxThreads.Value); } } foreach (var trait in settings.TraitsToInclude .SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v }))) { builder.Append("-trait \"{0}={1}\"", trait.Name, trait.Value); } foreach (var trait in settings.TraitsToExclude .SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v }))) { builder.Append("-notrait \"{0}={1}\"", trait.Name, trait.Value); } return(builder); }
public ProcessArgumentBuilder Get() { AppendCommonArguments(); AppendArgumentIfNotNull("releaseNumber", _settings.ReleaseNumber); AppendArgumentIfNotNull("defaultpackageversion", _settings.DefaultPackageVersion); AppendPackages(_settings, _builder); AppendArgumentIfNotNull("packagesFolder", _settings.PackagesFolder); AppendArgumentIfNotNull("releasenotes", _settings.ReleaseNotes); AppendArgumentIfNotNull("releasenotesfile", _settings.ReleaseNotesFile); if (_settings.IgnoreExisting) { _builder.Append("--ignoreexisting"); } return(_builder); }
private ProcessArgumentBuilder GetArguments(FilePath targetFilePath, NuGetRestoreSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("restore"); builder.AppendQuoted(targetFilePath.MakeAbsolute(_environment).FullPath); // RequireConsent? if (settings.RequireConsent) { builder.Append("-RequireConsent"); } // Packages Directory. if (settings.PackagesDirectory != null) { builder.Append("-PackagesDirectory"); builder.AppendQuoted(settings.PackagesDirectory.MakeAbsolute(_environment).FullPath); } // List of package sources. if (settings.Source != null && settings.Source.Count > 0) { builder.Append("-Source"); builder.AppendQuoted(string.Join(";", settings.Source)); } // List of package fallback sources. if (settings.FallbackSource != null && settings.FallbackSource.Count > 0) { builder.Append("-FallbackSource"); builder.AppendQuoted(string.Join(";", settings.FallbackSource)); } // No Cache? if (settings.NoCache) { builder.Append("-NoCache"); } // Disable Parallel Processing? if (settings.DisableParallelProcessing) { builder.Append("-DisableParallelProcessing"); } // Verbosity? if (settings.Verbosity.HasValue) { builder.Append("-Verbosity"); builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant()); } // Configuration file. if (settings.ConfigFile != null) { builder.Append("-ConfigFile"); builder.AppendQuoted(settings.ConfigFile.MakeAbsolute(_environment).FullPath); } // MSBuildVersion? if (settings.MSBuildVersion.HasValue) { builder.Append("-MSBuildVersion"); builder.Append(settings.MSBuildVersion.Value.ToString("D")); } builder.Append("-NonInteractive"); return(builder); }
private static ProcessArgumentBuilder ProcessArguments( ICakeContext cakeContext, ProcessArgumentBuilder builder, FilePath project, XUnit2Settings settings) { // No shadow copy? if (!settings.ShadowCopy) { throw new CakeException("-noshadow is not supported in .netcoreapp"); } // No app domain? if (settings.NoAppDomain) { throw new CakeException("-noappdomain is not supported in .netcoreapp"); } if (settings.OutputDirectory == null && (settings.HtmlReport || settings.NUnitReport || settings.XmlReport)) { throw new CakeException("OutputDirectory must not be null"); } // Generate NUnit Style XML report? if (settings.NUnitReport) { var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName()); var assemblyFilename = reportFileName.AppendExtension(".xml"); var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment) .GetFilePath(assemblyFilename); builder.Append("-nunit"); builder.AppendQuoted(outputPath.FullPath); } // Generate HTML report? if (settings.HtmlReport) { var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName()); var assemblyFilename = reportFileName.AppendExtension(".html"); var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment) .GetFilePath(assemblyFilename); builder.Append("-html"); builder.AppendQuoted(outputPath.FullPath); } if (settings.XmlReportV1) { throw new CakeException("-xmlv1 is not supported in .netcoreapp"); } // Generate XML report? if (settings.XmlReport) { var reportFileName = new FilePath(project.GetDirectory().GetDirectoryName()); var assemblyFilename = reportFileName.AppendExtension(".xml"); var outputPath = settings.OutputDirectory.MakeAbsolute(cakeContext.Environment) .GetFilePath(assemblyFilename); builder.Append("-xml"); builder.AppendQuoted(outputPath.FullPath); } // parallelize test execution? if (settings.Parallelism != null && settings.Parallelism != ParallelismOption.None) { builder.Append($"-parallel {settings.Parallelism.ToString().ToLowerInvariant()}"); } // max thread count for collection parallelization if (settings.MaxThreads.HasValue) { if (settings.MaxThreads.Value == 0) { builder.Append("-maxthreads unlimited"); } else { builder.Append($"-maxthreads {settings.MaxThreads.Value}"); } } foreach (var trait in settings.TraitsToInclude .SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v }))) { builder.Append("-trait \"{0}={1}\"", trait.Name, trait.Value); } foreach (var trait in settings.TraitsToExclude .SelectMany(pair => pair.Value.Select(v => new { Name = pair.Key, Value = v }))) { builder.Append($"-notrait \"{trait.Name}={trait.Value}\""); } return(builder); }
/// <summary> /// Adds common arguments to the process builder. /// </summary> /// <param name="settings">The settings.</param> /// <param name="builder">The process argument builder.</param> /// <returns>The process argument builder.</returns> protected ProcessArgumentBuilder AddCommonArguments(ChocolateySettings settings, ProcessArgumentBuilder builder) { // Debug if (settings.Debug) { builder.Append("-d"); } // Verbose if (settings.Verbose) { builder.Append("-v"); } // Accept License if (settings.AcceptLicense) { builder.Append("--acceptLicense"); } // Always say yes, so as to not show interactive prompt builder.Append("-y"); // Force if (settings.Force) { builder.Append("-f"); } // Noop if (settings.Noop) { builder.Append("--noop"); } // Limit Output if (settings.LimitOutput) { builder.Append("-r"); } // Execution Timeout if (settings.ExecutionTimeout != 0) { builder.Append("--execution-timeout"); builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture)); } // Cache Location if (!string.IsNullOrWhiteSpace(settings.CacheLocation)) { builder.Append("-c"); builder.AppendQuoted(settings.CacheLocation); } // Allow Unofficial if (settings.AllowUnofficial) { builder.Append("--allowunofficial"); } // Package source if (!string.IsNullOrWhiteSpace(settings.Source)) { builder.Append("-s"); builder.AppendQuoted(settings.Source); } // Version if (settings.Version != null) { builder.Append("--version"); builder.AppendQuoted(settings.Version); } // OverrideArguments if (settings.OverrideArguments) { builder.Append("-o"); } // NotSilent if (settings.NotSilent) { builder.Append("--notSilent"); } // Package Parameters if (!string.IsNullOrWhiteSpace(settings.PackageParameters)) { builder.Append("--params"); builder.AppendQuoted(settings.PackageParameters); } // Side by side installation if (settings.SideBySide) { builder.Append("-m"); } // Skip PowerShell if (settings.SkipPowerShell) { builder.Append("-n"); } return(builder); }
private ProcessArgumentBuilder GetArguments(IEnumerable <FilePath> assemblyPaths, VSTestSettings settings) { var builder = new ProcessArgumentBuilder(); // Add the assembly to build. foreach (var assemblyPath in assemblyPaths) { builder.Append(assemblyPath.MakeAbsolute(_environment).FullPath); } if (settings.SettingsFile != null) { builder.AppendSwitch("/Settings", ":", settings.SettingsFile.MakeAbsolute(_environment).FullPath); } if (settings.Parallel) { builder.Append("/Parallel"); } if (settings.EnableCodeCoverage) { builder.Append("/EnableCodeCoverage"); } if (settings.InIsolation) { builder.Append("/InIsolation"); } if (settings.UseVsixExtensions != null) { builder.AppendSwitch("/UseVsixExtensions", ":", settings.UseVsixExtensions.Value ? "true" : "false"); } if (settings.TestAdapterPath != null) { builder.AppendSwitch("/TestAdapterPath", ":", settings.TestAdapterPath.MakeAbsolute(_environment).FullPath); } if (settings.PlatformArchitecture != VSTestPlatform.Default) { builder.AppendSwitch("/Platform", ":", settings.PlatformArchitecture.ToString()); } if (settings.FrameworkVersion != VSTestFrameworkVersion.Default) { builder.AppendSwitch("/Framework", ":", settings.FrameworkVersion.ToString().Replace("NET", "Framework")); } if (settings.TestCaseFilter != null) { builder.AppendSwitch("/TestCaseFilter", ":", settings.TestCaseFilter); } if (settings.Diag != null) { builder.AppendSwitch("/Diag", ":", settings.Diag.MakeAbsolute(_environment).FullPath); } if (!string.IsNullOrEmpty(settings.Logger)) { builder.Append("/Logger:{0}", settings.Logger.Trim()); } 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> internal void Evaluate(ProcessArgumentBuilder args) { args.Append(Command); AppendNpmSettings(args); EvaluateCore(args); }
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 detailed summary flag. if (settings.DetailedSummary.GetValueOrDefault()) { builder.Append("/ds"); } // Set the no console logger flag. if (settings.NoConsoleLogger.GetValueOrDefault()) { builder.Append("/noconlog"); } // Set the verbosity. builder.Append(string.Format(CultureInfo.InvariantCulture, "/v:{0}", settings.Verbosity.GetMSBuildVerbosityName())); 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"); } if (settings.Loggers.Count > 0) { foreach (var logger in settings.Loggers) { var argument = GetLoggerArgument(logger); builder.Append(argument); } } // Got any file loggers? if (settings.FileLoggers.Count > 0) { var arguments = settings.FileLoggers.Select((logger, index) => GetLoggerArgument(index, logger)); foreach (var argument in arguments) { builder.Append(argument); } } // Use binary logging? if (settings.BinaryLogger != null && settings.BinaryLogger.Enabled) { string binaryOptions = null; if (!string.IsNullOrEmpty(settings.BinaryLogger.FileName)) { binaryOptions = settings.BinaryLogger.FileName; } if (settings.BinaryLogger.Imports != MSBuildBinaryLogImports.Unspecified) { if (!string.IsNullOrEmpty(binaryOptions)) { binaryOptions = binaryOptions + ";"; } binaryOptions = binaryOptions + "ProjectImports=" + settings.BinaryLogger.Imports; } if (string.IsNullOrEmpty(binaryOptions)) { builder.Append("/bl"); } else { builder.Append("/bl:" + binaryOptions); } } // Treat errors as warníngs? if (settings.WarningsAsErrorCodes.Any()) { var codes = string.Join(";", settings.WarningsAsErrorCodes); builder.Append($"/warnaserror:{codes.Quote()}"); } else if (settings.WarningsAsError) { builder.Append("/warnaserror"); } // Any warnings to NOT treat as errors? if (settings.WarningsAsMessageCodes.Any()) { var codes = string.Join(";", settings.WarningsAsMessageCodes); builder.Append($"/warnasmessage:{codes.Quote()}"); } // Invoke restore target before any other target? if (settings.Restore) { builder.Append("/restore"); } // Add the solution as the last parameter. builder.AppendQuoted(solution.MakeAbsolute(_environment).FullPath); return(builder); }
private ProcessArgumentBuilder GetArguments(FilePath filePath, NuGetPackSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("pack"); // Version if (!string.IsNullOrWhiteSpace(settings.Version)) { builder.Append("-Version"); builder.AppendQuoted(settings.Version); } // Base path if (settings.BasePath != null) { builder.Append("-BasePath"); builder.AppendQuoted(settings.BasePath.MakeAbsolute(_environment).FullPath); } // Output directory if (settings.OutputDirectory != null) { builder.Append("-OutputDirectory"); builder.AppendQuoted(settings.OutputDirectory.MakeAbsolute(_environment).FullPath); } // Nuspec file builder.AppendQuoted(filePath.MakeAbsolute(_environment).FullPath); // No package analysis? if (settings.NoPackageAnalysis) { builder.Append("-NoPackageAnalysis"); } // IncludeReferencedProjects? if (settings.IncludeReferencedProjects) { builder.Append("-IncludeReferencedProjects"); } // Symbols? if (settings.Symbols) { builder.Append("-Symbols"); } // Verbosity if (settings.Verbosity != null) { builder.Append("-Verbosity"); builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant()); } // MSBuildVersion? if (settings.MSBuildVersion.HasValue) { builder.Append("-MSBuildVersion"); builder.Append(settings.MSBuildVersion.Value.ToString("D")); } // Properties if (settings.Properties != null && settings.Properties.Count > 0) { if (settings.Properties.Values.Any(string.IsNullOrWhiteSpace)) { throw new CakeException("Properties values can not be null or empty."); } if (settings.Properties.Keys.Any(string.IsNullOrWhiteSpace)) { throw new CakeException("Properties keys can not be null or empty."); } builder.Append("-Properties"); builder.AppendQuoted(string.Join(";", settings.Properties.Select(property => string.Concat(property.Key, "=", property.Value)))); } return(builder); }
public void Build(XCodeBuildSettings settings) { var builder = new ProcessArgumentBuilder(); if (settings.Verbose) { builder.Append("-verbose"); } if (settings.CheckFirstLaunchStatus) { builder.Append("-checkFirstLaunchStatus"); } if (!string.IsNullOrEmpty(settings.Project)) { builder.Append(string.Format("-project \"{0}\"", settings.Project)); } if (!string.IsNullOrEmpty(settings.Target)) { builder.Append(string.Format("-target \"{0}\"", settings.Target)); } if (settings.AllTargets) { builder.Append("-alltargets"); } if (settings.Workspace != null) { builder.Append("-workspace " + GetQuotedAbsolute(settings.Workspace)); } if (!string.IsNullOrEmpty(settings.Scheme)) { builder.Append(string.Format("-scheme \"{0}\"", settings.Scheme)); } if (!string.IsNullOrEmpty(settings.Configuration)) { builder.Append(string.Format("-configuration \"{0}\"", settings.Configuration)); } if (settings.XcConfig != null) { builder.Append("-xcconfig " + GetQuotedAbsolute(settings.XcConfig)); } if (!string.IsNullOrEmpty(settings.Arch)) { builder.Append(string.Format("-arch \"{0}\"", settings.Arch)); } if (!string.IsNullOrEmpty(settings.Sdk)) { builder.Append(string.Format("-sdk \"{0}\"", settings.Sdk)); } if (!string.IsNullOrEmpty(settings.Toolchain)) { builder.Append(string.Format("-toolchain \"{0}\"", settings.Toolchain)); } if (settings.Destination != null && settings.Destination.Count > 0) { builder.Append("-destination " + string.Join(",", settings.Destination.Select(kvp => string.Format("{0}={1}", kvp.Key, kvp.Value)))); if (settings.DestinationTimeout.HasValue) { builder.Append("-destination-timeout " + settings.DestinationTimeout.Value); } } if (settings.ParallelizeTargets) { builder.Append("-parallelizeTargets"); } if (settings.Jobs.HasValue) { builder.Append("-jobs " + settings.Jobs.Value); } if (settings.DryRun) { builder.Append("-dry-run"); } if (settings.ResultBundlePath != null) { builder.Append("-resultBundlePath " + GetQuotedAbsolute(settings.ResultBundlePath)); } if (settings.DerivedDataPath != null) { builder.Append("-derivedDataPath " + GetQuotedAbsolute(settings.DerivedDataPath)); } if (settings.ArchivePath != null) { builder.Append("-archivePath " + GetQuotedAbsolute(settings.ArchivePath)); } if (settings.ExportArchive) { builder.Append("-exportArchive"); } if (settings.ExportFormat.HasValue) { builder.Append("-exportFormat " + settings.ExportFormat.Value.ToString().ToLowerInvariant()); } if (settings.ExportPath != null) { builder.Append("-exportPath " + GetQuotedAbsolute(settings.ExportPath)); } if (settings.ExportOptionsPlist != null) { builder.Append("-exportOptionsPlist " + GetQuotedAbsolute(settings.ExportOptionsPlist)); } if (!string.IsNullOrEmpty(settings.ExportProvisioningProfile)) { builder.Append("-exportProvisioningProfile " + settings.ExportProvisioningProfile); } if (!string.IsNullOrEmpty(settings.ExportSigningIdentity)) { builder.Append("-exportSigningIdentity " + settings.ExportSigningIdentity); } if (!string.IsNullOrEmpty(settings.ExportInstallerIdentity)) { builder.Append("-exportInstallerIdentity " + settings.ExportInstallerIdentity); } if (settings.ExportWithOriginalSigningIdentity) { builder.Append("-exportWithOriginalSigningIdentity"); } if (settings.SkipUnavailableActions) { builder.Append("-skipUnavailableActions"); } if (settings.ExportLocalizations) { builder.Append("-exportLocalizations"); } if (settings.LocalizationPath != null) { builder.Append("-localizationPath " + GetQuotedAbsolute(settings.LocalizationPath)); } if (!string.IsNullOrEmpty(settings.ExportLanguage)) { builder.Append("-exportLanguage " + settings.ExportLanguage); } if (settings.Archive) { builder.Append("archive"); } else { builder.Append("build"); } if (settings.Clean) { builder.Append("clean"); } if (settings.BuildSettings != null && settings.BuildSettings.Count > 0) { builder.Append(string.Join(" ", settings.BuildSettings.Select(kvp => string.Format("{0}={1}", kvp.Key, kvp.Value)))); } Run(settings, builder, settings.ToolPath); }
/// <summary> /// Appends the specified secret text to the argument builder. /// </summary> /// <param name="builder">The builder.</param> /// <param name="text">The secret text to be appended.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> public static ProcessArgumentBuilder AppendSecret(this ProcessArgumentBuilder builder, string text) { builder?.Append(new SecretArgument(new TextArgument(text))); return(builder); }
private ProcessArgumentBuilder GetArguments(FilePath[] absoluteAssemblyPaths, SignToolSignSettings settings) { foreach (var path in absoluteAssemblyPaths) { if (!_fileSystem.Exist(path)) { const string format = "{0}: The assembly '{1}' does not exist."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), path.FullPath); throw new CakeException(message); } } var builder = new ProcessArgumentBuilder(); // SIGN Command. builder.Append("SIGN"); // SHA-256. if (settings.DigestAlgorithm == SignToolDigestAlgorithm.Sha256) { builder.Append("/fd sha256"); } // TimeStamp. if (settings.TimeStampUri != null) { if (settings.TimeStampDigestAlgorithm == SignToolDigestAlgorithm.Sha256) { // If Sha256 use RFC 3161 timestamp server. builder.Append("/tr"); builder.AppendQuoted(settings.TimeStampUri.AbsoluteUri); builder.Append("/td sha256"); } else { // Otherwise use SHA-1 Authenticode timestamp server builder.Append("/t"); builder.AppendQuoted(settings.TimeStampUri.AbsoluteUri); } } if (settings.CertPath == null && string.IsNullOrEmpty(settings.CertThumbprint) && string.IsNullOrEmpty(settings.CertSubjectName)) { const string format = "{0}: One of Certificate path, Certificate thumbprint or Certificate subject name is required but neither are specified."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName()); throw new CakeException(message); } if (settings.CertPath != null && !string.IsNullOrEmpty(settings.CertThumbprint)) { const string format = "{0}: Certificate path and Certificate thumbprint cannot be specified together."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName()); throw new CakeException(message); } if (settings.CertPath != null && !string.IsNullOrEmpty(settings.CertSubjectName)) { const string format = "{0}: Certificate path and Certificate subject name cannot be specified together."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName()); throw new CakeException(message); } if (!string.IsNullOrEmpty(settings.CertThumbprint) && !string.IsNullOrEmpty(settings.Password)) { const string format = "{0}: Certificate thumbprint and Password cannot be specified together."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName()); throw new CakeException(message); } if (!string.IsNullOrEmpty(settings.CertSubjectName) && !string.IsNullOrEmpty(settings.Password)) { const string format = "{0}: Certificate subject name and Password cannot be specified together."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName()); throw new CakeException(message); } if (settings.CertPath != null) { // Make certificate path absolute. settings.CertPath = settings.CertPath.IsRelative ? settings.CertPath.MakeAbsolute(_environment) : settings.CertPath; if (!_fileSystem.Exist(settings.CertPath)) { const string format = "{0}: The certificate '{1}' does not exist."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), settings.CertPath.FullPath); throw new CakeException(message); } // Path to PFX Certificate. builder.Append("/f"); builder.AppendQuoted(settings.CertPath.MakeAbsolute(_environment).FullPath); // PFX Password. if (!string.IsNullOrEmpty(settings.Password)) { builder.Append("/p"); builder.AppendSecret(settings.Password); } } if (settings.AdditionalCertPath != null) { // Make additional certificate path absolute. settings.AdditionalCertPath = settings.AdditionalCertPath.IsRelative ? settings.AdditionalCertPath.MakeAbsolute(_environment) : settings.AdditionalCertPath; if (!_fileSystem.Exist(settings.AdditionalCertPath)) { const string format = "{0}: The additional certificate '{1}' does not exist."; var message = string.Format(CultureInfo.InvariantCulture, format, GetToolName(), settings.AdditionalCertPath.FullPath); throw new CakeException(message); } // Path to additional certificate. builder.Append("/ac"); builder.AppendQuoted(settings.AdditionalCertPath.MakeAbsolute(_environment).FullPath); } // Certificate thumbprint. if (!string.IsNullOrEmpty(settings.CertThumbprint)) { builder.Append("/sha1"); builder.AppendQuoted(settings.CertThumbprint); } if (!string.IsNullOrEmpty(settings.CertSubjectName)) { builder.Append("/n"); builder.AppendQuoted(settings.CertSubjectName); } // Signed content description. if (!string.IsNullOrEmpty(settings.Description)) { builder.Append("/d"); builder.AppendQuoted(settings.Description); } // Signed content expanded description URL. if (settings.DescriptionUri != null) { builder.Append("/du"); builder.AppendQuoted(settings.DescriptionUri.AbsoluteUri); } // Append signature. if (settings.AppendSignature) { builder.Append("/as"); } // use machine store when requested if (settings.UseMachineStore) { builder.Append("/sm"); } // open a specific certificate store if (!string.IsNullOrWhiteSpace(settings.StoreName)) { builder.Append("/s"); builder.AppendQuoted(settings.StoreName); } // Target Assemblies to sign. foreach (var path in absoluteAssemblyPaths) { builder.AppendQuoted(path.FullPath); } return(builder); }
/// <summary> /// Appends the specified switch 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="text">The text to be appended.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> public static ProcessArgumentBuilder AppendSwitch(this ProcessArgumentBuilder builder, string @switch, string separator, string text) { builder?.Append(new SwitchArgument(@switch, new TextArgument(text), separator)); return(builder); }
private ProcessArgumentBuilder GetArguments(FilePath path, DNURestoreSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("restore"); // Specific project path? if (path != null) { builder.AppendQuoted(path.MakeAbsolute(_environment).FullPath); } // List of package sources if (settings.Sources != null && settings.Sources.Count > 0) { foreach (var source in settings.Sources) { builder.Append("--source"); builder.AppendQuoted(source); } } // List of fallback package sources if (settings.FallbackSources != null && settings.FallbackSources.Count > 0) { foreach (var fallbacksource in settings.FallbackSources) { builder.Append("--fallbacksource"); builder.AppendQuoted(fallbacksource); } } // Proxy if (settings.Proxy != null) { builder.Append("--proxy"); builder.AppendQuoted(settings.Proxy); } // No Cache? if (settings.NoCache) { builder.Append("--no-cache"); } // Packages if (settings.Packages != null) { builder.Append("--packages"); builder.AppendQuoted(settings.Packages.MakeAbsolute(_environment).FullPath); } // Ignore failed sources? if (settings.IgnoreFailedSources) { builder.Append("--ignore-failed-sources"); } // Quiet? if (settings.Quiet) { builder.Append("--quiet"); } // Parallel? if (settings.Parallel) { builder.Append("--parallel"); } // Locked? if (settings.Locked.HasValue) { switch (settings.Locked) { case DNULocked.Lock: builder.Append("--lock"); break; case DNULocked.Unlock: builder.Append("--unlock"); break; } } // List of runtime identifiers if (settings.Runtimes != null && settings.Runtimes.Count > 0) { foreach (var runtime in settings.Runtimes) { builder.Append("--runtime"); builder.AppendQuoted(runtime); } } return(builder); }
/// <summary> /// Appends the specified text to the argument builder. /// </summary> /// <param name="builder">The builder.</param> /// <param name="text">The text to be appended.</param> /// <param name="renderer">The renderer which handles quoting and escaping.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> public static ProcessArgumentBuilder Append(this ProcessArgumentBuilder builder, string text, IProcessArgumentRenderer renderer) { builder?.Append(new TextArgument(text, renderer)); return(builder); }
private ProcessArgumentBuilder GetInstallArguments(TopshelfSettings settings) { ProcessArgumentBuilder builder = new ProcessArgumentBuilder(); if ((settings != null) && (settings.Arguments != null)) { builder = settings.Arguments; } builder.Append(new TextArgument("install")); if (settings != null) { if (!string.IsNullOrWhiteSpace(settings.Username)) { builder.Append(new TextArgument("-username")); builder.Append(new QuotedArgument(new TextArgument(settings.Username))); } if (!string.IsNullOrWhiteSpace(settings.Password)) { builder.Append(new TextArgument("-password")); builder.Append(new QuotedArgument(new TextArgument(settings.Password))); } if (!string.IsNullOrWhiteSpace(settings.Instance)) { builder.Append(new TextArgument("-instance")); builder.Append(new QuotedArgument(new TextArgument(settings.Instance))); } builder.Append(settings.Autostart ? new TextArgument("--autostart") : new TextArgument("--manual")); if (settings.Disabled) builder.Append(new TextArgument("--disabled")); if (settings.Delayed) builder.Append(new TextArgument("--delayed")); if (settings.LocalSystem) builder.Append(new TextArgument("--localsystem")); if (settings.LocalService) builder.Append(new TextArgument("--localservice")); if (settings.NetworkService) builder.Append(new TextArgument("--networkservice")); if (!string.IsNullOrWhiteSpace(settings.ServiceName)) { builder.Append(new TextArgument("--servicename")); builder.Append(new QuotedArgument(new TextArgument(settings.Description))); } if (!string.IsNullOrWhiteSpace(settings.Description)) { builder.Append(new TextArgument("--description")); builder.Append(new QuotedArgument(new TextArgument(settings.Description))); } if (!string.IsNullOrWhiteSpace(settings.DisplayName)) { builder.Append(new TextArgument("--displayname")); builder.Append(new QuotedArgument(new TextArgument(settings.DisplayName))); } } return builder; }