public async Task <INuGetValidationResponse> GetResponseAsync(INuGetValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var validatorStatus = await _validatorStateService.GetStatusAsync(request);
var response = validatorStatus.ToNuGetValidationResponse();
if (validatorStatus.State == ValidationStatus.Failed)
{
_logger.LogInformation(
"SymbolValidationFailure " +
"status = {ValidationStatus}, snupkg URL = {NupkgUrl}, validation issues = {Issues}",
response.Status,
response.NupkgUrl,
response.Issues.Select(i => i.IssueCode));
}
return(response);
}
public virtual async Task <INuGetValidationResponse> GetResponseAsync(INuGetValidationRequest request)
{
var validatorStatus = await _validatorStateService.GetStatusAsync(request);
return(validatorStatus.ToNuGetValidationResponse());
}
private async Task <bool> HandleAsync(SignatureValidationMessage message, CancellationToken cancellationToken)
{
using (_logger.BeginScope("Handling signature validation message for package {PackageId} {PackageVersion}, validation {ValidationId}",
message.PackageId,
message.PackageVersion,
message.ValidationId))
{
// Find the signature validation entity that matches this message.
var validation = await _validatorStateService.GetStatusAsync(message.ValidationId);
// A signature validation should be queued with ValidatorState == Incomplete.
if (validation == null)
{
_logger.LogInformation(
"Could not find validation entity, requeueing (package: {PackageId} {PackageVersion}, validationId: {ValidationId})",
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
else if (validation.State == ValidationStatus.NotStarted)
{
_logger.LogWarning(
"Unexpected signature verification status '{ValidatorState}' when 'Incomplete' was expected, requeueing (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
else if (validation.State != ValidationStatus.Incomplete)
{
_logger.LogWarning(
"Terminal signature verification status '{ValidatorState}' when 'Incomplete' was expected, dropping message (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Consume the message.
return(true);
}
// Validate package
using (var packageStream = await _packageDownloader.DownloadAsync(message.NupkgUri, cancellationToken))
{
var result = await _signatureValidator.ValidateAsync(
validation.PackageKey,
packageStream,
message,
cancellationToken);
validation.State = result.State;
// Save any issues if the resulting state is terminal.
if (validation.State == ValidationStatus.Failed ||
validation.State == ValidationStatus.Succeeded)
{
validation.ValidatorIssues = validation.ValidatorIssues ?? new List <ValidatorIssue>();
foreach (var issue in result.Issues)
{
validation.ValidatorIssues.Add(new ValidatorIssue
{
IssueCode = issue.IssueCode,
Data = issue.Serialize(),
});
}
}
// Save the .nupkg URL if the resulting state is successful.
if (validation.State == ValidationStatus.Succeeded &&
result.NupkgUri != null)
{
validation.NupkgUrl = result.NupkgUri.AbsoluteUri;
}
}
// The signature validator should do all of the work to bring this validation to its completion.
if (validation.State != ValidationStatus.Succeeded &&
validation.State != ValidationStatus.Failed)
{
_logger.LogError("The signature validator should have set the status 'Succeeded' or 'Failed', not " +
"'{ValidatorState}' (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
return(false);
}
// Save the resulting validation status.
var completed = await SaveStatusAsync(validation, message);
if (completed && _featureFlagService.IsQueueBackEnabled())
{
_logger.LogInformation("Sending queue-back message for validation {ValidationId}.", message.ValidationId);
var messageData = PackageValidationMessageData.NewCheckValidator(message.ValidationId);
await _validationEnqueuer.SendMessageAsync(messageData);
}
return(completed);
}
}
public async Task <IValidationResult> GetResultAsync(IValidationRequest request)
{
var validatorStatus = await _validatorStateService.GetStatusAsync(request);
return(validatorStatus.ToValidationResult());
}
public async Task <ValidationStatus> GetStatusAsync(IValidationRequest request)
{
var validatorStatus = await _validatorStateService.GetStatusAsync(request);
return(validatorStatus.State);
}
public async Task <bool> HandleAsync(SymbolsValidatorMessage message)
{
using (_logger.BeginScope("{ValidatorName}: Handling message for {PackageId} {PackageVersion} validation set {ValidationId}",
ValidatorName.SymbolsValidator,
message.PackageId,
message.PackageNormalizedVersion,
message.ValidationId))
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var validation = await _validatorStateService.GetStatusAsync(message.ValidationId);
// A validation should be queued with ValidatorState == Incomplete.
if (validation == null)
{
_logger.LogInformation(
"{ValidatorName} : Could not find validation entity, requeueing (package: {PackageId} {PackageVersion}, validationId: {ValidationId})",
ValidatorName.SymbolsValidator,
message.PackageId,
message.PackageNormalizedVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
else if (validation.State == ValidationStatus.NotStarted)
{
_logger.LogWarning(
"{ValidatorName}:Unexpected status '{ValidatorState}' when 'Incomplete' was expected, requeueing package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
ValidatorName.SymbolsValidator,
validation.State,
message.PackageId,
message.PackageNormalizedVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
// Final states
else if (validation.State == ValidationStatus.Failed || validation.State == ValidationStatus.Succeeded)
{
_logger.LogWarning(
"{ValidatorName}:Terminal symbol verification status '{ValidatorState}' when 'Incomplete' was expected, dropping message (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
ValidatorName.SymbolsValidator,
validation.State,
message.PackageId,
message.PackageNormalizedVersion,
message.ValidationId);
// Consume the message.
return(true);
}
var validationResult = await _symbolValidatorService.ValidateSymbolsAsync(message, CancellationToken.None);
if (validationResult.Status == ValidationStatus.Failed || validationResult.Status == ValidationStatus.Succeeded)
{
validation.State = validationResult.Status;
validation.ValidatorIssues = validation.ValidatorIssues ?? new List <ValidatorIssue>();
foreach (var issue in validationResult.Issues)
{
validation.ValidatorIssues.Add(new ValidatorIssue
{
IssueCode = issue.IssueCode,
Data = issue.Serialize(),
});
}
if (validationResult.NupkgUrl != null)
{
validation.NupkgUrl = validationResult.NupkgUrl;
}
return(await SaveStatusAsync(validation, message, MaxDBSaveRetry));
}
_logger.LogWarning(
"{ValidatorName}:The validation did not return a complete status for package {PackageId} {PackageVersion} for validation id: {ValidationId} .",
ValidatorName.SymbolsValidator,
message.PackageId,
message.PackageNormalizedVersion,
message.ValidationId);
return(false);
}
}
private async Task <bool> HandleAsync(SignatureValidationMessage message, CancellationToken cancellationToken)
{
// Find the signature validation entity that matches this message.
var validation = await _validatorStateService.GetStatusAsync(message.ValidationId);
// A signature validation should be queued with ValidatorState == Incomplete.
if (validation == null)
{
_logger.LogInformation(
"Could not find validation entity, requeueing (package: {PackageId} {PackageVersion}, validationId: {ValidationId})",
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
else if (validation.State == ValidationStatus.NotStarted)
{
_logger.LogWarning(
"Unexpected signature verification status '{ValidatorState}' when 'Incomplete' was expected, requeueing (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Message may be retried.
return(false);
}
else if (validation.State != ValidationStatus.Incomplete)
{
_logger.LogWarning(
"Terminal signature verification status '{ValidatorState}' when 'Incomplete' was expected, dropping message (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
// Consume the message.
return(true);
}
// Validate package
using (var packageStream = await DownloadPackageAsync(message.NupkgUri, cancellationToken))
using (var package = new PackageArchiveReader(packageStream, leaveStreamOpen: false))
{
await _signatureValidator.ValidateAsync(package, validation, message, cancellationToken);
}
// The signature validator should do all of the work to bring this validation to its completion.
if (validation.State != ValidationStatus.Succeeded &&
validation.State != ValidationStatus.Failed)
{
_logger.LogError("The signature validator should have set the status 'Succeeded' or 'Failed', not " +
"'{ValidatorState}' (package id: {PackageId} package version: {PackageVersion} validation id: {ValidationId})",
validation.State,
message.PackageId,
message.PackageVersion,
message.ValidationId);
return(false);
}
// Save the resulting validation status.
return(await SaveStatusAsync(validation, message));
}