/// <summary>
/// execute callback operation
/// </summary>
/// <param name="success">command execute success</param>
/// <returns></returns>
public CommandCallbackResult ExecuteCallbackOperation(bool success)
{
#region execute async operation
if (!AsyncCallbackOperations.IsNullOrEmpty())
{
var internalMsgItem = new CommandCallbackInternalMessageItem(AsyncCallbackOperations);
InternalMessageQueue.Enqueue(internalMsgItem);
}
#endregion
#region execute sync operation
if (!SyncCallbackOperations.IsNullOrEmpty())
{
SyncCallbackOperations.ForEach(op =>
{
if (op.Item2 != null)
{
op.Item2.ExecuteSuccess = success;
}
op.Item1(op.Item2);
});
}
return(CommandCallbackResult.Default);
#endregion
}
/// <summary>
/// execute before execute operation
/// </summary>
/// <returns></returns>
public CommandBeforeExecuteResult ExecuteBeforeExecuteOperation()
{
#region execute async operation
if (!AsyncBeforeOperations.IsNullOrEmpty())
{
var internalMsgItem = new CommandBeforeOperationInternalMessageItem(AsyncBeforeOperations);
InternalMessageQueue.Enqueue(internalMsgItem);
}
#endregion
#region execut sync operation
if (SyncBeforeOperations.IsNullOrEmpty())
{
return(CommandBeforeExecuteResult.DefaultSuccess);;
}
CommandBeforeExecuteResult result = new CommandBeforeExecuteResult();
SyncBeforeOperations.ForEach(op =>
{
var opResult = op.Item1(op.Item2);
result.AllowExecuteCommand = result.AllowExecuteCommand && opResult.AllowExecuteCommand;
});
return(result);
#endregion
}
/// <summary>
/// Send email
/// </summary>
/// <param name="emailAccount">Email account</param>
/// <param name="sendInfos">Email send infos</param>
/// <returns>Return the email send result</returns>
public static async Task <List <EmailSendResult> > SendAsync(EmailAccount emailAccount, params EmailSendInfo[] sendInfos)
{
if (emailAccount == null || sendInfos.IsNullOrEmpty())
{
return(new List <EmailSendResult>(0));
}
List <EmailSendInfo> SyncInfos = new List <EmailSendInfo>();
List <EmailSendInfo> AsyncInfos = new List <EmailSendInfo>();
foreach (var sendInfo in sendInfos)
{
if (sendInfo == null)
{
continue;
}
if (sendInfo.Asynchronously)
{
AsyncInfos.Add(sendInfo);
}
else
{
SyncInfos.Add(sendInfo);
}
}
if (!AsyncInfos.IsNullOrEmpty())
{
SendEmailInternalMessageCommand emailInternalMessageCommand = new SendEmailInternalMessageCommand()
{
SendInfos = AsyncInfos,
EmailAccount = emailAccount
};
InternalMessageQueue.Enqueue(emailInternalMessageCommand);
}
if (SyncInfos.IsNullOrEmpty())
{
return(new List <EmailSendResult>(1)
{
EmailSendResult.SuccessResult(null)
});
}
return(await ExecuteSendAsync(emailAccount, SyncInfos).ConfigureAwait(false));
}
public static MessageSubscriber Create(IServiceProvider serviceProvider,
IMessageSubscriptionsRegistry subscriptionsRegistry,
IConnection connection,
ILogFactory logFactory,
ICompositeFormatterResolver formatterResolver,
Func <string, IMessagePublisher> repliesPublisher,
string exchangeName,
string queueName,
TimeSpan defaultFirstLevelRetryTimeout,
TimeSpan maxFirstLevelRetryMessageAge,
int maxFirstLevelRetryCount,
int firstLevelRetryQueueCapacity,
int processingQueueCapacity,
int messageConsumersCount,
int messageProcessorsCount)
{
var log = logFactory.CreateLog(typeof(MessageSubscriber));
log.Info("Creating RabbitMq subscriber...", new
{
exchangeName,
queueName,
defaultFirstLevelRetryTimeout,
maxFirstLevelRetryMessageAge,
maxFirstLevelRetryCount,
firstLevelRetryQueueCapacity,
processingQueueCapacity,
messageConsumersCount,
messageProcessorsCount
});
var internalQueue = new InternalMessageQueue(processingQueueCapacity);
var rejectManager = new RejectManager(logFactory);
var retryManager = new RetryManager
(
logFactory,
maxFirstLevelRetryMessageAge,
maxFirstLevelRetryCount,
firstLevelRetryQueueCapacity,
internalQueue
);
var messageConsumers = new List <IMessageConsumer>(messageConsumersCount);
for (var i = 0; i < messageConsumersCount; i++)
{
messageConsumers.Add(new MessageConsumer
(
connection,
internalQueue,
logFactory,
queueName
));
}
var messageProcessors = new List <IMessageProcessor>(messageConsumersCount);
for (var i = 0; i < messageProcessorsCount; i++)
{
messageProcessors.Add(new MessageProcessor
(
defaultFirstLevelRetryTimeout,
formatterResolver,
internalQueue,
logFactory,
repliesPublisher,
rejectManager,
retryManager,
serviceProvider,
subscriptionsRegistry
));
}
using (var channel = connection.CreateModel())
{
channel.BasicQos(0, 100, false);
channel.QueueDeclare(queueName, true, false, false, null);
log.Info($"Start receiving messages from the exchange {exchangeName} via the queue {queueName}:");
foreach (var subscription in subscriptionsRegistry.GetAllSubscriptions())
{
log.Info($"Binding message {subscription.RoutingKey}...");
channel.QueueBind(queueName, exchangeName, subscription.RoutingKey, null);
}
}
return(new MessageSubscriber
(
messageConsumers,
messageProcessors,
rejectManager,
retryManager
));
}
