MarketDataGateway still exists, but is greatly simplified. It creates several `IMarketDataProvider`s, each of which generates a list of `IMarketDataSource`s. The market data sources provide market data to an `IMarketDataListener`. * EmumbaMarketDataProvider * CCApiMarketDataProvider * PyMarketDataProvider * OnixsMarketDataProvider * ReplayMarketDataProvider As a side effect, individual py market data sources are now explicitly limited to a single venue (it probably should have been this way all along, since the shared memory writers do not expect updates to involve multiple venues).
140 lines
4.7 KiB
C++
140 lines
4.7 KiB
C++
#include "CCApiMarketDataProvider.h"
|
|
#include "lib/api/domain/Venue.pb.h"
|
|
#include "lib/api/md/MarketDataConfig.pb.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/io/ProtoPrinter.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/md/GeneralMarketDataListener.h"
|
|
#include "lib/md/GeneralSecurityIndex.h"
|
|
#include "lib/md/MDProducer.h"
|
|
#include "lib/persistence/IDGenerator.h"
|
|
#include "server/sparkd/md/binance/BinanceSubscription.h"
|
|
#include "server/sparkd/md/binance_us/BinanceUsSubscription.h"
|
|
#include "server/sparkd/md/binance_usds_futures/BinanceUsdsFuturesSubscription.h"
|
|
#include "server/sparkd/md/coinbase/CoinbaseSubscription.h"
|
|
#include "server/sparkd/md/deribit/DeribitSubscription.h"
|
|
#include "server/sparkd/md/ftx/FTXSubscription.h"
|
|
#include "server/sparkd/md/okx/OkxSubscription.h"
|
|
|
|
#include <ccapi_cpp/ccapi_event_dispatcher.h>
|
|
|
|
namespace bts::md {
|
|
|
|
using bts::api::md::MarketDataConfig;
|
|
using bts::persistence::IDGenerator;
|
|
using std::pair;
|
|
using std::shared_ptr;
|
|
using std::string;
|
|
using std::unique_ptr;
|
|
using std::unordered_map;
|
|
using std::vector;
|
|
|
|
static bool validate(
|
|
const MarketDataConfig & /*cfg*/, vector<string> & /*errs*/) {
|
|
return true;
|
|
}
|
|
|
|
struct CCApiMarketDataProvider::PImpl {
|
|
struct VenueSink {
|
|
GeneralSecurityIndex sec_index;
|
|
MDProducer md_producer;
|
|
GeneralMarketDataListener listener;
|
|
|
|
VenueSink(api::Venue venue, shared_ptr<IDGenerator> sec_id_store)
|
|
: sec_index(),
|
|
listener(sec_index, md_producer, venue, sec_id_store.get()) {}
|
|
};
|
|
|
|
MarketDataConfig config;
|
|
ccapi::EventDispatcher dispatcher;
|
|
shared_ptr<IDGenerator> sec_id_store;
|
|
unordered_map<api::Venue, unique_ptr<VenueSink>> venue_sinks;
|
|
vector<std::pair<api::domain::Venue, std::shared_ptr<IMarketDataSource>>>
|
|
sources;
|
|
|
|
PImpl(MarketDataConfig config, shared_ptr<IDGenerator> sec_id_store)
|
|
: config(std::move(config)), sec_id_store(std::move(sec_id_store)) {}
|
|
|
|
VenueSink *get_venue_sink(api::Venue venue) {
|
|
auto it = venue_sinks.find(venue);
|
|
if (it != venue_sinks.end()) {
|
|
return it->second.get();
|
|
}
|
|
return venue_sinks
|
|
.try_emplace(venue, std::make_unique<VenueSink>(venue, sec_id_store))
|
|
.first->second.get();
|
|
}
|
|
};
|
|
|
|
CCApiMarketDataProvider::CCApiMarketDataProvider(
|
|
MarketDataConfig config, shared_ptr<IDGenerator> sec_id_store)
|
|
: me_(std::make_unique<PImpl>(std::move(config), std::move(sec_id_store))) {
|
|
}
|
|
|
|
CCApiMarketDataProvider::~CCApiMarketDataProvider() = default;
|
|
|
|
vector<pair<api::domain::Venue, shared_ptr<IMarketDataSource>>>
|
|
CCApiMarketDataProvider::get_sources() {
|
|
auto &cfg = me_->config;
|
|
vector<string> cfg_errs;
|
|
if (!validate(cfg, cfg_errs)) {
|
|
LOG(md, Error,
|
|
"CCApiMarketDataProvider::get_sources failed. Invalid config: {}",
|
|
fmt::to_string(fmt::join(cfg_errs, "\n")));
|
|
}
|
|
|
|
// Binance
|
|
for (const auto &binance : cfg.binance()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_BINANCE,
|
|
std::make_shared<binance::BinanceSubscription>(
|
|
&me_->dispatcher, binance, me_->sec_id_store.get()));
|
|
}
|
|
// Binance US
|
|
for (const auto &binance_us : cfg.binance_us()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_BINANCE_US,
|
|
std::make_shared<binance_us::BinanceUsSubscription>(
|
|
&me_->dispatcher, binance_us, me_->sec_id_store.get()));
|
|
}
|
|
// Binance USDS Futures
|
|
for (const auto &binance_ufs : cfg.binance_usds_futures()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_BINANCE_USDS_FUTURES,
|
|
std::make_shared<
|
|
binance_usds_futures::BinanceUsdsFuturesSubscription>(
|
|
&me_->dispatcher, binance_ufs, me_->sec_id_store.get()));
|
|
}
|
|
// Coinbase
|
|
for (const auto &coinbase : cfg.coinbase()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_COINBASE,
|
|
std::make_shared<coinbase::CoinbaseSubscription>(
|
|
&me_->dispatcher, coinbase, me_->sec_id_store.get()));
|
|
}
|
|
// Deribit
|
|
for (const auto &deribit : cfg.deribit()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_DERIBIT,
|
|
std::make_shared<deribit::DeribitSubscription>(
|
|
&me_->dispatcher, deribit, me_->sec_id_store.get()));
|
|
}
|
|
// FTX
|
|
for (const auto &ftx : cfg.ftx()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_FTX,
|
|
std::make_shared<ftx::FTXSubscription>(
|
|
&me_->dispatcher, ftx, me_->sec_id_store.get()));
|
|
}
|
|
// Okx
|
|
for (const auto &okx : cfg.okx()) {
|
|
me_->sources.emplace_back(
|
|
api::domain::VENUE_OKX,
|
|
std::make_shared<okx::OkxSubscription>(
|
|
&me_->dispatcher, okx, me_->sec_id_store.get()));
|
|
}
|
|
return me_->sources;
|
|
}
|
|
|
|
} // namespace bts::md
|