public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, KafkaMessage kafkaMessage, IKafkaMessageContext messageContext)
{
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
_kafkaMessage = kafkaMessage;
_messageContext = messageContext;
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, QueueMessage queueMessage, IMessageContext messageContext)
{
_queueMessage = queueMessage;
_messageContext = messageContext;
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
public void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStream eventStream)
{
if (eventStream.Items == null || eventStream.Items.Count == 0)
{
eventStream.Items = processingCommand.Items;
}
var eventStreamMessage = new DomainEventStreamMessage(processingCommand.Message.Id, eventStream.AggregateRootId, eventStream.Version, eventStream.AggregateRootTypeName, eventStream.Events, eventStream.Items);
PublishDomainEventAsync(processingCommand, eventStreamMessage, 0);
}
public void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStream eventStream)
{
if (eventStream.Items == null || eventStream.Items.Count == 0)
{
eventStream.Items = processingCommand.Items;
}
var eventStreamMessage = new DomainEventStreamMessage(processingCommand.Message.Id, eventStream.AggregateRootId, eventStream.Version, eventStream.AggregateRootTypeName, eventStream.Events, eventStream.Items);
PublishDomainEventAsync(processingCommand, eventStreamMessage, 0);
}
private DomainEventStreamMessage ConvertToDomainEventStream(EventStreamMessage message)
{
var domainEventStreamMessage = new DomainEventStreamMessage(
message.CommandId,
message.AggregateRootId,
message.Version,
message.AggregateRootTypeName,
_eventSerializer.Deserialize<IDomainEvent>(message.Events),
message.Items);
domainEventStreamMessage.Timestamp = message.Timestamp;
return domainEventStreamMessage;
}
private DomainEventStreamMessage ConvertToDomainEventStream(EventStreamMessage message)
{
var domainEventStreamMessage = new DomainEventStreamMessage(
message.CommandId,
message.AggregateRootId,
message.Version,
message.AggregateRootTypeName,
_eventSerializer.Deserialize <IDomainEvent>(message.Events),
message.Items);
domainEventStreamMessage.Timestamp = message.Timestamp;
return(domainEventStreamMessage);
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("PublishDomainEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
_logger.DebugFormat("Publish domain events success, {0}", eventStream);
processingCommand.Complete(new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, null, null));
},
() => string.Format("[eventStream:{0}]", eventStream),
() => processingCommand.Complete(new CommandResult(CommandStatus.Failed, processingCommand.Message.Id, eventStream.AggregateRootId, null, "Publish domain event async failed.")),
retryTimes);
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively("PublishEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
_logger.DebugFormat("Publish event success, {0}", eventStream);
var commandHandleResult = processingCommand.CommandExecuteContext.GetResult();
var commandResult = new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, commandHandleResult, typeof(string).FullName);
CompleteCommand(processingCommand, commandResult);
},
() => string.Format("[eventStream:{0}]", eventStream),
null,
retryTimes, true);
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("PublishDomainEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Publish domain events success, {0}", eventStream);
}
var commandHandleResult = processingCommand.CommandExecuteContext.GetResult();
processingCommand.Complete(new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, commandHandleResult, typeof(string).FullName));
},
() => string.Format("[eventStream:{0}]", eventStream),
errorMessage => processingCommand.Complete(new CommandResult(CommandStatus.Failed, processingCommand.Message.Id, eventStream.AggregateRootId, errorMessage ?? "Publish domain event async failed.", typeof(string).FullName)),
retryTimes);
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively("PublishEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Publish event success, {0}", eventStream);
}
var commandHandleResult = processingCommand.CommandExecuteContext.GetResult();
CompleteCommand(processingCommand, new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, commandHandleResult, typeof(string).FullName));
},
() => string.Format("[eventStream:{0}]", eventStream),
errorMessage =>
{
_logger.Fatal(string.Format("Publish event has unknown exception, the code should not be run to here, errorMessage: {0}", errorMessage));
},
retryTimes, true);
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, IMessageTransportationContext messageContext)
{
_messageContext = messageContext;
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
public DomainEventStreamProcessContext(DomainEventStreamMessage domainEventStreamMessage)
{
_domainEventStreamMessage = domainEventStreamMessage;
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, QueueMessage queueMessage, IMessageContext messageContext)
: base(queueMessage, messageContext)
{
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
public DomainEventStreamProcessContext(DomainEventStreamMessage domainEventStreamMessage, ManualResetEvent waitHandle, IList <int> versionList)
{
_domainEventStreamMessage = domainEventStreamMessage;
_waitHandle = waitHandle;
_versionList = versionList;
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, QueueMessage queueMessage, IMessageContext messageContext)
: base(queueMessage, messageContext)
{
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively<AsyncTaskResult>("PublishDomainEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Publish domain events success, {0}", eventStream);
}
var commandHandleResult = processingCommand.CommandExecuteContext.GetResult();
processingCommand.Complete(new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, commandHandleResult, typeof(string).FullName));
},
() => string.Format("[eventStream:{0}]", eventStream),
errorMessage => processingCommand.Complete(new CommandResult(CommandStatus.Failed, processingCommand.Message.Id, eventStream.AggregateRootId, errorMessage ?? "Publish domain event async failed.", typeof(string).FullName)),
retryTimes);
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively("PublishEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Publish event success, {0}", eventStream);
}
var commandHandleResult = processingCommand.CommandExecuteContext.GetResult();
CompleteCommand(processingCommand, new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, commandHandleResult, typeof(string).FullName));
},
() => string.Format("[eventStream:{0}]", eventStream),
errorMessage =>
{
_logger.Fatal(string.Format("Publish event has unknown exception, the code should not be run to here, errorMessage: {0}", errorMessage));
},
retryTimes, true);
}
public DomainEventStreamProcessContext(DomainEventConsumer eventConsumer, DomainEventStreamMessage domainEventStreamMessage, KafkaMessage message, IKafkaMessageContext messageContext)
: base(message, messageContext)
{
_eventConsumer = eventConsumer;
_domainEventStreamMessage = domainEventStreamMessage;
}
public DomainEventStreamProcessContext(DomainEventStreamMessage domainEventStreamMessage)
{
_domainEventStreamMessage = domainEventStreamMessage;
}
private void PublishDomainEventAsync(ProcessingCommand processingCommand, DomainEventStreamMessage eventStream, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively<AsyncTaskResult>("PublishDomainEventAsync",
() => _domainEventPublisher.PublishAsync(eventStream),
currentRetryTimes => PublishDomainEventAsync(processingCommand, eventStream, currentRetryTimes),
result =>
{
_logger.DebugFormat("Publish domain events success, {0}", eventStream);
processingCommand.Complete(new CommandResult(CommandStatus.Success, processingCommand.Message.Id, eventStream.AggregateRootId, null, null));
},
() => string.Format("[eventStream:{0}]", eventStream),
errorMessage => processingCommand.Complete(new CommandResult(CommandStatus.Failed, processingCommand.Message.Id, eventStream.AggregateRootId, null, errorMessage ?? "Publish domain event async failed.")),
retryTimes);
}
public ProcessingEvent(DomainEventStreamMessage message, IEventProcessContext processContext)
{
Message = message;
ProcessContext = processContext;
}
