public async Task <bool> IsAvailableAsync(PackageIdentity identity, CancellationToken token)
{
var request = new HttpSourceRequest(() =>
{
var url = _urlBuilder.GetSymbolsUrl(identity);
// Ideally this would be an HTTP HEAD request, but MyGet does not seem to support
// this. As an alternative, make an HTTP GET range request for 0 bytes.
var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
requestMessage.Headers.Range = new RangeHeaderValue(0, 0);
return(requestMessage);
});
request.IgnoreNotFounds = true;
var output = await _httpSource.ProcessStreamAsync(
request,
stream =>
{
var isAvailable = stream != null;
return(Task.FromResult(isAvailable));
},
_logger,
token);
return(output);
}
public async Task <bool> StoreNuspecAsync(string id, string version, CancellationToken token)
{
var baseUrl = await _serviceIndexCache.GetUrlAsync(ServiceIndexTypes.FlatContainer);
var url = _flatContainerClient.GetPackageManifestUrl(baseUrl, id, version);
var nuGetLogger = _logger.ToNuGetLogger();
return(await _httpSource.ProcessStreamAsync(
new HttpSourceRequest(url, nuGetLogger)
{
IgnoreNotFounds = true,
},
async networkStream =>
{
if (networkStream == null)
{
return false;
}
await _fileStorageService.StoreStreamAsync(
id,
version,
FileArtifactType.Nuspec,
destStream => networkStream.CopyToAsync(destStream));
return true;
},
nuGetLogger,
token));
}
public static async Task <T> DeserializeUrlAsync <T>(
this HttpSource httpSource,
string url,
bool ignoreNotFounds,
int maxTries,
ILogger logger)
{
var nuGetLogger = logger.ToNuGetLogger();
return(await httpSource.ProcessStreamAsync(
new HttpSourceRequest(url, nuGetLogger)
{
IgnoreNotFounds = ignoreNotFounds,
MaxTries = maxTries,
RequestTimeout = TimeSpan.FromSeconds(30),
},
stream =>
{
if (stream == null)
{
return Task.FromResult(default(T));
}
using (var textReader = new StreamReader(stream))
using (var jsonReader = new JsonTextReader(textReader))
{
var result = Serializer.Deserialize <T>(jsonReader);
return Task.FromResult(result);
}
},
nuGetLogger,
CancellationToken.None));
}
private async Task <IReadOnlyList <V2Package> > ParseV2PageAsync(string url)
{
var nuGetLogger = _logger.ToNuGetLogger();
return(await _httpSource.ProcessStreamAsync(
new HttpSourceRequest(url, nuGetLogger),
stream =>
{
var document = XmlUtility.LoadXml(stream);
var page = _parser.ParsePage(document);
return Task.FromResult(page);
},
nuGetLogger,
CancellationToken.None));
}
public async Task <IReadOnlyList <VsixPackage> > EnumerateAsync(CancellationToken token)
{
var request = new HttpSourceRequest(_source, _logger);
request.IgnoreNotFounds = false;
return(await _httpSource.ProcessStreamAsync(
request,
stream =>
{
var doc = XDocument.Load(stream);
var entries = doc.Root.Elements(XName.Get("entry", AtomXmlns));
var packages = new List <VsixPackage>();
foreach (var entry in entries)
{
var contentElement = entry.Element(XName.Get("content", AtomXmlns));
var contentSrcAttribute = contentElement.Attribute("src");
var contentSrc = contentSrcAttribute.Value;
var vsix = entry.Element(XName.Get("Vsix", VsixXmlns));
var idElement = vsix.Element(XName.Get("Id", VsixXmlns));
var id = idElement.Value;
var versionElement = vsix.Element(XName.Get("Version", VsixXmlns));
var version = versionElement.Value;
var package = new VsixPackage
{
Id = id,
Version = version,
Url = contentSrc
};
packages.Add(package);
}
return Task.FromResult(packages);
},
_logger,
token));
}
public static async Task <BlobMetadata> GetBlobMetadataAsync(this HttpSource httpSource, string url, ILogger logger)
{
var nuGetLogger = logger.ToNuGetLogger();
// Try to get all of the information using a HEAD request.
var blobMetadata = await httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => HttpRequestMessageFactory.Create(HttpMethod.Head, url, nuGetLogger)),
response =>
{
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(Task.FromResult(new BlobMetadata(
exists: false,
hasContentMD5Header: false,
contentMD5: null)));
}
response.EnsureSuccessStatusCode();
var headerMD5Bytes = response.Content.Headers.ContentMD5;
if (headerMD5Bytes != null)
{
var contentMD5 = BytesToHex(headerMD5Bytes);
return(Task.FromResult(new BlobMetadata(
exists: true,
hasContentMD5Header: true,
contentMD5: contentMD5)));
}
return(Task.FromResult <BlobMetadata>(null));
},
nuGetLogger,
CancellationToken.None);
if (blobMetadata != null)
{
return(blobMetadata);
}
// If no Content-MD5 header was found in the response, calculate the package hash by downloading the
// package.
return(await httpSource.ProcessStreamAsync(
new HttpSourceRequest(url, nuGetLogger),
async stream =>
{
var buffer = new byte[16 * 1024];
using (var md5 = new MD5IncrementalHash())
{
int read;
do
{
read = await stream.ReadAsync(buffer, 0, buffer.Length);
md5.AppendData(buffer, 0, read);
}while (read > 0);
var hash = md5.GetHashAndReset();
var contentMD5 = BytesToHex(hash);
return new BlobMetadata(
exists: true,
hasContentMD5Header: false,
contentMD5: contentMD5);
}
},
nuGetLogger,
CancellationToken.None));
}
