public void Run(IBackgroundTaskInstance taskInstance) { _settingsUtility = new SettingsUtility(); _foregroundMessenger = new ForegroundMessenger(); _smtcWrapper = new SmtcWrapper(BackgroundMediaPlayer.Current.SystemMediaTransportControls); _playerWrapper = new PlayerWrapper(_smtcWrapper, _foregroundMessenger, _settingsUtility); _settingsUtility.Write(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Running); // Send information to foreground that background task has been started if app is active if (_playerWrapper.ForegroundAppState != AppState.Suspended) MessageHelper.SendMessageToForeground(new BackgroundAudioTaskStartedMessage()); // This must be retrieved prior to subscribing to events below which use it _deferral = taskInstance.GetDeferral(); // Mark the background task as started to unblock SMTC Play operation (see related WaitOne on this signal) TaskStarted.Set(); // Associate a cancellation and completed handlers with the background task. taskInstance.Task.Completed += TaskCompleted; // event may raise immediately before continung thread excecution so must be at the end taskInstance.Canceled += OnCanceled; }
/// <summary> /// This method looks for the requestedPackage and installes (unpacks) it. /// </summary> /// <param name="requestedPackage"></param> /// <param name="installedPackages"></param> /// <returns></returns> private static async Task InstallPackageActionAsync(NugetPackage requestedPackage, SourcePackageDependencyInfo packageToInstall, ISettings settings, SourceCacheContext cacheContext, List <NugetPackage> installedPackages) { var packetRoot = Path.GetFullPath(requestedPackage.RootPath); //var packagePathResolver = new PackagePathResolver(Path.Combine(packetRoot, packageToInstall.Id, packageToInstall.Version.ToFullString()), true); var packagePathResolver = new PackagePathResolver(packetRoot); var nuGetFramework = NuGetFramework.ParseFolder(requestedPackage.TargetFramework); var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, _logger), _logger); //Check if the package was previousely installed in this session var knownPackage = installedPackages.Where((x) => x.Id == packageToInstall.Id).FirstOrDefault(); var packageToInstallVersionRange = VersionRange.Parse(packageToInstall.Version.OriginalVersion); if (knownPackage == null || !packageToInstallVersionRange.Satisfies(knownPackage.VersionRange.MinVersion)) { PackageReaderBase packageReader; //Check if the package is already installed in the file system var installedPath = packagePathResolver.GetInstalledPath(packageToInstall); if (installedPath == null) { var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None); var download = downloadResource.GetDownloadResourceResultAsync( packageToInstall, new PackageDownloadContext(cacheContext), SettingsUtility.GetGlobalPackagesFolder(settings), _logger, CancellationToken.None); download.Wait(); var downloadResult = download.Result; await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None); packageReader = downloadResult.PackageReader; } else { packageReader = new PackageFolderReader(installedPath); } NugetPackage newlyInstalled = null; if (requestedPackage.Id != packageToInstall.Id) //Was not the first requested id, must be a dependency. { var nearest = GetNearestFramework(packageReader, nuGetFramework); if (nearest == null) { throw new Exceptions.TargetFrameworkNotFoundException($"The current package {packageToInstall.Id} V{packageToInstall.Version} was installed as dependecy of {requestedPackage}. The parent package framework {nuGetFramework} is unknown/incompatible with the dependency's available frameworks."); } else { var version = packageToInstall.Version; try { //If available, get the NuSpec version version = packageReader.NuspecReader.GetVersion(); } catch (NuGet.Packaging.Core.PackagingException) { } newlyInstalled = new NugetPackage(packageToInstall.Id, version.OriginalVersion, nearest.Item2.GetShortFolderName(), packageToInstall.Source.PackageSource.Source, null, nearest.Item1, requestedPackage.RootPath, requestedPackage.DependenciesForceMinVersion); } } else { NugetPackageType packageType = requestedPackage.PackageType; if (packageType != NugetPackageType.Other) { if (!CheckFrameworkMatch(packageReader, nuGetFramework, ref packageType)) { throw new Exceptions.TargetFrameworkNotFoundException($"The current package {packageToInstall.Id} V{packageToInstall.Version} requested framework {nuGetFramework} is unknown/incompatible with the available frameworks."); } } if (requestedPackage.Source.AbsoluteUri != packageToInstall.Source.PackageSource.Source) { //Possible Dependency Confusion attack throw new Exceptions.DependencyConfusionException($"The requested package has been found in {packageToInstall.Source.PackageSource.Source} instead of the required URI {requestedPackage.Source.AbsoluteUri}. Update the pakcage source if this is intended"); } newlyInstalled = new NugetPackage(requestedPackage.Id, requestedPackage.VersionRange.OriginalString, requestedPackage.TargetFramework, requestedPackage.Source.AbsoluteUri, null, packageType, requestedPackage.RootPath, requestedPackage.DependenciesForceMinVersion); } newlyInstalled.AddDependencies(packageToInstall.Dependencies); newlyInstalled.LoadLibraries(); installedPackages.Add(newlyInstalled); } }
public async Task GetPackageSpecsAsync_ReadSettingsWithRelativePaths(string restorePackagesPath, string sources, string fallbackFolders) { // Arrange using (var testDirectory = TestDirectory.Create()) { var projectAdapter = CreateProjectAdapter(testDirectory); Mock.Get(projectAdapter) .SetupGet(x => x.RestorePackagesPath) .Returns(restorePackagesPath); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreSources) .Returns(sources); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreFallbackFolders) .Returns(fallbackFolders); var projectServices = new TestProjectSystemServices(); var testProject = new LegacyPackageReferenceProject( projectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); var settings = NullSettings.Instance; var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings); await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); // Act var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext); // Assert Assert.NotNull(packageSpecs); var actualRestoreSpec = packageSpecs.Single(); SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec); // Assert packagespath Assert.Equal(restorePackagesPath != null ? Path.Combine(testDirectory, restorePackagesPath) : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath); // assert sources var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source); var expectedSources = sources != null?MSBuildStringUtility.Split(sources).Select(e => Path.Combine(testDirectory, e)) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); // assert fallbackfolders var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders; var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders).Select(e => Path.Combine(testDirectory, e)) : SettingsUtility.GetFallbackPackageFolders(settings); Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t))); // Verify Mock.Get(projectAdapter) .Verify(x => x.RestorePackagesPath, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreSources, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreFallbackFolders, Times.Once); } }
/// <summary> /// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json). /// </summary> /// <param name="projectPath">The full path to the project.</param> /// <param name="id">The ID of the package.</param> /// <param name="version">The version of the package.</param> /// <param name="settings">The NuGet settings to use.</param> /// <param name="logger">An <see cref="ILogger"/> to use for logging.</param> /// <returns></returns> public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit( string projectPath, string outputPath, string id, VersionRange version, ISettings settings, string[] additionalFeeds, ILogger logger) { var sources = SettingsUtility.GetEnabledSources(settings) .Concat(additionalFeeds.Select(f => new PackageSource(f))) .ToList(); using (SourceCacheContext sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { // The package spec details what packages to restore PackageSpec packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation { FrameworkName = i, }).ToList()) { Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange(id, version, LibraryDependencyTarget.Package), SuppressParent = LibraryIncludeFlags.All, AutoReferenced = true, IncludeType = LibraryIncludeFlags.None, Type = LibraryDependencyType.Build } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.GetTempPath(), OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(), ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(), PackagesPath = outputPath, Sources = sources, FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, FilePath = projectPath, Name = Path.GetFileNameWithoutExtension(projectPath), }; DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(packageSpec); dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); RestoreArgs restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = sourceCacheContext, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = logger, }; // Create requests from the arguments IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the package without generating extra files return(RestoreRunner.RunWithoutCommit(requests, restoreArgs)); } }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, IReadOnlyList <PackageSpec> packageSpecs, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject) || packageSpecs.Any(project => IsProjectBuildIntegrated(project)))) { return; } if (IsConsentGranted(_settings)) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { await _logger.DoAsync((l, _) => { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); l.WriteLine(VerbosityLevel.Quiet, message); }); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } // Cache p2ps discovered from DTE var cacheContext = new DependencyGraphCacheContext(_logger); var pathContext = NuGetPathContext.Create(_settings); // add deferred projects package spec in cacheContext packageSpecCache cacheContext.DeferredPackageSpecs.AddRange(packageSpecs); var isRestoreRequired = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync( _solutionManager, forceRestore, pathContext, cacheContext, _dependencyGraphProjectCacheHash); // No-op all project closures are up to date and all packages exist on disk. if (isRestoreRequired) { // Save the project between operations. _dependencyGraphProjectCacheHash = cacheContext.SolutionSpecHash; // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, cacheContext, providerCache, cacheModifier, sources, _settings, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false); if (isRestoreFailed) { _status = NuGetOperationStatus.Failed; } }, token); } } }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, RestoreOperationSource restoreSource, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject))) { return; } if (_packageRestoreConsent.IsGranted) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { await _logger.DoAsync((l, _) => { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); l.WriteLine(VerbosityLevel.Quiet, message); }); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } // Cache p2ps discovered from DTE var cacheContext = new DependencyGraphCacheContext(_logger, _settings); var pathContext = NuGetPathContext.Create(_settings); // Get full dg spec var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(_solutionManager, cacheContext); // Avoid restoring solutions with zero potential PackageReference projects. if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec)) { // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var isRestoreOriginalAction = true; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, dgSpec, cacheContext, providerCache, cacheModifier, sources, _nuGetProjectContext.OperationId, forceRestore, isRestoreOriginalAction, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false); _noOpProjectsCount = restoreSummaries.Where(summary => summary.NoOpRestore == true).Count(); if (isRestoreFailed) { _status = NuGetOperationStatus.Failed; } else if (_noOpProjectsCount < restoreSummaries.Count) { _status = NuGetOperationStatus.Succeeded; } }, token); } } else if (restoreSource == RestoreOperationSource.Explicit) { // Log an error when restore is disabled and user explicitly restore. await _logger.DoAsync((l, _) => { l.ShowError(Resources.PackageRefNotRestoredBecauseOfNoConsent); }); } }
static async Task Main(string[] args) { var packageId = "cake.nuget"; var packageVersion = NuGetVersion.Parse("0.30.0"); var nuGetFramework = NuGetFramework.ParseFolder("net46"); var settings = Settings.LoadDefaultSettings(root: null); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3()); using (var cacheContext = new SourceCacheContext()) { var repositories = sourceRepositoryProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); await GetPackageDependencies( new PackageIdentity(packageId, packageVersion), nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), NullLogger.Instance); var resolver = new PackageResolver(); var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))); var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages")); var packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(NullSettings.Instance, NullLogger.Instance), NullLogger.Instance //new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()), //SignedPackageVerifierSettings.GetDefault() ); var frameworkReducer = new FrameworkReducer(); foreach (var packageToInstall in packagesToInstall) { PackageReaderBase packageReader; var installedPath = packagePathResolver.GetInstalledPath(packageToInstall); if (installedPath == null) { var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageToInstall, new PackageDownloadContext(cacheContext), SettingsUtility.GetGlobalPackagesFolder(settings), NullLogger.Instance, CancellationToken.None); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None); packageReader = downloadResult.PackageReader; } else { packageReader = new PackageFolderReader(installedPath); } var libItems = packageReader.GetLibItems(); var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework)); Console.WriteLine(string.Join("\n", libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items))); var frameworkItems = packageReader.GetFrameworkItems(); nearest = frameworkReducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework)); Console.WriteLine(string.Join("\n", frameworkItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items))); } return; } async Task GetPackageDependencies(PackageIdentity package, NuGetFramework framework, SourceCacheContext cacheContext, ILogger logger, IEnumerable <SourceRepository> repositories, ISet <SourcePackageDependencyInfo> availablePackages) { if (availablePackages.Contains(package)) { return; } foreach (var sourceRepository in repositories) { var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>(); var dependencyInfo = await dependencyInfoResource.ResolvePackage( package, framework, cacheContext, logger, CancellationToken.None); if (dependencyInfo == null) { continue; } availablePackages.Add(dependencyInfo); foreach (var dependency in dependencyInfo.Dependencies) { await GetPackageDependencies( new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion), framework, cacheContext, logger, repositories, availablePackages); } } } }
/// <summary> /// Fetch, if not already downloaded, and install the package represented by /// (<paramref name="packageId"/>, <paramref name="version"/>). /// </summary> /// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks> /// <param name="packageId">Name of package to install.</param> /// <param name="version">Version of package to install.</param> public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress) { using (GetLocalRepositoryLock()) { currentProgressReport = progress; try { var identity = new PackageIdentity(packageId, version.ToNuGetVersion()); var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, true, true, VersionConstraints.None); var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray(); var projectContext = new EmptyNuGetProjectContext() { ActionType = NuGetActionType.Install, PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger), }; ActivityCorrelationId.StartNew(); { var installPath = SettingsUtility.GetGlobalPackagesFolder(settings); // Old version expects to be installed in GamePackages if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null) { installPath = oldRootDirectory; } var projectPath = Path.Combine("StrideLauncher.json"); var spec = new PackageSpec() { Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency FilePath = projectPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package), } }, TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net472"), } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.Combine(Path.GetTempPath(), $"StrideLauncher-{packageId}-{version.ToString()}"), OriginalTargetFrameworks = new[] { "net472" }, ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = installPath, Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, }; using (var context = new SourceCacheContext { MaxAge = DateTimeOffset.UtcNow }) { context.IgnoreFailedSources = true; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = NativeLogger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; foreach (var request in requests) { // Limit concurrency to avoid timeout request.Request.MaxDegreeOfConcurrency = 4; var command = new RestoreCommand(request.Request); // Act var result = await command.ExecuteAsync(); if (!result.Success) { throw new InvalidOperationException($"Could not restore package {packageId}"); } foreach (var install in result.RestoreGraphs.Last().Install) { var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version); if (package != null) { var packagePath = Path.Combine(installPath, package.Path); OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath)); } } } } if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0)) { UpdateTargetsHelper(); } } // Load the recently installed package var installedPackages = GetPackagesInstalled(new[] { packageId }); return(installedPackages.FirstOrDefault(p => p.Version == version)); } finally { currentProgressReport = null; } } }
/// <summary> /// Fetch, if not already downloaded, and install the package represented by /// (<paramref name="packageId"/>, <paramref name="version"/>). /// </summary> /// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks> /// <param name="packageId">Name of package to install.</param> /// <param name="version">Version of package to install.</param> public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress) { using (GetLocalRepositoryLock()) { currentProgressReport = progress; try { var identity = new PackageIdentity(packageId, version.ToNuGetVersion()); var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, true, true, VersionConstraints.None); var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray(); var projectContext = new EmptyNuGetProjectContext() { ActionType = NuGetActionType.Install, PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger), }; ActivityCorrelationId.StartNew(); { var installPath = SettingsUtility.GetGlobalPackagesFolder(settings); // Old version expects to be installed in GamePackages if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null) { installPath = oldRootDirectory; } var specPath = Path.Combine("TestProject", "project.json"); var spec = new PackageSpec() { Name = "TestProject", // make sure this package never collides with a dependency FilePath = specPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package), } }, TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net472"), } }, }; using (var context = new SourceCacheContext()) { context.IgnoreFailedSources = true; var provider = RestoreCommandProviders.Create(installPath, new List <string>(), sourceRepositoryProvider.GetRepositories(), context, new LocalPackageFileCache(), NativeLogger); var request = new RestoreRequest(spec, provider, context, null, NativeLogger) { //RequestedRuntimes = { "win7-d3d11" }, ProjectStyle = ProjectStyle.DotnetCliTool, }; var command = new RestoreCommand(request); // Act var result = await command.ExecuteAsync(); if (!result.Success) { throw new InvalidOperationException($"Could not restore package {packageId}"); } foreach (var install in result.RestoreGraphs.Last().Install) { var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version); if (package != null) { var packagePath = Path.Combine(installPath, package.Path); OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath)); } } } if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0)) { UpdateTargetsHelper(); } } // Load the recently installed package var installedPackages = GetPackagesInstalled(new[] { packageId }); return(installedPackages.FirstOrDefault(p => p.Version == version)); } finally { currentProgressReport = null; } } }
public override async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context) { PackageSpec packageSpec = null; if (context == null || !context.PackageSpecCache.TryGetValue(MSBuildProjectPath, out packageSpec)) { packageSpec = JsonPackageSpecReader.GetPackageSpec(ProjectName, JsonConfigPath); if (packageSpec == null) { throw new InvalidOperationException( string.Format(Strings.ProjectNotLoaded_RestoreFailed, ProjectName)); } var metadata = new ProjectRestoreMetadata(); packageSpec.RestoreMetadata = metadata; metadata.ProjectStyle = ProjectStyle.ProjectJson; metadata.OutputPath = await GetMSBuildProjectExtensionsPathAsync(); metadata.ProjectPath = MSBuildProjectPath; metadata.ProjectJsonPath = packageSpec.FilePath; metadata.ProjectName = packageSpec.Name; metadata.ProjectUniqueName = MSBuildProjectPath; metadata.CacheFilePath = await GetCacheFilePathAsync(); // Reload the target framework from csproj and update the target framework in packageSpec for restore await UpdateInternalTargetFrameworkAsync(); if (TryGetInternalFramework(out var targetFramework)) { var nuGetFramework = targetFramework as NuGetFramework; if (IsUAPFramework(nuGetFramework)) { // Ensure the project json has only one target framework if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1) { var tfi = packageSpec.TargetFrameworks.First(); if (tfi.Imports.Count > 0) { if (tfi.AssetTargetFallback) { nuGetFramework = new AssetTargetFallbackFramework(nuGetFramework, tfi.Imports.AsList()); } else { nuGetFramework = new FallbackFramework(nuGetFramework, tfi.Imports.AsList()); } } tfi.FrameworkName = nuGetFramework; } } } var references = (await ProjectServices .ReferencesReader .GetProjectReferencesAsync(context.Logger, CancellationToken.None)) .ToList(); if (references != null && references.Count > 0) { // Add msbuild reference groups for each TFM in the project foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName)) { metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework)); } foreach (var reference in references) { // This reference applies to all frameworks // Include/exclude flags may be applied later when merged with project.json // Add the reference for all TFM groups, there are no conditional project // references in UWP. There should also be just one TFM. foreach (var frameworkInfo in metadata.TargetFrameworks) { frameworkInfo.ProjectReferences.Add(reference); } } } // Write restore settings to the package spec. // For project.json these properties may not come from the project file. var settings = context?.Settings ?? NullSettings.Instance; packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings); packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList(); packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList(); packageSpec.RestoreMetadata.ConfigFilePaths = settings.GetConfigFilePaths(); context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec); } return(new[] { packageSpec }); }
public static async Task LoadPackage(string packageId, string packageVersion, HashSet <string> buildReferences, HashSet <string> runtimeReferences) { Console.WriteLine($"Loading package '{packageId} ({packageVersion})'..."); var version = NuGetVersion.Parse(packageVersion); var nuGetFramework = NuGetFramework.ParseFrameworkName(AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName, DefaultFrameworkNameProvider.Instance); var settings = Settings.LoadDefaultSettings(null); var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); var packagesPath = SettingsUtility.GetGlobalPackagesFolder(settings); var runtimeFramework = NuGetFramework.ParseFolder(BuildInfo.RuntimeIdentifier); using (var cacheContext = new SourceCacheContext()) { var repositories = sourceRepositoryProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); await GetPackageDependencies( new PackageIdentity(packageId, version), nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), NullLogger.Instance); var resolver = new PackageResolver(); var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))); var packagePathResolver = new PackagePathResolver(packagesPath, true); var packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance), NullLogger.Instance); var frameworkReducer = new FrameworkReducer(); foreach (var packageToInstall in packagesToInstall) { var installedPath = packagePathResolver.GetInstalledPath(packageToInstall); if (installedPath == null) { Console.WriteLine($"Installing package '{packageToInstall.Id} ({packageToInstall.Version})'..."); var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageToInstall, new PackageDownloadContext(cacheContext), packagesPath, NullLogger.Instance, CancellationToken.None); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None); } installedPath = packagePathResolver.GetInstalledPath(packageToInstall); var packageReader = new PackageFolderReader(installedPath); if (buildReferences != null) { var items = await packageReader.GetReferenceItemsAsync(CancellationToken.None); var paths = GetAssemblyPaths(items, frameworkReducer, nuGetFramework, installedPath); buildReferences.AddRange(paths); } if (runtimeReferences != null) { var items = await packageReader.GetItemsAsync("runtimes", CancellationToken.None); var nearest = items.Select(x => x.TargetFramework) .Where(x => x.Framework == runtimeFramework.Framework && (!x.HasProfile || x.Profile == runtimeFramework.Profile)) .OrderBy(x => x.HasProfile ? 1 : -1) .FirstOrDefault(); var runtimeDir = items.FirstOrDefault(x => x.TargetFramework.Equals(nearest))?.Items.FirstOrDefault()?.Split('/').ElementAtOrDefault(1); if (runtimeDir != null) { installedPath = Path.Combine(installedPath, "runtimes", runtimeDir); packageReader = new PackageFolderReader(installedPath); } items = await packageReader.GetLibItemsAsync(CancellationToken.None); var paths = GetAssemblyPaths(items, frameworkReducer, nuGetFramework, installedPath); runtimeReferences.AddRange(paths); } } } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var providersCache = new RestoreCommandProvidersCache(); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } } }
public bool ClearHttpCache() { return(ClearNuGetFolder(SettingsUtility.GetHttpCacheFolder(), "Http-cache")); }
public override bool Execute() { var log = new MSBuildLogger(Log); // Log Inputs BuildTasksUtility.LogInputParam(log, nameof(ProjectUniqueName), ProjectUniqueName); BuildTasksUtility.LogInputParam(log, nameof(RestoreSources), RestoreSources); BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPath), RestorePackagesPath); BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFolders), RestoreFallbackFolders); BuildTasksUtility.LogInputParam(log, nameof(RestoreConfigFile), RestoreConfigFile); BuildTasksUtility.LogInputParam(log, nameof(RestoreSolutionDirectory), RestoreSolutionDirectory); BuildTasksUtility.LogInputParam(log, nameof(RestoreRootConfigDirectory), RestoreRootConfigDirectory); BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPathOverride), RestorePackagesPathOverride); BuildTasksUtility.LogInputParam(log, nameof(RestoreSourcesOverride), RestoreSourcesOverride); BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFoldersOverride), RestoreFallbackFoldersOverride); BuildTasksUtility.LogInputParam(log, nameof(MSBuildStartupDirectory), MSBuildStartupDirectory); try { // Validate inputs if (RestoreSourcesOverride == null && MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log)) { // Fail due to invalid source combination return(false); } if (RestoreFallbackFoldersOverride == null && MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log)) { // Fail due to invalid fallback combination return(false); } // Settings // Find the absolute path of nuget.config, this should only be set on the command line. Setting the path in project files // is something that could happen, but it is not supported. var absoluteConfigFilePath = GetGlobalAbsolutePath(RestoreConfigFile); var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, string.IsNullOrEmpty(RestoreRootConfigDirectory) ? Path.GetDirectoryName(ProjectUniqueName) : RestoreRootConfigDirectory, absoluteConfigFilePath, _machineWideSettings); OutputConfigFilePaths = settings.GetConfigFilePaths().ToArray(); // PackagesPath OutputPackagesPath = RestoreSettingsUtils.GetValue( () => GetGlobalAbsolutePath(RestorePackagesPathOverride), () => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath), () => SettingsUtility.GetGlobalPackagesFolder(settings)); // Sources var currentSources = RestoreSettingsUtils.GetValue( () => RestoreSourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => GetGlobalAbsolutePath(e)).ToArray(), () => MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources) ? Array.Empty <string>() : null, () => RestoreSources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(), () => (new PackageSourceProvider(settings)).LoadPackageSources().Where(e => e.IsEnabled).Select(e => e.Source).ToArray()); // Append additional sources // Escape strings to avoid xplat path issues with msbuild. var additionalProjectSources = MSBuildRestoreUtility.AggregateSources( values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectSources"), excludeValues: Enumerable.Empty <string>()) .Select(MSBuildRestoreUtility.FixSourcePath) .ToArray(); OutputSources = AppendItems(currentSources, additionalProjectSources); // Fallback folders var currentFallbackFolders = RestoreSettingsUtils.GetValue( () => RestoreFallbackFoldersOverride?.Select(e => GetGlobalAbsolutePath(e)).ToArray(), () => MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders) ? Array.Empty <string>() : null, () => RestoreFallbackFolders?.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(), () => SettingsUtility.GetFallbackPackageFolders(settings).ToArray()); // Append additional fallback folders after removing excluded folders var additionalProjectFallbackFolders = MSBuildRestoreUtility.AggregateSources( values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFolders"), excludeValues: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFoldersExcludes")) .ToArray(); OutputFallbackFolders = AppendItems(currentFallbackFolders, additionalProjectFallbackFolders); } catch (Exception ex) { // Log exceptions with error codes if they exist. ExceptionUtilities.LogException(ex, log); return(false); } // Log Outputs BuildTasksUtility.LogOutputParam(log, nameof(OutputPackagesPath), OutputPackagesPath); BuildTasksUtility.LogOutputParam(log, nameof(OutputSources), OutputSources); BuildTasksUtility.LogOutputParam(log, nameof(OutputFallbackFolders), OutputFallbackFolders); BuildTasksUtility.LogOutputParam(log, nameof(OutputConfigFilePaths), OutputConfigFilePaths); return(true); }
/// <summary> /// Converts a NuGet package to a Unity package. /// </summary> private async Task ConvertNuGetPackageToUnity(PackageIdentity identity, NpmPackageInfo npmPackageInfo, NpmPackageVersion npmPackageVersion, IPackageSearchMetadata packageMeta, NuGetFramework targetFramework) { var unityPackageFileName = GetUnityPackageFileName(identity); var unityPackageFilePath = Path.Combine(RootUnityPackageFolder, unityPackageFileName); Logger.LogInformation($"Converting NuGet package {identity} to Unity `{unityPackageFileName}`"); var downloadResource = await _sourceRepository.GetResourceAsync <DownloadResource>(CancellationToken.None); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( identity, new PackageDownloadContext(_sourceCacheContext), SettingsUtility.GetGlobalPackagesFolder(_settings), Logger, CancellationToken.None); var packageReader = downloadResult.PackageReader; // Update Repository metadata if necessary var repoMeta = packageReader.NuspecReader.GetRepositoryMetadata(); if (repoMeta != null && repoMeta.Url != null && repoMeta.Commit != null && repoMeta.Type != null) { npmPackageVersion.Repository = new NpmSourceRepository() { Revision = repoMeta.Commit, Type = repoMeta.Type, Url = repoMeta.Url, }; } else { npmPackageVersion.Repository = null; } try { var memStream = new MemoryStream(); using (var outStream = File.Create(unityPackageFilePath)) using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = new TarOutputStream(gzoStream)) { foreach (var item in await packageReader.GetLibItemsAsync(CancellationToken.None)) { if (item.TargetFramework != targetFramework) { continue; } foreach (var file in item.Items) { var fileInUnityPackage = Path.GetFileName(file); var meta = UnityMeta.GetMetaForExtension(GetStableGuid(identity, fileInUnityPackage), Path.GetExtension(fileInUnityPackage)); if (meta == null) { continue; } memStream.Position = 0; memStream.SetLength(0); var stream = packageReader.GetStream(file); stream.CopyTo(memStream); var buffer = memStream.ToArray(); // write content WriteBufferToTar(tarArchive, fileInUnityPackage, buffer); // write meta file WriteTextFileToTar(tarArchive, fileInUnityPackage + ".meta", meta); } } // Write the package,json var unityPackage = CreateUnityPackage(npmPackageInfo, npmPackageVersion); var unityPackageAsJson = unityPackage.ToJson(); const string packageJsonFileName = "package.json"; WriteTextFileToTar(tarArchive, packageJsonFileName, unityPackageAsJson); WriteTextFileToTar(tarArchive, $"{packageJsonFileName}.meta", UnityMeta.GetMetaForExtension(GetStableGuid(identity, packageJsonFileName), ".json")); // Write the license to the package if any string license = null; string licenseUrlText = null; var licenseUrl = packageMeta.LicenseMetadata?.LicenseUrl.ToString() ?? packageMeta.LicenseUrl?.ToString(); if (!string.IsNullOrEmpty(licenseUrl)) { try { // Try to fetch the license from an URL using (var httpClient = new HttpClient()) { licenseUrlText = await httpClient.GetStringAsync(licenseUrl); } // If the license text is HTML, try to remove all text if (licenseUrlText != null) { licenseUrlText = licenseUrlText.Trim(); if (licenseUrlText.StartsWith("<")) { try { licenseUrlText = NUglify.Uglify.HtmlToText(licenseUrlText, HtmlToTextOptions.KeepStructure).Code ?? licenseUrlText; } catch { // ignored } } } } catch { // ignored } } if (!string.IsNullOrEmpty(packageMeta.LicenseMetadata?.License)) { license = packageMeta.LicenseMetadata.License; } // If the license fetched from the URL is bigger, use that one to put into the file if (licenseUrlText != null && (license == null || licenseUrlText.Length > license.Length)) { license = licenseUrlText; } if (!string.IsNullOrEmpty(license)) { const string licenseMdFile = "License.md"; WriteTextFileToTar(tarArchive, licenseMdFile, license); WriteTextFileToTar(tarArchive, $"{licenseMdFile}.meta", UnityMeta.GetMetaForExtension(GetStableGuid(identity, licenseMdFile), ".md")); } } using (var stream = File.OpenRead(unityPackageFilePath)) { var sha1 = Sha1sum(stream); WriteUnityPackageSha1(identity, sha1); npmPackageVersion.Distribution.Shasum = sha1; } } catch (Exception ex) { try { File.Delete(unityPackageFilePath); } catch { // ignored } LogError($"Error while processing package `{identity}`. Reason: {ex}"); } }
public static async Task Execute( Input input, Func <String> projectFileGetter, CancellationToken token ) { var packageFilePath = input.PackageFilePath; if (!packageFilePath.IsNullOrEmpty()) { var sourceNames = input.SourceNames; if (!sourceNames.IsNullOrEmpty()) { var settings = NuGetUtility.GetNuGetSettingsWithDefaultRootDirectory( Path.GetDirectoryName(projectFileGetter()), input.NuGetConfigurationFilePath); var psp = new PackageSourceProvider(settings); var packagePath = Path.GetFullPath(packageFilePath); var identity = new AsyncLazy <PackageIdentity>(async() => { using (var reader = new PackageArchiveReader(packagePath)) { return(await reader.GetIdentityAsync(token)); } }); var allRepositories = new Lazy <NuGetv3LocalRepository[]>(() => SettingsUtility.GetGlobalPackagesFolder(settings) .Singleton() .Concat(SettingsUtility.GetFallbackPackageFolders(settings)) .Select(repoPath => new NuGetv3LocalRepository(repoPath)) .ToArray() ); await Task.WhenAll(sourceNames.Select( sourceItem => PerformPushToSingleSourceAsync( settings, packagePath, psp, identity, allRepositories, new TextWriterLogger() { VerbosityLevel = input.LogLevel }, sourceItem, input.RetryTimeoutForDirectoryDeletionFail, token )) .ToArray() ); } else { await Console.Error.WriteLineAsync($"No sources specified for push command, please specify at least one source via \"{nameof( input.SourceNames )}\" property."); } } else { await Console.Error.WriteLineAsync($"No package file path specified for push command, please specify it via \"{nameof( input.PackageFilePath )}\" property."); } }
public static async Task <(RestoreRequest, RestoreResult)> Restore(ILogger logger, string packageName, VersionRange versionRange) { var settings = NuGet.Configuration.Settings.LoadDefaultSettings(null); var packageSourceProvider = new PackageSourceProvider(settings); // not sure what these do, but it was in the NuGet command line. var resourceProviders = new List <Lazy <INuGetResourceProvider> >(); resourceProviders.AddRange(Repository.Provider.GetCoreV3()); // Setup source provider as a V3 only. var sourceRepositoryProvider = new SourceRepositoryProvider(settings, resourceProviders); var installPath = SettingsUtility.GetGlobalPackagesFolder(settings); var assemblies = new List <string>(); var projectPath = Path.Combine("XenkoNugetResolver.json"); var spec = new PackageSpec() { Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency FilePath = projectPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageName, versionRange, LibraryDependencyTarget.Package), } }, TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net472"), } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.Combine(Path.GetTempPath(), $"XenkoNugetResolver-{packageName}-{versionRange.MinVersion.ToString()}"), OriginalTargetFrameworks = new[] { "net472" }, ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, }; using (var context = new SourceCacheContext()) { context.IgnoreFailedSources = true; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the packages for (int tryCount = 0; tryCount < 2; ++tryCount) { try { var results = await RestoreRunner.RunWithoutCommit(requests, restoreArgs); // Commit results so that noop cache works next time foreach (var result in results) { await result.Result.CommitAsync(logger, CancellationToken.None); } var mainResult = results.First(); return(mainResult.SummaryRequest.Request, mainResult.Result); } catch (Exception e) when(e is UnauthorizedAccessException || e is IOException) { // If we have an unauthorized access exception, it means assemblies are locked by running Xenko process // During first try, kill some known harmless processes, and try again if (tryCount == 1) { throw; } foreach (var process in new[] { "Xenko.ConnectionRouter" }.SelectMany(Process.GetProcessesByName)) { try { if (process.Id != Process.GetCurrentProcess().Id) { process.Kill(); process.WaitForExit(); } } catch (Exception) { } } } } throw new InvalidOperationException("Unreachable code"); } }
public override bool TryGetPackages(string packageConfigPath, PackageRestoreData packageRestoreData, out IEnumerable <PackageIdentityWithPath> packages) { packages = null; string projectJsonPath; if (ProjectJsonPathUtilities.IsProjectConfig(packageConfigPath)) { projectJsonPath = packageConfigPath; } else { if (!String.Equals("ProjectJson", packageRestoreData?.RestoreProjectStyle, StringComparison.OrdinalIgnoreCase) || String.IsNullOrWhiteSpace(packageRestoreData?.ProjectJsonPath)) { return(false); } projectJsonPath = packageRestoreData.ProjectJsonPath; } string lockFilePath = ProjectJsonPathUtilities.GetLockFilePath(projectJsonPath); if (!File.Exists(lockFilePath)) { throw new FileNotFoundException($"The lock file '{lockFilePath}' does not exist. Ensure that the restore succeeded and that the lock file was generated."); } LockFile lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance); string globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NuGetSettings); if (String.IsNullOrWhiteSpace(globalPackagesFolder)) { throw new NuGetConfigurationException(@"Unable to determine the NuGet repository path. This usually defaults to ""%UserProfile%\.nuget\packages"", ""%NUGET_PACKAGES%"", or the ""globalPackagesFolder"" in your NuGet.config."); } globalPackagesFolder = Path.GetFullPath(globalPackagesFolder); if (!Directory.Exists(globalPackagesFolder)) { throw new DirectoryNotFoundException($"The NuGet repository '{globalPackagesFolder}' does not exist. Ensure that NuGet is restore packages to the location specified in your NuGet.config."); } Log.LogMessage(MessageImportance.Low, $"Using repository path: '{globalPackagesFolder}'"); VersionFolderPathResolver versionFolderPathResolver = new VersionFolderPathResolver(globalPackagesFolder); packages = lockFile.Libraries.Select(i => { string installPath = versionFolderPathResolver.GetInstallPath(i.Name, i.Version); if (!String.IsNullOrWhiteSpace(installPath)) { installPath = Path.GetFullPath(installPath); } else { Log.LogWarning($"The package '{i.Name}' was not found in the repository."); } return(new PackageIdentityWithPath(i.Name, i.Version, installPath)); }).Where(i => !String.IsNullOrWhiteSpace(i.FullPath)); return(true); }
public static async Task InstallPackage(string packageId, string version, Dictionary <string, string> projectDependenciesDict, string installDefaultSource = "") { var packageSources = new ApplicationSettings().GetOrCreateApplicationSettings().ClientSettings.PackageSourceDT; var packageVersion = NuGetVersion.Parse(version); var nuGetFramework = NuGetFramework.ParseFolder("net48"); var settings = Settings.LoadDefaultSettings(root: null); var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); using (var cacheContext = new SourceCacheContext()) { var repositories = new List <SourceRepository>(); if (!string.IsNullOrEmpty(installDefaultSource)) { var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(installDefaultSource, "Default Packages Source", true)); repositories.Add(sourceRepo); } for (int i = 0; i < packageSources.Rows.Count; i++) { if (packageSources.Rows[i][0].ToString() == "True") { var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packageSources.Rows[i][2].ToString(), packageSources.Rows[i][1].ToString(), true)); repositories.Add(sourceRepo); } } var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); var dependencyTasks = repositories.Select(repository => GetPackageDependencies( new PackageIdentity(packageId, packageVersion), nuGetFramework, cacheContext, NullLogger.Instance, repository, repositories, availablePackages)).ToArray(); await Task.WhenAll(dependencyTasks); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), NullLogger.Instance); var resolver = new PackageResolver(); //TODO: Installation failure happens here if package isn't found. Failure is being caught but not reported because it's asynchronous var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))); var packagePathResolver = new PackagePathResolver(Folders.GetFolder(FolderType.LocalAppDataPackagesFolder)); var packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance), NullLogger.Instance); var frameworkReducer = new FrameworkReducer(); PackageReaderBase packageReader; PackageDownloadContext downloadContext = new PackageDownloadContext(cacheContext); for (int i = 0; i < packagesToInstall.ToList().Count; i++) { var installedPath = packagePathResolver.GetInstalledPath(packagesToInstall.ToList()[i]); if (installedPath == null) { var downloadResource = await packagesToInstall.ToList()[i].Source.GetResourceAsync <DownloadResource>(CancellationToken.None); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packagesToInstall.ToList()[i], downloadContext, SettingsUtility.GetGlobalPackagesFolder(settings), NullLogger.Instance, CancellationToken.None); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None); packageReader = downloadResult.PackageReader; } else { packageReader = new PackageFolderReader(installedPath); } if (packagesToInstall.ToList()[i].Id == packageId) { if (projectDependenciesDict.ContainsKey(packagesToInstall.ToList()[i].Id)) { projectDependenciesDict[packagesToInstall.ToList()[i].Id] = packagesToInstall.ToList()[i].Version.ToString(); } else { projectDependenciesDict.Add(packagesToInstall.ToList()[i].Id, packagesToInstall.ToList()[i].Version.ToString()); } } } } }
/// <summary> /// Creates new instance of <see cref="BoundRestoreCommandUser"/> with given parameters. /// </summary> /// <param name="nugetSettings">The settings to use.</param> /// <param name="thisFramework">The framework to bind to.</param> /// <param name="runtimeIdentifier">The runtime identifier. Will be used by <see cref="E_NuGetUtils.ExtractAssemblyPaths{TResult}(BoundRestoreCommandUser, LockFile, Func{String, IEnumerable{String}, TResult}, GetFileItemsDelegate, IEnumerable{String})"/> method.</param> /// <param name="runtimeGraph">Optional value indicating runtime graph information: either <see cref="global::NuGet.RuntimeModel.RuntimeGraph"/> directly, or <see cref="String"/> containing package ID of package holding <c>runtime.json</c> file, containing serialized runtime graph definition. If neither is specified, then <c>"Microsoft.NETCore.Platforms"</c> package ID used to locate <c>runtime.json</c> file, as per <see href="https://docs.microsoft.com/en-us/dotnet/core/rid-catalog">official documentation</see>.</param> /// <param name="nugetLogger">The logger to use in restore command.</param> /// <param name="sourceCacheContext">The optional <see cref="SourceCacheContext"/> to use.</param> /// <param name="nuspecCache">The optional <see cref="LocalPackageFileCache"/> to use.</param> /// <param name="clientPolicyContext">The optional <see cref="ClientPolicyContext"/> to use.</param> /// <param name="leaveSourceCacheOpen">Whether to leave the <paramref name="sourceCacheContext"/> open when disposing this <see cref="BoundRestoreCommandUser"/>.</param> /// <param name="lockFileCacheDir">The directory where to store serialized lock files returned by <see cref="RestoreIfNeeded"/>. If <c>null</c> or empty, then <paramref name="lockFileCacheEnvironmentVariableName"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param> /// <param name="lockFileCacheEnvironmentVariableName">The name of the environment variable containing the value for lock file cache directory. If <c>null</c> or empty, then environment variable reading will be skipped. If the environment variable itself is <c>null</c> or empty, then the user's home directory in conjunction with <paramref name="getDefaultLockFileCacheDir"/> will be used to deduce lock file cache directory. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param> /// <param name="getDefaultLockFileCacheDir">This callback will be used when <paramref name="lockFileCacheEnvironmentVariableName"/> is <c>null</c> or empty or when the named environment variable itself was <c>null</c> or empty. This callback will receive current user's home directory as parameter and should return the lock file cache directory. If <c>null</c>, then <see cref="GetDefaultLockFileDir"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param> /// <param name="disableLockFileCacheDir">This variable controls whether the results of <see cref="RestoreIfNeeded"/> will be stored to file system lock file cache directory. By default, the lock file caching is enabled. Set this parameter to <c>true</c> to completely disable caching lock files to file system.</param> /// <exception cref="ArgumentNullException">If <paramref name="nugetSettings"/> is <c>null</c>.</exception> public BoundRestoreCommandUser( ISettings nugetSettings, NuGetFramework thisFramework = null, String runtimeIdentifier = null, EitherOr <RuntimeGraph, String> runtimeGraph = default, ILogger nugetLogger = null, SourceCacheContext sourceCacheContext = null, LocalPackageFileCache nuspecCache = null, ClientPolicyContext clientPolicyContext = null, Boolean leaveSourceCacheOpen = false, String lockFileCacheDir = null, String lockFileCacheEnvironmentVariableName = DEFAULT_LOCK_FILE_CACHE_DIR_ENV_NAME, Func <String, String> getDefaultLockFileCacheDir = null, Boolean disableLockFileCacheDir = false ) { ArgumentValidator.ValidateNotNull(nameof(nugetSettings), nugetSettings); this.ThisFramework = thisFramework ?? NuGetUtility.TryAutoDetectThisProcessFramework(); if (nugetLogger == null) { nugetLogger = NullLogger.Instance; } var global = SettingsUtility.GetGlobalPackagesFolder(nugetSettings); var fallbacks = SettingsUtility.GetFallbackPackageFolders(nugetSettings); if (sourceCacheContext == null) { leaveSourceCacheOpen = false; } var ctx = sourceCacheContext ?? new SourceCacheContext(); var psp = new PackageSourceProvider(nugetSettings); var csp = new CachingSourceProvider(psp); this.RuntimeIdentifier = NuGetUtility.TryAutoDetectThisProcessRuntimeIdentifier(runtimeIdentifier); this._cacheContext = ctx; this._disposeSourceCacheContext = !leaveSourceCacheOpen; this.NuGetLogger = nugetLogger; this._restoreCommandProvider = RestoreCommandProviders.Create( global, fallbacks, new PackageSourceProvider(nugetSettings).LoadPackageSources().Where(s => s.IsEnabled).Select(s => csp.CreateRepository(s)), ctx, nuspecCache ?? new LocalPackageFileCache(), nugetLogger ); this._nugetRestoreRootDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); this._restoreTargetFW = new TargetFrameworkInformation() { FrameworkName = this.ThisFramework }; this.LocalRepositories = this._restoreCommandProvider.GlobalPackages.Singleton() .Concat(this._restoreCommandProvider.FallbackPackageFolders) .ToImmutableDictionary(r => r.RepositoryRoot, r => r); this.RuntimeGraph = new Lazy <RuntimeGraph>(() => { var rGraph = runtimeGraph.GetFirstOrDefault(); if (rGraph == null) { var packageName = runtimeGraph.GetSecondOrDefault(); if (String.IsNullOrEmpty(packageName)) { packageName = DEFAULT_RUNTIME_GRAPH_PACKAGE_ID; } var platformsPackagePath = this.LocalRepositories.Values .SelectMany(r => r.FindPackagesById(packageName)) .OrderByDescending(p => p.Version) .FirstOrDefault() ?.ExpandedPath; rGraph = String.IsNullOrEmpty(platformsPackagePath) ? null : JsonRuntimeFormat.ReadRuntimeGraph(Path.Combine(platformsPackagePath, global::NuGet.RuntimeModel.RuntimeGraph.RuntimeGraphFileName)); } return(rGraph); }, LazyThreadSafetyMode.ExecutionAndPublication); if (!disableLockFileCacheDir) { this.DiskCacheDirectory = lockFileCacheDir .OrIfNullOrEmpty(String.IsNullOrEmpty(lockFileCacheEnvironmentVariableName) ? null : Environment.GetEnvironmentVariable(lockFileCacheEnvironmentVariableName)) .OrIfNullOrEmpty((getDefaultLockFileCacheDir ?? GetDefaultLockFileDir)(Environment.GetEnvironmentVariable( #if NET46 Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32S || Environment.OSVersion.Platform == PlatformID.Win32Windows || Environment.OSVersion.Platform == PlatformID.WinCE #else System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows) #endif ? "USERPROFILE" : "HOME")) ) .OrIfNullOrEmpty(null); } this._allLockFiles = new ConcurrentDictionary <ImmutableSortedSet <String>, ImmutableDictionary <ImmutableArray <NuGetVersion>, String> >(); this._lockFileFormat = new LockFileFormat(); this._clientPolicyContext = clientPolicyContext ?? ClientPolicyContext.GetClientPolicy(nugetSettings, nugetLogger); }
/// <summary> /// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json). /// </summary> /// <param name="libraryIdentity">The <see cref="LibraryIdentity"/> of the package.</param> /// <param name="settings">The NuGet settings to use.</param> /// <param name="logger">An <see cref="ILogger"/> to use for logging.</param> /// <returns></returns> public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(LibraryIdentity libraryIdentity, ISettings settings, ILogger logger) { using (var sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { var projectPath = Path.Combine(Path.GetTempPath(), TempProjectName); // The package spec details what packages to restore var packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation { FrameworkName = i, }).ToList()) { Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange( libraryIdentity.Name, new VersionRange( minVersion: libraryIdentity.Version, includeMinVersion: true, maxVersion: libraryIdentity.Version, includeMaxVersion: true), LibraryDependencyTarget.Package), SuppressParent = LibraryIncludeFlags.All, AutoReferenced = true, IncludeType = LibraryIncludeFlags.None, Type = LibraryDependencyType.Build } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(TempProjectName), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = TempProjectName, OutputPath = Path.GetTempPath(), OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(), ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, FilePath = projectPath, Name = Path.GetFileNameWithoutExtension(TempProjectName), }; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(packageSpec); dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = sourceCacheContext, #pragma warning disable CS0618 // Type or member is obsolete CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false)), #pragma warning restore CS0618 // Type or member is obsolete Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the package without generating extra files return(RestoreRunner.RunWithoutCommit(requests, restoreArgs)); } }
private IList <string> GetConfigFilePaths(ISettings settings) { return(SettingsUtility.GetConfigFilePaths(settings).ToList()); }
public IReadOnlyList <string> GetEffectiveFallbackPackageFolders(ISettings settings) { return(SettingsUtility.GetFallbackPackageFolders(settings)); }
public DependencyGraph Analyze(string packageId, string version, string framework) { var package = new PackageIdentity(packageId, NuGetVersion.Parse(version)); var settings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3()); var nuGetFramework = NuGetFramework.ParseFolder(framework); var nugetLogger = _logger.AsNuGetLogger(); using (var cacheContext = new SourceCacheContext()) { var repositories = sourceRepositoryProvider.GetRepositories(); var resolvedPackages = new ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo>(PackageIdentityComparer.Default); ResolvePackage(package, nuGetFramework, cacheContext, nugetLogger, repositories, resolvedPackages).Wait(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(resolvedPackages.Values); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), nugetLogger); var resolver = new PackageResolver(); var prunedPackages = resolver.Resolve(resolverContext, CancellationToken.None) .Select(x => resolvedPackages[x]); var rootNode = new PackageReferenceNode(package.Id, package.Version.ToString()); var packageNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase); var builder = new DependencyGraph.Builder(rootNode); foreach (var target in prunedPackages) { var downloadResource = target.Source.GetResource <DownloadResource>(); var downloadResult = downloadResource.GetDownloadResourceResultAsync(new PackageIdentity(target.Id, target.Version), new PackageDownloadContext(cacheContext), SettingsUtility.GetGlobalPackagesFolder(settings), nugetLogger, CancellationToken.None).Result; var libItems = downloadResult.PackageReader.GetLibItems(); var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework)); var assemblyReferences = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items) .Where(x => Path.GetExtension(x).Equals(".dll", StringComparison.OrdinalIgnoreCase)) .Select(x => new AssemblyReferenceNode(Path.GetFileName(x))); var frameworkItems = downloadResult.PackageReader.GetFrameworkItems(); nearest = reducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework)); assemblyReferences = assemblyReferences.Concat(frameworkItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items) .Select(x => new AssemblyReferenceNode(x))); var packageReferenceNode = new PackageReferenceNode(target.Id, target.Version.ToString()); builder.WithNode(packageReferenceNode); builder.WithNodes(assemblyReferences); builder.WithEdges(assemblyReferences.Select(x => new Edge(packageReferenceNode, x))); packageNodes.Add(target.Id, packageReferenceNode); } foreach (var target in prunedPackages) { var packageReferenceNode = packageNodes[target.Id]; builder.WithEdges(target.Dependencies.Select(x => new Edge(packageReferenceNode, packageNodes[x.Id], x.VersionRange.ToString()))); } return(builder.Build()); } }
private async Task <RestoreSummary> PerformNuGetV2RestoreAsync(PackageRestoreInputs packageRestoreInputs) { ReadSettings(packageRestoreInputs); var packagesFolderPath = GetPackagesFolder(packageRestoreInputs); var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, packagesFolderPath); var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer()); if (packageRestoreInputs.RestoringWithSolutionFile) { installedPackageReferences.AddRange(packageRestoreInputs .PackagesConfigFiles .SelectMany(file => GetInstalledPackageReferences(file, allowDuplicatePackageIds: true))); } else if (packageRestoreInputs.PackagesConfigFiles.Count > 0) { // By default the PackageReferenceFile does not throw // if the file does not exist at the specified path. // So we'll need to verify that the file exists. Debug.Assert(packageRestoreInputs.PackagesConfigFiles.Count == 1, "Only one packages.config file is allowed to be specified " + "at a time when not performing solution restore."); var packageReferenceFile = packageRestoreInputs.PackagesConfigFiles[0]; if (!File.Exists(packageReferenceFile)) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("RestoreCommandFileNotFound"), packageReferenceFile); throw new InvalidOperationException(message); } installedPackageReferences.AddRange( GetInstalledPackageReferences(packageReferenceFile, allowDuplicatePackageIds: true)); } // EffectivePackageSaveMode is None when -PackageSaveMode is not provided by the user. None is treated as // Defaultv3 for V3 restore and should be treated as Defaultv2 for V2 restore. This is the case in the // actual V2 restore flow and should match in this preliminary missing packages check. var packageSaveMode = EffectivePackageSaveMode == Packaging.PackageSaveMode.None ? Packaging.PackageSaveMode.Defaultv2 : EffectivePackageSaveMode; var missingPackageReferences = installedPackageReferences.Where(reference => !nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray(); if (missingPackageReferences.Length == 0) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), "packages.config"); Console.LogMinimal(message); return(new RestoreSummary(true)); } var packageRestoreData = missingPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { packageRestoreInputs.RestoringWithSolutionFile ? packageRestoreInputs.DirectoryOfSolutionFile : packageRestoreInputs.PackagesConfigFiles[0] }, isMissing: true)); var packageSources = GetPackageSources(Settings); var repositories = packageSources .Select(sourceRepositoryProvider.CreateRepository) .ToArray(); var installCount = 0; var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>(); var collectorLogger = new RestoreCollectorLogger(Console); var packageRestoreContext = new PackageRestoreContext( nuGetPackageManager, packageRestoreData, CancellationToken.None, packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); }, packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); }, sourceRepositories: repositories, maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism, logger: collectorLogger); CheckRequireConsent(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var signingVerificationSettings = SignedPackageVerifierSettings.GetClientPolicy(Settings, collectorLogger); var projectContext = new ConsoleProjectContext(collectorLogger) { PackageExtractionContext = new PackageExtractionContext( Packaging.PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, collectorLogger, signedPackageVerifier, signingVerificationSettings) }; if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None) { projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode; } using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = NoCache; cacheContext.DirectDownload = DirectDownload; var downloadContext = new PackageDownloadContext(cacheContext, packagesFolderPath, DirectDownload) { ExtractionContext = new PackageExtractionContext( Packaging.PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode, collectorLogger, signedPackageVerifier, signingVerificationSettings) }; var result = await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, projectContext, downloadContext); if (downloadContext.DirectDownload) { GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext); } return(new RestoreSummary( result.Restored, "packages.config projects", SettingsUtility.GetConfigFilePaths(Settings), packageSources.Select(x => x.Source), installCount, collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents)))); } }
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (path == null) { throw new ArgumentNullException(nameof(path)); } var packageRoot = path.MakeAbsolute(_environment).FullPath; var targetFramework = type == PackageType.Addin ? _currentFramework : NuGetFramework.AnyFramework; var sourceRepositoryProvider = new NuGetSourceRepositoryProvider(_nugetSettings, _config, package, packageRoot); var localAndPrimaryRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer()); localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.LocalRepositories); localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.PrimaryRepositories); var allRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer()); allRepositories.AddRange(localAndPrimaryRepositories); allRepositories.AddRange(sourceRepositoryProvider.Repositories); var packageIdentity = GetPackageId(package, localAndPrimaryRepositories, targetFramework, _sourceCacheContext, _nugetLogger); if (packageIdentity == null) { return(Array.Empty <IFile>()); } if (packageIdentity.Version.IsPrerelease && !package.IsPrerelease()) { // TODO: Is this allowed? If not, log and return return(Array.Empty <IFile>()); } var pathResolver = new PackagePathResolver(packageRoot); var dependencyBehavior = GetDependencyBehavior(type, package); var downloadContext = new PackageDownloadContext(_sourceCacheContext); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); GetPackageDependencies(packageIdentity, targetFramework, _sourceCacheContext, _nugetLogger, allRepositories, availablePackages, dependencyBehavior, localAndPrimaryRepositories); var resolverContext = new PackageResolverContext( dependencyBehavior, new[] { packageIdentity.Id }, Enumerable.Empty <string>(), Enumerable.Empty <global::NuGet.Packaging.PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, allRepositories.Select(s => s.PackageSource), NullLogger.Instance); var resolver = new PackageResolver(); var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))); var packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(_nugetSettings, _nugetLogger), _nugetLogger); var installedFiles = new List <IFile>(); foreach (var packageToInstall in packagesToInstall) { var isTargetPackage = packageToInstall.Id.Equals(package.Package, StringComparison.OrdinalIgnoreCase); var installPath = new DirectoryPath(pathResolver.GetInstallPath(packageToInstall)); if (!_fileSystem.Exist(installPath)) { var downloadResource = packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).GetAwaiter().GetResult(); var downloadResult = downloadResource.GetDownloadResourceResultAsync( packageToInstall, downloadContext, SettingsUtility.GetGlobalPackagesFolder(_nugetSettings), _nugetLogger, CancellationToken.None).GetAwaiter().GetResult(); PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, pathResolver, packageExtractionContext, CancellationToken.None).GetAwaiter().GetResult(); // If this is the target package, to avoid problems with casing, get the actual install path from the nuspec if (isTargetPackage) { installPath = new DirectoryPath(pathResolver.GetInstallPath(downloadResult.PackageReader.GetIdentity())); } } if (_blackListedPackages.Contains(packageToInstall.Id)) { const string format = "Package {0} depends on package {1}. This dependency won't be loaded."; _log.Debug(format, package.Package, packageToInstall.ToString()); continue; } // If the installed package is not the target package, create a new PackageReference // which is passed to the content resolver. This makes logging make more sense. var installedPackageReference = isTargetPackage ? package : new PackageReference($"nuget:?package={packageToInstall.Id}"); installedFiles.AddRange(_contentResolver.GetFiles(installPath, installedPackageReference, type)); } return(installedFiles); }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, RestoreOperationSource restoreSource, IntervalTracker intervalTracker, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject))) { return; } if (_packageRestoreConsent.IsGranted) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); await _logger.WriteLineAsync(VerbosityLevel.Quiet, message); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } DependencyGraphCacheContext cacheContext; DependencyGraphSpec originalDgSpec; DependencyGraphSpec dgSpec; IReadOnlyList <IAssetsLogMessage> additionalMessages; using (intervalTracker.Start(RestoreTelemetryEvent.SolutionDependencyGraphSpecCreation)) { // Cache p2ps discovered from DTE cacheContext = new DependencyGraphCacheContext(_logger, _settings); var pathContext = NuGetPathContext.Create(_settings); // Get full dg spec (originalDgSpec, additionalMessages) = await DependencyGraphRestoreUtility.GetSolutionRestoreSpecAndAdditionalMessages(_solutionManager, cacheContext); } using (intervalTracker.Start(RestoreTelemetryEvent.SolutionUpToDateCheck)) { // Run solution based up to date check. var projectsNeedingRestore = _solutionUpToDateChecker.PerformUpToDateCheck(originalDgSpec, _logger).AsList(); dgSpec = originalDgSpec; // Only use the optimization results if the restore is not `force`. // Still run the optimization check anyways to prep the cache. if (!forceRestore) { // Update the dg spec. dgSpec = originalDgSpec.WithoutRestores(); foreach (var uniqueProjectId in projectsNeedingRestore) { dgSpec.AddRestore(uniqueProjectId); } // recorded the number of up to date projects _upToDateProjectCount = originalDgSpec.Restore.Count - projectsNeedingRestore.Count; _noOpProjectsCount = _upToDateProjectCount; } } using (intervalTracker.Start(RestoreTelemetryEvent.PackageReferenceRestoreDuration)) { // Avoid restoring if all the projects are up to date, or the solution does not have build integrated projects. if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec)) { // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var isRestoreOriginalAction = true; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, dgSpec, cacheContext, providerCache, cacheModifier, sources, _nuGetProjectContext.OperationId, forceRestore, isRestoreOriginalAction, additionalMessages, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false); _noOpProjectsCount += restoreSummaries.Where(summary => summary.NoOpRestore == true).Count(); _solutionUpToDateChecker.SaveRestoreStatus(restoreSummaries); if (isRestoreFailed) { _status = NuGetOperationStatus.Failed; } else if (_noOpProjectsCount < restoreSummaries.Count) { _status = NuGetOperationStatus.Succeeded; } }, token); } } } else if (restoreSource == RestoreOperationSource.Explicit) { _logger.ShowError(Resources.PackageRefNotRestoredBecauseOfNoConsent); } }
private async Task <TemplatePackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath templateRepositoryPath) { ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString()); var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion); var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); using (var cacheContext = new SourceCacheContext()) { IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); foreach (SourceRepository sourceRepository in repositories) { DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false); IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages( packageId, nugetFramework, cacheContext, NullLogger.Instance, CancellationToken.None).ConfigureAwait(false); if (dependencyInfo == null) { continue; } availablePackages.AddRange(dependencyInfo); } var resolverContext = new PackageResolverContext( DependencyBehavior.Highest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), NullLogger.Instance); var resolver = new PackageResolver(); SourcePackageDependencyInfo packageToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))) .FirstOrDefault(); var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings)); var packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance), NullLogger.Instance); string installedPath = packagePathResolver.GetInstalledPath(packageToInstall); PackageReaderBase packageReader; if (installedPath == null && packageToInstall != null) { DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false); DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageToInstall, new PackageDownloadContext(cacheContext), SettingsUtility.GetGlobalPackagesFolder(settings), NullLogger.Instance, CancellationToken.None).ConfigureAwait(false); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None).ConfigureAwait(false); packageReader = downloadResult.PackageReader; } else { packageReader = new PackageFolderReader(installedPath); } PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false); var templatePackageMetaData = new TemplatePackage { PackageId = identity.Id, Version = identity.Version.OriginalVersion, TemplateRepositoryPath = templateRepositoryPath.ToString(), }; foreach (FrameworkSpecificGroup contentItem in packageReader.GetContentItems()) { foreach (string item in contentItem.Items) { templatePackageMetaData.Templates.Add(new Template { NestedFilePath = item }); } } var packageFileExtractor = new PackageFileExtractor( templatePackageMetaData.Templates.Select(template => template.NestedFilePath), XmlDocFileSaveMode.None); await packageReader.CopyFilesAsync( templatePackageMetaData.InstalltionPath, templatePackageMetaData.Templates.Select(template => template.NestedFilePath), packageFileExtractor.ExtractPackageFile, NullLogger.Instance, CancellationToken.None).ConfigureAwait(false); return(templatePackageMetaData); } }
private void Save() { string filePath = SettingsUtility.GetAuthenticationSettingsFilePath(_authenticationSettings.Identifier); _authenticationSettings.Save(filePath, _password); }
public void SettingsUtility_GetPropertyMappings_Null() { SettingsUtility.GetPropertyMappings(null).Count.Should().Be(0); }