private static ConsumedMessage.ConsumingResult BuildFailure(IConsumer consumer,
ConsumedMessageBase message,
Exception exception)
{
consumer.OnError(exception);
return new ConsumedMessage.Failure(message, consumer, exception);
}
private static ConsumedMessage.ConsumingResult BuildFailure(IConsumer consumer,
ConsumedMessageBase message,
Exception exception)
{
consumer.OnError(exception);
return(new ConsumedMessage.Failure(message, consumer, exception));
}
protected ConsumingFailureBase(ConsumedMessageBase message,
ConsumedMessage.ConsumingResult[] results,
params Exception[] exceptions)
: base(message, results)
{
_exceptions = exceptions;
}
private AggregateConsumingResult AggregateResult(Task<ConsumingResult[]> task,
ConsumedMessageBase message,
IFallbackStrategy fallbackStrategy)
{
return task.Result.OfType<Failure>().Any()
? BuildErrorResult(task.Result, fallbackStrategy)
: new Messages.Success(message);
}
protected ConsumingFailureBase(ConsumedMessageBase message,
IFallbackStrategy fallbackStrategy,
params Exception[] exceptions)
: base(message)
{
_fallbackStrategy = fallbackStrategy;
_exceptions = exceptions;
}
public virtual Task <IPublishResult> ForwardAsync(ConsumedMessageBase message,
Exchange exchange,
String routingKey)
{
var properties = message.Args.BasicProperties.Clone() as IBasicProperties;
var body = message.Args.Body;
return(PublishInternalAsync(exchange, routingKey, properties, body));
}
internal static Task<ConsumedMessage.ConsumingResult> SafeConsumeAsync(this IConsumer consumer,
ConsumedMessageBase message)
{
try
{
return consumer.ConsumeAsync(message)
.ContinueWith(_ =>
{
if (_.Exception == null)
return new ConsumedMessage.Success(message, consumer);
return BuildFailure(consumer,
message,
_.Exception.GetBaseException());
});
}
catch (Exception exception) { return Task.FromResult(BuildFailure(consumer, message, exception)); }
}
internal static Task <ConsumedMessage.ConsumingResult> SafeConsumeAsync(this IConsumer consumer,
ConsumedMessageBase message)
{
try
{
return(consumer.ConsumeAsync(message)
.ContinueWith(_ =>
{
if (_.Exception == null)
{
return new ConsumedMessage.Success(message, consumer);
}
return BuildFailure(consumer,
message,
_.Exception.GetBaseException());
}));
}
catch (Exception exception) { return(Task.FromResult(BuildFailure(consumer, message, exception))); }
}
internal ConsumingFailure(ConsumedMessageBase message,
IFallbackStrategy fallbackStrategy,
params Exception[] exceptions)
: base(message, fallbackStrategy, exceptions)
{
}
protected AggregateConsumingResult(ConsumedMessageBase message)
{
Message = message;
}
internal UnsupportedMessageConsumingFailure(ConsumedMessageBase message, IFallbackStrategy fallbackStrategy)
: base(message, fallbackStrategy)
{
}
internal Success(ConsumedMessageBase message)
: base(message)
{
}
public void Apply(IOutboundChannel channel, ConsumedMessageBase message)
{
}
internal Success(ConsumedMessageBase message, ConsumedMessage.ConsumingResult[] results)
: base(message, results)
{
}
public void Apply(IOutboundChannel channel, ConsumedMessageBase message) { }
internal IEnumerable <IConsumer> FindSubscriptions(ConsumedMessageBase message)
{
return(_subscriptions.Where(_ => message.Match(_.Key))
.SelectMany(_ => _.Value));
}
internal UnresolvedMessageConsumingFailure(ConsumedMessageBase message,
ConsumedMessage.ConsumingResult[] results)
: base(message, results)
{
}
internal ConsumingFailure(ConsumedMessageBase message,
ConsumedMessage.ConsumingResult[] results,
params Exception[] exceptions)
: base(message, results, exceptions)
{
}
internal Failure(ConsumedMessageBase message, IConsumer consumer, Exception exception)
: base(message, consumer)
{
Exception = exception;
}
protected ConsumingResult(ConsumedMessageBase message, IConsumer consumer)
{
Message = message;
Consumer = consumer;
}
internal CorruptedMessageConsumingFailure(ConsumedMessageBase message,
ConsumedMessage.ConsumingResult[] results)
: base(message, results)
{
}
public void Apply(IOutboundChannel channel, ConsumedMessageBase message)
{
channel.ForwardAsync(message, _exchange, String.Empty);
}
Task IConsumer.ConsumeAsync(ConsumedMessageBase message)
{
return(ConsumeAsync(message.As <TMessage>()));
}
public Success(ConsumedMessageBase message, IConsumer consumer)
: base(message, consumer)
{
}
protected AggregateConsumingResult(ConsumedMessageBase message, ConsumedMessage.ConsumingResult[] results)
{
Message = message;
Results = results;
}
public void Apply(IOutboundChannel channel, ConsumedMessageBase message)
{
channel.ForwardAsync(message, _exchange, String.Empty);
}
public ConsumingResultStub(ConsumedMessageBase message, IConsumer consumer) : base(message, consumer)
{
}