private DbConnection CreateDbConnection <T>(IServiceProvider serviceProvider) where T : class, IDbConfiguration, new()
{
var connectionString = serviceProvider.GetRequiredService <IOptionsSnapshot <T> >().Value.ConnectionString;
var connectionFactory = new AzureSqlConnectionFactory(connectionString,
serviceProvider.GetRequiredService <ISecretInjector>(), Logger);
return(Task.Run(() => connectionFactory.CreateAsync()).Result);
}
protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
{
var verbose = arguments.GetOrDefault(Arguments.Verbose, false);
_maxRequeueQueueSize = arguments.GetOrDefault(Arguments.MaxRequeueQueueSize, DefaultMaxQueueSize);
CommandHelpers.AssertAzureStorage(arguments);
var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);
_statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);
_packageValidatorContextQueue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);
Logger.LogInformation(
"CONFIG storage: {Storage}",
monitoringStorageFactory);
_monitoringCursor = ValidationFactory.GetFront(monitoringStorageFactory);
_galleryCursor = CreateCursor(monitoringStorageFactory, GalleryCursorFileName);
_deletedCursor = CreateCursor(monitoringStorageFactory, DeletedCursorFileName);
var connectionString = arguments.GetOrThrow <string>(Arguments.ConnectionString);
var galleryDbConnection = new AzureSqlConnectionFactory(
connectionString,
SecretInjector,
LoggerFactory.CreateLogger <AzureSqlConnectionFactory>());
var packageContentUriBuilder = new PackageContentUriBuilder(
arguments.GetOrThrow <string>(Arguments.PackageContentUrlFormat));
var timeoutInSeconds = arguments.GetOrDefault(Arguments.SqlCommandTimeoutInSeconds, 300);
_galleryDatabaseQueryService = new GalleryDatabaseQueryService(
galleryDbConnection,
packageContentUriBuilder,
TelemetryService,
timeoutInSeconds);
var auditingStorageFactory = CommandHelpers.CreateSuffixedStorageFactory(
"Auditing",
arguments,
verbose,
new SemaphoreSlimThrottle(new SemaphoreSlim(ServicePointManager.DefaultConnectionLimit)));
_auditingStorage = auditingStorageFactory.Create();
var messageHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);
_client = new CollectorHttpClient(messageHandlerFactory());
}
/// <summary>
/// Initializes an <see cref="ISqlConnectionFactory"/>, for use by validation jobs.
/// </summary>
/// <returns>ConnectionStringBuilder, used for diagnostics.</returns>
public SqlConnectionStringBuilder RegisterDatabase <T>(
IServiceProvider services,
bool testConnection = true)
where T : IDbConfiguration
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var secretInjector = services.GetRequiredService <ISecretInjector>();
var connectionString = services.GetRequiredService <IOptionsSnapshot <T> >().Value.ConnectionString;
var connectionFactory = new AzureSqlConnectionFactory(connectionString, secretInjector);
return(RegisterDatabase(GetDatabaseKey <T>(), connectionString, testConnection, secretInjector));
}
private static void ConfigureValidationEntitiesContext(ContainerBuilder builder, ConfigurationService configuration, ISecretInjector secretInjector)
{
var connectionString = configuration.Current.SqlConnectionStringValidation;
var validationDbConnectionFactory = new AzureSqlConnectionFactory(connectionString, secretInjector);
builder.Register(c => new ValidationEntitiesContext(CreateDbConnection(validationDbConnectionFactory)))
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <ValidationEntityRepository <PackageValidationSet> >()
.As <IEntityRepository <PackageValidationSet> >()
.InstancePerLifetimeScope();
builder.RegisterType <ValidationEntityRepository <PackageValidation> >()
.As <IEntityRepository <PackageValidation> >()
.InstancePerLifetimeScope();
}
/// <summary>
/// Register a job database at initialization time. Each call should overwrite any existing
/// registration because <see cref="JobRunner"/> calls <see cref="Init"/> on every iteration.
/// </summary>
/// <returns>ConnectionStringBuilder, used for diagnostics.</returns>
private SqlConnectionStringBuilder RegisterDatabase(
string name,
string connectionString,
bool testConnection,
ISecretInjector secretInjector)
{
var connectionFactory = new AzureSqlConnectionFactory(connectionString, secretInjector, Logger);
SqlConnectionFactories[name] = connectionFactory;
if (testConnection)
{
Task.Run(() => TestConnection(name, connectionFactory)).Wait();
}
return(connectionFactory.SqlConnectionStringBuilder);
}
protected override void Load(ContainerBuilder builder)
{
var telemetryClient = TelemetryClientWrapper.Instance;
builder.RegisterInstance(telemetryClient)
.AsSelf()
.As <ITelemetryClient>()
.SingleInstance();
var diagnosticsService = new DiagnosticsService(telemetryClient);
builder.RegisterInstance(diagnosticsService)
.AsSelf()
.As <IDiagnosticsService>()
.SingleInstance();
var configuration = new ConfigurationService();
var secretReaderFactory = new SecretReaderFactory(configuration, diagnosticsService);
var secretReader = secretReaderFactory.CreateSecretReader();
var secretInjector = secretReaderFactory.CreateSecretInjector(secretReader);
builder.RegisterInstance(secretInjector)
.AsSelf()
.As <ISecretInjector>()
.SingleInstance();
configuration.SecretInjector = secretInjector;
UrlExtensions.SetConfigurationService(configuration);
builder.RegisterInstance(configuration)
.AsSelf()
.As <IGalleryConfigurationService>();
builder.Register(c => configuration.Current)
.AsSelf()
.As <IAppConfiguration>();
// Force the read of this configuration, so it will be initialized on startup
builder.Register(c => configuration.Features)
.AsSelf()
.As <FeatureConfiguration>();
builder.Register(c => configuration.PackageDelete)
.As <IPackageDeleteConfiguration>();
builder.RegisterType <TelemetryService>().As <ITelemetryService>().SingleInstance();
builder.RegisterType <CredentialBuilder>().As <ICredentialBuilder>().SingleInstance();
builder.RegisterType <CredentialValidator>().As <ICredentialValidator>().SingleInstance();
builder.RegisterInstance(LuceneCommon.GetDirectory(configuration.Current.LuceneIndexLocation))
.As <Lucene.Net.Store.Directory>()
.SingleInstance();
ConfigureSearch(builder, configuration);
builder.RegisterType <DateTimeProvider>().AsSelf().As <IDateTimeProvider>().SingleInstance();
builder.RegisterType <HttpContextCacheService>()
.AsSelf()
.As <ICacheService>()
.InstancePerLifetimeScope();
var galleryDbConnectionFactory = new AzureSqlConnectionFactory(configuration.Current.SqlConnectionString, secretInjector);
builder.RegisterInstance(galleryDbConnectionFactory)
.AsSelf()
.As <ISqlConnectionFactory>()
.SingleInstance();
builder.Register(c => new EntitiesContext(CreateDbConnection(galleryDbConnectionFactory), configuration.Current.ReadOnlyMode))
.AsSelf()
.As <IEntitiesContext>()
.As <DbContext>()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <User> >()
.AsSelf()
.As <IEntityRepository <User> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <ReservedNamespace> >()
.AsSelf()
.As <IEntityRepository <ReservedNamespace> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedFeed> >()
.AsSelf()
.As <IEntityRepository <CuratedFeed> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedPackage> >()
.AsSelf()
.As <IEntityRepository <CuratedPackage> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageRegistration> >()
.AsSelf()
.As <IEntityRepository <PackageRegistration> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Package> >()
.AsSelf()
.As <IEntityRepository <Package> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageDependency> >()
.AsSelf()
.As <IEntityRepository <PackageDependency> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageDelete> >()
.AsSelf()
.As <IEntityRepository <PackageDelete> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Certificate> >()
.AsSelf()
.As <IEntityRepository <Certificate> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <AccountDelete> >()
.AsSelf()
.As <IEntityRepository <AccountDelete> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Credential> >()
.AsSelf()
.As <IEntityRepository <Credential> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Scope> >()
.AsSelf()
.As <IEntityRepository <Scope> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageOwnerRequest> >()
.AsSelf()
.As <IEntityRepository <PackageOwnerRequest> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Organization> >()
.AsSelf()
.As <IEntityRepository <Organization> >()
.InstancePerLifetimeScope();
builder.RegisterType <CuratedFeedService>()
.AsSelf()
.As <ICuratedFeedService>()
.InstancePerLifetimeScope();
var supportDbConnectionFactory = new AzureSqlConnectionFactory(configuration.Current.SqlConnectionStringSupportRequest, secretInjector);
builder.Register(c => new SupportRequestDbContext(CreateDbConnection(supportDbConnectionFactory)))
.AsSelf()
.As <ISupportRequestDbContext>()
.InstancePerLifetimeScope();
builder.RegisterType <SupportRequestService>()
.AsSelf()
.As <ISupportRequestService>()
.InstancePerLifetimeScope();
builder.RegisterType <UserService>()
.AsSelf()
.As <IUserService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageService>()
.AsSelf()
.As <IPackageService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageDeleteService>()
.AsSelf()
.As <IPackageDeleteService>()
.InstancePerLifetimeScope();
builder.RegisterType <DeleteAccountService>()
.AsSelf()
.As <IDeleteAccountService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageOwnerRequestService>()
.AsSelf()
.As <IPackageOwnerRequestService>()
.InstancePerLifetimeScope();
builder.RegisterType <FormsAuthenticationService>()
.As <IFormsAuthenticationService>()
.InstancePerLifetimeScope();
builder.RegisterType <CookieTempDataProvider>()
.As <ITempDataProvider>()
.InstancePerLifetimeScope();
builder.RegisterType <StatusService>()
.AsSelf()
.As <IStatusService>()
.InstancePerLifetimeScope();
builder.RegisterType <SecurityPolicyService>()
.AsSelf()
.As <ISecurityPolicyService>()
.InstancePerLifetimeScope();
builder.RegisterType <ReservedNamespaceService>()
.AsSelf()
.As <IReservedNamespaceService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageUploadService>()
.AsSelf()
.As <IPackageUploadService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageOwnershipManagementService>()
.AsSelf()
.As <IPackageOwnershipManagementService>()
.InstancePerLifetimeScope();
builder.RegisterType <ValidationService>()
.AsSelf()
.As <IValidationService>()
.InstancePerLifetimeScope();
builder.RegisterType <ReadMeService>()
.AsSelf()
.As <IReadMeService>()
.InstancePerLifetimeScope();
builder.RegisterType <ApiScopeEvaluator>()
.AsSelf()
.As <IApiScopeEvaluator>()
.InstancePerLifetimeScope();
builder.RegisterType <ContentObjectService>()
.AsSelf()
.As <IContentObjectService>()
.SingleInstance();
builder.RegisterType <CertificateValidator>()
.AsSelf()
.As <ICertificateValidator>()
.SingleInstance();
builder.RegisterType <CertificateService>()
.AsSelf()
.As <ICertificateService>()
.InstancePerLifetimeScope();
Func <MailSender> mailSenderFactory = () =>
{
var settings = configuration;
if (settings.Current.SmtpUri != null && settings.Current.SmtpUri.IsAbsoluteUri)
{
var smtpUri = new SmtpUri(settings.Current.SmtpUri);
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = smtpUri.Host,
Port = smtpUri.Port,
EnableSsl = smtpUri.Secure
};
if (!string.IsNullOrWhiteSpace(smtpUri.UserName))
{
mailSenderConfiguration.UseDefaultCredentials = false;
mailSenderConfiguration.Credentials = new NetworkCredential(
smtpUri.UserName,
smtpUri.Password);
}
return(new MailSender(mailSenderConfiguration));
}
else
{
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = HostingEnvironment.MapPath("~/App_Data/Mail")
};
return(new MailSender(mailSenderConfiguration));
}
};
builder.Register(c => mailSenderFactory())
.AsSelf()
.As <IMailSender>()
.InstancePerLifetimeScope();
builder.RegisterType <MessageService>()
.AsSelf()
.As <IMessageService>()
.InstancePerLifetimeScope();
builder.Register(c => HttpContext.Current.User)
.AsSelf()
.As <IPrincipal>()
.InstancePerLifetimeScope();
IAuditingService defaultAuditingService = null;
switch (configuration.Current.StorageType)
{
case StorageType.FileSystem:
case StorageType.NotSpecified:
ConfigureForLocalFileSystem(builder, configuration);
defaultAuditingService = GetAuditingServiceForLocalFileSystem(configuration);
break;
case StorageType.AzureStorage:
ConfigureForAzureStorage(builder, configuration, telemetryClient);
defaultAuditingService = GetAuditingServiceForAzureStorage(builder, configuration);
break;
}
RegisterAsynchronousValidation(builder, configuration, secretInjector);
RegisterAuditingServices(builder, defaultAuditingService);
RegisterCookieComplianceService(builder, configuration, diagnosticsService);
// todo: bind all package curators by convention
builder.RegisterType <WebMatrixPackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
builder.RegisterType <Windows8PackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
// todo: bind all commands by convention
builder.RegisterType <AutomaticallyCuratePackageCommand>()
.AsSelf()
.As <IAutomaticallyCuratePackageCommand>()
.InstancePerLifetimeScope();
if (configuration.Current.Environment == Constants.DevelopmentEnvironment)
{
builder.RegisterType <AllowLocalHttpRedirectPolicy>()
.As <ISourceDestinationRedirectPolicy>()
.InstancePerLifetimeScope();
}
else
{
builder.RegisterType <NoLessSecureDestinationRedirectPolicy>()
.As <ISourceDestinationRedirectPolicy>()
.InstancePerLifetimeScope();
}
ConfigureAutocomplete(builder, configuration);
}
protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
{
var gallery = arguments.GetOrThrow <string>(Arguments.Gallery);
var index = arguments.GetOrThrow <string>(Arguments.Index);
var packageBaseAddress = arguments.GetOrThrow <string>(Arguments.ContentBaseAddress);
var source = arguments.GetOrThrow <string>(Arguments.Source);
var requireRepositorySignature = arguments.GetOrDefault(Arguments.RequireRepositorySignature, false);
var verbose = arguments.GetOrDefault(Arguments.Verbose, false);
var timeoutInSeconds = arguments.GetOrDefault(Arguments.SqlCommandTimeoutInSeconds, 300);
var sqlTimeout = TimeSpan.FromSeconds(timeoutInSeconds);
var connectionString = arguments.GetOrThrow <string>(Arguments.ConnectionString);
var galleryDbConnection = new AzureSqlConnectionFactory(
connectionString,
SecretInjector,
LoggerFactory.CreateLogger <AzureSqlConnectionFactory>());
var packageContentUriBuilder = new PackageContentUriBuilder(
arguments.GetOrThrow <string>(Arguments.PackageContentUrlFormat));
var galleryDatabase = new GalleryDatabaseQueryService(
galleryDbConnection,
packageContentUriBuilder,
TelemetryService,
timeoutInSeconds);
CommandHelpers.AssertAzureStorage(arguments);
var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);
var auditingStorageFactory = CommandHelpers.CreateSuffixedStorageFactory("Auditing", arguments, verbose);
var endpointConfiguration = CommandHelpers.GetEndpointConfiguration(arguments);
var messageHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);
Logger.LogInformation(
"CONFIG gallery: {Gallery} index: {Index} storage: {Storage} auditingStorage: {AuditingStorage} registration cursor uri: {RegistrationCursorUri} flat-container cursor uri: {FlatContainerCursorUri}",
gallery, index, monitoringStorageFactory, auditingStorageFactory, endpointConfiguration.RegistrationCursorUri, endpointConfiguration.FlatContainerCursorUri);
var validatorConfig = new ValidatorConfiguration(
packageBaseAddress,
requireRepositorySignature);
_packageValidator = ValidationFactory.CreatePackageValidator(
gallery,
index,
auditingStorageFactory,
validatorConfig,
endpointConfiguration,
messageHandlerFactory,
galleryDatabase,
LoggerFactory);
_queue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);
_statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);
_notificationService = new LoggerMonitoringNotificationService(LoggerFactory.CreateLogger <LoggerMonitoringNotificationService>());
_client = new CollectorHttpClient(messageHandlerFactory());
_queueLoopDuration = TimeSpan.FromHours(
arguments.GetOrDefault(
Arguments.QueueLoopDurationHours,
DefaultQueueLoopDurationHours));
_queueDelay = TimeSpan.FromSeconds(
arguments.GetOrDefault(
Arguments.QueueDelaySeconds,
DefaultQueueDelaySeconds));
_workerCount = arguments.GetOrDefault(Arguments.WorkerCount, DefaultWorkerCount);
SetUserAgentString();
}
private Task <SqlConnection> CreateNuGetSqlConnection()
{
var connectionFactory = new AzureSqlConnectionFactory(ConnectionString, SecretInjector);
return(connectionFactory.CreateAsync());
}
