RDB-136 Flow tabel wordt niet meer opgeruimd Bij een exceptie in Flow

Mogelijkheid voor het registreren van Cleanup middleware in Tapeti

Tapeti/Config/ICleanupMiddleware.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tapeti.Config
+{
+    public interface ICleanupMiddleware
+    {
+        Task Handle(IMessageContext context, ConsumeResponse response);
+    }
+}

Tapeti/Config/IConfig.cs

@@ -9,6 +9,7 @@ namespace Tapeti.Config
     {
         IDependencyResolver DependencyResolver { get; }
         IReadOnlyList<IMessageMiddleware> MessageMiddleware { get; }
+        IReadOnlyList<ICleanupMiddleware> CleanupMiddleware { get; }
         IReadOnlyList<IPublishMiddleware> PublishMiddleware { get; }
         IEnumerable<IQueue> Queues { get; }
 

Tapeti/Connection/TapetiConsumer.cs

@@ -16,18 +16,20 @@ namespace Tapeti.Connection
         private readonly string queueName;
         private readonly IDependencyResolver dependencyResolver;
         private readonly IReadOnlyList<IMessageMiddleware> messageMiddleware;
+        private readonly IReadOnlyList<ICleanupMiddleware> cleanupMiddleware;
         private readonly List<IBinding> bindings;
 
         private readonly ILogger logger;
         private readonly IExceptionStrategy exceptionStrategy;
 
 
-        public TapetiConsumer(TapetiWorker worker, string queueName, IDependencyResolver dependencyResolver, IEnumerable<IBinding> bindings, IReadOnlyList<IMessageMiddleware> messageMiddleware)
+        public TapetiConsumer(TapetiWorker worker, string queueName, IDependencyResolver dependencyResolver, IEnumerable<IBinding> bindings, IReadOnlyList<IMessageMiddleware> messageMiddleware, IReadOnlyList<ICleanupMiddleware> cleanupMiddleware)
         {
             this.worker = worker;
             this.queueName = queueName;
             this.dependencyResolver = dependencyResolver;
             this.messageMiddleware = messageMiddleware;
+            this.cleanupMiddleware = cleanupMiddleware;
             this.bindings = bindings.ToList();
 
             logger = dependencyResolver.Resolve<ILogger>();
@@ -74,8 +76,7 @@ namespace Tapeti.Connection
                     }
                     try
                     {
-                        // Cleanup handlers
+                        await RunCleanup(context, response);
-                        //response = exceptionStrategy.HandleException(null, exception.SourceException);
                     }
                     catch (Exception eCleanup)
                     {
@@ -107,6 +108,21 @@ namespace Tapeti.Connection
             });
         }
 
+        private async Task RunCleanup(MessageContext context, ConsumeResponse response)
+        {
+            foreach(var handler in cleanupMiddleware)
+            {
+                try
+                {
+                    await handler.Handle(context, response);
+                }
+                catch (Exception eCleanup)
+                {
+                    logger.HandlerException(eCleanup);
+                }
+            }
+        }
+
         private async Task DispatchMesage(MessageContext context, byte[] body)
         {
             var message = dependencyResolver.Resolve<IMessageSerializer>().Deserialize(body, context.Properties);

Tapeti/Connection/TapetiWorker.cs

@@ -57,7 +57,7 @@ namespace Tapeti.Connection
 
             return taskQueue.Value.Add(async () =>
             {
-                (await GetChannel()).BasicConsume(queueName, false, new TapetiConsumer(this, queueName, config.DependencyResolver, bindings, config.MessageMiddleware));
+                (await GetChannel()).BasicConsume(queueName, false, new TapetiConsumer(this, queueName, config.DependencyResolver, bindings, config.MessageMiddleware, config.CleanupMiddleware));
             }).Unwrap();
         }
 

Tapeti/Tapeti.csproj

@@ -53,6 +53,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Config\ICleanupMiddleware.cs" />
     <Compile Include="Config\IPublishContext.cs" />
     <Compile Include="Config\IMessageFilterMiddleware.cs" />
     <Compile Include="Config\IPublishMiddleware.cs" />

Tapeti/TapetiConfig.cs

@@ -26,6 +26,7 @@ namespace Tapeti
 
         private readonly List<IBindingMiddleware> bindingMiddleware = new List<IBindingMiddleware>();
         private readonly List<IMessageMiddleware> messageMiddleware = new List<IMessageMiddleware>();
+        private readonly List<ICleanupMiddleware> cleanupMiddleware = new List<ICleanupMiddleware>();
         private readonly List<IPublishMiddleware> publishMiddleware = new List<IPublishMiddleware>();
 
         private readonly IDependencyResolver dependencyResolver;
@@ -62,7 +63,7 @@ namespace Tapeti
 
             queues.AddRange(dynamicBindings.Select(bl => new Queue(new QueueInfo { Dynamic = true }, bl)));
 
-            var config = new Config(dependencyResolver, messageMiddleware, publishMiddleware, queues);
+            var config = new Config(dependencyResolver, messageMiddleware, cleanupMiddleware, publishMiddleware, queues);
             (dependencyResolver as IDependencyContainer)?.RegisterDefaultSingleton<IConfig>(config);
 
             return config;
@@ -83,6 +84,13 @@ namespace Tapeti
         }
 
 
+        public TapetiConfig Use(ICleanupMiddleware handler)
+        {
+            cleanupMiddleware.Add(handler);
+            return this;
+        }
+
+
         public TapetiConfig Use(IPublishMiddleware handler)
         {
             publishMiddleware.Add(handler);
@@ -108,6 +116,8 @@ namespace Tapeti
                         Use((IBindingMiddleware)middleware);
                     else if (middleware is IMessageMiddleware)
                         Use((IMessageMiddleware)middleware);
+                    else if (middleware is ICleanupMiddleware)
+                        Use((ICleanupMiddleware)middleware);
                     else if (middleware is IPublishMiddleware)
                         Use((IPublishMiddleware)middleware);
                     else
@@ -345,16 +355,18 @@ namespace Tapeti
         {
             public IDependencyResolver DependencyResolver { get; }
             public IReadOnlyList<IMessageMiddleware> MessageMiddleware { get; }
+            public IReadOnlyList<ICleanupMiddleware> CleanupMiddleware { get; }
             public IReadOnlyList<IPublishMiddleware> PublishMiddleware { get; }
             public IEnumerable<IQueue> Queues { get; }
 
             private readonly Dictionary<MethodInfo, IBinding> bindingMethodLookup;
 
 
-            public Config(IDependencyResolver dependencyResolver, IReadOnlyList<IMessageMiddleware> messageMiddleware, IReadOnlyList<IPublishMiddleware> publishMiddleware, IEnumerable<IQueue> queues)
+            public Config(IDependencyResolver dependencyResolver, IReadOnlyList<IMessageMiddleware> messageMiddleware, IReadOnlyList<ICleanupMiddleware> cleanupMiddleware, IReadOnlyList<IPublishMiddleware> publishMiddleware, IEnumerable<IQueue> queues)
             {
                 DependencyResolver = dependencyResolver;
                 MessageMiddleware = messageMiddleware;
+                CleanupMiddleware = cleanupMiddleware;
                 PublishMiddleware = publishMiddleware;
                 Queues = queues.ToList();