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); }