protected override Task ExecuteAsync(System.Threading.CancellationToken stoppingToken) { _queue.SubscribeAsync <UserCreateMessage>(CreateProfile); _queue.RespondAsync <ProfileRequestMessage, ResultMessage>(GetProfile); _queue.RespondAsync <ProfileUpdateRequestMessage, ResultMessage>(UpdateProfile); return(Task.CompletedTask); }
public static async Task Main() { Log.Logger = new LoggerConfiguration() .WriteTo.Console() .CreateLogger(); _client = ZyRabbitFactory.CreateSingleton(new ZyRabbitOptions { ClientConfiguration = new ConfigurationBuilder() .AddJsonFile("zyrabbit.json") .Build() .Get <ZyRabbitConfiguration>(), Plugins = p => p .UseGlobalExecutionId() .UseMessageContext <MessageContext>(), DependencyInjection = register => { register.AddSingleton(typeof(ILogger <>), typeof(SerilogLogger <>)); register.AddSingleton <Microsoft.Extensions.Logging.ILogger, SerilogLogger <object> >(resolver => new SerilogLogger <object>()); } }); await _client.SubscribeAsync <ValuesRequested, MessageContext>((requested, ctx) => ServerValuesAsync(requested, ctx)); await _client.RespondAsync <ValueRequest, ValueResponse>(request => SendValuesThoughRpcAsync(request)); Console.ReadKey(); }
protected override Task ExecuteAsync(System.Threading.CancellationToken stoppingToken) { _queue.RespondAsync <TeamRequestMessage, ResultMessage>(GetTeam); _queue.RespondAsync <TeamsRequestMessage, ResultMessage>(GetAllTeams); _queue.RespondAsync <PokemonRequestMessage, ResultMessage>(GetPokemon); _queue.RespondAsync <PokemenRequestMessage, ResultMessage>(GetAllPokemon); _queue.RespondAsync <BadgeRequestMessage, ResultMessage>(GetBadge); _queue.RespondAsync <BadgesRequestMessage, ResultMessage>(GetAllBadges); _queue.RespondAsync <PokemonTypeRequestMessage, ResultMessage>(GetPokemonType); _queue.RespondAsync <PokemonTypesRequestMessage, ResultMessage>(GetAllPokemonTypes); return(Task.CompletedTask); }
public void Setup() { _busClient = ZyRabbitFactory.CreateSingleton(); _request = new Request(); _respond = new Respond(); _busClient.RespondAsync <Request, Respond>(message => Task.FromResult(_respond)); _busClient.RespondAsync <Request, Respond>(message => Task.FromResult(_respond), ctx => ctx.UseRespondConfiguration(cfg => cfg .Consume(c => c .WithRoutingKey("custom_key")) .FromDeclaredQueue(q => q .WithName("custom_queue") .WithAutoDelete()) .OnDeclaredExchange(e => e .WithName("custom_exchange") .WithAutoDelete())) ); }
public static void Main(string[] args) { // var client = RabbitHutch.CreateBus("host=localhost;username=guest;password=guest"); IBusClient client = RawRabbitFactory.CreateSingleton(new RawRabbitOptions() { ClientConfiguration = ConnectionStringParser.Parse("guest:guest@localhost:5672/") }); client.RespondAsync <ValueRequest, ValueResponse>(r => SendValuesThoughRpcAsync(r)); QuitEvent.WaitOne(); }
public static void Main(string[] args) { _client = BusClientFactory.CreateDefault( cfg => cfg .SetBasePath(Environment.CurrentDirectory) .AddJsonFile("rawrabbit.json"), ioc => ioc .AddSingleton <IConfigurationEvaluator, AttributeConfigEvaluator>() ); _client.SubscribeAsync <ValuesRequested>(ServeValuesAsync); _client.RespondAsync <ValueRequest, ValueResponse>(SendValuesThoughRpcAsync); }
public static void Main(string[] args) { _client = BusClientFactory.CreateDefault( cfg => cfg .SetBasePath(Environment.CurrentDirectory) .AddJsonFile("rawrabbit.json"), ioc => ioc .AddSingleton<IConfigurationEvaluator, AttributeConfigEvaluator>() ); _client.SubscribeAsync<ValuesRequested>(ServeValuesAsync); _client.RespondAsync<ValueRequest, ValueResponse>(SendValuesThoughRpcAsync); }
public static void AddCommandHandler <TCommand, TCommandResponse>(this IBusClient busClient, IServiceProvider serviceProvider) where TCommand : ICommand where TCommandResponse : ICommandResponse { busClient.RespondAsync <TCommand, CommandResponse <TCommandResponse>, MessageContext>(async(command, messageContext) => { var handler = serviceProvider.GetRequiredService <ICommandHandler <TCommand, TCommandResponse> >(); var response = await handler.HandleAsync(command, messageContext); return(response); }); }
public static Task RespondAsync <TRequest, TResponse>( this IBusClient client, Func <TRequest, Task <TResponse> > handler, Action <IRespondContext> context = null, CancellationToken ct = default(CancellationToken)) { return(client.RespondAsync <TRequest, TResponse>(async request => { var response = await handler(request); return new Ack <TResponse>(response); }, context, ct)); }
/// <summary> /// Attaches a handler to a specific query. /// </summary> /// <typeparam name="TQuery">The query type</typeparam> public static void SubscribeToQuery <TQuery>(this IBusClient bus, IQueryHandler <TQuery> queryHandler) where TQuery : class, IQuery { bus.RespondAsync <TQuery, string>( async(query, context) => { return(await Task.Run(() => queryHandler.Handle(query))); }, config => { config.WithExchange(exchange => exchange.WithName(QueryExchangeName)); config.WithRoutingKey(typeof(TQuery).Name); config.WithQueue(queue => queue.WithName(QueryExchangeName + "." + typeof(TQuery).Name + ".Queue")); }); }
public RawRabbitCommandBus(IBusClient busClient, IServiceProvider serviceProvider) { _busClient = busClient; _serviceProvider = serviceProvider; _busClient.RespondAsync <ICommand, IHandleResult>(async(command, context) => { var commandHandlerType = _commandHandlers[command.GetType()]; var commandHandlerInstance = _serviceProvider.GetService(commandHandlerType); await(Task) commandHandlerInstance.GetType() .GetMethod("HandleAsync", new Type[] { command.GetType() }) .Invoke(commandHandlerInstance, new object[] { command }); return(new HandleResult()); }); }
public static Task <IPipeContext> RespondAsync <TRequest, TResponse, TMessageContext>( this IBusClient client, Func <TRequest, TMessageContext, Task <TResponse> > handler, Action <IRespondContext> context = null, CancellationToken ct = default(CancellationToken)) { return(client .RespondAsync <TRequest, TResponse, TMessageContext>((request, messageContext) => handler .Invoke(request, messageContext) .ContinueWith <TypedAcknowlegement <TResponse> >(t => { if (t.IsFaulted) { throw t.Exception; } return new Ack <TResponse>(t.Result); }, ct), context, ct)); }
public RawRabbitEventBus(IBusClient busClient, IServiceProvider serviceProvider) { _busClient = busClient; _serviceProvider = serviceProvider; _busClient.RespondAsync <IEvent, IHandleResult>(async(@event, context) => { var eventHandlerTypes = _eventHandlers[@event.GetType()]; Parallel.ForEach(eventHandlerTypes, async(eventHandlerType) => { var eventHandlerInstance = _serviceProvider.GetService(eventHandlerType); await(Task) eventHandlerInstance.GetType() .GetMethod("HandleAsync", new Type[] { @event.GetType() }) .Invoke(eventHandlerInstance, new object[] { @event }); }); return(await Task.FromResult(new HandleResult())); }); }
public static async Task WithRequestResponseAsync <TRequest, TResponse>(this IBusClient bus, IRequestHandler <TRequest, TResponse> requestHandler) where TRequest : IRequest where TResponse : IResponse => await bus.RespondAsync <TRequest, TResponse>(request => requestHandler.HandleAsync(request));
public static Task WithRequestHandlerAsync <TRequest>(this IBusClient busClient, IRequestHandler <TRequest> requestHandler) where TRequest : IRequest => busClient.RespondAsync <TRequest, IRespond>(msg => requestHandler.HandleAsync(msg), ctx => ctx.UseRespondConfiguration(cfg => cfg.FromDeclaredQueue(q => q.WithName(GetQueueName <TRequest>()))));
/// Start listening for messages protected override Task ExecuteAsync(System.Threading.CancellationToken stoppingToken) { _queue.RespondAsync <AuthenticationRequestMessage, ResultMessage>(VerifyToken); return(Task.CompletedTask); }