Removed state boolean from effect store implementations

stidsborg · stidsborg · commit 6028834c0f5d · 2024-12-20T15:42:15.000+01:00
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/EffectStoreTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/EffectStoreTests.cs
@@ -45,17 +45,17 @@ await store
         await store.SetEffectResult(functionId, storedEffect2);
         storedEffects = await store.GetEffectResults(functionId);
         storedEffects.Count.ShouldBe(2);
-        storedEffects[0].ShouldBe(storedEffect1);
-        storedEffects[1].ShouldBe(storedEffect2);
+        storedEffects.Any(s => s == storedEffect1).ShouldBeTrue();
+        storedEffects.Any(s => s == storedEffect2).ShouldBeTrue();
         
         await store.SetEffectResult(functionId, storedEffect2);
         await store.GetEffectResults(functionId);
         
         await store.SetEffectResult(functionId, storedEffect2);
         storedEffects = await store.GetEffectResults(functionId);
         storedEffects.Count.ShouldBe(2);
-        storedEffects[0].ShouldBe(storedEffect1);
-        storedEffects[1].ShouldBe(storedEffect2);
+        storedEffects.Any(s => s == storedEffect1).ShouldBeTrue();
+        storedEffects.Any(s => s == storedEffect2).ShouldBeTrue();
     }
     
     public abstract Task SingleEffectWithResultLifeCycle();
@@ -149,17 +149,17 @@ await store
             .SelectAsync(sas => sas.Count() == 2)
             .ShouldBeTrueAsync();
 
-        await store.DeleteEffectResult(functionId, storedEffect2.EffectId.ToStoredEffectId(), isState: false);
+        await store.DeleteEffectResult(functionId, storedEffect2.EffectId.ToStoredEffectId());
         var storedEffects = await store.GetEffectResults(functionId);
         storedEffects.Count.ShouldBe(1);
         storedEffects[0].EffectId.ShouldBe(storedEffect1.EffectId);
 
-        await store.DeleteEffectResult(functionId, storedEffect2.EffectId.ToStoredEffectId(), isState: false);
+        await store.DeleteEffectResult(functionId, storedEffect2.EffectId.ToStoredEffectId());
         storedEffects = await store.GetEffectResults(functionId);
         storedEffects.Count.ShouldBe(1);
         storedEffects[0].EffectId.ShouldBe(storedEffect1.EffectId);
         
-        await store.DeleteEffectResult(functionId, storedEffect1.EffectId.ToStoredEffectId(), isState: false);
+        await store.DeleteEffectResult(functionId, storedEffect1.EffectId.ToStoredEffectId());
         await store
             .GetEffectResults(functionId)
             .SelectAsync(sas => sas.Any())
@@ -268,15 +268,14 @@ protected async Task BulkInsertTest(Task<IEffectsStore> storeTask)
             Result: "some result 2".ToUtf8Bytes(),
             StoredException: null
         );
-
-
+        
         await store.SetEffectResults(storedId, [storedEffect1, storedEffect2]);
 
         var effects = await store.GetEffectResults(storedId);
         effects.Count.ShouldBe(2);
-        effects[0].EffectId.ShouldBe(storedEffect1.EffectId);
-        effects[0].Result.ShouldBe("some result 1".ToUtf8Bytes());
-        effects[1].EffectId.ShouldBe(storedEffect2.EffectId);
-        effects[1].Result.ShouldBe("some result 2".ToUtf8Bytes());
+        var effect1 = effects.Single(e => e.EffectId == storedEffect1.EffectId);
+        effect1.Result.ShouldBe("some result 1".ToUtf8Bytes());
+        var effect2 = effects.Single(e => e.EffectId == storedEffect2.EffectId);
+        effect2.Result.ShouldBe("some result 2".ToUtf8Bytes());
     }
 }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/StatesStoreTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/StatesStoreTests.cs
