private async Task Feed_FindPackagesById(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_FindPackagesById", ConsoleColor.Green);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", ExtractFeed(context.RequestUri.AbsolutePath)), ConsoleColor.DarkGreen);
await _channel.GetAllPackageVersions(context, context.Args.Id);
}
public async Task DownloadPackage(InterceptCallContext context, string id, string version)
{
JToken package = await GetPackageCore(context, id, version);
if (package == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "unable to find version {0} of package {1}", version, id));
}
string address = package["nupkgUrl"].ToString();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 PKG] {0}", address.ToString()), ConsoleColor.Cyan);
Stopwatch timer = new Stopwatch();
timer.Start();
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
HttpResponseMessage response = await client.GetAsync(address);
byte[] data = await response.Content.ReadAsByteArrayAsync();
timer.Stop();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 PKG] (status:{0}) (time:{1}ms) {2}", response.StatusCode, timer.ElapsedMilliseconds, address.ToString()),
response.StatusCode == System.Net.HttpStatusCode.OK ? ConsoleColor.Cyan : ConsoleColor.Red);
await context.WriteResponse(data, "application/zip");
}
private async Task Feed_Search(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_Search", ConsoleColor.Green);
string feed = ExtractFeed(context.RequestUri.AbsolutePath);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", feed), ConsoleColor.DarkGreen);
await SearchImpl(context, feed);
}
private async Task Feed_Packages(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_Packages", ConsoleColor.Green);
string feed = ExtractFeed(context.RequestUri.AbsolutePath);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", feed), ConsoleColor.DarkGreen);
string path = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
path = path.Substring(path.IndexOf(feed) + feed.Length + 1);
string query = context.RequestUri.Query;
await GetPackage(context, path, query, feed);
}
public async Task GetListOfPackageVersions(InterceptCallContext context, string id)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetListOfPackageVersions: {0}", id), ConsoleColor.Magenta);
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(id));
JArray array = new JArray();
// the package may not exist, in that case return an empty array
if (resolverBlob != null)
{
List <NuGetVersion> versions = new List <NuGetVersion>();
foreach (JToken package in resolverBlob["packages"])
{
NuGetVersion version = NuGetVersion.Parse(package["version"].ToString());
// all versions are returned, filter to only stable if needed
if (context.Args.IncludePrerelease || !version.IsPrerelease)
{
versions.Add(version);
}
}
versions.Sort();
foreach (NuGetVersion version in versions)
{
array.Add(version.ToString());
}
}
await context.WriteResponse(array);
}
public async Task GetListOfPackages(InterceptCallContext context)
{
context.Log("[V3 CALL] GetListOfPackages", ConsoleColor.Magenta);
var index = await FetchJson(context, context.Args.IncludePrerelease?new Uri(_listAvailableLatestPrereleaseIndex) : new Uri(_listAvailableLatestStableIndex));
var data = GetListAvailableDataStart(context, index);
// apply startswith if needed
if (context.Args.PartialId != null)
{
data = data.Where(e => e["id"].ToString().StartsWith(context.Args.PartialId, StringComparison.OrdinalIgnoreCase));
data = data.TakeWhile(e => e["id"].ToString().StartsWith(context.Args.PartialId, StringComparison.OrdinalIgnoreCase));
}
// take only 30
var ids = data.Take(30).Select(p => p["id"].ToString()).ToList();
ids.Sort(StringComparer.InvariantCultureIgnoreCase);
JArray array = new JArray();
foreach (var id in ids)
{
array.Add(id);
}
await context.WriteResponse(array);
}
public async Task Metadata(InterceptCallContext context, string feed = null)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Metadata: {0}", feed ?? string.Empty), ConsoleColor.Magenta);
Stream stream = GetResourceStream(feed == null ? "xml.Metadata.xml" : "xml.FeedMetadata.xml");
XElement xml = XElement.Load(stream);
await context.WriteResponse(xml);
}
private async Task Packages(InterceptCallContext context)
{
context.Log("[V3 CALL] Packages", ConsoleColor.Green);
string path = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
string query = context.RequestUri.Query;
await GetPackage(context, path, query);
}
private async Task PackageVersions(InterceptCallContext context)
{
context.Log("[V3 CALL] PackageVersions", ConsoleColor.Green);
string path = context.RequestUri.AbsolutePath;
string id = path.Substring(path.LastIndexOf("/") + 1);
await _channel.GetListOfPackageVersions(context, id);
}
public async Task SearchCount(InterceptCallContext context, string searchTerm, bool isLatestVersion, string targetFramework, bool includePrerelease, int skip, int take, string feedName)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] SearchCount: {0}", searchTerm), ConsoleColor.Magenta);
JObject obj = await FetchJson(context, MakeSearchAddress(searchTerm, isLatestVersion, targetFramework, includePrerelease, skip, take, feedName));
string count = obj != null ? count = obj["totalHits"].ToString() : "0";
await context.WriteResponse(count);
}
private async Task <JObject> FetchJson(InterceptCallContext context, Uri address)
{
string url = address.ToString().ToLowerInvariant();
JObject fromCache = null;
if (_cache.TryGet(address, out fromCache))
{
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 CACHE] {0}", address.ToString()), ConsoleColor.DarkCyan);
return(fromCache);
}
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 REQ] {0}", address.ToString()), ConsoleColor.Cyan);
Stopwatch timer = new Stopwatch();
timer.Start();
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
HttpResponseMessage response = await client.GetAsync(address);
timer.Stop();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 RES] (status:{0}) (time:{1}ms) {2}", response.StatusCode, timer.ElapsedMilliseconds, address.ToString()),
response.StatusCode == System.Net.HttpStatusCode.OK ? ConsoleColor.Cyan : ConsoleColor.Red);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string json = await response.Content.ReadAsStringAsync();
JObject obj = JObject.Parse(json);
_cache.AddOrUpdate(address, obj);
return(obj);
}
else
{
// expected in some cases
return(null);
}
}
public async Task Search(InterceptCallContext context, string searchTerm, bool isLatestVersion, string targetFramework, bool includePrerelease, int skip, int take, string feedName)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Search: {0} ({1},{2})", searchTerm, skip, take), ConsoleColor.Magenta);
JObject obj = await FetchJson(context, MakeSearchAddress(searchTerm, isLatestVersion, targetFramework, includePrerelease, skip, take, feedName));
IEnumerable <JToken> data = (obj != null) ? data = obj["data"] : Enumerable.Empty <JToken>();
XElement feed = InterceptFormatting.MakeFeedFromSearch(_source, _passThroughAddress, "Packages", data, "");
await context.WriteResponse(feed);
}
public async Task GetUpdates(InterceptCallContext context, string[] packageIds, string[] versions, string[] versionConstraints, string[] targetFrameworks, bool includePrerelease, bool includeAllVersions, bool count = false)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetUpdates{1}: {0}", string.Join("|", packageIds), count ? "Count" : string.Empty), ConsoleColor.Magenta);
var packages = await GetUpdatesCore(context, packageIds, versions, versionConstraints, targetFrameworks, includePrerelease, includeAllVersions);
if (count)
{
await context.WriteResponse(packages.Count);
}
else
{
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "GetUpdates", packages, packages.Select(p => p["id"].ToString()).ToArray());
await context.WriteResponse(feed);
}
}
public async Task GetPackage(InterceptCallContext context, string id, string version, string feedName)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetPackage: {0} {1}", id, version), ConsoleColor.Magenta);
var desiredPackage = await GetPackageCore(context, id, version);
if (desiredPackage == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "unable to find version {0} of package {1}", version, id));
}
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", new List <JToken> {
desiredPackage
}, id);
await context.WriteResponse(feed);
}
private async Task GetUpdates(InterceptCallContext context)
{
context.Log("[V3 CALL] GetUpdates", ConsoleColor.Green);
IDictionary <string, string> arguments = context.Args.Arguments;
string[] packageIds = Uri.UnescapeDataString(arguments["packageIds"]).Trim('\'').Split('|');
string[] versions = Uri.UnescapeDataString(arguments["versions"]).Trim('\'').Split('|');
string[] versionConstraints = Uri.UnescapeDataString(arguments["versionConstraints"]).Trim('\'').Split('|');
string[] targetFrameworks = Uri.UnescapeDataString(arguments["targetFrameworks"]).Trim('\'').Split('|');
bool includeAllVersions = false;
bool.TryParse(arguments["includeAllVersions"], out includeAllVersions);
await _channel.GetUpdates(context, packageIds, versions, versionConstraints, targetFrameworks, context.Args.IncludePrerelease, includeAllVersions, context.Args.Count);
}
private async Task DownloadPackage(InterceptCallContext context)
{
context.Log("[V3 CALL] DownloadPackage", ConsoleColor.Green);
var urlParts = new List <string>(context.RequestUri.AbsoluteUri.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries));
urlParts.Reverse();
if (urlParts.Count > 3 && StringComparer.OrdinalIgnoreCase.Equals("package", urlParts[2]))
{
await _channel.DownloadPackage(context, urlParts[1], urlParts[0]);
}
else
{
throw new ShimException("Invalid download url: " + context.RequestUri.ToString());
}
}
private async Task FindPackagesById(InterceptCallContext context)
{
context.Log("[V3 CALL] FindPackagesById", ConsoleColor.Green);
if (context.Args.Id == null)
{
throw new ShimException("unable to find id in query string");
}
if (context.Args.IsLatestVersion)
{
await _channel.GetLatestVersionPackage(context, context.Args.Id, context.Args.IncludePrerelease);
}
else
{
await _channel.GetAllPackageVersions(context, context.Args.Id);
}
}
public async Task GetAllPackageVersions(InterceptCallContext context, string id)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetAllPackageVersions: {0}", id), ConsoleColor.Magenta);
var ids = id.Split(new string[] { " or " }, StringSplitOptions.RemoveEmptyEntries);
List <JToken> packages = new List <JToken>();
foreach (var s in ids)
{
string curId = s.Trim('\'');
if (curId.StartsWith("tolower(id) eq '"))
{
curId = curId.Split('\'')[1];
}
// TODO: run in parallel
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(curId));
if (resolverBlob == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", curId));
}
foreach (var p in resolverBlob["packages"])
{
NuGetVersion version = NuGetVersion.Parse(p["version"].ToString());
// all versions are returned, filter to only stable if needed
if (context.Args.IncludePrerelease || !version.IsPrerelease)
{
p["id"] = resolverBlob["id"];
packages.Add(p);
}
}
}
var data = packages.OrderBy(p => p["id"].ToString()).ThenByDescending(p => NuGetVersion.Parse(p["version"].ToString()), VersionComparer.VersionRelease);
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", data, data.Select(p => p["id"].ToString()).ToArray());
await context.WriteResponse(feed);
}
public async Task Root(InterceptCallContext context, string feedName = null)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Root: {0}", feedName ?? string.Empty), ConsoleColor.Magenta);
if (feedName == null)
{
Stream stream = GetResourceStream("xml.Root.xml");
XElement xml = XElement.Load(stream);
await context.WriteResponse(xml);
}
else
{
Stream stream = GetResourceStream("xml.FeedRoot.xml");
string s = (new StreamReader(stream)).ReadToEnd();
string t = string.Format(s, feedName);
XElement xml = XElement.Load(new StringReader(t), LoadOptions.SetBaseUri);
await context.WriteResponse(xml);
}
}
public async Task Root(InterceptCallContext context, string feedName = null)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Root: {0}", feedName ?? string.Empty), ConsoleColor.Magenta);
if (feedName == null)
{
Stream stream = GetResourceStream("xml.Root.xml");
XElement xml = XElement.Load(stream);
await context.WriteResponse(xml);
}
else
{
Stream stream = GetResourceStream("xml.FeedRoot.xml");
string s = (new StreamReader(stream)).ReadToEnd();
string t = string.Format(s, feedName);
XElement xml = XElement.Load(new StringReader(t), LoadOptions.SetBaseUri);
await context.WriteResponse(xml);
}
}
public async Task GetLatestVersionPackage(InterceptCallContext context, string id, bool includePrerelease)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetLatestVersionPackage: {0} {1}", id, includePrerelease ? "[include prerelease]" : ""), ConsoleColor.Magenta);
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(id));
if (resolverBlob == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", id));
}
JToken latest = ExtractLatestVersion(resolverBlob, includePrerelease);
if (latest == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", id));
}
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", new List <JToken> {
latest
}, id);
await context.WriteResponse(feed);
}
private async Task PackageIds(InterceptCallContext context)
{
context.Log("[V3 CALL] PackageIds", ConsoleColor.Green);
await _channel.GetListOfPackages(context);
}
private async Task PackageIds(InterceptCallContext context)
{
context.Log("[V3 CALL] PackageIds", ConsoleColor.Green);
await _channel.GetListOfPackages(context);
}
private async Task Metadata(InterceptCallContext context)
{
context.Log("[V3 CALL] Metadata", ConsoleColor.Green);
await _channel.Metadata(context);
}
public async Task GetLatestVersionPackage(InterceptCallContext context, string id, bool includePrerelease)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetLatestVersionPackage: {0} {1}", id, includePrerelease ? "[include prerelease]" : ""), ConsoleColor.Magenta);
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(id));
if (resolverBlob == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", id));
}
JToken latest = ExtractLatestVersion(resolverBlob, includePrerelease);
if (latest == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", id));
}
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", new List<JToken> { latest }, id);
await context.WriteResponse(feed);
}
private async Task Feed_FindPackagesById(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_FindPackagesById", ConsoleColor.Green);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", ExtractFeed(context.RequestUri.AbsolutePath)), ConsoleColor.DarkGreen);
await _channel.GetAllPackageVersions(context, context.Args.Id);
}
private async Task Packages(InterceptCallContext context)
{
context.Log("[V3 CALL] Packages", ConsoleColor.Green);
string path = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
string query = context.RequestUri.Query;
await GetPackage(context, path, query);
}
public async Task Metadata(InterceptCallContext context, string feed = null)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Metadata: {0}", feed ?? string.Empty), ConsoleColor.Magenta);
Stream stream = GetResourceStream(feed == null ? "xml.Metadata.xml" : "xml.FeedMetadata.xml");
XElement xml = XElement.Load(stream);
await context.WriteResponse(xml);
}
public async Task GetAllPackageVersions(InterceptCallContext context, string id)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetAllPackageVersions: {0}", id), ConsoleColor.Magenta);
var ids = id.Split(new string[] { " or " }, StringSplitOptions.RemoveEmptyEntries);
List<JToken> packages = new List<JToken>();
foreach (var s in ids)
{
string curId = s.Trim('\'');
if (curId.StartsWith("tolower(id) eq '"))
{
curId = curId.Split('\'')[1];
}
// TODO: run in parallel
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(curId));
if (resolverBlob == null)
{
throw new InvalidOperationException(string.Format("package {0} not found", curId));
}
foreach (var p in resolverBlob["packages"])
{
NuGetVersion version = NuGetVersion.Parse(p["version"].ToString());
// all versions are returned, filter to only stable if needed
if (context.Args.IncludePrerelease || !version.IsPrerelease)
{
p["id"] = resolverBlob["id"];
packages.Add(p);
}
}
}
var data = packages.OrderBy(p => p["id"].ToString()).ThenByDescending(p => NuGetVersion.Parse(p["version"].ToString()), VersionComparer.VersionRelease);
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", data, data.Select(p => p["id"].ToString()).ToArray());
await context.WriteResponse(feed);
}
public async Task GetListOfPackageVersions(InterceptCallContext context, string id)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetListOfPackageVersions: {0}", id), ConsoleColor.Magenta);
JObject resolverBlob = await FetchJson(context, MakeResolverAddress(id));
JArray array = new JArray();
// the package may not exist, in that case return an empty array
if (resolverBlob != null)
{
List<NuGetVersion> versions = new List<NuGetVersion>();
foreach (JToken package in resolverBlob["packages"])
{
NuGetVersion version = NuGetVersion.Parse(package["version"].ToString());
// all versions are returned, filter to only stable if needed
if (context.Args.IncludePrerelease || !version.IsPrerelease)
{
versions.Add(version);
}
}
versions.Sort();
foreach (NuGetVersion version in versions)
{
array.Add(version.ToString());
}
}
await context.WriteResponse(array);
}
public async Task GetListOfPackages(InterceptCallContext context)
{
context.Log("[V3 CALL] GetListOfPackages", ConsoleColor.Magenta);
var index = await FetchJson(context, context.Args.IncludePrerelease ? new Uri(_listAvailableLatestPrereleaseIndex) : new Uri(_listAvailableLatestStableIndex));
var data = GetListAvailableDataStart(context, index);
// apply startswith if needed
if (context.Args.PartialId != null)
{
data = data.Where(e => e["id"].ToString().StartsWith(context.Args.PartialId, StringComparison.OrdinalIgnoreCase));
data = data.TakeWhile(e => e["id"].ToString().StartsWith(context.Args.PartialId, StringComparison.OrdinalIgnoreCase));
}
// take only 30
var ids = data.Take(30).Select(p => p["id"].ToString()).ToList();
ids.Sort(StringComparer.InvariantCultureIgnoreCase);
JArray array = new JArray();
foreach (var id in ids)
{
array.Add(id);
}
await context.WriteResponse(array);
}
public async Task GetUpdates(InterceptCallContext context, string[] packageIds, string[] versions, string[] versionConstraints, string[] targetFrameworks, bool includePrerelease, bool includeAllVersions, bool count = false)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetUpdates{1}: {0}", string.Join("|", packageIds), count ? "Count" : string.Empty), ConsoleColor.Magenta);
var packages = await GetUpdatesCore(context, packageIds, versions, versionConstraints, targetFrameworks, includePrerelease, includeAllVersions);
if (count)
{
await context.WriteResponse(packages.Count);
}
else
{
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "GetUpdates", packages, packages.Select(p => p["id"].ToString()).ToArray());
await context.WriteResponse(feed);
}
}
private async Task PackageVersions(InterceptCallContext context)
{
context.Log("[V3 CALL] PackageVersions", ConsoleColor.Green);
string path = context.RequestUri.AbsolutePath;
string id = path.Substring(path.LastIndexOf("/") + 1);
await _channel.GetListOfPackageVersions(context, id);
}
private async Task DownloadPackage(InterceptCallContext context)
{
context.Log("[V3 CALL] DownloadPackage", ConsoleColor.Green);
var urlParts = new List<string>(context.RequestUri.AbsoluteUri.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries));
urlParts.Reverse();
if (urlParts.Count > 3 && StringComparer.OrdinalIgnoreCase.Equals("package", urlParts[2]))
{
await _channel.DownloadPackage(context, urlParts[1], urlParts[0]);
}
else
{
throw new ShimException("Invalid download url: " + context.RequestUri.ToString());
}
}
private async Task GetUpdates(InterceptCallContext context)
{
context.Log("[V3 CALL] GetUpdates", ConsoleColor.Green);
IDictionary<string, string> arguments = context.Args.Arguments;
string[] packageIds = Uri.UnescapeDataString(arguments["packageIds"]).Trim('\'').Split('|');
string[] versions = Uri.UnescapeDataString(arguments["versions"]).Trim('\'').Split('|');
string[] versionConstraints = Uri.UnescapeDataString(arguments["versionConstraints"]).Trim('\'').Split('|');
string[] targetFrameworks = Uri.UnescapeDataString(arguments["targetFrameworks"]).Trim('\'').Split('|');
bool includeAllVersions = false;
bool.TryParse(arguments["includeAllVersions"], out includeAllVersions);
await _channel.GetUpdates(context, packageIds, versions, versionConstraints, targetFrameworks, context.Args.IncludePrerelease, includeAllVersions, context.Args.Count);
}
public async Task Search(InterceptCallContext context, string searchTerm, bool isLatestVersion, string targetFramework, bool includePrerelease, int skip, int take, string feedName, string sortBy)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] Search: {0} ({1},{2})", searchTerm, skip, take), ConsoleColor.Magenta);
JObject obj = await FetchJson(context, MakeSearchAddress(searchTerm, isLatestVersion, targetFramework, includePrerelease, skip, take, feedName, sortBy));
IEnumerable<JToken> data = (obj != null) ? data = obj["data"] : Enumerable.Empty<JToken>();
XElement feed = InterceptFormatting.MakeFeedFromSearch(_source, _passThroughAddress, "Packages", data, "");
await context.WriteResponse(feed);
}
private async Task Feed_Search(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_Search", ConsoleColor.Green);
string feed = ExtractFeed(context.RequestUri.AbsolutePath);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", feed), ConsoleColor.DarkGreen);
await SearchImpl(context, feed);
}
private async Task Search(InterceptCallContext context)
{
context.Log("[V3 CALL] Search", ConsoleColor.Green);
await SearchImpl(context);
}
private async Task Feed_Packages(InterceptCallContext context)
{
context.Log("[V3 CALL] Feed_Packages", ConsoleColor.Green);
string feed = ExtractFeed(context.RequestUri.AbsolutePath);
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] feed: {0}", feed), ConsoleColor.DarkGreen);
string path = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
path = path.Substring(path.IndexOf(feed) + feed.Length + 1);
string query = context.RequestUri.Query;
await GetPackage(context, path, query, feed);
}
private async Task Count(InterceptCallContext context)
{
context.Log("[V3 CALL] Count", ConsoleColor.Green);
await CountImpl(context);
}
public async Task GetPackage(InterceptCallContext context, string id, string version, string feedName)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] GetPackage: {0} {1}", id, version), ConsoleColor.Magenta);
var desiredPackage = await GetPackageCore(context, id, version);
if (desiredPackage == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "unable to find version {0} of package {1}", version, id));
}
XElement feed = InterceptFormatting.MakeFeed(_passThroughAddress, "Packages", new List<JToken> { desiredPackage }, id);
await context.WriteResponse(feed);
}
private async Task Search(InterceptCallContext context)
{
context.Log("[V3 CALL] Search", ConsoleColor.Green);
await SearchImpl(context);
}
private async Task Root(InterceptCallContext context)
{
context.Log("[V3 CALL] Root", ConsoleColor.Green);
await _channel.Root(context);
}
private async Task FindPackagesById(InterceptCallContext context)
{
context.Log("[V3 CALL] FindPackagesById", ConsoleColor.Green);
if (context.Args.Id == null)
{
throw new ShimException("unable to find id in query string");
}
if (context.Args.IsLatestVersion)
{
await _channel.GetLatestVersionPackage(context, context.Args.Id, context.Args.IncludePrerelease);
}
else
{
await _channel.GetAllPackageVersions(context, context.Args.Id);
}
}
private async Task Root(InterceptCallContext context)
{
context.Log("[V3 CALL] Root", ConsoleColor.Green);
await _channel.Root(context);
}
private async Task<JObject> FetchJson(InterceptCallContext context, Uri address)
{
string url = address.ToString().ToLowerInvariant();
JObject fromCache = null;
if (_cache.TryGet(address, out fromCache))
{
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 CACHE] {0}", address.ToString()), ConsoleColor.DarkCyan);
return fromCache;
}
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 REQ] {0}", address.ToString()), ConsoleColor.Cyan);
Stopwatch timer = new Stopwatch();
timer.Start();
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
HttpResponseMessage response = await client.GetAsync(address);
timer.Stop();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 RES] (status:{0}) (time:{1}ms) {2}", response.StatusCode, timer.ElapsedMilliseconds, address.ToString()),
response.StatusCode == System.Net.HttpStatusCode.OK ? ConsoleColor.Cyan : ConsoleColor.Red);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string json = await response.Content.ReadAsStringAsync();
JObject obj = JObject.Parse(json);
_cache.AddOrUpdate(address, obj);
return obj;
}
else
{
// expected in some cases
return null;
}
}
public async Task SearchCount(InterceptCallContext context, string searchTerm, bool isLatestVersion, string targetFramework, bool includePrerelease, int skip, int take, string feedName, string sortBy)
{
context.Log(string.Format(CultureInfo.InvariantCulture, "[V3 CALL] SearchCount: {0}", searchTerm), ConsoleColor.Magenta);
JObject obj = await FetchJson(context, MakeSearchAddress(searchTerm, isLatestVersion, targetFramework, includePrerelease, skip, take, feedName, sortBy));
string count = obj != null ? count = obj["totalHits"].ToString() : "0";
await context.WriteResponse(count);
}
private async Task Metadata(InterceptCallContext context)
{
context.Log("[V3 CALL] Metadata", ConsoleColor.Green);
await _channel.Metadata(context);
}
/// <summary>
/// Gathers the response data from the V3 source for the context uri.
/// </summary>
public async Task Invoke(InterceptCallContext context)
{
try
{
if (_initialized != true)
{
throw new InvalidOperationException("Requires Init");
}
string unescapedAbsolutePath = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
string path = unescapedAbsolutePath;
// v2 is still in the path for get-package
if (unescapedAbsolutePath.IndexOf(ShimConstants.V2UrlPath) > -1)
{
path = unescapedAbsolutePath.Remove(0, ShimConstants.V2UrlPath.Length);
}
else if (unescapedAbsolutePath.IndexOf(ShimConstants.V3UrlPath) > -1)
{
path = unescapedAbsolutePath.Remove(0, ShimConstants.V3UrlPath.Length);
}
foreach (var func in _funcs)
{
if (path == string.Empty)
{
await Root(context);
return;
}
else if (path.StartsWith(func.Item1))
{
await func.Item2(context);
return;
}
}
// url was not recognized - perhaps this is a feed
int index1 = path.IndexOf('/', 0) + 1;
if (index1 < path.Length)
{
int index2 = path.IndexOf('/', index1);
if (index2 < path.Length)
{
path = path.Remove(0, index2 + 1);
}
}
foreach (var func in _feedFuncs)
{
if (path == string.Empty)
{
await _channel.Root(context);
//await Feed_Root(context);
return;
}
if (path.StartsWith(func.Item1))
{
await func.Item2(context);
return;
}
}
// unknown process
throw new NotImplementedException();
}
catch (Exception ex)
{
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 ERR] (exception:{0}) {1}", ex.GetType().ToString(), context.RequestUri.AbsoluteUri), ConsoleColor.Red);
throw;
}
}
private async Task Count(InterceptCallContext context)
{
context.Log("[V3 CALL] Count", ConsoleColor.Green);
await CountImpl(context);
}
/// <summary>
/// Gathers the response data from the V3 source for the context uri.
/// </summary>
public async Task Invoke(InterceptCallContext context)
{
try
{
if (_initialized != true)
{
throw new InvalidOperationException("Requires Init");
}
// report metrics if the headers exist
Task metricsTask = ReportMetrics(context.Request);
string unescapedAbsolutePath = Uri.UnescapeDataString(context.RequestUri.AbsolutePath);
string path = unescapedAbsolutePath;
// v2 is still in the path for get-package
if (unescapedAbsolutePath.IndexOf(ShimConstants.V2UrlPath) == 0)
{
path = unescapedAbsolutePath.Remove(0, ShimConstants.V2UrlPath.Length);
}
if (unescapedAbsolutePath.IndexOf(ShimConstants.V3UrlPath) == 0)
{
path = unescapedAbsolutePath.Remove(0, ShimConstants.V3UrlPath.Length);
}
foreach (var func in _funcs)
{
if (path == string.Empty)
{
await Root(context);
return;
}
else if (path.StartsWith(func.Item1))
{
await func.Item2(context);
return;
}
}
// url was not recognized - perhaps this is a feed
int index1 = path.IndexOf('/', 0) + 1;
if (index1 < path.Length)
{
int index2 = path.IndexOf('/', index1);
if (index2 < path.Length)
{
path = path.Remove(0, index2 + 1);
}
}
foreach (var func in _feedFuncs)
{
if (path == string.Empty)
{
await _channel.Root(context);
//await Feed_Root(context);
return;
}
if (path.StartsWith(func.Item1))
{
await func.Item2(context);
return;
}
}
// unknown process
throw new NotImplementedException();
}
catch (Exception ex)
{
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 ERR] (exception:{0}) {1}", ex.GetType().ToString(), context.RequestUri.AbsoluteUri), ConsoleColor.Red);
throw;
}
}
public async Task DownloadPackage(InterceptCallContext context, string id, string version)
{
JToken package = await GetPackageCore(context, id, version);
if (package == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "unable to find version {0} of package {1}", version, id));
}
string address = package["nupkgUrl"].ToString();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 PKG] {0}", address.ToString()), ConsoleColor.Cyan);
Stopwatch timer = new Stopwatch();
timer.Start();
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
HttpResponseMessage response = await client.GetAsync(address);
byte[] data = await response.Content.ReadAsByteArrayAsync();
timer.Stop();
context.Log(String.Format(CultureInfo.InvariantCulture, "[V3 PKG] (status:{0}) (time:{1}ms) {2}", response.StatusCode, timer.ElapsedMilliseconds, address.ToString()),
response.StatusCode == System.Net.HttpStatusCode.OK ? ConsoleColor.Cyan : ConsoleColor.Red);
await context.WriteResponse(data, "application/zip");
}
