UnexpectedStateException dry'ing & refactoring

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

@@ -46,7 +46,7 @@ protected async Task ExistingActionCanBeDeletedFromControlPanel(Task<IFunctionSt
         var controlPanel = await rAction.ControlPanel(flowInstance).ShouldNotBeNullAsync();
         await controlPanel.Delete();
 
-        await Should.ThrowAsync<UnexpectedFunctionState>(controlPanel.Refresh());
+        await Should.ThrowAsync<UnexpectedStateException>(controlPanel.Refresh());
 
         await store.GetFunction(functionId).ShouldBeNullAsync();
 
@@ -106,7 +106,7 @@ async Task<string>(string _, Workflow workflow) =>
         var controlPanel = await rFunc.ControlPanel(flowInstance).ShouldNotBeNullAsync();
         await controlPanel.Delete();
 
-        await Should.ThrowAsync<UnexpectedFunctionState>(controlPanel.Refresh());
+        await Should.ThrowAsync<UnexpectedStateException>(controlPanel.Refresh());
 
         await store.GetFunction(functionId).ShouldBeNullAsync();
 

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

@@ -342,7 +342,7 @@ protected async Task ReInvocationFailsWhenTheFunctionDoesNotExist(Task<IFunction
         var controlPanel2 = await rAction.ControlPanel(flowInstance).ShouldNotBeNullAsync();
         await controlPanel1.Delete();
 
-        await Should.ThrowAsync<UnexpectedFunctionState>(() => controlPanel2.Restart());
+        await Should.ThrowAsync<UnexpectedStateException>(() => controlPanel2.Restart());
 
         unhandledExceptionCatcher.ShouldNotHaveExceptions();
     }

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

@@ -251,7 +251,7 @@ public async Task<PreparedReInvocation> PrepareForReInvocation(FlowId flowId, Re
             runningFunction.Dispose();
             sf = await _functionStore.GetFunction(flowId);
             if (sf == null)
-                throw new UnexpectedFunctionState(flowId, $"Function '{flowId}' was not found");
+                throw UnexpectedStateException.NotFound(flowId);
 
             await _functionStore.FailFunction(
                 flowId,

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

@@ -215,7 +215,7 @@ private async Task<PreparedReInvocation> PrepareForReInvocation(FlowId flowId, i
     {
         var restartedFunction = await _invocationHelper.RestartFunction(flowId, expectedEpoch);
         if (restartedFunction == null)
-            throw new UnexpectedFunctionState(flowId, $"Function '{flowId}' did not have expected epoch '{expectedEpoch}' on re-invocation");
+            throw UnexpectedStateException.EpochMismatch(flowId);
 
         return await PrepareForReInvocation(flowId, restartedFunction);
     }
@@ -289,7 +289,7 @@ private async Task PersistResultAndEnsureSuccess(FlowId flowId, Result<TReturn>
                 try
                 {
                     await ScheduleRestart(flowId.Instance.Value, expectedEpoch);
-                } catch (UnexpectedFunctionState) {} //allow this exception - the invocation has been surpassed by other execution
+                } catch (UnexpectedStateException) {} //allow this exception - the invocation has been surpassed by other execution
                 InvocationHelper<TParam, TReturn>.EnsureSuccess(flowId, result, allowPostponedOrSuspended);
                 break;
             }

Core/Cleipnir.ResilientFunctions/CoreRuntime/LeaseUpdater.cs

@@ -68,12 +68,7 @@ private async Task Start()
                 if (!success)
                 {
                     _disposed = true;
-                    _unhandledExceptionHandler.Invoke(
-                        new UnexpectedFunctionState(
-                            _flowId,
-                            $"{nameof(LeaseUpdater)} failed to update lease for executing function: '{_flowId}'"
-                        )
-                    );
+                    _unhandledExceptionHandler.Invoke(UnexpectedStateException.LeaseUpdateFailed(_flowId));
                 }
             }
             catch (Exception e)
@@ -82,7 +77,7 @@ private async Task Start()
                 _unhandledExceptionHandler.Invoke(
                     new FrameworkException(
                         _flowId.Type,
-                        $"{nameof(LeaseUpdater)} failed while executing function: '{_flowId}'",
+                        $"{nameof(LeaseUpdater)} failed for '{_flowId}'",
                         e
                     )
                 );

Core/Cleipnir.ResilientFunctions/Domain/ControlPanel.cs

@@ -239,7 +239,7 @@ public async Task Refresh()
     {
         var sf = await _invocationHelper.GetFunction(FlowId);
         if (sf == null)
-            throw new UnexpectedFunctionState(FlowId, $"Function '{FlowId}' not found");
+            throw UnexpectedStateException.NotFound(FlowId);
 
         Status = sf.Status;
         Epoch = sf.Epoch;

Core/Cleipnir.ResilientFunctions/Domain/Exceptions/UnexpectedStateException.cs

@@ -0,0 +1,19 @@
+using System;
+using Cleipnir.ResilientFunctions.CoreRuntime;
+
+namespace Cleipnir.ResilientFunctions.Domain.Exceptions;
+
+public sealed class UnexpectedStateException : FlowTypeException
+{
+    public FlowId FlowId { get; }
+
+    public UnexpectedStateException(FlowId flowId, string message)
+        : base(flowId.Type, message) => FlowId = flowId;
+
+    public UnexpectedStateException(FlowId flowId, string message, Exception innerException)
+        : base(flowId.Type, message, innerException) => FlowId = flowId;
+
+    public static UnexpectedStateException NotFound(FlowId flowId) => new(flowId, $"{flowId} was not found");
+    public static UnexpectedStateException EpochMismatch(FlowId flowId) => new(flowId, $"{flowId} did not have expected epoch at restart");
+    public static UnexpectedStateException LeaseUpdateFailed(FlowId flowId) => new(flowId, $"{nameof(LeaseUpdater)} failed to update lease for '{flowId}'");
+}

Core/Cleipnir.ResilientFunctions/Messaging/MessageWriter.cs

@@ -59,7 +59,7 @@ public async Task<Finding> AppendMessage<TMessage>(TMessage message, string? ide
             {
                 await _scheduleReInvocation(_flowId.Instance.Value, expectedEpoch: epoch);
             }
-            catch (UnexpectedFunctionState) { }
+            catch (UnexpectedStateException) { }
 
         return Finding.Found;
     }

Core/Cleipnir.ResilientFunctions/Messaging/MessagesPullerAndEmitter.cs

@@ -88,7 +88,7 @@ public async Task<InterruptCount> PullEvents(TimeSpan maxSinceLastSynced)
 
             var interruptCount = await _functionStore.GetInterruptCount(_flowId);
             if (interruptCount == null)
-                throw new UnexpectedFunctionState(_flowId, "Function was not found when fetching interrupt count");
+                throw UnexpectedStateException.NotFound(_flowId);
 
             lock (_sync)
                 _interruptCount = interruptCount.Value;