public ValidationPattern(ITaskItem item, TaskLoggingHelper log)
{
string idRegex = item.GetMetadata("IdentityRegex");
if (string.IsNullOrEmpty(idRegex))
{
// Temporarily support reading the regex from the Include/ItemSpec for backwards compatibility
// when the IdentityRegex isn't specified. This can be removed once all consumers are using IdentityRegex.
idRegex = item.ItemSpec;
}
_idPattern = new Regex(idRegex);
_expectedVersion = item.GetMetadata("ExpectedVersion");
_expectedPrerelease = item.GetMetadata("ExpectedPrerelease");
_log = log;
if (string.IsNullOrWhiteSpace(_expectedVersion))
{
if (string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Can't find ExpectedVersion or ExpectedPrerelease metadata on item {0}",
item.ItemSpec);
}
}
else if (!string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Both ExpectedVersion and ExpectedPrerelease metadata found on item {0}, but only one permitted",
item.ItemSpec);
}
}
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;
}
public static string GetVirtualProjectPath(string projectDir, ITaskItem item)
{
var link = item.GetMetadata ("Link");
// Note: if the Link metadata exists, then it will be the equivalent of the ProjectVirtualPath
if (!string.IsNullOrEmpty (link)) {
if (Path.DirectorySeparatorChar != '\\')
return link.Replace ('\\', '/');
return link;
}
// HACK: This is for Visual Studio iOS projects
if (!Directory.Exists (projectDir))
return item.ItemSpec;
var definingProjectFullPath = item.GetMetadata ("DefiningProjectFullPath");
var path = item.GetMetadata ("FullPath");
string baseDir;
if (!string.IsNullOrEmpty (definingProjectFullPath)) {
baseDir = Path.GetDirectoryName (definingProjectFullPath);
} else {
baseDir = projectDir;
}
baseDir = PathUtils.ResolveSymbolicLink (baseDir);
path = PathUtils.ResolveSymbolicLink (path);
return PathUtils.AbsoluteToRelative (baseDir, path);
}
static string GetLinkPath (ITaskItem file, string path)
{
string link = file.GetMetadata ("Link");
if (!string.IsNullOrEmpty (link)) {
return link;
}
string projectDir;
var definingProject = file.GetMetadata ("DefiningProjectFullPath");
if (!string.IsNullOrEmpty (definingProject)) {
projectDir = Path.GetDirectoryName (definingProject);
} else {
projectDir = Environment.CurrentDirectory;
}
projectDir = Path.GetFullPath (projectDir);
if (projectDir [projectDir.Length - 1] != Path.DirectorySeparatorChar) {
projectDir += Path.DirectorySeparatorChar;
}
if (path.StartsWith (projectDir, StringComparison.Ordinal)) {
link = path.Substring (projectDir.Length);
} else {
link = Path.GetFileName (path);
}
return link;
}
private static string GetMetadata(ITaskItem taskItem, TargetLanguage targetLanguage, string metadataName)
{
// Get metadata
var metadata = taskItem?.GetMetadata($"{metadataName}");
// Get prefixed metadata
var prefixedMetadata = taskItem?.GetMetadata($"{targetLanguage}{metadataName}");
return(string.IsNullOrWhiteSpace(prefixedMetadata)
? metadata
: prefixedMetadata);
}
protected override void ExecuteCore()
{
// Get information on the runtime package used for the current target
ITaskItem frameworkPack = RuntimePacks.Where(pack =>
pack.GetMetadata(MetadataKeys.FrameworkName).Equals("Microsoft.NETCore.App", StringComparison.OrdinalIgnoreCase))
.SingleOrDefault();
_runtimeIdentifier = frameworkPack?.GetMetadata(MetadataKeys.RuntimeIdentifier);
_packagePath = frameworkPack?.GetMetadata(MetadataKeys.PackageDirectory);
// Get the list of runtime identifiers that we support and can target
string supportedRuntimeIdentifiers = frameworkPack?.GetMetadata(MetadataKeys.AvailableRuntimeIdentifiers);
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var supportedRIDsList = supportedRuntimeIdentifiers == null?Array.Empty <string>() : supportedRuntimeIdentifiers.Split(';');
// Get the best RID for the host machine, which will be used to validate that we can run crossgen for the target platform and architecture
string hostRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
NETCoreSdkRuntimeIdentifier,
supportedRIDsList,
out bool wasInGraph);
if (hostRuntimeIdentifier == null || _runtimeIdentifier == null || _packagePath == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
if (!ExtractTargetPlatformAndArchitecture(_runtimeIdentifier, out string targetPlatform, out _targetArchitecture) ||
!ExtractTargetPlatformAndArchitecture(hostRuntimeIdentifier, out string hostPlatform, out Architecture hostArchitecture) ||
targetPlatform != hostPlatform)
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return;
}
if (!GetCrossgenComponentsPaths() || !File.Exists(_crossgenPath) || !File.Exists(_clrjitPath))
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return;
}
// Create tool task item
CrossgenTool = new TaskItem(_crossgenPath);
CrossgenTool.SetMetadata("JitPath", _clrjitPath);
if (!String.IsNullOrEmpty(_diasymreaderPath))
{
CrossgenTool.SetMetadata("DiaSymReader", _diasymreaderPath);
}
// Process input lists of files
ProcessInputFileList(Assemblies, _compileList, _symbolsCompileList, _r2rFiles, _r2rReferences);
}
/// <summary>
/// Creates a <see cref="VisualStudioComponent"/> using a workload definition.
/// </summary>
/// <param name="manifest"></param>
/// <param name="workload"></param>
/// <param name="componentVersions"></param>
/// <param name="shortNames"></param>
/// <param name="shortNameMetadata"></param>
/// <param name="componentResources"></param>
/// <returns></returns>
public static VisualStudioComponent Create(TaskLoggingHelper log, WorkloadManifest manifest, WorkloadDefinition workload, ITaskItem[] componentVersions,
ITaskItem[] shortNames, ITaskItem[] componentResources, ITaskItem[] missingPacks)
{
log?.LogMessage("Creating Visual Studio component");
string workloadId = $"{workload.Id}";
// If there's an explicit version mapping we use that, otherwise we fall back to the manifest version
// and normalize it since it can have semantic information and Visual Studio components do not support that.
ITaskItem versionItem = componentVersions?.Where(v => string.Equals(v.ItemSpec, workloadId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
Version version = (versionItem != null) && !string.IsNullOrWhiteSpace(versionItem.GetMetadata(Metadata.Version))
? new Version(versionItem.GetMetadata(Metadata.Version))
: (new NuGetVersion(manifest.Version)).Version;
ITaskItem resourceItem = componentResources?.Where(
r => string.Equals(r.ItemSpec, workloadId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// Workload definitions do not have separate title/description fields so the only option
// is to default to the workload description for both.
string title = resourceItem?.GetMetadata(Metadata.Title) ?? workload.Description;
string description = resourceItem?.GetMetadata(Metadata.Description) ?? workload.Description;
string category = resourceItem?.GetMetadata(Metadata.Category) ?? ".NET";
string isUiGroup = workload.IsAbstract ? "yes" : "no";
VisualStudioComponent component = new(Utils.ToSafeId(workloadId), description,
title, version, isUiGroup, shortNames, category);
IEnumerable <string> missingPackIds = missingPacks.Select(p => p.ItemSpec);
log?.LogMessage(MessageImportance.Low, $"Missing packs: {string.Join(", ", missingPackIds)}");
// If the work extends other workloads, we add those as component dependencies before
// processing direct pack dependencies
if (workload.Extends?.Count() > 0)
{
foreach (WorkloadDefinitionId dependency in workload.Extends)
{
// Component dependencies, aka. workload extensions only have minimum version dependencies.
component.AddDependency($"{Utils.ToSafeId(dependency.ToString())}", new Version("1.0.0.0"), maxVersion: null);
}
}
// Visual Studio is case-insensitive.
IEnumerable <WorkloadPackId> packIds = workload.Packs.Where(p => !missingPackIds.Contains($"{p}", StringComparer.OrdinalIgnoreCase));
log?.LogMessage(MessageImportance.Low, $"Packs: {string.Join(", ", packIds.Select(p=>$"{p}"))}");
foreach (WorkloadPackId packId in packIds)
{
log?.LogMessage(MessageImportance.Low, $"Adding component dependency for {packId} ");
component.AddDependency(manifest.Packs[packId]);
}
return(component);
}
private string FindNamespace(ITaskItem item) {
string s = item.GetMetadata("CustomToolNamespace");
if (!string.IsNullOrEmpty(s))
return s; // Easy - the namespace was set explicitly
s = item.GetMetadata("Link"); // If the Link metadata is set, it defines the file as the project sees it.
string dir = Path.GetDirectoryName(!string.IsNullOrEmpty(s) ? s : item.ItemSpec);
string rootNamespaceWithDot = RootNamespace;
if (!string.IsNullOrEmpty(rootNamespaceWithDot) && !rootNamespaceWithDot.EndsWith(".") && !string.IsNullOrEmpty(dir))
rootNamespaceWithDot += ".";
return rootNamespaceWithDot + dir;
}
protected override IEnumerable<Replacing> GetReplacings(ITaskItem item, string text)
{
foreach (var repl in base.GetReplacings(item, text)) yield return repl;
int i = 0;
string n = i > 0 ? i.ToString() : "";
string regex;
while (!string.IsNullOrEmpty(regex = item.GetMetadata("Replacing"+n))) {
int count;
if (!int.TryParse(item.GetMetadata("ReplaceCount"+n) ?? "", out count)) count = -1;
var options = ParseOptions(item.GetMetadata("ReplaceOptions"));
yield return new Replacing { Expression = regex, Options = options, Count = count, Replacement = item.GetMetadata("Replacement"+n) };
i++;
n = i > 0 ? i.ToString() : "";
}
}
protected XmlElement GetProjectElement(ITaskItem projectRef)
{
string metadata = projectRef.GetMetadata("Project");
XmlElement element = null;
if (this.cachedProjectElements.TryGetValue(metadata, out element) && (element != null))
{
return element;
}
string key = projectRef.GetMetadata("FullPath");
if (this.cachedProjectElementsByAbsolutePath.TryGetValue(key, out element) && (element != null))
{
return element;
}
return null;
}
private ITaskItem ComputeLocalizedResource(ITaskItem xlf)
{
var resxName = xlf.GetMetadata("FileName");
var resxFileName = resxName + ".resx";
var resxPath = Path.Combine(LocalizedResxRoot, resxFileName);
var resxItem = new TaskItem(resxPath);
resxItem.SetMetadata(NeutralResxMetadata, xlf.GetMetadata(NeutralResxMetadata));
resxItem.SetMetadata(ParentXlfMetadata, xlf.ItemSpec);
resxItem.SetMetadata(ComputedCultureCodeMetadata, xlf.GetMetadata(ComputedCultureCodeMetadata));
resxItem.SetMetadata(LogicalNameMetadata, $"{AssemblyName}.{resxName}.resources");
xlf.SetMetadata(ChildResxMetadata, resxPath);
return resxItem;
}
protected override string BuildSourceLinkUrl(Uri contentUri, Uri gitUri, string relativeUrl, string revisionId, ITaskItem hostItem)
{
return
(bool.TryParse(hostItem?.GetMetadata(IsEnterpriseEditionMetadataName), out var isEnterpriseEdition) && !isEnterpriseEdition
? BuildSourceLinkUrlForCloudEdition(contentUri, relativeUrl, revisionId)
: BuildSourceLinkUrlForEnterpriseEdition(contentUri, relativeUrl, revisionId, hostItem));
}
private bool ValidateCrossgenSupport()
{
_crossgenTool.PackagePath = _runtimePack?.GetMetadata(MetadataKeys.PackageDirectory);
if (_crossgenTool.PackagePath == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return(false);
}
if (!ExtractTargetPlatformAndArchitecture(_targetRuntimeIdentifier, out _targetPlatform, out _targetArchitecture) ||
!ExtractTargetPlatformAndArchitecture(_hostRuntimeIdentifier, out string hostPlatform, out Architecture hostArchitecture) ||
_targetPlatform != hostPlatform ||
!GetCrossgenComponentsPaths())
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return(false);
}
// Create tool task item
CrossgenTool = new TaskItem(_crossgenTool.ToolPath);
CrossgenTool.SetMetadata(MetadataKeys.JitPath, _crossgenTool.ClrJitPath);
if (!String.IsNullOrEmpty(_crossgenTool.DiaSymReaderPath))
{
CrossgenTool.SetMetadata(MetadataKeys.DiaSymReader, _crossgenTool.DiaSymReaderPath);
}
return(true);
}
public PackageFile( ITaskItem item )
{
FullPath = item.GetMetadata( "FullPath" );
PathInProject = item.ItemSpec;
var environmentData = item.GetMetadata( "Environment" );
if( string.IsNullOrEmpty( environmentData ) )
environmentData = "None";
var isDashboardData = item.GetMetadata( "IsDashboard" );
if( string.IsNullOrEmpty( isDashboardData ) )
isDashboardData = "false";
Environment = ( TargetEnvironment )Enum.Parse( typeof( TargetEnvironment ), environmentData, true );
IsDashboard = bool.Parse( isDashboardData );
}
static string GetTarget(ITaskItem x)
{
var target = x.GetMetadata("TargetPath");
if (Path.GetFileName(x.ItemSpec) == Path.GetFileName(target))
target = Path.GetDirectoryName(target);
return target;
}
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;
}
private IEnumerable<ITaskItem> ResolvePackage(ITaskItem package)
{
string id = package.ItemSpec;
string version = package.GetMetadata("Version");
Log.LogMessage(MessageImportance.Normal, "Resolving Package Reference {0} {1}...", id, version);
// Initial version just searches a machine-level repository
var localFs = new PhysicalFileSystem(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Lib"));
var defaultResolver = new DefaultPackagePathResolver(localFs);
var machineRepo = new LocalPackageRepository(defaultResolver, localFs);
var buildRepo = new BuildPackageRepository();
var remoteRepo = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2"));
var project = new BuildProjectSystem(ProjectDirectory, new FrameworkName(TargetFramework), CurrentReferences);
var manager = new PackageManager(remoteRepo, defaultResolver, localFs, machineRepo);
var projectManager = new ProjectManager(remoteRepo, defaultResolver, project, buildRepo);
// Install the package
var ver = new SemanticVersion(version);
manager.PackageInstalling += manager_PackageInstalling;
manager.InstallPackage(id, ver);
projectManager.AddPackageReference(id, ver);
return project.OutputReferences.Select(item =>
{
var name = AssemblyName.GetAssemblyName(item);
return new TaskItem(name.FullName, new Dictionary<string, string>() {
{"HintPath", item },
{"Private", "true"}
});
});
}
private bool ValidateCrossgen2Support()
{
_crossgen2Tool.PackagePath = _crossgen2Pack?.GetMetadata(MetadataKeys.PackageDirectory);
if (_crossgen2Tool.PackagePath == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return(false);
}
// Crossgen2 only supports the following host->target compilation scenarios in net5.0:
// win-x64 -> win-x64
// linux-x64 -> linux-x64
// linux-musl-x64 -> linux-musl-x64
if (_targetRuntimeIdentifier != _hostRuntimeIdentifier)
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return(false);
}
if (!GetCrossgen2ComponentsPaths())
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return(false);
}
// Create tool task item
Crossgen2Tool = new TaskItem(_crossgen2Tool.ToolPath);
Crossgen2Tool.SetMetadata("JitPath", _crossgen2Tool.ClrJitPath);
if (!String.IsNullOrEmpty(_crossgen2Tool.DiaSymReaderPath))
{
Crossgen2Tool.SetMetadata("DiaSymReader", _crossgen2Tool.DiaSymReaderPath);
}
return(true);
}
private string ComputeNeutralXlfName(ITaskItem neutralResouce)
{
var filename = neutralResouce.GetMetadata("Filename");
var xlfRootPath = LocalizationUtils.ComputeXlfRootPath(neutralResouce);
return Path.Combine(xlfRootPath, filename + ".xlf");
}
private bool ValidateCrossgen2Support()
{
ITaskItem crossgen2Pack = Crossgen2Packs?.FirstOrDefault();
_crossgen2Tool.PackagePath = crossgen2Pack?.GetMetadata(MetadataKeys.PackageDirectory);
if (string.IsNullOrEmpty(_crossgen2Tool.PackagePath) ||
!NuGetVersion.TryParse(crossgen2Pack.GetMetadata(MetadataKeys.NuGetPackageVersion), out NuGetVersion crossgen2PackVersion))
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return(false);
}
bool version5 = crossgen2PackVersion.Major < 6;
bool isSupportedTarget = ExtractTargetPlatformAndArchitecture(_targetRuntimeIdentifier, out _targetPlatform, out _targetArchitecture);
string targetOS = _targetPlatform switch
{
"linux" => "linux",
"linux-musl" => "linux",
"osx" => "osx",
"win" => "windows",
_ => null
};
// In .NET 5 Crossgen2 supported only the following host->target compilation scenarios:
// win-x64 -> win-x64
// linux-x64 -> linux-x64
// linux-musl-x64 -> linux-musl-x64
isSupportedTarget = isSupportedTarget &&
targetOS != null &&
(!version5 || _targetRuntimeIdentifier == _hostRuntimeIdentifier) &&
GetCrossgen2ComponentsPaths(version5);
if (!isSupportedTarget)
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return(false);
}
// Create tool task item
Crossgen2Tool = new TaskItem(_crossgen2Tool.ToolPath);
Crossgen2Tool.SetMetadata(MetadataKeys.IsVersion5, version5.ToString());
if (version5)
{
Crossgen2Tool.SetMetadata(MetadataKeys.JitPath, _crossgen2Tool.ClrJitPath);
}
else
{
Crossgen2Tool.SetMetadata(MetadataKeys.TargetOS, targetOS);
Crossgen2Tool.SetMetadata(MetadataKeys.TargetArch, ArchitectureToString(_targetArchitecture));
if (!string.IsNullOrEmpty(PerfmapFormatVersion))
{
Crossgen2Tool.SetMetadata(MetadataKeys.PerfmapFormatVersion, PerfmapFormatVersion);
}
}
_crossgen2IsVersion5 = version5;
return(true);
}
public PackageItem(ITaskItem item)
{
OriginalItem = item;
SourcePath = item.GetMetadata("FullPath");
SourceProject = GetMetadata("MSBuildSourceProjectFile");
string value = GetMetadata("TargetFramework");
if (!String.IsNullOrWhiteSpace(value))
{
TargetFramework = NuGetFramework.Parse(value);
}
TargetPath = item.GetMetadata(nameof(TargetPath));
AdditionalProperties = GetMetadata(nameof(AdditionalProperties));
UndefineProperties = GetMetadata(nameof(UndefineProperties));
HarvestedFrom = GetMetadata(nameof(HarvestedFrom));
Package = GetMetadata("PackageId");
PackageVersion = GetMetadata("PackageVersion");
IsDll = Path.GetExtension(SourcePath).Equals(".dll", StringComparison.OrdinalIgnoreCase);
IsPlaceholder = NuGetAssetResolver.IsPlaceholder(SourcePath);
IsRef = TargetPath.StartsWith("ref/", StringComparison.OrdinalIgnoreCase);
// determine if we need to append filename to TargetPath
// see https://docs.nuget.org/create/nuspec-reference#specifying-files-to-include-in-the-package
// SourcePath specifies file and target specifies file - do nothing
// SourcePath specifies file and Target specifies directory - copy filename
// SourcePath specifies wildcard files - copy wildcard
// SourcePath specifies recursive wildcard - do not allow, recursive directory may impact asset selection
// we don't want to attempt to expand the wildcard since the build may not yet be complete.
if (SourcePath.Contains("**"))
{
throw new ArgumentException($"Recursive wildcards \"**\" are not permitted in source paths for packages: {SourcePath}. Recursive directory may impact asset selection and we don't want to attempt to expand the wildcard since the build may not yet be complete.");
}
string sourceFile = Path.GetFileName(SourcePath);
if (!Path.GetExtension(TargetPath).Equals(Path.GetExtension(sourceFile), StringComparison.OrdinalIgnoreCase) ||
sourceFile.Contains("*"))
{
TargetPath = Path.Combine(TargetPath, sourceFile);
}
// standardize to /
TargetPath = TargetPath.Replace('\\', '/');
int dirLength = TargetPath.LastIndexOf('/');
TargetDirectory = (dirLength > 0) ? TargetPath.Substring(0, dirLength) : String.Empty;
}
internal BuiltItem(string targetName, ITaskItem item)
{
TargetName = targetName;
OutputPath = item.ItemSpec;
foreach (var name in item.MetadataNames)
Metadata.Add((string)name, item.GetMetadata((string)name));
}
public void UpdateProperties(string propertyOverrides, ITaskItem project, TaskLoggingHelper log)
{
log.LogMessage(MessageImportance.Normal, "Updating properties in file {0}", resourceFile.FullName);
if (string.IsNullOrWhiteSpace(propertyOverrides)) return;
var properties = propertyOverrides.ToDictionary(';', '=');
// Scan meta data for project-specific overrides
var metaDataNames = project.MetadataNames;
foreach (string metaDataName in metaDataNames)
{
properties[metaDataName] = project.GetMetadata(metaDataName);
}
var lines = File.ReadLines(resourceFile.FullName).ToList();
var results = new List<string>(lines.Count);
// Now process each line in the file)
foreach (var line in lines)
{
var key = GetKey(line);
if (key == null)
{
results.Add(line);
}
else
{
var isValueKey = false;
if (key.Equals("VALUE", StringComparison.OrdinalIgnoreCase))
{
key = GetValueKey(line);
if (string.IsNullOrEmpty(key))
{
results.Add(line);
continue;
}
isValueKey = true;
}
if (properties.ContainsKey(key))
{
log.LogMessage(MessageImportance.Low, "Setting \"{0}\" to \"{1}\"", key, properties[key]);
results.Add(string.Format(isValueKey ? "VALUE \"{0}\", \"{1}\\0\"" : "{0} {1}", key, properties[key]));
}
else
{
results.Add(line);
}
}
}
File.WriteAllLines(resourceFile.FullName, results);
}
private static string GetVirtualPath(string sourceDirectory, ITaskItem taskItem)
{
var file = taskItem.GetMetadata("Link");
if (string.IsNullOrEmpty(file))
{
file = taskItem.ItemSpec;
}
return GetVirtualPath(sourceDirectory, file);
}
protected override void ExecuteCore()
{
_runtimePack = GetNETCoreAppRuntimePack();
_crossgen2Pack = Crossgen2Packs?.FirstOrDefault();
_targetRuntimeIdentifier = _runtimePack?.GetMetadata(MetadataKeys.RuntimeIdentifier);
// Get the list of runtime identifiers that we support and can target
ITaskItem targetingPack = GetNETCoreAppTargetingPack();
string supportedRuntimeIdentifiers = targetingPack?.GetMetadata(MetadataKeys.RuntimePackRuntimeIdentifiers);
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var supportedRIDsList = supportedRuntimeIdentifiers == null?Array.Empty <string>() : supportedRuntimeIdentifiers.Split(';');
// Get the best RID for the host machine, which will be used to validate that we can run crossgen for the target platform and architecture
_hostRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
NETCoreSdkRuntimeIdentifier,
supportedRIDsList,
out bool wasInGraph);
if (_hostRuntimeIdentifier == null || _targetRuntimeIdentifier == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
if (ReadyToRunUseCrossgen2)
{
if (!ValidateCrossgen2Support())
{
return;
}
// NOTE: Crossgen2 does not yet currently support emitting native symbols, and until this feature
// is implemented, we will use crossgen for it. This should go away in the future when crossgen2 supports the feature.
if (EmitSymbols && !ValidateCrossgenSupport())
{
return;
}
}
else
{
if (!ValidateCrossgenSupport())
{
return;
}
}
// Future: check DiaSymReaderPath in the _crossgen2Tool info when crossgen2 starts supporting emitting native symbols
bool hasValidDiaSymReaderLib = String.IsNullOrEmpty(_crossgenTool.DiaSymReaderPath) ? false : File.Exists(_crossgenTool.DiaSymReaderPath);
// Process input lists of files
ProcessInputFileList(Assemblies, _compileList, _symbolsCompileList, _r2rFiles, _r2rReferences, hasValidDiaSymReaderLib);
}
private string GetRequestedRuntimeFrameworkVersion(ITaskItem frameworkReference)
{
string requestedVersion = frameworkReference?.GetMetadata("RuntimeFrameworkVersion");
if (string.IsNullOrEmpty(requestedVersion))
{
requestedVersion = RuntimeFrameworkVersion;
}
return(requestedVersion);
}
protected override IEnumerable<Replacing> GetReplacings(ITaskItem item, string text)
{
var ns = Namespaces + item.GetMetadata("AddUsings") ?? "";
var nss = ns.Trim(' ', '\t', '\n', '\r', ';').Replace("using", "").Replace(" ", "").Replace("\n", "").Replace("\r", "").Replace("\t", "").Split(';')
.Distinct()
.OrderBy(s => s)
.ToArray();
Replacement = "$0#pragma warning disable 105\r\nusing " + string.Join(";\r\nusing ", nss) + ";\r\n\r\n";
Count = 1;
return base.GetReplacings(item, text);
}
protected override IEnumerable<Replacing> GetReplacings(ITaskItem item, string text)
{
foreach (var repl in base.GetReplacings(item, text)) yield return Filter(repl);
if (Custom || string.IsNullOrEmpty(Regex)) {
int i = 0;
string n = i > 0 ? i.ToString() : "";
string regex;
while (!string.IsNullOrEmpty(regex = item.GetMetadata("CommentOut"+n))) {
int count;
if (!int.TryParse(item.GetMetadata("CommentOutCount"+n) ?? "", out count)) count = -1;
var optmeta = item.GetMetadata("CommentOutOptions");
var options = string.IsNullOrEmpty(optmeta) ? RegexOptions : ParseOptions(optmeta);
var repl = item.GetMetadata("CommentOutReplacement"+n);
if (string.IsNullOrEmpty(repl)) repl = Replacement ?? "";
yield return Filter(new Replacing { Expression = regex, Options = options, Count = count, Replacement = repl });
i++;
n = i > 0 ? i.ToString() : "";
}
}
}
public static string GetMetadata(this ITaskItem item, string metadataName, string defaultValue)
{
var value = item?.GetMetadata(metadataName);
if (string.IsNullOrEmpty(value))
{
return(defaultValue);
}
return(value);
}
protected internal AssemblyReference AddAssemblyFromItem(ITaskItem item)
{
AssemblyReferenceType managedAssembly;
AssemblyReference reference;
if (this.IsEmbedInteropEnabledForAssembly(item))
{
return null;
}
switch (this.GetItemAssemblyType(item))
{
case AssemblyType.Managed:
managedAssembly = AssemblyReferenceType.ManagedAssembly;
break;
case AssemblyType.Native:
managedAssembly = AssemblyReferenceType.NativeAssembly;
break;
case AssemblyType.Satellite:
managedAssembly = AssemblyReferenceType.ManagedAssembly;
break;
default:
managedAssembly = AssemblyReferenceType.Unspecified;
break;
}
if (this.GetItemDependencyType(item) == DependencyType.Install)
{
reference = this.manifest.AssemblyReferences.Add(item.ItemSpec);
this.SetItemAttributes(item, reference);
}
else
{
AssemblyIdentity identity = AssemblyIdentity.FromAssemblyName(item.ItemSpec);
if (identity.IsStrongName)
{
reference = new AssemblyReference {
AssemblyIdentity = identity
};
}
else
{
reference = new AssemblyReference(item.ItemSpec);
}
this.manifest.AssemblyReferences.Add(reference);
reference.IsPrerequisite = true;
}
reference.ReferenceType = managedAssembly;
if (string.Equals(item.GetMetadata("IsPrimary"), "true", StringComparison.Ordinal))
{
reference.IsPrimary = true;
}
return reference;
}
public static IList<string> GetResourceTags(ITaskItem item)
{
var tags = ParseTags (item.GetMetadata ("ResourceTags"));
if (tags.Length == 0)
return null;
Array.Sort (tags, StringComparer.Ordinal);
return tags;
}
public static NameValueCollection GetCustomItemMetadata(ITaskItem taskItem)
{
var nameValueCollection = new NameValueCollection();
foreach (string key in taskItem.CloneCustomMetadata().Keys)
{
nameValueCollection.Add(key, taskItem.GetMetadata(key));
}
return nameValueCollection;
}
public static TEnum GetEnumFromMetadata <TEnum>(this ITaskItem item, string metadataName, TEnum defaultValue)
where TEnum : struct
{
var value = item?.GetMetadata(metadataName);
if (!string.IsNullOrEmpty(value) && Enum.TryParse <TEnum>(value, out var output))
{
return(output);
}
return(defaultValue);
}
static string GetObjectFile(ITaskItem source)
{
string objectFilePath = Path.GetFullPath(source.GetMetadata("ObjectFileName"));
// cl.exe will accept a folder name as the ObjectFileName in which case
// the objectfile is created as <ObjectFileName>/<basename>.obj. Here
// we mimic this behaviour.
if ((File.GetAttributes(objectFilePath) & FileAttributes.Directory) != 0)
{
objectFilePath = Path.Combine(objectFilePath, Path.GetFileName(source.ItemSpec));
objectFilePath = Path.ChangeExtension(objectFilePath, ".obj");
}
return objectFilePath;
}
public ValidationPattern(ITaskItem item, TaskLoggingHelper log)
{
_idPattern = new Regex(item.ItemSpec);
_expectedVersion = item.GetMetadata("ExpectedVersion");
_expectedPrerelease = item.GetMetadata("ExpectedPrerelease");
_log = log;
if (string.IsNullOrWhiteSpace(_expectedVersion))
{
if (string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Can't find ExpectedVersion or ExpectedPrerelease metadata on item {0}",
item.ItemSpec);
}
}
else if (!string.IsNullOrWhiteSpace(_expectedPrerelease))
{
_log.LogError(
"Both ExpectedVersion and ExpectedPrerelease metadata found on item {0}, but only one permitted",
item.ItemSpec);
}
}
public bool Execute()
{
const string fullPath = "FullPath";
string src = SourceFile.GetMetadata(fullPath);
string dest = (DestinationFile?.GetMetadata(fullPath) ?? Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), "appsettings.json"));
foreach (string path in JPath.Split(new char[] { ';', ',' }, System.StringSplitOptions.RemoveEmptyEntries))
{
JsonEditor.CopyProperty(src, dest, path);
BuildEngine.LogMessageEvent(new BuildMessageEventArgs(
$"Copied '{Path.GetFileName(src)}':'{path}' property to '{Path.GetFileName(dest)}'", null, nameof(CopyJsonProperties), MessageImportance.Normal));
}
return(true);
}
public Dependency(ITaskItem originalItem)
{
OriginalItem = originalItem;
Name = originalItem.ItemSpec;
string fx = originalItem.GetMetadata("TargetFramework");
if (!String.IsNullOrEmpty(fx))
{
TargetFramework = NuGetFramework.Parse(fx);
}
else
{
TargetFramework = null;
}
string minNSFx = originalItem.GetMetadata("MinimumNETStandard");
if (!String.IsNullOrEmpty(minNSFx))
{
MinimumNETStandard = NuGetFramework.Parse(minNSFx);
}
else
{
MinimumNETStandard = null;
}
}
/// <summary>
/// Creates a <see cref="VisualStudioComponent"/> using a workload definition.
/// </summary>
/// <param name="manifest"></param>
/// <param name="workload"></param>
/// <param name="componentVersion"></param>
/// <param name="shortNames"></param>
/// <param name="shortNameMetadata"></param>
/// <param name="componentResources"></param>
/// <returns></returns>
public static VisualStudioComponent Create(TaskLoggingHelper log, WorkloadManifest manifest, WorkloadDefinition workload, string componentVersion,
ITaskItem[] shortNames, ITaskItem[] componentResources, ITaskItem[] missingPacks)
{
log?.LogMessage("Creating Visual Studio component");
Version version = string.IsNullOrWhiteSpace(componentVersion) ? new Version($"{manifest.Version}.0") :
new Version(componentVersion);
ITaskItem resourceItem = componentResources?.Where(
r => string.Equals(r.ItemSpec, workload.Id.ToString(), StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// Workload definitions do not have separate title/description fields so the only option
// is to default to the workload description for both.
string title = resourceItem?.GetMetadata(Metadata.Title) ?? workload.Description;
string description = resourceItem?.GetMetadata(Metadata.Description) ?? workload.Description;
string category = resourceItem?.GetMetadata(Metadata.Category) ?? ".NET";
VisualStudioComponent component = new(Utils.ToSafeId(workload.Id.ToString()), description,
title, version, shortNames, category);
IEnumerable <string> missingPackIds = missingPacks.Select(p => p.ItemSpec);
log?.LogMessage(MessageImportance.Low, $"Missing packs: {string.Join(", ", missingPackIds)}");
// Visual Studio is case-insensitive.
IEnumerable <WorkloadPackId> packIds = workload.Packs.Where(p => !missingPackIds.Contains($"{p}", StringComparer.OrdinalIgnoreCase));
log?.LogMessage(MessageImportance.Low, $"Packs: {string.Join(", ", packIds.Select(p=>$"{p}"))}");
foreach (WorkloadPackId packId in packIds)
{
log?.LogMessage(MessageImportance.Low, $"Adding component dependency for {packId} ");
component.AddDependency(manifest.Packs[packId]);
}
return(component);
}
protected override string?BuildSourceLinkUrl(Uri contentUri, Uri gitUri, string relativeUrl, string revisionId, ITaskItem?hostItem)
{
var virtualDirectory = hostItem?.GetMetadata(VirtualDirectoryMetadataName) ?? "";
if (!AzureDevOpsUrlParser.TryParseOnPremHttp(relativeUrl, virtualDirectory, out var projectPath, out var repositoryName))
{
Log.LogError(CommonResources.ValueOfWithIdentityIsInvalid, Names.SourceRoot.RepositoryUrlFullName, SourceRoot.ItemSpec, gitUri);
return(null);
}
return
(UriUtilities.Combine(
UriUtilities.Combine(contentUri.ToString(), projectPath), $"_apis/git/repositories/{repositoryName}/items") +
$"?api-version=1.0&versionType=commit&version={revisionId}&path=/*");
}
public TestManifest(ITaskItem manifestTaskItem, DirectoryInfo outputDirectory, string defaultNamespace, bool nameForParentDirectory)
{
ManifestFilePath = manifestTaskItem.ItemSpec;
ManifestDirectory = new Uri(Path.GetFullPath(Path.GetDirectoryName(ManifestFilePath)));
var className = manifestTaskItem.GetMetadata("TestClass");
if (String.IsNullOrEmpty(className))
{
if (nameForParentDirectory)
{
FileInfo f = new FileInfo(ManifestFilePath);
className = f.Directory.Name;
}
else
{
className = Path.GetFileNameWithoutExtension(ManifestFilePath);
}
}
ClassName = CleanupClassName(className);
OutputFilePath = outputDirectory.FullName + Path.DirectorySeparatorChar + ClassName + ".cs";
Namespace = manifestTaskItem.GetMetadata("TestNamespace");
if (String.IsNullOrEmpty(Namespace)) Namespace = defaultNamespace;
_testCases = new List<SparqlTestCase>();
ProcessManifest();
}
protected override void ExecuteCore()
{
_runtimePack = GetNETCoreAppRuntimePack();
_crossgen2Pack = Crossgen2Packs?.FirstOrDefault();
_targetRuntimeIdentifier = _runtimePack?.GetMetadata(MetadataKeys.RuntimeIdentifier);
// Get the list of runtime identifiers that we support and can target
ITaskItem targetingPack = GetNETCoreAppTargetingPack();
string supportedRuntimeIdentifiers = targetingPack?.GetMetadata(MetadataKeys.RuntimePackRuntimeIdentifiers);
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var supportedRIDsList = supportedRuntimeIdentifiers == null?Array.Empty <string>() : supportedRuntimeIdentifiers.Split(';');
// Get the best RID for the host machine, which will be used to validate that we can run crossgen for the target platform and architecture
_hostRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
NETCoreSdkRuntimeIdentifier,
supportedRIDsList,
out _);
if (_hostRuntimeIdentifier == null || _targetRuntimeIdentifier == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
if (ReadyToRunUseCrossgen2)
{
if (!ValidateCrossgen2Support())
{
return;
}
// NOTE: Crossgen2 does not yet currently support emitting native symbols, and until this feature
// is implemented, we will use crossgen for it. This should go away in the future when crossgen2 supports the feature.
if (EmitSymbols && !ValidateCrossgenSupport())
{
return;
}
}
else
{
if (!ValidateCrossgenSupport())
{
return;
}
}
}
private Version GetVersion(ITaskItem?hostItem)
{
var versionAsString = hostItem?.GetMetadata(VersionMetadataName);
if (!NullableString.IsNullOrEmpty(versionAsString))
{
if (Version.TryParse(versionAsString, out var version))
{
return(version);
}
Log.LogError(CommonResources.ItemOfItemGroupMustSpecifyMetadata, hostItem !.ItemSpec, HostsItemGroupName, VersionMetadataName);
}
return(s_versionWithNewUrlFormat);
}
protected override void ExecuteCore()
{
_runtimePack = GetNETCoreAppRuntimePack();
_crossgen2Pack = Crossgen2Packs?.FirstOrDefault();
_targetRuntimeIdentifier = _runtimePack?.GetMetadata(MetadataKeys.RuntimeIdentifier);
// Get the list of runtime identifiers that we support and can target
ITaskItem targetingPack = GetNETCoreAppTargetingPack();
string supportedRuntimeIdentifiers = targetingPack?.GetMetadata(MetadataKeys.RuntimePackRuntimeIdentifiers);
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var supportedRIDsList = supportedRuntimeIdentifiers == null?Array.Empty <string>() : supportedRuntimeIdentifiers.Split(';');
// Get the best RID for the host machine, which will be used to validate that we can run crossgen for the target platform and architecture
_hostRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
NETCoreSdkRuntimeIdentifier,
supportedRIDsList,
out _);
if (_hostRuntimeIdentifier == null || _targetRuntimeIdentifier == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
if (ReadyToRunUseCrossgen2)
{
if (!ValidateCrossgen2Support())
{
return;
}
// In .NET 5 Crossgen2 did not support emitting native symbols, so we use Crossgen to emit them
if (_crossgen2IsVersion5 && EmitSymbols && !ValidateCrossgenSupport())
{
return;
}
}
else
{
if (!ValidateCrossgenSupport())
{
return;
}
}
}
internal static bool TryConvertItemMetadataToBool(ITaskItem item, string itemMetadataName)
{
string metadataValue = item.GetMetadata(itemMetadataName);
if (metadataValue == null || metadataValue.Length == 0)
{
return false;
}
try
{
return Utilities.ConvertStringToBool(metadataValue);
}
catch (System.ArgumentException)
{
throw new Exception("Invalid metadata attribute: " + itemMetadataName + " " + metadataValue);
}
}
private KnownRuntimePack?SelectRuntimePack(ITaskItem frameworkReference, KnownFrameworkReference knownFrameworkReference, List <KnownRuntimePack> knownRuntimePacks)
{
var requiredLabelsMetadata = frameworkReference?.GetMetadata(MetadataKeys.RuntimePackLabels) ?? "";
HashSet <string> requiredRuntimePackLabels = null;
if (frameworkReference != null)
{
requiredRuntimePackLabels = new HashSet <string>(requiredLabelsMetadata.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries), StringComparer.OrdinalIgnoreCase);
}
// The runtime pack name matches the RuntimeFrameworkName on the KnownFrameworkReference
var matchingRuntimePacks = knownRuntimePacks.Where(krp => krp.Name.Equals(knownFrameworkReference.RuntimeFrameworkName, StringComparison.OrdinalIgnoreCase))
.Where(krp =>
{
if (requiredRuntimePackLabels == null)
{
return(krp.RuntimePackLabels.Length == 0);
}
else
{
return(requiredRuntimePackLabels.SetEquals(krp.RuntimePackLabels));
}
})
.ToList();
if (matchingRuntimePacks.Count == 0)
{
return(null);
}
else if (matchingRuntimePacks.Count == 1)
{
return(matchingRuntimePacks[0]);
}
else
{
string runtimePackDescriptionForErrorMessage = knownFrameworkReference.RuntimeFrameworkName +
(requiredLabelsMetadata == string.Empty ? string.Empty : ":" + requiredLabelsMetadata);
Log.LogError(Strings.ConflictingRuntimePackInformation, runtimePackDescriptionForErrorMessage,
string.Join(Environment.NewLine, matchingRuntimePacks.Select(rp => rp.RuntimePackNamePatterns)));
return(knownFrameworkReference.ToKnownRuntimePack());
}
}
private static ITaskItem ConvertToPackageFile(ITaskItem output)
{
var fileName = output.ItemSpec;
var targetPath = output.GetMetadata("TargetPath");
targetPath = string.IsNullOrEmpty(targetPath) ? Path.GetFileName(fileName) : targetPath;
var frameworkNameMoniker = output.GetTargetFrameworkMoniker();
var packageDirectory = output.GetPackageDirectory();
var targetSubdirectory = output.GetTargetSubdirectory();
var targetFramework = packageDirectory == PackageDirectory.Analyzers
? frameworkNameMoniker.GetAnalyzersFrameworkName()
: frameworkNameMoniker.GetShortFrameworkName();
var metadata = output.CloneCustomMetadata();
metadata[Metadata.TargetFramework] = targetFramework;
metadata[Metadata.PackageDirectory] = packageDirectory.ToString();
metadata[Metadata.TargetSubdirectory] = targetSubdirectory;
metadata[Metadata.FileTarget] = packageDirectory.Combine(targetFramework, targetSubdirectory, targetPath);
return new TaskItem(fileName, metadata);
}
private IEnumerable<ITaskItem> ComputeXlfResourceItems(ITaskItem neutralResource)
{
var neutralResxRootDirectory = Path.GetDirectoryName(neutralResource.GetMetadata("FullPath"));
var xlfRootPath = Path.Combine(neutralResxRootDirectory, RelativePathToXlfRoot);
if (!Directory.Exists(xlfRootPath))
{
throw new InvalidOperationException(
$"Could not find expected xlf root {xlfRootPath} next to its neutral resource {neutralResource.ItemSpec}");
}
var resx = neutralResource.ItemSpec;
return
(Directory.EnumerateFiles(xlfRootPath)
.Where(f => IsValidXlf(f, resx))
.Select((f => CreateXLFTaskItemForNeutralResx(f, resx))));
}
public string ProcessProperties(ITaskItem taskItem)
{
StringBuilder returnStr = new StringBuilder(Utils.EST_MAX_CMDLINE_LEN);
foreach ( string metaName in taskItem.MetadataNames )
{
string propValue = taskItem.GetMetadata(metaName);
string processed = ProcessProperty(metaName, propValue).Trim();
if (( processed != null ) && ( processed.Length > 0 ))
{
returnStr.Append(processed);
returnStr.Append(" ");
}
}
return returnStr.ToString().Trim();
}
private RuntimePatchRequest GetRuntimePatchRequest(ITaskItem frameworkReference)
{
string value = frameworkReference?.GetMetadata("TargetLatestRuntimePatch");
if (!string.IsNullOrEmpty(value))
{
return(MSBuildUtilities.ConvertStringToBool(value, defaultValue: false)
? RuntimePatchRequest.UseLatestVersion
: RuntimePatchRequest.UseDefaultVersion);
}
if (TargetLatestRuntimePatch)
{
return(RuntimePatchRequest.UseLatestVersion);
}
return(TargetLatestRuntimePatchIsDefault
? RuntimePatchRequest.UseDefaultVersionWithLatestRuntimePack
: RuntimePatchRequest.UseDefaultVersion);
}
protected override string BuildSourceLinkUrl(Uri contentUri, Uri gitUri, string relativeUrl, string revisionId, ITaskItem hostItem)
{
// The SourceLinkBitbucketGitHost item for bitbucket.org specifies EnterpriseEdition="false".
// Other items that may be specified by the project default to EnterpriseEdition="true" without specifying it.
bool isCloud = bool.TryParse(hostItem?.GetMetadata(IsEnterpriseEditionMetadataName), out var isEnterpriseEdition) && !isEnterpriseEdition;
if (isCloud)
{
return(BuildSourceLinkUrlForCloudEdition(contentUri, relativeUrl, revisionId));
}
if (TryParseEnterpriseUrl(relativeUrl, out var relativeBaseUrl, out var projectName, out var repositoryName))
{
var version = GetBitbucketEnterpriseVersion(hostItem);
return(BuildSourceLinkUrlForEnterpriseEdition(contentUri, relativeBaseUrl, projectName, repositoryName, revisionId, version));
}
Log.LogError(CommonResources.ValueOfWithIdentityIsInvalid, Names.SourceRoot.RepositoryUrlFullName, SourceRoot.ItemSpec, gitUri);
return(null);
}
private Version GetBitbucketEnterpriseVersion(ITaskItem hostItem)
{
var bitbucketEnterpriseVersionAsString = hostItem?.GetMetadata(VersionMetadataName);
Version bitbucketEnterpriseVersion;
if (!string.IsNullOrEmpty(bitbucketEnterpriseVersionAsString))
{
if (!Version.TryParse(bitbucketEnterpriseVersionAsString, out bitbucketEnterpriseVersion))
{
Log.LogError(CommonResources.ItemOfItemGroupMustSpecifyMetadata, hostItem.ItemSpec,
HostsItemGroupName, VersionMetadataName);
return(null);
}
}
else
{
bitbucketEnterpriseVersion = s_versionWithNewUrlFormat;
}
return(bitbucketEnterpriseVersion);
}
private bool BuildProject(ITaskItem project)
{
using (Process proc = new Process())
{
if (!string.IsNullOrEmpty(project.GetMetadata("ChgPropVBP")))
{
this.LogTaskMessage("START - Changing Properties VBP");
VBPProject projectVBP = new VBPProject(project.ItemSpec);
if (projectVBP.Load())
{
string[] linesProperty = project.GetMetadata("ChgPropVBP").Split(Separator);
string[] keyProperty = new string[linesProperty.Length];
string[] valueProperty = new string[linesProperty.Length];
int index;
for (index = 0; index <= linesProperty.Length - 1; index++)
{
if (linesProperty[index].IndexOf("=", StringComparison.OrdinalIgnoreCase) != -1)
{
keyProperty[index] = linesProperty[index].Substring(0, linesProperty[index].IndexOf("=", StringComparison.OrdinalIgnoreCase));
valueProperty[index] = linesProperty[index].Substring(linesProperty[index].IndexOf("=", StringComparison.OrdinalIgnoreCase) + 1);
}
if (!string.IsNullOrEmpty(keyProperty[index]) && !string.IsNullOrEmpty(valueProperty[index]))
{
this.LogTaskMessage(keyProperty[index] + " -> New value: " + valueProperty[index]);
projectVBP.SetProjectProperty(keyProperty[index], valueProperty[index], false);
}
}
projectVBP.Save();
}
this.LogTaskMessage("END - Changing Properties VBP");
}
FileInfo artifactFileInfo = null;
if (this.IfModificationExists)
{
this.LogTaskMessage("START - Checking for modified files");
bool doBuild = false;
VBPProject projectVBP = new VBPProject(project.ItemSpec);
if (projectVBP.Load())
{
FileInfo projectFileInfo = new FileInfo(projectVBP.ProjectFile);
artifactFileInfo = projectVBP.ArtifactFile;
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "artifactFile '{0}', LastWrite: {1}'", artifactFileInfo.FullName, artifactFileInfo.LastWriteTime));
if (projectFileInfo.LastWriteTime > artifactFileInfo.LastWriteTime)
{
this.LogTaskMessage(MessageImportance.High, string.Format("File '{0}' is newer then '{1}'", projectFileInfo.Name, artifactFileInfo.Name));
doBuild = true;
}
else
{
foreach (var file in projectVBP.GetFiles())
{
this.LogTaskMessage(string.Format("File '{0}', LastWrite: {1}'", file.FullName, file.LastWriteTime));
if (file.LastWriteTime > artifactFileInfo.LastWriteTime)
{
this.LogTaskMessage(MessageImportance.High, string.Format(CultureInfo.CurrentCulture, "File '{0}' is newer then '{1}'", file.Name, artifactFileInfo.Name));
doBuild = true;
break;
}
}
}
}
if (!doBuild)
{
this.LogTaskMessage(MessageImportance.High, "Build skipped, because no modifications exists.");
return(true);
}
this.LogTaskMessage("END - Checking for modified files");
}
proc.StartInfo.FileName = this.VB6Path;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.RedirectStandardError = true;
if (string.IsNullOrEmpty(project.GetMetadata("OutDir")))
{
proc.StartInfo.Arguments = @"/MAKE /OUT " + @"""" + project.ItemSpec + ".log" + @""" " + @"""" + project.ItemSpec + @"""";
}
else
{
if (!Directory.Exists(project.GetMetadata("OutDir")))
{
Directory.CreateDirectory(project.GetMetadata("OutDir"));
}
proc.StartInfo.Arguments = @"/MAKE /OUT " + @"""" + project.ItemSpec + ".log" + @""" " + @"""" + project.ItemSpec + @"""" + " /outdir " + @"""" + project.GetMetadata("OutDir") + @"""";
}
// start the process
this.LogTaskMessage("Running " + proc.StartInfo.FileName + " " + proc.StartInfo.Arguments);
proc.Start();
string outputStream = proc.StandardOutput.ReadToEnd();
if (outputStream.Length > 0)
{
this.LogTaskMessage(outputStream);
}
string errorStream = proc.StandardError.ReadToEnd();
if (errorStream.Length > 0)
{
Log.LogError(errorStream);
}
proc.WaitForExit();
if (proc.ExitCode != 0)
{
Log.LogError("Non-zero exit code from VB6.exe: " + proc.ExitCode);
try
{
using (FileStream myStreamFile = new FileStream(project.ItemSpec + ".log", FileMode.Open))
{
System.IO.StreamReader myStream = new System.IO.StreamReader(myStreamFile);
string myBuffer = myStream.ReadToEnd();
Log.LogError(myBuffer);
}
}
catch (Exception ex)
{
Log.LogError(string.Format(CultureInfo.CurrentUICulture, "Unable to open log file: '{0}'. Exception: {1}", project.ItemSpec + ".log", ex.Message));
}
return(false);
}
if (artifactFileInfo != null)
{
var myNow = DateTime.Now;
artifactFileInfo.LastWriteTime = myNow;
artifactFileInfo.LastAccessTime = myNow;
}
return(true);
}
}
public static bool ValidReferenceLibraryForPropertyProvider(ITaskItem referenceLibrary)
{
var copyLocal = referenceLibrary.GetMetadata("Private");
return(String.IsNullOrEmpty(copyLocal) || String.Compare(copyLocal, "false", true) != 0);
}
public override bool RunTask()
{
var resource_name_case_map = MonoAndroidHelper.LoadResourceCaseMap(ResourceNameCaseMap);
var acw_map = MonoAndroidHelper.LoadAcwMapFile(AcwMapFile);
var customViewMap = MonoAndroidHelper.LoadCustomViewMapFile(BuildEngine4, CustomViewMapFile);
var processed = new HashSet <string> ();
foreach (var kvp in acw_map)
{
var key = kvp.Key;
var value = kvp.Value;
if (key == value)
{
continue;
}
if (customViewMap.TryGetValue(key, out HashSet <string> resourceFiles))
{
foreach (var file in resourceFiles)
{
if (processed.Contains(file))
{
continue;
}
if (!File.Exists(file))
{
continue;
}
var document = XDocument.Load(file, options: LoadOptions.SetLineInfo);
var e = document.Root;
bool update = false;
foreach (var elem in AndroidResource.GetElements(e).Prepend(e))
{
update |= TryFixCustomView(elem, acw_map, (level, message) => {
ITaskItem resdir = ResourceDirectories?.FirstOrDefault(x => file.StartsWith(x.ItemSpec, StringComparison.OrdinalIgnoreCase)) ?? null;
switch (level)
{
case TraceLevel.Error:
Log.FixupResourceFilenameAndLogCodedError("XA1002", message, file, resdir?.ItemSpec, resource_name_case_map);
break;
case TraceLevel.Warning:
Log.FixupResourceFilenameAndLogCodedError("XA1001", message, file, resdir?.ItemSpec, resource_name_case_map);
break;
default:
Log.LogDebugMessage(message);
break;
}
});
}
foreach (XAttribute a in AndroidResource.GetAttributes(e))
{
update |= TryFixCustomClassAttribute(a, acw_map);
update |= TryFixFragment(a, acw_map);
}
if (update)
{
var lastModified = File.GetLastWriteTimeUtc(file);
if (document.SaveIfChanged(file))
{
Log.LogDebugMessage($"Fixed up Custom Views in {file}");
File.SetLastWriteTimeUtc(file, lastModified);
}
}
processed.Add(file);
}
}
}
var output = new Dictionary <string, ITaskItem> (processed.Count);
foreach (var file in processed)
{
ITaskItem resdir = ResourceDirectories?.FirstOrDefault(x => file.StartsWith(x.ItemSpec)) ?? null;
var hash = resdir?.GetMetadata("Hash") ?? null;
var stamp = resdir?.GetMetadata("StampFile") ?? null;
var filename = !string.IsNullOrEmpty(hash) ? hash : "compiled";
var stampFile = !string.IsNullOrEmpty(stamp) ? stamp : $"{filename}.stamp";
Log.LogDebugMessage($"{filename} {stampFile}");
output.Add(file, new TaskItem(Path.GetFullPath(file), new Dictionary <string, string> {
{ "StampFile", stampFile },
{ "Hash", filename },
{ "Resource", resdir?.ItemSpec ?? file },
}));
}
Processed = output.Values.ToArray();
return(!Log.HasLoggedErrors);
}
private bool IsTargetPathIncluded(ITaskItem item)
{
return(TargetFilePrefixes
?.Any(prefix => item.GetMetadata("TargetPath")?.StartsWith(prefix) == true) ?? true);
}
public static string MSBuildSourceProjectFile(this ITaskItem taskItem) =>
taskItem.GetMetadata("MSBuildSourceProjectFile");
public KnownFrameworkReference(ITaskItem item)
{
_item = item;
TargetFramework = NuGetFramework.Parse(item.GetMetadata("TargetFramework"));
}
public static string FullPath(this ITaskItem taskItem) =>
taskItem.GetMetadata("FullPath");
private IJobDefinition AddWorkItem(IJobDefinition def, ITaskItem workItem)
{
if (!workItem.GetRequiredMetadata(Log, MetadataNames.Identity, out string name))
{
return(def);
}
if (name.Contains('%'))
{
Log.LogWarning($"Work Item named '{name}' contains encoded characters which is not recommended.");
}
var cleanedName = Helpers.CleanWorkItemName(name);
if (name != cleanedName)
{
Log.LogWarning($"Work Item named '{name}' contains unsupported characters and has been renamed to '{cleanedName}'.");
}
name = cleanedName;
if (!workItem.GetRequiredMetadata(Log, MetadataNames.Command, out string command))
{
return(def);
}
Log.LogMessage(MessageImportance.Low, $"Adding work item '{name}'");
var commands = GetCommands(workItem, command).ToList();
IWorkItemDefinitionWithPayload wiWithPayload;
if (commands.Count == 1)
{
wiWithPayload = def.DefineWorkItem(name).WithCommand(commands[0]);
Log.LogMessage(MessageImportance.Low, $" Command: '{commands[0]}'");
}
else
{
string commandFile = _commandPayload.AddCommandFile(commands);
string helixCorrelationPayload =
IsPosixShell ? "$HELIX_CORRELATION_PAYLOAD/" : "%HELIX_CORRELATION_PAYLOAD%\\";
wiWithPayload = def.DefineWorkItem(name).WithCommand(helixCorrelationPayload + commandFile);
Log.LogMessage(MessageImportance.Low, $" Command File: '{commandFile}'");
foreach (string c in commands)
{
Log.LogMessage(MessageImportance.Low, $" {c}");
}
}
string payloadDirectory = workItem.GetMetadata(MetadataNames.PayloadDirectory);
string payloadArchive = workItem.GetMetadata(MetadataNames.PayloadArchive);
string payloadUri = workItem.GetMetadata(MetadataNames.PayloadUri);
IWorkItemDefinition wi;
if (!string.IsNullOrEmpty(payloadUri))
{
wi = wiWithPayload.WithPayloadUri(new Uri(payloadUri));
Log.LogMessage(MessageImportance.Low, $" Uri Payload: '{payloadUri}'");
}
else if (!string.IsNullOrEmpty(payloadDirectory))
{
wi = wiWithPayload.WithDirectoryPayload(payloadDirectory);
Log.LogMessage(MessageImportance.Low, $" Directory Payload: '{payloadDirectory}'");
}
else if (!string.IsNullOrEmpty(payloadArchive))
{
wi = wiWithPayload.WithArchivePayload(payloadArchive);
Log.LogMessage(MessageImportance.Low, $" Archive Payload: '{payloadArchive}'");
}
else
{
wi = wiWithPayload.WithEmptyPayload();
Log.LogMessage(MessageImportance.Low, " Empty Payload");
}
string timeoutString = workItem.GetMetadata(MetadataNames.Timeout);
if (!string.IsNullOrEmpty(timeoutString))
{
if (TimeSpan.TryParse(timeoutString, CultureInfo.InvariantCulture, out TimeSpan timeout))
{
wi = wi.WithTimeout(timeout);
Log.LogMessage(MessageImportance.Low, $" Timeout: '{timeout}'");
}
else
{
Log.LogWarning($"Timeout value '{timeoutString}' could not be parsed.");
}
}
else
{
Log.LogMessage(MessageImportance.Low, " Default Timeout");
}
return(wi.AttachToJob());
}
public void HarvestFilesFromPackage()
{
string pathToPackage = _packageFolders[PackageId];
var livePackageItems = Files.NullAsEmpty()
.Where(f => IsIncludedExtension(f.GetMetadata("Extension")))
.Select(f => new PackageItem(f));
var livePackageFiles = new Dictionary <string, PackageItem>(StringComparer.OrdinalIgnoreCase);
foreach (var livePackageItem in livePackageItems)
{
PackageItem existingitem;
if (livePackageFiles.TryGetValue(livePackageItem.TargetPath, out existingitem))
{
Log.LogError($"Package contains two files with same targetpath: {livePackageItem.TargetPath}, items:{livePackageItem.SourcePath}, {existingitem.SourcePath}.");
}
else
{
livePackageFiles.Add(livePackageItem.TargetPath, livePackageItem);
}
}
var harvestedFiles = new List <ITaskItem>();
var removeFiles = new List <ITaskItem>();
// make sure we preserve refs that match desktop assemblies
var liveDesktopDlls = livePackageFiles.Values.Where(pi => pi.IsDll && pi.TargetFramework?.Framework == FrameworkConstants.FrameworkIdentifiers.Net);
var desktopRefVersions = liveDesktopDlls.Where(d => d.IsRef && d.Version != null).Select(d => d.Version);
var desktopLibVersions = liveDesktopDlls.Where(d => !d.IsRef && d.Version != null).Select(d => d.Version);
// find desktop assemblies with no matching lib.
var preserveRefVersion = new HashSet <Version>(desktopLibVersions);
preserveRefVersion.ExceptWith(desktopRefVersions);
foreach (var extension in s_includedExtensions)
{
foreach (var packageFile in Directory.EnumerateFiles(pathToPackage, $"*{extension}", SearchOption.AllDirectories))
{
string harvestPackagePath = packageFile.Substring(pathToPackage.Length + 1).Replace('\\', '/');
// determine if we should include this file from the harvested package
// exclude if its specifically set for exclusion
if (ShouldExclude(harvestPackagePath))
{
Log.LogMessage(LogImportance.Low, $"Excluding package path {harvestPackagePath} because it is specifically excluded.");
continue;
}
ITaskItem includeItem = null;
if (!IncludeAllPaths && !ShouldInclude(harvestPackagePath, out includeItem))
{
Log.LogMessage(LogImportance.Low, $"Excluding package path {harvestPackagePath} because it is not included in {nameof(PathsToInclude)}.");
continue;
}
// allow for the harvested item to be moved
var remappedTargetPath = includeItem?.GetMetadata("TargetPath");
if (!String.IsNullOrEmpty(remappedTargetPath))
{
harvestPackagePath = remappedTargetPath + '/' + Path.GetFileName(packageFile);
}
List <string> targetPaths = new List <string>()
{
harvestPackagePath
};
var additionalTargetPaths = includeItem?.GetMetadata("AdditionalTargetPath");
if (!String.IsNullOrEmpty(additionalTargetPaths))
{
foreach (var additionalTargetPath in additionalTargetPaths.Split(';'))
{
if (!String.IsNullOrEmpty(additionalTargetPath))
{
targetPaths.Add(additionalTargetPath + '/' + Path.GetFileName(packageFile));
}
}
}
var assemblyVersion = extension == s_dll?VersionUtility.GetAssemblyVersion(packageFile) : null;
PackageItem liveFile = null;
foreach (var livePackagePath in targetPaths)
{
// determine if the harvested file clashes with a live built file
// we'll prefer the harvested reference assembly so long as it's the same API
// version and not required to match implementation 1:1 as is the case for desktop
if (livePackageFiles.TryGetValue(livePackagePath, out liveFile))
{
// Not a dll, or not a versioned assembly: prefer live built file.
if (extension != s_dll || assemblyVersion == null || liveFile.Version == null)
{
// we don't consider this an error even for explicitly included files
Log.LogMessage(LogImportance.Low, $"Preferring live build of package path {livePackagePath} over the asset from last stable package because the file is not versioned.");
continue;
}
// not a ref
if (!liveFile.IsRef)
{
LogSkipIncludedFile(livePackagePath, " because it is a newer implementation.");
continue;
}
// preserve desktop references to ensure bindingRedirects will work.
if (liveFile.TargetFramework.Framework == FrameworkConstants.FrameworkIdentifiers.Net)
{
LogSkipIncludedFile(livePackagePath, " because it is desktop reference.");
continue;
}
// as above but handle the case where a netstandard ref may be used for a desktop impl.
if (preserveRefVersion.Contains(liveFile.Version))
{
LogSkipIncludedFile(livePackagePath, " because it will be applicable for desktop projects.");
continue;
}
// preserve references with a different major.minor version
if (assemblyVersion.Major != liveFile.Version.Major ||
assemblyVersion.Minor != liveFile.Version.Minor)
{
LogSkipIncludedFile(livePackagePath, $" because it is a different API version ( {liveFile.Version.Major}.{liveFile.Version.Minor} vs {assemblyVersion.Major}.{assemblyVersion.Minor}.");
continue;
}
// preserve references that specifically set the preserve metadata.
bool preserve = false;
bool.TryParse(liveFile.OriginalItem.GetMetadata("Preserve"), out preserve);
if (preserve)
{
LogSkipIncludedFile(livePackagePath, " because it set metadata Preserve=true.");
continue;
}
// replace the live file with the harvested one, removing both the live file and PDB from the
// file list.
Log.LogMessage($"Using reference {livePackagePath} from last stable package {PackageId}/{PackageVersion} rather than the built reference {liveFile.SourcePath} since it is the same API version. Set <Preserve>true</Preserve> on {liveFile.SourceProject} if you'd like to avoid this..");
removeFiles.Add(liveFile.OriginalItem);
PackageItem livePdbFile;
if (livePackageFiles.TryGetValue(Path.ChangeExtension(livePackagePath, ".pdb"), out livePdbFile))
{
removeFiles.Add(livePdbFile.OriginalItem);
}
}
else
{
Log.LogMessage(LogImportance.Low, $"Including {livePackagePath} from last stable package {PackageId}/{PackageVersion}.");
}
var item = new TaskItem(packageFile);
if (liveFile?.OriginalItem != null)
{
// preserve all the meta-data from the live file that was replaced.
liveFile.OriginalItem.CopyMetadataTo(item);
}
else
{
if (includeItem != null)
{
includeItem.CopyMetadataTo(item);
}
var targetPath = Path.GetDirectoryName(livePackagePath).Replace('\\', '/');
item.SetMetadata("TargetPath", targetPath);
string targetFramework = GetTargetFrameworkFromPackagePath(targetPath);
item.SetMetadata("TargetFramework", targetFramework);
// only harvest for non-portable frameworks, matches logic in packaging.targets.
bool harvestDependencies = !targetFramework.StartsWith("portable-");
item.SetMetadata("HarvestDependencies", harvestDependencies.ToString());
item.SetMetadata("IsReferenceAsset", IsReferencePackagePath(targetPath).ToString());
}
if (assemblyVersion != null)
{
// overwrite whatever metadata may have been copied from the live file.
item.SetMetadata("AssemblyVersion", assemblyVersion.ToString());
}
item.SetMetadata("HarvestedFrom", $"{PackageId}/{PackageVersion}/{harvestPackagePath}");
harvestedFiles.Add(item);
}
}
}
HarvestedFiles = harvestedFiles.ToArray();
if (_pathsNotIncluded != null)
{
foreach (var pathNotIncluded in _pathsNotIncluded)
{
Log.LogError($"Path '{pathNotIncluded}' was specified in {nameof(PathsToInclude)} but was not found in the package {PackageId}/{PackageVersion}.");
}
}
if (Files != null)
{
UpdatedFiles = Files.Except(removeFiles).ToArray();
}
}
