Simplify serializer

stidsborg · Jan 24, 2025 · 2847595 · 2847595
1 parent c684903
commit 2847595
Show file tree

Hide file tree

Showing 18 changed files with 155 additions and 237 deletions.
diff --git a/...lientFunctions.Tests/InMemoryTests/RegistrationTests/RActionWithStateRegistrationTests.cs b/...lientFunctions.Tests/InMemoryTests/RegistrationTests/RActionWithStateRegistrationTests.cs
@@ -54,38 +54,23 @@ private class Serializer : ISerializer
         public bool Invoked { get; set; }
         private ISerializer Default { get; } = DefaultSerializer.Instance;
 
-        public byte[] SerializeParameter<TParam>(TParam parameter) 
+        public byte[] Serialize<T>(T value) 
         {
             Invoked = true;
-            return Default.SerializeParameter(parameter);
+            return Default.Serialize(value);
         }
 
-        public TParam DeserializeParameter<TParam>(byte[] json) 
-            => Default.DeserializeParameter<TParam>(json);
+        public T Deserialize<T>(byte[] json) 
+            => Default.Deserialize<T>(json);
 
         public StoredException SerializeException(FatalWorkflowException exception)
             => Default.SerializeException(exception);
         public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException)
             => Default.DeserializeException(flowId, storedException);
-
-        public byte[] SerializeResult<TResult>(TResult result)  
-            => Default.SerializeResult(result);
-        public TResult DeserializeResult<TResult>(byte[] json) 
-            => Default.DeserializeResult<TResult>(json);
-
+
         public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
             => Default.SerializeMessage(message);
         public object DeserializeMessage(byte[] json, byte[] type)
             => Default.DeserializeMessage(json, type);
-
-        public byte[] SerializeEffectResult<TResult>(TResult result)
-            => Default.SerializeEffectResult(result);
-        public TResult DeserializeEffectResult<TResult>(byte[] json)
-            => Default.DeserializeEffectResult<TResult>(json);
-
-        public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-            => Default.SerializeState(state);
-        public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-            => Default.DeserializeState<TState>(json);
     }
 }
diff --git a/...eipnir.ResilientFunctions.Tests/InMemoryTests/RegistrationTests/RFuncRegistrationTests.cs b/...eipnir.ResilientFunctions.Tests/InMemoryTests/RegistrationTests/RFuncRegistrationTests.cs
@@ -59,38 +59,22 @@ private class Serializer : ISerializer
         public bool Invoked { get; set; }
         private ISerializer Default { get; } = DefaultSerializer.Instance;
 
-        public byte[] SerializeParameter<TParam>(TParam parameter) 
+        public byte[] Serialize<T>(T value) 
         {
             Invoked = true;
-            return Default.SerializeParameter(parameter);
+            return Default.Serialize(value);
         }
-        public TParam DeserializeParameter<TParam>(byte[] json) 
-            => Default.DeserializeParameter<TParam>(json);
+        public T Deserialize<T>(byte[] json) 
+            => Default.Deserialize<T>(json);
 
         public StoredException SerializeException(FatalWorkflowException exception)
             => Default.SerializeException(exception);
         public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException)
             => Default.DeserializeException(flowId, storedException);
-
-        public byte[] SerializeResult<TResult>(TResult result)
-            => Default.SerializeResult(result);
-        public TResult DeserializeResult<TResult>(byte[] json) 
-            => Default.DeserializeResult<TResult>(json);
-
+
         public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
             => Default.SerializeMessage(message);
         public object DeserializeMessage(byte[] json, byte[] type)
             => Default.DeserializeMessage(json, type);
-
-        public byte[] SerializeEffectResult<TResult>(TResult result)
-            => Default.SerializeEffectResult(result);
-        public TResult DeserializeEffectResult<TResult>(byte[] json)
-            => Default.DeserializeEffectResult<TResult>(json);
-
-        public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-            => Default.SerializeState(state);
-
-        public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-            => Default.DeserializeState<TState>(json);
     }
 }
