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