This is a csharp/cpp interop method. The csharp delegate, which is passed to and eventually invoked from cpp, accepts this param by value already, but for some reason the corresponding cpp delegate accepts that same param by ref. While working to enable the api server build on Linux, I discovered this delegate was receiving bogus data from cpp. The problem went away when I changed the cpp delegate param to be passed by value, rather than ref.
217 lines
5.9 KiB
C++
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
|