public override bool Execute () { if (files == null || files.Length == 0) //nothing to do return true; assignedFiles = new ITaskItem [files.Length]; for (int i = 0; i < files.Length; i ++) { string file = files [i].ItemSpec; string afile = null; //FIXME: Hack! string normalized_root = Path.GetFullPath (rootFolder); // cur dir should already be set to // the project dir file = Path.GetFullPath (file); if (file.StartsWith (normalized_root)) { afile = Path.GetFullPath (file).Substring ( normalized_root.Length); // skip over "root/" if (afile [0] == '\\' || afile [0] == '/') afile = afile.Substring (1); } else { afile = Path.GetFileName (file); } assignedFiles [i] = new TaskItem (files [i]); assignedFiles [i].SetMetadata ("TargetPath", afile); } return true; }
/// <summary> /// Helper function to parse the ParameterEntryElement /// </summary> /// <param name="element"></param> /// <param name="parentItem"></param> /// <returns></returns> private Utilities.TaskItem ReadParameterEntryElement(Xml.XmlElement element, Utilities.TaskItem parentItem) { Debug.Assert(element != null && parentItem != null); Utilities.TaskItem taskItem = null; if (string.Compare(element.Name, "parameterEntry", System.StringComparison.OrdinalIgnoreCase) == 0) { taskItem = new Microsoft.Build.Utilities.TaskItem(parentItem); taskItem.RemoveMetadata("OriginalItemSpec"); foreach (Xml.XmlNode attribute in element.Attributes) { if (attribute != null && attribute.Name != null && attribute.Value != null) { string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value); taskItem.SetMetadata(attribute.Name, value); } } } else if (string.Compare(element.Name, "parameterValidation", System.StringComparison.OrdinalIgnoreCase) == 0) { taskItem = new Microsoft.Build.Utilities.TaskItem(parentItem); taskItem.RemoveMetadata("OriginalItemSpec"); taskItem.SetMetadata("Element", "parameterValidation"); foreach (Xml.XmlNode attribute in element.Attributes) { if (attribute != null && attribute.Name != null && attribute.Value != null) { string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value); taskItem.SetMetadata(attribute.Name, value); } } } return(taskItem); }
private static ITaskItem GetTaskItemFromJToken( this JToken token ) { ITaskItem retVal; switch (token) { case JValue value: retVal = new TaskItem(value.Value?.ToString() ?? ""); break; case JObject obj: retVal = new TaskItem( obj.Property(ITEM_SPEC).GetItemMetaData(), obj.Properties() .Where(p => !String.Equals(p.Name, ITEM_SPEC)) .ToDictionary(p => p.Name, p => p.GetItemMetaData()) ); break; default: retVal = null; break; } return(retVal); }
public override bool Execute() { if (string.IsNullOrEmpty(SourceDirectory)) { Log.LogError("Argument SourceDirectory is missing."); return false; } if (string.IsNullOrEmpty(StartAppPath)) { Log.LogError("Argument StartAppPath is missing."); return false; } if (string.IsNullOrEmpty(UniqueSourceDirectoryPath)) { Log.LogError("Argument UniqueSourceDirectoryPath is missing."); return false; } var orderer = new AppOrderer(); var list = orderer.GetAppBuildOrder(SourceDirectory, StartAppPath, UniqueSourceDirectoryPath, Log); var returnList = new List<ITaskItem>(); foreach (string app in list) { ITaskItem item = new TaskItem(app); item.SetMetadata("AppPath", app); returnList.Add(item); } AppList = returnList.ToArray(); return true; }
private void SetMetaData(TaskItem item, string data, bool set) { if (set) { item.SetMetadata(TemplateFile.MetadataValueTag, data); } }
public override bool Execute () { if (files == null || files.Length == 0) //nothing to do return true; List<ITaskItem> outFiles = new List<ITaskItem> (); for (int i = 0; i < files.Length; i ++) { string file = files [i].ItemSpec; string link = files [i].GetMetadata ("Link"); string definingProjectPath = files [i].GetMetadata ("DefiningProjectFullPath"); if (String.IsNullOrEmpty (link) && Path.IsPathRooted (file) && !string.IsNullOrEmpty (definingProjectPath)) { file = Path.GetFullPath (file); var projectDir = Path.GetFullPath (Path.GetDirectoryName (definingProjectPath)); if (projectDir.Length == 0 || projectDir [projectDir.Length - 1] != Path.DirectorySeparatorChar) projectDir += Path.DirectorySeparatorChar; if (file.StartsWith (projectDir)) { // The file is in the same folder or a subfolder of the project that contains it. // Use the relative path wrt the containing project as link. var outFile = new TaskItem (files [i]); outFile.SetMetadata ("Link", file.Substring (projectDir.Length)); outFiles.Add (outFile); } } } assignedFiles = outFiles.ToArray (); return true; }
public void BasicTestCreate() { var basicSampleTaskItem = new TaskItem("BasicSample"); var cSharpTaskItem = new TaskItem("Microsoft.CSharp"); var serviceTaskItem = new TaskItem( "Microsoft.Practices.ServiceLocation, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"); var task = new FindAssembliesInOutputDirTask(_fileSystem) { InputAssemblies = new ITaskItem[] { basicSampleTaskItem, cSharpTaskItem, serviceTaskItem }, OutputDir = new[] { @"C:\" } }; Assert.True(task.Execute()); var outputs = task.AssembliesInOutputDir; Assert.Contains(basicSampleTaskItem, outputs); Assert.Contains(serviceTaskItem, outputs); Assert.DoesNotContain(cSharpTaskItem, outputs); }
public void NullITaskItem() { ITaskItem item = null; TaskItem taskItem = new TaskItem(item); // no NullReferenceException }
public override bool Execute() { var results = new List<ITaskItem> (); Log.LogTaskName ("PackLibraryResources"); Log.LogTaskProperty ("BundleResourcesWithLogicalNames", BundleResourcesWithLogicalNames); Log.LogTaskProperty ("Prefix", Prefix); if (BundleResourcesWithLogicalNames != null) { foreach (var item in BundleResourcesWithLogicalNames) { var logicalName = item.GetMetadata ("LogicalName"); if (string.IsNullOrEmpty (logicalName)) { Log.LogError ("Items must have logical names computed."); return false; } var embedded = new TaskItem (item); embedded.SetMetadata ("LogicalName", "__" + Prefix + "_content_" + EscapeMangledResource (logicalName)); results.Add (embedded); } } EmbeddedResources = results.ToArray (); return !Log.HasLoggedErrors; }
public static ITaskItem CreateFileItem(string sourcePath, string targetPath, string targetFramework) { TaskItem item = new TaskItem(sourcePath); item.SetMetadata("TargetPath", targetPath); item.SetMetadata("TargetFramework", targetFramework); return item; }
public override bool Execute() { Log.LogMessage (MessageImportance.Low, "Task GetNugetPackageBasePath"); Log.LogMessage (MessageImportance.Low, "\tPackageName : {0}", PackageName); Log.LogMessage (MessageImportance.Low, "\tPackageConfigFiles : "); foreach (ITaskItem file in PackageConfigFiles) { Log.LogMessage (MessageImportance.Low, "\t\t{0}", file.ItemSpec); } Version latest = null; foreach (string file in PackageConfigFiles.Select (x => Path.GetFullPath (x.ItemSpec)).Distinct ().OrderBy (x => x)) { if (!File.Exists (file)) { Log.LogWarning ("\tPackages config file {0} not found", file); continue; } Version tmp = GetPackageVersion (file); if (latest != null && latest >= tmp) continue; latest = tmp; } if (latest == null) Log.LogError ("NuGet Package '{0}' not found", PackageName); else BasePath = new TaskItem (Path.Combine ("packages", $"{PackageName}.{latest}")); Log.LogMessage (MessageImportance.Low, $"BasePath == {BasePath}"); return !Log.HasLoggedErrors; }
private static ITaskItem[] GetSourceFolder(string folder) { var folderItem = new TaskItem(folder); folderItem.SetMetadata("Test-name", "Test-Content"); return new ITaskItem[] { folderItem }; }
private static ITaskItem CreateProjectCopyLocal(ProjectCopyLocal projectCopyLocal) { var copies = projectCopyLocal.CopyLocals; var result = new TaskItem(projectCopyLocal.Project); result.SetMetadata("CopyLocals", string.Join(Environment.NewLine, copies.ToArray())); return result; }
public void AppendItemWithMissingAttribute() { // Construct the task items. TaskItem i = new TaskItem(); i.ItemSpec = "MySoundEffect.wav"; i.SetMetadata("Name", "Kenny"); i.SetMetadata("Access", "Private"); TaskItem j = new TaskItem(); j.ItemSpec = "MySplashScreen.bmp"; j.SetMetadata("Name", "Cartman"); j.SetMetadata("HintPath", @"c:\foo"); j.SetMetadata("Access", "Public"); CommandLineBuilderExtension c = new CommandLineBuilderExtension(); c.AppendSwitchIfNotNull ( "/myswitch:", new ITaskItem[] { i, j }, new string[] { "Name", "HintPath", "Access" }, null ); Assert.Equal(@"/myswitch:MySoundEffect.wav,Kenny /myswitch:MySplashScreen.bmp,Cartman,c:\foo,Public", c.ToString()); }
public override bool Execute() { EmbeddedResources = new ITaskItem[BundleResources.Length]; Log.LogTaskName ("CreateEmbeddedResources"); Log.LogTaskProperty ("BundleResources", BundleResources); Log.LogTaskProperty ("Prefix", Prefix); for (int i = 0; i < BundleResources.Length; i++) { var bundleResource = BundleResources[i]; // clone the item var embeddedResource = new TaskItem (bundleResource.ItemSpec); bundleResource.CopyMetadataTo (embeddedResource); // mangle the resource name var logicalName = "__" + Prefix + "_content_" + EscapeMangledResource (bundleResource.GetMetadata ("LogicalName")); embeddedResource.SetMetadata ("LogicalName", logicalName); // add it to the output connection EmbeddedResources[i] = embeddedResource; } return true; }
private static void ResolveSDKFromRefereneAssemblyLocation(string referenceName, string expectedPath) { // Create the engine. MockEngine engine = new MockEngine(); TaskItem taskItem = new TaskItem(referenceName); taskItem.SetMetadata("SDKName", "FakeSDK, Version=1.0"); TaskItem resolvedSDK = new TaskItem(@"C:\FakeSDK"); resolvedSDK.SetMetadata("SDKName", "FakeSDK, Version=1.0"); resolvedSDK.SetMetadata("TargetedSDKConfiguration", "Debug"); resolvedSDK.SetMetadata("TargetedSDKArchitecture", "X86"); TaskItem[] assemblies = new TaskItem[] { taskItem }; // Now, pass feed resolved primary references into ResolveAssemblyReference. ResolveAssemblyReference t = new ResolveAssemblyReference(); t.BuildEngine = engine; t.Assemblies = assemblies; t.ResolvedSDKReferences = new ITaskItem[] { resolvedSDK }; t.SearchPaths = new String[] { @"C:\SomeOtherPlace" }; bool succeeded = Execute(t); Assert.True(succeeded); Assert.Equal(1, t.ResolvedFiles.Length); Assert.Equal(0, engine.Errors); Assert.Equal(0, engine.Warnings); Assert.True(t.ResolvedFiles[0].ItemSpec.Equals(expectedPath, StringComparison.OrdinalIgnoreCase)); }
protected ITaskItem ConvertPackageElement(ITaskItem project, PackageReference packageReference) { var id = packageReference.Id; var version = packageReference.Version; var targetFramework = packageReference.TargetFramework; var isDevelopmentDependency = packageReference.IsDevelopmentDependency; var requireReinstallation = packageReference.RequireReinstallation; var versionConstraint = packageReference.VersionConstraint; var item = new TaskItem(id); project.CopyMetadataTo(item); var packageDirectoryPath = GetPackageDirectoryPath(project.GetMetadata("FullPath"), id, version); item.SetMetadata("PackageDirectoryPath", packageDirectoryPath); item.SetMetadata("ProjectPath", project.GetMetadata("FullPath")); item.SetMetadata("IsDevelopmentDependency", isDevelopmentDependency.ToString()); item.SetMetadata("RequireReinstallation", requireReinstallation.ToString()); if (version != null) item.SetMetadata(Metadata.Version, version.ToString()); if (targetFramework != null) item.SetMetadata(Metadata.TargetFramework, targetFramework.GetShortFrameworkName()); if (versionConstraint != null) item.SetMetadata("VersionConstraint", versionConstraint.ToString()); return item; }
private static ITaskItem[] ExpandWildcards(ITaskItem[] expand) { if (expand == null) { return null; } ArrayList list = new ArrayList(); foreach (ITaskItem item in expand) { if (Microsoft.Build.Shared.FileMatcher.HasWildcards(item.ItemSpec)) { foreach (string str in Microsoft.Build.Shared.FileMatcher.GetFiles(null, item.ItemSpec)) { TaskItem item2 = new TaskItem(item) { ItemSpec = str }; Microsoft.Build.Shared.FileMatcher.Result result = Microsoft.Build.Shared.FileMatcher.FileMatch(item.ItemSpec, str); if ((result.isLegalFileSpec && result.isMatch) && ((result.wildcardDirectoryPart != null) && (result.wildcardDirectoryPart.Length > 0))) { item2.SetMetadata("RecursiveDir", result.wildcardDirectoryPart); } list.Add(item2); } } else { list.Add(item); } } return (ITaskItem[]) list.ToArray(typeof(ITaskItem)); }
public override bool Execute() { ArrayList list = new ArrayList(); foreach (ITaskItem item in AssemblyFiles) { AssemblyName an; try { an = AssemblyName.GetAssemblyName(item.ItemSpec); } catch (BadImageFormatException e) { Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message); continue; } catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e)) { Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message); continue; } ITaskItem newItem = new TaskItem(an.FullName); newItem.SetMetadata("Name", an.Name); if (an.Version != null) newItem.SetMetadata("Version", an.Version.ToString()); if (an.GetPublicKeyToken() != null) newItem.SetMetadata("PublicKeyToken", ByteArrayToHex(an.GetPublicKeyToken())); if (an.CultureInfo != null) newItem.SetMetadata("Culture", an.CultureInfo.ToString()); item.CopyMetadataTo(newItem); list.Add(newItem); } Assemblies = (ITaskItem[])list.ToArray(typeof(ITaskItem)); return !Log.HasLoggedErrors; }
public override bool Execute() { Regex packageNameRegex = new Regex(PackageNameRegex); List<ITaskItem> packageNameItems = new List<ITaskItem>(); foreach (string packageDrop in PackageDrops) { if (!Directory.Exists(packageDrop)) { Log.LogWarning("PackageDrop does not exist - '{0}'", packageDrop); continue; } IEnumerable<ITaskItem> packages = Directory.GetFiles(packageDrop).Select(f => new TaskItem(Path.GetFileNameWithoutExtension(f))); foreach (ITaskItem package in packages) { Match m = packageNameRegex.Match(package.ItemSpec); if (m.Success) { TaskItem packageName = new TaskItem(m.Groups[0].Value); packageName.SetMetadata("PackageName", m.Groups[1].Value); packageName.SetMetadata("PackageVersion", m.Groups[2].Value); packageName.SetMetadata("PrereleaseVersion", m.Groups[3].Value); packageNameItems.Add(packageName); } } } PackageNames = packageNameItems?.OrderBy(an => an.ItemSpec.ToString(), StringComparer.Ordinal)?.ToArray(); return true; }
public override bool Execute () { if (string.IsNullOrEmpty (extensionDomain)) { Log.LogError ("ExtensionDomain item not found"); return false; } if (addinReferences == null) { return true; } Application app = SetupService.GetExtensibleApplication (extensionDomain); if (app == null) { Log.LogError ("Extension domain '{0}' not found", extensionDomain); return false; } foreach (ITaskItem item in addinReferences) { string addinId = item.ItemSpec.Replace (':',','); Addin addin = app.Registry.GetAddin (addinId); if (addin == null) { Log.LogError ("Add-in '{0}' not found", addinId); return false; } if (addin.Description == null) { Log.LogError ("Add-in '{0}' could not be loaded", addinId); return false; } foreach (string asm in addin.Description.MainModule.Assemblies) { string file = Path.Combine (addin.Description.BasePath, asm); TaskItem ti = new TaskItem (file); references.Add (ti); } } return true; }
protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance) { if (singleLine.StartsWith("Successfully created package")) { var outputPackage = singleLine.Split('\'').Skip(1).First(); var outputPackageItem = new TaskItem(outputPackage); if (outputPackage.EndsWith(".symbols.nupkg", StringComparison.OrdinalIgnoreCase)) { OutputSymbolsPackage = new[] { outputPackageItem }; } else { OutputPackage = new[] { outputPackageItem }; } } if (messageImportance == MessageImportance.High) { Log.LogError(singleLine); return; } if (singleLine.StartsWith("Issue:") || singleLine.StartsWith("Description:") || singleLine.StartsWith("Solution:")) { Log.LogWarning(singleLine); return; } base.LogEventsFromTextOutput(singleLine, messageImportance); }
public override bool Execute () { assemblies = new ITaskItem [assembly_files.Length]; for (int i = 0; i < assemblies.Length; i++) { string file = assembly_files [i].ItemSpec; AssemblyName an = AssemblyName.GetAssemblyName (file); TaskItem item = new TaskItem (an.FullName); item.SetMetadata ("Version", an.Version.ToString ()); byte[] pk = an.GetPublicKeyToken (); string pkStr = pk != null? ByteArrayToString (pk) : "null"; item.SetMetadata ("PublicKeyToken", pkStr); CultureInfo culture = an.CultureInfo; if (culture != null) { string cn; if (culture.LCID == CultureInfo.InvariantCulture.LCID) cn = "neutral"; else cn = culture.Name; item.SetMetadata ("Culture", cn); } assemblies[i] = item; } return true; }
public override bool Execute() { // read the xml file and populate the JobsFound result if (File.Exists(ConfigFile)) { var doc = XDocument.Load(ConfigFile); var jobs = from wj in doc.Root.Elements("WebJob") select new { RelPath = wj.Attribute("RelativePath").Value, Schedule = wj.Attribute("Schedule").Value }; var resultList = new List<ITaskItem>(); foreach (var job in jobs) { var item = new TaskItem(job.RelPath); item.SetMetadata("Schedule", job.Schedule); resultList.Add(item); } JobsFound = resultList.ToArray(); } else { Log.LogMessage("web jobs config file not found at [{0}]", ConfigFile); } return !Log.HasLoggedErrors; }
protected internal override void AddCommandLineCommands ( CommandLineBuilderExtension commandLine) { if (Sources.Length == 0) return; foreach (ITaskItem item in Sources) commandLine.AppendSwitchIfNotNull ("--complist=", item.ItemSpec); commandLine.AppendSwitchIfNotNull ("--target=", LicenseTarget); if (ReferencedAssemblies != null) foreach (ITaskItem reference in ReferencedAssemblies) commandLine.AppendSwitchIfNotNull ("--load=", reference.ItemSpec); string outdir; if (Bag ["OutputDirectory"] != null) outdir = OutputDirectory; else outdir = "."; commandLine.AppendSwitchIfNotNull ("--outdir=", outdir); if (Bag ["NoLogo"] != null && NoLogo) commandLine.AppendSwitch ("--nologo"); OutputLicense = new TaskItem (Path.Combine (OutputDirectory, LicenseTarget.ItemSpec + ".licenses")); }
public void Build() { RegexCompiler task = new RegexCompiler(); task.BuildEngine = new MockBuild(); task.OutputDirectory = TaskUtility.TestDirectory; task.AssemblyName = "MSBuild.Community.RegularExpressions.dll"; task.AssemblyTitle = "MSBuild.Community.RegularExpressions"; task.AssemblyDescription = "MSBuild Community Tasks Regular Expressions"; task.AssemblyCompany = "MSBuildTasks"; task.AssemblyProduct = "MSBuildTasks"; task.AssemblyCopyright = "Copyright (c) MSBuildTasks 2008"; task.AssemblyVersion = "1.0.0.0"; task.AssemblyFileVersion = "1.0.0.0"; task.AssemblyInformationalVersion = "1.0.0.0"; task.AssemblyKeyFile = @"..\..\..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk"; List<ITaskItem> expressions = new List<ITaskItem>(); TaskItem item1 = new TaskItem("TextRegex"); item1.SetMetadata("Pattern", @"\G[^<]+"); item1.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline"); item1.SetMetadata("IsPublic", "true"); TaskItem item2 = new TaskItem("CommentRegex"); item2.SetMetadata("Pattern", @"\G<%--(([^-]*)-)*?-%>"); item2.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline"); item2.SetMetadata("IsPublic", "true"); task.RegularExpressions = new ITaskItem[] {item1, item2}; bool result = task.Execute(); Assert.IsTrue(result); }
public override bool Execute() { var inputsGroupedByConfigFile = new Dictionary<string, List<WorkItem>>(); OutputFiles = new ITaskItem[InputFiles.Length]; for (int i = 0; i < InputFiles.Length; i++) { string infileLocal = InputFiles[i].ItemSpec; OutputFiles[i] = new TaskItem(Path.ChangeExtension(infileLocal, ExecutablesCommon.GeneratedFileExtension)); string infile = Path.GetFullPath(infileLocal); string outfile = Path.ChangeExtension(infile, ExecutablesCommon.GeneratedFileExtension); string configFile = ExecutablesCommon.FindConfigFilePath(infile) ?? ""; List<WorkItem> l; if (!inputsGroupedByConfigFile.TryGetValue(configFile, out l)) inputsGroupedByConfigFile[configFile] = l = new List<WorkItem>(); l.Add(new WorkItem() { InFile = infile, OutFile = outfile, Namespace = FindNamespace(InputFiles[i]) }); } bool success = true; foreach (var kvp in inputsGroupedByConfigFile) { ExecutablesCommon.ProcessWorkItemsInSeparateAppDomain(kvp.Key, kvp.Value, (item, ex) => { if (ex is TemplateErrorException) { Log.LogError(null, null, null, item.InFile, 0, 0, 0, 0, ex.Message); success = false; } else { Log.LogErrorFromException(ex, true, true, item.InFile); success = false; } return true; }); } return success; }
public void Init() { mockCompiler = new MockPythonCompiler(); compilerTask = new PythonCompilerTask(mockCompiler); sourceTaskItem = new TaskItem("test.py"); compilerTask.Sources = new ITaskItem[] {sourceTaskItem}; }
public override bool Execute() { var frameworks = new List<ITaskItem> (); Log.LogTaskName ("CollectFrameworks"); Log.LogTaskProperty ("AppBundlePath", AppBundlePath); var fwDir = Path.Combine (AppBundlePath, "Frameworks"); if (Directory.Exists (fwDir)) { foreach (var fw in Directory.GetDirectories (fwDir)) { if (!fw.EndsWith (".framework")) { Log.LogWarning ("Found a directory within the Frameworks directory which is not a framework: {0}", fw); continue; } var fwName = Path.GetFileName (fw); var stem = fwName.Substring (0, fwName.Length - ".framework".Length); var fwBinary = Path.Combine (fw, stem); if (!File.Exists (fwBinary)) { Log.LogWarning ("The framework {0} does not contain a binary named {1}", Path.GetDirectoryName (fwBinary), Path.GetFileName (fwBinary)); continue; } var framework = new TaskItem (fwBinary); frameworks.Add (framework); } } else { Log.LogMessage ("No Frameworks directory found."); } Frameworks = frameworks.ToArray (); return !Log.HasLoggedErrors; }
public void CheckForSpecificMetadataOnParent() { Reference reference = new Reference(isWinMDFile, fileExists, getRuntimeVersion); ITaskItem taskItem = new TaskItem("TestReference"); taskItem.SetMetadata("SpecificVersion", "true"); reference.MakePrimaryAssemblyReference(taskItem, true, ".dll"); Assert.True(reference.CheckForSpecificVersionMetadataOnParentsReference(false)); }
private ITaskItem CreateScriptItem(FileInfo arg) { var item = new TaskItem(arg.FullName); item.SetMetadata("Schema", arg.Directory.Name); return item; }
public override bool Execute() { Log.LogTaskName ("PrepareNativeReferences"); Log.LogTaskProperty ("IntermediateOutputPath", IntermediateOutputPath); Log.LogTaskProperty ("NativeReferences", NativeReferences); if (NativeReferences == null || NativeReferences.Length == 0) return !Log.HasLoggedErrors; var embeddedResources = new List<ITaskItem> (); var nativeFrameworks = new List<ITaskItem> (); var text = new StringBuilder (); for (int i = 0; i < NativeReferences.Length; i++) { NativeReferenceKind kind; string value; value = NativeReferences[i].GetMetadata ("Kind") ?? string.Empty; if (!Enum.TryParse (value, out kind)) { Log.LogError (null, null, null, NativeReferences[i].ItemSpec, 0, 0, 0, 0, "Unknown native reference type: {0}", value); continue; } var path = NativeReferences[i].ItemSpec; var logicalName = Path.GetFileName (path); var item = new TaskItem (path); if (kind == NativeReferenceKind.Framework) { nativeFrameworks.Add (item); } else { item.SetMetadata ("LogicalName", logicalName); embeddedResources.Add (item); } text.AppendFormat ("[assembly: ObjCRuntime.LinkWith (\"{0}\"", logicalName); AppendLinkTargetProperty (text, NativeReferences[i]); AppendBooleanProperty (text, NativeReferences[i], "IsCxx"); AppendBooleanProperty (text, NativeReferences[i], "NeedsGccExceptionHandling"); AppendBooleanProperty (text, NativeReferences[i], "SmartLink", true); AppendBooleanProperty (text, NativeReferences[i], "ForceLoad"); AppendStringProperty (text, NativeReferences[i], "Frameworks"); AppendStringProperty (text, NativeReferences[i], "WeakFrameworks"); AppendStringProperty (text, NativeReferences[i], "LinkerFlags"); text.Append (")]"); text.AppendLine (); } var linkWith = Path.Combine (IntermediateOutputPath, "LinkWithAttributes.cs"); Directory.CreateDirectory (Path.GetDirectoryName (linkWith)); File.WriteAllText (linkWith, text.ToString ()); EmbeddedResources = embeddedResources.ToArray (); NativeFrameworks = nativeFrameworks.ToArray (); LinkWithAttributes = new TaskItem (linkWith); return !Log.HasLoggedErrors; }
/// <summary> /// Parse the Parameter element /// </summary> /// <param name="element"></param> private void ReadParameterElement(Xml.XmlElement element) { Debug.Assert(element != null); if (string.Compare(element.Name, "parameter", System.StringComparison.OrdinalIgnoreCase) == 0) { Xml.XmlAttribute nameAttribute = element.Attributes.GetNamedItem("name") as Xml.XmlAttribute; if (nameAttribute != null) { Utilities.TaskItem taskItem = new Microsoft.Build.Utilities.TaskItem(nameAttribute.Value); foreach (Xml.XmlNode attribute in element.Attributes) { string attributeName = attribute.Name.ToLower(System.Globalization.CultureInfo.InvariantCulture); if (string.CompareOrdinal(attributeName, "xmlns") == 0 || attribute.Name.StartsWith("xmlns:", System.StringComparison.Ordinal) || string.CompareOrdinal(attributeName, "name") == 0 ) { continue; } string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value); taskItem.SetMetadata(attribute.Name, value); } // work around the MSDeploy.exe limition of the Parameter must have the ParameterEntry. // m_parametersList.Add(taskItem); bool fAddNoParameterEntryParameter = true; foreach (Xml.XmlNode childNode in element.ChildNodes) { Xml.XmlElement childElement = childNode as Xml.XmlElement; if (childElement != null) { Utilities.TaskItem childEntry = ReadParameterEntryElement(childElement, taskItem); if (childEntry != null) { fAddNoParameterEntryParameter = false; // we have Parameter entry, supress adding the Parameter with no entry m_parametersList.Add(childEntry); } } } if (fAddNoParameterEntryParameter) { // finally add a parameter without any entry m_parametersList.Add(taskItem); } } } }
private async Task PushBuildManifestAsync( BlobFeedAction blobFeedAction, IEnumerable <BlobArtifactModel> blobArtifacts, IEnumerable <PackageArtifactModel> packageArtifacts) { bool disabledByBlob = await blobFeedAction.feed.CheckIfBlobExists( $"{blobFeedAction.feed.RelativePath}{DisableManifestPushConfigurationBlob}"); if (disabledByBlob) { Log.LogMessage( MessageImportance.Normal, $"Skipping manifest push: feed has '{DisableManifestPushConfigurationBlob}'."); return; } string blobPath = $"{AssetsVirtualDir}{ManifestAssetOutputDir}{ManifestName}.xml"; string existingStr = await blobFeedAction.feed.DownloadBlobAsString( $"{blobFeedAction.feed.RelativePath}{blobPath}"); BuildModel buildModel; if (existingStr != null) { buildModel = BuildModel.Parse(XElement.Parse(existingStr)); } else { buildModel = new BuildModel( new BuildIdentity( ManifestName, ManifestBuildId, ManifestBranch, ManifestCommit)); } buildModel.Artifacts.Blobs.AddRange(blobArtifacts); buildModel.Artifacts.Packages.AddRange(packageArtifacts); string tempFile = null; try { tempFile = Path.GetTempFileName(); File.WriteAllText(tempFile, buildModel.ToXml().ToString()); var item = new MSBuild.TaskItem(tempFile, new Dictionary <string, string> { ["RelativeBlobPath"] = blobPath }); using (var clientThrottle = new SemaphoreSlim(MaxClients, MaxClients)) { await blobFeedAction.UploadAssets( item, clientThrottle, UploadTimeoutInMinutes, allowOverwrite : true); } } finally { if (tempFile != null) { File.Delete(tempFile); } } }