public void Handle(Type processorType, IDomainEventRecord record, int retryMaxCount = 5, bool sendToErrorQueue = true)
{
var retries = 0;// record.MetaData.ContainsKey("retries") ? (Int64)record.MetaData["retries"] : 0;
if (retries >= retryMaxCount)
{
//if (sendToErrorQueue)
// _faultQueueService.Put(new FaultInfo()
// {
// ProcessorType = processorType,
// Record = record,
// RetryMaxCount = retryMaxCount
// });
return;
}
//record.MetaData["retries"] = ++retries;
try
{
_backgroundJobQueue.PutJob <RetryEventTask, RetryEventTaskParams>(new RetryEventTaskParams()
{
ProcessorType = processorType.AssemblyQualifiedName,
Record = new Test(record.GetDomainEvent(), record.GetDomainEventType(), record.Sequence),
RetryMaxCount = retryMaxCount,
sendToErrorQueue = sendToErrorQueue
});
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void Publish(IDomainEventRecord message)
{
using (var stream = new MemoryStream())
{
Serializer.Serialize(stream, message);
_db.Publish(_channel, stream.ToArray(), CommandFlags.FireAndForget);
}
}
//this will block if too many events published
private void AddEventToDisruptor(IDomainEventRecord message)
{
if (message.Sequence <= _ringBuffer.Cursor)
{
return;
}
while ((_ringBuffer.Cursor + _ringBuffer.RemainingCapacity()) < message.Sequence)
{
//this will block until message.Sequence will be available or timeout
_barrier.WaitFor(message.Sequence, TimeSpan.FromMilliseconds(100));
}
_ringBuffer[message.Sequence].Value = message;
_ringBuffer.Publish(message.Sequence);
}
public virtual bool HandleEvent(IDomainEventRecord record)
{
var messageType = record.GetDomainEventType();
if (!CanHandleMessage(messageType))
{
return(false);
}
var message = record.GetDomainEvent();
var handler = Handlers.GetValueOrDefault(messageType);
handler.Invoke(message);
return(true);
}
public bool AddEventForProcessing(IDomainEventRecord message)
{
if (!Started())
{
return(false);
}
//Если добавляется сообщение, которое заведомо не влезет в буфер дисруптора и будет заблокировано - не нужно его обрабатывать
if (message.Sequence - _ringBuffer.Cursor > _ringBuffer.BufferSize)
{
return(false);
}
AddEventToDisruptor(message);
return(true);
}
public bool HandleEvent(IDomainEventRecord record)
{
var messageType = record.GetDomainEventType();
if (!CanHandleMessage(messageType))
{
return(false);
}
TSaga saga = null;
var message = record.GetDomainEvent() as IDomainEvent;
var sagaMapper = _sagaEventMapper.GetMapper <TSaga>();
if (message is SagaCommand)
{
saga = _sagaRepository.GetSagaById <TSaga>((message as SagaCommand).SagaId);
}
else
{
var sagaCorrelationId = sagaMapper.GetCorrelationIdFromEvent(message);
if (sagaCorrelationId != null)
{
saga = _sagaRepository.GetSagaByCorrelationId <TSaga>(sagaCorrelationId);
}
}
if (saga == null)
{
saga = _sagaRepository.CreateNewSaga <TSaga>();
}
var handler = Handlers.GetValueOrDefault(messageType);
handler.Invoke(saga, message);
saga.SagaState.SagaVersion++;
//todo : better handle transient faults
var sagaCorrelationIds = sagaMapper.GetCorrelationIdsFromSaga(saga);
_sagaRepository.SaveSaga(saga, sagaCorrelationIds);
return(true);
}
public void Publish(IDomainEventRecord message)
{
//do nothing
}
public void Publish(IDomainEventRecord message)
{
_publishAction(message);
}
public void Recieve(IDomainEventRecord message)
{
_loop.AddEventForProcessing(message);
}
public virtual bool HandleEvent(IDomainEventRecord record)
{
return(false);
}
public void Handle(Type processorType, IDomainEventRecord record, int retryMaxCount = 5, bool sendToErrorQueue = true)
{
//noop
}
public virtual void Recieve(IDomainEventRecord message)
{
_consumerAction?.Invoke(message);
}
public override bool HandleEvent(IDomainEventRecord record)
{
//OzzyLogger<ICommonEvents>.Log.TraceInformationalEvent(record.ToString());
return(false);
}
public void Publish(IDomainEventRecord message)
{
_domainQueue.OnNext(message);
}
