public static ServerPackageMetadata Parse(IPackage package) { var Version = NuGetVersion.Parse(package.Version.ToString()); var Published = package.Published; var title = String.IsNullOrEmpty(package.Title) ? package.Id : package.Title; var summary = package.Summary; var desc = package.Description; //*TODOs: Check if " " is the separator in the case of V3 jobjects ... var authors = package.Authors; var owners = package.Owners; var iconUrl = package.IconUrl; var licenseUrl = package.LicenseUrl; var projectUrl = package.ProjectUrl; IEnumerable<string> tags = package.Tags == null ? new string[0] : package.Tags.Split(' '); var dependencySets = package.DependencySets.Select(p => GetVisualStudioUIPackageDependencySet(p)); var requiresLiceneseAcceptance = package.RequireLicenseAcceptance; var identity = new PackageIdentity(package.Id, Version); NuGetVersion minClientVersion = null; if (package.MinClientVersion != null) { NuGetVersion.TryParse(package.MinClientVersion.ToString(), out minClientVersion); } var downloadCount = package.DownloadCount; // This concept is not in v2 yet IEnumerable<string> types = new string[] { "Package" }; return new ServerPackageMetadata( identity, title, summary, desc, authors, iconUrl, licenseUrl, projectUrl, tags, Published, dependencySets, requiresLiceneseAcceptance, minClientVersion, downloadCount, -1, owners, types); }
public static async Task Extract ( Solution solution, PackageIdentity packageIdentity, DownloadResourceResult downloadResult, CancellationToken token) { string globalPackagesFolder = await GetPackagesDirectory (solution); var defaultPackagePathResolver = new VersionFolderPathResolver (globalPackagesFolder); string hashPath = defaultPackagePathResolver.GetHashPath (packageIdentity.Id, packageIdentity.Version); if (File.Exists (hashPath)) return; var versionFolderPathContext = new VersionFolderPathContext ( packageIdentity, globalPackagesFolder, NullLogger.Instance, PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode); downloadResult.PackageStream.Position = 0; await PackageExtractor.InstallFromSourceAsync ( stream => downloadResult.PackageStream.CopyToAsync (stream, BufferSize, token), versionFolderPathContext, token); }
/// <summary> /// Sets <param name="targetPackageStream"></param> for a given <param name="packageIdentity"></param> /// from the given <param name="sourceRepository"></param>. If successfully set, returns true. Otherwise, false /// </summary> public static async Task<bool> GetPackageStream(SourceRepository sourceRepository, PackageIdentity packageIdentity, Stream targetPackageStream, CancellationToken token) { // TODO: Tie up machine cache with CacheClient?! try { token.ThrowIfCancellationRequested(); // Step-1 : Get the download stream for packageIdentity Stream downloadStream = await GetDownloadStream(sourceRepository, packageIdentity, token); if(downloadStream == null) { return false; } token.ThrowIfCancellationRequested(); // Step-2: Copy download stream to targetPackageStream if it is not null await downloadStream.CopyToAsync(targetPackageStream); return true; } catch (Exception) { return false; } }
/// <summary> /// Clear out all versions less than the minimuim. This can be used to prevent downgrading /// </summary> public static IEnumerable<SourceDependencyInfo> RemoveAllVersionsLessThan(IEnumerable<SourceDependencyInfo> packages, PackageIdentity minimum) { var comparer = VersionComparer.VersionRelease; return packages.Where(p => !StringComparer.OrdinalIgnoreCase.Equals(minimum.Id, p.Id) || (StringComparer.OrdinalIgnoreCase.Equals(minimum.Id, p.Id) && comparer.Compare(p.Version, minimum.Version) >= 0)); }
public async Task TestFolderNuGetProjectInstall() { // Arrange var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder(); var packageFileInfo = TestPackages.GetLegacyTestPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder(); var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath); var packagePathResolver = new PackagePathResolver(randomTestDestinationPath); var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity); var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity)); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using(var packageStream = packageFileInfo.OpenRead()) { // Act await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } // Assert Assert.True(File.Exists(nupkgFilePath)); Assert.True(File.Exists(Path.Combine(packageInstallPath, "lib/test.dll"))); using(var packageStream = File.OpenRead(nupkgFilePath)) { var zipArchive = new ZipArchive(packageStream); Assert.Equal(5, zipArchive.Entries.Count); } // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath); }
private async ThreadingTask InstallFromStream(Task<Stream> getStream, PackageIdentity package, string packagesFolder, CancellationToken token) { bool isValid = true; if (OfflineFeedUtility.PackageExists(package, packagesFolder, out isValid)) { return; } var logger = new NugetMsBuildLogger(new TaskLoggingHelper(this)); var versionFolderPathContext = new VersionFolderPathContext( package, packagesFolder, isLowercasePackagesDirectory: false, logger: logger, packageSaveMode: PackageSaveMode.Defaultv3, xmlDocFileSaveMode: XmlDocFileSaveMode.None); await PackageExtractor.InstallFromSourceAsync( async dest => { var source = await getStream; await source.CopyToAsync(dest, bufferSize: DefaultBufferSize, cancellationToken: token); }, versionFolderPathContext, token); }
private static void CheckIfPackageCanBeUninstalled(PackageIdentity packageIdentity, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependenciesDict, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependentsDict, UninstallationContext uninstallationContext, HashSet<PackageIdentity> packagesMarkedForUninstall) { HashSet<PackageIdentity> dependents; if (dependentsDict.TryGetValue(packageIdentity, out dependents) && dependents != null) { if (!uninstallationContext.ForceRemove) { var unMarkedDependents = dependents.Where(d => !packagesMarkedForUninstall.Contains(d)).ToList(); if (unMarkedDependents.Count > 0) { throw CreatePackageHasDependentsException(packageIdentity, unMarkedDependents); } } } HashSet<PackageIdentity> dependencies; if (uninstallationContext.RemoveDependencies && dependenciesDict.TryGetValue(packageIdentity, out dependencies) && dependencies != null) { foreach(var dependency in dependencies) { CheckIfPackageCanBeUninstalled(dependency, dependenciesDict, dependentsDict, uninstallationContext, packagesMarkedForUninstall); } } }
public override async Task<Stream> GetStream(PackageIdentity identity, CancellationToken token) { Stream result = null; IPackage package = null; SemanticVersion version = SemanticVersion.Parse(identity.Version.ToString()); // attempt a normal lookup first if (!V2Client.TryFindPackage(identity.Id, version, out package)) { // skip further look ups for online repos DataServicePackageRepository v2Online = V2Client as DataServicePackageRepository; if (v2Online == null) { IVersionComparer versionComparer = VersionComparer.VersionRelease; // otherwise search further to find the package - this is needed for v2 non-normalized versions V2Client.FindPackagesById(identity.Id).Any(p => versionComparer.Equals(identity.Version, NuGetVersion.Parse(p.ToString()))); } } if (package != null) { result = package.GetStream(); } return result; }
public PackageOperationEventArgs(string installPath, PackageIdentity package, string fileSystemRoot) { Package = package; InstallPath = installPath; //FileSystem = fileSystem; FileSystemRoot = fileSystemRoot; }
public static IDictionary<PackageIdentity, HashSet<PackageIdentity>> GetPackageDependents(IEnumerable<PackageDependencyInfo> dependencyInfoEnumerable, IEnumerable<PackageIdentity> installedPackages, out IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependenciesDict) { Dictionary<PackageIdentity, HashSet<PackageIdentity>> dependentsDict = new Dictionary<PackageIdentity, HashSet<PackageIdentity>>(PackageIdentity.Comparer); dependenciesDict = new Dictionary<PackageIdentity, HashSet<PackageIdentity>>(PackageIdentity.Comparer); foreach (var dependencyInfo in dependencyInfoEnumerable) { var packageIdentity = new PackageIdentity(dependencyInfo.Id, dependencyInfo.Version); foreach(var dependency in dependencyInfo.Dependencies) { var dependencyPackageIdentity = installedPackages.Where(i => dependency.Id.Equals(i.Id, StringComparison.OrdinalIgnoreCase) && dependency.VersionRange.Satisfies(i.Version)).FirstOrDefault(); if(dependencyPackageIdentity != null) { // Update the package dependents dictionary HashSet<PackageIdentity> dependents; if(!dependentsDict.TryGetValue(dependencyPackageIdentity, out dependents)) { dependentsDict[dependencyPackageIdentity] = dependents = new HashSet<PackageIdentity>(PackageIdentity.Comparer); } dependents.Add(packageIdentity); // Update the package dependencies dictionary HashSet<PackageIdentity> dependencies; if(!dependenciesDict.TryGetValue(packageIdentity, out dependencies)) { dependenciesDict[packageIdentity] = dependencies = new HashSet<PackageIdentity>(PackageIdentity.Comparer); } dependencies.Add(dependencyPackageIdentity); } } } return dependentsDict; }
public async Task<ActionResult> Index() { TestModel model = new TestModel(); model.Result = new List<string>(); var provider = RepositoryFactory.CreateProvider(new string[] { "https://api.nuget.org/v3/index.json", "https://nuget.org/api/v2" }); var id = new PackageIdentity("newtonsoft.json", NuGetVersion.Parse("6.0.4")); foreach (var source in provider.GetRepositories()) { var resource = await source.GetResourceAsync<DownloadResource>(); var uri = await resource.GetDownloadUrl(id); var stream = await resource.GetStream(id, CancellationToken.None); } model.Result.Add("DownloadResource"); foreach (var source in provider.GetRepositories()) { var resource = await source.GetResourceAsync<UISearchResource>(); var results = await resource.Search("elmah", new SearchFilter(), 0, 10, CancellationToken.None); } model.Result.Add("UISearchResource"); return View(model); }
/// <summary> /// Retrieve dependency info for a single package. /// </summary> /// <param name="package">package id and version</param> /// <param name="projectFramework">project target framework. This is used for finding the dependency group</param> /// <param name="token">cancellation token</param> /// <returns> /// Returns dependency info for the given package if it exists. If the package is not found null is /// returned. /// </returns> public override async Task<SourcePackageDependencyInfo> ResolvePackage(PackageIdentity package, NuGetFramework projectFramework, CancellationToken token) { try { SourcePackageDependencyInfo result = null; // Construct the registration index url var uri = _regResource.GetUri(package.Id); // Retrieve the registration blob var singleVersion = new VersionRange(minVersion: package.Version, includeMinVersion: true, maxVersion: package.Version, includeMaxVersion: true); var regInfo = await ResolverMetadataClient.GetRegistrationInfo(_client, uri, singleVersion, projectFramework, token); // regInfo is null if the server returns a 404 for the package to indicate that it does not exist if (regInfo != null) { // Parse package and dependeny info from the blob result = GetPackagesFromRegistration(regInfo, token).FirstOrDefault(); } return result; } catch (Exception ex) { // Wrap exceptions coming from the server with a user friendly message var error = String.Format(CultureInfo.CurrentUICulture, Strings.Protocol_PackageMetadataError, package, _source); throw new NuGetProtocolException(error, ex); } }
/// <summary> /// Basic search /// </summary> public override async Task<IEnumerable<SimpleSearchMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken) { var results = new List<SimpleSearchMetadata>(); foreach (var result in await _rawSearch.Search(searchTerm, filters, skip, take, cancellationToken)) { var version = NuGetVersion.Parse(result["version"].ToString()); var identity = new PackageIdentity(result["id"].ToString(), version); var description = result["description"].ToString(); var allVersions = new List<NuGetVersion>(); foreach (var versionObj in ((JArray)result["versions"])) { allVersions.Add(NuGetVersion.Parse(versionObj["version"].ToString())); } var data = new SimpleSearchMetadata(identity, description, allVersions); results.Add(data); } return results; }
public Task<PackageDownloadMetadata> GetNupkgUrlForDownload(PackageIdentity identity) { //*TODOs: Temp implementation. Need to do erorr handling and stuff. return Task.Factory.StartNew(() => { if(V2Client is DataServicePackageRepository) { //TODOs:Not sure if there is some other standard way to get the Url from a dataservice repo. DataServicePackage has downloadurl property but not sure how to get it. return new PackageDownloadMetadata(new Uri(Path.Combine(V2Client.Source, "api/v2/" + identity.Id + "." + identity.Version + ".nupkg"))); } else if(V2Client is LocalPackageRepository) { LocalPackageRepository lrepo = V2Client as LocalPackageRepository; SemanticVersion semVer = new SemanticVersion(identity.Version.Version); return new PackageDownloadMetadata(new Uri(Path.Combine(V2Client.Source, lrepo.PathResolver.GetPackageFileName(identity.Id, semVer)))); } else { // TODO: move the string into a resoure file throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, "Unable to get download metadata for package {0}",identity.Id)); } }); }
/// <summary> /// Remove all versions of a package id from the list, except for the target version /// </summary> public static IEnumerable<SourceDependencyInfo> RemoveAllVersionsForIdExcept(IEnumerable<SourceDependencyInfo> packages, PackageIdentity target) { var comparer = VersionComparer.VersionRelease; return packages.Where(p => !StringComparer.OrdinalIgnoreCase.Equals(target.Id, p.Id) || (StringComparer.OrdinalIgnoreCase.Equals(target.Id, p.Id) && comparer.Equals(p.Version, target.Version))); }
public override Task InstallPackage( PackageIdentity id, IEnumerable<FrameworkName> packageSupportedFrameworks, IExecutionLogger logger, CancellationToken cancelToken) { var args = new Dictionary<string, object>(); var projectFrameworks = _nugetAwareProject.GetSupportedFrameworksAsync(cancelToken).Result; args["Frameworks"] = projectFrameworks.Where( projectFramework => NuGet.VersionUtility.IsCompatible( projectFramework, packageSupportedFrameworks)).ToArray(); var task = _nugetAwareProject.InstallPackageAsync( new NuGetPackageMoniker { Id = id.Id, Version = id.Version.ToString() }, args, logger: null, progress: null, cancellationToken: cancelToken); return task; }
public async Task GetCachedPackageInfo(string PackageID) { NuGetFactory factory = new NuGetFactory("NuGet", "https://api.nuget.org/v3/index.json"); var metaResource = await factory.GetUIMetadata(); var searchResource = await factory.GetSearch(); var packageMeta = await searchResource.Search(PackageID, new SearchFilter { IncludePrerelease = true }, 0, 100, CancellationToken.None); var packagesFound = packageMeta.Where(x => x.Identity.Id.Equals(PackageID, StringComparison.InvariantCultureIgnoreCase)).ToList(); Assert.False(packagesFound.Count == 0); Assert.True(packagesFound.Count > 0); var nugetPackage = packagesFound.First(); var versions = await (await factory.GetMetadata()).GetVersions(PackageID, CancellationToken.None); foreach (var version in versions) { var versionIdentity = new PackageIdentity(nugetPackage.Identity.Id, version); var meta = await metaResource.GetMetadata(versionIdentity, CancellationToken.None); foreach (var item in meta.DependencySets) { Assert.NotNull(item.TargetFramework.Framework); } } }
/// <summary> /// Install package by Identity /// </summary> /// <param name="project"></param> /// <param name="identity"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null) { List<NuGetProjectAction> actions = new List<NuGetProjectAction>(); // For Install-Package -Force if (isForce) { PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p => StringComparer.OrdinalIgnoreCase.Equals(identity.Id, p.PackageIdentity.Id)).FirstOrDefault(); if (installedReference != null) { actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, installedReference.PackageIdentity, uninstallContext, projectContext, CancellationToken.None)); } NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identity, ActiveSourceRepository); actions.Add(installAction); } else { actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None)); } if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); } }
public async Task<IPackageSearchMetadata> GetPackageMetadataAsync(PackageIdentity identity, bool includePrerelease, CancellationToken cancellationToken) { var tasks = _sourceRepositories .Select(r => r.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken)) .ToList(); if (_localRepository != null) { tasks.Add(_localRepository.GetPackageMetadataFromLocalSourceAsync(identity, cancellationToken)); } var ignored = tasks .Select(task => task.ContinueWith(LogError, TaskContinuationOptions.OnlyOnFaulted)) .ToArray(); var completed = (await Task.WhenAll(tasks)) .Where(m => m != null); var master = completed.FirstOrDefault(m => !string.IsNullOrEmpty(m.Summary)) ?? completed.FirstOrDefault() ?? PackageSearchMetadataBuilder.FromIdentity(identity).Build(); return master.WithVersions( asyncValueFactory: () => MergeVersionsAsync(identity, completed)); }
public async Task TestUninstallLastPackage() { // Arrange var randomTestFolder = TestFilesystemUtility.CreateRandomTestFolder(); var packagesConfigFileName = "packages.config"; var targetFramework = NuGetFramework.Parse("net45"); var metadata = new Dictionary<string, object>() { { NuGetProjectMetadataKeys.TargetFramework, targetFramework}, }; var packagesConfigFullPath = Path.Combine(randomTestFolder, packagesConfigFileName); var packagesConfigNuGetProject = new PackagesConfigNuGetProject(packagesConfigFullPath, metadata); var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.0.0")); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; MakeFileReadOnly(packagesConfigFullPath); // Act await packagesConfigNuGetProject.InstallPackageAsync(packageIdentity, Stream.Null, testNuGetProjectContext, token); MakeFileReadOnly(packagesConfigFullPath); // Assert var installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, installedPackagesList.Count); Assert.Equal(packageIdentity, installedPackagesList[0].PackageIdentity); Assert.Equal(targetFramework, installedPackagesList[0].TargetFramework); // Main Act await packagesConfigNuGetProject.UninstallPackageAsync(packageIdentity, testNuGetProjectContext, token); // Main Assert installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, installedPackagesList.Count); }
public override async Task<IEnumerable<ServerPackageMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken) { List<ServerPackageMetadata> results = new List<ServerPackageMetadata>(); var searchResultJsonObjects = await _searchResource.Search(searchTerm, filters, skip, take, cancellationToken); foreach (JObject package in searchResultJsonObjects) { // TODO: verify this parsing is needed string id = package.Value<string>(Properties.PackageId); NuGetVersion version = NuGetVersion.Parse(package.Value<string>(Properties.Version)); PackageIdentity topPackage = new PackageIdentity(id, version); Uri iconUrl = GetUri(package, Properties.IconUrl); string summary = package.Value<string>(Properties.Summary); if (string.IsNullOrWhiteSpace(summary)) { // summary is empty. Use its description instead. summary = package.Value<string>(Properties.Description); } // retrieve metadata for the top package results.Add(PackageMetadataParser.ParseMetadata(package)); } return results; }
void CreatePackageReferenceNode ( bool installed = true, bool installPending = false, PackageIdentity updatedPackage = null) { node = new PackageReferenceNode (null, packageReference, installed, installPending, updatedPackage); }
public UIPackageMetadata( PackageIdentity identity, string title, string summary, string description, string authors, string owners, Uri iconUrl, Uri licenseUrl, Uri projectUrl, Uri reportAbuseUrl, string tags, DateTimeOffset? published, IEnumerable<PackageDependencyGroup> dependencySet, bool requireLicenseAccept, int? downloadCount) { Identity = identity; Summary = summary; Description = description; Authors = authors; Owners = owners; IconUrl = iconUrl; LicenseUrl = licenseUrl; ProjectUrl = projectUrl; ReportAbuseUrl = reportAbuseUrl; Description = description; Summary = summary; Tags = tags; DependencySets = dependencySet; RequireLicenseAcceptance = requireLicenseAccept; Title = title; DownloadCount = downloadCount; }
private IEnumerable<PackageIdentity> GetConsolidatedPackageIdentityForResolver() { PackageIdentity identity = null; // If Version is specified by commandline parameter if (!string.IsNullOrEmpty(Version)) { NuGetVersion nVersion = PowerShellPackage.GetNuGetVersionFromString(Version); PackageIdentity pIdentity = new PackageIdentity(Id, nVersion); identity = Client.PackageRepositoryHelper.ResolvePackage(V2LocalRepository, pIdentity, true); } else { VsProject target = this.GetProject(true); InstalledPackageReference installedPackage = GetInstalledReference(target, Id); if (installedPackage == null) { Log(MessageLevel.Error, Resources.Cmdlet_PackageNotInstalled, Id); } else { identity = installedPackage.Identity; Version = identity.Version.ToNormalizedString(); } } return new List<PackageIdentity>() { identity }; }
public async Task<IEnumerable<PackageAction>> ResolveActionsAsync( PackageIdentity packageIdentity, PackageActionType operation, InstallationTarget target) { // Construct the Action Resolver var oldResolver = new OldResolver(); if (Logger != null) { oldResolver.Logger = new ShimLogger(Logger); } // Apply context settings ApplyContext(oldResolver); var packageManager = target.GetRequiredFeature<IPackageManager>(); var nullProjectManager = new NullProjectManager( new CoreInteropPackageManager( packageManager.LocalRepository, _dependencyResolver, new CoreInteropSourceRepository(_source))); oldResolver.AddOperation( MapNewToOldActionType(operation), await CreateVirtualPackage(packageIdentity.Id, packageIdentity.Version), nullProjectManager); // Resolve actions! var actions = await Task.Factory.StartNew(() => oldResolver.ResolveActions()); // Convert the actions var converted = from action in actions select new PackageAction( MapOldToNewActionType(action.ActionType), new PackageIdentity( action.Package.Id, new NuGetVersion( action.Package.Version.Version, action.Package.Version.SpecialVersion)), UnwrapPackage(action.Package), target, _source, packageIdentity); // Identify update operations so we can mark them as such. foreach (var group in converted.GroupBy(c => c.PackageIdentity.Id)) { var installs = group.Where(p => p.ActionType == PackageActionType.Install).ToList(); var uninstalls = group.Where(p => p.ActionType == PackageActionType.Uninstall).ToList(); if (installs.Count > 0 && uninstalls.Count > 0) { var maxInstall = installs.OrderByDescending(a => a.PackageIdentity.Version).First(); maxInstall.IsUpdate = true; } } return converted; }
public override async Task<bool> Exists(PackageIdentity identity, bool includeUnlisted, CancellationToken token) { // TODO: get the url and just check the headers? var metadata = await _regResource.GetPackageMetadata(identity, token); // TODO: listed check return metadata != null; }
public void TestToString() { var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); Assert.Equal("packageA.1.0.0", packageIdentity.ToString()); var formattedString = string.Format("This is package '{0}'", packageIdentity); Assert.Equal("This is package 'packageA.1.0.0'", formattedString); }
public VsPackageMetadata(PackageIdentity package, string title, IEnumerable<string> authors, string description, string installPath) { _package = package; _installPath = installPath ?? string.Empty; _title = title ?? package.Id; _authors = authors ?? Enumerable.Empty<string>(); _description = description ?? string.Empty; }
public abstract Task InstallPackage( PackageIdentity id, // the supported frameworks of the package IEnumerable<FrameworkName> frameworks, IExecutionLogger logger, CancellationToken cancelToken);
public PackageContent(PackageIdentity identity, IEnumerable<PackageIdentity> dependencies) { Identity = identity; Dependencies = dependencies; Lib = new List<PackageFile>(); Content = new List<PackageFile>(); Plugin = new List<PackageFile>(); }
private RuntimeGraph LoadRuntimeGraph(LocalPackageInfo package) { var id = new PackageIdentity(package.Id, package.Version); return(_request.RuntimeGraphCacheByPackage.GetOrAdd(id, (x) => LoadRuntimeGraphCore(package))); }