public static IClientBuilder UseQueueSuffix(this IClientBuilder builder, QueueSuffixOptions options = null) { if (options == null) { builder.Register(pipe => pipe.Use<QueueSuffixMiddleware>()); } else { builder.Register(pipe => pipe.Use<QueueSuffixMiddleware>(options)); } return builder; }
public static IClientBuilder UseHttpContext(this IClientBuilder builder) { #if NET451 builder.Register(p => p .Use <NetFxHttpContextMiddleware>() ); #endif #if NETSTANDARD1_6 builder.Register( p => p.Use <AspNetCoreHttpContextMiddleware>(), p => p.AddSingleton <Microsoft.AspNetCore.Http.IHttpContextAccessor, Microsoft.AspNetCore.Http.HttpContextAccessor>() ); #endif return(builder); }
public static IClientBuilder UseJaeger(this IClientBuilder builder, ITracer tracer) { builder.Register(pipe => pipe.Use <JaegerStagedMiddleware>(tracer)); return(builder); }
/// <summary> /// Replaces the default serializer with Protobuf. /// </summary> public static IClientBuilder UseProtobuf(this IClientBuilder builder) { builder.Register( pipe: p => {}, ioc: di => di.AddSingleton <ISerializer, ProtobufSerializer>()); return(builder); }
/// <summary> /// Replaces the default serializer with MessagePack. /// </summary> public static IClientBuilder UseMessagePack(this IClientBuilder builder, MessagePackFormat format = MessagePackFormat.Normal) { builder.Register( pipe: p => { }, ioc: di => di.AddSingleton <ISerializer, MessagePackSerializerWorker>(resolver => new MessagePackSerializerWorker(format))); return(builder); }
/// <summary> /// Replaces the default serializer with ZeroFormatter. /// </summary> public static IClientBuilder UseZeroFormatter(this IClientBuilder builder) { builder.Register( pipe: p => { }, ioc: di => di.AddSingleton <ISerializer, ZeroFormatterSerializerWorker>()); return(builder); }
public static IClientBuilder UseHttpContext(this IClientBuilder builder) { builder.Register( p => p.Use <AspNetCoreHttpContextMiddleware>(), p => p.AddSingleton <Microsoft.AspNetCore.Http.IHttpContextAccessor, Microsoft.AspNetCore.Http.HttpContextAccessor>() ); return(builder); }
public static IClientBuilder UseContextForwarding(this IClientBuilder builder) { builder.Register( pipe => pipe .Use <PublishForwardingMiddleware>() .Use <ConsumeForwardingMiddleware>(), ioc => ioc .AddSingleton <IMessageContextRepository, MessageContextRepository>()); return(builder); }
public static IClientBuilder UseMessageContext <TMessageContext>(this IClientBuilder builder, Func <IPipeContext, TMessageContext> createFunc) { Func <IPipeContext, object> genericCreateFunc = context => createFunc(context); builder.Register(pipe => pipe.Use <HeaderSerializationMiddleware>(new HeaderSerializationOptions { HeaderKeyFunc = context => PropertyHeaders.Context, RetrieveItemFunc = context => context.GetMessageContext(), CreateItemFunc = genericCreateFunc })); return(builder); }
public static IClientBuilder UseRetryLater(this IClientBuilder builder) { builder.Register( pipe => pipe .Use <RetryLaterMiddleware>() .Use <RetryInformationExtractionMiddleware>(), ioc => ioc .AddSingleton <IRetryInformationHeaderUpdater, RetryInformationHeaderUpdater>() .AddSingleton <IRetryInformationProvider, RetryInformationProvider>() ); return(builder); }
/// <summary> /// Registers dependencies for the StateMachine operation. /// /// StateMachine models are stored in-memory, but can /// be changed by registrating functions for get, add and update. /// The execution is only exclusive in the process. If usesd in /// a distributed environment, consider changing this by /// register an own execute func. /// </summary> /// <param name="builder">The client builder</param> /// <param name="get">Get for model (repo)</param> /// <param name="addOrUpdate">Add or update (repo)</param> /// <param name="execute">Method to ensure exclusive execution</param> /// <returns></returns> public static IClientBuilder UseStateMachine( this IClientBuilder builder, Func <Guid, Task <Model> > get = null, Func <Model, Task> addOrUpdate = null, Func <Guid, Func <Task>, CancellationToken, Task> execute = null) { builder.Register( pipe => {}, ioc => ioc .AddSingleton <IGlobalLock>(new GlobalLock(execute)) .AddSingleton <IModelRepository>(new ModelRepository(get, addOrUpdate)) .AddTransient <IStateMachineActivator, StateMachineActivator>(resolver => new StateMachineActivator(resolver.GetService <IModelRepository>(), resolver)) ); return(builder); }
public static IClientBuilder UsePolly(this IClientBuilder builder, PolicyOptions options) { builder.Register( pipe => pipe .Use <PolicyMiddleware>(options) .Replace <QueueDeclareMiddleware, Enrichers.Polly.Middleware.QueueDeclareMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <ExchangeDeclareMiddleware, Enrichers.Polly.Middleware.ExchangeDeclareMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <QueueBindMiddleware, Enrichers.Polly.Middleware.QueueBindMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <ConsumerCreationMiddleware, Enrichers.Polly.Middleware.ConsumerCreationMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <BasicPublishMiddleware, Enrichers.Polly.Middleware.BasicPublishMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <ExplicitAckMiddleware, Enrichers.Polly.Middleware.ExplicitAckMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <PooledChannelMiddleware, Enrichers.Polly.Middleware.PooledChannelMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <TransientChannelMiddleware, Enrichers.Polly.Middleware.TransientChannelMiddleware>(argsFunc: oldArgs => oldArgs) .Replace <HandlerInvocationMiddleware, Enrichers.Polly.Middleware.HandlerInvocationMiddleware>(argsFunc: oldArgs => oldArgs), ioc => ioc .AddSingleton <IChannelFactory, RawRabbit.Enrichers.Polly.Services.ChannelFactory>() .AddSingleton(options.ConnectionPolicies)); return(builder); }
public static IClientBuilder UseAttributeRouting(this IClientBuilder builder, ConsumeAttributeOptions consume = null, ProduceAttributeOptions produce = null) { if (consume == null) { consume = new ConsumeAttributeOptions { MessageTypeFunc = context => context.Get <Type>(IncommingMessageType) ?? context.Get <Type>(PipeKey.MessageType) }; } if (produce == null) { produce = new ProduceAttributeOptions { MessageTypeFunc = context => context.Get <Type>(OutgoingMessageType) ?? context.Get <Type>(PipeKey.MessageType) }; } builder.Register(pipe => pipe .Use <ConsumeAttributeMiddleware>(consume) .Use <ProduceAttributeMiddleware>(produce)); return(builder); }
public static IClientBuilder UseGlobalExecutionId(this IClientBuilder builder) { builder.Register(pipe => pipe // Pulisher .Use <AppendGlobalExecutionIdMiddleware>() .Use <ExecutionIdRoutingMiddleware>() .Use <PublishHeaderAppenderMiddleware>() // Subscriber .Use <WildcardRoutingKeyMiddleware>() // Message Received .Use <HeaderDeserializationMiddleware>(new HeaderDeserializationOptions { HeaderKeyFunc = c => PropertyHeaders.GlobalExecutionId, HeaderTypeFunc = c => typeof(string), ContextSaveAction = (ctx, id) => ctx.Properties.TryAdd(PipeKey.GlobalExecutionId, id) }) .Use <PersistGlobalExecutionIdMiddleware>() ); return(builder); }
public static IClientBuilder UseExtensionRetryLater(this IClientBuilder builder) { builder.UseAttributeRouting().UseRetryLater().Register( pipe: p => { p.Replace <RetryLaterMiddleware, ExtensionRetryLaterMiddleware>(args: new RetryLaterOptions() { DeliveryArgsFunc = pipeContext => { var deliveryEventArgs = pipeContext.GetDeliveryEventArgs(); //var consumerConfiguration = pipeContext.GetConsumerConfiguration(); //if (consumerConfiguration != null && consumerConfiguration.Queue != null) //{ // deliveryEventArgs.RoutingKey = consumerConfiguration.Queue.Name; // deliveryEventArgs.Exchange = consumerConfiguration.Queue.Name; //} return(deliveryEventArgs); } }); }); builder.Register(pipe: p => { p.Replace <HeaderDeserializationMiddleware, HeaderDeserializationMiddleware>(args: new HeaderDeserializationOptions() { HeaderKeyFunc = c => PropertyHeaders.Context, HeaderTypeFunc = c => c.GetMessageContextType(), ContextSaveAction = (pipeCtx, msgCtx) => pipeCtx.Properties.TryAdd(PipeKey.MessageContext, msgCtx), DeliveryArgsFunc = pipeContext => { var deliveryEventArgs = pipeContext.GetDeliveryEventArgs(); //增加这个是因为RawRabbit中HeaderDeserializationMiddleware有一个BUG,在Headers==null的时候会引发一个异常 if (deliveryEventArgs.BasicProperties.Headers == null) { deliveryEventArgs.BasicProperties.Headers = new Dictionary <string, object>(); } return(deliveryEventArgs); } }); }); return(builder); }
private static IClientBuilder ProcessUniqueMessages(this IClientBuilder clientBuilder) { clientBuilder.Register(c => c.Use <ProcessUniqueMessagesMiddleware>()); return(clientBuilder); }
private static IClientBuilder UpdateRetryInfo(this IClientBuilder clientBuilder) { clientBuilder.Register(c => c.Use <RetryStagedMiddleware>()); return(clientBuilder); }