Implement settings & extend test coverage

Author: rbev

src/ServiceControl.Persistence.EFCore/DbContexts/ServiceControlDbContext.cs

@@ -7,19 +7,22 @@ namespace ServiceControl.Persistence.EFCore.DbContexts;
 public abstract class ServiceControlDbContext(DbContextOptions options) : DbContext(options)
 {
     public DbSet<EndpointSettingsEntity> EndpointSettings { get; set; }
+    public DbSet<FailedMessageEntity> FailedMessages { get; set; }
     public DbSet<KnownEndpointEntity> KnownEndpoints { get; set; }
     public DbSet<KnownEndpointInsertOnlyEntity> KnownEndpointsInsertOnly { get; set; }
+    public DbSet<TrialMetadataEntity> TrialMetadata { get; set; }
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        optionsBuilder.EnableDetailedErrors();
-    }
+        => optionsBuilder.EnableDetailedErrors();
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);
 
+        modelBuilder.ApplyConfiguration(new EndpointSettingsConfiguration());
+        modelBuilder.ApplyConfiguration(new FailedMessageEntityConfiguration());
         modelBuilder.ApplyConfiguration(new KnownEndpointConfiguration());
         modelBuilder.ApplyConfiguration(new KnownEndpointInsertOnlyConfiguration());
+        modelBuilder.ApplyConfiguration(new TrialMetadataEntityConfiguration());
     }
 }

src/ServiceControl.Persistence.EFCore/Entities/FailedMessageEntity.cs

@@ -2,8 +2,10 @@ namespace ServiceControl.Persistence.EFCore.Entities;
 
 public class FailedMessageEntity
 {
+    //todo: incomplete, needs the ingestion done...
     public Guid Id { get; set; }
-    public string EndpointAddress
-    
-    //todo: incomplete, needs the other feature finished...
+
+    public required string OriginalMessageIdentifier { get; set; }
+
+    public required string EndpointAddress { get; set; }
 }

src/ServiceControl.Persistence.EFCore/Entities/TrialMetadataEntity.cs

@@ -0,0 +1,9 @@
+namespace ServiceControl.Persistence.EFCore.Entities;
+
+public class TrialMetadataEntity
+{
+    public const int TrialMetadataId = 1;
+
+    public int Id { get; set; }
+    public DateOnly? TrialEndDate { get; set; }
+}

…Configurations/EndpointSettingsEntity.cs …rations/EndpointSettingsConfiguration.cssrc/ServiceControl.Persistence.EFCore/EntityConfigurations/EndpointSettingsEntity.cs renamed to src/ServiceControl.Persistence.EFCore/EntityConfigurations/EndpointSettingsConfiguration.cs src/ServiceControl.Persistence.EFCore/EntityConfigurations/EndpointSettingsEntity.cs renamed to src/ServiceControl.Persistence.EFCore/EntityConfigurations/EndpointSettingsConfiguration.cs

@@ -4,11 +4,12 @@ namespace ServiceControl.Persistence.EFCore.EntityConfigurations;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-public class EndpointSettingsConfiguration :  IEntityTypeConfiguration<EndpointSettingsEntity>
+public class EndpointSettingsConfiguration : IEntityTypeConfiguration<EndpointSettingsEntity>
 {
     public void Configure(EntityTypeBuilder<EndpointSettingsEntity> builder)
     {
         builder.ToTable("EndpointSettings");
         builder.HasKey(x => x.Name);
+        builder.Property(x => x.Name).HasMaxLength(200).IsRequired();
     }
 }

src/ServiceControl.Persistence.EFCore/EntityConfigurations/FailedMessageEntityConfiguration.cs

@@ -0,0 +1,20 @@
+namespace ServiceControl.Persistence.EFCore.EntityConfigurations;
+
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+public class FailedMessageEntityConfiguration : IEntityTypeConfiguration<FailedMessageEntity>
+{
+    public void Configure(EntityTypeBuilder<FailedMessageEntity> builder)
+    {
+        builder.ToTable("FailedMessages");
+        builder.HasKey(e => e.Id);
+        builder.Property(e => e.Id).ValueGeneratedNever();
+        //todo: validate column constraints
+        builder.Property(e => e.OriginalMessageIdentifier).HasMaxLength(200).IsRequired();
+        builder.Property(e => e.EndpointAddress).HasMaxLength(200).IsRequired();
+        
+        builder.HasIndex(e => new { e.OriginalMessageIdentifier, e.EndpointAddress });
+    }
+}

src/ServiceControl.Persistence.EFCore/EntityConfigurations/TrialMetadataEntityConfiguration.cs

@@ -0,0 +1,18 @@
+namespace ServiceControl.Persistence.EFCore.EntityConfigurations;
+
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+public class TrialMetadataEntityConfiguration : IEntityTypeConfiguration<TrialMetadataEntity>
+{
+    public void Configure(EntityTypeBuilder<TrialMetadataEntity> builder)
+    {
+        builder.HasKey(e => e.Id);
+        builder.HasData(new TrialMetadataEntity
+        {
+            Id = 1,
+            TrialEndDate = null
+        });
+    }
+}

src/ServiceControl.Persistence.EFCore/Implementation/DataStoreBase.cs

