public void Start() { var cashinSettings = RabbitMqSubscriptionSettings .ForSubscriber(_connectionString, _exchangeName, "limitoperationscollector-cashin") .MakeDurable() .UseRoutingKey(((int)MessageType.CashIn).ToString()); _cashinSubscriber = new RabbitMqSubscriber <CashInEvent>(_logFactory, cashinSettings, new ResilientErrorHandlingStrategy(_logFactory, cashinSettings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_logFactory, cashinSettings))) .SetMessageDeserializer(new ProtobufMessageDeserializer <CashInEvent>()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .Start(); var cashoutSettings = RabbitMqSubscriptionSettings .ForSubscriber(_connectionString, _exchangeName, "limitoperationscollector-cashout") .MakeDurable() .UseRoutingKey(((int)MessageType.CashOut).ToString()); _cashoutSubscriber = new RabbitMqSubscriber <CashOutEvent>(_logFactory, cashoutSettings, new ResilientErrorHandlingStrategy(_logFactory, cashoutSettings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_logFactory, cashoutSettings))) .SetMessageDeserializer(new ProtobufMessageDeserializer <CashOutEvent>()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .Start(); }
public void Start() { var settings = new RabbitMqSubscriptionSettings { ConnectionString = _rabbitConfig.ConnectionString, QueueName = QueueName, ExchangeName = _rabbitConfig.ExchangeLimit, DeadLetterExchangeName = $"{_rabbitConfig.ExchangeLimit}.dlx", RoutingKey = "", IsDurable = false }; try { _subscriber = new RabbitMqSubscriber <LimitQueueItem>(settings, new DeadQueueErrorHandlingStrategy(_log, settings)) .SetMessageDeserializer(new JsonMessageDeserializer <LimitQueueItem>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessage) .CreateDefaultBinding() .SetLogger(_log) .Start(); } catch (Exception ex) { _log.WriteErrorAsync(nameof(LimitTradeQueue), nameof(Start), null, ex).Wait(); throw; } }
public virtual void Run() { WriteInfoToLogAndSlack("Starting listening exchange " + ExchangeName); try { var nSubscribers = Settings.NumOfSubscribers ?? 1; _connector = new RabbitMqSubscriber <TMessage> [nSubscribers]; var settings = GetRabbitMqSubscriptionSettings(); for (int i = 0; i < nSubscribers; i++) { _connector[i] = new RabbitMqSubscriber <TMessage>(settings, new ResilientErrorHandlingStrategy(_logger, settings, TimeSpan.FromSeconds(1))) .SetMessageDeserializer(new JsonMessageDeserializer <TMessage>()) .SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy()) .Subscribe(HandleMessage) .SetLogger(_logger) .Start(); } ; WriteInfoToLogAndSlack("Broker listening queue " + settings.QueueName); } catch (Exception ex) { _logger.WriteErrorAsync(ApplicationInfo.ApplicationFullName, "Application.RunAsync", null, ex).GetAwaiter() .GetResult(); } }
public void Start() { var settings = new RabbitMqSubscriptionSettings { ConnectionString = _settings.ConnectionString, ExchangeName = _settings.ExchangeName, QueueName = _settings.QueueName, IsDurable = true }; var errorHandlingStrategy = new ResilientErrorHandlingStrategy(_logFactory, settings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_logFactory, settings)); _subscriber = new RabbitMqSubscriber <HistoryOperation>(_logFactory, settings, errorHandlingStrategy) .SetMessageDeserializer(new JsonMessageDeserializer <HistoryOperation>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .Start(); _log.Info($"<< {nameof(HistoryOperationSubscruber)} is started."); }
public void Start() { _blobSaver.Start(); string endpointName = !string.IsNullOrWhiteSpace(_routingKey) ? $"{_appEndpointName}.{_routingKey}" : _appEndpointName; var settings = RabbitMqSubscriptionSettings .ForSubscriber(_connectionString, _exchangeName, endpointName) .MakeDurable(); if (!string.IsNullOrWhiteSpace(_routingKey)) { settings.UseRoutingKey(_routingKey); } _subscriber = new RabbitMqSubscriber <byte[]>( settings, new ResilientErrorHandlingStrategy( _log, settings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_log, settings))) .SetMessageDeserializer(this) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .SetLogger(_log) .SetPrefetchCount(_prefetchCount) .Start(); }
public static IObservable <T> ReadAsJson <T>(RabbitMqSubscriptionSettings settings, ILogFactory log) { return(Observable.Create <T>(async(obs, ct) => { var subscriber = new RabbitMqSubscriber <T>( log, settings, new ResilientErrorHandlingStrategy( settings: settings, logFactory: log, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(log, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <T>()) .Subscribe(x => { obs.OnNext(x); return Task.CompletedTask; }) .CreateDefaultBinding(); using (subscriber.Start()) { var cts = new TaskCompletionSource <Unit>(); ct.Register(() => cts.SetResult(Unit.Default)); await cts.Task; } obs.OnCompleted(); })); }
public void ShouldUseDeadLetterQueueOnException() { _subscriber = new RabbitMqSubscriber <string>( EmptyLogFactory.Instance, _settings, new DeadQueueErrorHandlingStrategy(EmptyLogFactory.Instance, _settings)) .CreateDefaultBinding() .SetMessageDeserializer(new DefaultStringDeserializer()); const string expected = "GetDefaultHost message"; SetupNormalQueue(); PublishToQueue(expected); var completeLock = new ManualResetEventSlim(false); var handler = new Func <string, Task>(s => { completeLock.Set(); throw new Exception(); }); _subscriber.Subscribe(handler); _subscriber.Start(); completeLock.Wait(); var result = ReadFromQueue(PoisonQueueName); Assert.That(result, Is.EqualTo(expected)); }
public void Subscribe <TMessage>(RabbitMqSettings settings, bool isDurable, Func <TMessage, Task> handler, IMessageDeserializer <TMessage> deserializer) { var subscriptionSettings = new RabbitMqSubscriptionSettings { ConnectionString = settings.ConnectionString, QueueName = QueueHelper.BuildQueueName(settings.ExchangeName, _env), ExchangeName = settings.ExchangeName, IsDurable = isDurable, }; var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings, new DefaultErrorHandlingStrategy(_logger, subscriptionSettings)) .SetMessageDeserializer(deserializer) .Subscribe(handler) .SetLogger(_logger) .SetConsole(_consoleWriter); if (!_subscribers.TryAdd(subscriptionSettings, rabbitMqSubscriber)) { throw new InvalidOperationException( $"A subscriber for queue {subscriptionSettings.QueueName} was already initialized"); } rabbitMqSubscriber.Start(); }
public EventStoreSubscription( DatabaseContext databaseContext, IConnection rabbitMqConnection) { _mongoDbReader = new MongoDbReader <T>(databaseContext); _rabbitMqSubscriber = new RabbitMqSubscriber(rabbitMqConnection); }
public void Start() { try { UpdateCache().Wait(); _subscriber = new RabbitMqSubscriber <IQuote>(new RabbitMqSubscriberSettings { ConnectionString = _settings.QuoteFeedRabbitSettings.ConnectionString, QueueName = $"{_settings.QuoteFeedRabbitSettings.ExchangeName}.marketprofileservice", ExchangeName = _settings.QuoteFeedRabbitSettings.ExchangeName }) .SetMessageDeserializer(new JsonMessageDeserializer <Quote>()) .SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy()) .Subscribe(ProcessQuote) .SetLogger(_log) .Start(); _timer = new Timer(PersistCache, null, _settings.CacheSettings.PersistPeriod, Timeout.InfiniteTimeSpan); } catch (Exception ex) { _log.WriteErrorAsync(Constants.ComponentName, null, null, ex).Wait(); throw; } }
public void Start() { var settings = RabbitMqSubscriptionSettings.CreateForSubscriber( _rabbitConfig.ConnectionString, _rabbitConfig.ExchangeTrade, _rabbitConfig.QueueTrade); settings.MakeDurable(); try { _subscriber = new RabbitMqSubscriber <TradeQueueItem>( settings, new ResilientErrorHandlingStrategy(_log, settings, retryTimeout: TimeSpan.FromSeconds(20), retryNum: 3, next: new DeadQueueErrorHandlingStrategy(_log, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <TradeQueueItem>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessage) .CreateDefaultBinding() .SetLogger(_log) .Start(); } catch (Exception ex) { _log.WriteErrorAsync(nameof(TradeSubscriber), nameof(Start), null, ex).Wait(); throw; } }
public void ConfigureServices(ContainerBuilder builder, ILog log) { var mq = settings.BrokerQuoteFeed.RabbitMq; var connectionsString = $"amqp://{mq.Username}:{mq.Password}@{mq.Host}:{mq.Port}"; var subscriberSettings = new RabbitMqSubscriberSettings() { ConnectionString = connectionsString, QueueName = mq.ExchangeOrderbook + ".quotefeedbroker", ExchangeName = mq.ExchangeOrderbook, IsDurable = true }; var publisherSettings = new RabbitMqPublisherSettings { ConnectionString = connectionsString, ExchangeName = mq.QuoteFeed }; var subscriber = new RabbitMqSubscriber <OrderBook>(subscriberSettings); var publisher = new RabbitMqPublisher <Quote>(publisherSettings); var broker = new Broker(subscriber, publisher, log); builder.RegisterInstance(subscriber) .As <IStartable>() .As <IStopable>(); builder.RegisterInstance(publisher) .As <IStartable>() .As <IStopable>(); }
public void Subscribe <TMessage>(IReloadingManager <RabbitConnectionSettings> settings, bool isDurable, Func <TMessage, Task> handler) { // on-the fly connection strings switch is not supported currently for rabbitMq var currSettings = settings.CurrentValue; var subscriptionSettings = new RabbitMqSubscriptionSettings { ConnectionString = currSettings.ConnectionString, QueueName = $"{currSettings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}", ExchangeName = currSettings.ExchangeName, IsDurable = isDurable, }; var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>( _loggerFactory.CreateLogger <RabbitMqSubscriber <TMessage> >(), subscriptionSettings) .SetMessageDeserializer(new JsonMessageDeserializer <TMessage>(JsonSerializerSettings)) .Subscribe(handler) .UseMiddleware(new ExceptionSwallowMiddleware <TMessage>( _loggerFactory.CreateLogger <ExceptionSwallowMiddleware <TMessage> >())) .SetReadHeadersAction(_correlationManager.FetchCorrelationIfExists); if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber)) { throw new InvalidOperationException( $"A subscriber for queue {subscriptionSettings.QueueName} was already initialized"); } rabbitMqSubscriber.Start(); }
public void Start() { var settings = new RabbitMqSubscriptionSettings { ConnectionString = _settings.ConnectionString, QueueName = _settings.QueueName, ExchangeName = _settings.ExchangeName, IsDurable = false }; _subscriber = new RabbitMqSubscriber <TickPrice>( _logFactory, settings, new ResilientErrorHandlingStrategy( settings: settings, logFactory: _logFactory, retryTimeout: TimeSpan.FromSeconds(10))) .SetMessageDeserializer(new JsonMessageDeserializer <TickPrice>()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding(); _subscriber.Start(); _log.Info($"<< {nameof(TickPricesSubscriber)} is started."); }
public void Start() { var settings = RabbitMqSubscriptionSettings .ForSubscriber(_connectionString, "lykke", _exchangeName, "lykke", "marketdata"); settings.DeadLetterExchangeName = null; try { _subscriber = new RabbitMqSubscriber <LimitOrdersMessage>(_logFactory, settings, new ResilientErrorHandlingStrategy(_logFactory, settings, retryTimeout: TimeSpan.FromSeconds(10), retryNum: 10, next: new DeadQueueErrorHandlingStrategy(_logFactory, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <LimitOrdersMessage>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessLimitOrdersAsync) .CreateDefaultBinding() .Start(); } catch (Exception ex) { _log.Error(nameof(Start), ex); throw; } }
public void Start() { var nameOfEndpoint = nameof(PayInvoicePortal); #if DEBUG nameOfEndpoint += "_DEBUG"; #endif var rabbitMqSubscriptionSettings = RabbitMqSubscriptionSettings .ForSubscriber(_rabbitSettings.ConnectionString, _rabbitSettings.InvoiceUpdateExchangeName, nameOfEndpoint) .MakeDurable(); rabbitMqSubscriptionSettings.DeadLetterExchangeName = null; _subscriber = new RabbitMqSubscriber <InvoiceUpdateMessage>( _logFactory, rabbitMqSubscriptionSettings, new ResilientErrorHandlingStrategy( _logFactory, rabbitMqSubscriptionSettings, TimeSpan.FromSeconds(10))) .SetMessageDeserializer(new JsonMessageDeserializer <InvoiceUpdateMessage>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .Start(); _log.Info($"{nameof(InvoiceUpdateSubscriber)} is started."); }
public void ShouldUseDeadLetterQueueOnException() { _subscriber = new RabbitMqSubscriber <string>( new NullLogger <RabbitMqSubscriber <string> >(), _settings) .UseMiddleware(new ExceptionSwallowMiddleware <string>(new NullLogger <ExceptionSwallowMiddleware <string> >())) .CreateDefaultBinding() .SetMessageDeserializer(new DefaultStringDeserializer()); const string expected = "GetDefaultHost message"; SetupNormalQueue(); PublishToQueue(expected); var completeLock = new ManualResetEventSlim(false); var handler = new Func <string, Task>(s => { completeLock.Set(); throw new Exception(); }); _subscriber.Subscribe(handler); _subscriber.Start(); completeLock.Wait(); var result = ReadFromQueue(PoisonQueueName); Assert.That(result, Is.EqualTo(expected)); }
private static IStopable TrySubscribe(AppArguments appArguments, Regex filter, StreamWriter outputWriter) { Console.WriteLine("Subscribing..."); try { var settings = new RabbitMqSubscriptionSettings { ConnectionString = appArguments.ConnectionString, ExchangeName = appArguments.ExchangeName, QueueName = $"{appArguments.ExchangeName}.RabbitMqReader-{Guid.NewGuid()}", IsDurable = false, ReconnectionsCountToAlarm = -1, ReconnectionDelay = TimeSpan.FromSeconds(5) }; var subscriber = new RabbitMqSubscriber <object>( settings, new DefaultErrorHandlingStrategy(new LogToConsole(), settings)) .CreateDefaultBinding() .SetLogger(new LogToConsole()) .SetMessageDeserializer(GetDeserializer(appArguments.MessageFormat)) .SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy()) .Subscribe( message => { var userMessage = JsonConvert.SerializeObject(message, Formatting.Indented); if (filter != null) { if (!filter.IsMatch(userMessage)) { return(Task.CompletedTask); } } Console.WriteLine(userMessage); outputWriter?.WriteLine(userMessage); if (appArguments.MessageSeparator != null) { Console.WriteLine(appArguments.MessageSeparator); outputWriter?.WriteLine(appArguments.MessageSeparator); } return(Task.CompletedTask); }) .Start(); Console.WriteLine("Subscriber is started"); return(subscriber); } catch (Exception e) { Console.WriteLine($"Failed to subscribe: {e.Message}"); return(null); } }
public void Start() { var settings = new RabbitMqSubscriptionSettings { ConnectionString = _rabbitConfig.ConnectionString, QueueName = QueueName, ExchangeName = _rabbitConfig.ExchangeSwap, DeadLetterExchangeName = $"{_rabbitConfig.ExchangeTransfer}.cache.dlx", RoutingKey = "", IsDurable = false }; try { _subscriber = new RabbitMqSubscriber <TradeQueueItem>(settings, new ResilientErrorHandlingStrategy(_log, settings, TimeSpan.FromSeconds(5), int.MaxValue)) .SetMessageDeserializer(new JsonMessageDeserializer <TradeQueueItem>()) .SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy()) .Subscribe(ProcessMessage) .CreateDefaultBinding() .SetLogger(_log) .Start(); } catch (Exception ex) { _log.WriteErrorAsync(nameof(TradeQueue), nameof(Start), null, ex).Wait(); throw; } }
public void Start() { // NOTE: Read https://github.com/LykkeCity/Lykke.RabbitMqDotNetBroker/blob/master/README.md to learn // about RabbitMq subscriber configuration var settings = RabbitMqSubscriptionSettings .CreateForSubscriber(_connectionString, _exchangeName, "chinalysiscash"); settings.IsDurable = true; // TODO: Make additional configuration, using fluent API here: // ex: .MakeDurable() _subscriber = new RabbitMqSubscriber <ChainalisysCashMessage>(settings, new ResilientErrorHandlingStrategy(_log, settings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_log, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <ChainalisysCashMessage>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .SetLogger(_log) .SetConsole(new LogToConsole()) .Start(); }
public void Start() { var settings = RabbitMqSubscriptionSettings .ForSubscriber(_rabbitConnectionString, "orderbook", "quotesproducer") .MakeDurable(); try { _subscriber = new RabbitMqSubscriber <OrderBookMessage>(_logFactory, settings, new ResilientErrorHandlingStrategy(_logFactory, settings, retryTimeout: TimeSpan.FromSeconds(10), retryNum: 10, next: new DeadQueueErrorHandlingStrategy(_logFactory, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <OrderBookMessage>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessOrderBookAsync) .SetPrefetchCount(1000) .CreateDefaultBinding() .Start(); } catch (Exception ex) { _log.Error(nameof(Start), ex); throw; } }
public void Subscribe <TMessage>( string connectionString, MarketType market, string source, string context, IMessageDeserializer <TMessage> deserializer, Func <TMessage, Task> handler) { var ns = NamespaceMap[market]; var applicationName = "wamphost"; var endpoint = context == null ? string.Empty : $".{context}"; endpoint = $"{applicationName}{endpoint}.{_env}"; var settings = RabbitMqSubscriptionSettings.ForSubscriber(connectionString, ns, source, ns, endpoint); settings.DeadLetterExchangeName = null; var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(settings, new DefaultErrorHandlingStrategy(_log, settings)) .SetMessageDeserializer(deserializer) .CreateDefaultBinding() .Subscribe(handler) .SetLogger(_log) .Start(); _stopables.Add(rabbitMqSubscriber); }
public void Start() { // NOTE: Read https://github.com/LykkeCity/Lykke.RabbitMqDotNetBroker/blob/master/README.md to learn // about RabbitMq subscriber configuration var settings = RabbitMqSubscriptionSettings .CreateForSubscriber(_rabbitMqConnectionString, _exchangeName, "orderbooktoblobbridge") .MakeDurable(); var deserializer = _useMessagePack ? (IMessageDeserializer <OrderbookMessage>) new MessagePackMessageDeserializer <OrderbookMessage>() : new JsonMessageDeserializer <OrderbookMessage>(); _subscriber = new RabbitMqSubscriber <OrderbookMessage>(settings, new ResilientErrorHandlingStrategy(_log, settings, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_log, settings))) .SetMessageDeserializer(deserializer) .SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy()) .Subscribe(ProcessMessageAsync) .CreateDefaultBinding() .SetConsole(_console) .SetLogger(_log) .Start(); }
public void Start() { var settings = RabbitMqSubscriptionSettings .CreateForSubscriber(_settings.ConnectionString, _settings.Namespace, "candles-v2", _settings.Namespace, "candleshistory") .MakeDurable(); try { _subscriber = new RabbitMqSubscriber<CandlesUpdatedEvent>(settings, new ResilientErrorHandlingStrategy(_log, settings, retryTimeout: TimeSpan.FromSeconds(10), retryNum: 10, next: new DeadQueueErrorHandlingStrategy(_log, settings))) .SetMessageDeserializer(new MessagePackMessageDeserializer<CandlesUpdatedEvent>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessCandlesUpdatedEventAsync) .CreateDefaultBinding() .SetLogger(_log) .Start(); } catch (Exception ex) { _log.WriteErrorAsync(nameof(CandlesSubscriber), nameof(Start), null, ex).Wait(); throw; } }
public void Start() { var cashinSettings = new RabbitMqSubscriptionSettings { ConnectionString = _rabbitMqSettings.NewMeRabbitConnString, QueueName = $"{_rabbitMqSettings.EventsExchange}.cashin.txhandler", ExchangeName = _rabbitMqSettings.EventsExchange, RoutingKey = ((int)MessageType.CashIn).ToString(), IsDurable = QueueDurable }; cashinSettings.DeadLetterExchangeName = $"{cashinSettings.QueueName}.dlx"; var cashoutSettings = new RabbitMqSubscriptionSettings { ConnectionString = _rabbitMqSettings.NewMeRabbitConnString, QueueName = $"{_rabbitMqSettings.EventsExchange}.cashout.txhandler", ExchangeName = _rabbitMqSettings.EventsExchange, RoutingKey = ((int)MessageType.CashOut).ToString(), IsDurable = QueueDurable }; cashoutSettings.DeadLetterExchangeName = $"{cashoutSettings.QueueName}.dlx"; try { _cashinSubscriber = new RabbitMqSubscriber <CashInEvent>(_logFactory, cashinSettings, new ResilientErrorHandlingStrategy(_logFactory, cashinSettings, retryTimeout: TimeSpan.FromSeconds(20), retryNum: 3, next: new DeadQueueErrorHandlingStrategy(_logFactory, cashinSettings))) .SetMessageDeserializer(new ProtobufMessageDeserializer <CashInEvent>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .SetAlternativeExchange(_rabbitMqSettings.AlternateConnectionString) .SetDeduplicator(MongoStorageDeduplicator.Create(_deduplicatorSettings.ConnectionString, _deduplicatorSettings.CollectionName)) .Subscribe(ProcessCashinMessage) .CreateDefaultBinding() .Start(); _cashoutSubscriber = new RabbitMqSubscriber <CashOutEvent>(_logFactory, cashoutSettings, new ResilientErrorHandlingStrategy(_logFactory, cashoutSettings, retryTimeout: TimeSpan.FromSeconds(20), retryNum: 3, next: new DeadQueueErrorHandlingStrategy(_logFactory, cashoutSettings))) .SetMessageDeserializer(new ProtobufMessageDeserializer <CashOutEvent>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .SetAlternativeExchange(_rabbitMqSettings.AlternateConnectionString) .SetDeduplicator(MongoStorageDeduplicator.Create(_deduplicatorSettings.ConnectionString, _deduplicatorSettings.CollectionName)) .Subscribe(ProcessCashoutMessage) .CreateDefaultBinding() .Start(); } catch (Exception ex) { _log.Error(ex); throw; } }
public void Subscribe <TMessage>(IReloadingManager <RabbitConnectionSettings> settings, bool isDurable, Func <TMessage, Task> handler) { // on-the fly connection strings switch is not supported currently for rabbitMq var currSettings = settings.CurrentValue; var subscriptionSettings = new RabbitMqSubscriptionSettings { ConnectionString = currSettings.ConnectionString, QueueName = $"{currSettings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}{currSettings.AdditionalQueueSuffix}", ExchangeName = currSettings.ExchangeName, IsDurable = isDurable, }; var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings, new DefaultErrorHandlingStrategy(_logger, subscriptionSettings)) .SetMessageDeserializer(new JsonMessageDeserializer <TMessage>(JsonSerializerSettings)) .Subscribe(handler) .SetLogger(_logger); if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber)) { throw new InvalidOperationException( $"A subscriber for queue {subscriptionSettings.QueueName} was already initialized"); } rabbitMqSubscriber.Start(); }
public void Subscribe <TMessage>(RabbitConnectionSettings settings, bool isDurable, Func <TMessage, Task> handler, IMessageDeserializer <TMessage> deserializer) { var subscriptionSettings = new RabbitMqSubscriptionSettings { ConnectionString = settings.ConnectionString, QueueName = $"{settings.ExchangeName}.{PlatformServices.Default.Application.ApplicationName}.{settings.RoutingKey ?? "all"}", ExchangeName = settings.ExchangeName, RoutingKey = settings.RoutingKey, IsDurable = isDurable, }; var rabbitMqSubscriber = new RabbitMqSubscriber <TMessage>(subscriptionSettings, new DefaultErrorHandlingStrategy(_logger, subscriptionSettings)) .SetMessageDeserializer(deserializer) .Subscribe(handler) .SetLogger(_logger); if (!_subscribers.TryAdd(subscriptionSettings.QueueName, rabbitMqSubscriber)) { throw new InvalidOperationException( $"A subscriber for queue {subscriptionSettings.QueueName} was already initialized"); } rabbitMqSubscriber.Start(); }
public void Start() { var settings = new RabbitMqSubscriptionSettings { ConnectionString = _settings.ConnectionString, ExchangeName = _settings.Exchange, QueueName = $"{_settings.Exchange}.{_settings.QueueSuffix}", IsDurable = false, DeadLetterExchangeName = null }; _subscriber = new RabbitMqSubscriber <TickPriceExt>( _logFactory, settings, new ResilientErrorHandlingStrategy( settings: settings, logFactory: _logFactory, retryTimeout: TimeSpan.FromSeconds(10), next: new DeadQueueErrorHandlingStrategy(_logFactory, settings))) .SetMessageDeserializer(new JsonMessageDeserializer <TickPriceExt>()) .Subscribe(HandleTickPrice) .CreateDefaultBinding(); _subscriber.Start(); }
public void Start() { var settings = RabbitMqSubscriptionSettings.CreateForSubscriber( _rabbitConfig.ConnectionString, _rabbitConfig.ExchangeLimit, _rabbitConfig.QueueLimit); settings.MakeDurable(); try { _subscriber = new RabbitMqSubscriber <LimitQueueItem>(settings, new DeadQueueErrorHandlingStrategy(_log, settings)) .SetMessageDeserializer(new JsonMessageDeserializer <LimitQueueItem>()) .SetMessageReadStrategy(new MessageReadQueueStrategy()) .Subscribe(ProcessMessage) .CreateDefaultBinding() .SetLogger(_log) .Start(); } catch (Exception ex) { _log.WriteErrorAsync(nameof(LimitTradeSubscriber), nameof(Start), null, ex).Wait(); throw; } }
public async void Start() { var boxes = await _boxRepo.GetAll(); // On start up call AssetConfigurationLock is not needed. _assetConfiguration = boxes.ToArray(); // Start Primary Subscriber. Uses BestBidAsk Model _primarySubscriber = CreateSubscriber <BestBidAsk>(_settings.PricesSettingsBoxOptions.PrimaryFeed, PrimaryMessageReceived_BestBidAsk); LogInfo("Start", $"AssetQuoteSubscriber Primary Feed [{_settings.PricesSettingsBoxOptions.PrimaryFeed.RabbitMqConnectionString}]"); if (_settings.PricesSettingsBoxOptions.SecondaryFeed != null) { // Start Secondary Subscriber. Uses Asset quote model _secondarySubscriber = CreateSubscriber <AssetQuote>( _settings.PricesSettingsBoxOptions.SecondaryFeed, SecondaryMessageReceived_AssetQuote); if (_secondarySubscriber != null) { LogInfo("Start", $"AssetQuoteSubscriber Secondary Feed [{_settings.PricesSettingsBoxOptions.SecondaryFeed.RabbitMqConnectionString}]"); } } // Start Timer to check incoming dataconnection int CheckInterval = _settings.PricesSettingsBoxOptions.NoFeedSlackReportInSeconds; _checkConnectionTimer.Change(CheckInterval * 1000, -1); }