Now that we have all these different builds (sparkd, spark, api server, data streams) - many of which are cross platform - we need a proper toggle for this (relying on 'IF WIN32' preprocessors doesn't cut it)
251 lines
7.0 KiB
C++
251 lines
7.0 KiB
C++
#if defined(EXPORT_MD_CONSUMER)
|
|
#include "MDConsumer.h"
|
|
#include "SecurityCache.h"
|
|
#include "UserSymbol.h"
|
|
#include "common.h"
|
|
#include "lib/domain/DomainSecurityUtils.h"
|
|
#include "lib/md/SymbolLoader.h"
|
|
#include "lib/md/protos/co2.pb.h"
|
|
#include "lib/utils/Dispatcher.h"
|
|
#include "lib/utils/defer.h"
|
|
#include "relay/RelayClient.h"
|
|
#include <atomic>
|
|
#include <set>
|
|
#include <string>
|
|
|
|
namespace bts {
|
|
namespace md {
|
|
|
|
#define CAPI extern "C" BTS_EXPORT
|
|
|
|
using bts::domain::DomainSecurityUtils;
|
|
using bts::domain::SecurityCriteria;
|
|
|
|
//
|
|
// 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<UserSymbol> 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<int> working = 0;
|
|
if (working <= 0) {
|
|
++working;
|
|
md::scan_securities_thread().post([=]() {
|
|
DEFER(--working); // exceptionsafe
|
|
consumer->scan_securities();
|
|
});
|
|
}
|
|
}
|
|
|
|
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
|
|
#ifdef _WIN32
|
|
__try {
|
|
cb(key, buffer, buffer_size, &handle);
|
|
} __except (EXCEPTION_CONTINUE_EXECUTION) {
|
|
}
|
|
#else
|
|
__try {
|
|
cb(key, buffer, buffer_size, &handle);
|
|
} catch(...) {
|
|
}
|
|
#endif
|
|
}
|
|
|
|
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);
|
|
});
|
|
}
|
|
|
|
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_linux(
|
|
MDConsumer *consumer,
|
|
const char* symbol,
|
|
int venue_i,
|
|
int type_i,
|
|
int64_t &cursor,
|
|
raw_receive_pb cb) {
|
|
auto type = static_cast<SecurityType>(type_i);
|
|
auto venue = static_cast<Venue>(venue_i);
|
|
bts_assert(consumer);
|
|
google::protobuf::Arena arena;
|
|
co2::TradeList *ptrades =
|
|
google::protobuf::Arena::CreateMessage<co2::TradeList>(&arena);
|
|
auto channel =
|
|
consumer->get_channel(symbol, type, venue);
|
|
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;
|
|
}
|
|
|
|
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<co2::TradeList>(&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<co2::RFQList>(&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() == "*") {
|
|
const auto system_symbols = SymbolLoader::load(SecurityCriteria::create(
|
|
{DomainSecurityUtils::convert(channel.exchange())},
|
|
{DomainSecurityUtils::convert(channel.type())}));
|
|
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) {
|
|
const auto system_symbols = SymbolLoader::load();
|
|
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
|