#ifdef _WIN32 #include "MDConsumer.h" #include "SecurityCache.h" #include "UserSymbol.h" #include "common.h" #include "get_symbols.h" #include "lib/md/protos/co2.pb.h" #include "lib/utils/Dispatcher.h" #include "lib/utils/defer.h" #include "relay/RelayClient.h" #include #include #include namespace bts { namespace md { #define CAPI extern "C" BTS_EXPORT // // MDConsumer struct BlitUserSymbol { const char *symbol; api::Venue exchange; SecurityType type; }; CAPI MDConsumer * create_md_consumer(BlitUserSymbol *usersymbols, uint32_t count, bool shared) { SecurityCache cache; std::set symbols; for (size_t x = 0; x < count; ++x) { symbols.insert(UserSymbol( usersymbols[x].symbol, usersymbols[x].exchange, usersymbols[x].type)); } return new MDConsumer( cache, nullptr /*synthetics*/, nullptr /*mbo*/, &symbols, shared); } CAPI void destroy_md_consumer(MDConsumer *consumer) { if (consumer != nullptr) { delete consumer; } } CAPI bool md_consumer_all_heartbeats_ok(MDConsumer *consumer) { if (consumer) { return consumer->all_heartbeats_ok(); } return false; } CAPI bool md_consumer_get_handle( MDConsumer *consumer, security_key key, MDConsumerHandle &handle) { bts_assert(consumer); bts_assert(key != invalid_security_key); handle = consumer->get_handle(key); return handle.is_initialized(); } typedef void (*security_cb)( security_key, const char *, size_t, MDConsumerHandle *handle); CAPI size_t md_consumer_walk_security_list(MDConsumer *consumer, security_cb cb) { bts_assert(consumer); std::string buffer; return consumer->walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle handle) { buffer.clear(); security->SerializePartialToString(&buffer); cb(security->id(), buffer.c_str(), buffer.size(), &handle); }); } CAPI void md_consumer_scan_securities(MDConsumer *consumer) { bts_assert(consumer); static std::atomic working = 0; if (working <= 0) { ++working; md::scan_securities_thread().post([=]() { DEFER(--working); // exceptionsafe consumer->scan_securities(); }); } } #ifdef _WIN32 void safe_call_clr_callback( security_cb cb, security_key key, const char *buffer, size_t buffer_size, MDConsumerHandle &handle) { // Protect against clr shutting down __try { cb(key, buffer, buffer_size, &handle); } __except (EXCEPTION_CONTINUE_EXECUTION) { } } CAPI void md_consumer_set_on_security(MDConsumer *consumer, security_cb cb) { bts_assert(consumer); consumer->on_security( [=](const SecurityPtr &security, MDConsumerHandle handle) { std::string buffer; security->SerializePartialToString(&buffer); safe_call_clr_callback( cb, security->id(), buffer.c_str(), buffer.size(), handle); }); } #endif bool is_heart_beat_ok(const ColdHeader &header); CAPI bool md_consumer_is_heart_beating(const ColdHeader *header) { if (header == nullptr) return false; return is_heart_beat_ok(*header); } typedef void (*raw_receive_pb)(const char *, size_t); CAPI int md_consumer_read_trades( MDConsumer *consumer, BlitUserSymbol &symbol, int64_t &cursor, raw_receive_pb cb) { bts_assert(consumer); google::protobuf::Arena arena; co2::TradeList *ptrades = google::protobuf::Arena::CreateMessage(&arena); auto channel = consumer->get_channel(symbol.symbol, symbol.type, symbol.exchange); if (channel.is_initialized()) { cursor = channel.read_trades(*ptrades->mutable_items(), cursor); std::string buffer; ptrades->SerializeToString(&buffer); cb(buffer.c_str(), buffer.size()); return ptrades->items_size(); } return 0; } CAPI int md_consumer_read_rfqs( MDConsumer *consumer, BlitUserSymbol &symbol, int64_t &cursor, raw_receive_pb cb) { bts_assert(consumer); google::protobuf::Arena arena; co2::RFQList *plist = google::protobuf::Arena::CreateMessage(&arena); auto channel = consumer->get_channel(symbol.symbol, symbol.type, symbol.exchange); if (channel.is_initialized()) { cursor = channel.read_rfqs(*plist->mutable_items(), cursor); std::string buffer; plist->SerializeToString(&buffer); cb(buffer.c_str(), buffer.size()); return plist->items_size(); } return 0; } // // MDConsumerChannel // // Relay control CAPI void add_relay_symbol( md::RelayControl *prelay, BlitUserSymbol symbol, uint32_t flags) { co2::SecurityChannel channel; channel.set_symbol(symbol.symbol); channel.set_exchange(symbol.exchange); channel.set_type(symbol.type); channel.set_flags(flags); if (channel.symbol() == "*") { std::set system_symbols; get_system_md_symbols(channel.exchange(), channel.type(), system_symbols); for (const auto &sym : system_symbols) { channel.set_symbol(sym.symbol()); md::add_relay_symbol(prelay, channel); } } else { md::add_relay_symbol(prelay, channel); } } CAPI void set_relay_token( md::RelayControl *prelay, const char *token, size_t token_size) { md::set_relay_token(prelay, std::string(token, token_size)); } typedef void (*usersymbol_cb)(BlitUserSymbol symbol); CAPI void md_consumer_get_system_md_symbols(usersymbol_cb cb) { std::set system_symbols; get_system_md_symbols( api::VENUE_UNSET, api::SECURITYTYPE_UNSET, system_symbols); for (auto &s : system_symbols) { BlitUserSymbol blit_sym = {s.symbol().c_str(), s.exchange(), s.type()}; cb(blit_sym); } } typedef void (*just_action)(); CAPI void post_on_scan_security_thread(just_action a) { md::scan_securities_thread().post(a); } CAPI void dump_co2_memory_to_disk(MDConsumer *consumer, const char *path) { if (consumer) { consumer->dump_shm_to(path); } } } // namespace md } // namespace bts #endif