public IcmTickPriceHarvester(IcmExchangeConfiguration config, IcmModelConverter modelConverter, IHandler <TickPrice> tickPriceHandler, ILog log)
{
_log = log;
_enabled = config.RabbitMq.Enabled;
if (!_enabled)
{
return;
}
var instruments = config.SupportedCurrencySymbols.Select(x => new Instrument(IcmExchange.Name, x.LykkeSymbol).Name).ToHashSet();
var rabbitSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = config.RabbitMq.ConnectionString,
ExchangeName = config.RabbitMq.Exchange,
QueueName = config.RabbitMq.Queue
};
var errorStrategy = new DefaultErrorHandlingStrategy(_log, rabbitSettings);
_rabbit = new RabbitMqSubscriber <OrderBook>(rabbitSettings, errorStrategy)
.SetMessageDeserializer(new GenericRabbitModelConverter <OrderBook>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.SetConsole(new LogToConsole())
.SetLogger(_log)
.Subscribe(async orderBook =>
{
if (instruments.Contains(orderBook.Asset))
{
var tickPrice = modelConverter.ToTickPrice(orderBook);
if (tickPrice != null)
{
await tickPriceHandler.Handle(tickPrice);
}
}
});
}
public void SetUp()
{
_settings = new RabbitMqSubscriptionSettings
{
QueueName = "QueueName"
};
_strategy = new DefaultErrorHandlingStrategy(EmptyLogFactory.Instance, _settings);
}
public void ShouldResendToNextHandlerOnError()
{
var nextHandler = Substitute.For <IErrorHandlingStrategy>();
_strategy = new DefaultErrorHandlingStrategy(EmptyLogFactory.Instance, _settings, nextHandler);
var handler = new Action(() => throw new Exception());
var acceptor = Substitute.For <IMessageAcceptor>();
_strategy.Execute(handler, acceptor, CancellationToken.None);
nextHandler.Received(1).Execute(handler, acceptor, CancellationToken.None);
}
private void StartRabbitMqOrdersSubscription()
{
var rabbitSettings = new RabbitMqSubscriptionSettings()
{
ConnectionString = Config.RabbitMq.Orders.ConnectionString,
ExchangeName = Config.RabbitMq.Orders.Exchange,
QueueName = Config.RabbitMq.Orders.Queue
};
var errorStrategy = new DefaultErrorHandlingStrategy(LykkeLog, rabbitSettings);
orderStatusesRabbit = new RabbitMqSubscriber <LimitOrderMessage>(rabbitSettings, errorStrategy)
.SetMessageDeserializer(new GenericRabbitModelConverter <LimitOrderMessage>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.SetConsole(new LogToConsole())
.SetLogger(LykkeLog)
.Subscribe(HandleOrderStatus)
.Start();
}
private void RegisterTradeSignalSubscriber(ContainerBuilder container)
{
var subscriberSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = _config.RabbitMq.Signals.ConnectionString,
ExchangeName = _config.RabbitMq.Signals.Exchange,
QueueName = _config.RabbitMq.Signals.Queue,
IsDurable = false
};
var errorStrategy = new DefaultErrorHandlingStrategy(_log, subscriberSettings);
var subscriber = new RabbitMqSubscriber <TradingSignal>(subscriberSettings, errorStrategy)
.SetMessageDeserializer(new GenericRabbitModelConverter <TradingSignal>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.SetConsole(new LogToConsole())
.SetLogger(_log);
container.Register(c => subscriber);
}
public LimitOrdersConsumer(ILogFactory logFactory,
RabbitMqSettings settings,
IWampHostedRealm realm,
ISessionRepository sessionRepository)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (logFactory == null)
{
throw new ArgumentNullException(nameof(logFactory));
}
_sessionRepository = sessionRepository ?? throw new ArgumentNullException(nameof(sessionRepository));
_subject = realm.Services.GetSubject(TopicUri);
try
{
var subscriptionSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = settings.ConnectionString,
QueueName = $"{settings.ExchangeName}.{QueueName}",
ExchangeName = settings.ExchangeName,
IsDurable = QueueDurable
};
var strategy = new DefaultErrorHandlingStrategy(logFactory, subscriptionSettings);
_subscriber = new RabbitMqSubscriber <LimitOrderMessage>(logFactory, subscriptionSettings, strategy)
.SetMessageDeserializer(new JsonMessageDeserializer <LimitOrderMessage>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.Subscribe(ProcessLimitOrder)
.Start();
}
catch (Exception ex)
{
var log = logFactory.CreateLog(this);
log.Error(ex);
throw;
}
}
public ICMTickPriceHarvester(
ICMAdapterSettings config,
ICMModelConverter modelConverter,
IHandler <TickPrice> tickPriceHandler,
IHandler <TradingOrderBook> orderBookHandler,
IThrottling orderBooksThrottler,
IThrottling tickPriceThrottler,
RepeatingTicksFilter repeatingTicksFilter,
ILog log)
{
_config = config;
_modelConverter = modelConverter;
_tickPriceHandler = tickPriceHandler;
_orderBookHandler = orderBookHandler;
_orderBooksThrottler = orderBooksThrottler;
_tickPricesThrottler = tickPriceThrottler;
_repaetingTicksFilter = repeatingTicksFilter;
_log = log;
_instruments = config.SupportedCurrencySymbols.Select(x => new Instrument(x.LykkeSymbol).Name).ToHashSet();
var rabbitSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = config.RabbitMq.SourceFeed.ConnectionString,
ExchangeName = config.RabbitMq.SourceFeed.Exchange,
QueueName = config.RabbitMq.SourceFeed.Queue
};
var errorStrategy = new DefaultErrorHandlingStrategy(_log, rabbitSettings);
_rabbit = new RabbitMqSubscriber <ICMOrderBook>(rabbitSettings, errorStrategy)
.SetMessageDeserializer(new GenericRabbitModelConverter <ICMOrderBook>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.SetConsole(new LogToConsole())
.SetLogger(_log)
.Subscribe(HandleOrderBook);
}
public IcmTickPriceHarvester(
IcmExchangeConfiguration config,
IcmModelConverter modelConverter,
IHandler <TickPrice> tickPriceHandler,
IHandler <Trading.OrderBook> orderBookHandler,
ILog log)
{
_config = config;
_modelConverter = modelConverter;
_tickPriceHandler = tickPriceHandler;
_orderBookHandler = orderBookHandler;
_log = log;
_enabled = config.RabbitMq.Enabled;
if (!_enabled)
{
return;
}
_instruments = config.SupportedCurrencySymbols.Select(x => new Instrument(IcmExchange.Name, x.LykkeSymbol).Name).ToHashSet();
var rabbitSettings = new RabbitMqSubscriptionSettings
{
ConnectionString = config.RabbitMq.ConnectionString,
ExchangeName = config.RabbitMq.Exchange,
QueueName = config.RabbitMq.Queue
};
var errorStrategy = new DefaultErrorHandlingStrategy(_log, rabbitSettings);
if (_config.Enabled)
{
_rabbit = new RabbitMqSubscriber <OrderBook>(rabbitSettings, errorStrategy)
.SetMessageDeserializer(new GenericRabbitModelConverter <OrderBook>())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.SetConsole(new LogToConsole())
.SetLogger(_log)
.Subscribe(HandleOrderBook);
}
}
