Address PR review

src/Serval/src/Serval.Shared/Services/EntityServiceBase.cs

@@ -5,7 +5,7 @@ public abstract class EntityServiceBase<T>(IRepository<T> entities)
 {
     protected IRepository<T> Entities { get; } = entities;
 
-    public async Task<T> GetAsync(string id, CancellationToken cancellationToken = default)
+    public virtual async Task<T> GetAsync(string id, CancellationToken cancellationToken = default)
     {
         T? entity = await Entities.GetAsync(id, cancellationToken);
         if (entity is null)

src/Serval/src/Serval.Translation/Services/BuildService.cs

@@ -4,13 +4,16 @@ public class BuildService(IRepository<Build> builds) : EntityServiceBase<Build>(
 {
     public async Task<IEnumerable<Build>> GetAllAsync(string parentId, CancellationToken cancellationToken = default)
     {
-        return await Entities.GetAllAsync(e => e.EngineRef == parentId, cancellationToken);
+        return await Entities.GetAllAsync(e => e.EngineRef == parentId && (e.IsInitialized ?? true), cancellationToken);
     }
 
     public Task<Build?> GetActiveAsync(string parentId, CancellationToken cancellationToken = default)
     {
         return Entities.GetAsync(
-            b => b.EngineRef == parentId && (b.State == JobState.Active || b.State == JobState.Pending),
+            b =>
+                b.EngineRef == parentId
+                && (b.IsInitialized ?? true)
+                && (b.State == JobState.Active || b.State == JobState.Pending),
             cancellationToken
         );
     }
@@ -21,7 +24,7 @@ public Task<EntityChange<Build>> GetNewerRevisionAsync(
         CancellationToken cancellationToken = default
     )
     {
-        return GetNewerRevisionAsync(e => e.Id == id, minRevision, cancellationToken);
+        return GetNewerRevisionAsync(e => e.Id == id && (e.IsInitialized ?? true), minRevision, cancellationToken);
     }
 
     public Task<EntityChange<Build>> GetActiveNewerRevisionAsync(
@@ -31,7 +34,10 @@ public Task<EntityChange<Build>> GetActiveNewerRevisionAsync(
     )
     {
         return GetNewerRevisionAsync(
-            b => b.EngineRef == parentId && (b.State == JobState.Active || b.State == JobState.Pending),
+            b =>
+                b.EngineRef == parentId
+                && (b.IsInitialized ?? true)
+                && (b.State == JobState.Active || b.State == JobState.Pending),
             minRevision,
             cancellationToken
         );

src/Serval/src/Serval.Translation/Services/EngineCleanupService.cs

@@ -1,29 +1,7 @@
-using Microsoft.Extensions.DependencyInjection;
-
 namespace Serval.Translation.Services;
 
 public class EngineCleanupService(
     IServiceProvider services,
     ILogger<EngineCleanupService> logger,
     TimeSpan? timeout = null
-) : UninitializedCleanupService<Engine>(services, logger, timeout)
-{
-    public EngineService? EngineService { get; set; }
-
-    protected override async Task DoWorkAsync(IServiceScope scope, CancellationToken cancellationToken)
-    {
-        EngineService = scope.ServiceProvider.GetRequiredService<EngineService>();
-        await base.DoWorkAsync(scope, cancellationToken);
-    }
-
-    protected override async Task DeleteEntityAsync(
-        IRepository<Engine> engines,
-        Engine engine,
-        CancellationToken cancellationToken
-    )
-    {
-        if (EngineService == null)
-            return;
-        await EngineService.DeleteAsync(engine.Id, cancellationToken);
-    }
-}
+) : UninitializedCleanupService<Engine>(services, logger, timeout) { }

src/Serval/src/Serval.Translation/Services/EngineService.cs

@@ -24,6 +24,14 @@ IScriptureDataFileService scriptureDataFileService
     private readonly ILogger<EngineService> _logger = loggerFactory.CreateLogger<EngineService>();
     private readonly IScriptureDataFileService _scriptureDataFileService = scriptureDataFileService;
 
+    public override async Task<Engine> GetAsync(string id, CancellationToken cancellationToken = default)
+    {
+        Engine engine = await base.GetAsync(id, cancellationToken);
+        if (!(engine.IsInitialized ?? true))
+            throw new EntityNotFoundException($"Could not find the {typeof(Engine).Name} '{id}'.");
+        return engine;
+    }
+
     public async Task<Models.TranslationResult> TranslateAsync(
         string engineId,
         string segment,
@@ -153,7 +161,7 @@ await Entities.UpdateAsync(
                     u.Set(e => e.IsInitialized, true);
                     u.Set(e => e.IsModelPersisted, engine.IsModelPersisted);
                 },
-                cancellationToken: cancellationToken
+                cancellationToken: CancellationToken.None
             );
         }
         catch (RpcException rpcex)

src/Serval/src/Serval.Translation/Services/UnitializedEntityCleanupService.cs

@@ -24,13 +24,15 @@ protected override async Task DoWorkAsync(IServiceScope scope, CancellationToken
     public async Task CheckEntitiesAsync(IRepository<T> entities, CancellationToken cancellationToken)
     {
         var now = DateTime.UtcNow;
-        IEnumerable<T> uninitializedEntities = (await entities.GetAllAsync(cancellationToken)).Where(b =>
-            !(b.IsInitialized ?? true) && (now - (b.DateCreated ?? DateTime.UtcNow)) > _timeout
+        IEnumerable<T> uninitializedEntities = await entities.GetAllAsync(
+            e => !(e.IsInitialized ?? true) && e.DateCreated != null && (now - e.DateCreated) > _timeout,
+            cancellationToken
         );
+
         foreach (T entity in uninitializedEntities)
         {
             _logger.LogInformation(
-                "Deleting {type} {id} because it was never successfully started",
+                "Deleting {type} {id} because it was never successfully initialized.",
                 typeof(T),
                 entity.Id
             );

src/Serval/test/Serval.Translation.Tests/Services/EngineCleanupServiceTests.cs

@@ -1,7 +1,3 @@
-using Google.Protobuf.WellKnownTypes;
-using MassTransit.Mediator;
-using Serval.Translation.V1;
-
 namespace Serval.Translation.Services;
 
 [TestFixture]
@@ -54,28 +50,6 @@ public TestEnvironment()
                 Substitute.For<ILogger<EngineCleanupService>>(),
                 TimeSpan.Zero
             );
-
-            var translationServiceClient = Substitute.For<TranslationEngineApi.TranslationEngineApiClient>();
-            translationServiceClient.DeleteAsync(Arg.Any<DeleteRequest>()).Returns(CreateAsyncUnaryCall(new Empty()));
-
-            GrpcClientFactory grpcClientFactory = Substitute.For<GrpcClientFactory>();
-            grpcClientFactory
-                .CreateClient<TranslationEngineApi.TranslationEngineApiClient>("Nmt")
-                .Returns(translationServiceClient);
-
-            var engineService = new EngineService(
-                Engines,
-                new MemoryRepository<Build>(),
-                new MemoryRepository<Pretranslation>(),
-                Substitute.For<IScopedMediator>(),
-                grpcClientFactory,
-                Substitute.For<IOptionsMonitor<DataFileOptions>>(),
-                new MemoryDataAccessContext(),
-                new LoggerFactory(),
-                Substitute.For<IScriptureDataFileService>()
-            );
-
-            Service.EngineService = engineService;
         }
 
         public EngineCleanupService Service { get; }
@@ -84,16 +58,5 @@ public async Task CheckEnginesAsync()
         {
             await Service.CheckEntitiesAsync(Engines, CancellationToken.None);
         }
-
-        private static AsyncUnaryCall<TResponse> CreateAsyncUnaryCall<TResponse>(TResponse response)
-        {
-            return new AsyncUnaryCall<TResponse>(
-                Task.FromResult(response),
-                Task.FromResult(new Metadata()),
-                () => Status.DefaultSuccess,
-                () => new Metadata(),
-                () => { }
-            );
-        }
     }
 }