git.stella-ops.org/src/Concelier/__Libraries/StellaOps.Concelier.Storage.Mongo/ServiceCollectionExtensions.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using StellaOps.Concelier.Core.Jobs;
using StellaOps.Concelier.Storage.Mongo.Advisories;
using StellaOps.Concelier.Storage.Mongo.Aliases;
using StellaOps.Concelier.Storage.Mongo.ChangeHistory;
using StellaOps.Concelier.Storage.Mongo.Documents;
using StellaOps.Concelier.Storage.Mongo.Dtos;
using StellaOps.Concelier.Storage.Mongo.Raw;
using StellaOps.Concelier.Core.Raw;
using StellaOps.Concelier.Storage.Mongo.Exporting;
using StellaOps.Concelier.Storage.Mongo.JpFlags;
using StellaOps.Concelier.Storage.Mongo.MergeEvents;
using StellaOps.Concelier.Storage.Mongo.Conflicts;
using StellaOps.Concelier.Storage.Mongo.PsirtFlags;
using StellaOps.Concelier.Storage.Mongo.Statements;
using StellaOps.Concelier.Storage.Mongo.Events;
using StellaOps.Concelier.Core.Events;
using StellaOps.Concelier.Storage.Mongo.Migrations;
using StellaOps.Concelier.Storage.Mongo.Observations;
using StellaOps.Concelier.Core.Observations;
using StellaOps.Concelier.Storage.Mongo.Linksets;
using StellaOps.Concelier.Storage.Mongo.Orchestrator;
using StellaOps.Concelier.Storage.Mongo.PolicyDelta;
using StellaOps.Concelier.Core.Linksets;

