Unified some cleaners.

src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemaIndexCleaner.cs → src/Squidex.Domain.Apps.Entities/AppGrainCleaner.cs

@@ -10,13 +10,13 @@ using System.Threading.Tasks;
 using Orleans;
 using Squidex.Infrastructure;
 
-namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
+namespace Squidex.Domain.Apps.Entities
 {
-    public sealed class SchemaIndexCleaner : IAppStorage
+    public sealed class AppGrainCleaner<T> : ICleanableAppStorage where T : ICleanableAppGrain
     {
         private readonly IGrainFactory grainFactory;
 
-        public SchemaIndexCleaner(IGrainFactory grainFactory)
+        public AppGrainCleaner(IGrainFactory grainFactory)
         {
             Guard.NotNull(grainFactory, nameof(grainFactory));
 
@@ -25,7 +25,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
 
         public Task ClearAsync(Guid appId)
         {
-            return grainFactory.GetGrain<ISchemasByAppIndex>(appId).ClearAsync();
+            return grainFactory.GetGrain<T>(appId).ClearAsync();
         }
     }
 }

src/Squidex.Domain.Apps.Entities/Backup/CleanerGrain.cs → src/Squidex.Domain.Apps.Entities/Backup/AppCleanerGrain.cs

@@ -21,16 +21,17 @@ using Squidex.Infrastructure;
 using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Orleans;
 using Squidex.Infrastructure.States;
+using Squidex.Infrastructure.Tasks;
 
 namespace Squidex.Domain.Apps.Entities.Backup
 {
     [Reentrant]
-    public sealed class CleanerGrain : GrainOfString, IRemindable, ICleanerGrain
+    public sealed class AppCleanerGrain : GrainOfString, IRemindable, IAppCleanerGrain
     {
         private readonly IGrainFactory grainFactory;
         private readonly IStore<Guid> store;
         private readonly IEventStore eventStore;
-        private readonly IEnumerable<IAppStorage> storages;
+        private readonly IEnumerable<ICleanableAppStorage> storages;
         private IPersistence<State> persistence;
         private bool isCleaning;
         private State state = new State();
@@ -43,7 +44,7 @@ namespace Squidex.Domain.Apps.Entities.Backup
             public HashSet<Guid> PendingApps { get; set; } = new HashSet<Guid>();
         }
 
-        public CleanerGrain(IGrainFactory grainFactory, IEventStore eventStore, IStore<Guid> store, IEnumerable<IAppStorage> storages)
+        public AppCleanerGrain(IGrainFactory grainFactory, IEventStore eventStore, IStore<Guid> store, IEnumerable<ICleanableAppStorage> storages)
         {
             Guard.NotNull(grainFactory, nameof(grainFactory));
             Guard.NotNull(store, nameof(store));
@@ -60,9 +61,9 @@ namespace Squidex.Domain.Apps.Entities.Backup
 
         public async override Task OnActivateAsync(string key)
         {
-            await RegisterOrUpdateReminder("Default", TimeSpan.Zero, TimeSpan.FromMinutes(10));
+            await RegisterOrUpdateReminder("Default", TimeSpan.Zero, TimeSpan.FromMinutes(2));
 
-            persistence = store.WithSnapshots<CleanerGrain, State, Guid>(Guid.Empty, s =>
+            persistence = store.WithSnapshots<AppCleanerGrain, State, Guid>(Guid.Empty, s =>
             {
                 state = s;
             });
@@ -81,12 +82,16 @@ namespace Squidex.Domain.Apps.Entities.Backup
 
         public Task ActivateAsync()
         {
-            return CleanAsync();
+            CleanAsync().Forget();
+
+            return TaskHelper.Done;
         }
 
         public Task ReceiveReminder(string reminderName, TickStatus status)
         {
-            return CleanAsync();
+            CleanAsync().Forget();
+
+            return TaskHelper.Done;
         }
 
         private async Task CleanAsync()

src/Squidex.Domain.Apps.Entities/Backup/BackupGrain.cs

@@ -84,6 +84,19 @@ namespace Squidex.Domain.Apps.Entities.Backup
             await CleanupAsync();
         }
 
+        public async Task ClearAsync()
+        {
+            foreach (var job in state.Jobs)
+            {
+                await CleanupArchiveAsync(job);
+                await CleanupBackupAsync(job);
+            }
+
+            state = new BackupState();
+
+            await persistence.DeleteAsync();
+        }
+
         private async Task ReadAsync()
         {
             await persistence.ReadAsync();

src/Squidex.Domain.Apps.Entities/Backup/EnqueueAppToCleanerMiddleware.cs

@@ -17,13 +17,13 @@ namespace Squidex.Domain.Apps.Entities.Backup
 {
     public sealed class EnqueueAppToCleanerMiddleware : ICommandMiddleware
     {
-        private readonly ICleanerGrain cleaner;
+        private readonly IAppCleanerGrain cleaner;
 
         public EnqueueAppToCleanerMiddleware(IGrainFactory grainFactory)
         {
             Guard.NotNull(grainFactory, nameof(grainFactory));
 
-            cleaner = grainFactory.GetGrain<ICleanerGrain>(SingleGrain.Id);
+            cleaner = grainFactory.GetGrain<IAppCleanerGrain>(SingleGrain.Id);
         }
 
         public async Task HandleAsync(CommandContext context, Func<Task> next)

src/Squidex.Domain.Apps.Entities/Backup/ICleanerGrain.cs → src/Squidex.Domain.Apps.Entities/Backup/IAppCleanerGrain.cs

@@ -11,7 +11,7 @@ using Squidex.Infrastructure.Orleans;
 
 namespace Squidex.Domain.Apps.Entities.Backup
 {
-    public interface ICleanerGrain : IBackgroundGrain
+    public interface IAppCleanerGrain : IBackgroundGrain
     {
         Task EnqueueAppAsync(Guid appId);
     }

src/Squidex.Domain.Apps.Entities/Backup/IBackupGrain.cs

@@ -8,12 +8,11 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Orleans;
 using Squidex.Infrastructure.Orleans;
 
 namespace Squidex.Domain.Apps.Entities.Backup
 {
-    public interface IBackupGrain : IGrainWithGuidKey
+    public interface IBackupGrain : ICleanableAppGrain
     {
         Task RunAsync();
 

src/Squidex.Domain.Apps.Entities/ICleanableAppGrain.cs

@@ -0,0 +1,17 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Threading.Tasks;
+using Orleans;
+
+namespace Squidex.Domain.Apps.Entities
+{
+    public interface ICleanableAppGrain : IGrainWithGuidKey
+    {
+        Task ClearAsync();
+    }
+}

src/Squidex.Domain.Apps.Entities/IAppStorage.cs → src/Squidex.Domain.Apps.Entities/ICleanableAppStorage.cs

@@ -10,7 +10,7 @@ using System.Threading.Tasks;
 
 namespace Squidex.Domain.Apps.Entities
 {
-    public interface IAppStorage
+    public interface ICleanableAppStorage
     {
         Task ClearAsync(Guid appId);
     }

src/Squidex.Domain.Apps.Entities/Rules/Indexes/IRulesByAppIndex.cs

@@ -8,11 +8,10 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Orleans;
 
 namespace Squidex.Domain.Apps.Entities.Rules
 {
-    public interface IRulesByAppIndex : IGrainWithGuidKey
+    public interface IRulesByAppIndex : ICleanableAppGrain
     {
         Task AddRuleAsync(Guid ruleId);
 
@@ -20,8 +19,6 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
         Task RebuildAsync(HashSet<Guid> rules);
 
-        Task ClearAsync();
-
         Task<List<Guid>> GetRuleIdsAsync();
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/Indexes/RuleIndexCleaner.cs

@@ -1,31 +0,0 @@
-// ==========================================================================
-//  Squidex Headless CMS
-// ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschraenkt)
-//  All rights reserved. Licensed under the MIT license.
-// ==========================================================================
-
-using System;
-using System.Threading.Tasks;
-using Orleans;
-using Squidex.Infrastructure;
-
-namespace Squidex.Domain.Apps.Entities.Rules.Indexes
-{
-    public sealed class RuleIndexCleaner : IAppStorage
-    {
-        private readonly IGrainFactory grainFactory;
-
-        public RuleIndexCleaner(IGrainFactory grainFactory)
-        {
-            Guard.NotNull(grainFactory, nameof(grainFactory));
-
-            this.grainFactory = grainFactory;
-        }
-
-        public Task ClearAsync(Guid appId)
-        {
-            return grainFactory.GetGrain<IRulesByAppIndex>(appId).ClearAsync();
-        }
-    }
-}

src/Squidex.Domain.Apps.Entities/Schemas/Indexes/ISchemasByAppIndex.cs

@@ -8,18 +8,15 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Orleans;
 
 namespace Squidex.Domain.Apps.Entities.Schemas
 {
-    public interface ISchemasByAppIndex : IGrainWithGuidKey
+    public interface ISchemasByAppIndex : ICleanableAppGrain
     {
         Task AddSchemaAsync(Guid schemaId, string name);
 
         Task RemoveSchemaAsync(Guid schemaId);
 
-        Task ClearAsync();
-
         Task RebuildAsync(Dictionary<string, Guid> schemas);
 
         Task<Guid> GetSchemaIdAsync(string name);

src/Squidex.Domain.Apps.Entities/Tags/GrainTagService.cs

@@ -13,7 +13,7 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Tags
 {
-    public sealed class GrainTagService : ITagService, IAppStorage
+    public sealed class GrainTagService : ITagService, ICleanableAppStorage
     {
         private readonly IGrainFactory grainFactory;
 

src/Squidex/Config/Domain/EntitiesServices.cs

@@ -52,8 +52,7 @@ namespace Squidex.Config.Domain
                     c.GetRequiredService<IOptions<MyUrlsOptions>>(),
                     c.GetRequiredService<IAssetStore>(),
                     exposeSourceUrl))
-                .As<IGraphQLUrlGenerator>()
-                .As<IRuleUrlGenerator>();
+                .As<IGraphQLUrlGenerator>().As<IRuleUrlGenerator>();
 
             services.AddSingletonAs<CachingGraphQLService>()
                 .As<IGraphQLService>();
@@ -86,7 +85,7 @@ namespace Squidex.Config.Domain
                 .AsSelf();
 
             services.AddSingletonAs<GrainTagService>()
-                .As<ITagService>().As<IAppStorage>();
+                .As<ITagService>().As<ICleanableAppStorage>();
 
             services.AddSingletonAs<FileTypeTagGenerator>()
                 .As<ITagGenerator<CreateAsset>>();
@@ -94,11 +93,14 @@ namespace Squidex.Config.Domain
             services.AddSingletonAs<ImageTagGenerator>()
                 .As<ITagGenerator<CreateAsset>>();
 
-            services.AddSingletonAs<RuleIndexCleaner>()
-                .As<IAppStorage>();
+            services.AddSingletonAs<AppGrainCleaner<IBackupGrain>>()
+                .As<ICleanableAppStorage>();
 
-            services.AddSingletonAs<SchemaIndexCleaner>()
-                .As<IAppStorage>();
+            services.AddSingletonAs<AppGrainCleaner<IRulesByAppIndex>>()
+                .As<ICleanableAppStorage>();
+
+            services.AddSingletonAs<AppGrainCleaner<ISchemasByAppIndex>>()
+                .As<ICleanableAppStorage>();
 
             services.AddSingletonAs<JintScriptEngine>()
                 .As<IScriptEngine>();

src/Squidex/Config/Orleans/SiloWrapper.cs

@@ -15,6 +15,7 @@ using Orleans;
 using Orleans.Configuration;
 using Orleans.Hosting;
 using Squidex.Config.Domain;
+using Squidex.Domain.Apps.Entities.Backup;
 using Squidex.Domain.Apps.Entities.Contents;
 using Squidex.Domain.Apps.Entities.Rules;
 using Squidex.Infrastructure;
@@ -62,6 +63,7 @@ namespace Squidex.Config.Orleans
                     .EnableDirectClient()
                     .AddIncomingGrainCallFilter<LocalCacheFilter>()
                     .AddStartupTask<Bootstrap<IContentSchedulerGrain>>()
+                    .AddStartupTask<Bootstrap<IAppCleanerGrain>>()
                     .AddStartupTask<Bootstrap<IEventConsumerManagerGrain>>()
                     .AddStartupTask<Bootstrap<IRuleDequeuerGrain>>()
                     .AddStartupTask((services, ct) =>

tests/Squidex.Domain.Apps.Entities.Tests/Rules/Indexes/RuleIndexCleanerTests.cs → tests/Squidex.Domain.Apps.Entities.Tests/AppGrainCleanerTests.cs

@@ -11,21 +11,21 @@ using FakeItEasy;
 using Orleans;
 using Xunit;
 
-namespace Squidex.Domain.Apps.Entities.Rules.Indexes
+namespace Squidex.Domain.Apps.Entities
 {
-    public class RuleIndexCleanerTests
+    public class AppGrainCleanerTests
     {
         private readonly IGrainFactory grainFactory = A.Fake<IGrainFactory>();
-        private readonly IRulesByAppIndex index = A.Fake<IRulesByAppIndex>();
+        private readonly ICleanableAppGrain index = A.Fake<ICleanableAppGrain>();
         private readonly Guid appId = Guid.NewGuid();
-        private readonly RuleIndexCleaner sut;
+        private readonly AppGrainCleaner<ICleanableAppGrain> sut;
 
-        public RuleIndexCleanerTests()
+        public AppGrainCleanerTests()
         {
-            A.CallTo(() => grainFactory.GetGrain<IRulesByAppIndex>(appId, null))
+            A.CallTo(() => grainFactory.GetGrain<ICleanableAppGrain>(appId, null))
                 .Returns(index);
 
-            sut = new RuleIndexCleaner(grainFactory);
+            sut = new AppGrainCleaner<ICleanableAppGrain>(grainFactory);
         }
 
         [Fact]

tests/Squidex.Domain.Apps.Entities.Tests/Backup/EnqueueAppToCleanerMiddlewareTests.cs

@@ -20,13 +20,13 @@ namespace Squidex.Domain.Apps.Entities.Backup
     {
         private readonly IGrainFactory grainFactory = A.Fake<IGrainFactory>();
         private readonly ICommandBus commandBus = A.Fake<ICommandBus>();
-        private readonly ICleanerGrain index = A.Fake<ICleanerGrain>();
+        private readonly IAppCleanerGrain index = A.Fake<IAppCleanerGrain>();
         private readonly Guid appId = Guid.NewGuid();
         private readonly EnqueueAppToCleanerMiddleware sut;
 
         public EnqueueAppToCleanerMiddlewareTests()
         {
-            A.CallTo(() => grainFactory.GetGrain<ICleanerGrain>(SingleGrain.Id, null))
+            A.CallTo(() => grainFactory.GetGrain<IAppCleanerGrain>(SingleGrain.Id, null))
                 .Returns(index);
 
             sut = new EnqueueAppToCleanerMiddleware(grainFactory);

tests/Squidex.Domain.Apps.Entities.Tests/Schemas/Indexes/SchemaIndexCleanerTests.cs

@@ -1,40 +0,0 @@
-// ==========================================================================
-//  Squidex Headless CMS
-// ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschraenkt)
-//  All rights reserved. Licensed under the MIT license.
-// ==========================================================================
-
-using System;
-using System.Threading.Tasks;
-using FakeItEasy;
-using Orleans;
-using Xunit;
-
-namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
-{
-    public class SchemaIndexCleanerTests
-    {
-        private readonly IGrainFactory grainFactory = A.Fake<IGrainFactory>();
-        private readonly ISchemasByAppIndex index = A.Fake<ISchemasByAppIndex>();
-        private readonly Guid appId = Guid.NewGuid();
-        private readonly SchemaIndexCleaner sut;
-
-        public SchemaIndexCleanerTests()
-        {
-            A.CallTo(() => grainFactory.GetGrain<ISchemasByAppIndex>(appId, null))
-                .Returns(index);
-
-            sut = new SchemaIndexCleaner(grainFactory);
-        }
-
-        [Fact]
-        public async Task Should_forward_to_index()
-        {
-            await sut.ClearAsync(appId);
-
-            A.CallTo(() => index.ClearAsync())
-                .MustHaveHappened();
-        }
-    }
-}