New option to indefinitely requeue a message on an exception criteria. Closes GH-1182

Author: jeremydmiller

src/Samples/DocumentationSamples/ExceptionHandling.cs

@@ -54,6 +54,12 @@ public static async Task with_scripted_error_handling()
                     // Or instead you could just discard the message and stop
                     // all processing too!
                     .Then.Discard().AndPauseProcessing(5.Minutes());
+
+                // Obviously use this with caution, but this allows you
+                // to tell Wolverine to requeue an exception on failures no
+                // matter how many attempts have been made already
+                opts.OnException<NotReadyException>()
+                    .RequeueIndefinitely();
             }).StartAsync();
 
         #endregion
@@ -88,4 +94,6 @@ public static async Task with_scheduled_retry()
     }
 }
 
-public class SqlException : Exception;
+public class SqlException : Exception;
+
+public class NotReadyException : Exception;

src/Testing/CoreTests/Acceptance/indefinite_scheduled_retries.cs

@@ -6,7 +6,7 @@
 
 namespace CoreTests.Acceptance;
 
-public class indefinite_scheduled_retires
+public class indefinite_error_handling
 {
     [Fact]
     public async Task should_indefinitively_retry_command()
@@ -26,6 +26,26 @@ public async Task should_indefinitively_retry_command()
         catch (OperationCanceledException) { }
         IndefiniteRetriesHandler.CalledCount.ShouldBe(5);
     }
+    
+    [Fact]
+    public async Task should_indefinitively_requeue_command()
+    {
+        IndefiniteRetriesHandler.CalledCount = 0;
+        using var cts = new CancellationTokenSource(5.Seconds());
+        using var host = await Host.CreateDefaultBuilder()
+            .UseWolverine(opts => opts.Policies.OnException<IndefiniteRetryException>().RequeueIndefinitely())
+            .StartAsync();
+
+        var messageBus = host.MessageBus();
+        await messageBus.SendAsync(new IndefiniteRetriesCommand(cts, SucceedAfterAttempts: 5));
+        try
+        {
+            await Task.Delay(Timeout.Infinite, cts.Token);
+        }
+        catch (OperationCanceledException) { }
+        IndefiniteRetriesHandler.CalledCount.ShouldBe(5);
+    }
+    
     [Fact]
     public async Task should_indefinitively_retry_command_when_given_multiple_delays()
     {

src/Testing/CoreTests/Bugs/Bug_1182_infinite_loop_codegen.cs

@@ -0,0 +1,50 @@
+using System.Diagnostics;
+using System.Reflection;
+using JasperFx.CodeGeneration;
+using JasperFx.CodeGeneration.Model;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Spectre.Console;
+using Wolverine.ErrorHandling;
+using Wolverine.Runtime.Handlers;
+using Xunit;
+
+namespace CoreTests.Bugs;
+
+public class Bug_1182_infinite_loop_codegen
+{
+    [Fact]
+    public async Task do_not_go_into_infinite_loop()
+    {
+        using var host = await Host.CreateDefaultBuilder()
+            .UseWolverine(opts =>
+            {
+                opts.Discovery.DisableConventionalDiscovery().IncludeType(typeof(InfiniteCommandHandlingThing));
+            }).StartAsync();
+        
+        var collections = host.Services.GetServices<ICodeFileCollection>().ToArray();
+
+        var builder = new DynamicCodeBuilder(host.Services, collections)
+        {
+            ServiceVariableSource = host.Services.GetService<IServiceVariableSource>()
+        };
+
+        var ex = Should.Throw<CodeGenerationException>(() => builder.GenerateAllCode());
+        ex.InnerException.InnerException.ShouldBeOfType<ArgumentOutOfRangeException>();
+
+    }
+}
+
+public static class InfiniteCommandHandlingThing
+{
+    public static void Configure(HandlerChain chain)
+    {
+        chain.OnException<Exception>().Requeue(int.MaxValue);
+    }
+
+    public static void Handle(InfiniteCommand command)
+    {
+    }
+}
+
+public record InfiniteCommand;

src/Wolverine/ErrorHandling/PolicyExpression.cs

@@ -130,6 +130,10 @@ public IAdditionalActions MoveToErrorQueue()
 
     public IAdditionalActions Requeue(int maxAttempts = 3)
     {
+        if (maxAttempts > 25)
+            throw new ArgumentOutOfRangeException(nameof(maxAttempts),
+                "Wolverine allows a maximum of 25 attempts, see the RequeueIndefinitely() option");
+        
         for (var i = 0; i < maxAttempts - 1; i++)
         {
             var slot = _rule.AddSlot(RequeueContinuation.Instance);
@@ -138,6 +142,13 @@ public IAdditionalActions Requeue(int maxAttempts = 3)
 
         return this;
     }
+    
+    public IAdditionalActions RequeueIndefinitely()
+    {
+        _rule.InfiniteSource = RequeueContinuation.Instance;
+
+        return this;
+    }
 
     public IAdditionalActions PauseThenRequeue(TimeSpan delay)
     {
@@ -159,6 +170,10 @@ public IAdditionalActions ScheduleRetry(params TimeSpan[] delays)
         {
             throw new InvalidOperationException("You must specify at least one delay time");
         }
+        
+        if (delays.Length > 25)
+            throw new ArgumentOutOfRangeException(nameof(delays),
+                "Wolverine allows a maximum of 25 attempts, see the ScheduleRetryIndefinitely() option");
 
         for (var i = 0; i < delays.Length; i++)
         {
@@ -200,6 +215,10 @@ public IAdditionalActions RetryTimes(int attempts)
         {
             throw new ArgumentOutOfRangeException(nameof(attempts));
         }
+        
+        if (attempts > 25)
+            throw new ArgumentOutOfRangeException(nameof(attempts),
+                "Wolverine allows a maximum of 25 attempts, maybe see one of the indefinite requeue or reschedule policies");
 
         for (var i = 0; i < attempts; i++)
         {
@@ -216,6 +235,11 @@ public IAdditionalActions RetryWithCooldown(params TimeSpan[] delays)
         {
             throw new InvalidOperationException("You must specify at least one delay time");
         }
+        
+        if (delays.Length > 25)
+            throw new ArgumentOutOfRangeException(nameof(delays),
+                "Wolverine allows a maximum of 25 attempts, maybe see one of the indefinite requeue or reschedule policies");
+
 
         for (var i = 0; i < delays.Length; i++)
         {
@@ -280,6 +304,13 @@ public interface IFailureActions
     /// <param name="maxAttempts">The maximum number of attempts to process the message. The default is 3</param>
     IAdditionalActions Requeue(int maxAttempts = 3);
 
+    /// <summary>
+    /// Requeue the message back to the incoming transport no matter how many times
+    /// the message has failed. Use with caution obviously!!!!!
+    /// </summary>
+    /// <returns></returns>
+    IAdditionalActions RequeueIndefinitely();
+
     /// <summary>
     ///     Discard the message without any further attempt to process the message
     /// </summary>
@@ -365,6 +396,11 @@ public IAdditionalActions Requeue(int maxAttempts = 3)
         return new FailureActions(_match, _parent).Requeue(maxAttempts);
     }
 
+    public IAdditionalActions RequeueIndefinitely()
+    {
+        return new FailureActions(_match, _parent).RequeueIndefinitely();
+    }
+
     /// <summary>
     ///     Discard the message without any further attempt to process the message
     /// </summary>