Added RetentionCleanUpFrequency setting

Author: stidsborg

Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/SunshineTests.cs

@@ -45,6 +45,6 @@ public override Task SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(
         );
 
     [TestMethod]
-    public override Task InvocationModeShouldBeDirectInSunshineScenario()
-        => InvocationModeShouldBeDirectInSunshineScenario(FunctionStoreFactory.Create());
+    public override Task FunctionIsRemovedAfterRetentionPeriod()
+        => FunctionIsRemovedAfterRetentionPeriod(FunctionStoreFactory.Create());
 }

Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/SunshineTests.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Castle.Components.DictionaryAdapter.Xml;
 using Cleipnir.ResilientFunctions.CoreRuntime.Invocation;
 using Cleipnir.ResilientFunctions.Domain;
 using Cleipnir.ResilientFunctions.Helpers;
@@ -282,24 +284,48 @@ protected async Task SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(
         result.ShouldBeNull();
     }
 
-    public abstract Task InvocationModeShouldBeDirectInSunshineScenario();
-    protected async Task InvocationModeShouldBeDirectInSunshineScenario(Task<IFunctionStore> storeTask)
+    public abstract Task FunctionIsRemovedAfterRetentionPeriod();
+    protected async Task FunctionIsRemovedAfterRetentionPeriod(Task<IFunctionStore> storeTask)
     {
         var store = await storeTask;
         var unhandledExceptionCatcher = new UnhandledExceptionCatcher();
-        FunctionTypeId functionTypeId = "SomeFunctionType";
-        using var functionsRegistry = new FunctionsRegistry(store, new Settings(unhandledExceptionCatcher.Catch));
+        var functionId = TestFunctionId.Create();
+        {
+            using var functionsRegistry = new FunctionsRegistry(
+                store,
+                new Settings(
+                    unhandledExceptionCatcher.Catch,
+                    enableWatchdogs: false
+                )
+            );
+        
+            var rFunc = functionsRegistry.RegisterAction(
+                functionId.TypeId,
+                inner: (string _) => {}
+            ).Invoke;
 
-        var syncedInvocationMode = new Synced<InvocationMode>();
-        var rFunc = functionsRegistry.RegisterAction(
-            functionTypeId,
-            (string _) => syncedInvocationMode.Value = InvocationMode.Direct
-        ).Invoke;
+            await rFunc("hello world", "hello world");
+        }
 
-        await rFunc("hello world", "hello world");
+        {
+            using var functionsRegistry = new FunctionsRegistry(
+                store,
+                new Settings(
+                    unhandledExceptionCatcher.Catch,
+                    enableWatchdogs: true,
+                    retentionPeriod: TimeSpan.Zero
+                )
+            );    
+            
+            functionsRegistry.RegisterAction(
+                functionId.TypeId,
+                inner: (string _) => {}
+            );
+            
+            await BusyWait.Until(async () => await store.GetFunction(functionId) is null);
+        }
 
-        syncedInvocationMode.Value.ShouldBe(InvocationMode.Direct);
+        unhandledExceptionCatcher.ThrownExceptions.ShouldBeEmpty();
     }
-
     private class State : Domain.WorkflowState {}
 }

Core/Cleipnir.ResilientFunctions/CoreRuntime/Invocation/InvocationMode.cs

@@ -12,15 +12,15 @@ internal class RetentionWatchdog
     private readonly IFunctionStore _functionStore;
     private readonly UnhandledExceptionHandler _unhandledExceptionHandler;
     private readonly ShutdownCoordinator _shutdownCoordinator;
-    private readonly TimeSpan _checkFrequency;
+    private readonly TimeSpan _cleanUpFrequency;
     private readonly TimeSpan _delayStartUp;
     private readonly TimeSpan _retentionPeriod;
     private readonly FunctionTypeId _functionTypeId;
 
     public RetentionWatchdog(
         FunctionTypeId functionTypeId,
         IFunctionStore functionStore,
-        TimeSpan checkFrequency,
+        TimeSpan cleanUpFrequency,
         TimeSpan delayStartUp,
         TimeSpan retentionPeriod,
         UnhandledExceptionHandler unhandledExceptionHandler,
@@ -30,7 +30,7 @@ public RetentionWatchdog(
         _functionStore = functionStore;
         _unhandledExceptionHandler = unhandledExceptionHandler;
         _shutdownCoordinator = shutdownCoordinator;
-        _checkFrequency = checkFrequency;
+        _cleanUpFrequency = cleanUpFrequency;
         _delayStartUp = delayStartUp;
         _retentionPeriod = retentionPeriod;
     }
@@ -58,7 +58,7 @@ public async Task Start()
                 }
 
                 var timeElapsed = DateTime.UtcNow - now;
-                var delay = (_checkFrequency - timeElapsed).RoundUpToZero();
+                var delay = (_cleanUpFrequency - timeElapsed).RoundUpToZero();
 
                 await Task.Delay(delay);
             }

Core/Cleipnir.ResilientFunctions/CoreRuntime/Watchdogs/RetentionWatchdog.cs

