protected override void ExecuteCore() { bool writeDevRuntimeConfig = !string.IsNullOrEmpty(RuntimeConfigDevPath); if (!WriteAdditionalProbingPathsToMainConfig) { if (AdditionalProbingPaths?.Any() == true && !writeDevRuntimeConfig) { Log.LogWarning(Strings.SkippingAdditionalProbingPaths); } } LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); WriteRuntimeConfig(projectContext); if (writeDevRuntimeConfig) { WriteDevRuntimeConfig(projectContext); } }
protected override void ExecuteCore() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); var nugetFramework = NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker); lockFile.GetTargetAndThrowIfNotFound(nugetFramework, RuntimeIdentifier); }
protected override void ExecuteCore() { LoadFilesToSkip(); LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> frameworkReferences = ReferenceInfo.CreateFrameworkReferenceInfos(ReferencePaths); IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceSatellitePaths); IEnumerable <string> excludeFromPublishAssets = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, IsSelfContained); DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext) .WithMainProjectInDepsFile(IncludeMainProject) .WithFrameworkReferences(frameworkReferences) .WithDirectReferences(directReferences) .WithReferenceProjectInfos(referenceProjects) .WithExcludeFromPublishAssets(excludeFromPublishAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWhereFiltered(GetFilteredPackages()) .Build(); if (compileFilesToSkip.Any() || runtimeFilesToSkip.Any()) { dependencyContext = TrimFilesToSkip(dependencyContext); } var writer = new DependencyContextWriter(); using (var fileStream = File.Create(DepsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(DepsFilePath)); }
private NuGetFramework ParseFramework(string name) { var framework = NuGetUtils.ParseFrameworkName(name); if (framework == null) { Log.LogError(Strings.InvalidFrameworkName, framework); } return(framework); }
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); } }
private NuGetFramework ParseFramework(string name) { var framework = NuGetUtils.ParseFrameworkName(name); if (framework == null) { // TODO: localize: https://github.com/dotnet/sdk/issues/33 Log.LogError($"Invalid framework name: '{framework}'."); } return(framework); }
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() { 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(); }
public static LockFileTarget GetTargetAndReturnNullIfNotFound(this LockFile lockFile, string frameworkAlias, string runtimeIdentifier) { LockFileTarget lockFileTarget = lockFile.GetTarget(frameworkAlias, runtimeIdentifier); if (lockFileTarget == null && lockFile.PackageSpec.TargetFrameworks.All(tfi => string.IsNullOrEmpty(tfi.TargetAlias))) { var nuGetFramework = NuGetUtils.ParseFrameworkName(frameworkAlias); lockFileTarget = lockFile.GetTarget(nuGetFramework, runtimeIdentifier); } return(lockFileTarget); }
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() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName); WriteRuntimeConfig(projectContext); if (!string.IsNullOrEmpty(RuntimeConfigDevPath)) { WriteDevRuntimeConfig(projectContext); } }
protected override void ExecuteCore() { var embeddedApphostPaths = new List <ITaskItem>(); foreach (var runtimeIdentifier in ShimRuntimeIdentifiers.Select(r => r.ItemSpec)) { var resolvedApphostAssetPath = GetApphostAsset(ApphostsForShimRuntimeIdentifiers, runtimeIdentifier); var packagedShimOutputDirectoryAndRid = Path.Combine( PackagedShimOutputDirectory, runtimeIdentifier); var appHostDestinationFilePath = Path.Combine( packagedShimOutputDirectoryAndRid, ToolCommandName + ExecutableExtension.ForRuntimeIdentifier(runtimeIdentifier)); Directory.CreateDirectory(packagedShimOutputDirectoryAndRid); // per https://github.com/dotnet/cli/issues/9870 nuget layout (as in {packageid}/{packageversion}/tools/)is normalized version var normalizedPackageVersion = NuGetVersion.Parse(PackageVersion).ToNormalizedString(); // 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(), normalizedPackageVersion, PackageId.ToLowerInvariant(), normalizedPackageVersion, "tools", NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker).GetShortFolderName(), "any", ToolEntryPoint }); AppHost.Create( resolvedApphostAssetPath, appHostDestinationFilePath, appBinaryFilePath ); var item = new TaskItem(appHostDestinationFilePath); item.SetMetadata(MetadataKeys.ShimRuntimeIdentifier, runtimeIdentifier); embeddedApphostPaths.Add(item); } EmbeddedApphostPaths = embeddedApphostPaths.ToArray(); }
protected override void ExecuteCore() { var lockFileCache = new LockFileCache(this); LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, runtimeFrameworks: null, IsSelfContained); var packageClosure = new HashSet <PackageIdentity>(); foreach (var packageItem in PackagesToPrune) { var pkgName = packageItem.ItemSpec; if (!string.IsNullOrEmpty(pkgName)) { packageClosure.UnionWith(projectContext.GetTransitiveList(pkgName)); } } var packagesToPublish = new HashSet <PackageIdentity>(); foreach (var resolvedFile in ResolvedFiles) { var resolvedPkg = ItemUtilities.GetPackageIdentity(resolvedFile); if (resolvedPkg != null && !packageClosure.Contains(resolvedPkg)) { _assembliesToPublish.Add(resolvedFile); packagesToPublish.Add(resolvedPkg); } } AssembliesToPublish = _assembliesToPublish.ToArray(); foreach (var resolvedPkg in packagesToPublish) { TaskItem item = new TaskItem(resolvedPkg.Id); item.SetMetadata("Version", resolvedPkg.Version.ToString()); _packagesResolved.Add(item); } PublishedPackages = _packagesResolved.ToArray(); }
protected override void ExecuteCore() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> frameworkReferences = ReferenceInfo.CreateFrameworkReferenceInfos(ReferencePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceSatellitePaths); IEnumerable <string> privateAssets = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName); DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext) .WithFrameworkReferences(frameworkReferences) .WithReferenceProjectInfos(referenceProjects) .WithPrivateAssets(privateAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(DepsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(DepsFilePath)); }
protected override void ExecuteCore() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); NuGetPathContext nugetPathContext = NuGetPathContext.Create(Path.GetDirectoryName(ProjectPath)); IEnumerable <string> privateAssetsPackageIds = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName); IEnumerable <ResolvedFile> resolvedAssemblies = new PublishAssembliesResolver(new NuGetPackageResolver(nugetPathContext)) .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() { bool writeDevRuntimeConfig = !string.IsNullOrEmpty(RuntimeConfigDevPath); if (!WriteAdditionalProbingPathsToMainConfig) { if (AdditionalProbingPaths?.Any() == true && !writeDevRuntimeConfig) { Log.LogWarning(Strings.SkippingAdditionalProbingPaths); } } if (!string.IsNullOrEmpty(RollForward)) { if (!RollForwardValues.Any(v => string.Equals(RollForward, v, StringComparison.OrdinalIgnoreCase))) { Log.LogError(Strings.InvalidRollForwardValue, RollForward, string.Join(", ", RollForwardValues)); return; } } LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); WriteRuntimeConfig(projectContext); if (writeDevRuntimeConfig) { WriteDevRuntimeConfig(projectContext); } }
protected override void ExecuteCore() { bool writeDevRuntimeConfig = !string.IsNullOrEmpty(RuntimeConfigDevPath); if (!WriteAdditionalProbingPathsToMainConfig) { if (AdditionalProbingPaths?.Any() == true && !writeDevRuntimeConfig) { Log.LogWarning(Strings.SkippingAdditionalProbingPaths); } } if (!string.IsNullOrEmpty(RollForward)) { if (!RollForwardValues.Any(v => string.Equals(RollForward, v, StringComparison.OrdinalIgnoreCase))) { Log.LogError(Strings.InvalidRollForwardValue, RollForward, string.Join(", ", RollForwardValues)); return; } } if (AssetsFilePath == null) { var isFrameworkDependent = LockFileExtensions.IsFrameworkDependent( RuntimeFrameworks, IsSelfContained, RuntimeIdentifier, string.IsNullOrWhiteSpace(PlatformLibraryName)); if (isFrameworkDependent != true) { throw new ArgumentException( $"{nameof(DependencyContextBuilder)} Does not support non FrameworkDependent without asset file. " + $"runtimeFrameworks: {string.Join(",", RuntimeFrameworks.Select(r => r.ItemSpec))} " + $"isSelfContained: {IsSelfContained} " + $"runtimeIdentifier: {RuntimeIdentifier} " + $"platformLibraryName: {PlatformLibraryName}"); } if (PlatformLibraryName != null) { throw new ArgumentException( "Does not support non null PlatformLibraryName(TFM < 3) without asset file."); } WriteRuntimeConfig( RuntimeFrameworks.Select(r => new ProjectContext.RuntimeFramework(r)).ToArray(), null, isFrameworkDependent: true, new List <LockFileItem>()); } else { LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); WriteRuntimeConfig(projectContext.RuntimeFrameworks, projectContext.PlatformLibrary, projectContext.IsFrameworkDependent, projectContext.LockFile.PackageFolders); if (writeDevRuntimeConfig) { WriteDevRuntimeConfig(projectContext.LockFile.PackageFolders); } } }
private void WriteDepsFileNew(string depsFilePath) { LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> referenceAssemblyInfos = ReferenceInfo.CreateReferenceInfos(ReferenceAssemblies); IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths); IEnumerable <ReferenceInfo> dependencyReferences = ReferenceInfo.CreateDependencyReferenceInfos(ReferenceDependencyPaths, ReferenceSatellitePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceDependencyPaths, ReferenceSatellitePaths); IEnumerable <string> excludeFromPublishAssets = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); IEnumerable <RuntimePackAssetInfo> runtimePackAssets = RuntimePackAssets.Select(item => RuntimePackAssetInfo.FromItem(item)); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); var builder = new DependencyContextBuilder2(mainProject, projectContext, IncludeRuntimeFileVersions); builder = builder .WithMainProjectInDepsFile(IncludeMainProject) .WithReferenceAssemblies(referenceAssemblyInfos) .WithDirectReferences(directReferences) .WithDependencyReferences(dependencyReferences) .WithReferenceProjectInfos(referenceProjects) .WithExcludeFromPublishAssets(excludeFromPublishAssets) .WithRuntimePackAssets(runtimePackAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWereFiltered(GetFilteredPackages()); if (CompileReferences.Length > 0) { builder = builder.WithCompileReferences(ReferenceInfo.CreateReferenceInfos(CompileReferences)); } var resolvedNuGetFiles = ResolvedNuGetFiles.Select(f => new ResolvedFile(f, false)) .Concat(ResolvedRuntimeTargetsFiles.Select(f => new ResolvedFile(f, true))); builder = builder.WithResolvedNuGetFiles(resolvedNuGetFiles); DependencyContext dependencyContext = builder.Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(depsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(depsFilePath)); }
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); } }
private void WriteDepsFile(string depsFilePath) { ProjectContext projectContext; if (AssetsFilePath == null) { projectContext = null; } else { LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); } CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); var userRuntimeAssemblySet = new HashSet <string>(UserRuntimeAssemblies ?? Enumerable.Empty <string>(), StringComparer.OrdinalIgnoreCase); Func <ITaskItem, bool> isUserRuntimeAssembly = item => userRuntimeAssemblySet.Contains(item.ItemSpec); IEnumerable <ReferenceInfo> referenceAssemblyInfos = ReferenceInfo.CreateReferenceInfos(ReferenceAssemblies); // If there is a generated asset file. The projectContext will have project reference. // So remove it from directReferences to avoid duplication var projectContextHasProjectReferences = projectContext != null; IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths, projectContextHasProjectReferences, isUserRuntimeAssembly); IEnumerable <ReferenceInfo> dependencyReferences = ReferenceInfo.CreateDependencyReferenceInfos(ReferenceDependencyPaths, ReferenceSatellitePaths, isUserRuntimeAssembly); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos(ReferencePaths, ReferenceSatellitePaths, isUserRuntimeAssembly); IEnumerable <RuntimePackAssetInfo> runtimePackAssets = IsSelfContained ? RuntimePackAssets.Where(item => !IsSingleFile || !item.GetMetadata(MetadataKeys.DropFromSingleFile).Equals("true")) .Select(item => RuntimePackAssetInfo.FromItem(item)) : Enumerable.Empty <RuntimePackAssetInfo>(); DependencyContextBuilder builder; if (projectContext != null) { // Generate the RID-fallback for self-contained builds. // // In order to support loading components with RID-specific assets, // the AssemblyDependencyResolver requires a RID fallback graph. // The component itself should not carry the RID fallback graph with it, because // it would need to carry graph of all the RIDs and needs updates for newer RIDs. // For framework dependent apps, the RID fallback graph comes from the core framework Microsoft.NETCore.App, // so there is no need to write it into the app. // If self-contained apps, the (applicable subset of) RID fallback graph needs to be written to the deps.json manifest. // // If a RID-graph is provided to the DependencyContextBuilder, it generates a RID-fallback // graph with respect to the target RuntimeIdentifier. RuntimeGraph runtimeGraph = IsSelfContained ? new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath) : null; builder = new DependencyContextBuilder(mainProject, IncludeRuntimeFileVersions, runtimeGraph, projectContext); } else { builder = new DependencyContextBuilder( mainProject, IncludeRuntimeFileVersions, RuntimeFrameworks, isSelfContained: IsSelfContained, platformLibraryName: PlatformLibraryName, runtimeIdentifier: RuntimeIdentifier, targetFramework: TargetFramework); } builder = builder .WithMainProjectInDepsFile(IncludeMainProject) .WithReferenceAssemblies(referenceAssemblyInfos) .WithDirectReferences(directReferences) .WithDependencyReferences(dependencyReferences) .WithReferenceProjectInfos(referenceProjects) .WithRuntimePackAssets(runtimePackAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWereFiltered(GetFilteredPackages()); if (CompileReferences.Length > 0) { builder = builder.WithCompileReferences(ReferenceInfo.CreateReferenceInfos(CompileReferences)); } var resolvedNuGetFiles = ResolvedNuGetFiles.Select(f => new ResolvedFile(f, false)) .Concat(ResolvedRuntimeTargetsFiles.Select(f => new ResolvedFile(f, true))); builder = builder.WithResolvedNuGetFiles(resolvedNuGetFiles); DependencyContext dependencyContext = builder.Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(depsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(depsFilePath)); }
protected override void ExecuteCore() { var embeddedApphostPaths = new List <ITaskItem>(); foreach (var runtimeIdentifier in ShimRuntimeIdentifiers.Select(r => r.ItemSpec)) { var resolvedApphostAssetPath = GetApphostAsset(ApphostsForShimRuntimeIdentifiers, runtimeIdentifier); var packagedShimOutputDirectoryAndRid = Path.Combine( PackagedShimOutputDirectory, runtimeIdentifier); var appHostDestinationFilePath = Path.Combine( packagedShimOutputDirectoryAndRid, ToolCommandName + ExecutableExtension.ForRuntimeIdentifier(runtimeIdentifier)); Directory.CreateDirectory(packagedShimOutputDirectoryAndRid); // per https://github.com/dotnet/cli/issues/9870 nuget layout (as in {packageid}/{packageversion}/tools/)is normalized version var normalizedPackageVersion = NuGetVersion.Parse(PackageVersion).ToNormalizedString(); // 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(), normalizedPackageVersion, PackageId.ToLowerInvariant(), normalizedPackageVersion, "tools", NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker).GetShortFolderName(), "any", ToolEntryPoint }); try { var windowsGraphicalUserInterface = runtimeIdentifier.StartsWith("win") && "WinExe".Equals(OutputType, StringComparison.OrdinalIgnoreCase); if (ResourceUpdater.IsSupportedOS() && runtimeIdentifier.StartsWith("win")) { HostWriter.CreateAppHost(appHostSourceFilePath: resolvedApphostAssetPath, appHostDestinationFilePath: appHostDestinationFilePath, appBinaryFilePath: appBinaryFilePath, windowsGraphicalUserInterface: windowsGraphicalUserInterface, assemblyToCopyResorcesFrom: IntermediateAssembly); } else { // by passing null to assemblyToCopyResorcesFrom, it will skip copying resources, // which is only supported on Windows if (windowsGraphicalUserInterface) { Log.LogWarning(Strings.AppHostCustomizationRequiresWindowsHostWarning); } HostWriter.CreateAppHost(appHostSourceFilePath: resolvedApphostAssetPath, appHostDestinationFilePath: appHostDestinationFilePath, appBinaryFilePath: appBinaryFilePath, windowsGraphicalUserInterface: false, assemblyToCopyResorcesFrom: null); } } catch (AppNameTooLongException ex) { throw new BuildErrorException(Strings.FileNameIsTooLong, ex.LongName); } catch (PlaceHolderNotFoundInAppHostException ex) { throw new BuildErrorException(Strings.AppHostHasBeenModified, resolvedApphostAssetPath, BitConverter.ToString(ex.MissingPattern)); } var item = new TaskItem(appHostDestinationFilePath); item.SetMetadata(MetadataKeys.ShimRuntimeIdentifier, runtimeIdentifier); embeddedApphostPaths.Add(item); } EmbeddedApphostPaths = embeddedApphostPaths.ToArray(); }