@@ -37,7 +37,7 @@ await statesStore.SetEffectResult(
         var state2 = states.Single(s => s.EffectId == "Id#2".ToEffectId(isState: true));
         state2.Result.ShouldBe("SomeJson#2".ToUtf8Bytes());
 
-        await statesStore.DeleteEffectResult(flowId, state1.EffectId.ToStoredEffectId(), isState: true);
+        await statesStore.DeleteEffectResult(flowId, state1.EffectId.ToStoredEffectId());
         
         states = await statesStore.GetEffectResults(flowId);
         states.Count.ShouldBe(1);
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/CrashableEffectStore.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/CrashableEffectStore.cs
@@ -40,10 +40,10 @@ public Task<IReadOnlyList<StoredEffect>> GetEffectResults(StoredId storedId)
             ? Task.FromException<IReadOnlyList<StoredEffect>>(new TimeoutException())
             : _inner.GetEffectResults(storedId);
 
-    public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId, bool isState)
+    public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId)
         => _crashed
             ? Task.FromException(new TimeoutException())
-            : _inner.DeleteEffectResult(storedId, effectId, isState);
+            : _inner.DeleteEffectResult(storedId, effectId);
 
     public Task Remove(StoredId storedId)
         => _crashed
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/Effect.cs b/Core/Cleipnir.ResilientFunctions/Domain/Effect.cs
@@ -290,7 +290,7 @@ public async Task Clear(string id)
             if (!effectResults.ContainsKey(effectId))
                 return;
         
-        await effectsStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: false), isState: false);
+        await effectsStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: false));
         lock (_sync)
             effectResults.Remove(effectId);
     }
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/EffectId.cs b/Core/Cleipnir.ResilientFunctions/Domain/EffectId.cs
@@ -1,6 +1,17 @@
 namespace Cleipnir.ResilientFunctions.Domain;
 
-public record EffectId(string Value, bool IsState);
+public record EffectId(string Value, bool IsState)
+{
+    public string Serialize() => IsState ? $"S!{Value}" : $"E!{Value}" ;
+
+    public static EffectId Deserialize(string s)
+    {
+        var suffix = s[2..];
+        var isState = s[0] == 'S';
+        
+        return new EffectId(suffix, isState);
+    }
+}
 
 public static class EffectIdExtensions
 {
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/ExistingEffects.cs b/Core/Cleipnir.ResilientFunctions/Domain/ExistingEffects.cs
@@ -47,7 +47,7 @@ public async Task<WorkStatus> GetStatus(EffectId effectId)
     public async Task Remove(string effectId)
     {
         var storedEffects = await GetStoredEffects();
-        await effectsStore.DeleteEffectResult(storedId, effectId.ToStoredEffectId(isState: false), isState: false);
+        await effectsStore.DeleteEffectResult(storedId, effectId.ToStoredEffectId(isState: false));
         storedEffects.Remove(new EffectId(effectId, IsState: false));
     }
 
@@ -61,14 +61,14 @@ private async Task Set(StoredEffect storedEffect)
     public Task SetValue<TValue>(string effectId, TValue value) => SetSucceeded(effectId, value);
 
     public Task SetStarted(string effectId) 
-        => Set(new StoredEffect(new EffectId(effectId, IsState: false), StoredEffectId.Create(effectId), WorkStatus.Started, Result: null, StoredException: null));
+        => Set(new StoredEffect(effectId.ToEffectId(), effectId.ToEffectId().ToStoredEffectId(), WorkStatus.Started, Result: null, StoredException: null));
     
     public Task SetSucceeded(string effectId)
-        => Set(new StoredEffect(new EffectId(effectId, IsState: false), StoredEffectId.Create(effectId), WorkStatus.Completed, Result: null, StoredException: null));
+        => Set(new StoredEffect(effectId.ToEffectId(), effectId.ToEffectId().ToStoredEffectId(), WorkStatus.Completed, Result: null, StoredException: null));
     
     public Task SetSucceeded<TResult>(string effectId, TResult result)
-        => Set(new StoredEffect(new EffectId(effectId, IsState: false),StoredEffectId.Create(effectId), WorkStatus.Completed, Result: serializer.SerializeEffectResult(result), StoredException: null));
+        => Set(new StoredEffect(effectId.ToEffectId(), effectId.ToEffectId().ToStoredEffectId(), WorkStatus.Completed, Result: serializer.SerializeEffectResult(result), StoredException: null));
 
     public Task SetFailed(string effectId, Exception exception)
-        => Set(new StoredEffect(new EffectId(effectId, IsState: false), StoredEffectId.Create(effectId), WorkStatus.Failed, Result: null, StoredException: serializer.SerializeException(exception)));
+        => Set(new StoredEffect(effectId.ToEffectId(), effectId.ToEffectId().ToStoredEffectId(), WorkStatus.Failed, Result: null, StoredException: serializer.SerializeException(exception)));
 }
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/ExistingStates.cs b/Core/Cleipnir.ResilientFunctions/Domain/ExistingStates.cs
@@ -56,7 +56,7 @@ private async Task<Dictionary<StateId, StoredState>> GetStoredStates()
     public async Task Remove(string stateId)
     {
         var storedStates = await GetStoredStates();
-        await _effectsStore.DeleteEffectResult(_storedId, stateId.ToStoredEffectId(isState: true), isState: true);
+        await _effectsStore.DeleteEffectResult(_storedId, stateId.ToStoredEffectId(isState: true));
         storedStates.Remove(stateId);
     }
 
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/States.cs b/Core/Cleipnir.ResilientFunctions/Domain/States.cs
@@ -86,7 +86,7 @@ private async Task RemoveInner(string id)
             if (!existingStoredStates.ContainsKey(id))
                 return;
         