@@ -36,20 +36,7 @@ protected async Task ExecuteWithDbContext(Func<ServiceControlDbContext, Task> op
     /// <summary>
     /// Executes an operation with a scoped DbContext, without returning a result
     /// </summary>
-    protected async IAsyncEnumerable<T> ExecuteWithDbContext<T>(Func<ServiceControlDbContext, IAsyncEnumerable<T>> operation)
-    {
-        await using var scope = scopeFactory.CreateAsyncScope();
-        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContext>();
-        await foreach (var row in operation(dbContext))
-        {
-            yield return row;
-        }
-    }
-    
-    /// <summary>
-    /// Executes an operation with a scoped DbContext, without returning a result
-    /// </summary>
-    protected async IAsyncEnumerable<T> ExecuteWithDbContext<T>(Func<ServiceControlDbContext, IAsyncEnumerable<T>> operation, [EnumeratorCancellation] CancellationToken cancellationToken)
+    protected async IAsyncEnumerable<T> ExecuteWithDbContext<T>(Func<ServiceControlDbContext, IAsyncEnumerable<T>> operation, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         await using var scope = scopeFactory.CreateAsyncScope();
         var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContext>();

src/ServiceControl.Persistence.EFCore/Implementation/EndpointSettingsStore.cs

@@ -25,20 +25,21 @@ public Task UpdateEndpointSettings(EndpointSettings settings, CancellationToken
                 await context.SaveChangesAsync(token);
                 return;
             }
-            catch (someexception e) when (condition)
+            catch (DbUpdateException)
             {
-                //this failed because of key conflict so it's a race!
+                //this probably failed because of key conflict so try again
             }
 
             await context.Entry(entity).ReloadAsync(token);
-            entity.TrackInstances = settings.TrackInstances;
-            await context.SaveChangesAsync(token);
         }
+
+        entity.TrackInstances = settings.TrackInstances;
+        await context.SaveChangesAsync(token);
     });
 
     public Task Delete(string name, CancellationToken cancellationToken) => ExecuteWithDbContext(async context =>
     {
-        context.KnownEndpoints.RemoveRange(context.KnownEndpoints.Where(x => x.Name == name));
+        context.EndpointSettings.RemoveRange(context.EndpointSettings.Where(x => x.Name == name));
         await context.SaveChangesAsync(cancellationToken);
     });
 }

src/ServiceControl.Persistence.EFCore/Implementation/QueueAddressStore.cs

@@ -1,16 +1,32 @@
 namespace ServiceControl.Persistence.EFCore.Implementation;
 
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using ServiceControl.MessageFailures;
 using ServiceControl.Persistence.Infrastructure;
 
-public class QueueAddressStore : IQueueAddressStore
+public class QueueAddressStore(IServiceScopeFactory scopeFactory) : DataStoreBase(scopeFactory), IQueueAddressStore
 {
-    public Task<QueryResult<IList<QueueAddress>>> GetAddresses(PagingInfo pagingInfo)
-    {
-        await exe
-        var queryable 
-    }
+    public Task<QueryResult<IList<QueueAddress>>> GetAddresses(PagingInfo pagingInfo) =>
+        GetAddressesBySearchTerm(string.Empty, pagingInfo);
 
     public Task<QueryResult<IList<QueueAddress>>> GetAddressesBySearchTerm(string search, PagingInfo pagingInfo) =>
-        throw new NotImplementedException();
+        ExecuteWithDbContext(async context =>
+        {
+            var query = context.FailedMessages
+                .Where(fm => string.IsNullOrWhiteSpace(search) || fm.EndpointAddress.StartsWith(search))
+                .Select(fm => new { fm.OriginalMessageIdentifier, fm.EndpointAddress })
+                .Distinct()
+                .GroupBy(failure => failure.EndpointAddress)
+                .OrderBy(failuresByEndpoint => failuresByEndpoint.Key)
+                .Select(failuresByEndpoint => new QueueAddress
+                {
+                    PhysicalAddress = failuresByEndpoint.Key,
+                    FailedMessageCount = failuresByEndpoint.Count()
+                });
+
+            var items = await query.Skip(pagingInfo.Offset).Take(pagingInfo.PageSize).ToListAsync();
+
+            return new QueryResult<IList<QueueAddress>>(items, new QueryStatsInfo("", query.Count(), false));
+        });
 }

src/ServiceControl.Persistence.EFCore/Implementation/TrialLicenseDataProvider.cs

@@ -1,11 +1,23 @@
 namespace ServiceControl.Persistence.EFCore.Implementation;
 
-public class TrialLicenseDataProvider : ITrialLicenseDataProvider
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+public class TrialLicenseDataProvider(IServiceScopeFactory scopeFactory) : DataStoreBase(scopeFactory), ITrialLicenseDataProvider
 {
     public Task<DateOnly?> GetTrialEndDate(CancellationToken cancellationToken)
-    {
-    }
+        => ExecuteWithDbContext(async context =>
+        {
+            var trialMetadata = await context.TrialMetadata.SingleAsync(t => t.Id == TrialMetadataEntity.TrialMetadataId, cancellationToken);
+            return trialMetadata.TrialEndDate;
+        });
 
-    public Task StoreTrialEndDate(DateOnly trialEndDate, CancellationToken cancellationToken) =>
-        throw new NotImplementedException();
-}
+    public Task StoreTrialEndDate(DateOnly trialEndDate, CancellationToken cancellationToken)
+        => ExecuteWithDbContext(async context =>
+        {
+            var trialMetadata = await context.TrialMetadata.SingleAsync(t => t.Id == TrialMetadataEntity.TrialMetadataId, cancellationToken);
+            trialMetadata.TrialEndDate = trialEndDate;
+            await (Task)context.SaveChangesAsync(cancellationToken);
+        });
+}