Files
spark/src/lib/md/MDConsumerInterop.cpp
T

217 lines
5.9 KiB
C++

#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 <atomic>
#include <set>
#include <string>
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<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();
});
}
}
#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<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() == "*") {
std::set<UserSymbol> 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<UserSymbol> 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