public void Apply(IPipeBuilder <T> builder)
{
var filter = new RateLimitFilter <T>(_rateLimit, _interval);
builder.AddFilter(filter);
_router?.ConnectPipe(filter);
}
public void Apply(IPipeBuilder <CompensateContext <TLog> > builder)
{
var retryPolicy = _policyFactory(Filter);
var policy = new ConsumeContextRetryPolicy <CompensateContext <TLog>, RetryCompensateContext <TLog> >(retryPolicy, _cancellationToken, Factory);
builder.AddFilter(new RetryFilter <CompensateContext <TLog> >(policy, _observers));
}
void IPipeSpecification <TContext> .Apply(IPipeBuilder <TContext> builder)
{
IPipe <BindContext <TContext, TSource> > pipe = _pipeConfigurator.Build();
var bindFilter = new PipeContextSourceBindFilter <TContext, TSource>(pipe, _source);
builder.AddFilter(bindFilter);
}
void IPipeSpecification <TContext> .Apply(IPipeBuilder <TContext> builder)
{
var mapper = _autoMapperConfigurator.MapperConfiguration.CreateMapper();
AutoMapperFilter <TContext> filter = new AutoMapperFilter <TContext>(mapper);
builder.AddFilter(filter);
}
public void Apply(IPipeBuilder <ConsumeContext <TMessage> > builder)
{
var retryPolicy = _policyFactory(Filter);
var policy = new ConsumeContextRetryPolicy <ConsumeContext <TMessage>, RetryConsumeContext <TMessage> >(retryPolicy, CancellationToken.None, Factory);
builder.AddFilter(new RedeliveryRetryFilter <TMessage>(policy, _observers));
}
public void Apply(IPipeBuilder <ConsumeContext> builder)
{
var retryPolicy = _policyFactory(Filter);
var contextRetryPolicy = new ConsumeContextRetryPolicy(retryPolicy, _cancellationToken);
builder.AddFilter(new RetryFilter <ConsumeContext>(contextRetryPolicy, _observers));
}
public void Apply(IPipeBuilder <ExecuteContext <TArguments> > builder)
{
var retryPolicy = _policyFactory(Filter);
var policy = new ConsumeContextRetryPolicy <ExecuteContext <TArguments>, RetryExecuteContext <TArguments> >(retryPolicy, _cancellationToken, Factory);
builder.AddFilter(new RetryFilter <ExecuteContext <TArguments> >(policy, _observers));
}
public void Apply(IPipeBuilder <T> builder)
{
var filter = new ConcurrencyLimitFilter <T>(_concurrencyLimit);
builder.AddFilter(filter);
_dynamicRouter.ConnectPipe(filter);
}
public void Apply(IPipeBuilder <ConsumerConsumeContext <TConsumer> > builder)
{
var messageBuilder = builder as IPipeBuilder <ConsumeContext <TMessage> >;
if (messageBuilder != null)
{
_specification.Apply(messageBuilder);
}
}
void IPipeSpecification <ExecuteContext <TMessage> > .Apply(IPipeBuilder <ExecuteContext <TMessage> > builder)
{
if (Count > 0)
{
IMessageInitializer <TMessage> initializer = Build();
builder.AddFilter(new TransformFilter <TMessage>(initializer));
}
}
public void Apply(IPipeBuilder <ExecuteActivityContext <TActivity, TArguments> > builder)
{
var messageBuilder = builder as IPipeBuilder <ExecuteActivityContext <TArguments> >;
if (messageBuilder != null)
{
_specification.Apply(messageBuilder);
}
}
public void Apply(IPipeBuilder <ConsumeContext <T> > builder)
{
if (_keyProvider == null)
{
throw new ConfigurationException($"The partition key provider was not found for message type: {TypeMetadataCache<T>.ShortName}");
}
builder.AddFilter(new PartitionFilter <ConsumeContext <T> >(_keyProvider, _partitioner));
}
public void Apply(IPipeBuilder <ConsumeContext <TMessage> > builder)
{
var retryPolicy = _policyFactory(Filter);
var policy = new ConsumeContextRetryPolicy <ConsumeContext <TMessage>, RetryConsumeContext <TMessage> >(retryPolicy,
x => x as RetryConsumeContext <TMessage> ?? new RedeliveryRetryConsumeContext <TMessage>(x));
builder.AddFilter(new RedeliveryRetryFilter <TMessage>(policy, _observers));
}
public void Apply(IPipeBuilder <CompensateActivityContext <TActivity, TLog> > builder)
{
var messageBuilder = builder as IPipeBuilder <CompensateActivityContext <TLog> >;
if (messageBuilder != null)
{
_specification.Apply(messageBuilder);
}
}
void IPipeSpecification <TContext> .Apply(IPipeBuilder <TContext> builder)
{
IPipe <BindContext <TContext, TTarget> > pipe = _pipeConfigurator.Build();
ITargetFilter <TTarget> targetFilter = _filterFactory();
var bindFilter = new BindFilter <TContext, TTarget>(pipe, targetFilter);
builder.AddFilter(bindFilter);
}
public void Apply(IPipeBuilder <TInput> builder)
{
var dispatchFilter = new DynamicFilter <TInput>(_pipeContextConverterFactory);
foreach (var specification in _specifications)
{
specification.Connect(dispatchFilter);
}
builder.AddFilter(dispatchFilter);
}
public void Apply(IPipeBuilder <TInput> builder)
{
var dispatchFilter = new DynamicFilter <TInput>(_pipeContextConverterFactory);
foreach (Action <IPipeConnector> action in _connectActions)
{
action(dispatchFilter);
}
builder.AddFilter(dispatchFilter);
}
public void Apply(IPipeBuilder <TInput> builder)
{
var dynamicFilter = new DynamicFilter <TInput>(_pipeContextConverterFactory);
var count = _specifications.Count;
for (var index = 0; index < count; index++)
{
_specifications[index].Connect(dynamicFilter);
}
builder.AddFilter(dynamicFilter);
}
private IAsyncPipe <int, int> CreateAsyncPipe(IPipeBuilder <int, int> builder)
{
return(builder.AsyncPipe()
.Executor(async(model, cache) =>
{
await Task.Delay(1000);
return PipeResult <int>
.DefaultSuccessful
.SetValue(model);
})
.Add()
.Return((model, results) => results[0]));
}
public void Apply(IPipeBuilder <ConnectionContext> builder)
{
IPipe <ModelContext> pipe = Pipe.New <ModelContext>(x =>
{
x.UseFilter(new PrepareReceiveQueueFilter(_settings, _managementPipe, _exchangeBindings));
x.UseFilter(new RabbitMqConsumerFilter(_receivePipe, _receiveObserver, _endpointObserver, _supervisor));
});
IFilter <ConnectionContext> modelFilter = new ReceiveModelFilter(pipe, _supervisor, _modelSettings);
builder.AddFilter(modelFilter);
}
internal AsyncExecutionPool(
IPipeBuilder <M, R> builder,
Func <IPipeBuilder <M, R>, IAsyncPipe <M, R> > factory,
int initialCount,
int maxCount,
int increaseRatio = 2)
{
_stack = new ConcurrentStack <IAsyncPipe <M, R> >();
_builder = builder;
_factory = factory;
_initialCount = initialCount;
_maxCount = maxCount;
_increaseRatio = increaseRatio;
InitPool();
}
public void Apply(IPipeBuilder <ConnectionContext> builder)
{
IPipe <ModelContext> pipe = Pipe.New <ModelContext>(x =>
{
x.UseFilter(new ConfigureTopologyFilter <ReceiveSettings>(_settings, _topology.BrokerTopology));
if (_settings.PurgeOnStartup)
{
x.UseFilter(new PurgeOnStartupFilter(_settings.QueueName));
}
x.UseFilter(new PrefetchCountFilter(_managementPipe, _settings.PrefetchCount));
x.UseFilter(new RabbitMqConsumerFilter(_receivePipe, _receiveObserver, _transportObserver, _supervisor, _topology));
});
IFilter <ConnectionContext> modelFilter = new ReceiveModelFilter(pipe, _supervisor, _host);
builder.AddFilter(modelFilter);
}
public ClusterInMemoryTopologyDriver(string clientId, InternalTopologyBuilder topologyBuilder, IStreamConfig configuration, IStreamConfig topicConfiguration, TimeSpan startTimeout, CancellationToken token)
{
this.startTimeout = startTimeout;
this.configuration = configuration;
this.configuration.ClientId = clientId;
this.topicConfiguration = topicConfiguration;
this.token = token;
kafkaSupplier = new MockKafkaSupplier();
pipeBuilder = new KafkaPipeBuilder(kafkaSupplier);
// ONLY FOR CHECK IF TOLOGY IS CORRECT
topologyBuilder.BuildTopology();
threadTopology = StreamThread.Create(
$"{this.configuration.ApplicationId.ToLower()}-stream-thread-0",
clientId,
topologyBuilder,
this.configuration,
kafkaSupplier,
kafkaSupplier.GetAdmin(configuration.ToAdminConfig($"{clientId}-admin")),
0);
}
public void Apply(IPipeBuilder <ConsumeContext> builder)
{
builder.AddFilter(new PublishMessageSchedulerFilter());
}
public void Apply(IPipeBuilder <PublishContext> builder)
{
builder.AddFilter(new OpenTracingPublishFilter(_configuration));
}
public void Apply(IPipeBuilder <ConsumeContext> builder)
{
builder.AddFilter(new OpenTracingConsumeFilter(_configuration));
}
public void Apply(IPipeBuilder <TContext> builder)
{
builder.AddFilter(new InterceptFilter <TContext>(_pipe));
}
public void Apply(IPipeBuilder <ConsumerConsumeContext <TConsumer, TMessage> > builder)
{
_specification.Apply(builder);
}
public void Apply(IPipeBuilder <SagaConsumeContext <TSaga, TMessage> > builder)
{
_specification.Apply(builder);
}
void IPipeSpecification <SendContext> .Apply(IPipeBuilder <SendContext> builder)
{
builder.AddFilter(this);
}