diff --git a/...silientFunctions.Tests/InMemoryTests/RegistrationTests/RFuncWithStateRegistrationTests.cs b/...silientFunctions.Tests/InMemoryTests/RegistrationTests/RFuncWithStateRegistrationTests.cs
@@ -59,37 +59,22 @@ private class Serializer : ISerializer
         public bool Invoked { get; set; }
         private ISerializer Default { get; } = DefaultSerializer.Instance;
 
-        public byte[] SerializeParameter<TParam>(TParam parameter)
+        public byte[] Serialize<T>(T parameter)
         {
             Invoked = true;
-            return Default.SerializeParameter(parameter);
+            return Default.Serialize(parameter);
         }
-        public TParam DeserializeParameter<TParam>(byte[] json)
-            => Default.DeserializeParameter<TParam>(json);
+        public T Deserialize<T>(byte[] bytes)
+            => Default.Deserialize<T>(bytes);
 
         public StoredException SerializeException(FatalWorkflowException exception)
             => Default.SerializeException(exception);
         public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException)
             => Default.DeserializeException(flowId, storedException);
 
-        public byte[] SerializeResult<TResult>(TResult result) 
-            => Default.SerializeResult(result);
-        public TResult DeserializeResult<TResult>(byte[] json) 
-            => Default.DeserializeResult<TResult>(json);
-
         public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
             => Default.SerializeMessage(message);
         public object DeserializeMessage(byte[] json, byte[] type)
             => Default.DeserializeMessage(json, type);
-
-        public byte[] SerializeEffectResult<TResult>(TResult result)
-            => Default.SerializeEffectResult(result);
-        public TResult DeserializeEffectResult<TResult>(byte[] json)
-            => Default.DeserializeEffectResult<TResult>(json);
-
-        public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-            => Default.SerializeState(state);
-        public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-            => Default.DeserializeState<TState>(json);
     }
 }
diff --git a/...Cleipnir.ResilientFunctions.Tests/Messaging/TestTemplates/CustomMessageSerializerTests.cs b/...Cleipnir.ResilientFunctions.Tests/Messaging/TestTemplates/CustomMessageSerializerTests.cs
@@ -61,22 +61,17 @@ private class EventSerializer : ISerializer
         public Utils.SyncedList<object> EventToSerialize { get; } = new();
         public Utils.SyncedList<Tuple<string, string>> EventToDeserialize { get; }= new();
 
-        public byte[] SerializeParameter<TParam>(TParam parameter)  
-            => DefaultSerializer.Instance.SerializeParameter(parameter);
+        public byte[] Serialize<T>(T value)  
+            => DefaultSerializer.Instance.Serialize(value);
 
-        public TParam DeserializeParameter<TParam>(byte[] json) 
-            => DefaultSerializer.Instance.DeserializeParameter<TParam>(json);
+        public T Deserialize<T>(byte[] json) 
+            => DefaultSerializer.Instance.Deserialize<T>(json);
 
         public StoredException SerializeException(FatalWorkflowException exception)
             => DefaultSerializer.Instance.SerializeException(exception);
         public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException)
             => DefaultSerializer.Instance.DeserializeException(flowId, storedException);
 
-        public byte[] SerializeResult<TResult>(TResult result) 
-            => DefaultSerializer.Instance.SerializeResult(result);
-        public TResult DeserializeResult<TResult>(byte[] json) 
-            => DefaultSerializer.Instance.DeserializeResult<TResult>(json);
-
         public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
         {
             EventToSerialize.Add(message);
@@ -87,15 +82,5 @@ public object DeserializeMessage(byte[] json, byte[] type)
             EventToDeserialize.Add(Tuple.Create(json.ToStringFromUtf8Bytes(), type.ToStringFromUtf8Bytes()));
             return DefaultSerializer.Instance.DeserializeMessage(json, type);
         }
