Files
spark/src/lib/md/MDConsumerInterop.cpp
T
2019-03-29 15:38:26 -04:00

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