Files
spark/src/lib/md/MDConsumerInterop.cpp
T
John Colvin 9291d30ae9 build: Add cmake opt to export MDConsumerInterop fns
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)
2024-06-05 15:44:35 +00:00

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