-
-        public byte[] SerializeEffectResult<TResult>(TResult result)
-            => DefaultSerializer.Instance.SerializeEffectResult(result);
-        public TResult DeserializeEffectResult<TResult>(byte[] json)
-            => DefaultSerializer.Instance.DeserializeEffectResult<TResult>(json);
-
-        public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-            => DefaultSerializer.Instance.SerializeState(state);
-        public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-            => DefaultSerializer.Instance.DeserializeState<TState>(json);
     }
 }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/Messaging/TestTemplates/MessagesTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/Messaging/TestTemplates/MessagesTests.cs
@@ -434,22 +434,17 @@ private class ExceptionThrowingEventSerializer : ISerializer
         public ExceptionThrowingEventSerializer(Type failDeserializationOnType) 
             => _failDeserializationOnType = failDeserializationOnType;
 
-        public byte[] SerializeParameter<TParam>(TParam parameter) 
-            => DefaultSerializer.Instance.SerializeParameter(parameter);
+        public byte[] Serialize<T>(T value) 
+            => DefaultSerializer.Instance.Serialize(value);
 
-        public TParam DeserializeParameter<TParam>(byte[] json)
-            => DefaultSerializer.Instance.DeserializeParameter<TParam>(json);
+        public T Deserialize<T>(byte[] json)
+            => DefaultSerializer.Instance.Deserialize<T>(json);
 
         public StoredException SerializeException(FatalWorkflowException exception)
             => DefaultSerializer.Instance.SerializeException(exception);
         public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException)
             => DefaultSerializer.Instance.DeserializeException(flowId, storedException);
-
-        public byte[] SerializeResult<TResult>(TResult result)
-            => DefaultSerializer.Instance.SerializeResult(result);
-        public TResult DeserializeResult<TResult>(byte[] json)
-            => DefaultSerializer.Instance.DeserializeResult<TResult>(json);
-
+
         public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
             => DefaultSerializer.Instance.SerializeMessage(message);
 
@@ -461,15 +456,5 @@ public object DeserializeMessage(byte[] json, byte[] type)
 
             return DefaultSerializer.Instance.DeserializeMessage(json, type);
         }
-
-        public byte[] SerializeEffectResult<TResult>(TResult result)
-            => DefaultSerializer.Instance.SerializeEffectResult(result);
-        public TResult DeserializeEffectResult<TResult>(byte[] json)
-            => DefaultSerializer.Instance.DeserializeEffectResult<TResult>(json);
-
-        public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
-            => DefaultSerializer.Instance.SerializeState(state);
-        public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
-            => DefaultSerializer.Instance.DeserializeState<TState>(json);
     }
 }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/ControlPanelTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/ControlPanelTests.cs
