rafactor publisher excutor.

src/DotNetCore.CAP/IPublishExecutor.cs

+using System.Threading.Tasks;
+
+namespace DotNetCore.CAP
+{
+    public interface IPublishExecutor
+    {
+        Task<OperateResult> PublishAsync(string keyName, string content);
+    }
+}

src/DotNetCore.CAP/IQueueExecutor.Publish.Base.cs

 using System;
 using System.Diagnostics;
 using System.Threading.Tasks;
+using DotNetCore.CAP.Infrastructure;
 using DotNetCore.CAP.Models;
 using DotNetCore.CAP.Processor;
 using DotNetCore.CAP.Processor.States;
@@ -8,7 +9,7 @@ using Microsoft.Extensions.Logging;
 
 namespace DotNetCore.CAP
 {
-    public abstract class BasePublishQueueExecutor : IQueueExecutor
+    public abstract class BasePublishQueueExecutor : IQueueExecutor, IPublishExecutor
     {
         private readonly ILogger _logger;
         private readonly CapOptions _options;
@@ -40,7 +41,7 @@ namespace DotNetCore.CAP
                 IState newState;
                 if (!result.Succeeded)
                 {
-                    var shouldRetry = await UpdateMessageForRetryAsync(message, connection);
+                    var shouldRetry = UpdateMessageForRetryAsync(message);
                     if (shouldRetry)
                     {
                         newState = new ScheduledState();
@@ -51,6 +52,7 @@ namespace DotNetCore.CAP
                         newState = new FailedState();
                         _logger.JobFailed(result.Exception);
                     }
+                    message.Content = Helper.AddExceptionProperty(message.Content, result.Exception);
                 }
                 else
                 {
@@ -67,6 +69,7 @@ namespace DotNetCore.CAP
             }
             catch (Exception ex)
             {
+                fetched.Requeue();
                 _logger.ExceptionOccuredWhileExecutingJob(message?.Name, ex);
                 return OperateResult.Failed(ex);
             }
@@ -74,8 +77,7 @@ namespace DotNetCore.CAP
 
         public abstract Task<OperateResult> PublishAsync(string keyName, string content);
 
-        private static async Task<bool> UpdateMessageForRetryAsync(CapPublishedMessage message,
-            IStorageConnection connection)
+        private static bool UpdateMessageForRetryAsync(CapPublishedMessage message)
         {
             var retryBehavior = RetryBehavior.DefaultRetry;
 
@@ -85,11 +87,7 @@ namespace DotNetCore.CAP
 
             var due = message.Added.AddSeconds(retryBehavior.RetryIn(retries));
             message.ExpiresAt = due;
-            using (var transaction = connection.CreateTransaction())
-            {
-                transaction.UpdateMessage(message);
-                await transaction.CommitAsync();
-            }
+          
             return true;
         }
     }

src/DotNetCore.CAP/IQueueExecutor.Subscribe.cs

 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
-using DotNetCore.CAP.Abstractions;
 using DotNetCore.CAP.Infrastructure;
 using DotNetCore.CAP.Internal;
 using DotNetCore.CAP.Models;
@@ -14,29 +12,25 @@ namespace DotNetCore.CAP
 {
     public class SubscribeQueueExecutor : IQueueExecutor
     {
-		private readonly IConsumerInvokerFactory _consumerInvokerFactory;
         private readonly ILogger _logger;
         private readonly CapOptions _options;
-		private readonly MethodMatcherCache _selector;
         private readonly IStateChanger _stateChanger;
+        private readonly ISubscriberExecutor _subscriberExecutor;
 
         public SubscribeQueueExecutor(
-			IStateChanger stateChanger,
-			MethodMatcherCache selector,
             CapOptions options,
-			IConsumerInvokerFactory consumerInvokerFactory,
-			ILogger<BasePublishQueueExecutor> logger)
+            IStateChanger stateChanger,
+            ISubscriberExecutor subscriberExecutor,
+            ILogger<SubscribeQueueExecutor> logger)
         {
-			_selector = selector;
             _options = options;
-			_consumerInvokerFactory = consumerInvokerFactory;
+            _subscriberExecutor = subscriberExecutor;
             _stateChanger = stateChanger;
             _logger = logger;
         }
 
         public async Task<OperateResult> ExecuteAsync(IStorageConnection connection, IFetchedMessage fetched)
         {
-			//return await Task.FromResult(OperateResult.Success);
             var message = await connection.GetReceivedMessageAsync(fetched.MessageId);
             try
             {
@@ -45,29 +39,13 @@ namespace DotNetCore.CAP
 
                 if (message.Retries > 0)
                     _logger.JobRetrying(message.Retries);
-				var result = await ExecuteSubscribeAsync(message);
+
+                var result = await _subscriberExecutor.ExecuteAsync(message);
                 sp.Stop();
 
-				IState newState;
-				if (!result.Succeeded)
-				{
-					var shouldRetry = await UpdateMessageForRetryAsync(message, connection, result.Exception?.Message);
-					if (shouldRetry)
-					{
-						newState = new ScheduledState();
-						_logger.JobFailedWillRetry(result.Exception);
-					}
-					else
-					{
-						newState = new FailedState();
-						_logger.JobFailed(result.Exception);
-					}
-				}
-				else
-				{
-					newState = new SucceededState(_options.SucceedMessageExpiredAfter);
-				}
-				await _stateChanger.ChangeStateAsync(message, newState, connection);
+                var state = GetNewState(result, message);
+
+                await _stateChanger.ChangeStateAsync(message, state, connection);
 
                 fetched.RemoveFromQueue();
 
@@ -80,7 +58,7 @@ namespace DotNetCore.CAP
             {
                 _logger.LogError(ex.Message);
 
-				await AddErrorReasonToContent(message, ex.Message, connection);
+                AddErrorReasonToContent(message, ex);
 
                 await _stateChanger.ChangeStateAsync(message, new FailedState(), connection);
 
@@ -98,36 +76,32 @@ namespace DotNetCore.CAP
             }
         }
 
-		protected virtual async Task<OperateResult> ExecuteSubscribeAsync(CapReceivedMessage receivedMessage)
+        private IState GetNewState(OperateResult result, CapReceivedMessage message)
         {
-			try
+            IState newState;
+            if (!result.Succeeded)
             {
-				var executeDescriptorGroup = _selector.GetTopicExector(receivedMessage.Name);
-
-				if (!executeDescriptorGroup.ContainsKey(receivedMessage.Group))
+                var shouldRetry = UpdateMessageForRetryAsync(message);
+                if (shouldRetry)
                 {
-					var error = $"Topic:{receivedMessage.Name}, can not be found subscriber method.";
-					throw new SubscriberNotFoundException(error);
+                    newState = new ScheduledState();
+                    _logger.JobFailedWillRetry(result.Exception);
                 }
-
-				// If there are multiple consumers in the same group, we will take the first
-				var executeDescriptor = executeDescriptorGroup[receivedMessage.Group][0];
-				var consumerContext = new ConsumerContext(executeDescriptor, receivedMessage.ToMessageContext());
-
-				await _consumerInvokerFactory.CreateInvoker(consumerContext).InvokeAsync();
-
-				return OperateResult.Success;
+                else
+                {
+                    newState = new FailedState();
+                    _logger.JobFailed(result.Exception);
                 }
-			catch (Exception ex)
+                AddErrorReasonToContent(message, result.Exception);
+            }
+            else
             {
-				_logger.ConsumerMethodExecutingFailed($"Group:{receivedMessage.Group}, Topic:{receivedMessage.Name}",
-					ex);
-
-				return OperateResult.Failed(ex);
+                newState = new SucceededState(_options.SucceedMessageExpiredAfter);
             }
+            return newState;
         }
 
-		private static async Task<bool> UpdateMessageForRetryAsync(CapReceivedMessage message, IStorageConnection connection, string exceptionMessage)
+        private static bool UpdateMessageForRetryAsync(CapReceivedMessage message)
         {
             var retryBehavior = RetryBehavior.DefaultRetry;
 
@@ -138,25 +112,12 @@ namespace DotNetCore.CAP
             var due = message.Added.AddSeconds(retryBehavior.RetryIn(retries));
             message.ExpiresAt = due;
 
-			await AddErrorReasonToContent(message, exceptionMessage, connection);
-
             return true;
         }
 
-		public static Task AddErrorReasonToContent(CapReceivedMessage message, string description, IStorageConnection connection)
-		{
-			var exceptions = new List<KeyValuePair<string, string>>
-			{
-				new KeyValuePair<string, string>("ExceptionMessage", description)
-			};
-
-			message.Content = Helper.AddJsonProperty(message.Content, exceptions);
-			using (var transaction = connection.CreateTransaction())
+        private static void AddErrorReasonToContent(CapReceivedMessage message, Exception exception)
         { 
-				transaction.UpdateMessage(message);
-				transaction.CommitAsync();
-			}
-			return Task.CompletedTask;
+            message.Content = Helper.AddExceptionProperty(message.Content, exception);
         }
     }
 }
\ No newline at end of file