-        await effectStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: true), isState: true);
+        await effectStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: true));
 
         lock (_sync)
         {
diff --git a/Core/Cleipnir.ResilientFunctions/Storage/IEffectsStore.cs b/Core/Cleipnir.ResilientFunctions/Storage/IEffectsStore.cs
@@ -10,6 +10,6 @@ public interface IEffectsStore
     Task SetEffectResult(StoredId storedId, StoredEffect storedEffect);
     Task SetEffectResults(StoredId storedId, IReadOnlyList<StoredEffect> storedEffects);
     Task<IReadOnlyList<StoredEffect>> GetEffectResults(StoredId storedId);
-    Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId, bool isState);
+    Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId);
     Task Remove(StoredId storedId);
 }
diff --git a/Core/Cleipnir.ResilientFunctions/Storage/InMemoryEffectsStore.cs b/Core/Cleipnir.ResilientFunctions/Storage/InMemoryEffectsStore.cs
@@ -1,15 +1,15 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Cleipnir.ResilientFunctions.Helpers;
 
 namespace Cleipnir.ResilientFunctions.Storage;
 
 public class InMemoryEffectsStore : IEffectsStore
 {
-    private record EffectKey(StoredEffectId EffectId, bool IsState);
-    private readonly Dictionary<StoredId, Dictionary<EffectKey, StoredEffect>> _effects = new();
-    private readonly object _sync = new();
+    private readonly Dictionary<StoredId, Dictionary<StoredEffectId, StoredEffect>> _effects = new();
+    private readonly Lock _sync = new();
 
     public Task Initialize() => Task.CompletedTask;
 
@@ -25,11 +25,10 @@ public Task SetEffectResult(StoredId storedId, StoredEffect storedEffect)
     {
         lock (_sync)
         {
-            var key = new EffectKey(storedEffect.StoredEffectId, storedEffect.EffectId.IsState);
             if (!_effects.ContainsKey(storedId))
-                _effects[storedId] = new Dictionary<EffectKey, StoredEffect>();
+                _effects[storedId] = new Dictionary<StoredEffectId, StoredEffect>();
                 
-            _effects[storedId][key] = storedEffect;
+            _effects[storedId][storedEffect.StoredEffectId] = storedEffect;
         }
         
         return Task.CompletedTask;
@@ -49,12 +48,11 @@ public Task<IReadOnlyList<StoredEffect>> GetEffectResults(StoredId storedId)
                 : ((IReadOnlyList<StoredEffect>) _effects[storedId].Values.ToList()).ToTask();
     }
 
-    public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId, bool isState)
+    public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId)
     {
-        var key = new EffectKey(effectId, isState);
         lock (_sync)
             if (_effects.ContainsKey(storedId))
-                _effects[storedId].Remove(key);
+                _effects[storedId].Remove(effectId);
 
         return Task.CompletedTask;
     }