@@ -376,7 +376,7 @@ protected async Task SucceedingExistingFunctionFromControlPanelSucceeds(Task<IFu
         var sf = await store.GetFunction(rFunc.MapToStoredId(functionId));
         sf.ShouldNotBeNull();
         sf.Status.ShouldBe(Status.Succeeded);
-        var result = DefaultSerializer.Instance.DeserializeResult<string>(sf.Result!);
+        var result = DefaultSerializer.Instance.Deserialize<string>(sf.Result!);
         result.ShouldBe("hello world");
 
         unhandledExceptionCatcher.ShouldNotHaveExceptions();

diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/StoreTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/StoreTests.cs
@@ -373,7 +373,7 @@ await store.PostponeFunction(
         sf.Epoch.ShouldBe(0);
         sf.Status.ShouldBe(Status.Executing);
         DefaultSerializer.Instance
-            .DeserializeParameter<string>(sf.Parameter!)
+            .Deserialize<string>(sf.Parameter!)
             .ShouldBe(PARAM);
     }
 

diff --git a/Core/Cleipnir.ResilientFunctions/CoreRuntime/Invocation/InvocationHelper.cs b/Core/Cleipnir.ResilientFunctions/CoreRuntime/Invocation/InvocationHelper.cs
@@ -96,7 +96,7 @@ public async Task<TReturn> WaitForFunctionResult(FlowId flowId, StoredId storedI
                     return 
                         storedFunction.Result == null 
                             ? default!
-                            : _settings.Serializer.DeserializeResult<TReturn>(storedFunction.Result);
+                            : _settings.Serializer.Deserialize<TReturn>(storedFunction.Result);
                 case Status.Failed:
                     throw Serializer.DeserializeException(flowId, storedFunction.Exception!);
                 case Status.Postponed:
@@ -274,7 +274,7 @@ public async Task<PreparedReInvocation> PrepareForReInvocation(StoredId storedId
         {
             var param = sf.Parameter == null 
                 ? default 
-                : Serializer.DeserializeParameter<TParam>(sf.Parameter);                
+                : Serializer.Deserialize<TParam>(sf.Parameter);                
 
             return new PreparedReInvocation(flowId, param, sf.Epoch, runningFunction, sf.ParentId);
         }
@@ -370,10 +370,10 @@ public async Task Interrupt(IReadOnlyList<StoredId> storedIds)
             Param:
                 sf.Parameter == null 
                 ? default
-                : serializer.DeserializeParameter<TParam>(sf.Parameter),
+                : serializer.Deserialize<TParam>(sf.Parameter),
             Result: sf.Result == null 
                 ? default 
-                : serializer.DeserializeResult<TReturn>(sf.Result),
+                : serializer.Deserialize<TReturn>(sf.Result),
             FatalWorkflowException: sf.Exception == null 
                 ? null 
                 : serializer.DeserializeException(flowId, sf.Exception)
@@ -400,7 +400,7 @@ await _functionStore.BulkScheduleFunctions(
                 new IdWithParam(
                     new StoredId(_storedType, bw.Instance.ToStoredInstance()),
                     bw.Instance,
-                    _isParamlessFunction ? null : serializer.SerializeParameter(bw.Param)
+                    _isParamlessFunction ? null : serializer.Serialize(bw.Param)
                 )
             ),
             parent?.StoredId
@@ -487,7 +487,7 @@ public DistributedSemaphores CreateSemaphores(StoredId storedId, Effect effect)
 
         return param is null
             ? null 
-            : Serializer.SerializeParameter(param);
+            : Serializer.Serialize(param);
     }
 
     private byte[]? SerializeResult(TReturn? result)
@@ -497,7 +497,7 @@ public DistributedSemaphores CreateSemaphores(StoredId storedId, Effect effect)
 
         return result is null
             ? null 
-            : Serializer.SerializeResult(result);
+            : Serializer.Serialize(result);
     }
 
     public InnerScheduled<TReturn> CreateInnerScheduled(List<FlowId> scheduledIds, Workflow? parentWorkflow, bool? detach)
@@ -543,7 +543,7 @@ public InnerScheduled<TReturn> CreateInnerScheduled(List<FlowId> scheduledIds, W
                     FlowId = fc.Id,
                     Result = fc.Result == null
                         ? default!
-                        : serializer.DeserializeResult<TReturn>(fc.Result)    
+                        : serializer.Deserialize<TReturn>(fc.Result)    
                 }
 
             ).ToDictionary(a => a.FlowId, a => a.Result);

