public static INuGetResourceCollection GetResources(string baseUrl, RequestWrapper request) { object cacheLock; if (String.IsNullOrEmpty(baseUrl)) { return(NuGetResourceCollectionLocal.Make()); } if (!sessionResourceCollectionCacheLocks.ContainsKey(baseUrl)) { lock (sessionResourceCollectionCacheLocks) { if (!sessionResourceCollectionCacheLocks.ContainsKey(baseUrl)) { sessionResourceCollectionCacheLocks[baseUrl] = new object(); } } } cacheLock = sessionResourceCollectionCacheLocks[baseUrl]; lock (cacheLock) { if (!sessionResourceCollectionCache.ContainsKey(baseUrl)) { sessionResourceCollectionCache[baseUrl] = GetResourcesImpl(baseUrl, request); } } return(sessionResourceCollectionCache[baseUrl]); }
public override bool IsAvailable(RequestWrapper request) { foreach (NuGetServiceInfo endpoint in this.Endpoints) { if (IsSingleEndpointAvailable(endpoint, request)) { return(true); } } return(false); }
private IEnumerable <IPackage> FindImpl(NuGetSearchContext findContext, RequestWrapper request) { request.Debug(Messages.DebugInfoCallMethod3, "NuGetPackageFeed3", "FindImpl", findContext.PackageInfo.Id); try { return(base.Execute <IEnumerable <IPackage> >((baseUrl) => GetPackagesForBaseUrl(baseUrl, findContext, request))); } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetPackageFeed3", "FindImpl"); } }
public static IEnumerable <R> GetPageResults <B, R>(RequestWrapper request, Func <B, IEnumerable <IEnumerable <R> > > getResultsFromResponse, B response) { IEnumerable <IEnumerable <R> > resultCollections = getResultsFromResponse(response); foreach (IEnumerable <R> resultCollection in resultCollections) { foreach (R result in resultCollection) { yield return(result); } } }
public override bool IsAvailable(RequestWrapper request) { foreach (NuGetServiceInfo endpoint in this.Endpoints) { Stream s = NuGetClient.DownloadDataToStream(endpoint.Url, request); if (s != null) { return(true); } } return(false); }
public NuGetSearchResult Find(NuGetSearchContext findContext, RequestWrapper request) { request.Debug(Messages.DebugInfoCallMethod3, "NuGetPackageFeed3", "Find", findContext.PackageInfo.Id); if (System.Management.Automation.WildcardPattern.ContainsWildcardCharacters(findContext.PackageInfo.Id)) { // Short circuit when there's wildcards - this will never work return(findContext.MakeResult(new List <IPackage>())); } NuGetSearchResult result = findContext.MakeResult(FindImpl(findContext, request), versionPostFilterRequired: false); request.Debug(Messages.DebugInfoReturnCall, "NuGetPackageFeed3", "Find"); return(result); }
private bool IsSingleEndpointAvailable(NuGetServiceInfo endpoint, RequestWrapper request) { HttpClient client = request.GetClient(); HttpResponseMessage response = PathUtility.GetHttpResponse(client, endpoint.Url, (() => request.IsCanceled()), ((msg, num) => request.Verbose(Resources.Messages.RetryingDownload, msg, num)), (msg) => request.Verbose(msg), (msg) => request.Debug(msg)); if (response != null) { return(true); } else { return(false); } }
public bool InstallPackage(PublicObjectView packageView, RequestWrapper request) { try { request.Debug(Messages.DebugInfoCallMethod, "NuGetFilesFeed3", "InstallPackage"); PackageItem package = packageView.GetValue <PackageItem>(); request.Debug(Messages.DebugInfoCallMethod3, "NuGetFilesFeed3", "InstallPackage", package.FastPath); return(NuGetClient.InstallOrDownloadPackageHelper(package, request.Request, Constants.Install, (packageItem, progressTracker) => this.InstallSinglePackage(packageItem, request.Request, progressTracker))); } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetFilesFeed3", "InstallPackage"); } }
public bool InstallPackage(PublicObjectView packageView, RequestWrapper request) { try { request.Debug(Messages.DebugInfoCallMethod, "NuGetLocalPackageFeed", "InstallPackage"); PackageItem package = packageView.GetValue <PackageItem>(); request.Debug(Messages.DebugInfoCallMethod3, "NuGetLocalPackageFeed", "InstallPackage", package.FastPath); // TODO: For now this has to require NuGetRequest, due to its usage of stuff like request.GetOptionValue and request.YieldPackage return(NuGetClient.InstallOrDownloadPackageHelper(package, request.Request, Constants.Install, (packageItem, progressTracker) => NuGetClient.InstallSinglePackage(packageItem, request.Request, progressTracker))); } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetLocalPackageFeed", "InstallPackage"); } }
public NuGetSearchResult Search(NuGetSearchContext searchContext, RequestWrapper request) { request.Debug(Messages.DebugInfoCallMethod, "NuGetSearchFeed2", "Search"); if (request == null) { return(searchContext.MakeResult()); } string searchString = this.ResourcesCollection.GetSearchQueryDelegate(searchContext.SearchTerms); request.Debug(Messages.DebugInfoCallMethod3, "NuGetSearchFeed2", "Search", searchString); var searchQuery = searchString.MakeSearchQuery(this.baseUrl, searchContext.AllowPrerelease, searchContext.AllVersions); return(searchContext.MakeResult(NuGetWebUtility.SendRequest(searchQuery, request))); }
public override bool IsAvailable(RequestWrapper request) { try { // Execute a simple query against the query service. If there's no exception (the response came back successfully), the query service is up Find(new NuGetSearchContext() { PackageInfo = new PackageEntryInfo(Constants.DummyPackageId) }, request); return(true); } catch (Exception) { return(false); } }
public bool IsAvailable(RequestWrapper request) { bool valid = false; HttpClient client = request.GetClient(); string queryUri = Constants.DummyPackageId.MakeFindPackageByIdQuery(PathUtility.UriCombine(this.baseUrl, NuGetConstant.FindPackagesById)); HttpResponseMessage response = PathUtility.GetHttpResponse(client, queryUri, (() => request.IsCanceled()), ((msg, num) => request.Verbose(Resources.Messages.RetryingDownload, msg, num)), (msg) => request.Verbose(msg), (msg) => request.Debug(msg)); // The link is not valid if (response != null && response.IsSuccessStatusCode) { valid = true; } return(valid); }
private static INuGetResourceCollection GetResourcesImpl(string baseUrl, RequestWrapper request) { INuGetResourceCollection res = null; HttpClient client = request.GetClientWithHeaders(); HttpResponseMessage response = PathUtility.GetHttpResponse(client, baseUrl, (() => request.IsCanceled()), ((msg, num) => request.Verbose(Resources.Messages.RetryingDownload, msg, num)), (msg) => request.Verbose(msg), (msg) => request.Debug(msg)); if (!response.IsSuccessStatusCode) { throw new Exception(Resources.Messages.NuGetEndpointDiscoveryFailed); } string content = new StreamReader(NuGetClient.DownloadDataToStream(baseUrl, request)).ReadToEnd(); // If the response starts with the magic XML header, it's v2 if (content.StartsWith(Constants.XmlStartContent)) { res = NuGetResourceCollection2.Make(baseUrl); } else { try { dynamic root = DynamicJsonParser.Parse(content); string version = root.version; if (version != null && version.StartsWith("3.")) { // v3 feed res = NuGetResourceCollection3.Make(root, baseUrl, request); } } catch (Exception ex) { Exception discoveryException = new Exception(Resources.Messages.NuGetEndpointDiscoveryFailed, ex); throw discoveryException; } } if (res == null) { // Couldn't figure out what this is throw new Exception(Resources.Messages.NuGetEndpointDiscoveryFailed); } return(res); }
public PackageEntryInfo GetVersionInfo(PackageEntryInfo packageInfo, RequestWrapper request) { try { request.Debug(Messages.DebugInfoCallMethod, "NuGetFilesFeed3", "GetVersionInfo"); if (packageInfo == null) { throw new ArgumentNullException("packageInfo"); } if (request == null) { throw new ArgumentNullException("request"); } string query = String.Format(CultureInfo.InvariantCulture, Constants.VersionIndexTemplate, this.baseUrl, this.baseUrl.EndsWith("/") ? String.Empty : "/", packageInfo.Id.ToLowerInvariant()); Stream queryResponse = NuGetClient.DownloadDataToStream(query, request, ignoreNullResponse: true); if (queryResponse != null) { dynamic root = DynamicJsonParser.Parse(new StreamReader(queryResponse).ReadToEnd()); if (root.HasProperty("versions")) { foreach (string v in root.versions) { packageInfo.AddVersion(new SemanticVersion(v)); } } else { request.Debug(Messages.VersionIndexDownloadFailed, packageInfo.Id); } } else { request.Debug(Messages.VersionIndexDownloadFailed, packageInfo.Id); } } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetFilesFeed3", "GetVersionInfo"); } return(packageInfo); }
public NuGetSearchResult Search(NuGetSearchContext searchContext, RequestWrapper request) { // This is a search scenario, so it should be safe to skip some metadata for the sake of performance searchContext.EnableDeepMetadataBypass = true; return(base.Execute <NuGetSearchResult>((baseUrl) => { // For now we'll just get all versions and return the latest HttpQueryBuilder qb = new HttpQueryBuilder(); // Once searchTermQb encodes the searchTerm, don't encode the ":" part of the resulting string qb.Add(Constants.QueryQueryParam, this.ResourcesCollection.GetSearchQueryDelegate(searchContext.SearchTerms), separator: "=", encode: false).Add(Constants.TakeQueryParam, Constants.SearchPageCount) .Add(Constants.SemVerLevelQueryParam, Constants.SemVerLevel2); if (searchContext.AllowPrerelease) { qb.Add(Constants.PrereleaseQueryParam, "true"); } NuGetSearchTerm searchTerm = searchContext.SearchTerms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.SearchTerm).FirstOrDefault(); IEnumerable <IPackage> packages = SearchPackagesWithBackup(baseUrl, qb, request, searchContext, searchTerm); return searchContext.MakeResult(packages, versionPostFilterRequired: true, namePostFilterRequired: false, containsPostFilterRequired: false); })); }
public NuGetSearchResult Find(NuGetSearchContext findContext, RequestWrapper request) { if (string.IsNullOrWhiteSpace(findContext.PackageInfo.Id)) { return(null); } request.Debug(Messages.DebugInfoCallMethod3, "NuGetPackageFeed2", "FindPackage", findContext.PackageInfo.Id); var query = findContext.PackageInfo.Id.MakeFindPackageByIdQuery(this.nugetFindPackageIdQueryFormat); var packages = NuGetClient.FindPackage(query, request).Where(package => findContext.PackageInfo.Id.Equals(package.Id, StringComparison.OrdinalIgnoreCase)); if (findContext.RequiredVersion != null) { //Usually versions has a limited number, ToArray should be ok. var versions = findContext.RequiredVersion.GetComparableVersionStrings().ToArray(); packages = packages.Where(package => versions.Contains(package.Version, StringComparer.OrdinalIgnoreCase)); } //Will only enumerate packages once return(findContext.MakeResult(packages)); }
private PackageBase GetPackageFromCatalogUrl(string catalogUrl, RequestWrapper request, HashSet <SemanticVersion> packageSemanticVersions, NuGetSearchContext context) { Stream catalogResponseStream = NuGetClient.DownloadDataToStream(catalogUrl, request); if (catalogResponseStream != null) { string content = new StreamReader(catalogResponseStream).ReadToEnd(); dynamic catalogContent = DynamicJsonParser.Parse(content); if ((packageSemanticVersions == null || packageSemanticVersions.Contains(new SemanticVersion(catalogContent.version)))) { PackageBase pb = this.ResourcesCollection.PackageConverter.Make(DynamicJsonParser.Parse(content), context.PackageInfo); if (pb != null) { return(pb); } } } else { request.Warning(Messages.CouldNotGetResponseFromQuery, catalogUrl); } return(null); }
/// <summary> /// Find packages when the registration URL is already known. /// </summary> /// <param name="registrationUrl"></param> /// <param name="request"></param> /// <returns></returns> internal IEnumerable <PackageBase> Find(string registrationUrl, NuGetSearchContext context, RequestWrapper request, bool finalAttempt) { request.Debug(Messages.DebugInfoCallMethod3, "NuGetPackageFeed3", "Find", registrationUrl); List <PackageBase> packages = null; PackageBase cachedPackage; if (!registrationUrl.Contains("index.json") && ConcurrentInMemoryCache.Instance.TryGet <PackageBase>(registrationUrl, out cachedPackage)) { if (cachedPackage == null) { return(packages); } else { packages = new List <PackageBase>() { cachedPackage }; return(packages); } } Stream s = NuGetClient.DownloadDataToStream(registrationUrl, request, ignoreNullResponse: true, tries: 1); if (s != null) { packages = new List <PackageBase>(); // Now we can get the catalog entry dynamic root = DynamicJsonParser.Parse(new StreamReader(s).ReadToEnd()); if (root.Metadata.HasProperty("type")) { // First check if this is a Package or PackageRegistration type // Package is from packageId + version // PackageRegistration is from packageId bool isRegistrationType = false; foreach (string t in root.Metadata.type) { if (t.Equals("PackageRegistration", StringComparison.OrdinalIgnoreCase)) { isRegistrationType = true; break; } } if (context.PackageInfo.AllVersions.Count == 0) { // Only when the version list is restricted is this method usually faster this.ResourcesCollection.FilesFeed.GetVersionInfo(context.PackageInfo, request); } HashSet <SemanticVersion> packageSemanticVersions = null; if (context.PackageInfo.AllVersions.Count > 0) { packageSemanticVersions = FilterVersionsByRequirements(context, context.PackageInfo); } if (isRegistrationType) { // This is a registration index, like: "https://api.nuget.org/v3/registration3/json/index.json" // Get all versions from files service // In addition, when DeepMetadataBypass is enabled, we MUST use the registration index to get package info // If a call to -Name -RequiredVersion is done, DeepMetadataBypass will never be enabled (for now) // If we wanted, we could enable this by checking if !isRegistrationType && context.EnableDeepMetadataBypass, then call into Find with the registration index URL if (!context.AllVersions && packageSemanticVersions != null && !context.EnableDeepMetadataBypass) { foreach (SemanticVersion packageVersion in packageSemanticVersions) { NuGetSearchResult result = this.ResourcesCollection.PackagesFeed.Find(new NuGetSearchContext() { PackageInfo = context.PackageInfo, RequiredVersion = packageVersion, EnableDeepMetadataBypass = context.EnableDeepMetadataBypass }, request); PackageBase package = result.Result == null ? null : result.Result.FirstOrDefault() as PackageBase; if (package != null) { packages.Add(package); } } } else { // Going to collect versions from the registration index in here // Map of package version -> either PackageBase (if context.EnableDeepMetadataBypass) or catalog URL Dictionary <SemanticVersion, object> catalogObjects = new Dictionary <SemanticVersion, object>(); // If the version list hasn't been built yet, we can build it from the registration page instead of using FilesFeed bool buildPackageInfoVersions = context.PackageInfo.AllVersions.Count == 0; // Fallback to catalog crawling in these cases: // - Bypass deep metadata // - Getting version list failed // - All versions required foreach (dynamic catalogPage in root.items) { dynamic actualCatalogPage = catalogPage; if (!actualCatalogPage.HasProperty("items")) { // Sometimes the catalog page on the PackageRegistration entry doesn't have the actual page contents // In this case, the ID metadata tag points to the full catalog entry Stream fullCatalogPageResponseStream = NuGetClient.DownloadDataToStream(actualCatalogPage.Metadata.id, request); if (fullCatalogPageResponseStream != null) { actualCatalogPage = DynamicJsonParser.Parse(new StreamReader(fullCatalogPageResponseStream).ReadToEnd()); } } foreach (dynamic packageEntry in actualCatalogPage.items) { SemanticVersion version = new SemanticVersion(packageEntry.catalogentry.version); if (buildPackageInfoVersions) { context.PackageInfo.AddVersion(version); } bool hasCatalogEntry = packageEntry.HasProperty("catalogentry"); if (context.EnableDeepMetadataBypass || !hasCatalogEntry) { // Bypass retrieving "deep" (but required) metadata like packageHash // Also do this if there's no catalog entry PackageBase pb = null; if (packageEntry.HasProperty("catalogentry")) { pb = this.ResourcesCollection.PackageConverter.Make(packageEntry.catalogentry, context.PackageInfo); } else { // In some implementations (lookin' at you MyGet) there's no catalogEntry object pb = this.ResourcesCollection.PackageConverter.Make(packageEntry, context.PackageInfo); } if (pb != null) { catalogObjects[version] = pb; } } else { catalogObjects[version] = this.ResourcesCollection.CatalogUrlConverter.Make(packageEntry); } } } packageSemanticVersions = FilterVersionsByRequirements(context, context.PackageInfo); foreach (SemanticVersion version in packageSemanticVersions) { if (!catalogObjects.ContainsKey(version)) { continue; } if (context.EnableDeepMetadataBypass) { packages.Add((PackageBase)catalogObjects[version]); } else { PackageBase pb = GetPackageFromCatalogUrl((string)catalogObjects[version], request, packageSemanticVersions, context); if (pb != null) { packages.Add(pb); } } } } } else { // In some implementations (lookin' at you MyGet) there's no catalogEntry object PackageBase pb = ConcurrentInMemoryCache.Instance.GetOrAdd <PackageBase>(registrationUrl, () => { if (!root.HasProperty("catalogentry")) { if ((packageSemanticVersions == null || packageSemanticVersions.Contains(new SemanticVersion(root.version)))) { return(this.ResourcesCollection.PackageConverter.Make(root)); } else { return(null); } } else { return(GetPackageFromCatalogUrl(this.ResourcesCollection.CatalogUrlConverter.Make(root), request, packageSemanticVersions, context)); } }); if (pb != null) { packages.Add(pb); } } } else { request.Warning(Messages.JsonSchemaMismatch, "type"); request.Debug(Messages.JsonObjectDump, DynamicJsonParser.Serialize(root)); } if (context.RequiredVersion == null && context.MinimumVersion == null && context.MaximumVersion == null && packages != null) { PackageBase absoluteLatestPackage = packages.Where(p => p.IsPrerelease).OrderByDescending(pb => ((IPackage)pb).Version).FirstOrDefault(); if (absoluteLatestPackage != null) { absoluteLatestPackage.IsAbsoluteLatestVersion = true; } PackageBase latestPackage = packages.Where(p => !p.IsPrerelease).OrderByDescending(pb => ((IPackage)pb).Version).FirstOrDefault(); if (latestPackage != null) { latestPackage.IsLatestVersion = true; } } } else if (finalAttempt) { // This is the last retry of this URL. It's definitely not a good one. ConcurrentInMemoryCache.Instance.GetOrAdd <PackageBase>(registrationUrl, () => null); } return(packages); }
public IEnumerable <string> Autocomplete(NuGetSearchTerm autocompleteSearchTerm, RequestWrapper request, bool allowPrerelease) { return(Autocomplete(autocompleteSearchTerm, request, acceptedPattern: null, allowPrerelease: allowPrerelease)); }
private IEnumerable <IPackage> GetPackagesForBaseUrl(string baseUrl, NuGetSearchContext findContext, RequestWrapper request) { bool urlHit = false; int attempts = 3; while (!urlHit && attempts-- > 0) { foreach (string candidateUrl in GetCandidateUrls(findContext.PackageInfo.Id, findContext.RequiredVersion, baseUrl)) { IEnumerable <IPackage> packages = Find(candidateUrl, findContext, request, attempts == 0); if (packages != null) { urlHit = true; foreach (IPackage package in packages) { yield return(package); } break; } } } }
public static NuGetResourceCollection3 Make(dynamic root, string baseUrl, RequestWrapper request) { request.Debug(Messages.DebugInfoCallMethod3, "NuGetResourceCollection3", "Make", baseUrl); NuGetResourceCollection3 collection = new NuGetResourceCollection3(); Dictionary <NuGetServiceType, NuGetServiceInfo> currentServiceMap = new Dictionary <NuGetServiceType, NuGetServiceInfo>(); foreach (dynamic resourceElement in root.resources) { NuGetServiceInfo serviceInfo = NuGetServiceInfo.GetV3Endpoint(resourceElement); if (serviceInfo == null) { continue; } bool serviceUsed = currentServiceMap.ContainsKey(serviceInfo.Type) && currentServiceMap[serviceInfo.Type].Preference <= serviceInfo.Preference; bool serviceSupplement = currentServiceMap.ContainsKey(serviceInfo.Type) && currentServiceMap[serviceInfo.Type].Preference == serviceInfo.Preference; switch (serviceInfo.Type) { case NuGetServiceType.AutoComplete: // No feed yet OR no version (lowest possible stable version) OR greater version if (serviceUsed || collection.AutoCompleteFeed == null) { serviceUsed = true; if (serviceSupplement) { ((NuGetAutoCompleteFeed3)collection.AutoCompleteFeed).Endpoints.Add(serviceInfo); } else { collection.AutoCompleteFeed = new NuGetAutoCompleteFeed3(serviceInfo); } } break; case NuGetServiceType.Registrations: if (serviceUsed || collection.PackagesFeed == null) { serviceUsed = true; if (serviceSupplement) { ((NuGetPackageFeed3)collection.PackagesFeed).Endpoints.Add(serviceInfo); } else { collection.PackagesFeed = new NuGetPackageFeed3(serviceInfo); } } break; case NuGetServiceType.Query: if (serviceUsed || collection.QueryFeed == null) { serviceUsed = true; if (serviceSupplement) { ((NuGetQueryFeed3)collection.QueryFeed).Endpoints.Add(serviceInfo); } else { collection.QueryFeed = new NuGetQueryFeed3(serviceInfo); } } break; case NuGetServiceType.Files: if (serviceUsed || collection.FilesFeed == null) { serviceUsed = true; collection.FilesFeed = new NuGetFilesFeed3(serviceInfo.Url); } break; case NuGetServiceType.ReportAbuse: if (serviceUsed || collection.AbuseFeed == null) { serviceUsed = true; collection.AbuseFeed = new NuGetAbuseFeed3(serviceInfo.Url); } break; } if (serviceUsed) { request.Debug(Messages.NuGetEndpointDiscovered, serviceInfo.Type, serviceInfo.Url); if (!serviceSupplement) { currentServiceMap[serviceInfo.Type] = serviceInfo; } } } collection.GetSearchQueryDelegate = (searchTerms) => { string searchString = String.Empty; // TODO: encode search terms? foreach (NuGetSearchTerm searchTerm in searchTerms) { switch (searchTerm.Term) { case NuGetSearchTerm.NuGetSearchTermType.SearchTerm: searchString += searchTerm.Text; break; case NuGetSearchTerm.NuGetSearchTermType.Tag: HttpQueryBuilder tQb = new HttpQueryBuilder().Add(Constants.TagQueryParam, searchTerm.Text, separator: ":", encode: false); searchString += " " + tQb.ToQueryString(); break; case NuGetSearchTerm.NuGetSearchTermType.Contains: HttpQueryBuilder cQb = new HttpQueryBuilder().Add(Constants.DescriptionQueryParam, searchTerm.Text, separator: ":", encode: false); searchString += " " + cQb.ToQueryString(); break; default: break; } } return(searchString.Trim()); }; collection.PackageConverter = new PackageBaseConverter(); collection.PackageDependencyConverter = new PackageDependencyConverter(); collection.PackageDependencySetConverter = new DependencyGroupConverter(); collection.CatalogUrlConverter = new CatalogUrlConverter(); Uri uri = new Uri(baseUrl); if (uri.Host.Contains(Constants.NuGetOrgHost)) { collection.GalleryFeed = new NuGetGalleryFeedOrg(); } else if (uri.Host.Contains(Constants.MyGetOrgHost)) { collection.GalleryFeed = new NuGetGalleryFeedMyGet(baseUrl); } request.Debug(Messages.DebugInfoReturnCall, "NuGetResourceCollection3", "Make"); return(collection); }
private IEnumerable <IEnumerable <PackageBase> > GetPackageCollectionsForSearchResult(dynamic searchResult, NuGetSearchContext searchContext, NuGetSearchTerm searchTerm, HashSet <string> foundPackageIds, RequestWrapper request) { if (searchResult.HasProperty("data")) { foreach (dynamic packageEntry in searchResult.data) { foundPackageIds.Add(packageEntry.id); yield return(GetPackagesForPackageEntry(packageEntry, searchContext, request)); } } }
public NuGetSearchResult Find(NuGetSearchContext findContext, RequestWrapper request) { throw new NotImplementedException(); }
private IEnumerable <IPackage> SearchPackagesWithBackup(string baseUrl, HttpQueryBuilder qb, RequestWrapper request, NuGetSearchContext searchContext, NuGetSearchTerm searchTerm) { // First execute the actual search HashSet <string> foundPackageIds = new HashSet <string>(); return(NuGetWebUtility.GetResults <dynamic, PackageBase>(request, (dynamic root) => { long res = -1; if (root.HasProperty("totalhits")) { res = root.totalhits; request.Debug(Resources.Messages.TotalPackagesDiscovered, res); } else { request.Warning(Resources.Messages.JsonSchemaMismatch, "totalhits"); request.Debug(Resources.Messages.JsonObjectDump, DynamicJsonParser.Serialize(root)); } return res; }, (dynamic root) => GetPackageCollectionsForSearchResult(root, searchContext, searchTerm, foundPackageIds, request), (long packagesToSkip) => { if (packagesToSkip > 0) { HttpQueryBuilder currentQb = qb.CloneAdd(Constants.SkipQueryParam, packagesToSkip.ToString()); return currentQb.AddQueryString(baseUrl); } return qb.AddQueryString(baseUrl); }, (string content) => { return DynamicJsonParser.Parse(content); }, Constants.SearchPageCountInt)); }
public bool IsAvailable(RequestWrapper request) { return(true); }
public PackageEntryInfo GetVersionInfo(PackageEntryInfo packageInfo, RequestWrapper request) { throw new NotImplementedException(); }
public bool DownloadPackage(PublicObjectView packageView, string destination, RequestWrapper request) { try { request.Debug(Messages.DebugInfoCallMethod3, "NuGetFilesFeed3", "DownloadPackage", destination); PackageItem package = packageView.GetValue <PackageItem>(); // TODO: For now this has to require NuGetRequest, due to its usage of stuff like request.GetOptionValue and request.YieldPackage return(NuGetClient.InstallOrDownloadPackageHelper(package, request.Request, Constants.Install, (packageItem, progressTracker) => this.DownloadSinglePackage(packageItem, request.Request, destination, progressTracker))); } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetFilesFeed3", "DownloadPackage"); } }
public bool IsAvailable(RequestWrapper request) => true;
private IEnumerable <PackageBase> GetPackagesForPackageEntry(dynamic packageEntry, NuGetSearchContext searchContext, RequestWrapper request) { PackageEntryInfo packageEntryInfo = new PackageEntryInfo(packageEntry.id); if (!PackageFilterUtility.IsValidByName(packageEntryInfo, searchContext)) { yield break; } // This will help us take packageEntryInfo.LatestVersion and packageEntryInfo.AbsoluteLatestVersion and get the matching package easily // We're not setting isLatestVersion here so we don't have to deal with "is it latest or absolute latest" Dictionary <SemanticVersion, PackageBase> versionToPackageTable = new Dictionary <SemanticVersion, PackageBase>(); NuGetSearchContext individualPackageSearchContext = new NuGetSearchContext() { PackageInfo = packageEntryInfo, AllVersions = searchContext.AllVersions, AllowPrerelease = searchContext.AllowPrerelease, RequiredVersion = searchContext.RequiredVersion, MinimumVersion = searchContext.MinimumVersion, MaximumVersion = searchContext.MaximumVersion, EnableDeepMetadataBypass = searchContext.EnableDeepMetadataBypass }; bool latestVersionRequired = !searchContext.AllVersions && searchContext.RequiredVersion == null && searchContext.MinimumVersion == null && searchContext.MaximumVersion == null; if (searchContext.EnableDeepMetadataBypass) { if (latestVersionRequired) { // Use the search result page to get the metadata for the latest version SemanticVersion individualPackageVersion = new SemanticVersion(packageEntry.version); packageEntryInfo.AddVersion(individualPackageVersion); PackageBase pb = this.ResourcesCollection.PackageConverter.Make(packageEntry); if (pb != null) { yield return(pb); } } else { // Go to the registration index of this package first. This allows us to bypass "deep" (but required) metadata in certain cases. NuGetPackageFeed3 packageFeed3 = (NuGetPackageFeed3)this.ResourcesCollection.PackagesFeed; NuGetSearchResult result = packageFeed3.Find(individualPackageSearchContext, request); foreach (PackageBase pb in result.Result.Cast <PackageBase>()) { yield return(pb); } } } else { // Either we want a specific version or we want all metadata for any packages foreach (dynamic packageVersionEntry in packageEntry.versions) { if (packageEntry.version.Equals(packageVersionEntry.version) || searchContext.AllVersions) { if (packageVersionEntry.Metadata.HasProperty("id")) { // Collect all versions from the search results so we can manually set isLatestVersion and isAbsoluteLatestVersion later SemanticVersion individualPackageVersion = new SemanticVersion(packageVersionEntry.version); packageEntryInfo.AddVersion(individualPackageVersion); // Skip prerelease versions if AllowPrereleaseVersions is not specified if (!String.IsNullOrEmpty(individualPackageVersion.SpecialVersion) && !searchContext.AllowPrerelease) { continue; } long?versionDownloadCount = null; if (packageVersionEntry.HasProperty("downloads")) { versionDownloadCount = packageVersionEntry.downloads; } string registrationUrl = packageVersionEntry.Metadata.id; // This should be PackageFeed3 // There should be a better way to reuse this function NuGetPackageFeed3 packageFeed3 = (NuGetPackageFeed3)this.ResourcesCollection.PackagesFeed; PackageBase packageVersionPackage = packageFeed3.Find(registrationUrl, individualPackageSearchContext, request, true).FirstOrDefault(); if (packageVersionPackage != null) { if (versionDownloadCount.HasValue) { packageVersionPackage.VersionDownloadCount = versionDownloadCount.Value; } // Reset these so we haven't collected all versions yet, so this is wrong packageVersionPackage.IsLatestVersion = false; packageVersionPackage.IsAbsoluteLatestVersion = false; versionToPackageTable[individualPackageVersion] = packageVersionPackage; } } } } // Now manually set the latest versions if (packageEntryInfo.LatestVersion != null && versionToPackageTable.ContainsKey(packageEntryInfo.LatestVersion)) { versionToPackageTable[packageEntryInfo.LatestVersion].IsLatestVersion = true; } if (packageEntryInfo.AbsoluteLatestVersion != null && versionToPackageTable.ContainsKey(packageEntryInfo.AbsoluteLatestVersion)) { versionToPackageTable[packageEntryInfo.AbsoluteLatestVersion].IsAbsoluteLatestVersion = true; } // I think this is the best we can do for enumeration (reads all versions of a package before yielding anything) foreach (PackageBase package in versionToPackageTable.Values) { yield return(package); } } }
public IEnumerable <string> Autocomplete(NuGetSearchTerm autocompleteSearchTerm, RequestWrapper request, WildcardPattern acceptedPattern, bool allowPrerelease) { try { request.Debug(Messages.DebugInfoCallMethod3, "NuGetAutoCompleteFeed3", "Autocomplete", autocompleteSearchTerm.ToString()); return(base.Execute <IEnumerable <string> >((baseUrl) => { HttpQueryBuilder qb = new HttpQueryBuilder(); if (autocompleteSearchTerm.Term == NuGetSearchTerm.NuGetSearchTermType.Id) { qb.Add(Constants.PackageIdQueryParam, autocompleteSearchTerm.Text); } else if (autocompleteSearchTerm.Term == NuGetSearchTerm.NuGetSearchTermType.AutoComplete) { qb.Add(Constants.QueryQueryParam, autocompleteSearchTerm.Text); } if (allowPrerelease) { qb.Add(Constants.PrereleaseQueryParam, "true"); } qb.Add(Constants.TakeQueryParam, Constants.SearchPageCount) .Add(Constants.SemVerLevelQueryParam, Constants.SemVerLevel2); return NuGetWebUtility.GetResults <dynamic, string>(request, (dynamic root) => { long res = -1; if (root.HasProperty("totalhits")) { res = root.totalhits; request.Debug(Resources.Messages.TotalPackagesDiscovered, res); } else { request.Warning(Resources.Messages.JsonSchemaMismatch, "totalhits"); request.Debug(Resources.Messages.JsonObjectDump, DynamicJsonParser.Serialize(root)); } return res; }, (dynamic root) => GetAutoCompleteResults(root, autocompleteSearchTerm, acceptedPattern), (long resultsToSkip) => { if (resultsToSkip > 0) { HttpQueryBuilder currentQb = qb.CloneAdd(Constants.SkipQueryParam, resultsToSkip.ToString()); return currentQb.AddQueryString(baseUrl); } return qb.AddQueryString(baseUrl); }, (string content) => { return DynamicJsonParser.Parse(content); }, Constants.SearchPageCountInt); })); } finally { request.Debug(Messages.DebugInfoReturnCall, "NuGetAutoCompleteFeed3", "Autocomplete"); } }