diff --git a/Core/Cleipnir.ResilientFunctions/Storage/Types.cs b/Core/Cleipnir.ResilientFunctions/Storage/Types.cs
@@ -62,14 +62,14 @@ public record StatusAndEpoch(Status Status, int Epoch);
 
 public record StoredEffectId(Guid Value)
 {
-    public static StoredEffectId Create(string instanceId) 
-        => new(InstanceIdFactory.FromString(instanceId));
+    public static StoredEffectId Create(EffectId effectId) 
+        => new(InstanceIdFactory.FromString(effectId.Serialize()));
 }
 
 public static class StoredEffectIdExtensions
 {
-    public static StoredEffectId ToStoredEffectId(this string effectId, bool isState) => StoredEffectId.Create(effectId);
-    public static StoredEffectId ToStoredEffectId(this EffectId effectId) => StoredEffectId.Create(effectId.Value);
+    public static StoredEffectId ToStoredEffectId(this string effectId, bool isState) => ToStoredEffectId(effectId.ToEffectId(isState));
+    public static StoredEffectId ToStoredEffectId(this EffectId effectId) => StoredEffectId.Create(effectId);
 }
 
 public record StoredEffect(
@@ -81,15 +81,26 @@ public record StoredEffect(
 )
 {
     public static StoredEffect CreateCompleted(EffectId effectId, byte[] result)
-        => new(effectId with {IsState = false}, StoredEffectId.Create(effectId.Value), WorkStatus.Completed, result, StoredException: null);
+        => new(effectId, effectId.ToStoredEffectId(), WorkStatus.Completed, result, StoredException: null);
     public static StoredEffect CreateCompleted(EffectId effectId)
-        => new(effectId with {IsState = false}, StoredEffectId.Create(effectId.Value), WorkStatus.Completed, Result: null, StoredException: null);
+        => new(effectId, effectId.ToStoredEffectId(), WorkStatus.Completed, Result: null, StoredException: null);
     public static StoredEffect CreateStarted(EffectId effectId)
-        => new(effectId with {IsState = false}, StoredEffectId.Create(effectId.Value), WorkStatus.Started, Result: null, StoredException: null);
+        => new(effectId, effectId.ToStoredEffectId(), WorkStatus.Started, Result: null, StoredException: null);
     public static StoredEffect CreateFailed(EffectId effectId, StoredException storedException)
-        => new(effectId with {IsState = false}, StoredEffectId.Create(effectId.Value), WorkStatus.Failed, Result: null, storedException);
+        => new(effectId, effectId.ToStoredEffectId(), WorkStatus.Failed, Result: null, storedException);
+
     public static StoredEffect CreateState(StoredState storedState)
-        => new(new EffectId(storedState.StateId.Value, IsState: true), StoredEffectId.Create(storedState.StateId.Value), WorkStatus.Completed, storedState.StateJson, StoredException: null);
+    {
+        var effectId = storedState.StateId.Value.ToEffectId(isState: true);
+        return new StoredEffect(
+            effectId,
+            effectId.ToStoredEffectId(),
+            WorkStatus.Completed,
+            storedState.StateJson,
+            StoredException: null
+        );
+    }
+        
 };
 public record StoredState(StateId StateId, byte[] StateJson);
 
diff --git a/Stores/MariaDB/Cleipnir.ResilientFunctions.MariaDB/MariaDbEffectsStore.cs b/Stores/MariaDB/Cleipnir.ResilientFunctions.MariaDB/MariaDbEffectsStore.cs
diff --git a/Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL/PostgreSqlEffectsStore.cs b/Stores/PostgreSQL/Cleipnir.ResilientFunctions.PostgreSQL/PostgreSqlEffectsStore.cs
diff --git a/Stores/SqlServer/Cleipnir.ResilientFunctions.SqlServer/SqlServerEffectsStore.cs b/Stores/SqlServer/Cleipnir.ResilientFunctions.SqlServer/SqlServerEffectsStore.cs

Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ public async Task Clear(string id)`
`290`	`290`	`if (!effectResults.ContainsKey(effectId))`
`291`	`291`	`return;`
`292`	`292`
`293`		`- await effectsStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: false), isState: false);`
	`293`	`+ await effectsStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: false));`
`294`	`294`	`lock (_sync)`
`295`	`295`	`effectResults.Remove(effectId);`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ private async Task<Dictionary<StateId, StoredState>> GetStoredStates()`
`56`	`56`	`public async Task Remove(string stateId)`
`57`	`57`	`{`
`58`	`58`	`var storedStates = await GetStoredStates();`
`59`		`- await _effectsStore.DeleteEffectResult(_storedId, stateId.ToStoredEffectId(isState: true), isState: true);`
	`59`	`+ await _effectsStore.DeleteEffectResult(_storedId, stateId.ToStoredEffectId(isState: true));`
