private SemanticVersion ResolvePackageVersion(string projectFile) { var projectFolder = Path.GetDirectoryName(projectFile); var projectLockFile = Path.Combine(projectFolder, LockFileFormat.LockFileName); if (!File.Exists(projectLockFile)) { _reports.WriteError("The project.lock.json file is missing. Restore the packages to generate it."); return(null); } var lockFileReader = new LockFileFormat(); var lockFile = lockFileReader.Read(projectLockFile); var librariesForPackage = lockFile ?.Libraries .Where(lib => string.Equals(_packageId, lib.Name, StringComparison.OrdinalIgnoreCase)); // Projects can reference multiple versions of the same library if (librariesForPackage.Count() > 1) { _reports.WriteError($"The project references multiple versions of the '{_packageId}'."); return(null); } var packageVersion = librariesForPackage.FirstOrDefault()?.Version; if (packageVersion == null) { _reports.WriteError($"The project is not referencing the '{_packageId}' package. Sources can be retrieved only for packages used by the project."); return(null); } return(packageVersion); }
public static IReadOnlyList <PackageIdentity> GetOrderedProjectDependencies( BuildIntegratedNuGetProject buildIntegratedProject) { var results = new List <PackageIdentity>(); var lockFilePath = ProjectJsonPathUtilities.GetLockFilePath(buildIntegratedProject.JsonConfigPath); var lockFileFormat = new LockFileFormat(); // Read the lock file to find the full closure of dependencies if (File.Exists(lockFilePath)) { var lockFile = lockFileFormat.Read(lockFilePath); var dependencies = new HashSet <PackageDependencyInfo>(PackageIdentity.Comparer); foreach (var target in lockFile.Targets) { foreach (var targetLibrary in target.Libraries) { var identity = new PackageIdentity(targetLibrary.Name, targetLibrary.Version); var dependency = new PackageDependencyInfo(identity, targetLibrary.Dependencies); dependencies.Add(dependency); } } // Sort dependencies var sortedDependencies = SortPackagesByDependencyOrder(dependencies); results.AddRange(sortedDependencies); } return(results); }
public async Task NETCoreProject2Project_VerifyLibFilesUnderCompile(string path, string expected) { // Arrange using (var cacheContext = new SourceCacheContext()) using (var pathContext = new SimpleTestPathContext()) { var logger = new TestLogger(); var sources = new List <PackageSource>(); sources.Add(new PackageSource(pathContext.PackageSource)); var spec1 = NETCoreRestoreTestUtility.GetProject(projectName: "projectA", framework: "netstandard1.6"); var spec2 = NETCoreRestoreTestUtility.GetProject(projectName: "projectB", framework: "netstandard1.3"); var specs = new[] { spec1, spec2 }; // Create fake projects, the real data is in the specs var projects = NETCoreRestoreTestUtility.CreateProjectsFromSpecs(pathContext, specs); // Link projects spec1.RestoreMetadata.TargetFrameworks.Single().ProjectReferences.Add(new ProjectRestoreReference() { ProjectPath = projects[1].ProjectPath, ProjectUniqueName = spec2.RestoreMetadata.ProjectUniqueName, }); var projectDir = Path.GetDirectoryName(spec2.RestoreMetadata.ProjectPath); var absolutePath = Path.Combine(projectDir, "bin", "debug", "b.dll"); spec2.RestoreMetadata.Files.Add(new ProjectRestoreMetadataFile(path, Path.Combine(projectDir, absolutePath))); // Create dg file var dgFile = new DependencyGraphSpec(); dgFile.AddProject(spec1); dgFile.AddProject(spec2); dgFile.AddRestore(spec1.RestoreMetadata.ProjectUniqueName); dgFile.Save(Path.Combine(pathContext.WorkingDirectory, "out.dg")); var lockFormat = new LockFileFormat(); // Act var summaries = await NETCoreRestoreTestUtility.RunRestore(pathContext, logger, sources, dgFile, cacheContext); var success = summaries.All(s => s.Success); // Assert Assert.True(success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); var assetsFile = lockFormat.Read(Path.Combine(spec1.RestoreMetadata.OutputPath, LockFileFormat.AssetsFileName)); var projectBTarget = assetsFile.Targets.Single().Libraries.Single(e => e.Type == "project"); // Verify compile and runtime Assert.Equal(expected, string.Join("|", projectBTarget.CompileTimeAssemblies.Select(e => e.Path))); Assert.Equal(expected, string.Join("|", projectBTarget.RuntimeAssemblies.Select(e => e.Path))); } }
public static bool RequiresPackageRestore(string functionPath) { string projectFilePath = Path.Combine(functionPath, DotNetConstants.ProjectFileName); if (!File.Exists(projectFilePath)) { // If there's no project file, we can just return from here // as there's nothing to restore return(false); } string lockFilePath = Path.Combine(functionPath, DotNetConstants.ProjectLockFileName); if (!File.Exists(lockFilePath)) { // If have a project.json and no lock file, we need to // restore the packages, just return true and skip validation return(true); } // This mimics the logic used by Nuget to validate a lock file against a given project file. // In order to determine whether we have a match, we: // - Read the project frameworks and their dependencies, // extracting the appropriate version range using the lock file format // - Read the lock file depenency groups // - Ensure that each project dependency matches a dependency in the lock file for the // appropriate group matching the framework (including non-framework specific/project wide dependencies) LockFile lockFile = null; try { var reader = new LockFileFormat(); lockFile = reader.Read(lockFilePath); } catch (FileFormatException) { return(true); } var projectDependencies = GetProjectDependencies(projectFilePath) .Select(d => d.ToLockFileDependencyGroupString()) .OrderBy(d => d, StringComparer.OrdinalIgnoreCase) .ToList(); var dependencyGroups = lockFile.ProjectFileDependencyGroups .Where(d => string.Equals(d.FrameworkName, FrameworkConstants.CommonFrameworks.NetStandard20.DotNetFrameworkName, StringComparison.OrdinalIgnoreCase)) .Aggregate(new List <string>(), (a, d) => { a.AddRange(d.Dependencies.Where(name => !name.StartsWith("NETStandard.Library", StringComparison.OrdinalIgnoreCase))); return(a); }); return(!projectDependencies.SequenceEqual(dependencyGroups.OrderBy(d => d, StringComparer.OrdinalIgnoreCase))); }
public async Task Restore_TamperedPackage_FailsAsync() { // Arrange var nupkg = new SimpleTestPackageContext("A", "1.0.0"); using (var pathContext = new SimpleTestPathContext()) using (var testCertificate = new X509Certificate2(_trustedTestCert.Source.Cert)) { // Set up solution, project, and packages var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot); var projectA = SimpleTestProjectContext.CreateNETCore( "a", pathContext.SolutionRoot, NuGetFramework.Parse("NETStandard2.0")); var packageX = new SimpleTestPackageContext("X", "9.0.0"); var signedPackagePath = await SignedArchiveTestUtility.AuthorSignPackageAsync(testCertificate, packageX, pathContext.PackageSource); SignedArchiveTestUtility.TamperWithPackage(signedPackagePath); projectA.AddPackageToAllFrameworks(packageX); solution.Projects.Add(projectA); solution.Create(pathContext.SolutionRoot); var args = new string[] { projectA.ProjectPath, "-Source", pathContext.PackageSource }; // Act var result = RunRestore(_nugetExePath, pathContext, expectedExitCode: 1, additionalArgs: args); var reader = new LockFileFormat(); var lockFile = reader.Read(projectA.AssetsFileOutputPath); var errors = lockFile.LogMessages.Where(m => m.Level == LogLevel.Error); var warnings = lockFile.LogMessages.Where(m => m.Level == LogLevel.Warning); // Assert result.ExitCode.Should().Be(1); result.Errors.Should().Contain(_NU3008); result.AllOutput.Should().Contain($"WARNING: {_NU3027}"); errors.Count().Should().Be(1); errors.First().Code.Should().Be(NuGetLogCode.NU3008); errors.First().Message.Should().Be(_NU3008Message); errors.First().LibraryId.Should().Be(packageX.ToString()); warnings.Count().Should().Be(1); warnings.First().Code.Should().Be(NuGetLogCode.NU3027); warnings.First().Message.Should().Be(_NU3027Message); warnings.First().LibraryId.Should().Be("X.9.0.0"); } }
public static void UpdateDependencies(SolutionProject project, bool directDependencies, bool flattenedDependencies) { if (flattenedDependencies) { project.FlattenedDependencies.Clear(); } if (directDependencies) { project.DirectDependencies.Clear(); } var projectAssetsJsonPath = Path.Combine(project.FullPath.GetFullDirectory(), @"obj", LockFileFormat.AssetsFileName); if (File.Exists(projectAssetsJsonPath)) { var format = new LockFileFormat(); var projectAssets = format.Read(projectAssetsJsonPath); // Update dependencies if (flattenedDependencies) { foreach (var library in projectAssets.Libraries) { var projectDependency = new Dependency(library.Name, library.Version.ToPackageVersion(), library.Type == "project" ? DependencyType.Project : DependencyType.Package) { MSBuildProject = library.Type == "project" ? library.MSBuildProject : null }; project.FlattenedDependencies.Add(projectDependency); // Try to resolve package if already loaded projectDependency.Package = project.Session.Packages.Find(projectDependency); } } if (directDependencies) { foreach (var projectReference in projectAssets.PackageSpec.RestoreMetadata.TargetFrameworks.First().ProjectReferences) { var projectName = new UFile(projectReference.ProjectUniqueName).GetFileNameWithoutExtension(); project.DirectDependencies.Add(new DependencyRange(projectName, null, DependencyType.Project) { MSBuildProject = projectReference.ProjectPath }); } foreach (var dependency in projectAssets.PackageSpec.TargetFrameworks.First().Dependencies) { if (dependency.AutoReferenced) { continue; } project.DirectDependencies.Add(new DependencyRange(dependency.Name, dependency.LibraryRange.VersionRange.ToPackageVersionRange(), DependencyType.Package)); } } } }
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path) { return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync( path, lockedToken => { var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path)); return lockFile; }, CancellationToken.None)); }
public override bool Execute() { var assetsFilePath = string.Empty; if (!string.IsNullOrEmpty(ProjectAssetsFileAbsolutePath) && File.Exists(ProjectAssetsFileAbsolutePath)) { assetsFilePath = ProjectAssetsFileAbsolutePath; } else { assetsFilePath = Path.Combine(RestoreOutputAbsolutePath, LockFileFormat.AssetsFileName); } if (!File.Exists(assetsFilePath)) { throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileNotFound, assetsFilePath)); } // The assets file is necessary for project and package references. Pack should not do any traversal, // so we leave that work up to restore (which produces the assets file). var lockFileFormat = new LockFileFormat(); var assetsFile = lockFileFormat.Read(assetsFilePath); if (assetsFile.PackageSpec == null) { throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileDoesNotHaveValidPackageSpec, assetsFilePath)); } var projectDirectory = Path.GetDirectoryName(assetsFile.PackageSpec.RestoreMetadata.ProjectPath); // Using the libraries section of the assets file, the library name and version for the project path. var projectPathToLibraryIdentities = assetsFile .Libraries .Where(library => library.MSBuildProject != null) .Select(library => new TaskItem(Path.GetFullPath(Path.Combine( projectDirectory, PathUtility.GetPathWithDirectorySeparator(library.MSBuildProject))))); if (projectPathToLibraryIdentities != null) { ProjectReferences = projectPathToLibraryIdentities.ToArray(); } else { ProjectReferences = Array.Empty <ITaskItem>(); } return(true); }
/// <summary> /// Read lock file /// </summary> public static LockFile GetLockFileOrNull(string lockFilePath) { LockFile lockFile = null; var lockFileFormat = new LockFileFormat(); // Read the lock file to find the full closure of dependencies if (File.Exists(lockFilePath)) { lockFile = lockFileFormat.Read(lockFilePath); } return(lockFile); }
private static ImmutableArray <PackageReference> InitializeAssemblyRegistry(string functionDirectory) { var builder = ImmutableArray <PackageReference> .Empty.ToBuilder(); string fileName = Path.Combine(functionDirectory, DotNetConstants.ProjectLockFileName); if (File.Exists(fileName)) { LockFile lockFile = null; try { var reader = new LockFileFormat(); lockFile = reader.Read(fileName); var target = lockFile.Targets .FirstOrDefault(t => string.Equals(t.TargetFramework.DotNetFrameworkName, FrameworkConstants.CommonFrameworks.NetStandard20.DotNetFrameworkName)); if (target != null) { string nugetCachePath = PackageManager.GetNugetPackagesPath(); // Get all the referenced libraries for the target, excluding the framework references we add by default var libraries = target.Libraries.Where(s => !DotNetConstants.FrameworkReferences.Contains(s.Name)); foreach (var library in libraries) { var package = new PackageReference(library.Name, library.Version.ToFullString()); var assemblies = GetAssembliesList(library.CompileTimeAssemblies, nugetCachePath, package); package.CompileTimeAssemblies.AddRange(assemblies); assemblies = GetAssembliesList(library.RuntimeAssemblies, nugetCachePath, package); package.RuntimeAssemblies.AddRange(assemblies); var frameworkAssemblies = library.FrameworkAssemblies.ToDictionary(a => new AssemblyName(a)); package.FrameworkAssemblies.AddRange(frameworkAssemblies); builder.Add(package); } } } catch (FileFormatException) { return(ImmutableArray <PackageReference> .Empty); } } return(builder.ToImmutableArray()); }
private static bool TryReadLockFile(string directory, out LockFile lockFile) { lockFile = null; string file = Path.Combine(directory, LockFileFormat.LockFileName); if (File.Exists(file)) { using (var stream = File.OpenRead(file)) { lockFile = LockFileFormat.Read(stream); } return(true); } return(false); }
public async Task StandaloneProject_BasicRestore() { // Arrange using (var pathContext = new SimpleTestPathContext()) { var logger = new TestLogger(); var dgFile = new DependencyGraphSpec(); var projectJson = @" { ""frameworks"": { ""netstandard1.6"": { ""dependencies"": { ""a"": ""1.0.0"" } } } }"; var spec = JsonPackageSpecReader.GetPackageSpec(projectJson, "x", Path.Combine(pathContext.SolutionRoot, "project.json")); spec.RestoreMetadata = new ProjectRestoreMetadata(); spec.RestoreMetadata.ProjectStyle = ProjectStyle.Standalone; spec.RestoreMetadata.OutputPath = Path.Combine(pathContext.SolutionRoot, "x"); spec.RestoreMetadata.ProjectUniqueName = "x"; spec.RestoreMetadata.ProjectName = "x"; spec.RestoreMetadata.ProjectPath = Path.Combine(pathContext.SolutionRoot, "x.csproj"); dgFile.AddProject(spec); dgFile.AddRestore("x"); await SimpleTestPackageUtility.CreateFolderFeedV3Async(pathContext.PackageSource, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); // Act var result = await CommandsTestUtility.RunSingleRestore(dgFile, pathContext, logger); var path = Path.Combine(spec.RestoreMetadata.OutputPath, "project.assets.json"); // Assert Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); Assert.True(File.Exists(path)); var lockFormat = new LockFileFormat(); var lockFile = lockFormat.Read(path); Assert.Equal(NuGetFramework.Parse("netstandard1.6"), lockFile.Targets.Single().TargetFramework); Assert.Equal("a", lockFile.Targets.Single().Libraries.Single().Name); } }
public async Task GivenAProjectIsUsedOverAPackageVerifyNoDowngradeWarningAsync() { // Arrange using (var pathContext = new SimpleTestPathContext()) { // Set up solution, project, and packages var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot); var projectA = SimpleTestProjectContext.CreateNETCore( "a", pathContext.SolutionRoot, NuGetFramework.Parse("NETStandard1.5")); var projectB = SimpleTestProjectContext.CreateNETCore( "b", pathContext.SolutionRoot, NuGetFramework.Parse("NETStandard1.5")); // A -> B projectA.AddProjectToAllFrameworks(projectB); var packageX = new SimpleTestPackageContext("x", "9.0.0"); var packageB = new SimpleTestPackageContext("b", "9.0.0"); packageX.Dependencies.Add(packageB); await SimpleTestPackageUtility.CreatePackagesAsync(pathContext.PackageSource, packageX, packageB); // PackageB will be overridden by ProjectB projectA.AddPackageToAllFrameworks(packageX); solution.Projects.Add(projectA); solution.Projects.Add(projectB); solution.Create(pathContext.SolutionRoot); // Act var r = Util.Restore(pathContext, projectA.ProjectPath); var output = r.Item2 + " " + r.Item3; var reader = new LockFileFormat(); var lockFileObj = reader.Read(projectA.AssetsFileOutputPath); // Assert Assert.NotNull(lockFileObj); Assert.Equal(0, lockFileObj.LogMessages.Count()); Assert.DoesNotContain("downgrade", output, StringComparison.OrdinalIgnoreCase); } }
public ImmutableArray <PackageReference> FindUnresolvedPackageReferences(ProjectFileInfo projectFile) { if (projectFile.PackageReferences.Length == 0) { return(ImmutableArray <PackageReference> .Empty); } // If the lock file does not exist, all of the package references are unresolved. if (!File.Exists(projectFile.ProjectAssetsFile)) { return(projectFile.PackageReferences); } var lockFileFormat = new LockFileFormat(); var lockFile = lockFileFormat.Read(projectFile.ProjectAssetsFile); return(FindUnresolvedPackageReferencesInLockFile(projectFile, lockFile)); }
public AssetsFileDependenciesSnapshot UpdateFromAssetsFile(string path) { Requires.NotNull(path, nameof(path)); try { // Parse the file using var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete, 4096 * 10, FileOptions.SequentialScan); LockFile lockFile = LockFileFormat.Read(fileStream, path); return(new AssetsFileDependenciesSnapshot(lockFile, this)); } catch { return(this); } }
public ModuleLoaderContext(IServiceProvider serviceProvider, string projectDirectory) { ProjectDirectory = projectDirectory; RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory); // A new project resolver is required. you cannot reuse the one from the // parent service provider as that will be for the parent context. ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory); var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver()); // Need to pass through package directory incase you download a package from the gallary, this needs to know about it var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository( NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory))); var gacDependencyResolver = new GacDependencyResolver(); var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver); var unresolvedDependencyProvider = new UnresolvedDependencyProvider(); var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName); if (File.Exists(projectLockJsonPath)) { var lockFileFormat = new LockFileFormat(); var lockFile = lockFileFormat.Read(projectLockJsonPath); nuGetDependencyProvider.ApplyLockFile(lockFile); } DependencyWalker = new DependencyWalker(new IDependencyProvider[] { projectDepencyProvider, nuGetDependencyProvider, referenceAssemblyDependencyResolver, gacDependencyResolver, unresolvedDependencyProvider }); LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] { new ModuleProjectLibraryExportProvider( ProjectResolver, serviceProvider), referenceAssemblyDependencyResolver, gacDependencyResolver, nuGetDependencyProvider }); }
public async Task GivenAPackageDowngradeVerifyDowngradeWarningAsync() { // Arrange using (var pathContext = new SimpleTestPathContext()) { // Set up solution, project, and packages var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot); var projectA = SimpleTestProjectContext.CreateNETCore( "a", pathContext.SolutionRoot, NuGetFramework.Parse("NETStandard1.5")); var packageB = new SimpleTestPackageContext("b", "9.0.0"); var packageI1 = new SimpleTestPackageContext("i", "9.0.0"); var packageI2 = new SimpleTestPackageContext("i", "1.0.0"); packageB.Dependencies.Add(packageI1); await SimpleTestPackageUtility.CreatePackagesAsync(pathContext.PackageSource, packageB, packageI1, packageI2); projectA.AddPackageToAllFrameworks(packageB); projectA.AddPackageToAllFrameworks(packageI2); solution.Projects.Add(projectA); solution.Create(pathContext.SolutionRoot); // Act var r = Util.Restore(pathContext, projectA.ProjectPath); var output = r.Item2 + " " + r.Item3; var reader = new LockFileFormat(); var lockFileObj = reader.Read(projectA.AssetsFileOutputPath); // Assert Assert.NotNull(lockFileObj); Assert.Equal(1, lockFileObj.LogMessages.Count()); Assert.Contains("Detected package downgrade: i from 9.0.0 to 1.0.0", lockFileObj.LogMessages.First().Message, StringComparison.OrdinalIgnoreCase); Assert.Contains("Detected package downgrade: i from 9.0.0 to 1.0.0", output, StringComparison.OrdinalIgnoreCase); } }
public static async Task <PackageVersion> GetPackageVersion(string fullPath) { try { // Solution file: extract projects var solutionDirectory = Path.GetDirectoryName(fullPath) ?? ""; var solution = Stride.Core.VisualStudio.Solution.FromFile(fullPath); foreach (var project in solution.Projects) { if (project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharp || project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharpNewSystem) { var projectPath = project.FullPath; var projectAssetsJsonPath = Path.Combine(Path.GetDirectoryName(projectPath), @"obj", LockFileFormat.AssetsFileName); #if !STRIDE_LAUNCHER && !STRIDE_VSPACKAGE if (!File.Exists(projectAssetsJsonPath)) { var log = new Stride.Core.Diagnostics.LoggerResult(); await VSProjectHelper.RestoreNugetPackages(log, projectPath); } #endif if (File.Exists(projectAssetsJsonPath)) { var format = new LockFileFormat(); var projectAssets = format.Read(projectAssetsJsonPath); foreach (var library in projectAssets.Libraries) { if ((library.Type == "package" || library.Type == "project") && (library.Name == "Stride.Engine" || library.Name == "Xenko.Engine")) { return(new PackageVersion((string)library.Version.ToString())); } } } } } } catch (Exception e) { e.Ignore(); } return(null); }
public ModuleLoaderContext(IServiceProvider serviceProvider, string projectDirectory) { ProjectDirectory = projectDirectory; RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory); // A new project resolver is required. you cannot reuse the one from the // parent service provider as that will be for the parent context. ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory); var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver()); // Need to pass through package directory incase you download a package from the gallary, this needs to know about it var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository( NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory))); var gacDependencyResolver = new GacDependencyResolver(); var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver); var unresolvedDependencyProvider = new UnresolvedDependencyProvider(); var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName); if (File.Exists(projectLockJsonPath)) { var lockFileFormat = new LockFileFormat(); var lockFile = lockFileFormat.Read(projectLockJsonPath); nuGetDependencyProvider.ApplyLockFile(lockFile); } DependencyWalker = new DependencyWalker(new IDependencyProvider[] { projectDepencyProvider, nuGetDependencyProvider, referenceAssemblyDependencyResolver, gacDependencyResolver, unresolvedDependencyProvider }); LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] { new ModuleProjectLibraryExportProvider( ProjectResolver, serviceProvider), referenceAssemblyDependencyResolver, gacDependencyResolver, nuGetDependencyProvider }); }
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path) { if (!File.Exists(path)) { throw new GracefulException(string.Join( Environment.NewLine, $"File not found `{path}`.", "The project may not have been restored or restore failed - run `dotnet restore`")); } return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync( path, lockedToken => { var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path)); return lockFile; }, CancellationToken.None)); }
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path) { return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync( path, lockedToken => { if (!File.Exists(path)) { throw new GracefulException(string.Join( Environment.NewLine, string.Format(Resources.GetString("FileNotFound"), path), Resources.GetString("ProjectNotRestoredOrRestoreFailed"))); } var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path), Resources.GetString("CouldNotAccessAssetsFile")); return lockFile; }, CancellationToken.None)); }
public static async Task <LockFile> ReadWithLock(this LockFileFormat subject, string path) { if (!File.Exists(path)) { throw new GracefulException(string.Join( Environment.NewLine, string.Format(LocalizableStrings.FileNotFound, path), LocalizableStrings.ProjectNotRestoredOrRestoreFailed)); } return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync( path, lockedToken => { var lockFile = FileAccessRetrier.RetryOnFileAccessFailure(() => subject.Read(path)); return lockFile; }, CancellationToken.None)); }
private LockFile GetAssetsFile(IPackTaskRequest <IMSBuildItem> request) { if (request.PackItem == null) { throw new PackagingException(NuGetLogCode.NU5028, Strings.NoPackItemProvided); } string assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName); if (!File.Exists(assetsFilePath)) { throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileNotFound, assetsFilePath)); } // The assets file is necessary for project and package references. Pack should not do any traversal, // so we leave that work up to restore (which produces the assets file). var lockFileFormat = new LockFileFormat(); return(lockFileFormat.Read(assetsFilePath)); }
public void GivenAnUnknownPackageVerifyError() { // Arrange using (var pathContext = new SimpleTestPathContext()) { // Set up solution, project, and packages var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot); var projectA = SimpleTestProjectContext.CreateNETCore( "a", pathContext.SolutionRoot, NuGetFramework.Parse("NETStandard1.5")); var packageB = new SimpleTestPackageContext("b", "9.0.0"); projectA.AddPackageToAllFrameworks(packageB); solution.Projects.Add(projectA); solution.Create(pathContext.SolutionRoot); // Act var r = Util.Restore(pathContext, projectA.ProjectPath, expectedExitCode: 1); var output = r.Item2 + " " + r.Item3; var reader = new LockFileFormat(); var lockFileObj = reader.Read(projectA.AssetsFileOutputPath); // Assert Assert.NotNull(lockFileObj); Assert.Equal(1, lockFileObj.LogMessages.Count()); Assert.Contains("Unable to find package b. No packages exist with this id in source(s): source", lockFileObj.LogMessages.First().Message, StringComparison.OrdinalIgnoreCase); Assert.Contains("Unable to find package b. No packages exist with this id in source(s): source", output, StringComparison.OrdinalIgnoreCase); } }
public async Task Project2ProjectInLockFile_VerifyProjectsReferencesInLibAndTargets() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""1.0.0"", ""frameworks"": { ""net45"": {} } }"; var project3Json = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; using (var packagesDir = TestDirectory.Create()) using (var workingDir = TestDirectory.Create()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3")); project1.Create(); project2.Create(); project3.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json); var project1Path = Path.Combine(project1.FullName, "project1.csproj"); var project2Path = Path.Combine(project2.FullName, "project2.csproj"); var project3Path = Path.Combine(project3.FullName, "project3.csproj"); File.WriteAllText(project1Path, string.Empty); File.WriteAllText(project2Path, string.Empty); File.WriteAllText(project3Path, string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var specPath3 = Path.Combine(project3.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project2", specPath2); var spec3 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project3", specPath3); var logger = new TestLogger(); var restoreContext = new RestoreArgs() { GlobalPackagesFolder = packagesDir, Log = logger, CacheContext = new SourceCacheContext() }; // Modify specs for netcore spec3 = spec3.WithTestRestoreMetadata(); spec3.FilePath = project3Path; spec3.RestoreMetadata.ProjectPath = project3Path; spec3.RestoreMetadata.ProjectUniqueName = project3Path; spec2 = spec2.WithTestRestoreMetadata().WithTestProjectReference(spec3); spec2.FilePath = project2Path; spec2.RestoreMetadata.ProjectPath = project2Path; spec2.RestoreMetadata.ProjectUniqueName = project2Path; spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2); spec1.FilePath = project1Path; spec1.RestoreMetadata.ProjectPath = project1Path; spec1.RestoreMetadata.ProjectUniqueName = project1Path; var request = await ProjectJsonTestHelpers.GetRequestAsync(restoreContext, spec1, spec2, spec3); request.LockFilePath = Path.Combine(project1.FullName, "project.assets.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); Assert.True(result.Success, logger.ShowMessages()); var lockFile = format.Read(request.LockFilePath, logger); var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0")); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0")); var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project2") .Single(); var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project3") .Single(); // Assert Assert.True(result.Success); Assert.Equal(2, lockFile.Libraries.Count); Assert.Equal("project", project2Lib.Type); Assert.Equal("project", project3Lib.Type); Assert.Equal("../project2/project2.csproj", project2Lib.Path); Assert.Equal("../project3/project3.csproj", project3Lib.Path); Assert.Equal("../project2/project2.csproj", project2Lib.MSBuildProject); Assert.Equal("../project3/project3.csproj", project3Lib.MSBuildProject); Assert.Equal(1, project2Target.Dependencies.Count); Assert.Equal("project3", project2Target.Dependencies.Single().Id); Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString()); Assert.Equal(0, project3Target.Dependencies.Count); Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework); Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework); } }
public async Task Project2ProjectInLockFile_VerifyProjectsUnderProjectFileDependencyGroups_External() { // Arrange var sources = new List <PackageSource>(); var projectJson = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; using (var packagesDir = TestDirectory.Create()) using (var workingDir = TestDirectory.Create()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3")); project1.Create(); project2.Create(); project3.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), projectJson); File.WriteAllText(Path.Combine(project3.FullName, "project.json"), projectJson); File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.csproj"), string.Empty); File.WriteAllText(Path.Combine(project3.FullName, "project3.csproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var specPath3 = Path.Combine(project3.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project2", specPath2); var spec3 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project3", specPath3); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir, logger); request.ExternalProjects.Add(new ExternalProjectReference( "project1", spec1, Path.Combine(project1.FullName, "project1.xproj"), new string[] { "project2" })); request.ExternalProjects.Add(new ExternalProjectReference( "project2", spec2, Path.Combine(project2.FullName, "project2.csproj"), new string[] { "project3" })); request.ExternalProjects.Add(new ExternalProjectReference( "project3", spec3, Path.Combine(project3.FullName, "project3.csproj"), new string[] { })); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0")); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0")); var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project2") .Single(); var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project3") .Single(); // Assert Assert.True(result.Success); Assert.Equal(2, lockFile.Libraries.Count); Assert.Equal("project", project2Lib.Type); Assert.Equal("project", project3Lib.Type); Assert.Equal("../project2/project.json", project2Lib.Path); Assert.Equal("../project3/project.json", project3Lib.Path); Assert.Equal("../project2/project2.csproj", project2Lib.MSBuildProject); Assert.Equal("../project3/project3.csproj", project3Lib.MSBuildProject); Assert.Equal(1, project2Target.Dependencies.Count); Assert.Equal("project3", project2Target.Dependencies.Single().Id); Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString()); Assert.Equal(0, project3Target.Dependencies.Count); Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework); Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework); } }
public async Task Project2ProjectInLockFile_VerifySnapshotVersions() { // Arrange var sources = new List <PackageSource>(); var projectJson = @" { ""version"": ""2.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj2 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""dependencies"": { ""project3"": ""2.0.0-*"" }, ""frameworks"": { ""net45"": { } } }"; var project3Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj3 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var globalJson = @" { ""projects"": [ ""projects"" ] }"; using (var packagesDir = TestDirectory.Create()) using (var workingDir = TestDirectory.Create()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3")); project1.Create(); project2.Create(); project3.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json); File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson); File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project3.xproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var specPath3 = Path.Combine(project3.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var spec3 = JsonPackageSpecReader.GetPackageSpec(project3Json, "project3", specPath3); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir, logger); request.ExternalProjects.Add(new ExternalProjectReference( "project1", spec1, Path.Combine(project1.FullName, "project1.csproj"), new string[] { "project2" })); request.ExternalProjects.Add(new ExternalProjectReference( "project2", spec2, Path.Combine(project2.FullName, "project2.xproj"), new string[] { "project3" })); request.ExternalProjects.Add(new ExternalProjectReference( "project3", spec3, Path.Combine(project2.FullName, "project3.xproj"), new string[] { })); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("2.0.0")); var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("2.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Single(lib => lib.Name == "project2"); var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Single(lib => lib.Name == "project3"); // Assert Assert.True(result.Success); Assert.Equal("2.0.0", project2Target.Version.ToString()); Assert.Equal("2.0.0", project3Target.Version.ToString()); Assert.Equal("2.0.0", project2Lib.Version.ToString()); Assert.Equal("2.0.0", project3Lib.Version.ToString()); Assert.Equal("2.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString()); } }
public async Task ExecuteCommandAsync(ListPackageArgs listPackageArgs) { if (!File.Exists(listPackageArgs.Path)) { Console.Error.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.ListPkg_ErrorFileNotFound, listPackageArgs.Path)); return; } //If the given file is a solution, get the list of projects //If not, then it's a project, which is put in a list var projectsPaths = Path.GetExtension(listPackageArgs.Path).Equals(".sln") ? MSBuildAPIUtility.GetProjectsFromSolution(listPackageArgs.Path).Where(f => File.Exists(f)) : new List <string>(new string[] { listPackageArgs.Path }); var autoReferenceFound = false; var msBuild = new MSBuildAPIUtility(listPackageArgs.Logger); //Print sources, but not for generic list (which is offline) if (listPackageArgs.ReportType != ReportType.Default) { Console.WriteLine(); Console.WriteLine(Strings.ListPkg_SourcesUsedDescription); ProjectPackagesPrintUtility.PrintSources(listPackageArgs.PackageSources); Console.WriteLine(); } foreach (var projectPath in projectsPaths) { //Open project to evaluate properties for the assets //file and the name of the project var project = MSBuildAPIUtility.GetProject(projectPath); if (!MSBuildAPIUtility.IsPackageReferenceProject(project)) { Console.Error.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.Error_NotPRProject, projectPath)); Console.WriteLine(); continue; } var projectName = project.GetPropertyValue(ProjectName); var assetsPath = project.GetPropertyValue(ProjectAssetsFile); // If the file was not found, print an error message and continue to next project if (!File.Exists(assetsPath)) { Console.Error.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.Error_AssetsFileNotFound, projectPath)); Console.WriteLine(); } else { var lockFileFormat = new LockFileFormat(); var assetsFile = lockFileFormat.Read(assetsPath); // Assets file validation if (assetsFile.PackageSpec != null && assetsFile.Targets != null && assetsFile.Targets.Count != 0) { // Get all the packages that are referenced in a project var packages = msBuild.GetResolvedVersions(project.FullPath, listPackageArgs.Frameworks, assetsFile, listPackageArgs.IncludeTransitive, includeProjects: listPackageArgs.ReportType == ReportType.Default); // If packages equals null, it means something wrong happened // with reading the packages and it was handled and message printed // in MSBuildAPIUtility function, but we need to move to the next project if (packages != null) { // No packages means that no package references at all were found in the current framework if (!packages.Any()) { Console.WriteLine(string.Format(Strings.ListPkg_NoPackagesFoundForFrameworks, projectName)); } else { if (listPackageArgs.ReportType != ReportType.Default) // generic list package is offline -- no server lookups { PopulateSourceRepositoryCache(listPackageArgs); await GetRegistrationMetadataAsync(packages, listPackageArgs); await AddLatestVersionsAsync(packages, listPackageArgs); } bool printPackages = FilterPackages(packages, listPackageArgs); // Filter packages for dedicated reports, inform user if none if (listPackageArgs.ReportType != ReportType.Default && !printPackages) { switch (listPackageArgs.ReportType) { case ReportType.Outdated: Console.WriteLine(string.Format(Strings.ListPkg_NoUpdatesForProject, projectName)); break; case ReportType.Deprecated: Console.WriteLine(string.Format(Strings.ListPkg_NoDeprecatedPackagesForProject, projectName)); break; case ReportType.Vulnerable: Console.WriteLine(string.Format(Strings.ListPkg_NoVulnerablePackagesForProject, projectName)); break; } } printPackages = printPackages || ReportType.Default == listPackageArgs.ReportType; if (printPackages) { var hasAutoReference = false; ProjectPackagesPrintUtility.PrintPackages(packages, projectName, listPackageArgs, ref hasAutoReference); autoReferenceFound = autoReferenceFound || hasAutoReference; } } } } else { Console.WriteLine(string.Format(Strings.ListPkg_ErrorReadingAssetsFile, assetsPath)); } // Unload project ProjectCollection.GlobalProjectCollection.UnloadProject(project); } } // Print a legend message for auto-reference markers used if (autoReferenceFound) { Console.WriteLine(Strings.ListPkg_AutoReferenceDescription); } }
private void UpdateLockFile(PublishRoot root) { var lockFileFormat = new LockFileFormat(); string lockFilePath; if (root.NoSource) { lockFilePath = Path.Combine(TargetPath, "root", LockFileFormat.LockFileName); } else { lockFilePath = Path.Combine(TargetPath, LockFileFormat.LockFileName); } LockFile lockFile; if (File.Exists(lockFilePath)) { lockFile = lockFileFormat.Read(lockFilePath); } else { lockFile = new LockFile { Islocked = false }; var project = GetCurrentProject(); // Restore dependency groups for future lockfile validation lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup( string.Empty, project.Dependencies.Select(x => x.LibraryRange.ToString()))); foreach (var frameworkInfo in project.GetTargetFrameworks()) { lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup( frameworkInfo.FrameworkName.ToString(), frameworkInfo.Dependencies.Select(x => x.LibraryRange.ToString()))); } } if (root.NoSource) { // The dependency group shared by all frameworks should only contain the main nupkg (i.e. entrypoint) lockFile.ProjectFileDependencyGroups.RemoveAll(g => string.IsNullOrEmpty(g.FrameworkName)); lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup( string.Empty, new[] { _libraryDescription.LibraryRange.ToString() })); } var repository = new PackageRepository(root.TargetPackagesPath); var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath); // For dependency projects that were published to nupkgs // Add them to lockfile to ensure the contents of lockfile are still valid using (var sha512 = SHA512.Create()) { foreach (var publishProject in root.Projects.Where(p => p.IsPackage)) { var packageInfo = repository.FindPackagesById(publishProject.Name) .SingleOrDefault(); if (packageInfo == null) { root.Reports.Information.WriteLine("Unable to locate published package {0} in {1}", publishProject.Name.Yellow(), repository.RepositoryRoot); continue; } var package = packageInfo.Package; var nupkgPath = resolver.GetPackageFilePath(package.Id, package.Version); var project = publishProject.GetCurrentProject(); lockFile.Libraries.Add(LockFileUtils.CreateLockFileLibraryForProject( project, package, sha512, project.GetTargetFrameworks().Select(f => f.FrameworkName), resolver)); } } lockFileFormat.Write(lockFilePath, lockFile); }
private static void Process(FileInfo file) { var json = JObject.Parse(File.ReadAllText(file.FullName)); var format = new LockFileFormat(); var lockFile = format.Read(Path.Combine(file.DirectoryName, "project.lock.json")); var projects = new HashSet<string>(); foreach (var lib in lockFile.Libraries) { if (lib.Type == "project") { projects.Add(lib.Name); } } var dependencies = new List<JProperty>(); var rootDeps = json["dependencies"] as JObject; if (rootDeps != null) { foreach (var dep in rootDeps.Properties()) { dependencies.Add(dep); } } var frameworks = json["frameworks"] as JObject; if (frameworks != null) { foreach (var fw in frameworks.Properties()) { var fwDeps = fw.Value["dependencies"] as JObject; if (fwDeps != null) { foreach (var dep in fwDeps.Properties()) { dependencies.Add(dep); } } } } foreach (var dep in dependencies) { if (projects.Contains(dep.Name)) { if (dep.Value.Type == JTokenType.String) { var newVal = new JObject(); newVal.Add("target", "project"); dep.Value = newVal; } else { var jObj = dep.Value as JObject; var targetProp = jObj.Properties().SingleOrDefault(p => p.Name == "target"); if (targetProp == null) { dep.Value["target"] = "project"; } var versionProp = jObj.Properties().SingleOrDefault(p => p.Name == "version"); if (versionProp != null) { versionProp.Remove(); } } } } File.WriteAllText(file.FullName, json.ToString(), Encoding.UTF8); }
public async Task RestoreTargets_RestoreWithRuntimes() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""netstandardapp1.5"": { ""dependencies"": { ""packageA"": ""1.0.0"" } } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); request.RequestedRuntimes.Add("win7-x86"); var packageA = new SimpleTestPackageContext() { Id = "packageA" }; packageA.AddFile("lib/netstandard1.5/a.dll"); packageA.AddFile("native/a.dll"); packageA.AddFile("runtimes/unix/native/a.dll"); packageA.AddFile("runtimes/unix/lib/netstandard1.5/a.dll"); packageA.AddFile("runtimes/win7/lib/netstandard1.5/a.dll"); packageA.AddFile("runtimes/win7-x86/lib/netstandard1.5/a.dll"); packageA.AddFile("runtimes/win7-x86/lib/netstandard1.5/en-us/a.resources.dll"); SimpleTestPackageUtility.CreatePackages(packageSource.FullName, packageA); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var format = new LockFileFormat(); var lockFile = format.Read(request.LockFilePath); var targetLib = lockFile.Targets.Single(graph => graph.RuntimeIdentifier == null).Libraries.Single(); var ridTargetLib = lockFile.Targets.Single(graph => graph.RuntimeIdentifier != null).Libraries.Single(); // Assert Assert.True(result.Success); Assert.Equal(5, targetLib.RuntimeTargets.Count); Assert.Equal("runtimes/unix/lib/netstandard1.5/a.dll", targetLib.RuntimeTargets[0].Path); Assert.Equal("runtime", targetLib.RuntimeTargets[0].Properties["assetType"]); Assert.Equal("unix", targetLib.RuntimeTargets[0].Properties["rid"]); Assert.Equal("runtimes/win7-x86/lib/netstandard1.5/en-us/a.resources.dll", targetLib.RuntimeTargets[3].Path); Assert.Equal("resource", targetLib.RuntimeTargets[3].Properties["assetType"]); Assert.Equal("win7-x86", targetLib.RuntimeTargets[3].Properties["rid"]); Assert.Equal("runtimes/unix/native/a.dll", targetLib.RuntimeTargets[1].Path); Assert.Equal("native", targetLib.RuntimeTargets[1].Properties["assetType"]); Assert.Equal("unix", targetLib.RuntimeTargets[1].Properties["rid"]); // This section does not exist for RID graphs Assert.Equal(0, ridTargetLib.RuntimeTargets.Count); } }
protected IEnumerable <RuntimeLibrary> GetNugetReferences(string projectFilePath, Project project) { Logger.WriteInfo("Adding nuget references."); ICollection <RuntimeLibrary> runtimeLibraries = new List <RuntimeLibrary>(); LockFileFormat lockFileFormat = new LockFileFormat(); string lockFileFilePath = Path.Combine(Path.GetDirectoryName(projectFilePath), project.GetPropertyValue(PropertyNames.ProjectAssetsFile)); if (!File.Exists(lockFileFilePath)) { Logger.WriteError($"Lock file {lockFileFilePath} not found. Run dotnet restore before executing Automaty."); throw new AutomatyException(); } LockFile lockFile = lockFileFormat.Read(lockFileFilePath); string targetFramework = project.GetPropertyValue(PropertyNames.TargetFramework); if (string.IsNullOrEmpty(targetFramework)) { Logger.WriteDebug("Multi targeting project assembly detected."); targetFramework = GetSuitableTargetFramework(project.GetPropertyValue(PropertyNames.TargetFrameworks)); Logger.WriteDebug($"Using target framework {targetFramework}."); } LockFileTarget lockFileTarget = lockFile.GetTarget(NuGetUtils.ParseFrameworkName(targetFramework), string.Empty); NuGetPackageResolver nuGetPackageResolver = NuGetPackageResolver.CreateResolver(lockFile, Path.GetDirectoryName(projectFilePath)); // Add nuget references foreach (LockFileTargetLibrary library in lockFileTarget.Libraries) { if (library.Type != LibraryType.Package) { continue; } string packageDirectory = nuGetPackageResolver.GetPackageDirectory(library.Name, library.Version); foreach (LockFileItem file in library.RuntimeAssemblies.Where(file => !NuGetUtils.IsPlaceholderFile(file.Path))) { string filePath = Path.GetFullPath(Path.Combine(packageDirectory, file.Path)); Logger.WriteDebug($"Adding \"{filePath}\"."); runtimeLibraries.Add(new RuntimeLibrary { Name = library.Name, DirectoryName = Path.GetDirectoryName(filePath), FileName = Path.GetFileName(filePath) }); } } return(runtimeLibraries); }
private bool PrunePackages(PublishRoot root) { var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath); // Special cases (for backwards compat) var specialFolders = new List<string> { "native", "InteropAssemblies", "redist", "runtimes" }; if (!root.NoSource) { // 'shared' folder is build time dependency, so we only copy it when deploying with source specialFolders.Add("shared"); } var lockFilePath = Path.GetFullPath(Path.Combine(ApplicationBasePath, LockFileFormat.LockFileName)); var format = new LockFileFormat(); root.LockFile = format.Read(lockFilePath); var keep = new HashSet<string>(); foreach (var target in root.LockFile.Targets) { foreach (var library in target.Libraries) { var packagesDir = resolver.GetInstallPath(library.Name, library.Version); var manifest = resolver.GetManifestFilePath(library.Name, library.Version); keep.Add(manifest); foreach (var path in library.RuntimeAssemblies) { keep.Add(CombinePath(packagesDir, path)); } foreach (var path in library.CompileTimeAssemblies) { keep.Add(CombinePath(packagesDir, path)); } foreach (var path in library.NativeLibraries) { keep.Add(CombinePath(packagesDir, path)); } foreach (var path in library.ResourceAssemblies) { keep.Add(CombinePath(packagesDir, path)); } foreach (var specialFolder in specialFolders) { var specialFolderPath = CombinePath(packagesDir, specialFolder); if (!Directory.Exists(specialFolderPath)) { continue; } keep.AddRange(Directory.EnumerateFiles(specialFolderPath, "*.*", SearchOption.AllDirectories)); } } } foreach (var package in root.Packages) { var packageDir = resolver.GetInstallPath(package.Library.Name, package.Library.Version); var packageFiles = Directory.EnumerateFiles(packageDir, "*.*", SearchOption.AllDirectories); foreach (var file in packageFiles) { if (!keep.Contains(file)) { File.Delete(file); } } root.Operations.DeleteEmptyFolders(packageDir); } return true; }
private void PurgeOrphanPackages() { _reports.Verbose.WriteLine("Removing orphaned packages..."); // Find the packages still used by the command scripts var applicationPackagesStillUsed = _commandsRepo.Commands .Select(cmd => _commandsRepo.FindCommandOwner(cmd)) .Distinct(); // Get all the installed packages var packagesRepo = new PackageRepository( _commandsRepo.PackagesRoot, caseSensitivePackagesName: false); // Key = package<id, version>, Value = bool (true if used, false otherwise) var usedPackages = packagesRepo .GetAllPackages() .SelectMany(pack => pack.Value) .ToDictionary( pack => pack, _ => false); var lockFileFormat = new LockFileFormat(); // Mark all the packages still in used by using the dependencies in the lock file foreach(var applicationPackage in applicationPackagesStillUsed) { var appLockFileFullPath = Path.Combine( _commandsRepo.PackagesRoot.Root, _commandsRepo.PathResolver.GetPackageDirectory(applicationPackage.Id, applicationPackage.Version), InstallBuilder.CommandsFolderName, LockFileFormat.LockFileName); if (!File.Exists(appLockFileFullPath)) { _reports.Verbose.WriteLine("Lock file {0} not found. This package will be removed if it is not used by another application", appLockFileFullPath); // The lock file is missing, probably the app is not installed correctly // unless someone else is using it, we'll remove it continue; } var lockFile = lockFileFormat.Read(appLockFileFullPath); foreach(var dependency in lockFile.PackageLibraries) { var dependencyPackage = new NuGet.PackageInfo( _commandsRepo.PackagesRoot, dependency.Name, dependency.Version, null, null); if (usedPackages.ContainsKey(dependencyPackage)) { // Mark the dependency as used usedPackages[dependencyPackage] = true; } } } // Now it's time to remove those unused packages var unusedPackages = usedPackages .Where(pack => !pack.Value) .Select(pack => pack.Key); foreach (var package in unusedPackages) { packagesRepo.RemovePackage(package); _reports.Verbose.WriteLine("Removed orphaned package: {0} {1}", package.Id, package.Version); } }
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request) { // Load the assets JSON file produced by restore. var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName); if (!File.Exists(assetsFilePath)) { throw new PackagingException(NuGetLogCode.NU5023, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileNotFound, assetsFilePath)); } var builder = new PackageBuilder(request.Deterministic) { Id = request.PackageId, Description = request.Description, Title = request.Title, Copyright = request.Copyright, ReleaseNotes = request.ReleaseNotes, RequireLicenseAcceptance = request.RequireLicenseAcceptance, PackageTypes = ParsePackageTypes(request) }; if (request.DevelopmentDependency) { builder.DevelopmentDependency = true; } if (request.PackageVersion != null) { NuGetVersion version; if (!NuGetVersion.TryParse(request.PackageVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5024, string.Format( CultureInfo.CurrentCulture, Strings.InvalidPackageVersion, request.PackageVersion)); } builder.Version = version; } else { builder.Version = new NuGetVersion("1.0.0"); } if (request.Authors != null) { builder.Authors.AddRange(request.Authors); } if (request.Tags != null) { builder.Tags.AddRange(request.Tags); } Uri tempUri; if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri)) { builder.LicenseUrl = tempUri; } if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri)) { builder.ProjectUrl = tempUri; } if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri)) { builder.IconUrl = tempUri; } if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType)) { builder.Repository = new RepositoryMetadata( request.RepositoryType, request.RepositoryUrl, request.RepositoryBranch, request.RepositoryCommit); } builder.LicenseMetadata = BuildLicenseMetadata(request); builder.Icon = request.PackageIcon; if (request.MinClientVersion != null) { Version version; if (!Version.TryParse(request.MinClientVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5022, string.Format( CultureInfo.CurrentCulture, Strings.InvalidMinClientVersion, request.MinClientVersion)); } builder.MinClientVersion = version; } // The assets file is necessary for project and package references. Pack should not do any traversal, // so we leave that work up to restore (which produces the assets file). var lockFileFormat = new LockFileFormat(); var assetsFile = lockFileFormat.Read(assetsFilePath); if (assetsFile.PackageSpec == null) { throw new PackagingException(NuGetLogCode.NU5025, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileDoesNotHaveValidPackageSpec, assetsFilePath)); } var projectRefToVersionMap = new Dictionary <string, string>(PathUtility.GetStringComparerBasedOnOS()); if (request.ProjectReferencesWithVersions != null && request.ProjectReferencesWithVersions.Any()) { projectRefToVersionMap = request .ProjectReferencesWithVersions .ToDictionary(msbuildItem => msbuildItem.Identity, msbuildItem => msbuildItem.GetProperty("ProjectVersion"), PathUtility.GetStringComparerBasedOnOS()); } var nuGetFrameworkComparer = new NuGetFrameworkFullComparer(); var frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(nuGetFrameworkComparer); if (request.FrameworksWithSuppressedDependencies != null && request.FrameworksWithSuppressedDependencies.Any()) { frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(request.FrameworksWithSuppressedDependencies .Select(t => NuGetFramework.Parse(t.Identity)).ToList(), nuGetFrameworkComparer); } PopulateProjectAndPackageReferences(builder, assetsFile, projectRefToVersionMap, frameworksWithSuppressedDependencies); PopulateFrameworkAssemblyReferences(builder, request); PopulateFrameworkReferences(builder, assetsFile); return(builder); }
private SemanticVersion ResolvePackageVersion(string projectFile) { var projectFolder = Path.GetDirectoryName(projectFile); var projectLockFile = Path.Combine(projectFolder, LockFileFormat.LockFileName); if (!File.Exists(projectLockFile)) { _reports.WriteError("The project.lock.json file is missing. Restore the packages to generate it."); return null; } var lockFileReader = new LockFileFormat(); var lockFile = lockFileReader.Read(projectLockFile); var librariesForPackage = lockFile ?.Libraries .Where(lib => string.Equals(_packageId, lib.Name, StringComparison.OrdinalIgnoreCase)); // Projects can reference multiple versions of the same library if (librariesForPackage.Count() > 1) { _reports.WriteError($"The project references multiple versions of the '{_packageId}'."); return null; } var packageVersion = librariesForPackage.FirstOrDefault()?.Version; if (packageVersion == null) { _reports.WriteError($"The project is not referencing the '{_packageId}' package. Sources can be retrieved only for packages used by the project."); return null; } return packageVersion; }