private void HandleMessageAsync(DisptachingMessage dispatchingMessage, IMessageHandlerProxy handlerProxy, int handlerTypeCode, int messageTypeCode, int retryTimes)
{
var message = dispatchingMessage.Message;
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("HandleMessageAsync",
() => handlerProxy.HandleAsync(message),
currentRetryTimes => HandleMessageAsync(dispatchingMessage, handlerProxy, handlerTypeCode, messageTypeCode, currentRetryTimes),
result =>
{
var messageHandleRecord = new MessageHandleRecord
{
MessageId = message.Id,
HandlerTypeCode = handlerTypeCode,
MessageTypeCode = messageTypeCode,
Timestamp = DateTime.Now
};
var sequenceMessage = message as ISequenceMessage;
if (sequenceMessage != null)
{
messageHandleRecord.AggregateRootTypeCode = sequenceMessage.AggregateRootTypeCode;
messageHandleRecord.AggregateRootId = sequenceMessage.AggregateRootId;
messageHandleRecord.Version = sequenceMessage.Version;
}
AddMessageHandledRecordAsync(dispatchingMessage, messageHandleRecord, handlerProxy.GetInnerHandler().GetType(), handlerTypeCode, 0);
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerProxy.GetInnerHandler().GetType().Name),
null,
retryTimes,
true);
}
public async Task<AsyncTaskResult> AddRecordAsync(MessageHandleRecord record)
{
try
{
using (var connection = GetConnection())
{
await connection.InsertAsync(new
{
HandlerTypeCode = record.HandlerTypeCode,
MessageId = record.MessageId,
MessageTypeCode = record.MessageTypeCode,
AggregateRootTypeCode = record.AggregateRootTypeCode,
AggregateRootId = record.AggregateRootId,
Version = record.Version,
Timestamp = record.Timestamp
}, _tableName);
return AsyncTaskResult.Success;
}
}
catch (SqlException ex)
{
if (ex.Number == 2627 && ex.Message.Contains(_primaryKeyName))
{
return AsyncTaskResult.Success;
}
_logger.Error("Insert message handle record has sql exception.", ex);
return new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message);
}
catch (Exception ex)
{
_logger.Error("Insert message handle record has unknown exception.", ex);
return new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message);
}
}
public async Task <AsyncTaskResult> AddRecordAsync(MessageHandleRecord record)
{
try
{
using (var connection = GetConnection())
{
await connection.InsertAsync(new
{
HandlerTypeCode = record.HandlerTypeCode,
MessageId = record.MessageId,
MessageTypeCode = record.MessageTypeCode,
AggregateRootTypeCode = record.AggregateRootTypeCode,
AggregateRootId = record.AggregateRootId,
Version = record.Version,
Timestamp = record.Timestamp
}, _tableName);
return(AsyncTaskResult.Success);
}
}
catch (SqlException ex)
{
if (ex.Number == 2627 && ex.Message.Contains(_primaryKeyName))
{
return(AsyncTaskResult.Success);
}
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
}
public async Task<AsyncTaskResult> AddRecordAsync(MessageHandleRecord record)
{
try
{
using (var connection = GetConnection())
{
await connection.InsertAsync(record, _oneMessageTableName);
return AsyncTaskResult.Success;
}
}
catch (SqlException ex)
{
if (ex.Number == 2627 && ex.Message.Contains(_oneMessageTablePrimaryKeyName))
{
return AsyncTaskResult.Success;
}
_logger.Error("Insert message handle record has sql exception.", ex);
return new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message);
}
catch (Exception ex)
{
_logger.Error("Insert message handle record has unknown exception.", ex);
return new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message);
}
}
public async Task <AsyncTaskResult> AddRecordAsync(MessageHandleRecord record)
{
try
{
using (var connection = GetConnection())
{
await connection.InsertAsync(record, _oneMessageTableName);
return(AsyncTaskResult.Success);
}
}
catch (DbException ex)
{
//if (ex.Number == 2627 && ex.Message.Contains(_oneMessageTablePrimaryKeyName))
//{
// return AsyncTaskResult.Success;
//}
_logger.Error("Insert message handle record has sql exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
catch (Exception ex)
{
_logger.Error("Insert message handle record has unknown exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message));
}
}
public async Task <AsyncTaskResult> AddRecordAsync(MessageHandleRecord record)
{
try
{
using (var connection = GetConnection())
{
await connection.InsertAsync(new
{
HandlerTypeCode = record.HandlerTypeCode,
MessageId = record.MessageId,
MessageTypeCode = record.MessageTypeCode,
AggregateRootTypeCode = record.AggregateRootTypeCode,
AggregateRootId = record.AggregateRootId,
Version = record.Version,
FinishedTime = record.FinishedTime
}, _tableName);
return(AsyncTaskResult.Success);
}
}
catch (SqlException ex)
{
if (ex.Number == 2627 && ex.Message.Contains(_primaryKeyName))
{
return(AsyncTaskResult.Success);
}
_logger.Error("Insert message handle record has sql exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
catch (Exception ex)
{
_logger.Error("Insert message handle record has unknown exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message));
}
}
private void HandleSingleMessageAsync(SingleMessageDisptaching singleMessageDispatching, IMessageHandlerProxy1 handlerProxy, string handlerTypeName, string messageTypeName, QueuedHandler <IMessageHandlerProxy1> queueHandler, int retryTimes)
{
var message = singleMessageDispatching.Message;
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("HandleSingleMessageAsync",
() => handlerProxy.HandleAsync(message),
currentRetryTimes => HandleSingleMessageAsync(singleMessageDispatching, handlerProxy, handlerTypeName, messageTypeName, queueHandler, currentRetryTimes),
result =>
{
var messageHandleRecord = new MessageHandleRecord
{
MessageId = message.Id,
MessageTypeName = messageTypeName,
HandlerTypeName = handlerTypeName,
CreatedOn = DateTime.Now
};
var sequenceMessage = message as ISequenceMessage;
if (sequenceMessage != null)
{
messageHandleRecord.AggregateRootTypeName = sequenceMessage.AggregateRootTypeName;
messageHandleRecord.AggregateRootId = sequenceMessage.AggregateRootStringId;
messageHandleRecord.Version = sequenceMessage.Version;
}
AddMessageHandledRecordAsync(singleMessageDispatching, messageHandleRecord, handlerProxy.GetInnerObject().GetType(), handlerTypeName, handlerProxy, queueHandler, 0);
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerProxy.GetInnerObject().GetType().Name),
null,
retryTimes,
true);
}
private void AddMessageHandledRecordAsync(DisptachingMessage dispatchingMessage, MessageHandleRecord messageHandleRecord, Type handlerType, int handlerTypeCode, int retryTimes)
{
var message = dispatchingMessage.Message;
_ioHelper.TryAsyncActionRecursively<AsyncTaskResult>("AddMessageHandledRecordAsync",
() => _messageHandleRecordStore.AddRecordAsync(messageHandleRecord),
currentRetryTimes => AddMessageHandledRecordAsync(dispatchingMessage, messageHandleRecord, handlerType, handlerTypeCode, currentRetryTimes),
result =>
{
dispatchingMessage.RemoveHandledHandler(handlerTypeCode);
_logger.DebugFormat("Message handled success, handlerType:{0}, messageType:{1}, messageId:{2}", handlerType.Name, message.GetType().Name, message.Id);
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerType.Name),
null,
retryTimes,
true);
}
private void AddMessageHandledRecordAsync(DisptachingMessage dispatchingMessage, MessageHandleRecord messageHandleRecord, Type handlerType, int handlerTypeCode, int retryTimes)
{
var message = dispatchingMessage.Message;
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("AddMessageHandledRecordAsync",
() => _messageHandleRecordStore.AddRecordAsync(messageHandleRecord),
currentRetryTimes => AddMessageHandledRecordAsync(dispatchingMessage, messageHandleRecord, handlerType, handlerTypeCode, currentRetryTimes),
result =>
{
dispatchingMessage.RemoveHandledHandler(handlerTypeCode);
_logger.DebugFormat("Message handled success, handlerType:{0}, messageType:{1}, messageId:{2}", handlerType.Name, message.GetType().Name, message.Id);
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerType.Name),
null,
retryTimes,
true);
}
Task<AsyncTaskResult> IMessageHandleRecordStore.AddRecordAsync(MessageHandleRecord record)
{
_dict.TryAdd(record.MessageId + record.HandlerTypeCode.ToString(), 0);
return _successTask;
}
private void AddMessageHandledRecordAsync(SingleMessageDisptaching singleMessageDispatching, MessageHandleRecord messageHandleRecord, Type handlerType, string handlerTypeName, IMessageHandlerProxy1 handlerProxy, QueuedHandler <IMessageHandlerProxy1> queueHandler, int retryTimes)
{
var message = singleMessageDispatching.Message;
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("AddMessageHandledRecordAsync",
() => _messageHandleRecordStore.AddRecordAsync(messageHandleRecord),
currentRetryTimes => AddMessageHandledRecordAsync(singleMessageDispatching, messageHandleRecord, handlerType, handlerTypeName, handlerProxy, queueHandler, currentRetryTimes),
result =>
{
singleMessageDispatching.RemoveHandledHandler(handlerTypeName);
if (queueHandler != null)
{
queueHandler.OnHandlerFinished(handlerProxy);
}
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Message handled success, handlerType:{0}, messageType:{1}, messageId:{2}", handlerType.Name, message.GetType().Name, message.Id);
}
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerType.Name),
null,
retryTimes,
true);
}
Task <AsyncTaskResult> IMessageHandleRecordStore.AddRecordAsync(MessageHandleRecord record)
{
_dict.TryAdd(record.MessageId + record.HandlerTypeCode.ToString(), 0);
return(_successTask);
}
private void HandleMessageAsync(DisptachingMessage dispatchingMessage, IMessageHandlerProxy handlerProxy, int handlerTypeCode, int messageTypeCode, int retryTimes)
{
var message = dispatchingMessage.Message;
_ioHelper.TryAsyncActionRecursively<AsyncTaskResult>("HandleMessageAsync",
() => handlerProxy.HandleAsync(message),
currentRetryTimes => HandleMessageAsync(dispatchingMessage, handlerProxy, handlerTypeCode, messageTypeCode, currentRetryTimes),
result =>
{
var messageHandleRecord = new MessageHandleRecord
{
MessageId = message.Id,
HandlerTypeCode = handlerTypeCode,
MessageTypeCode = messageTypeCode,
Timestamp = DateTime.Now
};
var sequenceMessage = message as ISequenceMessage;
if (sequenceMessage != null)
{
messageHandleRecord.AggregateRootTypeCode = sequenceMessage.AggregateRootTypeCode;
messageHandleRecord.AggregateRootId = sequenceMessage.AggregateRootId;
messageHandleRecord.Version = sequenceMessage.Version;
}
AddMessageHandledRecordAsync(dispatchingMessage, messageHandleRecord, handlerProxy.GetInnerHandler().GetType(), handlerTypeCode, 0);
},
() => string.Format("[messageId:{0}, messageType:{1}, handlerType:{2}]", message.Id, message.GetType().Name, handlerProxy.GetInnerHandler().GetType().Name),
null,
retryTimes,
true);
}
