private string SubscribeToResponse <TRequest, TResponse>() where TResponse : class { var rpcKey = new RpcKey { Request = typeof(TRequest), Response = typeof(TResponse) }; responseQueues.AddOrUpdate(rpcKey, key => { var queue = advancedBus.QueueDeclare( conventions.RpcReturnQueueNamingConvention(), passive: false, durable: false, exclusive: true, autoDelete: true); advancedBus.Consume <TResponse>(queue, (message, messageRecievedInfo) => Task.Factory.StartNew(() => { ResponseAction responseAction; if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction)) { responseAction.OnSuccess(message); } })); return(queue.Name); }, (_, queueName) => queueName); return(responseQueues[rpcKey]); }
//listen to position messages public void SubscribePositionMessageQueues() { try { if (Logger.IsInfoEnabled) { Logger.Info("Binding Position Message Queue: " + _positionMessageQueue.Name, _type.FullName, "SubscribePositionMessageQueues"); } // Listening to Position Messages _rabbitBus.Consume <Position>( _positionMessageQueue, (msg, messageReceivedInfo) => Task.Factory.StartNew( () => { if (PositionMessageArrived != null) { PositionMessageArrived(msg); } })); } catch (Exception exception) { Logger.Error(exception, _type.FullName, "SubscribePositionMessageQueues"); } }
/// <summary> /// Binds the Admin Message Queue /// Starts listening to the incoming Admin Level messages /// </summary> public void SubscribeAdminMessageQueues() { try { if (Logger.IsInfoEnabled) { Logger.Info("Binding Admin Message Queue: " + _adminMessageQueue.Name, _type.FullName, "SubscribeAdminMessageQueues"); } // Listening to Login Messages _easyNetQBus.Consume <string>( _adminMessageQueue, (msg, messageReceivedInfo) => Task.Factory.StartNew( () => { if (msg.Body.Equals("OrderLogin")) { OrderExecutionLoginRequest(); } else if (msg.Body.Equals("OrderLogout")) { OrderExecutionLogoutRequest(); } })); } catch (Exception exception) { Logger.Error(exception, _type.FullName, "SubscribeAdminMessageQueues"); } }
public void TransMedPublishesEvent() { //SystemX lytter _advancedBus.Consume(_systemXQueue, (IMessage <PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event> msg, MessageReceivedInfo info) => { Console.WriteLine($"SystemX mottok melding med routingkey {info.RoutingKey}: {JsonConvert.SerializeObject(msg.Body)}"); _waitForMessage.Set(); }); //TransMed publiserer event var eventToPublish = new Message <PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event>(new PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event { NIN = "12345678901", TreatmentDescription = "Stivkrampevaksine", UserId = "les-123" }); //sett AMQP properties (correlationid settes av easynetq, trenger ikke reply-to siden vi ikke skal ha svar) eventToPublish.Properties.Expiration = TimeSpan.FromDays(2).TotalMilliseconds.ToString(CultureInfo.InvariantCulture); //ttl eventToPublish.Properties.AppId = "TransMed"; //tilsvarer sanns. "sender" //publish _advancedBus.Publish(_systemXExchange, $"event.{nameof(PatientHaveReceivedTreatmentAndCanBeInvoicedA97Event)}", true, eventToPublish); _waitForMessage.WaitOne(3000); }
public virtual void SubscribeAsync <T>(string subscriptionId, Func <T, Task> onMessage, Action <ISubscriptionConfiguration <T> > configure) { Preconditions.CheckNotNull(subscriptionId, "subscriptionId"); Preconditions.CheckNotNull(onMessage, "onMessage"); var configuration = new SubscriptionConfiguration <T>(); configure(configuration); var queueName = GetQueueName <T>(subscriptionId); var exchangeName = GetExchangeName <T>(); var queue = advancedBus.QueueDeclare(queueName); var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic); if (configuration.Topics.Count == 0) { advancedBus.Bind(exchange, queue, "#"); } else { foreach (var topic in configuration.Topics) { advancedBus.Bind(exchange, queue, topic); } } advancedBus.Consume <T>(queue, (message, messageRecievedInfo) => onMessage(message.Body)); }
public void Start() { _bus = BusFactory.CreateAdvancedBus(ConfigurationReader.WorkflowSender); var senderQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Sender"); var senderExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Sender", ExchangeType.Fanout); _bus.Bind(senderExchange, senderQueue, string.Empty); var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Receiver"); var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Receiver", ExchangeType.Fanout); _bus.Bind(receiverExchange, receiverQueue, string.Empty); _bus.Consume(senderQueue, x => x .Add<SendRequestToDataProviderCommand>( (message, info) => new SenderCauseFailureConsumers<SendRequestToDataProviderCommand>(message)) .Add<GetResponseFromDataProviderCommmand>( (message, info) => new SenderCauseFailureConsumers<GetResponseFromDataProviderCommmand>(message)) .Add<CreateTransactionCommand>( (message, info) => new SenderCauseFailureConsumers<CreateTransactionCommand>(message)) .Add<ReceiveEntryPointRequest>( (message, info) => new SenderCauseFailureConsumers<ReceiveEntryPointRequest>(message)) .Add<ReturnEntryPointResponse>( (message, info) => new SenderCauseFailureConsumers<ReturnEntryPointResponse>(message)) .Add<RaisingSecurityFlagCommand>( (message, info) => new SenderCauseFailureConsumers<RaisingSecurityFlagCommand>(message)) .Add<ConfiguringDataProviderCommand>( (message, info) => new SenderCauseFailureConsumers<ConfiguringDataProviderCommand>(message)) .Add<TransformingDataProviderResponseCommand>( (message, info) => new SenderCauseFailureConsumers<TransformingDataProviderResponseCommand>(message)) .Add<ErrorInDataProviderCommand>( (message, info) => new SenderCauseFailureConsumers<ErrorInDataProviderCommand>(message)) .Add<StartingCallCommand>( (message, info) => new SenderCauseFailureConsumers<StartingCallCommand>(message)) .Add<EndingCallCommand>((message, info) => new SenderCauseFailureConsumers<EndingCallCommand>(message))); _bus.Consume(receiverQueue, x => x .Add<RequestToDataProvider>( (message, info) => new ReceiverCauseFailureConsumers<RequestToDataProvider>(message)) .Add<EntryPointReceivedRequest>( (message, info) => new ReceiverCauseFailureConsumers<EntryPointReceivedRequest>(message)) .Add<ResponseFromDataProvider>( (message, info) => new ReceiverCauseFailureConsumers<ResponseFromDataProvider>(message)) .Add<EntryPointReturnedResponse>( (message, info) => new ReceiverCauseFailureConsumers<EntryPointReturnedResponse>(message)) //.Add<BillTransactionMessage>( // (message, info) => new ReceiverConsumers<BillTransactionMessage>(message)) .Add<SecurityFlagRaised>( (message, info) => new ReceiverCauseFailureConsumers<SecurityFlagRaised>(message)) .Add<DataProviderCallEnded>( (message, info) => new ReceiverCauseFailureConsumers<DataProviderCallEnded>(message)) .Add<DataProviderCallStarted>( (message, info) => new ReceiverCauseFailureConsumers<DataProviderCallStarted>(message)) .Add<DataProviderError>( (message, info) => new ReceiverCauseFailureConsumers<DataProviderError>(message)) .Add<DataProviderResponseTransformed>( (message, info) => new ReceiverCauseFailureConsumers<DataProviderResponseTransformed>(message)) .Add<DataProviderConfigured>( (message, info) => new ReceiverCauseFailureConsumers<DataProviderConfigured>(message))); _log.DebugFormat("Data Provider Command Processor Service Started"); }
public IDisposable Receive <T>( string queue, Func <T, Task> onMessage, Action <IConsumerConfiguration> configure = null) where T : class { var declaredQueue = DeclareQueue(queue); return(advancedBus.Consume <T>(declaredQueue, (message, info) => onMessage(message.Body), configure)); }
public void SubscribeJobMessage() { var queue = _bus.QueueDeclare("JobMessage"); _bus.Consume <string>(queue, async(msg, info) => { using var serviceScope = _pr.GetRequiredService <IServiceScopeFactory>().CreateScope(); var bookingService = serviceScope.ServiceProvider.GetService <IBookingService>(); await bookingService.CheckReservation(DeserializeJobMessage(msg.Body)); }); }
/// <inheritdoc/> public IDisposable Subscribe <T>(Action <T> action, string queueName) where T : OutgoingMessage { var queue = bus.QueueDeclare(queueName); return(bus.Consume(queue, (body, properties, info) => { var jsonMessage = Encoding.UTF8.GetString(body); var resultMessage = JsonConvert.DeserializeObject <T>(jsonMessage); action.Invoke(resultMessage); })); }
public void ConsumeFromAQueue() { var queue = new Queue("my_queue", false); advancedBus.Consume(queue, (body, properties, info) => Task.Factory.StartNew(() => { var message = Encoding.UTF8.GetString(body); Console.Out.WriteLine("Got message: '{0}'", message); })); Thread.Sleep(500); }
public void Start(QueueReaderSettings config, ActiveQueueContext context) { var connectionString = config.ConnectionString.FetchConnectionSslOptions(out var configure); _client = RabbitHutch .CreateBus(x => { var connectionConfig = x.Resolve <IConnectionStringParser>().Parse(connectionString); return(configure(connectionConfig)); }, x => { }) .Advanced; var queue = _client.QueueDeclare(config.QueueName); _client.Consume(queue, (body, properties, info) => Task.Factory.StartNew(() => { try { var msg = Event.Parser.ParseFrom(body); context.OnReceivedMessage(msg); } catch (Exception ex) { context.OnError($"MessagePump.OnMessage RabbitMQ Parse Error: {ex.Message}"); } })); }
public void SubscriberToAlarmData(string[] keys) { foreach (var key in keys) { _bus.Bind(_exchange, _alarmDataQueue, key); } _bus.Consume(_alarmDataQueue, (body, properties, info) => Task.Run(() => { var message = Encoding.UTF8.GetString(body); var key = info.RoutingKey; if (keys.Contains(key)) { HandleAlarmData(message); } })); }
public void Start() { _log.DebugFormat("Started billing service"); var container = new WindsorContainer().Install( new NHibernateInstaller(), new WindsorInstaller(), new CacheProviderInstaller(), new RepositoryInstaller(), new AutoMapperInstaller(), new ConsumerInstaller(), new BusInstaller(), new PublishReportQueueInstaller(), new PivotInstaller(), new ScheduleInstaller()); advancedBus = container.Resolve<IAdvancedBus>(); var q = advancedBus.QueueDeclare("DataPlatform.Transactions.Billing"); advancedBus.Consume(q, x => x .Add<InvoiceTransactionCreated>((message, info) => new TransactionConsumer<InvoiceTransactionCreated> (message, container)) .Add<UserMessage>((message, info) => new TransactionConsumer<UserMessage> (message, container)) .Add<CustomerMessage>((message, info) => new TransactionConsumer<CustomerMessage>(message, container)) .Add<ClientMessage>((message, info) => new TransactionConsumer<ClientMessage>(message, container)) .Add<PackageMessage>((message, info) => new TransactionConsumer<PackageMessage>(message, container)) .Add<ContractMessage>((message, info) => new TransactionConsumer<ContractMessage>(message, container)) .Add<TransactionRequestMessage>((message, info) => new TransactionConsumer<TransactionRequestMessage>(message, container)) .Add<TransactionRequestCleanupMessage>((message, info) => new TransactionConsumer<TransactionRequestCleanupMessage>(message, container))); _log.DebugFormat("Billing service started"); }
/// <summary> /// 订阅消息。自定义主题、交换机名称。EasyNetQ高级API /// </summary> /// <typeparam name="T"></typeparam> /// <param name="work">消息处理方式</param> /// <param name="subscriptionId">订阅者ID</param> /// <param name="fail">失败处理方式</param> /// <param name="exchangeName">交换机名称</param> /// <param name="topics">主题</param> public void Subscribe <T>(Action <T> work, Action fail = null, string subscriptionId = "topic_subid", string exchangeName = "default_exchange", params string[] topics) where T : class, IBaseMqMessage { this.Logger(this.GetType(), "订阅消息。自定义主题、交换机名称-Subscribe", () => { IAdvancedBus advanced = bus.Advanced; IExchange exchange = advanced.ExchangeDeclare(exchangeName, ExchangeType.Topic); IQueue queue = advanced.QueueDeclare(subscriptionId); foreach (var item in topics) { advanced.Bind(exchange, queue, item); } advanced.Consume(queue, registration => { registration.Add <T>((message, info) => { work(message.Body); }); }); }, e => { if (fail != null) { fail.Invoke(); } }); }
public void Start() { _log.DebugFormat("Started billing run service"); var container = new WindsorContainer().Install( new NHibernateInstaller(), new WindsorInstaller(), new CacheProviderInstaller(), new RepositoryInstaller(), new AutoMapperInstaller(), new ConsumerInstaller(), new BusInstaller(), new PublishReportQueueInstaller(), new PivotInstaller(), new ReportBuilderInstaller(), new NotificationInstaller()); try { advancedBus = container.Resolve<IAdvancedBus>(); var q = advancedBus.QueueDeclare("DataPlatform.Transactions.BillingRun"); advancedBus.Consume(q, x => x .Add<BillingMessage>((message, info) => new TransactionConsumer<BillingMessage>(message, container))); } catch (Exception e) { this.Error(() => e.Message); } _log.DebugFormat("Billing run service started"); }
/// <summary> /// 메세지 구독 /// </summary> /// <param name="onMessage">메세지 도착시 실행될 Func</param> /// <param name="messageConfig">메세지 구독 설정</param> public IDisposable Subscribe(Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, MessageConfiguration messageConfig) { var queue = new Queue(messageConfig.QueueName, false); return(advancedBus.Consume(queue, onMessage, config => config.WithPrefetchCount(messageConfig.PrefetchCount))); //return advancedBus.Consume(queue, onMessage); }
public RabbitMQClient Consume <T>(string queueName, Action <IMessage <T>, MessageReceivedInfo> onMessage) where T : class { var queue = _queues[queueName]; _bus.Consume(queue, onMessage); return(this); }
private string SubscribeToResponse <TResponse>(Action <TResponse> onResponse) where TResponse : class { var queue = advancedBus.QueueDeclare( conventions.RpcReturnQueueNamingConvention(), passive: false, durable: false, exclusive: true, autoDelete: true).SetAsSingleUse(); advancedBus.Consume <TResponse>(queue, (message, messageRecievedInfo) => { var tcs = new TaskCompletionSource <object>(); try { onResponse(message.Body); tcs.SetResult(null); } catch (Exception exception) { tcs.SetException(exception); } return(tcs.Task); }); return(queue.Name); }
private void RunListeningBus() { _bus.Consume(_bus.QueueDeclare("auth-queue"), register => { register.Add <AuthMessage>(async(message, info) => { try { if (message.Body.IsSuccess) { _sessionRepo.Update(message.Body.UserId, (session) => { session.State = SessionState.MainMenu; }); await _telegramBotClient.SendTextMessageAsync(message.Body.ChatId, "Authentication completed \U0001F973", replyMarkup: Keyboards.GetMainMenuKeyboard()); } } catch (Exception ex) { _logger.LogError($"UserId={message.Body.UserId.ToString()}, ErrorMessage={ex.Message}, StackTrace={ex.StackTrace}"); } }); }); }
protected void Application_Start() { RouteTable.Routes.MapHubs(); AreaRegistration.RegisterAllAreas(); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); string connectionString = string.Format( "host={0};virtualHost={1};username={2};password={3}", rabbitMQBrokerHost, virtualHost, username, password); _bus = RabbitHutch.CreateBus(connectionString).Advanced; var exchange = _bus.ExchangeDeclare("machine", EasyNetQ.Topology.ExchangeType.Fanout); var queue = _bus.QueueDeclare( "machine.info", durable: false, exclusive: false, autoDelete: true); _bus.Bind(exchange, queue, "info"); _hubContext = GlobalHost.ConnectionManager.GetHubContext <MachineHub>(); _bus.Consume <MachineInfo>(queue, (body, info) => Task.Factory.StartNew(() => { var machine = body.Body; _hubContext.Clients.All.update(machine); })); }
public BoxViewModel(string name, IAdvancedBus bus) { Box = new Box { Name = name, }; var exchange = bus.ExchangeDeclare("box", EasyNetQ.Topology.ExchangeType.Fanout); var queue = bus.QueueDeclare( "update." + Box.Name, durable: false, exclusive: true, autoDelete: true); bus.Bind(exchange, queue, name); bus.Consume <Box>(queue, (body, info) => Task.Factory.StartNew(() => { var box = body.Body; X = box.X; Y = box.Y; })); }
public virtual IDisposable SubscribeAsync <T>(string subscriptionId, Func <T, Task> onMessage, Action <ISubscriptionConfiguration> configure) where T : class { Preconditions.CheckNotNull(subscriptionId, "subscriptionId"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configure, "configure"); var configuration = new SubscriptionConfiguration(connectionConfiguration.PrefetchCount); configure(configuration); var queueName = conventions.QueueNamingConvention(typeof(T), subscriptionId); var exchangeName = conventions.ExchangeNamingConvention(typeof(T)); var queue = advancedBus.QueueDeclare(queueName, autoDelete: configuration.AutoDelete, expires: configuration.Expires); var exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic); foreach (var topic in configuration.Topics.AtLeastOneWithDefault("#")) { advancedBus.Bind(exchange, queue, topic); } return(advancedBus.Consume <T>( queue, (message, messageReceivedInfo) => onMessage(message.Body), x => { x.WithPriority(configuration.Priority) .WithCancelOnHaFailover(configuration.CancelOnHaFailover) .WithPrefetchCount(configuration.PrefetchCount); if (configuration.IsExclusive) { x.AsExclusive(); } })); }
public static void ConsumeTypeAgnostic <T>(this IAdvancedBus @this, IQueue queue, Action <T, MessageReceivedInfo> action) where T : class { @this.Consume <object>(queue, (body, properties) => { var msg = JsonConvert.DeserializeObject <T>(body.Body.ToString()); action(msg, properties); }); }
public async Task <IDisposable> AddSubscription <TEvent>(string sourceBoundedContextName, string publishedLanguageEntity) where TEvent : class { var queue = await _messageBus.QueueDeclareAsync(NamingConventions.QueueNamingConvention(_boundedContextName, sourceBoundedContextName, publishedLanguageEntity, _subscriberId)); await _messageBus.BindAsync( new Exchange( NamingConventions.ExchangeNamingConvention(sourceBoundedContextName, publishedLanguageEntity)), queue, ""); return(_messageBus.Consume(queue, async(bytes, properties, info) => { var msg = Encoding.UTF8.GetString(bytes); Console.WriteLine(msg); var validationResult = await _schemaValidator.IsValid <TEvent>(msg); if (validationResult.IsValid) { var envelope = System.Text.Json.JsonSerializer.Deserialize <Envelope <TEvent> >(msg); var props = new MessageProperties(); properties.CopyTo(props); await _eventDispatcher.HandleEvent(envelope, props); } else { throw new Exception($"Schema is invalid, errors: {string.Join(", ", validationResult.Errors)}"); } })); }
/// <summary> /// Consume a stream of messages asynchronously /// </summary> /// <typeparam name="T">The message type</typeparam> /// <param name="bus">The bus instance</param> /// <param name="queue">The queue to take messages from</param> /// <param name="onMessage">The message handler</param> /// <returns>A disposable to cancel the consumer</returns> public static IDisposable Consume <T>( this IAdvancedBus bus, IQueue queue, Func <IMessage <T>, MessageReceivedInfo, Task> onMessage ) { Preconditions.CheckNotNull(bus, "bus"); return(bus.Consume(queue, onMessage, c => { })); }
/// <summary> /// Consume raw bytes from the queue. /// </summary> /// <param name="bus">The bus instance</param> /// <param name="queue">The queue to subscribe to</param> /// <param name="onMessage"> /// The message handler. Takes the message body, message properties and some information about the /// receive context. /// </param> /// <returns>A disposable to cancel the consumer</returns> public static IDisposable Consume( this IAdvancedBus bus, IQueue queue, Action <byte[], MessageProperties, MessageReceivedInfo> onMessage ) { Preconditions.CheckNotNull(bus, "bus"); return(bus.Consume(queue, onMessage, c => { })); }
protected override IDisposable ConfigureSubscription(IAdvancedBus bus, IQueue queue) { return(bus.Consume( queue, ConsumerHandler <IProcessingCommand, ProcessingCommandHandler>(), conf => conf.WithPrefetchCount(1) )); }
protected virtual string SubscribeToResponse <TRequest, TResponse>() where TResponse : class { var responseType = typeof(TResponse); var rpcKey = new RpcKey { Request = typeof(TRequest), Response = responseType }; if (responseQueues.TryGetValue(rpcKey, out ResponseQueueWithCancellation queueWithCancellation)) { return(queueWithCancellation.QueueName); } lock (responseQueuesAddLock) { if (responseQueues.TryGetValue(rpcKey, out queueWithCancellation)) { return(queueWithCancellation.QueueName); } var queue = advancedBus.QueueDeclare( conventions.RpcReturnQueueNamingConvention(), passive: false, durable: false, exclusive: true, autoDelete: true); var exchange = DeclareAndBindRpcExchange( conventions.RpcResponseExchangeNamingConvention(responseType), queue, queue.Name); var cancellation = advancedBus.Consume <TResponse>(queue, (message, messageReceivedInfo) => Task.Factory.StartNew(() => { ResponseAction responseAction; if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction)) { responseAction.OnSuccess(message); } })); responseQueues.TryAdd(rpcKey, new ResponseQueueWithCancellation { QueueName = queue.Name, Cancellation = cancellation }); return(queue.Name); } }
public void Subscribe <TMessage>(Action <TMessage> handler) where TMessage : class { var queue = advancedBus.QueueDeclare(); var exchange = advancedBus.ExchangeDeclare(EXCHANGE_NAME, ExchangeType.Direct); var binding = advancedBus.Bind(exchange, queue, ROUTING_KEY); advancedBus.Consume(queue, x => x .Add <TMessage>((message, info) => handler(message.Body))); }
public void Subscribe <TMessage>(Action <TMessage> handler) where TMessage : class { var queue = advancedBus.QueueDeclare(QUEUE_NAME, durable: true, exclusive: false, autoDelete: false); advancedBus.Consume(queue, x => x .Add <TMessage>((message, info) => handler(message.Body))); }
/// <inheritdoc /> public void Subscribe(Func <BaseMessage, Task> handler) { CheckDisposed(); CheckAndReconnect(); _logger.LogDebug("Try to subscribe to queue with id: {queueId}", _configuration.Id); _consumer = _advancedBus.Consume(_queue, (body, messageProperties, info) => handler?.Invoke(body.ConvertToBaseMessage(messageProperties))); _logger.LogDebug("Done to subscribe to queue with id: {queueId}", _configuration.Id); }
/// <summary> /// Consume a stream of messages asynchronously /// </summary> /// <typeparam name="T">The message type</typeparam> /// <param name="bus">The bus instance</param> /// <param name="queue">The queue to take messages from</param> /// <param name="onMessage">The message handler</param> /// <param name="configure"> /// Fluent configuration e.g. x => x.WithPriority(10) /// </param> /// <returns>A disposable to cancel the consumer</returns> public static IDisposable Consume <T>( this IAdvancedBus bus, IQueue queue, Func <IMessage <T>, MessageReceivedInfo, Task> onMessage, Action <IConsumerConfiguration> configure ) { Preconditions.CheckNotNull(bus, "bus"); return(bus.Consume <T>(queue, (m, i, c) => onMessage(m, i), configure)); }
/// <summary> /// Consume raw bytes from the queue. /// </summary> /// <param name="bus">The bus instance</param> /// <param name="queue">The queue to subscribe to</param> /// <param name="onMessage"> /// The message handler. Takes the message body, message properties and some information about the /// receive context. Returns a Task. /// </param> /// <param name="configure"> /// Fluent configuration e.g. x => x.WithPriority(10) /// </param> /// <returns>A disposable to cancel the consumer</returns> public static IDisposable Consume( this IAdvancedBus bus, IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task <AckStrategy> > onMessage, Action <IConsumerConfiguration> configure ) { Preconditions.CheckNotNull(bus, "bus"); return(bus.Consume(queue, (m, p, i, c) => onMessage(m, p, i), configure)); }
public void Start() { this.Info(() => "Started reporting service"); var container = new WindsorContainer().Install( new WindsorInstaller(), new BusInstaller(), new NotificationInstaller(), new ConsumerInstaller()); advancedBus = container.Resolve<IAdvancedBus>(); var q = advancedBus.QueueDeclare("DataPlatform.Reports.Billing"); advancedBus.Consume(q, x => x .Add<ReportMessage>((message, info) => new TransactionConsumer<ReportMessage>(message, container))); }
public void Start() { _log.DebugFormat("Started billing cache service"); var container = new WindsorContainer().Install( new NHibernateInstaller(), new WindsorInstaller(), new CacheProviderInstaller(), new RepositoryInstaller(), new ConsumerInstaller(), new BusInstaller()); advancedBus = container.Resolve<IAdvancedBus>(); var cache = advancedBus.QueueDeclare("DataPlatform.Cache.Billing"); advancedBus.Consume(cache, x => x .Add<BillCacheMessage>((message, info) => new TransactionConsumer<BillCacheMessage>(message, container))); _log.DebugFormat("Billing cache service started"); }
public void Start() { Log.Debug("Starting Cache Worker"); var properties = new NameValueCollection(); properties["quartz.scheduler.instanceName"] = "RemoteServer"; properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz"; properties["quartz.threadPool.threadCount"] = "5"; properties["quartz.threadPool.threadPriority"] = "Normal"; properties["quartz.plugin.xml.type"] = "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz"; properties["quartz.plugin.xml.fileNames"] = "jobs.xml"; ISchedulerFactory schedulerFactory = new StdSchedulerFactory(properties); _scheduler = schedulerFactory.GetScheduler(); _scheduler.JobFactory = new JobFactory(_container); _scheduler.Start(); _bus = _container.Resolve<IAdvancedBus>(); var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Cache.Receiver"); var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Cache.Receiver", ExchangeType.Fanout); _bus.Bind(receiverExchange, receiverQueue, string.Empty); _bus.Consume(receiverQueue, q => q .Add<ClearCacheCommand>( (message, info) => new ReceiverConsumers<ClearCacheCommand>(message, _container)) .Add<RefreshCacheCommand>( (message, info) => new ReceiverConsumers<RefreshCacheCommand>(message, _container)) .Add<RestartCacheDataStoreCommand>( (message, info) => new ReceiverConsumers<RestartCacheDataStoreCommand>(message, _container))); Log.Debug("Cache Worker has started"); }
public void Start() { _log.DebugFormat("Data Provider Command Processor Service being fired up..."); var container = new WindsorContainer().Install( new WindsorInstaller(), new RepositoryInstaller(), new ConsumerInstaller(), new BusInstaller()); _bus = container.Resolve<IAdvancedBus>(); var senderQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Sender"); var senderExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Sender", ExchangeType.Fanout); _bus.Bind(senderExchange, senderQueue, string.Empty); var receiverQueue = _bus.QueueDeclare("DataPlatform.DataProvider.Receiver"); var receiverExchange = _bus.ExchangeDeclare("DataPlatform.DataProvider.Receiver", ExchangeType.Fanout); _bus.Bind(receiverExchange, receiverQueue, string.Empty); _bus.Consume(senderQueue, q => q .Add<SendRequestToDataProviderCommand>( (message, info) => new SenderConsumers<SendRequestToDataProviderCommand>(message, container)) .Add<GetResponseFromDataProviderCommmand>( (message, info) => new SenderConsumers<GetResponseFromDataProviderCommmand>(message, container)) .Add<CreateTransactionCommand>( (message, info) => new SenderConsumers<CreateTransactionCommand>(message, container)) .Add<ReceiveEntryPointRequest>( (message, info) => new SenderConsumers<ReceiveEntryPointRequest>(message, container)) .Add<ReturnEntryPointResponse>( (message, info) => new SenderConsumers<ReturnEntryPointResponse>(message, container)) .Add<RaisingSecurityFlagCommand>( (message, info) => new SenderConsumers<RaisingSecurityFlagCommand>(message, container)) .Add<ConfiguringDataProviderCommand>( (message, info) => new SenderConsumers<ConfiguringDataProviderCommand>(message, container)) .Add<TransformingDataProviderResponseCommand>( (message, info) => new SenderConsumers<TransformingDataProviderResponseCommand>(message, container)) .Add<ErrorInDataProviderCommand>( (message, info) => new SenderConsumers<ErrorInDataProviderCommand>(message, container)) .Add<StartingCallCommand>( (message, info) => new SenderConsumers<StartingCallCommand>(message, container)) .Add<EndingCallCommand>((message, info) => new SenderConsumers<EndingCallCommand>(message, container))); _bus.Consume(receiverQueue, q => q .Add<RequestToDataProvider>( (message, info) => new ReceiverConsumers<RequestToDataProvider>(message, container)) .Add<EntryPointReceivedRequest>( (message, info) => new ReceiverConsumers<EntryPointReceivedRequest>(message, container)) .Add<ResponseFromDataProvider>( (message, info) => new ReceiverConsumers<ResponseFromDataProvider>(message, container)) .Add<EntryPointReturnedResponse>( (message, info) => new ReceiverConsumers<EntryPointReturnedResponse>(message, container)) .Add<BillTransactionMessage>( (message, info) => new ReceiverConsumers<BillTransactionMessage>(message, container)) .Add<SecurityFlagRaised>( (message, info) => new ReceiverConsumers<SecurityFlagRaised>(message, container)) .Add<DataProviderCallEnded>( (message, info) => new ReceiverConsumers<DataProviderCallEnded>(message, container)) .Add<DataProviderCallStarted>( (message, info) => new ReceiverConsumers<DataProviderCallStarted>(message, container)) .Add<DataProviderError>( (message, info) => new ReceiverConsumers<DataProviderError>(message, container)) .Add<DataProviderResponseTransformed>( (message, info) => new ReceiverConsumers<DataProviderResponseTransformed>(message, container)) .Add<DataProviderConfigured>( (message, info) => new ReceiverConsumers<DataProviderConfigured>(message, container))); var apiReceiverQueue = _bus.QueueDeclare("DataPlatform.Api"); var apiReceiverExchange = _bus.ExchangeDeclare("DataPlatform.Api", ExchangeType.Fanout); _bus.Bind(apiReceiverExchange, apiReceiverQueue, string.Empty); _bus.Consume(apiReceiverQueue, q => q.Add<RequestMetadataMessage>((message, info) => new ReceiverConsumers<RequestMetadataMessage>(message, container))); _log.DebugFormat("Data Provider Command Processor Service Started"); }