public RegistrationListedValidator(
RegistrationEndpoint endpoint,
ValidatorConfiguration config,
ILogger <RegistrationListedValidator> logger)
: base(endpoint, config, logger)
{
}
public RegistrationRequireLicenseAcceptanceValidator(
RegistrationEndpoint endpoint,
ValidatorConfiguration config,
ILogger <RegistrationRequireLicenseAcceptanceValidator> logger)
: base(endpoint, config, logger)
{
}
public RegistrationListedValidator(
IDictionary <FeedType, SourceRepository> feedToSource,
ValidatorConfiguration config,
ILogger <RegistrationListedValidator> logger)
: base(config, logger)
{
}
public FlatContainerValidator(
FlatContainerEndpoint endpoint,
ValidatorConfiguration config,
ILogger<FlatContainerValidator> logger)
: base(endpoint, config, logger)
{
}
public SearchHasVersionValidator(
SearchEndpoint endpoint,
ValidatorConfiguration config,
ILogger <Validator> logger)
: base(endpoint, config, logger)
{
}
public PackageValidator Create(
string galleryUrl,
string indexUrl,
StorageFactory auditingStorageFactory,
IEnumerable <EndpointFactory.Input> endpointInputs,
Func <HttpMessageHandler> messageHandlerFactory,
ValidatorConfiguration validatorConfig,
bool verbose = false)
{
if (string.IsNullOrEmpty(galleryUrl))
{
throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(galleryUrl));
}
if (string.IsNullOrEmpty(indexUrl))
{
throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(indexUrl));
}
if (auditingStorageFactory == null)
{
throw new ArgumentNullException(nameof(auditingStorageFactory));
}
if (endpointInputs == null)
{
throw new ArgumentNullException(nameof(endpointInputs));
}
if (messageHandlerFactory == null)
{
throw new ArgumentNullException(nameof(messageHandlerFactory));
}
if (validatorConfig == null)
{
throw new ArgumentNullException(nameof(validatorConfig));
}
var validatorFactory = new ValidatorFactory(validatorConfig, _loggerFactory);
var endpointFactory = new EndpointFactory(validatorFactory, messageHandlerFactory, _loggerFactory);
var validators = new List <IAggregateValidator>();
validators.AddRange(endpointInputs.Select(e => endpointFactory.Create(e)));
validators.Add(new CatalogAggregateValidator(validatorFactory, validatorConfig));
var feedToSource = new Dictionary <FeedType, SourceRepository>()
{
{ FeedType.HttpV2, new SourceRepository(new PackageSource(galleryUrl), GetResourceProviders(ResourceProvidersToInjectV2), FeedType.HttpV2) },
{ FeedType.HttpV3, new SourceRepository(new PackageSource(indexUrl), GetResourceProviders(ResourceProvidersToInjectV3), FeedType.HttpV3) }
};
return(new PackageValidator(
validators,
auditingStorageFactory,
feedToSource,
_loggerFactory.CreateLogger <PackageValidator>(),
_loggerFactory.CreateLogger <ValidationContext>()));
}
public RegistrationRequireLicenseAcceptanceValidator(
IDictionary <FeedType, SourceRepository> feedToSource,
ValidatorConfiguration config,
ILogger <RegistrationRequireLicenseAcceptanceValidator> logger)
: base(config, logger)
{
}
public PackageIsRepositorySignedValidator(
FlatContainerEndpoint endpoint,
ValidatorConfiguration config,
ILogger <PackageIsRepositorySignedValidator> logger)
: base(endpoint, config, logger)
{
}
public PackageHasSignatureValidator(
CatalogEndpoint endpoint,
ValidatorConfiguration config,
ILogger <PackageHasSignatureValidator> logger)
: base(endpoint, config, logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static void RegisterValidatorConfiguration(
this ContainerBuilder builder,
ValidatorConfiguration validatorConfig)
{
if (validatorConfig == null)
{
throw new ArgumentNullException(nameof(validatorConfig));
}
builder
.RegisterInstance(validatorConfig)
.AsSelf();
}
public static PackageValidator CreatePackageValidator(
string galleryUrl,
string indexUrl,
StorageFactory auditingStorageFactory,
ValidatorConfiguration validatorConfig,
EndpointConfiguration endpointConfig,
Func <HttpMessageHandler> messageHandlerFactory,
IGalleryDatabaseQueryService galleryDatabase,
ILoggerFactory loggerFactory)
{
if (auditingStorageFactory == null)
{
throw new ArgumentNullException(nameof(auditingStorageFactory));
}
var collection = new ServiceCollection();
collection.AddSingleton(loggerFactory);
collection.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
var builder = new ContainerBuilder();
builder.Populate(collection);
builder.RegisterValidatorConfiguration(validatorConfig);
builder.RegisterEndpointConfiguration(endpointConfig);
builder.RegisterMessageHandlerFactory(messageHandlerFactory);
builder.RegisterEndpoints(endpointConfig);
builder.RegisterSourceRepositories(galleryUrl, indexUrl, galleryDatabase);
builder.RegisterValidators(endpointConfig);
builder
.RegisterInstance(auditingStorageFactory)
.AsSelf()
.As <StorageFactory>();
builder.RegisterType <PackageValidator>();
var container = builder.Build();
return(container.Resolve <PackageValidator>());
}
public FlatContainerValidator(ValidatorConfiguration config, ILogger <FlatContainerValidator> logger)
: base(config, logger)
{
}
public PackageIsRepositorySignedValidator(
ValidatorConfiguration config,
ILogger <PackageIsRepositorySignedValidator> logger)
: base(config, logger)
{
}
public RegistrationIdValidator(ValidatorConfiguration config, ILogger <RegistrationIdValidator> logger)
: base(config, logger)
{
}
protected Validator(ValidatorConfiguration config, ILogger <Validator> logger)
{
Config = config ?? throw new ArgumentNullException(nameof(config));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
CommonLogger = logger.AsCommon();
}
/// <summary>
/// Create a new validator factory.
/// </summary>
/// <param name="validatorConfig">The config that will be passed to <see cref="IValidator"/>s.</param>
/// <param name="loggerFactory">The factory used to create <see cref="IValidator"/>s' loggers.</param>
public ValidatorFactory(ValidatorConfiguration validatorConfig, ILoggerFactory loggerFactory)
{
_validatorConfig = validatorConfig ?? throw new ArgumentNullException(nameof(validatorConfig));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
}