@@ -60,7 +60,7 @@ public static void CreateAndStart(
         var retentionWatchdog = new RetentionWatchdog(
             functionTypeId,
             functionStore,
-            settings.WatchdogCheckFrequency,
+            settings.RetentionCleanUpFrequency,
             settings.DelayStartup,
             settings.RetentionPeriod,
             settings.UnhandledExceptionHandler,

Core/Cleipnir.ResilientFunctions/CoreRuntime/Watchdogs/WatchDogsFactory.cs

@@ -10,6 +10,7 @@ public class Settings
 {
     internal Action<RFunctionException>? UnhandledExceptionHandler { get; }
     internal TimeSpan? RetentionPeriod { get; }
+    internal TimeSpan? RetentionCleanUpFrequency { get; }
     internal TimeSpan? LeaseLength { get; }
     internal bool? EnableWatchdogs { get; }
     internal TimeSpan? WatchdogCheckFrequency { get; }
@@ -23,6 +24,7 @@ public Settings(
         Action<RFunctionException>? unhandledExceptionHandler = null, 
         TimeSpan? retentionPeriod = null,
         TimeSpan? leaseLength = null, 
+        TimeSpan? retentionCleanUpFrequency = null,
         bool? enableWatchdogs = null,
         TimeSpan? watchdogCheckFrequency = null,
         TimeSpan? messagesPullFrequency = null,
@@ -33,6 +35,7 @@ public Settings(
     {
         UnhandledExceptionHandler = unhandledExceptionHandler;
         RetentionPeriod = retentionPeriod;
+        RetentionCleanUpFrequency = retentionCleanUpFrequency;
         LeaseLength = leaseLength;
         EnableWatchdogs = enableWatchdogs;
         WatchdogCheckFrequency = watchdogCheckFrequency;
@@ -47,6 +50,7 @@ public Settings(
 public record SettingsWithDefaults(
     UnhandledExceptionHandler UnhandledExceptionHandler,
     TimeSpan RetentionPeriod,
+    TimeSpan RetentionCleanUpFrequency,
     TimeSpan LeaseLength,
     bool EnableWatchdogs,
     TimeSpan WatchdogCheckFrequency,
@@ -65,6 +69,7 @@ public SettingsWithDefaults Merge(Settings? child)
                 ? UnhandledExceptionHandler
                 : new UnhandledExceptionHandler(child.UnhandledExceptionHandler),
             child.RetentionPeriod ?? RetentionPeriod,
+            child.RetentionCleanUpFrequency ?? RetentionCleanUpFrequency,
             child.LeaseLength ?? LeaseLength,
             child.EnableWatchdogs ?? EnableWatchdogs,
             child.WatchdogCheckFrequency ?? WatchdogCheckFrequency,
@@ -80,6 +85,7 @@ public SettingsWithDefaults Merge(Settings? child)
         = new(
             UnhandledExceptionHandler: new UnhandledExceptionHandler(_ => {}),
             RetentionPeriod: TimeSpan.MaxValue,
+            RetentionCleanUpFrequency: TimeSpan.FromHours(1), 
             LeaseLength: TimeSpan.FromSeconds(10),
             EnableWatchdogs: true,
             WatchdogCheckFrequency: TimeSpan.FromSeconds(1),

Core/Cleipnir.ResilientFunctions/Domain/Settings.cs

@@ -42,6 +42,6 @@ public override Task SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(
         => SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(FunctionStoreFactory.Create());
 
     [TestMethod]
-    public override Task InvocationModeShouldBeDirectInSunshineScenario()
-        => InvocationModeShouldBeDirectInSunshineScenario(FunctionStoreFactory.Create());
+    public override Task FunctionIsRemovedAfterRetentionPeriod()
+        => FunctionIsRemovedAfterRetentionPeriod(FunctionStoreFactory.Create());
 }

Stores/MySQL/Cleipnir.ResilientFunctions.MySQL.Tests/RFunctionTests/SunshineTests.cs

@@ -41,8 +41,8 @@ public override Task SunshineScenarioNullReturningFuncWithState()
     [TestMethod]
     public override Task SecondInvocationOnNullReturningFuncReturnsNullSuccessfully()
         => SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(FunctionStoreFactory.Create());
-
+    
     [TestMethod]
-    public override Task InvocationModeShouldBeDirectInSunshineScenario()
-        => InvocationModeShouldBeDirectInSunshineScenario(FunctionStoreFactory.Create());
+    public override Task FunctionIsRemovedAfterRetentionPeriod()
+        => FunctionIsRemovedAfterRetentionPeriod(FunctionStoreFactory.Create());
 }

Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL.Tests/RFunctionTests/SunshineTests.cs

@@ -42,8 +42,7 @@ public override Task SunshineScenarioNullReturningFuncWithState()
     public override Task SecondInvocationOnNullReturningFuncReturnsNullSuccessfully()
         => SecondInvocationOnNullReturningFuncReturnsNullSuccessfully(FunctionStoreFactory.Create());
 
-
     [TestMethod]
-    public override Task InvocationModeShouldBeDirectInSunshineScenario()
-        => InvocationModeShouldBeDirectInSunshineScenario(FunctionStoreFactory.Create());
+    public override Task FunctionIsRemovedAfterRetentionPeriod()
+        => FunctionIsRemovedAfterRetentionPeriod(FunctionStoreFactory.Create());
 }