`60`	`60`	`storedStates.Remove(stateId);`
`61`	`61`	`}`
`62`	`62`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ private async Task RemoveInner(string id)`
`86`	`86`	`if (!existingStoredStates.ContainsKey(id))`
`87`	`87`	`return;`
`88`	`88`
`89`		`- await effectStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: true), isState: true);`
	`89`	`+ await effectStore.DeleteEffectResult(storedId, id.ToStoredEffectId(isState: true));`
`90`	`90`
`91`	`91`	`lock (_sync)`
`92`	`92`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@ public interface IEffectsStore`
`10`	`10`	`Task SetEffectResult(StoredId storedId, StoredEffect storedEffect);`
`11`	`11`	`Task SetEffectResults(StoredId storedId, IReadOnlyList<StoredEffect> storedEffects);`
`12`	`12`	`Task<IReadOnlyList<StoredEffect>> GetEffectResults(StoredId storedId);`
`13`		`- Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId, bool isState);`
	`13`	`+ Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId);`
`14`	`14`	`Task Remove(StoredId storedId);`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,15 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Linq;`
	`3`	`+using System.Threading;`
`3`	`4`	`using System.Threading.Tasks;`
`4`	`5`	`using Cleipnir.ResilientFunctions.Helpers;`
`5`	`6`
`6`	`7`	`namespace Cleipnir.ResilientFunctions.Storage;`
`7`	`8`
`8`	`9`	`public class InMemoryEffectsStore : IEffectsStore`
`9`	`10`	`{`
`10`		`- private record EffectKey(StoredEffectId EffectId, bool IsState);`
`11`		`- private readonly Dictionary<StoredId, Dictionary<EffectKey, StoredEffect>> _effects = new();`
`12`		`- private readonly object _sync = new();`
	`11`	`+ private readonly Dictionary<StoredId, Dictionary<StoredEffectId, StoredEffect>> _effects = new();`
	`12`	`+ private readonly Lock _sync = new();`
`13`	`13`
`14`	`14`	`public Task Initialize() => Task.CompletedTask;`
`15`	`15`
`@@ -25,11 +25,10 @@ public Task SetEffectResult(StoredId storedId, StoredEffect storedEffect)`
`25`	`25`	`{`
`26`	`26`	`lock (_sync)`
`27`	`27`	`{`
`28`		`- var key = new EffectKey(storedEffect.StoredEffectId, storedEffect.EffectId.IsState);`
`29`	`28`	`if (!_effects.ContainsKey(storedId))`
`30`		`- _effects[storedId] = new Dictionary<EffectKey, StoredEffect>();`
	`29`	`+ _effects[storedId] = new Dictionary<StoredEffectId, StoredEffect>();`
`31`	`30`
`32`		`- _effects[storedId][key] = storedEffect;`
	`31`	`+ _effects[storedId][storedEffect.StoredEffectId] = storedEffect;`
`33`	`32`	`}`
`34`	`33`
`35`	`34`	`return Task.CompletedTask;`
`@@ -49,12 +48,11 @@ public Task<IReadOnlyList<StoredEffect>> GetEffectResults(StoredId storedId)`
`49`	`48`	`: ((IReadOnlyList<StoredEffect>) _effects[storedId].Values.ToList()).ToTask();`
`50`	`49`	`}`
`51`	`50`
`52`		`- public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId, bool isState)`
	`51`	`+ public Task DeleteEffectResult(StoredId storedId, StoredEffectId effectId)`
`53`	`52`	`{`
`54`		`- var key = new EffectKey(effectId, isState);`
`55`	`53`	`lock (_sync)`
`56`	`54`	`if (_effects.ContainsKey(storedId))`
`57`		`- _effects[storedId].Remove(key);`
	`55`	`+ _effects[storedId].Remove(effectId);`
`58`	`56`
`59`	`57`	`return Task.CompletedTask;`
`60`	`58`	`}`