public async Task <InstallerResult> InstallAsync( PackageIdentity package, IExtensibleProject project, IReadOnlyList <SourceRepository> repositories, bool ignoreMissingPackages = false, CancellationToken cancellationToken = default) { try { // Step 1. Decide what framework version used on package resolving // Enforce platform-specific framework for .NET 5.0 var targetFramework = FrameworkParser.TryParseFrameworkName(project.Framework, _frameworkNameProvider); var reducer = new FrameworkReducer(); #if NET5_0_OR_GREATER var mostSpecific = reducer.ReduceUpwards(project.SupportedPlatforms).FirstOrDefault(); targetFramework = mostSpecific; #endif _nugetLogger.LogInformation($"Installing package {package}, Target framework: {targetFramework}"); // Prepare to step 2. Add globals if cache enabled as available repository with highest priority. // Note: This part falls under responsibility of RepositoryContextService but the same logic used to determine what packages are found by IPackageLoaderService // To not break behavior for now add here if (!project.NoCache) { var repositoryList = repositories.ToList(); repositoryList.Insert(0, new SourceRepository(new PackageSource(DefaultNuGetFolders.GetGlobalPackagesFolder(), ".nuget"), Repository.Provider.GetCoreV3())); repositories = repositoryList; } // Step 2. Build list of dependencies and determine DependencyBehavior if some packages are misssed in current feed Resolver.PackageResolverContext resolverContext = null; using (var cacheContext = new SourceCacheContext()) { #pragma warning disable IDISP013 // Await in using. var getDependencyResourcesTasks = repositories.Select(repo => repo.GetResourceAsync <DependencyInfoResource>()); #pragma warning restore IDISP013 // Await in using. var dependencyResources = (await getDependencyResourcesTasks.WhenAllOrExceptionAsync()).Where(x => x.IsSuccess && x.Result is not null) .Select(x => x.Result).ToArray(); var dependencyInfoResources = new DependencyInfoResourceCollection(dependencyResources); resolverContext = await ResolveDependenciesAsync(package, targetFramework, PackageIdentityComparer.Default, dependencyInfoResources, cacheContext, project, ignoreMissingPackages, cancellationToken); if (resolverContext is null || !(resolverContext?.AvailablePackages?.Any() ?? false)) { var errorMessage = $"Package {package} cannot be resolved with current settings (TFM: {targetFramework}) for chosen destination"; _nugetLogger.LogWarning(errorMessage); return(new InstallerResult(errorMessage)); } // Step 3. Try to check is main package can be downloaded from resource var mainPackageInfo = resolverContext.AvailablePackages.FirstOrDefault(p => p.Id == package.Id); _nugetLogger.LogInformation($"Downloading {package}..."); var mainDownloadedFiles = await DownloadPackageResourceAsync(mainPackageInfo, cacheContext, cancellationToken); _nugetLogger.LogInformation($"{package} download completed"); if (!mainDownloadedFiles.IsAvailable()) { // Downlod failed by some reasons (probably connection issue or package goes deleted before feed updated) var errorMessage = $"Current source lists package {package} but attempts to download it have failed. The source in invalid or required packages were removed while the current operation was in progress"; _nugetLogger.LogError(errorMessage); return(new InstallerResult(errorMessage)); } // Step 4. Check is main package compatible with target Framework var canBeInstalled = await CheckCanBeInstalledAsync(project, mainDownloadedFiles.PackageReader, targetFramework, cancellationToken); if (!canBeInstalled) { throw new IncompatiblePackageException($"Package {package} incompatible with project target platform {targetFramework}"); } // Step 5. Build install list using NuGet Resolver and select available resources. // Track packages which already installed and make sure only one version of package exists var resolver = new Resolver.PackageResolver(); var availablePackagesToInstall = await resolver.ResolveWithVersionOverrideAsync(resolverContext, project, DependencyBehavior.Highest, (project, conflict) => _fileSystemService.CreateDeleteme(conflict.PackageIdentity.Id, project.GetInstallPath(conflict.PackageIdentity)), cancellationToken); // Step 6. Download everything except main package and extract all availablePackagesToInstall.Remove(mainPackageInfo); _nugetLogger.LogInformation($"Downloading package dependencies..."); var downloadResults = await DownloadPackagesResourcesAsync(availablePackagesToInstall, cacheContext, cancellationToken); downloadResults[mainPackageInfo] = mainDownloadedFiles; _nugetLogger.LogInformation($"{downloadResults.Count - 1} dependencies downloaded"); var extractionContext = GetExtractionContext(); await ExtractPackagesResourcesAsync(downloadResults, project, extractionContext, cancellationToken); await CheckLibAndFrameworkItemsAsync(downloadResults, targetFramework, cancellationToken); return(new InstallerResult(downloadResults)); } } catch (NuGetResolverInputException ex) { throw new IncompatiblePackageException($"Package {package} or some of it dependencies are missed for current target framework", ex); } catch (Exception ex) { Log.Error(ex); throw; } }
public static bool TryGetCompatibleItems <T>(FrameworkName projectFramework, IEnumerable <T> items, out IEnumerable <T> compatibleItems) where T : IFrameworkTargetable { if (!items.Any()) { compatibleItems = Enumerable.Empty <T>(); return(true); } // Not all projects have a framework, we need to consider those projects. var internalProjectFramework = projectFramework ?? EmptyFramework; // Turn something that looks like this: // item -> [Framework1, Framework2, Framework3] into // [{item, Framework1}, {item, Framework2}, {item, Framework3}] var normalizedItems = from item in items let frameworks = (item.SupportedFrameworks != null && item.SupportedFrameworks.Any()) ? item.SupportedFrameworks : new FrameworkName[] { null } from framework in frameworks select new { Item = item, TargetFramework = framework }; // Group references by target framework (if there is no target framework we assume it is the default) var frameworkGroups = normalizedItems .GroupBy(g => g.TargetFramework, g => g.Item) .ToList(); // Try to find the best match using NuGet's Get Nearest algorithm var nuGetFrameworkToFrameworkGroup = frameworkGroups .Where(g => g.Key != null) .ToDictionary(g => GetNuGetFramework( NetPortableProfileTable.Instance, ReferenceAssemblyFrameworkNameProvider.Instance, g.Key), NuGetFramework.Comparer); var reducer = new FrameworkReducer( ReferenceAssemblyFrameworkNameProvider.Instance, ReferenceAssemblyCompatibilityProvider.Instance); var nearest = reducer.GetNearest( GetNuGetFramework( NetPortableProfileTable.Instance, ReferenceAssemblyFrameworkNameProvider.Instance, internalProjectFramework), nuGetFrameworkToFrameworkGroup.Keys); if (nearest != null) { compatibleItems = nuGetFrameworkToFrameworkGroup[nearest]; } else { compatibleItems = null; } bool hasItems = compatibleItems != null && compatibleItems.Any(); if (!hasItems) { // if there's no matching profile, fall back to the items without target framework // because those are considered to be compatible with any target framework compatibleItems = frameworkGroups.Where(g => g.Key == null).SelectMany(g => g); hasItems = compatibleItems != null && compatibleItems.Any(); } if (!hasItems) { compatibleItems = null; } return(hasItems); }
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 UninstallPackage(PackageIdentity identity) { var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var installedPath = packagePathResolver.GetInstalledPath(identity); PackageReaderBase packageReader; packageReader = new PackageFolderReader(installedPath); var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger); var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger); bool failed = true; try { await PackageExtractor.ExtractPackageAsync(installedPath, packageReader, packagePathResolver, packageExtractionContext, CancellationToken.None); failed = false; } catch (Exception) { } if (failed) { try { await Download(identity); installedPath = packagePathResolver.GetInstalledPath(identity); packageReader = new PackageFolderReader(installedPath); failed = false; } catch (Exception) { throw; } } var libItems = packageReader.GetLibItems(); var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { RemoveFile(installedPath, f); } var cont = packageReader.GetContentItems(); nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework)); files = cont .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { RemoveFile(installedPath, f); } if (System.IO.Directory.Exists(installedPath + @"\build")) { if (System.IO.Directory.Exists(installedPath + @"\build\x64")) { foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64")) { var filename = System.IO.Path.GetFileName(f); var target = System.IO.Path.Combine(Destinationfolder, filename); if (System.IO.File.Exists(target)) { try { System.IO.File.Delete(target); } catch (Exception) { } } } } } }
public async Task <bool> IsPackageInstalled(LocalPackageInfo package) { await Download(package.Identity); var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var installedPath = packagePathResolver.GetInstalledPath(package.Identity); PackageReaderBase packageReader; packageReader = new PackageFolderReader(installedPath); var libItems = packageReader.GetLibItems(); if (libItems.Count() == 0) { Console.WriteLine("Booom!"); } var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { string source = ""; string f2 = ""; string filename = ""; string dir = ""; string target = ""; try { source = System.IO.Path.Combine(installedPath, f); f2 = f.Substring(f.IndexOf("/", 4) + 1); filename = System.IO.Path.GetFileName(f2); dir = System.IO.Path.GetDirectoryName(f2); target = System.IO.Path.Combine(Destinationfolder, dir, filename); if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir))) { System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir)); } if (!System.IO.File.Exists(source)) { return(false); } if (!System.IO.File.Exists(target)) { return(false); } var infoOld = new System.IO.FileInfo(source); var infoNew = new System.IO.FileInfo(target); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } return(true); }
private IEnumerable <LibraryDependency> GetDependencies(LocalPackageInfo package, NuGetFramework targetFramework) { NuspecReader nuspecReader = null; using (var stream = File.OpenRead(package.ManifestPath)) { nuspecReader = new NuspecReader(stream); } var reducer = new FrameworkReducer(); var deps = nuspecReader.GetDependencyGroups() .ToDictionary(g => new NuGetFramework(g.TargetFramework), g => g.Packages); var nearest = reducer.GetNearest(targetFramework, deps.Keys); if (nearest != null) { foreach (var d in deps[nearest]) { yield return(new LibraryDependency { LibraryRange = new LibraryRange { Name = d.Id, VersionRange = d.VersionRange == null ? null : new NuGetVersionRange(d.VersionRange) } }); } } // TODO: Remove this when we do #596 // ASP.NET Core isn't compatible with generic PCL profiles //if (string.Equals(targetFramework.Identifier, VersionUtility.AspNetCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase)) //{ // yield break; //} var frameworks = nuspecReader.GetFrameworkReferenceGroups() .ToDictionary(f => f.TargetFramework, f => f.Items); nearest = reducer.GetNearest(targetFramework, frameworks.Keys) ?? frameworks.Keys.FirstOrDefault(f => f.AnyPlatform); if (nearest != null) { if (nearest.AnyPlatform && !targetFramework.IsDesktop()) { // REVIEW: This isn't 100% correct since none *can* mean // any in theory, but in practice it means .NET full reference assembly // If there's no supported target frameworks and we're not targeting // the desktop framework then skip it. // To do this properly we'll need all reference assemblies supported // by each supported target framework which isn't always available. yield break; } foreach (var name in frameworks[nearest]) { yield return(new LibraryDependency { LibraryRange = new LibraryRange { Name = name, IsGacOrFrameworkReference = true } }); } } }
public bool InstallPackage(PackageIdentity identity) { var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var installedPath = packagePathResolver.GetInstalledPath(identity); using (var packageReader = new PackageFolderReader(installedPath)) { var libItems = packageReader.GetLibItems(); var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { InstallFile(installedPath, f); } var cont = packageReader.GetContentItems(); nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework)); files = cont .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { InstallFile(installedPath, f); } try { var dependencies = packageReader.GetPackageDependencies(); nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework)); foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest))) { foreach (var p in dep.Packages) { var local = GetLocal(p.Id); InstallPackage(local.Identity); } } } catch (Exception ex) { Logger.LogError(ex.ToString()); } } if (System.IO.Directory.Exists(installedPath + @"\build")) { if (System.IO.Directory.Exists(installedPath + @"\build\x64")) { foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64")) { var filename = System.IO.Path.GetFileName(f); var target = System.IO.Path.Combine(Destinationfolder, filename); CopyIfNewer(f, target); } } } return(true); }
public async Task InstallPackageAsync( Project project, string packageId, string version, string framework) { var packageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(version)); var settings = Settings.LoadDefaultSettings(root: null); var sourceRepoProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3()); var nuGetFramework = NuGetFramework.ParseFolder(framework); var logger = NullLogger.Instance; using (var cacheContext = new SourceCacheContext()) { var repositories = sourceRepoProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); // This will cache the dependencies. await GetPackageDependencies( packageIdentity, nuGetFramework, cacheContext, logger, repositories, availablePackages) .ConfigureAwait(false); var resolverContext = new PackageResolverContext( dependencyBehavior: DependencyBehavior.Lowest, targetIds: new[] { packageId }, requiredPackageIds: Enumerable.Empty <string>(), packagesConfig: Enumerable.Empty <PackageReference>(), preferredVersions: Enumerable.Empty <PackageIdentity>(), availablePackages: availablePackages, packageSources: sourceRepoProvider .GetRepositories() .Select(s => s.PackageSource), log: logger); 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 packageExtractContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, logger), //new PackageSignatureVerifier( //new[] { new SignatureTrustAndValidityVerificationProvider() as ISignatureVerificationProvider }), //SignatureVerificationProviderFactory.GetSignatureVerificationProviders()), logger); var frameworkReducer = new FrameworkReducer(); foreach (var packageToInstall in packagesToInstall) { PackageReaderBase packageReader; var installedPath = packagePathResolver.GetInstallPath(packageToInstall); if (installedPath == null) { var downloadResource = await packageToInstall.Source .GetResourceAsync <DownloadResource>(CancellationToken.None) .ConfigureAwait(false); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageToInstall, new PackageDownloadContext(cacheContext), SettingsUtility.GetGlobalPackagesFolder(settings), logger, CancellationToken.None) .ConfigureAwait(false); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractContext, CancellationToken.None) .ConfigureAwait(false); packageReader = downloadResult.PackageReader; } else { packageReader = new PackageFolderReader(installedPath); } var libtItems = packageReader.GetLibItems(); var nearest = frameworkReducer.GetNearest( nuGetFramework, libtItems.Select(x => x.TargetFramework)); var frameworkItems = packageReader.GetFrameworkItems(); nearest = frameworkReducer.GetNearest( nuGetFramework, frameworkItems.Select(x => x.TargetFramework)); } } // Update csproj file to include the project reference. var projectElement = new ProjectElement(project); projectElement.AddPackageReference( packageId, version) .Save(); }
/// <summary> /// Adds refresh files to the specified project for all assemblies references belonging to the packages /// specified by packageNames. /// </summary> /// <param name="project">The project.</param> /// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames) { if (project == null) { throw new ArgumentNullException("project"); } if (repositoryPath == null) { throw new ArgumentNullException("repositoryPath"); } if (!packageNames.Any()) { return; } VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var logger = new LoggerAdapter(context); context.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context); foreach (var packageName in packageNames) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version); DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath)); PackageFolderReader reader = new PackageFolderReader(packageFolder); var frameworkGroups = reader.GetReferenceItems(); var groups = reader.GetReferenceItems(); var fwComparer = new NuGetFrameworkFullComparer(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework)); if (targetGroupFramework != null) { var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault(); foreach (string refItem in refGroup.Items) { string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar)); // create one refresh file for each assembly reference, as per required by Website projects // projectSystem.CreateRefreshFile(assemblyPath); RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath); } } } }
public async Task <InternalNuGetCompatibilityResult> CheckCompatibilityAsync(string packageName, string version, string targetFramework, IEnumerable <SourceRepository> internalRepositories) { if (packageName == null || targetFramework == null || internalRepositories == null) { var invalidParamNames = new List <string>(); if (packageName == null) { invalidParamNames.Add(nameof(packageName)); } if (targetFramework == null) { invalidParamNames.Add(nameof(targetFramework)); } if (internalRepositories == null) { invalidParamNames.Add(nameof(internalRepositories)); } throw new ArgumentException($"Invalid parameter(s) found. The following parameters " + $"cannot be null: {string.Join(", ", invalidParamNames)}"); } string tmpPath = Path.GetTempPath(); var framework = NuGetFramework.Parse(targetFramework); var package = new PackageIdentity(packageName, NuGetVersion.Parse(version)); // Get package information from Nuget SourcePackageDependencyInfo packageSource = null; foreach (var sourceRepository in internalRepositories) { var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>(); packageSource = await dependencyInfoResource.ResolvePackage( package, framework, _cacheContext, NullLogger.Instance, CancellationToken.None); if (packageSource != null) { break; } } if (packageSource == null) { var errorMessage = $"Error: No package source found for {package}."; _logger.LogError(errorMessage); var innerException = new PackageSourceNotFoundException(errorMessage); throw new PortingAssistantClientException(ExceptionMessage.PackageSourceNotFound(package), innerException); } // Download package var downloadResource = await packageSource.Source.GetResourceAsync <DownloadResource>(); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageSource, new PackageDownloadContext(_cacheContext), Path.Combine(tmpPath), NullLogger.Instance, CancellationToken.None); var packageReader = downloadResult.PackageReader; var nuspecReader = packageReader.NuspecReader; var dependencies = nuspecReader.GetDependencyGroups(); var dependencyPackages = dependencies .SelectMany(d => d.Packages) .Select(p => p.Id) .ToList(); // Gather dlls var frameworkReducer = new FrameworkReducer(); var libItems = packageReader.GetLibItems(); var nearestTargetFrameworks = libItems .Select(li => frameworkReducer.GetNearest( framework, new List <NuGetFramework> { li.TargetFramework })) .ToList(); var isCompatible = libItems.Any() ? nearestTargetFrameworks.Any(nugetFramework => nugetFramework != null) : frameworkReducer.GetNearest(framework, packageReader.GetSupportedFrameworks()) != null; var compatibleDlls = libItems .Where(li => nearestTargetFrameworks.Contains(li.TargetFramework)) .SelectMany(li => li.Items) .Where(s => s.EndsWith("dll", StringComparison.OrdinalIgnoreCase)) .ToList(); var incompatibleDlls = libItems .SelectMany(li => li.Items) .Where(s => !compatibleDlls.Contains(s) && s.EndsWith("dll", StringComparison.OrdinalIgnoreCase)) .ToList(); return(new InternalNuGetCompatibilityResult { IncompatibleDlls = incompatibleDlls, CompatibleDlls = compatibleDlls, IsCompatible = isCompatible, DependencyPackages = dependencyPackages, Source = packageSource.Source.PackageSource.Name }); }
public IEnumerable <AssemblyInfo> GetAssemblies(PackageIdentity pkg) { // Ignore all SDK packages: if (pkg == null || IsSystemPackage(pkg)) { return(Enumerable.Empty <AssemblyInfo>()); } var pkgInfo = LocalPackagesFinder.GetPackage(pkg, Logger, CancellationToken.None); if (pkgInfo == null) { Logger.LogWarning($"Could not find Package {pkg}"); return(Enumerable.Empty <AssemblyInfo>()); } var packageReader = pkgInfo.GetReader(); var libs = packageReader?.GetLibItems(); // If package contains no dlls: if (libs == null) { Logger.LogWarning($"Could not find any dll for {pkg}"); return(Enumerable.Empty <AssemblyInfo>()); } var root = Path.GetDirectoryName(pkgInfo.Path); string[] CheckOnFramework(NuGetFramework framework) { var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(framework, libs.Select(x => x.TargetFramework)); if (nearest == null) { return(new string[0]); } var files = libs .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items) .Where(n => n.EndsWith(".dll")) .Select(p => Path.Combine(root, p)); return(files.ToArray()); } var names = CheckOnFramework(NETCOREAPP3_1); Assembly?LoadAssembly(string path) { try { return(Assembly.LoadFile(path)); } catch (Exception e) { Logger.LogWarning($"Unable to load assembly '{path}' ({e.Message})"); return(null); } } return(names .Select(LoadAssembly) .Select(AssemblyInfo.Create) .Where(a => a != null)); }
public static async Task InstallPackages(PackagePathResolver packagePathResolver, SourcePackageDependencyInfo packageToInstall, SourceCacheContext cacheContext, PackageExtractionContext packageExtractionContext, FrameworkReducer frameworkReducer, NuGetFramework nuGetFramework, ISettings settings, ILogger logger) { 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), logger, 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))); }
public override void DoExecute(IInstallPluginContext input) { var pluginInstallFolder = Path.Combine(input.InstallDirectory, input.PackageId); if (Directory.Exists(pluginInstallFolder)) { return; } Directory.CreateDirectory(pluginInstallFolder); var nuGetVersion = NuGetVersion.Parse(input.PackageVersion); var packageIdentity = new PackageIdentity(input.PackageId, nuGetVersion); var nuGetFramework = NuGetFramework.ParseFolder(input.PackageFramework); var packagesToInstall = _nugetService .GetPackagesToInstall(packageIdentity, nuGetFramework, input.OmitDependencies) .Result; var frameworkReducer = new FrameworkReducer(); foreach (var packageToInstall in packagesToInstall) { var(package, installPath) = _nugetService.DownloadPackage(packageToInstall).Result; var libItems = package.GetLibItems().ToList(); var possibleFrameworks = libItems.Select(group => group.TargetFramework); var nearestFramework = frameworkReducer.GetNearest(nuGetFramework, possibleFrameworks); var assemblies = libItems .Where(group => group.TargetFramework == nearestFramework) .SelectMany(group => group.Items) .ToList(); foreach (var assembly in assemblies) { var destFileName = Path.Combine(pluginInstallFolder, Path.GetFileName(assembly)); if (File.Exists(destFileName)) { continue; } var sourceFileName = Path.Combine(installPath, assembly); File.Copy(sourceFileName, destFileName); } var contentItems = package.GetContentItems().ToList(); var nearestContentFramework = frameworkReducer.GetNearest(nuGetFramework, contentItems.Select(x => x.TargetFramework)); var ci = contentItems .Where(group => group.TargetFramework == nearestContentFramework) .SelectMany(group => group.Items) .ToList(); foreach (var contentItem in ci) { var destFileName = Path.Combine(pluginInstallFolder, contentItem); var folder = Path.GetDirectoryName(destFileName); if (folder != null && !Directory.Exists(folder)) { Directory.CreateDirectory(folder); } if (File.Exists(destFileName)) { continue; } var sourceFileName = Path.Combine(installPath, contentItem); File.Copy(sourceFileName, destFileName); } } }
public void UninstallPackage(string TargetFolder, PackageIdentity identity) { var packagePathResolver = new PackagePathResolver(PackagesInstallFolder); var installedPath = packagePathResolver.GetInstalledPath(identity); PackageReaderBase packageReader; packageReader = new PackageFolderReader(installedPath); var libItems = packageReader.GetLibItems(); var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { UninstallFile(TargetFolder, installedPath, f); } var cont = packageReader.GetContentItems(); nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework)); files = cont .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { UninstallFile(TargetFolder, installedPath, f); } try { var dependencies = packageReader.GetPackageDependencies(); nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework)); foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest))) { foreach (var p in dep.Packages) { var local = getLocal(p.Id); UninstallPackage(TargetFolder, local.Identity); } } } catch (Exception ex) { Log.Error(ex.ToString()); } if (System.IO.Directory.Exists(installedPath + @"\build")) { if (System.IO.Directory.Exists(installedPath + @"\build\x64")) { foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64")) { var filename = System.IO.Path.GetFileName(f); var target = System.IO.Path.Combine(TargetFolder, filename); if (System.IO.File.Exists(target)) { try { System.IO.File.Delete(target); } catch (Exception) { PendingDeletion.Add(target); } } } } } }
public async Task UninstallAsync(PackageIdentity package, IExtensibleProject project, IEnumerable <PackageReference> installedPackageReferences, CancellationToken cancellationToken = default) { List <string> failedEntries = null; ICollection <PackageIdentity> uninstalledPackages; var targetFramework = FrameworkParser.TryParseFrameworkName(project.Framework, _frameworkNameProvider); #if NET5_0_OR_GREATER var reducer = new FrameworkReducer(); var mostSpecific = reducer.ReduceUpwards(project.SupportedPlatforms).FirstOrDefault(); targetFramework = mostSpecific; #endif var projectConfig = _nuGetProjectConfigurationProvider.GetProjectConfig(project); var uninstallationContext = new UninstallationContext(false, false); _nugetLogger.LogInformation($"Uninstall package {package}, Target framework: {targetFramework}"); if (projectConfig is null) { _nugetLogger.LogWarning($"Project {project.Name} doesn't implement any configuration for own packages"); } using (var cacheContext = new SourceCacheContext() { NoCache = false, DirectDownload = false, }) { var dependencyInfoResource = await project.AsSourceRepository(_sourceRepositoryProvider) .GetResourceAsync <DependencyInfoResource>(cancellationToken); var dependencyInfoResourceCollection = new DependencyInfoResourceCollection(dependencyInfoResource); var resolverContext = await ResolveDependenciesAsync(package, targetFramework, PackageIdentity.Comparer, dependencyInfoResourceCollection, cacheContext, project, true, cancellationToken); var packageReferences = installedPackageReferences.ToList(); if (uninstallationContext.RemoveDependencies) { uninstalledPackages = await GetPackagesCanBeUninstalledAsync(resolverContext.AvailablePackages, packageReferences.Select(x => x.PackageIdentity)); } else { uninstalledPackages = new List <PackageIdentity>() { package }; } } try { foreach (var removedPackage in uninstalledPackages) { if (removedPackage.Version is null) { _nugetLogger.LogWarning($"Skip package {removedPackage.Id} uninstall. Check your package.config for references of this packages"); continue; } var folderProject = new FolderNuGetProject(project.ContentPath); if (folderProject.PackageExists(removedPackage)) { _directoryService.ForceDeleteDirectory(_fileService, folderProject.GetInstalledPath(removedPackage), out failedEntries); } if (projectConfig is null) { continue; } var result = await projectConfig.UninstallPackageAsync(removedPackage, _nuGetProjectContextProvider.GetProjectContext(FileConflictAction.PromptUser), cancellationToken); if (!result) { _nugetLogger.LogError($"Saving package configuration failed in project {project} when installing package {package}"); } } } catch (IOException ex) { Log.Error(ex); _nugetLogger.LogError("Package files cannot be complete deleted by unexpected error (may be directory in use by another process?"); } finally { LogHelper.LogUnclearedPaths(failedEntries, Log); } }
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); } else { foreach (DataRow row in packageSources.Rows) { if (row[0].ToString() == "True") { var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(row[2].ToString(), row[1].ToString(), true)); repositories.Add(sourceRepo); } } } 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(); //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); foreach (var packageToInstall in packagesToInstall) { var installedPath = packagePathResolver.GetInstalledPath(packageToInstall); if (installedPath == null) { var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None); var downloadResult = await downloadResource.GetDownloadResourceResultAsync( packageToInstall, 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 (packageToInstall.Id == packageId) { if (projectDependenciesDict.ContainsKey(packageToInstall.Id)) { projectDependenciesDict[packageToInstall.Id] = packageToInstall.Version.ToString(); } else { projectDependenciesDict.Add(packageToInstall.Id, packageToInstall.Version.ToString()); } } } } }
public static void Generate(string outDir, Nuspec spec) { if (Directory.Exists(outDir)) { Directory.Delete(outDir, true); } Directory.CreateDirectory(outDir); /* * This approach creates a lib/<framework> as necessary, depending on the target framework of each assembly. * An issue will arise when referencing such nuget package via SlnX, because as per today there only one * targetFramework can be selected on each <package ... /> element. * Another potential issue is caused by NuGet.exe (see https://docs.microsoft.com/en-us/nuget/reference/nuspec#dependencies-element). * For each lib/<framework> there should be a * <group targetFramework="<framework>"> in the <dependencies> element. * This code creates such a structure, but due to the nature of the Slnx nuget packages handling * it cannot know weather a file (DLL) in a specific framwork does reference one of the listed packages. * It fact, it is well possible that this code would generate invalid dependencies. * e.g. * <group targetFramework="net45"> ---> Caused by a project present in the SlnX (no reference to NUinit here) * <dependency id = "NUnit" version="3.13.1" /> ---> Caused by another project in the SlnX * <group> * For this reason, the code will now check for the "highest" compatible framwork, and create the package for that one only * * var dependencies = new StringBuilder(); * foreach (var frameworkItems in spec.Files) * { * var frameworkDir = Path.Combine(outDir, "lib", frameworkItems.Key); * Directory.CreateDirectory(frameworkDir); * foreach(var f in frameworkItems.Value) * { * File.Copy(f, Path.Combine(frameworkDir, Path.GetFileName(f)), true); * } * * if (string.IsNullOrEmpty(frameworkItems.Key)) * { * dependencies.Append(_dependencyGroupOpening); * } * else * { * dependencies.AppendFormat(_dependencyGroupFrameworkTemplate, frameworkItems.Key); * } * dependencies.AppendLine(); * foreach (var d in spec.Dependecies) * { * dependencies.AppendFormat(string.Format(_dependencyTemplate, d.Id, d.Version)); * dependencies.AppendLine(); * } * dependencies.Append(_dependencyGroupClosing); * dependencies.AppendLine(); * } */ var frameworkReducer = new FrameworkReducer(); var highestFramework = frameworkReducer.ReduceUpwards(spec.Elements.Select(x => NuGetFramework.Parse(x.Key))).ToList(); if (highestFramework.Count != 1) { var required = string.Join(Environment.NewLine, highestFramework); throw new Exception($"For the required package {spec.Id} multiple .NET frameworks would be necessary. This is probably caused by a mixture of '.NET Framework' and '.NET Core' based projects.\nThis is not supported.\nRequired frameworks: {required}"); } var highestFrameworkName = highestFramework.Single().GetShortFolderName(); var packageVersion = spec.Version; if (packageVersion == null) { if (!spec.Elements.ContainsKey(highestFrameworkName)) { throw new Exception($"The .NET version of the required package {spec.Id} has been resolved to {highestFrameworkName}. No file has been found under that framework."); } var assemblies = spec.Elements[highestFrameworkName].Where(x => File.Exists(x) && (x.ToLower().EndsWith(".dll") || x.ToLower().EndsWith(".exe"))); if (assemblies.Count() == 0) { throw new Exception("Error while loading the nuget information. No DLL found from which automatically retrieve the version information."); } var assemblyPath = assemblies.First(); if (File.Exists(assemblyPath)) { var assemblyName = AssemblyName.GetAssemblyName(assemblyPath); packageVersion = assemblyName.Version.ToString(3); } else { throw new Exception(string.Format("Unable to automatically retrieve the package version. Assembly {0} not found", assemblyPath)); } } foreach (var frameworkItems in spec.Elements) { var frameworkDir = Path.Combine(outDir, "lib", highestFrameworkName); Directory.CreateDirectory(frameworkDir); foreach (var f in frameworkItems.Value) { FileAttributes attr = File.GetAttributes(f); if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { CopyDirectory(f, Path.Combine(frameworkDir, Path.GetFileName(f))); } else { File.Copy(f, Path.Combine(frameworkDir, Path.GetFileName(f)), true); } } } var dependencies = new StringBuilder(); if (string.IsNullOrEmpty(highestFrameworkName)) { dependencies.Append(_dependencyGroupOpening); } else { dependencies.AppendFormat(_dependencyGroupFrameworkTemplate, highestFrameworkName); } dependencies.AppendLine(); foreach (var d in spec.Dependecies) { dependencies.AppendFormat(string.Format(_dependencyTemplate, d.Id, d.VersionRange.OriginalString)); dependencies.AppendLine(); } dependencies.Append(_dependencyGroupClosing); dependencies.AppendLine(); string customElements = null; if (spec.AdditionalElements != null) { var lines = spec.AdditionalElements.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); customElements = string.Join($"{Environment.NewLine} ", lines); } var content = string.Format(_nuspecTemplate, spec.Id, packageVersion, customElements, dependencies); Utilities.WriteAllText(Path.Combine(outDir, spec.FileName), content); }
public static List <string> LoadPackageAssemblies(string configPath, bool throwException = false) { string packagesPath = Folders.GetFolder(FolderType.LocalAppDataPackagesFolder); List <string> assemblyPaths = new List <string>(); var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies; var packagePathResolver = new PackagePathResolver(packagesPath); var nuGetFramework = NuGetFramework.ParseFolder("net48"); var settings = Settings.LoadDefaultSettings(root: null); var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagesPath, "Local OpenBots Repo", true)); var resolver = new PackageResolver(); var frameworkReducer = new FrameworkReducer(); var repositories = new List <SourceRepository> { localRepo }; Parallel.ForEach(dependencies, async dependency => { try { using (var cacheContext = new SourceCacheContext()) { var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); await GetPackageDependencies( new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)), nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { dependency.Key }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), NullLogger.Instance); var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))); foreach (var packageToInstall in packagesToInstall) { PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall)); var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework)); var packageListAssemblyPaths = packageReader.GetLibItems() .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList(); if (packageListAssemblyPaths != null) { foreach (string path in packageListAssemblyPaths) { if (!assemblyPaths.Contains(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path))) { assemblyPaths.Add(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)); } } } } } } catch (Exception ex) { //Only true for scheduled and attended executions if (throwException) { MessageBox.Show($"Unable to load {packagesPath}\\{dependency.Key}.{dependency.Value}. " + "Please install this package using the OpenBots Studio Package Manager.", "Error"); Application.Exit(); } else { Console.WriteLine(ex); } } }); try { return(FilterAssemblies(assemblyPaths)); } catch (Exception) { //try again return(LoadPackageAssemblies(configPath, throwException)); } }
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity) { var result = new List <IPackageSearchMetadata>(); using (var cacheContext = new SourceCacheContext()) { var repositories = SourceRepositoryProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); await GetPackageDependencies(identity, cacheContext, availablePackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { identity.Id }, Enumerable.Empty <string>(), Enumerable.Empty <NuGet.Packaging.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 NuGet.Packaging.PackagePathResolver(Packagesfolder); var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, OpenRPAPackageManagerLogger.Instance); var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, OpenRPAPackageManagerLogger.Instance); 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), NuGet.Configuration.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); //} InstallPackage(packageToInstall); } } return(result); }
public bool InstallPackage(PackageIdentity identity) { bool ret = true; var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder); var installedPath = packagePathResolver.GetInstalledPath(identity); PackageReaderBase packageReader; packageReader = new PackageFolderReader(installedPath); var libItems = packageReader.GetLibItems(); var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { InstallFile(installedPath, f); } var cont = packageReader.GetContentItems(); nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework)); files = cont .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { InstallFile(installedPath, f); } try { var dependencies = packageReader.GetPackageDependencies(); nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework)); foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest))) { foreach (var p in dep.Packages) { var local = getLocal(p.Id); InstallPackage(local.Identity); } } } catch (Exception ex) { ret = false; SharedObject.Instance.Output(SharedObject.enOutputType.Error, "安装nupkg包出错", ex); } if (System.IO.Directory.Exists(installedPath + @"\build")) { if (System.IO.Directory.Exists(installedPath + @"\build\x64")) { foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64")) { var filename = System.IO.Path.GetFileName(f); var target = System.IO.Path.Combine(TargetFolder, filename); CopyIfNewer(f, target); } } } return(ret); }
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(new PackageSourceProvider(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()); } }
public async Task <IReadOnlyList <NuGetVersion> > GetAllVersions(string package, IEnumerable <Uri> sources, bool includePrerelease, NuGetFramework targetFramework, string projectFilePath, bool isDevelopmentDependency, int olderThanDays, bool ignoreFailedSources = false) { var allVersions = new List <NuGetVersion>(); foreach (var source in sources) { try { var metadata = await FindMetadataResourceForSource(source, projectFilePath); if (metadata != null) { var compatibleMetadataList = (await metadata.GetMetadataAsync(package, includePrerelease, false, _context, NullLogger.Instance, CancellationToken.None)).ToList(); if (olderThanDays > 0) { compatibleMetadataList = compatibleMetadataList.Where(c => !c.Published.HasValue || c.Published <= DateTimeOffset.UtcNow.AddDays(-olderThanDays)).ToList(); } // We need to ensure that we only get package versions which are compatible with the requested target framework. // For development dependencies, we do not perform this check if (!isDevelopmentDependency) { var reducer = new FrameworkReducer(); compatibleMetadataList = compatibleMetadataList .Where(meta => meta.DependencySets == null || !meta.DependencySets.Any() || reducer.GetNearest(targetFramework, meta.DependencySets.Select(ds => ds.TargetFramework)) != null) .ToList(); } foreach (var m in compatibleMetadataList) { if (m is PackageSearchMetadata packageSearchMetadata) { allVersions.Add(packageSearchMetadata.Version); } else if (m is PackageSearchMetadataV2Feed packageSearchMetadataV2Feed) { allVersions.Add(packageSearchMetadataV2Feed.Version); } else if (m is LocalPackageSearchMetadata localPackageSearchMetadata) { allVersions.Add(localPackageSearchMetadata.Identity.Version); } else { allVersions.Add(m.Identity.Version); } } ; } } catch (HttpRequestException) { // Suppress HTTP errors when connecting to NuGet sources } catch (Exception ex) { if (!ignoreFailedSources) { continue; } // if the inner exception is NOT HttpRequestException, throw it if (ex.InnerException != null && !(ex.InnerException is HttpRequestException)) { throw ex; } } } return(allVersions); }
public async Task Download(PackageIdentity identity) { var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var installedPath = packagePathResolver.GetInstalledPath(identity); if (identity.HasVersion && !string.IsNullOrEmpty(installedPath)) { var idstring = identity.Id + "." + identity.Version; if (installedPath.Contains(idstring)) { return; } } var result = new List <IPackageSearchMetadata>(); using (var cacheContext = new SourceCacheContext()) { var repositories = SourceRepositoryProvider.GetRepositories(); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); await GetPackageWithoutDependencies(identity, cacheContext, availablePackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { identity.Id }, Enumerable.Empty <string>(), Enumerable.Empty <NuGet.Packaging.PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource), Logger); var packageToInstall = availablePackages.Where(p => p.Id == identity.Id).FirstOrDefault(); // var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger); var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger); var frameworkReducer = new FrameworkReducer(); // PackageReaderBase packageReader; 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), NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings), Logger, CancellationToken.None); await PackageExtractor.ExtractPackageAsync( downloadResult.PackageSource, downloadResult.PackageStream, packagePathResolver, packageExtractionContext, CancellationToken.None); // packageReader = downloadResult.PackageReader; // } //else //{ // packageReader = new PackageFolderReader(installedPath); //} } return; }
public IVsNuGetFramework GetNearest(IVsNuGetFramework targetFramework, IEnumerable <IVsNuGetFramework> fallbackTargetFrameworks, IEnumerable <IVsNuGetFramework> frameworks) { if (targetFramework == null) { throw new ArgumentNullException(nameof(targetFramework)); } if (fallbackTargetFrameworks == null) { throw new ArgumentNullException(nameof(fallbackTargetFrameworks)); } if (frameworks == null) { throw new ArgumentNullException(nameof(frameworks)); } var inputFrameworks = new Dictionary <NuGetFramework, IVsNuGetFramework>(); NuGetFramework ToNuGetFramework(IVsNuGetFramework framework, string paramName) { NuGetFramework nugetFramework = MSBuildProjectFrameworkUtility.GetProjectFramework( projectFilePath: null, targetFrameworkMoniker: framework.TargetFrameworkMoniker, targetPlatformMoniker: framework.TargetPlatformMoniker, targetPlatformMinVersion: framework.TargetPlatformMinVersion); if (!nugetFramework.IsSpecificFramework) { throw new ArgumentException($"Framework '{framework}' could not be parsed", paramName); } inputFrameworks[nugetFramework] = framework; return(nugetFramework); } List <NuGetFramework> ToNuGetFrameworks(IEnumerable <IVsNuGetFramework> enumerable, string paramName) { var list = new List <NuGetFramework>(); foreach (var framework in enumerable) { if (framework == null) { throw new ArgumentException("Enumeration contains a null value", paramName); } NuGetFramework nugetFramework = ToNuGetFramework(framework, paramName); list.Add(nugetFramework); } return(list); } NuGetFramework targetNuGetFramework = ToNuGetFramework(targetFramework, nameof(targetFramework)); List <NuGetFramework> nugetFallbackTargetFrameworks = ToNuGetFrameworks(fallbackTargetFrameworks, nameof(fallbackTargetFrameworks)); List <NuGetFramework> nugetFrameworks = ToNuGetFrameworks(frameworks, nameof(frameworks)); try { if (nugetFallbackTargetFrameworks.Count > 0) { targetNuGetFramework = new FallbackFramework(targetNuGetFramework, nugetFallbackTargetFrameworks); } var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(targetNuGetFramework, nugetFrameworks); if (nearest == null) { return(null); } var originalFrameworkString = inputFrameworks[nearest]; return(originalFrameworkString); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName); throw; } }
public static async Task Main() { var packageId = "cake.nuget"; var packageVersion = NuGetVersion.Parse("0.30.0"); var nuGetFramework = NuGetFramework.ParseFolder("net46"); var settings = Settings.LoadDefaultSettings(root: null); var packageSourceProvider = new PackageSourceProvider( settings, new PackageSource[] { new PackageSource("https://api.nuget.org/v3/index.json") }); var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, 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(settings, NullLogger.Instance), NullLogger.Instance); 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))); } } 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); } } } }
public FrameworkLogic() { _reducer = new FrameworkReducer(); _compatibilityProvider = DefaultCompatibilityProvider.Instance; }
public async Task PreProcess(string directive, ScriptExecutionContext context, Action <string> logger) { var actionLogger = new NugetLogger(logger); var nugetDirective = NugetPreProcessorDirective.Parse(directive); string frameworkName = Assembly.GetEntryAssembly() !.GetCustomAttributes(true) .OfType <System.Runtime.Versioning.TargetFrameworkAttribute>() .Select(x => x.FrameworkName) .FirstOrDefault() !; NuGetFramework framework = frameworkName == null ? NuGetFramework.AnyFramework : NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider()); using var cache = new SourceCacheContext(); var packagesPath = Path.Combine(Path.GetTempPath(), "packages"); await CreateEmptyNugetConfig(packagesPath, nugetDirective.FeedUrl); var settings = Settings.LoadImmutableSettingsGivenConfigPaths(new[] { Path.Combine(packagesPath, "empty.config") }, new SettingsLoadingContext()); var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); #pragma warning disable CS0618 // Type or member is obsolete var repositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3()); #pragma warning restore CS0618 // Type or member is obsolete var repository = repositoryProvider.GetRepositories().FirstOrDefault(); var packageMetadataResource = await repository.GetResourceAsync <PackageMetadataResource>(CancellationToken.None); var searchMetadata = await packageMetadataResource.GetMetadataAsync( nugetDirective.PackageId, includePrerelease : false, includeUnlisted : false, cache, actionLogger, CancellationToken.None); if (!searchMetadata.Any()) { throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}"); } var latest = searchMetadata.OrderByDescending(a => a.Identity.Version).FirstOrDefault(); if (latest is null) { throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}"); } var packageId = latest.Identity; var dependencyResource = await repository.GetResourceAsync <DependencyInfoResource>(); await GetPackageDependencies( packageId, framework, cache, repository, dependencyResource, availablePackages, actionLogger); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { nugetDirective.PackageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, new[] { repository.PackageSource }, actionLogger); var resolver = new PackageResolver(); var toInstall = resolver.Resolve(resolverContext, CancellationToken.None) .Select(a => availablePackages.Single(b => PackageIdentityComparer.Default.Equals(b, a))); var pathResolver = new PackagePathResolver(packagesPath); var extractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, actionLogger), actionLogger); var libraries = new List <string>(); var frameworkReducer = new FrameworkReducer(); var downloadResource = await repository.GetResourceAsync <DownloadResource>(CancellationToken.None); foreach (var package in toInstall) { libraries.AddRange(await Install(downloadResource, package, pathResolver, extractionContext, frameworkReducer, framework, packagesPath, actionLogger)); } foreach (var path in libraries) { var assembly = Assembly.LoadFrom(path); if (context.TryAddReferenceAssembly(assembly)) { foreach (var ns in assembly.GetTypes().Where(a => a.Namespace != null).Select(a => a.Namespace).Distinct()) { context.AddImport(ns); } } } }
static IEnumerable <string> GetAssemblyPaths(IEnumerable <FrameworkSpecificGroup> items, FrameworkReducer frameworkReducer, NuGetFramework nuGetFramework, string installedPath) { var nearest = frameworkReducer.GetNearest(nuGetFramework, items.Select(x => x.TargetFramework)); return(items .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items) .Where(x => x.EndsWith(".dll")) .Select(x => Path.Combine(installedPath, x))); }