diff --git a/Core/Cleipnir.ResilientFunctions/CoreRuntime/Serialization/CustomSerializableDecorator.cs b/Core/Cleipnir.ResilientFunctions/CoreRuntime/Serialization/CustomSerializableDecorator.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using Cleipnir.ResilientFunctions.Domain;
+using Cleipnir.ResilientFunctions.Helpers;
+using Cleipnir.ResilientFunctions.Storage;
+
+namespace Cleipnir.ResilientFunctions.CoreRuntime.Serialization;
+/*
+public class CustomSerializableDecorator : ISerializer
+{
+    private readonly ISerializer _inner;
+    private readonly Dictionary<Type, Func<byte[], ISerializer, object>> _deserializers = new();
+    private readonly Lock _lock = new();
+
+    public CustomSerializableDecorator(ISerializer inner) => _inner = inner;
+    
+    public byte[] SerializeParameter<TParam>(TParam parameter) 
+        => parameter is ICustomSerializable customSerializable
+            ? customSerializable.Serialize(this)
+            : _inner.SerializeParameter(parameter);
+    
+    public TParam DeserializeParameter<TParam>(byte[] json)
+    {
+        return typeof(TParam).IsAssignableTo(typeof(ICustomSerializable)) 
+            ? CustomDeserialize<TParam>(json) 
+            : _inner.DeserializeParameter<TParam>(json);
+    }
+    
+    public StoredException SerializeException(FatalWorkflowException exception)
+        => _inner.SerializeException(exception);
+
+    public FatalWorkflowException DeserializeException(FlowId flowId, StoredException storedException) 
+        => _inner.DeserializeException(flowId, storedException);
+
+    public byte[] SerializeResult<TResult>(TResult result)
+        => result is ICustomSerializable customSerializable
+            ? customSerializable.Serialize(this)
+            : _inner.SerializeResult(result);
+    
+    public TResult DeserializeResult<TResult>(byte[] json) 
+    {
+        return typeof(TResult).IsAssignableTo(typeof(ICustomSerializable)) 
+            ? CustomDeserialize<TResult>(json) 
+            : _inner.DeserializeParameter<TResult>(json);
+    }
+
+    public SerializedMessage SerializeMessage<TEvent>(TEvent message) where TEvent : notnull
+        => _inner.SerializeMessage(message); //todo allow custom serializer
+    public object DeserializeMessage(byte[] json, byte[] type) => _inner.DeserializeMessage(json, type);
+
+    public byte[] SerializeEffectResult<TResult>(TResult result)
+        => result is ICustomSerializable customSerializable
+            ? customSerializable.Serialize(this)
+            : _inner.SerializeEffectResult(result);
+    
+    public TResult DeserializeEffectResult<TResult>(byte[] json)
+    {
+        return typeof(TResult).IsAssignableTo(typeof(ICustomSerializable)) 
+            ? CustomDeserialize<TResult>(json) 
+            : _inner.DeserializeEffectResult<TResult>(json);
+    }
+
+    public byte[] SerializeState<TState>(TState state) where TState : FlowState, new()
+        => _inner.SerializeState(state);
+    public TState DeserializeState<TState>(byte[] json) where TState : FlowState, new()
+        => _inner.DeserializeState<TState>(json);
+    
+    private T CustomDeserialize<T>(byte[] bytes)
+    {
+        lock (_lock)
+        {
+            if (!_deserializers.ContainsKey(typeof(T)))
+            {
+                //var serializeMethodInfo = typeof(T).GetMethod(nameof(ICustomSerializable.Serialize), BindingFlags.Public | BindingFlags.Static);
+                //var serializeFunc = (Func<ISerializer, byte[]>) Delegate.CreateDelegate(typeof(Func<ISerializer, byte[]>), serializeMethodInfo!);
+                var deserializeMethodInfo = typeof(T).GetMethod(nameof(ICustomSerializable.Deserialize), BindingFlags.Public | BindingFlags.Static);
+                var deserializeFunc = (Func<byte[], ISerializer, object>) Delegate.CreateDelegate(typeof(Func<byte[], ISerializer, object>), deserializeMethodInfo!);
+                _deserializers[typeof(T)] = deserializeFunc;
+            }
+
+            return (T) _deserializers[typeof(T)](bytes, this);
+        }
+    }
+}*/