namespace StellaOps.Concelier.Storage.Mongo;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddMongoStorage(this IServiceCollection services, Action<MongoStorageOptions> configureOptions)
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configureOptions);

        // In unit/integration tests we bypass Mongo wiring entirely; callers may inject fakes.
        var isTesting = string.Equals(
            Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT"),
            "Testing",
            StringComparison.OrdinalIgnoreCase);
        var bypass = string.Equals(
            Environment.GetEnvironmentVariable("CONCELIER_BYPASS_MONGO"),
            "1",
            StringComparison.OrdinalIgnoreCase);
        if (isTesting || bypass)
        {
            return services;
        }

        services.AddOptions<MongoStorageOptions>()
            .Configure(configureOptions)
            .PostConfigure(static options =>
            {
                // Normal path: enforce validity.
                options.EnsureValid();
            });

        services.TryAddSingleton(TimeProvider.System);

        services.AddSingleton<IMongoClient>(static sp =>
        {
            var options = sp.GetRequiredService<IOptions<MongoStorageOptions>>().Value;
            return new MongoClient(options.ConnectionString);
        });

        services.AddSingleton(static sp =>
        {
            var options = sp.GetRequiredService<IOptions<MongoStorageOptions>>().Value;
            var client = sp.GetRequiredService<IMongoClient>();
            var settings = new MongoDatabaseSettings
            {
                ReadConcern = ReadConcern.Majority,
                WriteConcern = WriteConcern.WMajority,
                ReadPreference = ReadPreference.PrimaryPreferred,
            };

            var database = client.GetDatabase(options.GetDatabaseName(), settings);
            var writeConcern = database.Settings.WriteConcern.With(wTimeout: options.CommandTimeout);
            return database.WithWriteConcern(writeConcern);
        });

        services.AddScoped<IMongoSessionProvider, MongoSessionProvider>();

        services.AddSingleton<MongoBootstrapper>();
        services.AddSingleton<IJobStore, MongoJobStore>();
        services.AddSingleton<ILeaseStore, MongoLeaseStore>();
        services.AddSingleton<ISourceStateRepository, MongoSourceStateRepository>();
        services.AddSingleton<IDocumentStore, DocumentStore>();
        services.AddSingleton<IDtoStore, DtoStore>();
        services.AddSingleton<IAdvisoryStore, AdvisoryStore>();
        services.AddSingleton<IAliasStore, AliasStore>();
        services.AddSingleton<IChangeHistoryStore, MongoChangeHistoryStore>();
        services.AddSingleton<IJpFlagStore, JpFlagStore>();
        services.AddSingleton<IPsirtFlagStore, PsirtFlagStore>();
        services.AddSingleton<IMergeEventStore, MergeEventStore>();
        services.AddSingleton<IAdvisoryStatementStore, AdvisoryStatementStore>();
        services.AddSingleton<IAdvisoryConflictStore, AdvisoryConflictStore>();
        services.AddSingleton<IAdvisoryObservationStore, AdvisoryObservationStore>();
        services.AddSingleton<IAdvisoryObservationLookup, AdvisoryObservationLookup>();
        services.AddSingleton<IAdvisoryEventRepository, MongoAdvisoryEventRepository>();
        services.AddSingleton<IAdvisoryEventLog, AdvisoryEventLog>();
        services.AddSingleton<IAdvisoryObservationEventPublisher, MongoAdvisoryObservationEventPublisher>();
        services.AddSingleton<NatsAdvisoryObservationEventPublisher>();
        services.AddSingleton<IAdvisoryObservationEventTransport>(sp =>
        {
            var options = sp.GetRequiredService<IOptions<AdvisoryObservationEventPublisherOptions>>().Value;
            if (options.Enabled && string.Equals(options.Transport, "nats", StringComparison.OrdinalIgnoreCase))
            {
                return sp.GetRequiredService<NatsAdvisoryObservationEventPublisher>();
            }

            return NullAdvisoryObservationEventTransport.Instance;
        });
        services.AddSingleton<IAdvisoryObservationEventOutbox, MongoAdvisoryObservationEventOutbox>();
        services.AddSingleton<IAdvisoryRawRepository, MongoAdvisoryRawRepository>();
        services.AddSingleton<StellaOps.Concelier.Storage.Mongo.Linksets.IMongoAdvisoryLinksetStore, StellaOps.Concelier.Storage.Mongo.Linksets.ConcelierMongoLinksetStore>();
        services.AddSingleton<StellaOps.Concelier.Core.Linksets.IAdvisoryLinksetStore>(sp =>
            sp.GetRequiredService<StellaOps.Concelier.Storage.Mongo.Linksets.IMongoAdvisoryLinksetStore>());
        services.AddSingleton<StellaOps.Concelier.Core.Linksets.IAdvisoryLinksetLookup>(sp =>
            sp.GetRequiredService<StellaOps.Concelier.Storage.Mongo.Linksets.IMongoAdvisoryLinksetStore>());
        services.AddSingleton<StellaOps.Concelier.Core.Observations.IAdvisoryObservationSink, StellaOps.Concelier.Storage.Mongo.Observations.AdvisoryObservationSink>();
        services.AddSingleton<StellaOps.Concelier.Core.Linksets.IAdvisoryLinksetSink, StellaOps.Concelier.Storage.Mongo.Linksets.ConcelierMongoLinksetSink>();
        services.AddSingleton<IExportStateStore, ExportStateStore>();
        services.TryAddSingleton<ExportStateManager>();

        services.AddSingleton<IMongoCollection<JobRunDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<JobRunDocument>(MongoStorageDefaults.Collections.Jobs);
        });

        services.AddSingleton<IMongoCollection<JobLeaseDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<JobLeaseDocument>(MongoStorageDefaults.Collections.Locks);
        });

        services.AddSingleton<IMongoCollection<AdvisoryObservationDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<AdvisoryObservationDocument>(MongoStorageDefaults.Collections.AdvisoryObservations);
        });

        services.AddSingleton<IMongoCollection<AdvisoryObservationEventDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<AdvisoryObservationEventDocument>(MongoStorageDefaults.Collections.AdvisoryObservationEvents);
        });

        services.AddSingleton<IMongoCollection<OrchestratorRegistryDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<OrchestratorRegistryDocument>(MongoStorageDefaults.Collections.OrchestratorRegistry);
        });

        services.AddSingleton<IMongoCollection<OrchestratorCommandDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<OrchestratorCommandDocument>(MongoStorageDefaults.Collections.OrchestratorCommands);
        });

        services.AddSingleton<IMongoCollection<OrchestratorHeartbeatDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<OrchestratorHeartbeatDocument>(MongoStorageDefaults.Collections.OrchestratorHeartbeats);
        });

        services.AddSingleton<IMongoCollection<AdvisoryLinksetDocument>>(static sp =>
        {
            var database = sp.GetRequiredService<IMongoDatabase>();
            return database.GetCollection<AdvisoryLinksetDocument>(MongoStorageDefaults.Collections.AdvisoryLinksets);
        });

        services.AddHostedService<RawDocumentRetentionService>();
        services.AddHostedService<AdvisoryObservationTransportWorker>();

        services.AddSingleton<MongoMigrationRunner>();
        services.AddSingleton<IMongoMigration, EnsureDocumentExpiryIndexesMigration>();
        services.AddSingleton<IMongoMigration, EnsureGridFsExpiryIndexesMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryRawIdempotencyIndexMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisorySupersedesBackfillMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryCanonicalKeyBackfillMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryRawValidatorMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryObservationsRawLinksetMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryLinksetsTenantLowerMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryEventCollectionsMigration>();
        services.AddSingleton<IMongoMigration, EnsureAdvisoryObservationEventCollectionMigration>();
        services.AddSingleton<IMongoMigration, SemVerStyleBackfillMigration>();
        services.AddSingleton<IMongoMigration, EnsureOrchestratorCollectionsMigration>();
        services.AddSingleton<IMongoMigration, EnsureLinkNotMergeCollectionsMigration>();
        services.AddSingleton<IMongoMigration, EnsureLinkNotMergeShardingAndTtlMigration>();
        services.AddSingleton<IMongoMigration, EnsureLegacyAdvisoriesBackfillMigration>();
        services.AddSingleton<IMongoMigration, EnsurePolicyDeltaCheckpointsCollectionMigration>();
        services.AddSingleton<IMongoMigration, EnsurePolicyLookupIndexesMigration>();

        services.AddSingleton<IOrchestratorRegistryStore, MongoOrchestratorRegistryStore>();
        services.AddSingleton<IPolicyDeltaCheckpointStore, MongoPolicyDeltaCheckpointStore>();

        services.AddSingleton<IHostedService, AdvisoryObservationTransportWorker>();

        return services;
    }
}