public override async Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token)
{
foreach (var handler in _resultHandlers)
{
await handler.Execute(dbconnection, message, token);
}
}
public ExecutorArgs(OnDemandTaskManager tasksManager, TaskInfo taskInfo, SSSBMessage message, MessageAtributes messageAtributes)
{
this.TasksManager = tasksManager;
this.TaskInfo = taskInfo;
this.Message = message;
this.Atributes = messageAtributes;
}
public ErrorMessageEventArgs(SSSBMessage message, ISSSBService svc, Exception processingException, CancellationToken cancellation)
{
this._message = message;
this._service = svc;
this._processingException = processingException;
this._cancellation = cancellation;
}
public ErrorMessageEventArgs(SSSBMessage message, BaseSSSBService svc, Exception processingException, CancellationToken cancellation)
{
this._message = message;
this._service = svc;
this._processingException = processingException;
this._cancellation = cancellation;
}
/// <summary>
/// Стандартная обработка сообщения об ошибке
/// </summary>
/// <param name="receivedMessage"></param>
public static void ErrorMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
if (receivedMessage.ConversationHandle.HasValue)
{
ServiceBrokerHelper.EndConversation(dbconnection, receivedMessage.ConversationHandle.Value);
_log.Error(string.Format(ServiceBrokerResources.ErrorMessageReceivedErrMsg, receivedMessage.ConversationHandle.Value, Encoding.Unicode.GetString(receivedMessage.Body)));
}
}
public ServiceMessageEventArgs(SSSBMessage message, BaseSSSBService svc, CancellationToken cancellation)
{
_message = message;
_service = svc;
_cancellation = cancellation;
_endConversationAfterProcessing = false;
_rollbackQue = false;
_ex = null;
_taskID = -1;
}
/// <summary>
/// Стандартная обработка сообщения об ошибке
/// </summary>
/// <param name="message"></param>
public async Task ErrorMessageHandler(SqlConnection dbconnection, SSSBMessage message)
{
try
{
_logger.LogError($"ErrorMessageHandler: {message.ConversationHandle} {message.MessageType} {message.ServiceName} {message.GetMessageXML()}");
}
finally
{
await _serviceBrokerHelper.EndConversation(dbconnection, message.ConversationHandle);
}
}
protected virtual async Task HandleAsyncProcessingResult(SSSBMessage message, CancellationToken token, Task <HandleMessageResult> completionTask)
{
token.ThrowIfCancellationRequested();
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
using (var dbconnection = await _connectionManager.CreateSSSBConnectionAsync(token))
{
await HandleSyncProcessingResult(dbconnection, message, token, completionTask);
transactionScope.Complete();
}
}
public override async Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token)
{
Guid conversationHandle = _conversationHandle.HasValue ? _conversationHandle.Value : message.ConversationHandle;
if (!string.IsNullOrEmpty(_error))
{
await _serviceBrokerHelper.EndConversationWithError(dbconnection, conversationHandle, _errorCode.HasValue?_errorCode.Value : 1, _error);
}
else
{
await _serviceBrokerHelper.EndConversation(dbconnection, conversationHandle);
}
}
/// <summary>
/// Отправка отложенного сообщения. Сообщение содержит информацию о типе, идентификатор диалога и пр. необходимую для отправки информацию.
/// </summary>
/// <param name="fromService"></param>
/// <param name="message"></param>
/// <param name="lifetime"></param>
/// <param name="isWithEncryption"></param>
/// <param name="activationTime"></param>
/// <param name="objectID"></param>
public async Task <long?> SendPendingMessage(SqlConnection dbconnection,
SSSBMessage message,
string fromService,
TimeSpan lifetime,
bool isWithEncryption,
DateTime activationTime,
string objectID,
int attemptNumber)
{
Debug($"Executing method SendPendingMessage(ConversationHandle: {message.ConversationHandle}, fromService: {fromService}, activationTime: {activationTime: dd.MM.yyyy HH:mm:ss}");
try
{
XElement xmessage = new XElement("DeferedMessage",
new XAttribute("conversationHandle", message.ConversationHandle),
new XAttribute("conversationGroupID", message.ConversationGroupID),
new XAttribute("messageType", message.MessageType),
new XAttribute("serviceName", message.ServiceName),
new XAttribute("contractName", message.ContractName),
new XAttribute("sequenceNumber", message.SequenceNumber),
new XAttribute("validationType", message.ValidationType),
new XAttribute("attemptNumber", attemptNumber),
new XElement("body", Convert.ToBase64String(message.Body))
);
byte[] body = xmessage.ConvertToBytes();
long?pendingMessageID = await _manager.SendPendingMessage(
dbconnection,
objectID,
activationTime,
fromService,
message.ServiceName,
message.ContractName,
(int)lifetime.TotalSeconds,
isWithEncryption,
body,
"PPS_DeferedMessageType");
return(pendingMessageID);
}
catch (SqlException ex)
{
DBWrapperExceptionsHelper.ThrowError(ex, ServiceBrokerResources.PendingMessageErrMsg, _logger);
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
throw new PPSException(ServiceBrokerResources.PendingMessageErrMsg, ex);
}
return(null);
}
/// <summary>
/// Отправка сообщения. Сообщение содержит информацию о типе, идентификатор диалога и пр. необходимую для отправки информацию.
/// </summary>
/// <param name="message"></param>
public async Task SendMessage(SqlConnection dbconnection, SSSBMessage message)
{
Debug($"Executing method SendMessage({message.MessageType}: {message.ConversationHandle})");
try
{
await _manager.SendMessage(dbconnection, message.ConversationHandle, message.MessageType, message.Body);
}
catch (SqlException ex)
{
DBWrapperExceptionsHelper.ThrowError(ex, ServiceBrokerResources.SendMessageErrMsg, _logger);
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
throw new PPSException(ServiceBrokerResources.SendMessageErrMsg, ex);
}
}
private Task _HandleProcessingResult(SqlConnection dbconnection, ServiceMessageEventArgs serviceArgs, bool isSync)
{
SSSBMessage message = serviceArgs.Message;
CancellationToken token = serviceArgs.Token;
Task processTask = serviceArgs.Completion.ContinueWith(async(antecedent) =>
{
try
{
if (isSync)
{
await this.HandleSyncProcessingResult(dbconnection, message, token, antecedent);
}
else
{
await this.HandleAsyncProcessingResult(message, token, antecedent);
}
}
catch (OperationCanceledException)
{
// NOOP
}
catch (PPSException)
{
// Already Logged
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
}
}, isSync ? TaskContinuationOptions.ExecuteSynchronously : TaskContinuationOptions.None).Unwrap();
var disposeTask = processTask.ContinueWith((antecedent) =>
{
try
{
this.OnDispose(serviceArgs);
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
}
}, TaskContinuationOptions.ExecuteSynchronously);
return(processTask);
}
public override Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token)
{
return(Task.CompletedTask);
}
public override async Task <ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs serviceMessageArgs)
{
MessageAtributes messageAtributes = null;
SSSBMessage originalMessage = null;
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
XElement envelopeXml = serviceMessageArgs.Message.GetMessageXML();
byte[] originalMessageBody = Convert.FromBase64String(envelopeXml.Element("body").Value);
XElement originalMessageXml = originalMessageBody.GetMessageXML();
messageAtributes = originalMessageXml.GetMessageAttributes();
messageAtributes.isDefered = true;
messageAtributes.attemptNumber = (int)envelopeXml.Attribute("attemptNumber");
string messageType = (string)envelopeXml.Attribute("messageType");
string serviceName = (string)envelopeXml.Attribute("serviceName");
string contractName = (string)envelopeXml.Attribute("contractName");
long sequenceNumber = (long)envelopeXml.Attribute("sequenceNumber");
MessageValidationType validationType = (MessageValidationType)Enum.Parse(typeof(MessageValidationType), envelopeXml.Attribute("validationType").Value);
Guid conversationHandle = Guid.Parse(envelopeXml.Attribute("conversationHandle").Value);
Guid conversationGroupID = Guid.Parse(envelopeXml.Attribute("conversationGroupID").Value);
originalMessage = new SSSBMessage(conversationHandle, conversationGroupID, validationType, contractName);
originalMessage.SequenceNumber = sequenceNumber;
originalMessage.ServiceName = serviceName;
originalMessage.Body = originalMessageBody;
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
return(serviceMessageArgs);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
return(serviceMessageArgs);
}
catch (Exception ex)
{
this.Logger.LogError(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
return(serviceMessageArgs);
}
OnDemandTaskManager taskManager = serviceMessageArgs.Services.GetRequiredService <OnDemandTaskManager>();
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
var task = await taskManager.GetTaskInfo(messageAtributes.TaskID.Value);
serviceMessageArgs.TaskID = messageAtributes.TaskID.Value;
var executorArgs = new ExecutorArgs(taskManager, task, originalMessage, messageAtributes);
await ExecuteTask(executorArgs, serviceMessageArgs);
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogCritical(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
}
return(serviceMessageArgs);
}
/// <summary>
/// Отправка сообщения. Сообщение содержит информацию о типе, идентификатор диалога и пр. необходимую для отправки информацию.
/// </summary>
/// <param name="message"></param>
public static void SendMessage(SqlConnection dbconnection, SSSBMessage message)
{
_log.Info("Выполнение метода SendMessage(message)");
try
{
SSSBManager.SendMessage(dbconnection, message.ConversationHandle, message.MessageType, message.Body);
}
catch (SqlException ex)
{
DBWrapperExceptionsHelper.ThrowError(ex, ServiceBrokerResources.SendMessageErrMsg, _log);
}
catch (Exception ex)
{
throw new PPSException(ServiceBrokerResources.SendMessageErrMsg, ex, _log);
}
}
/// <summary>
/// Отправка отложенного сообщения. Сообщение содержит информацию о типе, идентификатор диалога и пр. необходимую для отправки информацию.
/// </summary>
/// <param name="fromService"></param>
/// <param name="message"></param>
/// <param name="lifetime"></param>
/// <param name="isWithEncryption"></param>
/// <param name="activationTime"></param>
/// <param name="objectID"></param>
public static long SendPendingMessage(SqlConnection dbconnection, string fromService, SSSBMessage message, TimeSpan lifetime, bool isWithEncryption, Guid? initiatorConversationGroupID, DateTime activationTime, string objectID)
{
_log.Info("Выполнение метода SendPendingMessage(..)");
try
{
long? pendingMessageID = null;
SSSBManager.SendPendingMessage(dbconnection, objectID, activationTime, fromService, message.ServiceName, message.ContractName, (int)lifetime.TotalMilliseconds, isWithEncryption, message.ConversationGroupID, message.ConversationHandle, message.Body, message.MessageType, initiatorConversationGroupID, ref pendingMessageID);
return pendingMessageID.Value;
}
catch (SqlException ex)
{
DBWrapperExceptionsHelper.ThrowError(ex, ServiceBrokerResources.PendingMessageErrMsg, _log);
return 0;
}
catch (Exception ex)
{
throw new PPSException(ServiceBrokerResources.PendingMessageErrMsg, ex, _log);
}
}
public override Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token)
{
return(_serviceBrokerHelper.SendPendingMessage(dbconnection, message, _fromService, _lifeTime, false, _activationTime, null, _attemptNumber));
}
/// <summary>
/// Отправка ответного сообщения о завершении задачи
/// </summary>
/// <param name="receivedMessage"></param>
public static void SendStepCompleted(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
if (receivedMessage.ConversationHandle.HasValue)
ServiceBrokerHelper.SendStepCompletedMessage(dbconnection, receivedMessage.ConversationHandle.Value);
}
protected virtual async Task HandleSyncProcessingResult(SqlConnection dbconnection, SSSBMessage message, CancellationToken token, Task <HandleMessageResult> completionTask)
{
HandleMessageResult handleMessageResult = null;
try
{
handleMessageResult = await completionTask;
await handleMessageResult.Execute(dbconnection, message, token);
}
catch (OperationCanceledException)
{
await _standardMessageHandlers.EndDialogMessageWithErrorHandler(dbconnection, message, $"Operation on Service: '{message.ServiceName}', MessageType: '{message.MessageType}', ConversationHandle: '{message.ConversationHandle}', is Cancelled", 1);
}
catch (PPSException ex)
{
await _standardMessageHandlers.EndDialogMessageWithErrorHandler(dbconnection, message, $"Operation on Service: '{message.ServiceName}', MessageType: '{message.MessageType}', ConversationHandle: '{message.ConversationHandle}', ended with Error: {ex.Message}", 2);
}
catch (Exception ex)
{
try
{
_logger.LogError(new EventId(0, message.ServiceName), ErrorHelper.GetFullMessage(ex));
}
finally
{
await _standardMessageHandlers.EndDialogMessageWithErrorHandler(dbconnection, message, $"Operation on Service: '{message.ServiceName}', MessageType: '{message.MessageType}', ConversationHandle: '{message.ConversationHandle}', ended with Error: {ex.Message}", 3);
}
}
}
/// <summary>
/// Завершение диалога с отправкой сообщения об ошибке
/// </summary>
/// <param name="receivedMessage"></param>
public static void EndDialogMessageWithErrorHandler(SqlConnection dbconnection, SSSBMessage receivedMessage, string message, int? errorNumber)
{
ServiceBrokerHelper.EndConversationWithError(dbconnection, receivedMessage.ConversationHandle.Value, errorNumber, message);
}
/// <summary>
/// Стандартная обработка сообщения о завершении диалога
/// </summary>
/// <param name="receivedMessage"></param>
public static void EndDialogMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
if (receivedMessage.ConversationHandle.HasValue)
ServiceBrokerHelper.EndConversation(dbconnection, receivedMessage.ConversationHandle.Value);
}
/// <summary>
/// Стандартная обработка ECHO сообщения
/// </summary>
/// <param name="receivedMessage"></param>
public static void EchoMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
ServiceBrokerHelper.SendMessage(dbconnection, receivedMessage);
}
/// <summary>
/// Завершение диалога с отправкой сообщения об ошибке
/// </summary>
/// <param name="receivedMessage"></param>
public Task EndDialogMessageWithErrorHandler(SqlConnection dbconnection, SSSBMessage receivedMessage, string message, int errorNumber)
{
return(_serviceBrokerHelper.EndConversationWithError(dbconnection, receivedMessage.ConversationHandle, errorNumber, message));
}
public override Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token)
{
Guid conversationHandle = _conversationHandle.HasValue ? _conversationHandle.Value : message.ConversationHandle;
return(_serviceBrokerHelper.SendMessage(dbconnection, conversationHandle, _messageType, _xmlBody));
}
/// <summary>
/// Стандартная обработка сообщения об ошибке
/// </summary>
/// <param name="receivedMessage"></param>
public async Task ErrorMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
await _serviceBrokerHelper.EndConversation(dbconnection, receivedMessage.ConversationHandle);
_logger.LogError(string.Format(ServiceBrokerResources.ErrorMessageReceivedErrMsg, receivedMessage.ConversationHandle, Encoding.Unicode.GetString(receivedMessage.Body)));
}
/// <summary>
/// Стандартная обработка ECHO сообщения
/// </summary>
/// <param name="receivedMessage"></param>
public Task EchoMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
return(_serviceBrokerHelper.SendMessage(dbconnection, receivedMessage));
}
/// <summary>
/// Стандартная обработка сообщения о завершении диалога
/// </summary>
/// <param name="receivedMessage"></param>
public Task EndDialogMessageHandler(SqlConnection dbconnection, SSSBMessage receivedMessage)
{
return(_serviceBrokerHelper.EndConversation(dbconnection, receivedMessage.ConversationHandle));
}
public abstract Task Execute(SqlConnection dbconnection, SSSBMessage message, CancellationToken token);
