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");
}
}
