protected override void ExecuteCore() { var lockFileCache = new LockFileCache(BuildEngine4); LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath); IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath); HashSet <PackageIdentity> packagestoBeFiltered = null; if (TargetManifestFiles != null && TargetManifestFiles.Length > 0) { packagestoBeFiltered = new HashSet <PackageIdentity>(); foreach (var manifestFile in TargetManifestFiles) { Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.ParsingFiles, manifestFile)); var packagesSpecified = StoreArtifactParser.Parse(manifestFile); foreach (var pkg in packagesSpecified) { Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.PackageInfoLog, pkg.Id, pkg.Version)); } packagestoBeFiltered.UnionWith(packagesSpecified); } } ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, IsSelfContained); projectContext.PackagesToBeFiltered = packagestoBeFiltered; var assemblyResolver = new PublishAssembliesResolver(packageResolver) .WithExcludeFromPublish(excludeFromPublishPackageIds) .WithPreserveStoreLayout(PreserveStoreLayout); IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext); foreach (ResolvedFile resolvedAssembly in resolvedAssemblies) { TaskItem item = new TaskItem(resolvedAssembly.SourcePath); item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath); item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower()); _assembliesToPublish.Add(item); } foreach (var resolvedPkg in assemblyResolver.GetResolvedPackages()) { TaskItem item = new TaskItem(resolvedPkg.Id); item.SetMetadata("Version", resolvedPkg.Version.ToString()); _packagesResolved.Add(item); } }
protected override void ExecuteCore() { NuGetFramework targetFramework = NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker); LockFile lockFile = new LockFileCache(this).GetLockFile(ProjectAssetsFile); _packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath); var embeddedApphostPaths = new List <ITaskItem>(); foreach (var runtimeIdentifier in ShimRuntimeIdentifiers.Select(r => r.ItemSpec)) { var resolvedApphostAssetPath = GetApphostAsset(targetFramework, lockFile, runtimeIdentifier); var packagedShimOutputDirectoryAndRid = Path.Combine( PackagedShimOutputDirectory, runtimeIdentifier); var appHostDestinationFilePath = Path.Combine( packagedShimOutputDirectoryAndRid, ToolCommandName + Path.GetExtension(resolvedApphostAssetPath)); Directory.CreateDirectory(packagedShimOutputDirectoryAndRid); // This is the embedded string. We should normalize it on forward slash, so the file won't be different according to // build machine. var appBinaryFilePath = string.Join("/", new[] { ".store", PackageId.ToLowerInvariant(), PackageVersion, PackageId.ToLowerInvariant(), PackageVersion, "tools", targetFramework.GetShortFolderName(), "any", ToolEntryPoint }); AppHost.Create( resolvedApphostAssetPath, appHostDestinationFilePath, appBinaryFilePath, overwriteExisting: true ); var item = new TaskItem(appHostDestinationFilePath); item.SetMetadata("ShimRuntimeIdentifier", runtimeIdentifier); embeddedApphostPaths.Add(item); } EmbeddedApphostPaths = embeddedApphostPaths.ToArray(); }
protected override void ExecuteCore() { var lockFileCache = new LockFileCache(this); LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath); IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath); HashSet <PackageIdentity> packagestoBeFiltered = null; if (RuntimeStorePackages != null && RuntimeStorePackages.Length > 0) { packagestoBeFiltered = new HashSet <PackageIdentity>(); foreach (var package in RuntimeStorePackages) { packagestoBeFiltered.Add(ItemUtilities.GetPackageIdentity(package)); } } ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); projectContext.PackagesToBeFiltered = packagestoBeFiltered; var assemblyResolver = new PublishAssembliesResolver(packageResolver) .WithExcludeFromPublish(excludeFromPublishPackageIds) .WithPreserveStoreLayout(PreserveStoreLayout); IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext); foreach (ResolvedFile resolvedAssembly in resolvedAssemblies) { TaskItem item = new TaskItem(resolvedAssembly.SourcePath); item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath); item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower()); item.SetMetadata(MetadataKeys.PackageName, resolvedAssembly.Package.Id.ToString()); item.SetMetadata(MetadataKeys.PackageVersion, resolvedAssembly.Package.Version.ToString().ToLower()); if (resolvedAssembly.Asset == AssetType.Resources) { // For resources, the DestinationSubDirectory is set to the locale. Set the Culture // metadata on the generated item to this value so that the satellite assemblies can // be filtered by culture. item.SetMetadata(MetadataKeys.Culture, resolvedAssembly.DestinationSubDirectory); } _assembliesToPublish.Add(item); } }
protected override void ExecuteCore() { var lockFileCache = new LockFileCache(this); LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath); HashSet <PackageIdentity> packagestoBeFiltered = null; if (RuntimeStorePackages != null && RuntimeStorePackages.Length > 0) { packagestoBeFiltered = new HashSet <PackageIdentity>(); foreach (var package in RuntimeStorePackages) { packagestoBeFiltered.Add(ItemUtilities.GetPackageIdentity(package)); } } ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); projectContext.PackagesToBeFiltered = packagestoBeFiltered; var assetsFileResolver = new AssetsFileResolver(NuGetPackageResolver.CreateResolver(lockFile)) .WithExcludedPackages(PackageReferenceConverter.GetPackageIds(ExcludedPackageReferences)) .WithPreserveStoreLayout(PreserveStoreLayout); foreach (var resolvedFile in assetsFileResolver.Resolve(projectContext)) { TaskItem item = new TaskItem(resolvedFile.SourcePath); item.SetMetadata(MetadataKeys.DestinationSubPath, resolvedFile.DestinationSubPath); item.SetMetadata(MetadataKeys.DestinationSubDirectory, resolvedFile.DestinationSubDirectory); item.SetMetadata(MetadataKeys.AssetType, resolvedFile.Asset.ToString().ToLowerInvariant()); item.SetMetadata(MetadataKeys.PackageName, resolvedFile.Package.Id.ToString()); item.SetMetadata(MetadataKeys.PackageVersion, resolvedFile.Package.Version.ToString().ToLowerInvariant()); if (resolvedFile.Asset == AssetType.Resources) { // For resources, the DestinationSubDirectory is set to the locale. Set the Culture // metadata on the generated item to this value so that the satellite assemblies can // be filtered by culture. item.SetMetadata(MetadataKeys.Culture, resolvedFile.DestinationSubDirectory.TrimEnd(Path.DirectorySeparatorChar)); } _resolvedAssets.Add(item); } }
protected override void ExecuteCore() { if (Items.Length == 0 || (PackageFolders.Length == 0 && string.IsNullOrEmpty(AssetsFileWithAdditionalPackageFolders))) { Output = Items; return; } if (!string.IsNullOrEmpty(AssetsFileWithAdditionalPackageFolders)) { var lockFileCache = new LockFileCache(this); var lockFile = lockFileCache.GetLockFile(AssetsFileWithAdditionalPackageFolders); PackageFolders = PackageFolders.Concat(lockFile.PackageFolders.Select(p => p.Path)).ToArray(); } var packageResolver = NuGetPackageResolver.CreateResolver(PackageFolders); int index = 0; var updatedItems = new ITaskItem[Items.Length]; foreach (var item in Items) { string packageName = item.GetMetadata(MetadataKeys.NuGetPackageId); string packageVersion = item.GetMetadata(MetadataKeys.PackageVersion); if (string.IsNullOrEmpty(packageName) || string.IsNullOrEmpty(packageVersion) || !string.IsNullOrEmpty(item.GetMetadata(MetadataKeys.PackageDirectory))) { updatedItems[index++] = item; continue; } var parsedPackageVersion = NuGetVersion.Parse(packageVersion); string packageDirectory = packageResolver.GetPackageDirectory(packageName, parsedPackageVersion); if (packageDirectory == null) { updatedItems[index++] = item; continue; } var newItem = new TaskItem(item); newItem.SetMetadata(MetadataKeys.PackageDirectory, packageDirectory); updatedItems[index++] = newItem; } Output = updatedItems; }
public DependencyContextBuilder(SingleProjectInfo mainProjectInfo, ProjectContext projectContext, bool includeRuntimeFileVersions) { _mainProjectInfo = mainProjectInfo; _projectContext = projectContext; _includeRuntimeFileVersions = includeRuntimeFileVersions; // This resolver is only used for building file names, so that base path is not required. _versionFolderPathResolver = new VersionFolderPathResolver(rootPath: null); if (_includeRuntimeFileVersions) { // This is used to look up the paths to package files on disk, which is only needed in this class if // it needs to read the file versions _packageResolver = NuGetPackageResolver.CreateResolver(projectContext.LockFile); } }
protected override void ExecuteCore() { if (Items.Length == 0 || PackageFolders.Length == 0) { Output = Items; return; } var packageResolver = NuGetPackageResolver.CreateResolver(PackageFolders); int index = 0; var updatedItems = new ITaskItem[Items.Length]; foreach (var item in Items) { string packageName = item.GetMetadata(MetadataKeys.PackageName); string packageVersion = item.GetMetadata(MetadataKeys.PackageVersion); if (string.IsNullOrEmpty(packageName) || string.IsNullOrEmpty(packageVersion) || !string.IsNullOrEmpty(item.GetMetadata(MetadataKeys.PackageDirectory))) { updatedItems[index++] = item; continue; } var parsedPackageVersion = NuGetVersion.Parse(packageVersion); string packageDirectory = packageResolver.GetPackageDirectory(packageName, parsedPackageVersion); if (packageDirectory == null) { updatedItems[index++] = item; continue; } var newItem = new TaskItem(item); newItem.SetMetadata(MetadataKeys.PackageDirectory, packageDirectory); updatedItems[index++] = newItem; } Output = updatedItems; }
protected override void ExecuteCore() { if (Items != null) { NuGetPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(PackageFolders, ProjectPath); var updatedItems = new List <ITaskItem>(); foreach (var item in Items) { string packageName = item.GetMetadata(MetadataKeys.PackageName); string packageVersion = item.GetMetadata(MetadataKeys.PackageVersion); if (!string.IsNullOrEmpty(packageName) && !string.IsNullOrEmpty(packageVersion) && string.IsNullOrEmpty(item.GetMetadata(MetadataKeys.PackageDirectory))) { var newItem = new TaskItem(item); // Gracefully handle case where we don't have a packageResolver because we don't have an assets // file, which happens for design-time builds if (packageResolver != null) { var parsedPackageVersion = NuGetVersion.Parse(packageVersion); string packageDirectory = packageResolver.GetPackageDirectory(packageName, parsedPackageVersion); newItem.SetMetadata(MetadataKeys.PackageDirectory, packageDirectory); } updatedItems.Add(newItem); } else { updatedItems.Add(item); } } Output = updatedItems.ToArray(); } }
public DependencyContextBuilder(SingleProjectInfo mainProjectInfo, ProjectContext projectContext, bool includeRuntimeFileVersions) { _mainProjectInfo = mainProjectInfo; _projectContext = projectContext; _includeRuntimeFileVersions = includeRuntimeFileVersions; // This resolver is only used for building file names, so that base path is not required. _versionFolderPathResolver = new VersionFolderPathResolver(rootPath: null); if (_includeRuntimeFileVersions) { // This is used to look up the paths to package files on disk, which is only needed in this class if // it needs to read the file versions _packageResolver = NuGetPackageResolver.CreateResolver(projectContext.LockFile); } if (_projectContext.CompilationLockFileTarget != _projectContext.LockFileTarget) { _compilationTargetLibraries = _projectContext.CompilationLockFileTarget.Libraries .ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase); } }
protected override void ExecuteCore() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); IEnumerable <string> privateAssetsPackageIds = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences); IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName); IEnumerable <ResolvedFile> resolvedAssemblies = new PublishAssembliesResolver(packageResolver) .WithPrivateAssets(privateAssetsPackageIds) .Resolve(projectContext); foreach (ResolvedFile resolvedAssembly in resolvedAssemblies) { TaskItem item = new TaskItem(resolvedAssembly.SourcePath); item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath); _assembliesToPublish.Add(item); } }
protected override void ExecuteCore() { var lockFile = new LockFileCache(BuildEngine4).GetLockFile(ProjectAssetsFile); _packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath); var targetFramework = NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker); var compileTimeTarget = lockFile.GetTargetAndThrowIfNotFound(targetFramework, runtime: null); var runtimeTarget = lockFile.GetTargetAndThrowIfNotFound(targetFramework, RuntimeIdentifier); CheckRuntimePackageDependencies(compileTimeTarget, runtimeTarget); Analyzers = RaiseAnalyzers( lockFile, runtimeTarget); CompileTimeAssemblies = RaisePackageAssets( compileTimeTarget, package => package.CompileTimeAssemblies, setup: (asset, item) => { item.SetMetadata(MetadataKeys.Private, "false"); item.SetMetadata(MetadataKeys.HintPath, item.ItemSpec); if (MarkPackageReferencesAsExternallyResolved) { item.SetMetadata(MetadataKeys.ExternallyResolved, "true"); } }); if (!DisableFrameworkAssemblies) { FrameworkAssemblies = RaiseFrameworkAssemblies( compileTimeTarget, setup: (asset, item) => { item.SetMetadata(MetadataKeys.Pack, "false"); item.SetMetadata(MetadataKeys.Private, "false"); item.SetMetadata(MetadataKeys.NuGetIsFrameworkReference, "true"); }); } ContentFilesToPreprocess = RaisePackageAssets( runtimeTarget, p => p.ContentFiles, filter: asset => !string.IsNullOrEmpty(asset.PPOutputPath), setup: (asset, item) => { item.SetMetadata(MetadataKeys.BuildAction, asset.BuildAction.ToString()); item.SetMetadata(MetadataKeys.CopyToOutput, asset.CopyToOutput.ToString()); item.SetMetadata(MetadataKeys.PPOutputPath, asset.PPOutputPath); if (!string.IsNullOrEmpty(MetadataKeys.OutputPath)) { item.SetMetadata(MetadataKeys.OutputPath, asset.OutputPath); } if (!string.IsNullOrEmpty(asset.CodeLanguage)) { item.SetMetadata(MetadataKeys.CodeLanguage, asset.CodeLanguage); } }); NativeLibraries = RaisePackageAssets( runtimeTarget, package => package.NativeLibraries); ResourceAssemblies = RaisePackageAssets( runtimeTarget, package => package.ResourceAssemblies, setup: (asset, item) => { string locale = asset.Properties["locale"]; item.SetMetadata(MetadataKeys.Culture, locale); item.SetMetadata(MetadataKeys.DestinationSubDirectory, locale + Path.DirectorySeparatorChar); }); RuntimeAssemblies = RaisePackageAssets( runtimeTarget, package => package.RuntimeAssemblies); RuntimeTargets = RaisePackageAssets( runtimeTarget, package => package.RuntimeTargets, setup: (asset, item) => { string directory = Path.GetDirectoryName(asset.Path); item.SetMetadata(MetadataKeys.DestinationSubDirectory, directory + Path.DirectorySeparatorChar); }); if (!DisableTransitiveProjectReferences) { TransitiveProjectReferences = RaiseTransitiveProjectReferences(lockFile, runtimeTarget); } }