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));
}
