protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder (); args.Add ("-v"); args.Add ("--force"); args.Add ("--sign"); args.AddQuoted (SigningKey); if (!string.IsNullOrEmpty (Keychain)) { args.Add ("--keychain"); args.AddQuoted (Path.GetFullPath (Keychain)); } if (!string.IsNullOrEmpty (ResourceRules)) { args.Add ("--resource-rules"); args.AddQuoted (Path.GetFullPath (ResourceRules)); } if (!string.IsNullOrEmpty (Entitlements)) { args.Add ("--entitlements"); args.AddQuoted (Path.GetFullPath (Entitlements)); } if (!string.IsNullOrEmpty (ExtraArgs)) args.Add (ExtraArgs); args.AddQuoted (Path.GetFullPath (Resource)); return args.ToString (); }
public static BuildResult CompileXibFiles (IProgressMonitor monitor, IEnumerable<ProjectFile> files, FilePath outputRoot) { var result = new BuildResult (); var ibfiles = GetIBFilePairs (files, outputRoot).Where (NeedsBuilding).ToList (); if (ibfiles.Count > 0) { monitor.BeginTask (GettextCatalog.GetString ("Compiling interface definitions"), 0); foreach (var file in ibfiles) { file.EnsureOutputDirectory (); var args = new ProcessArgumentBuilder (); args.AddQuoted (file.Input); args.Add ("--compile"); args.AddQuoted (file.Output); var psi = new ProcessStartInfo ("ibtool", args.ToString ()); monitor.Log.WriteLine (psi.FileName + " " + psi.Arguments); psi.WorkingDirectory = outputRoot; string errorOutput; int code; try { code = ExecuteCommand (monitor, psi, out errorOutput); } catch (System.ComponentModel.Win32Exception ex) { LoggingService.LogError ("Error running ibtool", ex); result.AddError (null, 0, 0, null, "ibtool not found. Please ensure the Apple SDK is installed."); return result; } if (code != 0) { //FIXME: parse the plist that ibtool returns result.AddError (null, 0, 0, null, "ibtool returned error code " + code); } } monitor.EndTask (); } return result; }
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); }
protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder (); args.Add ("-rsrc"); args.AddQuoted (Source.ItemSpec); args.AddQuoted (Destination.ItemSpec); return args.ToString (); }
public void Test_With_No_Arguments(Type escapeHandlerType, string sigil) { // Arrange var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler; var builder = new ProcessArgumentBuilder(escapeHandler); // Act var result = builder.Build(); // Assert Assert.Equal("", result); }
public void Should_Make_Project_Path_Absolute() { // Given var context = UnityPlatformFixture.CreateContext(); var builder = new ProcessArgumentBuilder(); var platform = new WindowsPlatform("Project/Game.exe"); // When platform.BuildArguments(context, builder); // Then Assert.Equal("-buildWindowsPlayer \"/Working/Project/Game.exe\"", builder.Render()); }
public void Should_Use_64_Bit_Platform_If_Specified() { // Given var context = UnityPlatformFixture.CreateContext(); var builder = new ProcessArgumentBuilder(); var platform = new WindowsPlatform("C:/Project/Game.exe") { PlatformTarget = UnityPlatformTarget.x64 }; // When platform.BuildArguments(context, builder); // Then Assert.Equal("-buildWindows64Player \"C:/Project/Game.exe\"", builder.Render()); }
public void Should_Add_NoGraphics_Switch_If_Specified() { // Given var context = UnityPlatformFixture.CreateContext(); var builder = new ProcessArgumentBuilder(); var platform = new WindowsPlatform("C:/Project/Game.exe"); platform.NoGraphics = true; // When platform.BuildArguments(context, builder); // Then Assert.Equal("-nographics -buildWindowsPlayer \"C:/Project/Game.exe\"", builder.Render()); }
public void Test_Multiple_Arguments(string argumentValueSeparator, string sigil, string firstArgument, string secondArgument, string firstArgumentExpectedOutput, string secondArgumentExpectedOutput, Type escapeHandlerType) { // Arrange var s = sigil; var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler; var builder = new ProcessArgumentBuilder(escapeHandler, argumentValueSeparator); builder.AddOption($"{s}help"); builder.AddNamedArgument($"{s}f", firstArgument); builder.AddNamedArgument($"{s}o", secondArgument, "="); // Act var result = builder.Build(); // Assert Assert.Equal($"{s}help {s}f{argumentValueSeparator}{firstArgumentExpectedOutput} {s}o={secondArgumentExpectedOutput}", result); }
private void ExecuteProcess(FilePath filePath, ProcessArgumentBuilder arguments, int timeout = 60000) { try { filePath = filePath.MakeAbsolute(_Environment.WorkingDirectory); _Runner.Start(filePath, new ProcessSettings() { Arguments = arguments }) .WaitForExit(timeout); } catch (Exception ex) { if (!(ex is TimeoutException)) throw; _Log.Warning("Process timed out!"); } }
protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder (); if (Recursive) args.Add ("-r"); if (Symlinks) args.Add ("-y"); args.AddQuoted (OutputFile.GetMetadata ("FullPath")); var root = WorkingDirectory.GetMetadata ("FullPath"); for (int i = 0; i < Sources.Length; i++) { var relative = PathUtils.AbsoluteToRelative (root, Sources[i].GetMetadata ("FullPath")); args.AddQuoted (relative); } return args.ToString (); }
protected abstract void AppendCommandLineArguments(IDictionary <string, string> environment, ProcessArgumentBuilder args, ITaskItem[] items);
/// <summary> /// Runs the tool using a custom tool path and the specified settings. /// </summary> /// <param name="settings">The settings.</param> /// <param name="arguments">The arguments.</param> /// <returns>The process that the tool is running under.</returns> protected IProcess RunProcess(TSettings settings, ProcessArgumentBuilder arguments) { return(RunProcess(settings, arguments, null)); }
static bool BuildPackage (IProgressMonitor monitor, MonoMacProject project, ConfigurationSelector conf, MonoMacPackagingSettings settings, FilePath target) { string bundleKey = settings.BundleSigningKey; string packageKey = settings.PackageSigningKey; if (settings.SignBundle || settings.SignPackage) { var identities = Keychain.GetAllSigningIdentities (); if (string.IsNullOrEmpty (bundleKey)) { bundleKey = identities.FirstOrDefault (k => k.StartsWith (MonoMacPackagingSettingsWidget.APPLICATION_PREFIX)); if (string.IsNullOrEmpty (bundleKey)) { monitor.ReportError ("Did not find default app signing key", null); return false; } else if (!identities.Any (k => k == bundleKey)) { monitor.ReportError ("Did not find app signing key in keychain", null); return false; } } if (string.IsNullOrEmpty (packageKey)) { packageKey = identities.FirstOrDefault (k => k.StartsWith (MonoMacPackagingSettingsWidget.INSTALLER_PREFIX)); if (string.IsNullOrEmpty (packageKey)) { monitor.ReportError ("Did not find default package signing key", null); return false; } else if (!identities.Any (k => k == packageKey)) { monitor.ReportError ("Did not find package signing key in keychain", null); return false; } } } if (project.NeedsBuilding (conf)) { BuildResult res = project.Build (monitor, conf); if (res.ErrorCount > 0) { foreach (BuildError e in res.Errors) monitor.ReportError (e.ToString (), null); monitor.ReportError (GettextCatalog.GetString ("The project failed to build."), null); return false; } } var cfg = (MonoMacProjectConfiguration) project.GetConfiguration (conf); FilePath tempDir = "/tmp/monomac-build-" + DateTime.Now.Ticks; FilePath workingApp = tempDir.Combine (cfg.AppDirectory.FileName); try { monitor.BeginTask (GettextCatalog.GetString ("Creating app bundle"), 0); var files = Directory.GetFiles (cfg.AppDirectory, "*", SearchOption.AllDirectories); HashSet<string> createdDirs = new HashSet<string> (); foreach (FilePath f in files) { var rel = f.ToRelative (cfg.AppDirectory); var parentDir = rel.ParentDirectory; if (settings.IncludeMono) { if (parentDir.IsNullOrEmpty || parentDir == "." || parentDir == "Contents/MacOS") continue; var ext = rel.Extension; if (ext == ".mdb" || ext == ".exe" || ext == ".dll") continue; } if (monitor.IsCancelRequested) return false; if (createdDirs.Add (parentDir)) Directory.CreateDirectory (workingApp.Combine (parentDir)); monitor.Log.WriteLine (rel); File.Copy (f, workingApp.Combine (rel)); } monitor.EndTask (); if (settings.IncludeMono) { monitor.BeginTask (GettextCatalog.GetString ("Merging Mono into app bundle"), 0); var args = new ProcessArgumentBuilder (); args.Add ("-o"); args.AddQuoted (tempDir); args.Add ("-n"); args.AddQuoted (cfg.AppName); var assemblies = project.GetReferencedAssemblies (conf, true); foreach (var a in assemblies) { args.Add ("-a"); args.AddQuoted (a); } args.AddQuoted (cfg.CompiledOutputName); string mmpPath = Mono.Addins.AddinManager.CurrentAddin.GetFilePath ("mmp"); var psi = new ProcessStartInfo (mmpPath, args.ToString ()); monitor.Log.WriteLine ("mmp " + psi.Arguments); string err; if (MacBuildUtilities.ExecuteCommand (monitor, psi, out err) != 0) { monitor.Log.WriteLine (err); monitor.ReportError ("Merging Mono failed", null); return false; } var plistFile = workingApp.Combine ("Contents", "Info.plist"); var plistDoc = new PlistDocument (); plistDoc.LoadFromXmlFile (plistFile); ((PlistDictionary)plistDoc.Root)["MonoBundleExecutable"] = cfg.CompiledOutputName.FileName; plistDoc.WriteToFile (plistFile); monitor.EndTask (); } //TODO: verify bundle details if for app store? if (settings.SignBundle) { monitor.BeginTask (GettextCatalog.GetString ("Signing app bundle"), 0); var args = new ProcessArgumentBuilder (); args.Add ("-v", "-f", "-s"); args.AddQuoted (bundleKey, workingApp); var psi = new ProcessStartInfo ("codesign", args.ToString ()); monitor.Log.WriteLine ("codesign " + psi.Arguments); string err; if (MacBuildUtilities.ExecuteCommand (monitor, psi, out err) != 0) { monitor.Log.WriteLine (err); monitor.ReportError ("Signing failed", null); return false; } monitor.EndTask (); } if (settings.CreatePackage) { monitor.BeginTask (GettextCatalog.GetString ("Creating installer"), 0); var args = new ProcessArgumentBuilder (); args.Add ("--component"); args.AddQuoted (workingApp); args.Add ("/Applications", "--sign"); args.AddQuoted (packageKey); if (!settings.ProductDefinition.IsNullOrEmpty) { args.Add ("--product"); args.AddQuoted (settings.ProductDefinition); } args.AddQuoted (target); var psi = new ProcessStartInfo ("productbuild", args.ToString ()); monitor.Log.WriteLine ("productbuild " + psi.Arguments); string err; if (MacBuildUtilities.ExecuteCommand (monitor, psi, out err) != 0) { monitor.Log.WriteLine (err); monitor.ReportError ("Package creation failed", null); return false; } monitor.EndTask (); } else { Directory.Move (workingApp, target); } } finally { try { if (Directory.Exists (tempDir)) Directory.Delete (tempDir, true); } catch (Exception ex) { LoggingService.LogError ("Error removing temp directory", ex); } } return true; }
private ProcessArgumentBuilder GetArguments(FilePath packageFilePath, ChocolateyPushSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("push"); builder.Append(packageFilePath.MakeAbsolute(_environment).FullPath); if (settings.Source != null) { builder.Append("-s"); builder.Append(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.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"); } return(builder); }
void StartLogTracking () { var args = new ProcessArgumentBuilder (); args.Add ("-v time"); foreach (string tag in excludedLogTags) args.Add (tag + ":S"); trackLogOp = new AdbTrackLogOperation (device, ProcessLogLine, args.ToString ()); trackLogOp.Completed += delegate (IAsyncOperation op) { if (!op.Success) { SetCompleted (false); } }; }
public InstallPackageOperation Install (AndroidDevice device, string package, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-s", device.ID, "install"); args.AddQuoted (package); var errorCapture = new StringWriter (); var errorWriter = TeeTextWriter.ForNonNull (errorCapture, errorCapture); return new InstallPackageOperation (StartProcess (AdbExe, args.ToString (), outputLog, errorWriter), errorCapture); }
private void AppendQuoted(ProcessArgumentBuilder builder, string key, string value) { builder.AppendQuoted(string.Format(CultureInfo.InvariantCulture, "-{0}:{1}", key, value)); }
static void AddExtraArgs (ProcessArgumentBuilder args, string extraArgs, IPhoneProject proj, IPhoneProjectConfiguration conf) { if (!string.IsNullOrEmpty (extraArgs)) { var customTags = new Dictionary<string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", ProcessArgumentBuilder.EscapeQuotes (proj.BaseDirectory) }, { "solutiondir", ProcessArgumentBuilder.EscapeQuotes (proj.ParentSolution.BaseDirectory) }, { "appbundledir", ProcessArgumentBuilder.EscapeQuotes (conf.AppDirectory) }, { "targetpath", ProcessArgumentBuilder.EscapeQuotes (conf.CompiledOutputName) }, { "targetdir", ProcessArgumentBuilder.EscapeQuotes (conf.CompiledOutputName.ParentDirectory) }, { "targetname", ProcessArgumentBuilder.EscapeQuotes (conf.CompiledOutputName.FileName) }, { "targetext", ProcessArgumentBuilder.EscapeQuotes (conf.CompiledOutputName.Extension) }, }; args.Add (StringParserService.Parse (extraArgs, customTags)); } }
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); } // Version suffix if (!string.IsNullOrWhiteSpace(settings.Suffix)) { builder.Append("-Suffix"); builder.AppendQuoted(settings.Suffix); } // 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")); } // Use the tool folder if (settings.OutputToToolFolder) { builder.Append("-Tool"); } // 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); }
private static void AddCommonParameters(string name, string source, NuGetSourcesSettings settings, ProcessArgumentBuilder builder) { builder.Append("-Name"); builder.AppendQuoted(name); builder.Append("-Source"); if (settings.IsSensitiveSource) { // Sensitive information in source. builder.AppendQuotedSecret(source); } else { builder.AppendQuoted(source); } // Verbosity? if (settings.Verbosity.HasValue) { builder.Append("-Verbosity"); builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant()); } builder.Append("-NonInteractive"); }
public IProcessAsyncOperation StartActivity (AndroidDevice device, string activity, ProcessEventHandler outputLog, ProcessEventHandler errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-s", device.ID, "shell", "am", "start", "-a", "android.intent.action.MAIN", "-n"); args.AddQuoted (activity); return StartProcess (AdbExe, args.ToString (), outputLog, errorLog); }
public IProcessAsyncOperation SetProperty (AndroidDevice device, string property, string value, TextWriter outputLog, TextWriter errorLog) { if (property == null) throw new ArgumentNullException ("property"); if (value == null) throw new ArgumentNullException ("value"); var args = new ProcessArgumentBuilder (); args.Add ("-s", device.ID, "shell", "setprop"); args.AddQuoted (property, value); return StartProcess (AdbExe, args.ToString (), outputLog, errorLog); }
public IProcessAsyncOperation AlignPackage (string srcApk, string destApk, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-f"); args.Add ("4"); args.AddQuoted (srcApk); args.AddQuoted (destApk); return StartProcess (ZipAlignExe, args.ToString (), outputLog, errorLog); }
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.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.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); }
/// <summary> /// Runs the tool using a custom tool path and the specified settings. /// </summary> /// <param name="settings">The settings.</param> /// <param name="arguments">The arguments.</param> /// <param name="processSettings">The process settings</param> /// <returns>The process that the tool is running under.</returns> protected IProcess RunProcess( TSettings settings, ProcessArgumentBuilder arguments, ProcessSettings processSettings) { if (arguments == null && (processSettings?.Arguments == null)) { throw new ArgumentNullException(nameof(arguments)); } // Should we customize the arguments? if (settings.ArgumentCustomization != null) { arguments = settings.ArgumentCustomization(arguments); } // Get the tool name. var toolName = GetToolName(); // Get the tool path. var toolPath = GetToolPath(settings); if (toolPath == null || !_fileSystem.Exist(toolPath)) { const string message = "{0}: Could not locate executable."; throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName)); } // Get the working directory. var workingDirectory = GetWorkingDirectory(settings); if (workingDirectory == null) { const string message = "{0}: Could not resolve working directory."; throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName)); } // Create the process start info. var info = processSettings ?? new ProcessSettings(); if (info.Arguments == null) { info.Arguments = arguments; } if (info.WorkingDirectory == null) { info.WorkingDirectory = workingDirectory.MakeAbsolute(_environment).FullPath; } if (info.EnvironmentVariables == null) { info.EnvironmentVariables = GetEnvironmentVariables(settings); } // Run the process. var process = _processRunner.Start(toolPath, info); if (process == null) { const string message = "{0}: Process was not started."; throw new CakeException(string.Format(CultureInfo.InvariantCulture, message, toolName)); } return(process); }
protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder(); TargetArchitecture architectures; bool msym; if (string.IsNullOrEmpty(Architectures) || !Enum.TryParse(Architectures, out architectures)) { architectures = TargetArchitecture.Default; } if (architectures == TargetArchitecture.ARMv6) { Log.LogError("Target architecture ARMv6 is no longer supported in Xamarin.iOS. Please select a supported architecture."); return(null); } if (!string.IsNullOrEmpty(IntermediateOutputPath)) { Directory.CreateDirectory(IntermediateOutputPath); args.AddQuoted("--cache=" + Path.GetFullPath(IntermediateOutputPath)); } args.AddQuoted((SdkIsSimulator ? "--sim=" : "--dev=") + Path.GetFullPath(AppBundleDir)); if (AppleSdkSettings.XcodeVersion.Major >= 5 && IPhoneSdks.MonoTouch.Version.CompareTo(new IPhoneSdkVersion(6, 3, 7)) < 0) { args.Add("--compiler=clang"); } args.AddQuoted("--executable=" + ExecutableName); if (IsAppExtension) { args.Add("--extension"); } if (Debug) { if (FastDev && !SdkIsSimulator) { args.Add("--fastdev"); } args.Add("--debug"); } if (Profiling) { args.Add("--profiling"); } if (LinkerDumpDependencies) { args.Add("--linkerdumpdependencies"); } if (EnableSGenConc) { args.Add("--sgen-conc"); } switch (LinkMode.ToLowerInvariant()) { case "sdkonly": args.Add("--linksdkonly"); break; case "none": args.Add("--nolink"); break; } if (!string.IsNullOrEmpty(I18n)) { args.AddQuotedFormat("--i18n=" + I18n); } args.AddQuoted("--sdkroot=" + SdkRoot); args.AddQuoted("--sdk=" + SdkVersion); if (!minimumOSVersion.IsUseDefault) { args.AddQuoted("--targetver=" + minimumOSVersion.ToString()); } if (UseFloat32 /* We want to compile 32-bit floating point code to use 32-bit floating point operations */) { args.Add("--aot-options=-O=float32"); } else { args.Add("--aot-options=-O=-float32"); } if (!EnableGenericValueTypeSharing) { args.Add("--gsharedvt=false"); } if (LinkDescriptions != null) { foreach (var desc in LinkDescriptions) { args.AddQuoted(string.Format("--xml={0}", desc.ItemSpec)); } } if (EnableBitcode) { switch (Framework) { case PlatformFramework.WatchOS: args.Add("--bitcode=full"); break; case PlatformFramework.TVOS: args.Add("--bitcode=asmonly"); break; default: throw new InvalidOperationException(string.Format("Bitcode is currently not supported on {0}.", Framework)); } } if (!string.IsNullOrEmpty(HttpClientHandler)) { args.Add(string.Format("--http-message-handler={0}", HttpClientHandler)); } string thumb = UseThumb && UseLlvm ? "+thumb2" : ""; string llvm = UseLlvm ? "+llvm" : ""; string abi = ""; if (SdkIsSimulator) { if (architectures.HasFlag(TargetArchitecture.i386)) { abi += (abi.Length > 0 ? "," : "") + "i386"; } if (architectures.HasFlag(TargetArchitecture.x86_64)) { abi += (abi.Length > 0 ? "," : "") + "x86_64"; } if (string.IsNullOrEmpty(abi)) { architectures = TargetArchitecture.i386; abi = "i386"; } } else { if (architectures == TargetArchitecture.Default) { architectures = TargetArchitecture.ARMv7; } if (architectures.HasFlag(TargetArchitecture.ARMv7)) { abi += (abi.Length > 0 ? "," : "") + "armv7" + llvm + thumb; } if (architectures.HasFlag(TargetArchitecture.ARMv7s)) { abi += (abi.Length > 0 ? "," : "") + "armv7s" + llvm + thumb; } if (architectures.HasFlag(TargetArchitecture.ARM64)) { // Note: ARM64 does not have thumb. abi += (abi.Length > 0 ? "," : "") + "arm64" + llvm; } if (architectures.HasFlag(TargetArchitecture.ARMv7k)) { abi += (abi.Length > 0 ? "," : "") + "armv7k" + llvm; } if (string.IsNullOrEmpty(abi)) { abi = "armv7" + llvm + thumb; } } // Output the CompiledArchitectures CompiledArchitectures = architectures.ToString(); args.Add("--abi=" + abi); // output symbols to preserve when stripping args.AddQuoted("--symbollist=" + Path.GetFullPath(SymbolsList)); // don't have mtouch generate the dsyms... args.Add("--dsym=no"); if (!string.IsNullOrEmpty(ArchiveSymbols) && bool.TryParse(ArchiveSymbols.Trim(), out msym)) { args.Add("--msym=" + (msym ? "yes" : "no")); } var gcc = new GccOptions(); if (!string.IsNullOrEmpty(ExtraArgs)) { var extraArgs = ProcessArgumentBuilder.Parse(ExtraArgs); var target = MainAssembly.ItemSpec; string projectDir; if (ProjectDir.StartsWith("~/", StringComparison.Ordinal)) { // Note: Since the Visual Studio plugin doesn't know the user's home directory on the Mac build host, // it simply uses paths relative to "~/". Expand these paths to their full path equivalents. var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); projectDir = Path.Combine(home, ProjectDir.Substring(2)); } else { projectDir = ProjectDir; } var customTags = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", projectDir }, // Apparently msbuild doesn't propagate the solution path, so we can't get it. // { "solutiondir", proj.ParentSolution != null ? proj.ParentSolution.BaseDirectory : proj.BaseDirectory }, { "appbundledir", AppBundleDir }, { "targetpath", Path.Combine(Path.GetDirectoryName(target), Path.GetFileName(target)) }, { "targetdir", Path.GetDirectoryName(target) }, { "targetname", Path.GetFileName(target) }, { "targetext", Path.GetExtension(target) }, }; for (int i = 0; i < extraArgs.Length; i++) { var argument = extraArgs[i]; int startIndex = 0; while (argument.Length > startIndex && argument[startIndex] == '-') { startIndex++; } int endIndex = startIndex; while (endIndex < argument.Length && argument[endIndex] != '=') { endIndex++; } int length = endIndex - startIndex; if (length == 9 && string.CompareOrdinal(argument, startIndex, "gcc_flags", 0, 9) == 0) { // user-defined -gcc_flags argument string flags = null; if (endIndex < extraArgs[i].Length) { flags = Unquote(argument, endIndex + 1); } else if (i + 1 < extraArgs.Length) { flags = extraArgs[++i]; } if (!string.IsNullOrEmpty(flags)) { var gccArgs = ProcessArgumentBuilder.Parse(flags); for (int j = 0; j < gccArgs.Length; j++) { gcc.Arguments.Add(StringParserService.Parse(gccArgs[j], customTags)); } } } else { // other user-defined mtouch arguments args.AddQuoted(StringParserService.Parse(argument, customTags)); } } } BuildNativeReferenceFlags(gcc); BuildEntitlementFlags(gcc); foreach (var framework in gcc.Frameworks) { args.AddQuoted("--framework=" + framework); } foreach (var framework in gcc.WeakFrameworks) { args.AddQuoted("--weak-framework=" + framework); } if (gcc.Cxx) { args.Add("--cxx"); } if (gcc.Arguments.Length > 0) { args.Add("--gcc_flags"); args.AddQuoted(gcc.Arguments.ToString()); } foreach (var asm in References) { if (IsFrameworkItem(asm)) { args.AddQuoted("-r=" + ResolveFrameworkFile(asm.ItemSpec)); } else { args.AddQuoted("-r=" + Path.GetFullPath(asm.ItemSpec)); } } foreach (var ext in AppExtensionReferences) { args.AddQuoted("--app-extension=" + Path.GetFullPath(ext.ItemSpec)); } args.Add("--target-framework=" + TargetFrameworkIdentifier + "," + TargetFrameworkVersion); args.AddQuoted("--root-assembly=" + Path.GetFullPath(MainAssembly.ItemSpec)); // We give the priority to the ExtraArgs to set the mtouch verbosity. if (string.IsNullOrEmpty(ExtraArgs) || (!string.IsNullOrEmpty(ExtraArgs) && !ExtraArgs.Contains("-q") && !ExtraArgs.Contains("-v"))) { args.Add(GetVerbosityLevel(Verbosity)); } if (!string.IsNullOrWhiteSpace(License)) { args.Add(string.Format("--license={0}", License)); } return(args.ToString()); }
private ProcessArgumentBuilder GetArguments( DotCoverContext context, DotCoverAnalyseSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); builder.Append("Analyse"); // 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 the report type, don't include the default value if (settings.ReportType != DotCoverReportType.XML) { builder.AppendSwitch("/ReportType", "=", settings.ReportType.ToString()); } // 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); }
static BuildResult SignAppBundle (IProgressMonitor monitor, IPhoneProject proj, IPhoneProjectConfiguration conf, X509Certificate2 key, string resRules, string xcent) { monitor.BeginTask (GettextCatalog.GetString ("Signing application"), 0); var args = new ProcessArgumentBuilder (); args.Add ("-v", "-f", "-s"); args.AddQuoted (Keychain.GetCertificateCommonName (key)); args.AddQuotedFormat ("--resource-rules={0}", resRules); args.Add ("--entitlements"); args.AddQuoted (xcent); args.AddQuoted (conf.AppDirectory); AddExtraArgs (args, conf.CodesignExtraArgs, proj, conf); int signResultCode; var psi = new ProcessStartInfo ("codesign") { UseShellExecute = false, RedirectStandardError = true, RedirectStandardOutput = true, Arguments = args.ToString (), }; monitor.Log.WriteLine ("codesign " + psi.Arguments); psi.EnvironmentVariables.Add ("CODESIGN_ALLOCATE", "/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/codesign_allocate"); string output; if ((signResultCode = MacBuildUtilities.ExecuteCommand (monitor, psi, out output)) != 0) { monitor.Log.WriteLine (output); return BuildError (string.Format ("Code signing failed with error code {0}. See output for details.", signResultCode)); } monitor.EndTask (); return null; }
private ProcessArgumentBuilder GetArguments(FilePath codeCoverageReportFilePath, CoverallsNetReportType reportType, CoverallsNetSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append(GetReportType(reportType)); builder.Append("--input"); builder.AppendQuoted(codeCoverageReportFilePath.MakeAbsolute(_environment).FullPath); if (settings.OutputFilePath != null) { builder.Append("--output"); builder.AppendQuoted(settings.OutputFilePath.MakeAbsolute(_environment).FullPath); } if (settings.UseRelativePaths) { builder.Append("--useRelativePaths"); } if (settings.BaseFilePath != null) { builder.Append("--basePath"); builder.AppendQuoted(settings.BaseFilePath.MakeAbsolute(_environment).FullPath); } if (!string.IsNullOrWhiteSpace(settings.RepoToken)) { builder.Append("--repoToken"); builder.AppendQuotedSecret(settings.RepoToken); } if (!string.IsNullOrWhiteSpace(settings.RepoTokenVariable)) { builder.Append("--repoTokenVariable"); builder.AppendQuoted(settings.RepoTokenVariable); } if (!string.IsNullOrWhiteSpace(settings.CommitId)) { builder.Append("--commitId"); builder.AppendQuoted(settings.CommitId); } if (!string.IsNullOrWhiteSpace(settings.CommitBranch)) { builder.Append("--commitBranch"); builder.AppendQuoted(settings.CommitBranch); } if (!string.IsNullOrWhiteSpace(settings.CommitAuthor)) { builder.Append("--commitAuthor"); builder.AppendQuoted(settings.CommitAuthor); } if (!string.IsNullOrWhiteSpace(settings.CommitEmail)) { builder.Append("--commitEmail"); builder.AppendQuoted(settings.CommitEmail); } if (!string.IsNullOrWhiteSpace(settings.CommitMessage)) { builder.Append("--commitMessage"); builder.AppendQuoted(settings.CommitMessage); } if (!string.IsNullOrEmpty(settings.JobId)) { builder.Append("--jobId"); builder.Append(settings.JobId); } if (!string.IsNullOrWhiteSpace(settings.ServiceName)) { builder.Append("--serviceName"); builder.AppendQuoted(settings.ServiceName); } if (settings.TreatUploadErrorsAsWarnings) { builder.Append("--treatUploadErrorsAsWarnings"); } return(builder); }
public StartAvdOperation StartAvd (AndroidVirtualDevice avd) { var args = new ProcessArgumentBuilder (); args.Add ("-partition-size", "512", "-avd"); args.AddQuoted (avd.Name); args.Add ("-prop"); args.AddQuoted ("monodroid.avdname=" + avd.Name); var error = new StringWriter (); var process = StartProcess (EmulatorExe, args.ToString (), null, error); return new StartAvdOperation (process, error); }
/// <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); } } // 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"); } }
public IProcessAsyncOperation SignPackage (AndroidSigningOptions options, string unsignedApk, string signedApk, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-keystore"); args.AddQuoted (options.KeyStore); args.Add ("-storepass"); args.AddQuoted (options.StorePass); args.Add ("-keypass"); args.AddQuoted (options.KeyPass); args.Add ("-signedjar"); args.AddQuoted (signedApk, unsignedApk, options.KeyAlias); return StartProcess (JarsignerExe, args.ToString (), outputLog, errorLog); }
private static void AppendMSBuildSwitch(this ProcessArgumentBuilder builder, string @switch) => builder.Append($"/{@switch}");
protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder (); args.Add ("--compress"); args.AddQuoted (InputScene); args.Add ("-o"); args.AddQuoted (OutputScene); args.AddQuotedFormat ("--sdk-root={0}", SdkRoot); args.AddQuotedFormat ("--target-version-{0}={1}", OperatingSystem, SdkVersion); args.AddQuotedFormat ("--target-build-dir={0}", IntermediateOutputPath); return args.ToString (); }
private static void AppendMSBuildSwitchQuoted(this ProcessArgumentBuilder builder, string @switch, string value) => builder.AppendSwitchQuoted($"/{@switch}", ":", value);
/// <summary> /// Returns the arguments of the concrete runner. /// </summary> /// <param name="builder">Argument builder instance.</param> /// <param name="configFile">The optional path to the docfx.json config file.</param> /// <param name="settings">The settings.</param> protected abstract void GetArguments(ProcessArgumentBuilder builder, FilePath configFile, T settings);
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); }
protected int Compile(ITaskItem[] items, ITaskItem output, ITaskItem manifest) { var environment = new Dictionary <string, string> (); var args = new ProcessArgumentBuilder(); if (!string.IsNullOrEmpty(SdkBinPath)) { environment.Add("PATH", SdkBinPath); } if (!string.IsNullOrEmpty(SdkUsrPath)) { environment.Add("XCODE_DEVELOPER_USR_PATH", SdkUsrPath); } args.Add("--errors", "--warnings", "--notices"); args.Add("--output-format", "xml1"); AppendCommandLineArguments(environment, args, items); if (Link) { args.Add("--link"); } else if (UseCompilationDirectory) { args.Add("--compilation-directory"); } else { args.Add("--compile"); } args.AddQuoted(output.GetMetadata("FullPath")); foreach (var item in items) { args.AddQuoted(item.GetMetadata("FullPath")); } var startInfo = GetProcessStartInfo(environment, GetFullPathToTool(), args.ToString()); try { Log.LogMessage(MessageImportance.Normal, "Tool {0} execution started with arguments: {1}", startInfo.FileName, startInfo.Arguments); using (var stdout = File.CreateText(manifest.ItemSpec)) { var errors = new StringBuilder(); int exitCode; using (var stderr = new StringWriter(errors)) { var process = ProcessUtils.StartProcess(startInfo, stdout, stderr); process.Wait(); exitCode = process.Result; } Log.LogMessage(MessageImportance.Low, "Tool {0} execution finished (exit code = {1}).", startInfo.FileName, exitCode); if (exitCode != 0) { Log.LogError(null, null, null, items[0].ItemSpec, 0, 0, 0, 0, "{0}", errors); } return(exitCode); } } catch (Exception ex) { Log.LogError("Error executing tool '{0}': {1}", startInfo.FileName, ex.Message); File.Delete(manifest.ItemSpec); return(-1); } }
/// <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="text">The secret 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 AppendSwitchQuotedSecret(this ProcessArgumentBuilder builder, string @switch, string text) { return(AppendSwitchQuotedSecret(builder, @switch, " ", text)); }
/// <summary> /// Runs the tool using the specified settings. /// </summary> /// <param name="settings">The settings.</param> /// <param name="arguments">The arguments.</param> protected void Run(TSettings settings, ProcessArgumentBuilder arguments) { Run(settings, arguments, null, null); }
/// <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="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, IProcessArgument argument) { return(AppendQuotedSecret(builder, @switch, " ", argument)); }
void BuildNativeReferenceFlags(GccOptions gcc) { if (NativeReferences == null) { return; } foreach (var item in NativeReferences) { var value = item.GetMetadata("Kind"); NativeReferenceKind kind; bool boolean; if (string.IsNullOrEmpty(value) || !Enum.TryParse(value, out kind)) { Log.LogWarning("Unknown native reference type for '{0}'.", item.ItemSpec); continue; } if (kind == NativeReferenceKind.Static) { var libName = Path.GetFileName(item.ItemSpec); if (libName.EndsWith(".a", StringComparison.Ordinal)) { libName = libName.Substring(0, libName.Length - 2); } if (libName.StartsWith("lib", StringComparison.Ordinal)) { libName = libName.Substring(3); } if (!string.IsNullOrEmpty(Path.GetDirectoryName(item.ItemSpec))) { gcc.Arguments.AddQuoted("-L" + Path.GetDirectoryName(item.ItemSpec)); } gcc.Arguments.AddQuoted("-l" + libName); value = item.GetMetadata("ForceLoad"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { gcc.Arguments.Add("-force_load"); gcc.Arguments.AddQuoted(item.ItemSpec); } value = item.GetMetadata("IsCxx"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { gcc.Cxx = true; } } else if (kind == NativeReferenceKind.Framework) { gcc.Frameworks.Add(item.ItemSpec); } else { Log.LogWarning("Dynamic native references are not supported: '{0}'", item.ItemSpec); continue; } value = item.GetMetadata("NeedsGccExceptionHandling"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { if (!gcc.Arguments.Contains("-lgcc_eh")) { gcc.Arguments.Add("-lgcc_eh"); } } value = item.GetMetadata("WeakFrameworks"); if (!string.IsNullOrEmpty(value)) { foreach (var framework in value.Split(' ', '\t')) { gcc.WeakFrameworks.Add(framework); } } value = item.GetMetadata("Frameworks"); if (!string.IsNullOrEmpty(value)) { foreach (var framework in value.Split(' ', '\t')) { gcc.Frameworks.Add(framework); } } // Note: these get merged into gccArgs by our caller value = item.GetMetadata("LinkerFlags"); if (!string.IsNullOrEmpty(value)) { var linkerFlags = ProcessArgumentBuilder.Parse(value); foreach (var flag in linkerFlags) { gcc.Arguments.AddQuoted(flag); } } } }
/// <summary> /// Formats, quotes and appends the specified text to the argument builder. /// </summary> /// <param name="builder">The builder.</param> /// <param name="format">A composite format string to be quoted and appended.</param> /// <param name="args">An object array that contains zero or more objects to format.</param> /// <returns>The same <see cref="ProcessArgumentBuilder"/> instance so that multiple calls can be chained.</returns> /// <exception cref="ArgumentNullException"><paramref name="format" /> or <paramref name="args" /> is null. </exception> /// <exception cref="FormatException"><paramref name="format" /> is invalid.-or- The index of a format item is less than zero, or greater than or equal to the length of the <paramref name="args" /> array. </exception> public static ProcessArgumentBuilder AppendQuoted(this ProcessArgumentBuilder builder, string format, params object[] args) { var text = string.Format(CultureInfo.InvariantCulture, format, args); return(AppendQuoted(builder, text)); }
public GccOptions() { Arguments = new ProcessArgumentBuilder(); WeakFrameworks = new HashSet <string> (); Frameworks = new HashSet <string> (); }
private static ProcessArgumentBuilder GetArguments( PackageReference definition, DotNetToolOperation operation, ICakeLog log, DirectoryPath toolDirectoryPath) { var arguments = new ProcessArgumentBuilder(); arguments.Append("tool"); arguments.Append(Enum.GetName(typeof(DotNetToolOperation), operation).ToLowerInvariant()); arguments.AppendQuoted(definition.Package); if (definition.Parameters.ContainsKey("global")) { arguments.Append("--global"); } else { arguments.Append("--tool-path"); arguments.AppendQuoted(toolDirectoryPath.FullPath); } if (operation != DotNetToolOperation.Uninstall) { if (definition.Address != null) { arguments.Append("--add-source"); arguments.AppendQuoted(definition.Address.AbsoluteUri); } // Version if (definition.Parameters.ContainsKey("version")) { arguments.Append("--version"); arguments.Append(definition.Parameters["version"].First()); } // Config File if (definition.Parameters.ContainsKey("configfile")) { arguments.Append("--configfile"); arguments.AppendQuoted(definition.Parameters["configfile"].First()); } // Whether to ignore failed sources if (definition.Parameters.ContainsKey("ignore-failed-sources")) { arguments.Append("--ignore-failed-sources"); } // Framework if (definition.Parameters.ContainsKey("framework")) { arguments.Append("--framework"); arguments.Append(definition.Parameters["framework"].First()); } switch (log.Verbosity) { case Verbosity.Quiet: arguments.Append("--verbosity"); arguments.Append("quiet"); break; case Verbosity.Minimal: arguments.Append("--verbosity"); arguments.Append("minimal"); break; case Verbosity.Normal: arguments.Append("--verbosity"); arguments.Append("normal"); break; case Verbosity.Verbose: arguments.Append("--verbosity"); arguments.Append("detailed"); break; case Verbosity.Diagnostic: arguments.Append("--verbosity"); arguments.Append("diagnostic"); break; default: arguments.Append("--verbosity"); arguments.Append("normal"); break; } } return(arguments); }
static internal void AppendExtrasMtouchArgs (ProcessArgumentBuilder args, IPhoneSdkVersion sdkVersion, IPhoneProject proj, IPhoneProjectConfiguration conf) { if (conf.MtouchDebug) args.Add ("-debug"); switch (conf.MtouchLink) { case MtouchLinkMode.SdkOnly: args.Add ("-linksdkonly"); break; case MtouchLinkMode.None: args.Add ("-nolink"); break; case MtouchLinkMode.Full: default: break; } if (!string.IsNullOrEmpty (conf.MtouchI18n)) { args.AddQuotedFormat ("-i18n={0}", conf.MtouchI18n); } if (!sdkVersion.Equals (IPhoneSdkVersion.V3_0)) args.AddQuotedFormat ("-sdk={0}", sdkVersion); if (conf.MtouchMinimumOSVersion != "3.0") args.AddQuotedFormat ("-targetver={0}", conf.MtouchMinimumOSVersion); AddExtraArgs (args, conf.MtouchExtraArgs, proj, conf); }
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; }
public void Test_That_Argument_Starting_With_Sigil_Is_Quoted(Type escapeHandlerType, string sigil) { // Arrange var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler; var builder = new ProcessArgumentBuilder(escapeHandler); builder.AddArgument($"{sigil}test"); // Act var result = builder.Build(); // Assert Assert.Equal($"\"{sigil}test\"", result); }
public static void DotNetCoreExecute(this ICakeContext context, FilePath assemblyPath, ProcessArgumentBuilder arguments) { context.DotNetCoreExecute(assemblyPath, arguments, null); }
//string dname = "CN=Android Debug,O=Android,C=US"; public IProcessAsyncOperation Genkeypair (AndroidSigningOptions options, string dname, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-genkeypair"); args.Add ("-alias"); args.AddQuoted (options.KeyAlias); args.Add ("-dname"); args.AddQuoted (dname); args.Add ("-storepass"); args.AddQuoted (options.StorePass); args.Add ("-keypass"); args.AddQuoted (options.KeyPass); args.Add ("-keystore"); args.AddQuoted (options.KeyStore); return StartProcess (KeytoolExe, args.ToString (), outputLog, errorLog); }
public static void DotNetCoreExecute(this ICakeContext context, FilePath assemblyPath, ProcessArgumentBuilder arguments, DotNetCoreExecuteSettings settings) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (assemblyPath == null) { throw new ArgumentNullException(nameof(assemblyPath)); } if (settings == null) { settings = new DotNetCoreExecuteSettings(); } var executor = new DotNetCoreExecutor(context.FileSystem, context.Environment, context.ProcessRunner, context.Tools); executor.Execute(assemblyPath, arguments, settings); }
public IProcessAsyncOperation PullFile (AndroidDevice device, string source, string destination, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-s", device.ID, "pull"); args.AddQuoted (source, destination); return StartProcess (AdbExe, args.ToString (), outputLog, errorLog); }
private void AppendUsernameAndPassword(ProcessArgumentBuilder builder) { builder.AppendIf(!StringUtil.IsBlank(Username), string.Format("-Y{0},{1}", Username, Password)); }
public IProcessAsyncOperation Uninstall (AndroidDevice device, string package, TextWriter outputLog, TextWriter errorLog) { var args = new ProcessArgumentBuilder (); args.Add ("-s", device.ID, "uninstall"); args.AddQuoted (package); return StartProcess (AdbExe, args.ToString (), outputLog, errorLog); }
private ProcessArgumentBuilder GetArguments(string apiKey, string source, ChocolateyApiKeySettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("apikey"); builder.Append("-s"); builder.AppendQuoted(source); builder.Append("-k"); builder.AppendQuoted(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 Unoffical if (settings.AllowUnoffical) { builder.Append("--allowunofficial"); } return(builder); }
public void Test_ToStringSafe(string argumentValueSeparator, string argumentValue, bool isSensitive, string expected, Type escapeHandlerType, string sigil) { // Arrange var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler; var builder = new ProcessArgumentBuilder(escapeHandler, argumentValueSeparator); builder.AddNamedArgument("-p", argumentValue, isSensitiveArgument: isSensitive); // Act var result = builder.BuildSafe(SAFE_PLACEHOLDER); // Assert Assert.Equal(expected, result); }
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.Labels) { builder.Append("-labels"); } 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); }
public static void DotNetCoreRun(this ICakeContext context, string project, ProcessArgumentBuilder arguments) { context.DotNetCoreRun(project, arguments, null); }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { IPhoneProject proj = item as IPhoneProject; if (proj == null || proj.CompileTarget != CompileTarget.Exe) return base.Build (monitor, item, configuration); //prebuild var conf = (IPhoneProjectConfiguration) proj.GetConfiguration (configuration); bool isDevice = conf.Platform == IPhoneProject.PLAT_IPHONE; if (IPhoneFramework.SimOnly && isDevice) { //if in the GUI, show a dialog too if (MonoDevelop.Ide.IdeApp.IsInitialized) Gtk.Application.Invoke (delegate { IPhoneFramework.ShowSimOnlyDialog (); } ); return IPhoneFramework.GetSimOnlyError (); } var result = new BuildResult (); var sdkVersion = conf.MtouchSdkVersion.ResolveIfDefault (); if (!IPhoneFramework.SdkIsInstalled (sdkVersion)) { sdkVersion = IPhoneFramework.GetClosestInstalledSdk (sdkVersion); if (sdkVersion.IsUseDefault || !IPhoneFramework.SdkIsInstalled (sdkVersion)) { if (conf.MtouchSdkVersion.IsUseDefault) result.AddError ( string.Format ("The Apple iPhone SDK is not installed.")); else result.AddError ( string.Format ("Apple iPhone SDK version '{0}' is not installed, and no newer version was found.", conf.MtouchSdkVersion)); return result; } result.AddWarning ( string.Format ("Apple iPhone SDK version '{0}' is not installed. Using newer version '{1}' instead'.", conf.MtouchSdkVersion, sdkVersion)); } IPhoneAppIdentity identity = null; if (isDevice) { monitor.BeginTask (GettextCatalog.GetString ("Detecting signing identity..."), 0); if ((result = GetIdentity (monitor, proj, conf, out identity).Append (result)).ErrorCount > 0) return result; monitor.Log.WriteLine ("Provisioning profile: \"{0}\" ({1})", identity.Profile.Name, identity.Profile.Uuid); monitor.Log.WriteLine ("Signing Identity: \"{0}\"", Keychain.GetCertificateCommonName (identity.SigningKey)); monitor.Log.WriteLine ("App ID: \"{0}\"", identity.AppID); monitor.EndTask (); } else { identity = new IPhoneAppIdentity () { BundleID = !string.IsNullOrEmpty (proj.BundleIdentifier)? proj.BundleIdentifier : GetDefaultBundleID (proj, null) }; } result = base.Build (monitor, item, configuration).Append (result); if (result.ErrorCount > 0) return result; if (!Directory.Exists (conf.AppDirectory)) Directory.CreateDirectory (conf.AppDirectory); var assemblyRefs = proj.GetReferencedAssemblies (configuration).Distinct ().ToList (); FilePath mtouchOutput = conf.NativeExe; if (new FilePair (conf.CompiledOutputName, mtouchOutput).NeedsBuilding ()) { BuildResult error; var mtouch = GetMTouch (proj, monitor, out error); if (error != null) return error.Append (result); var args = new ProcessArgumentBuilder (); //FIXME: make verbosity configurable? args.Add ("-v"); args.Add ("--nomanifest", "--nosign"); //FIXME: should we error out if the platform is invalid? if (conf.Platform == IPhoneProject.PLAT_IPHONE) { args.Add ("-dev"); args.AddQuoted (conf.AppDirectory); } else { args.Add ("-sim"); args.AddQuoted (conf.AppDirectory); } foreach (string asm in assemblyRefs) args.AddQuotedFormat ("-r={0}", asm); AppendExtrasMtouchArgs (args, sdkVersion, proj, conf); args.AddQuoted (conf.CompiledOutputName); mtouch.WorkingDirectory = conf.OutputDirectory; mtouch.Arguments = args.ToString (); monitor.BeginTask (GettextCatalog.GetString ("Compiling to native code"), 0); string output; int code; monitor.Log.WriteLine ("{0} {1}", mtouch.FileName, mtouch.Arguments); if ((code = MacBuildUtilities.ExecuteCommand (monitor, mtouch, out output)) != 0) { if (String.IsNullOrEmpty (output)) { result.AddError (null, 0, 0, code.ToString (), "mtouch failed with no output"); } else { result.AddError (null, 0, 0, code.ToString (), "mtouch failed with the following message:\n" + output); } return result; } monitor.EndTask (); } if (result.Append (UnpackContent (monitor, conf, assemblyRefs)).ErrorCount > 0) return result; //create the info.plist, merging in the template if it exists var plistOut = conf.AppDirectory.Combine ("Info.plist"); ProjectFile appInfoIn = proj.Files.GetFile (proj.BaseDirectory.Combine ("Info.plist")); if (new FilePair (proj.FileName, plistOut).NeedsBuilding () || (appInfoIn != null && new FilePair (appInfoIn.FilePath, plistOut).NeedsBuilding ())) { try { monitor.BeginTask (GettextCatalog.GetString ("Updating application manifest"), 0); if (result.Append (UpdateInfoPlist (monitor, sdkVersion, proj, conf, identity, appInfoIn, plistOut)).ErrorCount > 0) return result; } finally { monitor.EndTask (); } } //create the Setting.bundle plist for debug settings, merging in the template if it exists try { monitor.BeginTask (GettextCatalog.GetString ("Updating debug settings manifest"), 0); var sbRootRel = Path.Combine ("Settings.bundle", "Root.plist"); var sbRootOut = conf.AppDirectory.Combine (sbRootRel); var sbRootIn = proj.Files.GetFile (proj.BaseDirectory.Combine (sbRootRel)); if (result.Append (UpdateDebugSettingsPlist (monitor, conf, sbRootIn, sbRootOut)).ErrorCount > 0) return result; } finally { monitor.EndTask (); } try { if (result.Append (ProcessPackaging (monitor, sdkVersion, proj, conf, identity)).ErrorCount > 0) return result; } finally { //if packaging failed, make sure that it's marked as needing building if (result.ErrorCount > 0 && File.Exists (conf.AppDirectory.Combine ("PkgInfo"))) File.Delete (conf.AppDirectory.Combine ("PkgInfo")); } //TODO: create/update the xcode project return result; }