public void AppendSwitchSimple() { CommandLineBuilder c = new CommandLineBuilder(); c.AppendSwitch("/a"); c.AppendSwitch("-b"); Assert.Equal("/a -b", c.ToString()); }
protected override void GenerateCommandLineCommands(CommandLineBuilder commandLineBuilder) { if (Source != null) { foreach (var item in Source) { commandLineBuilder.AppendSwitchIfNotNull("-Source ", item.ItemSpec); } } if (FallbackSource != null) { foreach (var item in FallbackSource) { commandLineBuilder.AppendSwitchIfNotNull("-FallbackSource ", item.ItemSpec); } } if (NoCache) { commandLineBuilder.AppendSwitch("-NoCache"); } if (DisableParallelProcessing) { commandLineBuilder.AppendSwitch("-DisableParallelProcessing"); } commandLineBuilder.AppendSwitchIfNotNull("-PackageSaveMode ", PackageSaveMode); }
protected override string GenerateCommandLineCommands() { CommandLineBuilder clb = new CommandLineBuilder(); clb.AppendSwitch("describe"); return clb.ToString(); }
protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendFileNameIfNotNull(Source); if (Source != null) { OutputRes = Path.ChangeExtension(OutputIL, ".res"); } builder.AppendSwitch("/nobar"); builder.AppendSwitchIfNotNull("/output=", OutputIL); if (Encoding == null || Encoding.StartsWith("uni", StringComparison.InvariantCultureIgnoreCase)) { builder.AppendSwitch("/unicode"); } if (Encoding != null && Encoding.StartsWith("utf", StringComparison.InvariantCultureIgnoreCase)) { builder.AppendSwitch("/utf8"); } builder.AppendSwitchIfNotNull("/item:", Item); Log.LogMessage(MessageImportance.High, "Disassembling {0}...", Source); return builder.ToString(); }
public string Parse(ITaskItem taskItem, bool fullOutputName, string outputExtension) { CommandLineBuilder builder = new CommandLineBuilder(); foreach (string name in taskItem.MetadataNames) { string value = taskItem.GetMetadata(name); if (outputExtension != null && name == "OutputFile") { value = Path.ChangeExtension(value, outputExtension); } if (fullOutputName && name == "ObjectFileName") { if ((File.GetAttributes(value) & FileAttributes.Directory) != 0) { value = Path.Combine(value, Path.GetFileName(taskItem.ItemSpec)); value = Path.ChangeExtension(value, ".obj"); } } AppendArgumentForProperty(builder, name, value); } string result = builder.ToString(); result = result.Replace('\\', '/'); // posix paths return result; }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("update"); builder.AppendFileNameIfNotNull(Package); builder.AppendSwitchIfNotNull("-Version ", Version); builder.AppendSwitchIfNotNull("-Source ", Source); builder.AppendSwitchIfNotNull("-OutputDirectory ", OutputDirectory); builder.AppendSwitchIfNotNull("-RepositoryPath ", RepositoryPath); builder.AppendSwitchIfNotNull("-OutputDirectory ", OutputDirectory); builder.AppendSwitchIfNotNull("-FileConflictAction ", FileConflictAction); builder.AppendSwitchIfNotNull("-Verbosity ", Verbosity); builder.AppendSwitchIfNotNull("-ConfigFile ", ConfigFile); if (Prerelease) builder.AppendSwitch("-Prerelease"); if (Safe) builder.AppendSwitch("-Safe"); if (Self) builder.AppendSwitch("-Self"); builder.AppendSwitch("-NonInteractive"); return builder.ToString(); }
protected override string GenerateCommandLineCommands() { // Running command: C:\Program Files (x86)\Java\jdk1.6.0_20\bin\javac.exe // "-J-Dfile.encoding=UTF8" // "-d" "bin\classes" // "-classpath" "C:\Users\Jonathan\Documents\Visual Studio 2010\Projects\AndroidMSBuildTest\AndroidMSBuildTest\obj\Debug\android\bin\mono.android.jar" // "-bootclasspath" "C:\Program Files (x86)\Android\android-sdk-windows\platforms\android-8\android.jar" // "-encoding" "UTF-8" // "@C:\Users\Jonathan\AppData\Local\Temp\tmp79c4ac38.tmp" //var android_dir = MonoDroid.MonoDroidSdk.GetAndroidProfileDirectory (TargetFrameworkDirectory); var cmd = new CommandLineBuilder (); cmd.AppendSwitchIfNotNull ("-J-Dfile.encoding=", "UTF8"); cmd.AppendSwitchIfNotNull ("-d ", ClassesOutputDirectory); cmd.AppendSwitchIfNotNull ("-classpath ", Jars == null || !Jars.Any () ? null : string.Join (Path.PathSeparator.ToString (), Jars.Select (i => i.ItemSpec))); cmd.AppendSwitchIfNotNull ("-bootclasspath ", JavaPlatformJarPath); cmd.AppendSwitchIfNotNull ("-encoding ", "UTF-8"); cmd.AppendFileNameIfNotNull (string.Format ("@{0}", TemporarySourceListFile)); cmd.AppendSwitchIfNotNull ("-target ", JavacTargetVersion); cmd.AppendSwitchIfNotNull ("-source ", JavacSourceVersion); return cmd.ToString (); }
/// <summary> /// Construct the command line from the task properties by using the CommandLineBuilder /// </summary> /// <returns></returns> protected override string GenerateCommandLineCommands() { CommandLineBuilder builder = new CommandLineBuilder(); foreach(ITaskItem iti in this._sources) { builder.AppendFileNameIfNotNull(iti); } if (this._configurationFile != null) { builder.AppendSwitchIfNotNull("/config:", new string[] {this._configurationFile}, ":"); } if (this._filename != null) { builder.AppendSwitchIfNotNull("/fileName:", new string[] {this._filename}, ":"); } // Log a High importance message stating the file that we are assembling Log.LogMessage(MessageImportance.High, "Assembling {0}", this._sources); // We have all of our switches added, return the commandline as a string return builder.ToString(); }
/// <summary> /// Generates the command line commands. /// </summary> protected override string GenerateCommandLineCommands() { ////if (this.Assemblies.Length != 1) { //// throw new NotSupportedException("Exactly 1 assembly for signing is supported."); ////} CommandLineBuilder args = new CommandLineBuilder(); args.AppendSwitch("-q"); if (this.KeyFile != null) { args.AppendSwitch("-R"); } else if (this.KeyContainer != null) { args.AppendSwitch("-Rc"); } else { throw new InvalidOperationException("Either KeyFile or KeyContainer must be set."); } args.AppendFileNameIfNotNull(this.Assemblies[0]); if (this.KeyFile != null) { args.AppendFileNameIfNotNull(this.KeyFile); } else { args.AppendFileNameIfNotNull(this.KeyContainer); } return args.ToString(); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var commandLine = new CommandLineBuilder(); GenerateCommand(commandLine); GenerateArguments(commandLine); return commandLine.ToString(); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { CommandLineBuilder builder = new CommandLineBuilder(); builder.AppendSwitchIfNotNull("/config:", ConfigFile); builder.AppendFileNameIfNotNull(ManifestFile); return builder.ToString(); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { CommandLineBuilder builder = new CommandLineBuilder(); builder.AppendSwitchIfNotNull("/d:", ChmDirectory); builder.AppendSwitchIfNotNull("/l:", LanguageId ?? "1033"); return builder.ToString(); }
protected override string GenerateCommandLineCommands() { CommandLineBuilder builder = new CommandLineBuilder(); builder.AppendSwitch("pack"); if (!File.Exists(this.Target)) { throw new FileNotFoundException(string.Format("The file '{0}' could not be found.", this.Target), this.Target); } builder.AppendFileNameIfNotNull(this.Target); builder.AppendSwitchIfTrue("-Symbols", this.Symbols); builder.AppendSwitchIfTrue("-NoDefaultExcludes", this.NoDefaultExcludes); builder.AppendSwitchIfTrue("-NoPackageAnalysis", this.NoPackageAnalysis); builder.AppendSwitchIfTrue("-ExcludeEmptyDirectories", this.ExcludeEmptyDirectories); builder.AppendSwitchIfTrue("-IncludeReferencedProjects", this.IncludeReferencedProjects); builder.AppendSwitchIfNotNull("-Version ", this.Version); builder.AppendSwitchIfNotNull("-Properties ", this.Properties, ";"); builder.AppendSwitchIfNotNull("-Exclude ", this.Excluded, ";"); builder.AppendSwitchIfNotNull("-MinClientVersion ", this.MinClientVersion); builder.AppendSwitchIfNotNull("-BasePath ", this.BasePath); builder.AppendSwitchIfNotNull("-OutputDirectory ", this.OutputDirectory); builder.AppendSwitchIfNotNull("-Verbosity ", this.Verbosity); builder.AppendSwitch("-NonInteractive "); builder.AppendTextUnquotedIfNotNullOrEmpty(this.CustomSwitches); return builder.ToString(); }
protected override string GenerateCommandLineCommands () { var builder = new CommandLineBuilder (); builder.AppendSwitch("p"); builder.AppendSwitch("-f"); var resdir = Path.Combine (ProjectDir, "res"); var reszip = Path.Combine (ProjectDir, ProjectName + "-res.zip"); if (Directory.Exists (resdir)) { builder.AppendSwitch("-S"); builder.AppendFileNameIfNotNull (resdir); } builder.AppendSwitch("-F"); builder.AppendFileNameIfNotNull (reszip); builder.AppendSwitch("-J"); builder.AppendFileNameIfNotNull (ProjectDir); builder.AppendSwitch ("-M"); builder.AppendFileNameIfNotNull (AndroidManifest); builder.AppendSwitch ("-I"); builder.AppendFileNameIfNotNull (FrameworkApk); return builder.ToString (); }
protected override string GenerateCommandLineCommands() { Log.LogDebugMessage ("MDoc"); Log.LogDebugMessage (" RunExport: {0}", RunExport); Log.LogDebugMessage (" TargetAssembly: {0}", TargetAssembly); Log.LogDebugMessage (" References"); if (References != null) foreach (var reference in References) Log.LogDebugMessage (" {0}", reference); Log.LogDebugMessage (" OutputDocDirectory: {0}", OutputDocDirectory); if (RunExport) { var cmd = new CommandLineBuilder (); cmd.AppendSwitch ("--debug"); cmd.AppendSwitch ("export-msxdoc"); cmd.AppendSwitchIfNotNull ("-o", Path.ChangeExtension (TargetAssembly, ".xml")); cmd.AppendSwitch (OutputDocDirectory); return cmd.ToString (); } else { var refPaths = References.Select (Path.GetDirectoryName).Distinct (); var cmd = new CommandLineBuilder (); cmd.AppendSwitch ("--debug"); cmd.AppendSwitch ("update"); cmd.AppendSwitch ("--delete"); cmd.AppendSwitchIfNotNull ("-L", Path.GetDirectoryName (TargetAssembly)); foreach (var rp in refPaths) cmd.AppendSwitchIfNotNull ("-L", rp); cmd.AppendSwitchIfNotNull ("-o", OutputDocDirectory); cmd.AppendSwitch (Path.GetFullPath (TargetAssembly)); return cmd.ToString (); } }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("kill-server"); return builder.ToString(); }
/// <summary> /// Generates the arguments. /// </summary> /// <param name="builder">The builder.</param> protected override void GenerateArguments(CommandLineBuilder builder) { builder.AppendSwitch("--count"); base.GenerateArguments(builder); builder.AppendSwitch(Revision); }
protected override string GenerateCommandLineCommands() { var args = new CommandLineBuilder (); args.AppendFileNameIfNotNull (Input); return args.ToString (); }
protected override void GenerateCommandLineCommands(CommandLineBuilder commandLineBuilder) { commandLineBuilder.AppendSwitch("setApiKey"); commandLineBuilder.AppendFileNameIfNotNull(ApiKey); commandLineBuilder.AppendSwitchIfNotNullOrWhiteSpace("-Source ", Source); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("wait-for-device"); return builder.ToString(); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("uninstall"); builder.AppendSwitch(PackageName); return builder.ToString(); }
/// <summary> /// Returns a string value containing the command line arguments to pass directly to the executable file. /// </summary> /// <returns> /// A string value containing the command line arguments to pass directly to the executable file. /// </returns> protected override string GenerateCommandLineCommands() { var args = new CommandLineBuilder(); args.AppendSwitch("pack"); args.AppendFileNameIfNotNull(this.NuSpec); args.AppendSwitchIfNotNull("-b ", this.BaseDirectory); args.AppendSwitchIfNotNull("-o ", this.OutputPackageDirectory); return args.ToString(); }
protected override void GenerateCommandLineCommands(CommandLineBuilder commandLineBuilder) { commandLineBuilder.AppendSwitch("config"); commandLineBuilder.AppendFileNameIfNotNull(Key); commandLineBuilder.AppendSwitchIfAny("-Set ", Set); commandLineBuilder.AppendSwitchIfTrue("-AsPath", AsPath); }
protected override string GenerateCommandLineCommands() { var args = new CommandLineBuilder(); args.AppendSwitch("a"); args.AppendSwitch("--"); args.AppendFileNameIfNotNull(this.ZipFileName); return args.ToString(); }
protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch(File); if (Args != null) builder.AppendSwitch(Args); return builder.ToString(); }
protected override void GenerateCommandLineCommands(CommandLineBuilder commandLineBuilder) { commandLineBuilder.AppendSwitch("add"); commandLineBuilder.AppendFileNameIfNotNull(Package); commandLineBuilder.AppendSwitchIfNotNullOrWhiteSpace("-Source ", Source); commandLineBuilder.AppendSwitchIfTrue("-Expand", Expand); }
protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitchIfNotNull("/source:", SourceDirectory); builder.AppendSwitchIfNotNull("/target:", TargetDirectory); builder.AppendSwitchIfNotNull("/output:", OutputUpdateFile); return builder.ToString(); }
/// <summary> /// Generates the arguments. /// </summary> /// <param name="builder">The builder.</param> protected override void GenerateArguments(CommandLineBuilder builder) { builder.AppendSwitch("--verify"); if (Short) builder.AppendSwitch("--short"); base.GenerateArguments(builder); builder.AppendSwitch(Revision); }
private string AppendArgumentForProperty(CommandLineBuilder builder, string name, string value) { PropertyWrapper current; ToolProperties.TryGetValue(name, out current); if (current != null && value.Length > 0) { // call appropriate function for type m_typeFunctionMap[current.PropertyType](builder, current.Property, value); } return string.Empty; }
protected override string GenerateCommandLineCommands() { var builder = new CommandLineBuilder(); builder.AppendSwitch("/r"); builder.AppendFileNameIfNotNull(Source); Output = Path.ChangeExtension(Source.ItemSpec, ".res"); Log.LogMessage(MessageImportance.High, "Generate res file from {0}...", Source); return builder.ToString(); }
/// <summary> /// Utility function to help to generate Switch per item /// </summary> /// <param name="commandLine"></param> /// <param name="strSwitch"></param> /// <param name="args"></param> private static void GenerateSwitchPerItem(Utilities.CommandLineBuilder commandLine, string strSwitch, string args) { if (!string.IsNullOrEmpty(args)) { foreach (string dl in args.Split(new char[] { ';' })) { if (!string.IsNullOrEmpty(dl)) { commandLine.AppendSwitchUnquotedIfNotNull(strSwitch, dl); } } } }
/// <summary> /// Utility to build DeclareParameterOptions /// </summary> /// <param name="commandLineBuilder"></param> /// <param name="items"></param> static public void AddDeclareParametersOptions(Utilities.CommandLineBuilder commandLineBuilder, Framework.ITaskItem[] originalItems, string valueQuote, bool foptimisticParameterDefaultValue) { System.Collections.Generic.IList <Framework.ITaskItem> items = MsDeploy.Utility.SortParametersTaskItems(originalItems, foptimisticParameterDefaultValue, MsDeploy.DeclareParameterMetadata.DefaultValue.ToString()); if (commandLineBuilder != null && items != null) { System.Collections.Generic.List <string> arguments = new System.Collections.Generic.List <string>(6); System.Collections.Generic.Dictionary <string, string> lookupDictionary = new System.Collections.Generic.Dictionary <string, string>(items.Count); foreach (Framework.ITaskItem item in items) { AddDeclareParameterToCommandArgument(arguments, item, valueQuote, lookupDictionary); commandLineBuilder.AppendSwitchUnquotedIfNotNull("-declareParam:", arguments.Count == 0 ? null : string.Join(",", arguments.ToArray())); } } }
static public void AddSkipDirectiveToBaseOptions(Utilities.CommandLineBuilder commandLineBuilder, Framework.ITaskItem[] skipRuleItems, string valueQuoteChar) { if (commandLineBuilder != null && skipRuleItems != null) // Dev10 bug 496639 foreach will throw the exception if the replaceRuleItem is null { System.Collections.Generic.List <string> arguments = new System.Collections.Generic.List <string>(6); foreach (Framework.ITaskItem item in skipRuleItems) { arguments.Clear(); MsDeploy.Utility.BuildArgumentsBaseOnEnumTypeName(item, arguments, typeof(MsDeploy.SkipRuleMetadata), valueQuoteChar); commandLineBuilder.AppendSwitchUnquotedIfNotNull("-skip:", arguments.Count == 0? null : string.Join(",", arguments.ToArray())); } } }
static internal void AddImportParametersFilesOptions(Utilities.CommandLineBuilder commandLineBuilder, string parameterFlag, Framework.ITaskItem[] items) { if (commandLineBuilder != null && !string.IsNullOrEmpty(parameterFlag) && items != null) // Dev10 bug 496639 foreach will throw the exception if the replaceRuleItem is null { foreach (Framework.ITaskItem item in items) { string fileName = item.ItemSpec; if (!string.IsNullOrEmpty(fileName)) { commandLineBuilder.AppendSwitch(string.Concat(parameterFlag, "\"", fileName, "\"")); } } } }
/// <summary> /// Utility function to set SimpleeSyncParameter Name/Value /// </summary> /// <param name="commandLineBuilder"></param> /// <param name="items"></param> static public void AddSimpleSetParametersToObject(Utilities.CommandLineBuilder commandLineBuilder, Framework.ITaskItem[] originalItems, string valueQuoteChar, bool foptimisticParameterDefaultValue) { System.Collections.Generic.IList <Framework.ITaskItem> items = MsDeploy.Utility.SortParametersTaskItems(originalItems, foptimisticParameterDefaultValue, MsDeploy.SimpleSyncParameterMetadata.Value.ToString()); if (commandLineBuilder != null && items != null) { System.Collections.Generic.List <string> arguments = new System.Collections.Generic.List <string>(6); foreach (Framework.ITaskItem item in items) { arguments.Clear(); // special for name string name = item.ItemSpec; if (!string.IsNullOrEmpty(name)) { string valueData = MsDeploy.Utility.PutValueInQuote(name, valueQuoteChar); arguments.Add(string.Concat("name=", valueData)); } // the rest, build on the enum name MsDeploy.Utility.BuildArgumentsBaseOnEnumTypeName(item, arguments, typeof(MsDeploy.SimpleSyncParameterMetadata), valueQuoteChar); commandLineBuilder.AppendSwitchUnquotedIfNotNull("-setParam:", arguments.Count == 0 ? null : string.Join(",", arguments.ToArray())); } } }
/// <summary> /// Generates command line arguments for msdeploy.exe /// </summary> protected override string GenerateCommandLineCommands() { Utilities.CommandLineBuilder commandLine = new Utilities.CommandLineBuilder(); AddDestinationProviderSettingToObject(commandLine, "-source:", this.Source, m_strValueQuote, null, this); AddDestinationProviderSettingToObject(commandLine, "-dest:", this.Destination, m_strValueQuote, AdditionalDestinationProviderOptions, this); commandLine.AppendSwitchUnquotedIfNotNull("-verb:", m_verb); commandLine.AppendSwitchUnquotedIfNotNull("-failureLevel:", m_failureLevel); commandLine.AppendSwitchUnquotedIfNotNull("-xpath:", m_xpath); commandLine.AppendSwitchUnquotedIfNotNull("-replace:", m_replace); commandLine.AppendSwitchUnquotedIfNotNull("-skip:", m_skip); GenerateSwitchPerItem(commandLine, "-enableRule:", m_enableRule); GenerateSwitchPerItem(commandLine, "-disableRule:", m_disableRule); GenerateSwitchPerItem(commandLine, "-enableLink:", m_enableLink); GenerateSwitchPerItem(commandLine, "-disableLink:", m_disableLink); GenerateSwitchPerItem(commandLine, "-disableSkipDirective:", m_disableSkipDirective); GenerateSwitchPerItem(commandLine, "-enableSkipDirective:", m_enableSkipDirective); // this allow multiple replace rule to happen, we should consider do the same thing for skip: AddReplaceRulesToOptions(commandLine, m_replaceRuleItemsITaskItem, m_strValueQuote); AddSkipDirectiveToBaseOptions(commandLine, m_skipRuleItemsITaskItem, m_strValueQuote); AddImportDeclareParametersFilesOptions(commandLine, m_importDeclareParametersItems); AddDeclareParametersOptions(commandLine, m_declareParameterItems, m_strValueQuote, OptimisticParameterDefaultValue); AddImportSetParametersFilesOptions(commandLine, m_importSetParametersItems); AddSimpleSetParametersToObject(commandLine, m_simpleSetParamterItems, m_strValueQuote, OptimisticParameterDefaultValue); AddSetParametersToObject(commandLine, m_setParamterItems, m_strValueQuote, OptimisticParameterDefaultValue); if (m_xml) { commandLine.AppendSwitch("-xml"); } if (m_whatif) { commandLine.AppendSwitch("-whatif"); } if (m_verbose) { commandLine.AppendSwitch("-verbose"); } if (m_allowUntrusted) { commandLine.AppendSwitch("-allowUntrusted"); } if (m_useChecksum) { commandLine.AppendSwitch("-useChecksum"); } if (m_enableTransaction) { commandLine.AppendSwitch("-enableTransaction"); } if (m_retryAttempts > 0) { commandLine.AppendSwitchUnquotedIfNotNull("-retryAttempts=", m_retryAttempts.ToString(CultureInfo.InvariantCulture)); } if (m_retryInterval > 0) { commandLine.AppendSwitchUnquotedIfNotNull("-retryInterval=", m_retryInterval.ToString(CultureInfo.InvariantCulture)); } if (!string.IsNullOrEmpty(UserAgent)) { commandLine.AppendSwitchUnquotedIfNotNull("-userAgent=", string.Concat("\"", UserAgent, "\"")); } //IISExpress support //public const string AppHostConfigDirectory = "-appHostConfigDir"; // * public const string WebServerDirectory = "-webServerDir"; // public const string WebServerManifest = "-webServerManifest"; commandLine.AppendSwitchIfNotNull("-appHostConfigDir:", WebServerAppHostConfigDirectory); commandLine.AppendSwitchIfNotNull("-webServerDir:", WebServerDirectory); // bug in msdeploy.exe currently only take the file name commandLine.AppendSwitchIfNotNull("-webServerManifest:", System.IO.Path.GetFileName(WebServerManifest)); m_lastCommandLine = commandLine.ToString(); // show arguments in the output Log.LogMessage(Framework.MessageImportance.Low, string.Concat("\"", GenerateFullPathToTool(), "\" ", m_lastCommandLine)); return(m_lastCommandLine); }
static public void AddDestinationProviderSettingToObject(Utilities.CommandLineBuilder commandLineBuilder, string dest, Framework.ITaskItem[] items, string valueQuoteChar, Framework.ITaskItem[] additionalProviderItems, MSDeploy msdeploy) { //commandLineBuilder.AppendSwitchUnquotedIfNotNull("-source:", m_source); //commandLineBuilder.AppendSwitchUnquotedIfNotNull("-dest:", m_dest); System.Collections.Generic.List <string> arguments = new System.Collections.Generic.List <string>(6); if (items != null && items.GetLength(0) == 1) { Framework.ITaskItem taskItem = items[0]; string provider = taskItem.ItemSpec; string path = taskItem.GetMetadata("Path"); string valueData = MsDeploy.Utility.PutValueInQuote(path, valueQuoteChar); string setData = (string.IsNullOrEmpty(path)) ? provider : string.Concat(provider, "=", valueData); arguments.Add(setData); //Commonly supported provider settings: // computerName=<name> Name of remote computer or proxy-URL // wmsvc=<name> Name of remote computer or proxy-URL for the Web // Management Service (wmsvc) // userName=<name> User name to authenticate // password=<password> Password of user name // encryptPassword=<pwd> Password to use for encryption related operations // includeAcls=<bool> If true, include ACLs in the operation for the // specified path foreach (string name in taskItem.MetadataNames) { if (!MsDeploy.Utility.IsInternalMsdeployWellKnownItemMetadata(name)) { string value = taskItem.GetMetadata(name); if (!string.IsNullOrEmpty(value)) { valueData = MsDeploy.Utility.PutValueInQuote(value, valueQuoteChar); setData = string.Concat(name, "=", valueData); arguments.Add(setData); } } else { MsDeploy.Utility.IISExpressMetadata expressMetadata; if (System.Enum.TryParse <MsDeploy.Utility.IISExpressMetadata>(name, out expressMetadata)) { string value = taskItem.GetMetadata(name); if (!string.IsNullOrEmpty(value)) { switch (expressMetadata) { case Utility.IISExpressMetadata.WebServerAppHostConfigDirectory: msdeploy.WebServerAppHostConfigDirectory = value; break; case Utility.IISExpressMetadata.WebServerDirectory: msdeploy.WebServerDirectory = value; break; case Utility.IISExpressMetadata.WebServerManifest: msdeploy.WebServerManifest = value; break; } } } } } } // If additional parameters are specified, we add these too. the itemSpec will be something like iisApp, contentPath, etc and // each item should have a name\value pair defined as metadata. Each provider will be written as itemSpec.Name=Value if (additionalProviderItems != null) { foreach (Framework.ITaskItem item in additionalProviderItems) { if (!string.IsNullOrEmpty(item.ItemSpec)) { string settingName = item.GetMetadata("Name"); string settingValue = item.GetMetadata("Value"); if (!string.IsNullOrEmpty(settingName) && !string.IsNullOrEmpty(settingValue)) { string providerString = string.Concat(item.ItemSpec, ".", settingName, "=", settingValue); arguments.Add(providerString); } } } } commandLineBuilder.AppendSwitchUnquotedIfNotNull(dest, arguments.Count == 0 ? null : string.Join(",", arguments.ToArray())); return; }
/// <summary> /// Utility function to setParameters in type, scope, match, value of SyncParameter /// </summary> /// <param name="commandLineBuilder"></param> /// <param name="items"></param> static public void AddSetParametersToObject(Utilities.CommandLineBuilder commandLineBuilder, Framework.ITaskItem[] originalItems, string valueQuote, bool foptimisticParameterDefaultValue) { System.Collections.Generic.IList <Framework.ITaskItem> items = MsDeploy.Utility.SortParametersTaskItems(originalItems, foptimisticParameterDefaultValue, MsDeploy.ExistingSyncParameterMetadata.Value.ToString()); if (commandLineBuilder != null && items != null) { System.Collections.Generic.List <string> arguments = new System.Collections.Generic.List <string>(6); System.Collections.Generic.Dictionary <string, string> lookupDictionary = new System.Collections.Generic.Dictionary <string, string>(items.Count); System.Collections.Generic.Dictionary <string, string> nameValueDictionary = new System.Collections.Generic.Dictionary <string, string>(items.Count, System.StringComparer.OrdinalIgnoreCase); foreach (Framework.ITaskItem item in items) { arguments.Clear(); System.Collections.Generic.List <string> idenities = new System.Collections.Generic.List <string>(6); string name = item.ItemSpec; if (!string.IsNullOrEmpty(name)) { string element = item.GetMetadata(MsDeploy.ExistingParameterValiationMetadata.Element.ToString()); if (string.IsNullOrEmpty(element)) { element = "parameterEntry"; } if (string.Compare(element, "parameterEntry", System.StringComparison.OrdinalIgnoreCase) == 0) { idenities.Add(name); foreach (string dPIdentity in System.Enum.GetNames(typeof(MsDeploy.ExistingDeclareParameterMetadata))) { idenities.Add(item.GetMetadata(dPIdentity)); } string identity = string.Join(",", idenities.ToArray()); if (!lookupDictionary.ContainsKey(identity)) { string data = null; bool fExistingName = nameValueDictionary.ContainsKey(name); if (nameValueDictionary.ContainsKey(name)) { data = nameValueDictionary[name]; } else { data = item.GetMetadata(MsDeploy.ExistingSyncParameterMetadata.Value.ToString()); nameValueDictionary.Add(name, data); } // the rest, build on the Enum Name MsDeploy.Utility.BuildArgumentsBaseOnEnumTypeName(item, arguments, typeof(MsDeploy.ExistingDeclareParameterMetadata), valueQuote); if (arguments.Count > 0 && !string.IsNullOrEmpty(data)) { arguments.Add(string.Concat(MsDeploy.ExistingSyncParameterMetadata.Value.ToString().ToLower(System.Globalization.CultureInfo.InvariantCulture), "=", MsDeploy.Utility.PutValueInQuote(data, valueQuote))); } lookupDictionary.Add(identity, name); } } else if (string.Compare(element, "parameterValidation", System.StringComparison.OrdinalIgnoreCase) == 0) { System.Diagnostics.Debug.Assert(false, "msdeploy.exe doesn't support parameterValidation entry in the command line for declareParameter yet."); } } commandLineBuilder.AppendSwitchUnquotedIfNotNull("-setParam:", arguments.Count == 0 ? null : string.Join(",", arguments.ToArray())); } } }
static public void AddImportSetParametersFilesOptions(Utilities.CommandLineBuilder commandLineBuilder, Framework.ITaskItem[] items) { AddImportParametersFilesOptions(commandLineBuilder, "-setParamFile:", items); }