public static async Task <bool> UrlExistsAsync(this HttpSource httpSource, string url, ILogger logger)
{
var nuGetLogger = logger.ToNuGetLogger();
return(await httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => HttpRequestMessageFactory.Create(HttpMethod.Head, url, nuGetLogger))
{
IgnoreNotFounds = true,
},
response =>
{
if (response.StatusCode == HttpStatusCode.OK)
{
return Task.FromResult(true);
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
return Task.FromResult(false);
}
throw new HttpRequestException(
$"The request to {url} return HTTP {(int)response.StatusCode} {response.ReasonPhrase}.");
},
nuGetLogger,
CancellationToken.None));
}
public async Task <int> GetCountAsync(ILogger log, CancellationToken token)
{
var uri = string.Format("{0}/Packages/$count", _baseAddress);
return(await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(
() =>
{
var request = HttpRequestMessageFactory.Create(HttpMethod.Get, uri, log);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/atom+xml"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
return request;
}),
async response =>
{
if (response.StatusCode == HttpStatusCode.OK)
{
var intString = await response.Content.ReadAsStringAsync();
return int.Parse(intString);
}
throw new FatalProtocolException(string.Format(
CultureInfo.CurrentCulture,
"The V2 feed at '{0}' returned an unexpected status code '{1} {2}'.",
uri,
(int)response.StatusCode,
response.ReasonPhrase));
},
log,
token));
}
// Pushes a package to the Http server.
private async Task PushPackageToServer(string source,
string apiKey,
string pathToPackage,
long packageSize,
ILogger logger,
CancellationToken token)
{
await _httpSource.ProcessResponseAsync(
() => CreateRequest(source, pathToPackage, apiKey),
response =>
{
response.EnsureSuccessStatusCode();
return(Task.FromResult(0));
},
logger,
token);
}
// Pushes a package to the Http server.
private async Task PushPackageToServer(string source,
string apiKey,
string pathToPackage,
long packageSize,
TimeSpan requestTimeout,
ILogger logger,
CancellationToken token)
{
var serviceEndpointUrl = GetServiceEndpointUrl(source, string.Empty);
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => CreateRequest(serviceEndpointUrl, pathToPackage, apiKey, logger))
{
RequestTimeout = requestTimeout
},
response =>
{
response.EnsureSuccessStatusCode();
return(Task.FromResult(0));
},
logger,
token);
}
public static async Task <ODataServiceDocumentResourceV2> CreateODataServiceDocumentResourceV2(
string url,
HttpSource client,
DateTime utcNow,
ILogger log,
CancellationToken token)
{
// Get the service document and record the URL after any redirects.
string lastRequestUri;
try
{
lastRequestUri = await client.ProcessResponseAsync(
new HttpSourceRequest(() => HttpRequestMessageFactory.Create(HttpMethod.Get, url, log)),
response =>
{
if (response.RequestMessage == null)
{
return(Task.FromResult(url));
}
return(Task.FromResult(response.RequestMessage.RequestUri.ToString()));
},
log,
token);
}
catch (Exception ex) when(!(ex is FatalProtocolException) && (!(ex is OperationCanceledException)))
{
string message = String.Format(CultureInfo.CurrentCulture, Strings.Log_FailedToReadServiceIndex, url);
throw new FatalProtocolException(message, ex);
}
// Trim the query string or any trailing slash.
var builder = new UriBuilder(lastRequestUri)
{
Query = null
};
var baseAddress = builder.Uri.AbsoluteUri.Trim('/');
return(new ODataServiceDocumentResourceV2(baseAddress, DateTime.UtcNow));
}
public async Task PushAsync(Stream packageStream, CancellationToken token)
{
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() =>
{
// Retries should seek the package stream to the beginning.
packageStream.Position = 0;
var packageContent = new StreamContent(packageStream)
{
Headers =
{
ContentType = MediaTypeHeaderValue.Parse("application/octet-stream")
}
};
var content = new MultipartFormDataContent();
content.Add(packageContent, "package", "package.nupkg");
var request = HttpRequestMessageFactory.Create(
HttpMethod.Put,
_pushUrl,
new HttpRequestMessageConfiguration(logger: _logger, promptOn403: false));
request.Content = content;
request.Headers.TransferEncodingChunked = true;
request.Headers.Add("X-NuGet-ApiKey", _destinationApiKey);
return(request);
}),
response =>
{
response.EnsureSuccessStatusCode();
return(Task.FromResult(0));
},
_logger,
token);
}
// Pushes a package to the Http server.
private async Task PushPackageToServer(string source,
string apiKey,
string pathToPackage,
long packageSize,
bool noServiceEndpoint,
TimeSpan requestTimeout,
ILogger logger,
CancellationToken token)
{
var serviceEndpointUrl = GetServiceEndpointUrl(source, string.Empty, noServiceEndpoint);
var useTempApiKey = IsSourceNuGetSymbolServer(source);
if (useTempApiKey)
{
var maxTries = 3;
using (var packageReader = new PackageArchiveReader(pathToPackage))
{
var packageIdentity = packageReader.GetIdentity();
var success = false;
var retry = 0;
while (retry < maxTries && !success)
{
try
{
retry++;
success = true;
// If user push to https://nuget.smbsrc.net/, use temp api key.
var tmpApiKey = await GetSecureApiKey(packageIdentity, apiKey, noServiceEndpoint, requestTimeout, logger, token);
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => CreateRequest(serviceEndpointUrl, pathToPackage, tmpApiKey, logger))
{
RequestTimeout = requestTimeout,
MaxTries = 1
},
response =>
{
response.EnsureSuccessStatusCode();
return(Task.FromResult(0));
},
logger,
token);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
if (retry == maxTries)
{
throw;
}
success = false;
logger.LogInformation(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RetryingHttp,
HttpMethod.Put,
source)
+ Environment.NewLine
+ ExceptionUtilities.DisplayMessage(e));
}
}
}
}
else
{
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => CreateRequest(serviceEndpointUrl, pathToPackage, apiKey, logger))
{
RequestTimeout = requestTimeout
},
response =>
{
response.EnsureSuccessStatusCode();
return(Task.FromResult(0));
},
logger,
token);
}
}
/// <summary>
/// Pushes a package to the Http server.
/// </summary>
/// <returns>Indicator of whether to show PushCommandPackagePushed message.</returns>
private async Task <bool> PushPackageToServer(string source,
string apiKey,
string pathToPackage,
bool noServiceEndpoint,
bool skipDuplicate,
TimeSpan requestTimeout,
ILogger logger,
CancellationToken token)
{
Uri serviceEndpointUrl = GetServiceEndpointUrl(source, string.Empty, noServiceEndpoint);
bool useTempApiKey = IsSourceNuGetSymbolServer(source);
HttpStatusCode?codeNotToThrow = ConvertSkipDuplicateParamToHttpStatusCode(skipDuplicate);
bool showPushCommandPackagePushed = true;
if (useTempApiKey)
{
var maxTries = 3;
using (var packageReader = new PackageArchiveReader(pathToPackage))
{
PackageIdentity packageIdentity = packageReader.GetIdentity();
var success = false;
var retry = 0;
while (retry < maxTries && !success)
{
try
{
retry++;
success = true;
// If user push to https://nuget.smbsrc.net/, use temp api key.
string tmpApiKey = await GetSecureApiKey(packageIdentity, apiKey, noServiceEndpoint, requestTimeout, logger, token);
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => CreateRequest(serviceEndpointUrl, pathToPackage, tmpApiKey, logger))
{
RequestTimeout = requestTimeout,
MaxTries = 1
},
response =>
{
HttpStatusCode?responseStatusCode = EnsureSuccessStatusCode(response, codeNotToThrow, logger);
bool logOccurred = DetectAndLogSkippedErrorOccurrence(responseStatusCode, source, pathToPackage, response.ReasonPhrase, logger);
showPushCommandPackagePushed = !logOccurred;
return(Task.FromResult(0));
},
logger,
token);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
if (retry == maxTries)
{
throw;
}
success = false;
logger.LogInformation(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RetryingHttp,
HttpMethod.Put,
source)
+ Environment.NewLine
+ ExceptionUtilities.DisplayMessage(e));
}
}
}
}
else
{
await _httpSource.ProcessResponseAsync(
new HttpSourceRequest(() => CreateRequest(serviceEndpointUrl, pathToPackage, apiKey, logger))
{
RequestTimeout = requestTimeout
},
response =>
{
HttpStatusCode?responseStatusCode = EnsureSuccessStatusCode(response, codeNotToThrow, logger);
bool logOccurred = DetectAndLogSkippedErrorOccurrence(responseStatusCode, source, pathToPackage, response.ReasonPhrase, logger);
showPushCommandPackagePushed = !logOccurred;
return(Task.FromResult(0));
},
logger,
token);
}
return(showPushCommandPackagePushed);
}
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));
}
