public static Task RespondAsync <TRequest, TResponse>( this IBusClient client, Func <TRequest, Task <TypedAcknowlegement <TResponse> > > handler, Action <IRespondContext> context = null, CancellationToken ct = default(CancellationToken)) { return(client .InvokeAsync( RespondPipe, ctx => { Func <object[], Task <Acknowledgement> > genericHandler = args => handler((TRequest)args[0]) .ContinueWith(tResponse => { if (tResponse.IsFaulted) { throw tResponse.Exception; } return tResponse.Result.AsUntyped(); }, ct); ctx.Properties.Add(RespondKey.IncomingMessageType, typeof(TRequest)); ctx.Properties.Add(RespondKey.OutgoingMessageType, typeof(TResponse)); ctx.Properties.Add(PipeKey.MessageHandler, genericHandler); context?.Invoke(new RespondContext(ctx)); }, ct )); }
public static async Task <Ackable <BasicGetResult> > GetAsync(this IBusClient busClient, Action <IGetConfigurationBuilder> config = null, CancellationToken token = default(CancellationToken)) { var result = await busClient .InvokeAsync(UntypedGetPipe, context => context.Properties.Add(PipeKey.ConfigurationAction, config), token); return(result.Get <Ackable <object> >(GetKey.AckableResult).AsAckable <BasicGetResult>()); }
public static Task BasicConsumeAsync(this IBusClient busClient, Func <BasicDeliverEventArgs, Task <Acknowledgement> > consumeFunc, Action <IPipeContext> context) { Func <object[], Task <Acknowledgement> > genericFunc = args => consumeFunc(args[0] as BasicDeliverEventArgs); return(busClient .InvokeAsync(pipe => pipe .Use <ConsumeConfigurationMiddleware>() .Use <QueueBindMiddleware>(new QueueBindOptions { ExchangeNameFunc = ctx => ctx.GetConsumeConfiguration()?.ExchangeName }) .Use <ConsumerCreationMiddleware>() .Use <ConsumerMessageHandlerMiddleware>(new ConsumeOptions { Pipe = p => p .Use <HandlerInvocationMiddleware>(new HandlerInvocationOptions { HandlerArgsFunc = ctx => new object[] { ctx.GetDeliveryEventArgs() }, }) .Use <ExplicitAckMiddleware>() }) .Use <ConsumerConsumeMiddleware>(), ctx => { ctx.Properties.Add(PipeKey.MessageHandler, genericFunc); context?.Invoke(ctx); } )); }
public static Task BindQueueAsync <TMessage>(this IBusClient client, CancellationToken ct = default(CancellationToken)) { return(client.InvokeAsync(BindQueueAction, cfg => { cfg.Properties.AddOrReplace(PipeKey.MessageType, typeof(TMessage)); }, ct)); }
public static Task DeleteExchangeAsync(this IBusClient client, string exchangeName, bool ifUsed = false) { return(client.InvokeAsync(DeleteExchangePipe, context => { context.Properties.Add(ExchangeName, exchangeName); context.Properties.Add(IfUsed, ifUsed); })); }
public static Task DeleteExchangeAsync <TMessage>(this IBusClient client, bool ifUsed = false) { return(client.InvokeAsync(DeleteExchangePipe, context => { context.Properties.Add(PipeKey.MessageType, typeof(TMessage)); context.Properties.Add(IfUsed, ifUsed); })); }
public static async Task <IBasicConsumer> CreateConsumerAsync(this IBusClient client, ConsumeConfiguration config = null, CancellationToken ct = default(CancellationToken)) { var result = await client.InvokeAsync(ConsumerAction, context => { context.Properties.Add(PipeKey.ConsumeConfiguration, config); }, ct); return(result.GetConsumer()); }
public static Task PublishAsync <TMessage>(this IBusClient client, TMessage message, Action <IPublishContext> context = null, CancellationToken token = default(CancellationToken)) { return(client.InvokeAsync( PublishPipeAction, ctx => { ctx.Properties.Add(PipeKey.MessageType, message?.GetType() ?? typeof(TMessage)); ctx.Properties.Add(PipeKey.Message, message); context?.Invoke(new PublishContext(ctx)); }, token)); }
public static async Task RegisterStateMachineAsync <TTriggerConfiguration>( this IBusClient busClient, CancellationToken ct = default(CancellationToken)) where TTriggerConfiguration : TriggerConfigurationCollection, new() { var triggerCfgs = new TTriggerConfiguration().GetTriggerConfiguration(); foreach (var triggerCfg in triggerCfgs) { await busClient.InvokeAsync(triggerCfg.Pipe, triggerCfg.Context, ct); } }
internal static async Task <Ackable <TMessage> > GetAsync <TMessage>(this IBusClient busClient, Action <IGetConfigurationBuilder> config = null, Action <IPipeContext> pipeAction = null, CancellationToken token = default(CancellationToken)) { var result = await busClient .InvokeAsync(DeserializedBodyGetPipe, context => { context.Properties.Add(PipeKey.ConfigurationAction, config); context.Properties.Add(PipeKey.MessageType, typeof(TMessage)); pipeAction?.Invoke(context); }, token); return(result.Get <Ackable <object> >(GetKey.AckableResult).AsAckable <TMessage>()); }
public static Task BasicPublishAsync( this IBusClient busClient, BasicPublishConfiguration config, CancellationToken token = default(CancellationToken) ) { return(busClient.InvokeAsync( PublishPipe, context => context.Properties.Add(PipeKey.BasicPublishConfiguration, config), token )); }
public static Task BindQueueAsync(this IBusClient client, string queueName, string exchangeName, string routingKey, CancellationToken ct = default(CancellationToken)) { return(client.InvokeAsync(BindQueueAction, cfg => { cfg.Properties.AddOrReplace(PipeKey.ConsumeConfiguration, new ConsumeConfiguration { QueueName = queueName, ExchangeName = exchangeName, RoutingKey = routingKey }); }, ct)); }
public static async Task <TResponse> RequestAsync <TRequest, TResponse>(this IBusClient client, TRequest message = default(TRequest), Action <IRequestContext> context = null, CancellationToken ct = default(CancellationToken)) { var result = await client .InvokeAsync(RequestPipe, ctx => { ctx.Properties.Add(RequestKey.OutgoingMessageType, typeof(TRequest)); ctx.Properties.Add(RequestKey.IncommingMessageType, typeof(TResponse)); ctx.Properties.Add(PipeKey.Message, message); context?.Invoke(new RequestContext(ctx)); }, ct); return(result.Get <TResponse>(RequestKey.ResponseMessage)); }
public static Task SubscribeAsync <TMessage>(this IBusClient client, Func <TMessage, Task <Acknowledgement> > subscribeMethod, Action <ISubscribeContext> context = null, CancellationToken ct = default(CancellationToken)) { return(client.InvokeAsync( SubscribePipe, ctx => { Func <object[], Task <Acknowledgement> > genericHandler = args => subscribeMethod((TMessage)args[0]); ctx.Properties.TryAdd(PipeKey.MessageType, typeof(TMessage)); ctx.Properties.TryAdd(PipeKey.MessageHandler, genericHandler); context?.Invoke(new SubscribeContext(ctx)); }, ct)); }
public static Task BasicPublishAsync( this IBusClient busClient, object message, Action <IBasicPublishConfigurationBuilder> config = null, CancellationToken token = default(CancellationToken)) { return(busClient.InvokeAsync( PublishPipe, context => { context.Properties.Add(PipeKey.Message, message); context.Properties.Add(PipeKey.ConfigurationAction, config); }, token )); }
public static MessageSequence <TCompleteType> ExecuteSequence <TCompleteType>( this IBusClient client, Func <IMessageChainPublisher, MessageSequence <TCompleteType> > cfg ) { var sequenceMachine = client .InvokeAsync(ctx => ctx .Use <RetrieveStateMachineMiddleware>(new RetrieveStateMachineOptions { StateMachineTypeFunc = pipeContext => typeof(StateMachine.MessageSequence) }) ) .GetAwaiter() .GetResult() .GetStateMachine(); return(cfg((StateMachine.MessageSequence)sequenceMachine)); }
public static Task <IPipeContext> SubscribeAsync <TMessage, TMessageContext>( this IBusClient client, Func <TMessage, TMessageContext, Task <Acknowledgement> > subscribeMethod, Action <ISubscribeContext> context = null, CancellationToken token = default(CancellationToken)) { return(client .InvokeAsync( SubscribePipe, ctx => { Func <object[], Task <Acknowledgement> > genericHandler = args => subscribeMethod((TMessage)args[0], (TMessageContext)args[1]); ctx.Properties.TryAdd(PipeKey.MessageType, typeof(TMessage)); if (!ctx.Properties.ContainsKey(PipeContextExtensions.PipebasedContextFunc)) { ctx.AddMessageContextType <TMessageContext>(); } ctx.Properties.TryAdd(PipeKey.MessageHandler, genericHandler); context?.Invoke(new SubscribeContext(ctx)); }, token)); }
public static Task DeleteQueueAsync(this IBusClient client, string queueName) { return(client.InvokeAsync(DeletePipe, ctx => ctx.Properties.Add(QueueName, queueName))); }
public static Task DeclareExchangeAsync <TMessage>(this IBusClient client, CancellationToken ct = default(CancellationToken)) { return(client.InvokeAsync(DeclareExchangeAction, context => context.Properties.TryAdd(PipeKey.MessageType, typeof(TMessage)), ct)); }
public static async Task DeclareQueueAsync <TMessage>(this IBusClient client, CancellationToken ct = default(CancellationToken)) { await client.InvokeAsync(DeclareQueueAction, ctx => ctx.Properties.Add(PipeKey.MessageType, typeof(TMessage)), ct); }
public static Task DeleteQueueAsync <TMessage>(this IBusClient client) { return(client.InvokeAsync(DeletePipe, ctx => ctx.Properties.Add(PipeKey.MessageType, typeof(TMessage)))); }
public static async Task DeclareQueueAsync(this IBusClient client, QueueDeclaration declaration, CancellationToken ct = default(CancellationToken)) { await client.InvokeAsync(DeclareQueueAction, ctx => ctx.Properties.Add(PipeKey.QueueDeclaration, declaration), ct); }
public Task <IPipeContext> InvokeAsync(Action <IPipeBuilder> pipeCfg, Action <IPipeContext> contextCfg, CancellationToken token = new CancellationToken()) { return(_busClient.InvokeAsync(pipeCfg, contextCfg, token)); }
public static async Task <IModel> CreateChannelAsync(this IBusClient busClient, ChannelCreationOptions options = null, CancellationToken token = default(CancellationToken)) { var context = await busClient.InvokeAsync(CreateChannelPipe, token : token); return(context.GetChannel()); }
public static Task DeclareExchangeAsync(this IBusClient client, ExchangeDeclaration declaration, CancellationToken ct = default(CancellationToken)) { return(client.InvokeAsync(DeclareExchangeAction, ctx => ctx.Properties.Add(PipeKey.ExchangeDeclaration, declaration), ct)); }