182 lines
5.6 KiB
C++
182 lines
5.6 KiB
C++
#ifdef _WIN32
|
|
#include "common.h"
|
|
#include "UserSymbol.h"
|
|
#include "MDConsumer.h"
|
|
#include "SecurityCache.h"
|
|
#include "get_symbols.h"
|
|
#include "relay/RelayClient.h"
|
|
#include "lib/utils/Dispatcher.h"
|
|
#include "lib/utils/defer.h"
|
|
#include "lib/md/protos/co2.pb.h"
|
|
#include <set>
|
|
#include <string>
|
|
#include <atomic>
|
|
|
|
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);
|
|
}
|
|
|
|
}} //namespace
|
|
#endif
|