Deribit orders (mostly) work

This commit is contained in:
taha afzal committed 2022-03-31 14:34:29 -04:00
1 parent 32c4d05106
commit 64240c5f3b
15 files changed
+889 -327

No files matched your search

+1 -1
View File
@@ -1 +1 @@
set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/domain/Currency.proto;api/domain/SecurityType.proto;api/domain/Venue.proto;api/io/URL.proto;api/md/MarketDataSubscriptionParams.proto;api/md/binance/BinanceMarketDataSubscriptionParams.proto;api/md/deribit/DeribitMarketDataSubscriptionParams.proto;api/md/ftx/FTXMarketDataSubscriptionParams.proto;api/md/glbx/GlbxMarketDataSubscriptionParams.proto;api/md/huobi/HuobiMarketDataSubscriptionParams.proto;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/service_helpers/AlgoServiceUtils.cpp;api/service_helpers/PositionUtilities.cpp;api/services/AdminService.proto;api/services/AlgoDefinitionService.proto;api/services/AlgoService.proto;api/services/AnalyticsService.proto;api/services/ApiUnitTestService.proto;api/services/AuthService.proto;api/services/BasePositionService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MBOService.proto;api/services/MarginService.proto;api/services/MarketDataAuxiliaryService.proto;api/services/MarketDataRelay.proto;api/services/MarketDataService.proto;api/services/MoneyFileService.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/PositionService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;communincation/websockets/tests/WebsocketSyncClientTests.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cme_reference_data.conf;config/defaults/edge.conf;config/defaults/jetfix.conf;config/defaults/keycode.conf;config/defaults/logging.conf;config/defaults/orderman_cfg.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/position_cfg.conf;config/defaults/span.conf;config/defaults/spreader.conf;config/defaults/testkeys.conf;config/defaults/threads.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/algo_types.proto;config/protos/cme_reference_data.proto;config/protos/exchange_sim_cfg.proto;config/protos/jetfix.proto;config/protos/keycode.proto;config/protos/logging.proto;config/protos/market_data.proto;config/protos/mercury_cfg.proto;config/protos/orderman_cfg.proto;config/protos/orders_fills_cleanup.proto;config/protos/perflog_cfg.proto;config/protos/ports.proto;config/protos/position_cfg.proto;config/protos/quickbus_cfg.proto;config/protos/span.proto;config/protos/spartan.proto;config/protos/spreader.proto;config/protos/subprocess.proto;config/protos/symbols.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/threads.proto;config/protos/toggles.proto;config/protos/ui.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain/AggressorSide.cpp;domain/NewOrder.cpp;domain/OrderDefinition.cpp;domain/OrderStatus.cpp;domain/OrderUpdate.cpp;domain/Side.cpp;domain/TimeInForce.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;domain_model/sod.cpp;domain_model/tests/domain_tests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;io/QueryParams.cpp;io/URL.cpp;io/http/CurlHandle.cpp;io/http/HTTPClient.cpp;io/http/HTTPHeaders.cpp;io/http/HTTPRequest.cpp;io/http/HTTPResponse.cpp;io/websocket/WebsocketClient.cpp;io/websocket/WebsocketClientConfiguration.cpp;io/websocket/WebsocketError.cpp;io/websocket/WebsocketMessage.cpp;io/websocket/WebsocketSSLClientInternal.cpp;io/websocket/tests/WebsocketClientTests.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPeriodicDumper.cpp;md/Diag/ShmDumper.cpp;md/MBOProcessor.cpp;md/MBOSeLine truncated
set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/domain/Currency.proto;api/domain/SecurityType.proto;api/domain/Venue.proto;api/io/URL.proto;api/md/MarketDataSubscriptionParams.proto;api/md/binance/BinanceMarketDataSubscriptionParams.proto;api/md/deribit/DeribitMarketDataSubscriptionParams.proto;api/md/ftx/FTXMarketDataSubscriptionParams.proto;api/md/glbx/GlbxMarketDataSubscriptionParams.proto;api/md/huobi/HuobiMarketDataSubscriptionParams.proto;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/service_helpers/AlgoServiceUtils.cpp;api/service_helpers/PositionUtilities.cpp;api/services/AdminService.proto;api/services/AlgoDefinitionService.proto;api/services/AlgoService.proto;api/services/AnalyticsService.proto;api/services/ApiUnitTestService.proto;api/services/AuthService.proto;api/services/BasePositionService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MBOService.proto;api/services/MarginService.proto;api/services/MarketDataAuxiliaryService.proto;api/services/MarketDataRelay.proto;api/services/MarketDataService.proto;api/services/MoneyFileService.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/PositionService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;communincation/websockets/tests/WebsocketSyncClientTests.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cme_reference_data.conf;config/defaults/edge.conf;config/defaults/jetfix.conf;config/defaults/keycode.conf;config/defaults/logging.conf;config/defaults/orderman_cfg.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/position_cfg.conf;config/defaults/span.conf;config/defaults/spreader.conf;config/defaults/testkeys.conf;config/defaults/threads.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/algo_types.proto;config/protos/cme_reference_data.proto;config/protos/exchange_sim_cfg.proto;config/protos/jetfix.proto;config/protos/keycode.proto;config/protos/logging.proto;config/protos/market_data.proto;config/protos/mercury_cfg.proto;config/protos/orderman_cfg.proto;config/protos/orders_fills_cleanup.proto;config/protos/perflog_cfg.proto;config/protos/ports.proto;config/protos/position_cfg.proto;config/protos/quickbus_cfg.proto;config/protos/span.proto;config/protos/spartan.proto;config/protos/spreader.proto;config/protos/subprocess.proto;config/protos/symbols.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/threads.proto;config/protos/toggles.proto;config/protos/ui.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain/AggressorSide.cpp;domain/NewOrder.cpp;domain/OrderDefinition.cpp;domain/OrderStatus.cpp;domain/OrderUpdate.cpp;domain/Side.cpp;domain/TimeInForce.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;domain_model/sod.cpp;domain_model/tests/domain_tests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;io/QueryParams.cpp;io/URL.cpp;io/http/CurlHandle.cpp;io/http/HTTPClient.cpp;io/http/HTTPHeaders.cpp;io/http/HTTPRequest.cpp;io/http/HTTPResponse.cpp;io/websocket/WebsocketClient.cpp;io/websocket/WebsocketClientConfiguration.cpp;io/websocket/WebsocketError.cpp;io/websocket/WebsocketMessage.cpp;io/websocket/WebsocketSSLClientInternal.cpp;io/websocket/tests/WebsocketClientTests.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPeriodicDumper.cpp;md/Diag/ShmDumper.cpp;md/MBOProcessor.cpp;md/MBOSeLine truncated
+3 -1
View File
@@ -3,13 +3,13 @@
#include "lib/api/services/OrderService.pb.h"
#include "lib/jetfix/common/OutFIX.h"
#include "lib/logging/logging.h"
#include "lib/orderman/Governor.h"
#include "lib/orderman/actors/order_manager/OrderManager.h"
#include "lib/orderman/actors/order_manager/OrderServicesData.h"
#include "lib/orderman/actors/order_manager/SessionServices.h"
#include "lib/orderman/events/FilledPositionEvent.h"
#include "lib/orderman/events/StatusUpdateEvent.h"
#include "lib/orderman/events/TickerUpdateEvent.h"
#include "lib/orderman/Governor.h"
#include "lib/orderman/orderman_utils/EventStream.h"
#include "lib/orderman/orders/Order.h"
@@ -314,6 +314,8 @@ using ExeReportSubID = EventStream<NewExecutionReportEvent>::SubID;
template <class CB>
inline ExeReportSubID OrderServices::subscribe_to_exe_report(
SessionServices &ss, OrderKey k, CB &&cb) {
LOG(OrderMan, Info, "OrderServices::subscribe_to_exe_report ss: {} k: {}",
ss.session_name(), k);
return ss.subscribe_to_exe_report(
k, [this, cb](auto const &ev) { this->on_external_event(ev, cb); });
}
+3
View File
@@ -3,6 +3,7 @@
#include "lib/config/config.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/domain_model/Security.h"
#include "lib/logging/logging.h"
#include "lib/orderman/actors/SODPosition.h"
#include "lib/orderman/events/NewExecutionReportEvent.h"
#include "lib/orderman/events/OrderDefinitionUpdateEvent.h"
@@ -133,6 +134,8 @@ FillStore::~FillStore() {}
void FillStore::on_execution_report(
const mercury::Update<NewExecutionReportEvent> &u) {
LOG(OrderMan, Info, "FillStore::on_execution_report n of events: {}",
u.events == nullptr ? 0 : u.events->size());
if (u.events) {
for (auto const &ev : *u.events) {
auto &er = *ev.data;
+4
View File
@@ -149,11 +149,15 @@ void OrderStore::store_and_publish_if_complete(
me->store->update(
orders_ns, std::to_string(k.value()),
utils::pb::to_string(rec));
LOG(OrderMan, Info,
"OrderStore::store_and_publish_if_complete updated key: {}", k);
} else {
me->store->insert(
orders_ns, std::to_string(k.value()),
utils::pb::to_string(rec));
rec_info.is_saved = true;
LOG(OrderMan, Info,
"OrderStore::store_and_publish_if_complete added key: {}", k);
}
} else {
LOG(OrderMan, Warn,
+258 -75
View File
@@ -20,13 +20,24 @@
#include "lib/utils/TimeStamp.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_chrono.h"
#include "lib/utils/datetime.h"
#include "lib/utils/helper_macros.h"
#include "server/sparkd/md/platforms/emumba/EmMDListener.h"
#include "server/sparkd/md/platforms/emumba/IEMOrderMuxer.h"
#include "lib/utils/Uuid.h"
#include <atomic>
#include <bits/stdint-intn.h>
#include <bits/stdint-uintn.h>
#include <boost/pool/object_pool.hpp>
#include <cmath>
#include <cstdint>
#include <emumba-deribit-connector/market_data_common.h>
#include <emumba-deribit-connector/order_entry_common.h>
#include <queue>
#include <set>
#include <string>
#include <tbb/concurrent_queue.h>
#include <unordered_map>
#include <variant>
#include <vector>
@@ -34,11 +45,36 @@
namespace bts {
namespace orderman {
struct EMCallbackMsg {
// didnt make it const since tbb::queue needs a copy cons
emumba::deribit_connector::data_types::error ec;
emumba::order_entry::order_key order_key;
emumba::order_entry::order_state order_state;
};
struct FillState {
double avg_fill_price = 0.0;
double total_fills = 0.0;
bool has_new_fills(double new_total_fills) const {
return std::abs(total_fills - new_total_fills) > 0.0000001;
}
std::tuple<double, double> latest_fills(
double new_avg_fill_price, double new_total_fills) {
double last_fills = new_total_fills - total_fills;
double last_fill_price = (new_total_fills * new_avg_fill_price) -
(total_fills * avg_fill_price);
last_fill_price /= last_fills;
return {last_fill_price, last_fills};
}
};
struct EMExecutionGateway::PImpl {
PImpl(md::SecurityOracle o)
: admin_data(), connection_time(), sec_oracle(o) {
: exe_report_pool(), admin_data(), connection_time(), sec_oracle(o) {
LOG(OrderMan, Info, "EMExecutionGateway::PImpl constructor");
}
size_t msg_seq_num = 0;
boost::object_pool<ExecutionReport> exe_report_pool;
std::unordered_map<SecurityKey::Value, api::Security const *> securities;
std::unordered_map<int64_t, api::Security const *> securities_by_exchange_id;
OnExeReport on_exe_report;
@@ -50,8 +86,53 @@ struct EMExecutionGateway::PImpl {
std::vector<OrderMsg> buffered_msgs = {};
unsigned long exchange_oid = 0;
std::vector<ExecutionReport> exe_reports = {};
IEMOrderMuxer *order_mux = nullptr;
// em's key or order
std::unordered_map<int64_t, CreateOrderMsg> order_map = {};
// bts key to em keys
std::unordered_map<OrderKey, int64_t> key_map = {};
std::unordered_map<int64_t, FillState> fill_map = {};
tbb::concurrent_queue<EMCallbackMsg> em_cb_queue =
tbb::concurrent_queue<EMCallbackMsg>();
};
api::orderman::NativeOrderStatus native_order_status(
const emumba::order_entry::order_state &state) {
switch (state.order_status) {
case emumba::order_entry::status::working:
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_NEW;
case emumba::order_entry::status::completed:
// maybe check fills
// if (state.total_fills.value() > 0)
// return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_FILLED;
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_FILLED;
case emumba::order_entry::status::canceled:
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_CANCELED;
case emumba::order_entry::status::rejected:
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_REJECTED;
case emumba::order_entry::status::untriggered:
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNDEFINED;
}
bts_assert(false);
return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNDEFINED;
}
// get em's qty
double get_quantity(const emumba::market_data::quantity &q) {
const auto &v = q.value();
if (std::holds_alternative<double>(v))
return std::get<double>(v);
return static_cast<double>(std::get<uint32_t>(v));
}
std::string get_exchange_oid(const emumba::order_entry::order_state &state) {
using namespace emumba::order_entry;
const auto &exch_state = state.exchange_order_state;
bts_assert(std::holds_alternative<deribit_order_state>(exch_state));
const auto &deribit_state = std::get<deribit_order_state>(exch_state);
return deribit_state.exchange_order_id;
}
EMExecutionGateway::EMExecutionGateway(md::SecurityOracle o)
: IExecutionGateway(), me(new PImpl(o)) {
LOG(OrderMan, Info, "EMExecutionGateway::EMExecutionGateway constructor");
@@ -60,81 +141,21 @@ EMExecutionGateway::EMExecutionGateway(md::SecurityOracle o)
EMExecutionGateway::~EMExecutionGateway() {}
void EMExecutionGateway::start() {
LOG(OrderMan, Info, "EMExecutionGateway::start");
_init();
LOG(OrderMan, Info, "EMExecutionGateway::start order_mux aquired: {}",
me->order_mux != nullptr);
}
// this is a periodic timer
void EMExecutionGateway::dispatch_incoming_fix_messages() {
if (me->buffered_msgs.size() == 0) {
return;
}
std::vector<OrderMsg> aux_msgs = me->buffered_msgs;
me->buffered_msgs.clear();
for (OrderMsg m : aux_msgs) {
if (std::holds_alternative<CreateOrderMsg>(m)) {
CreateOrderMsg cr_msg = std::get<CreateOrderMsg>(m);
LOG(OrderMan, Info,
"EMExecutionGateway::dispatch_incoming_fix_message key: {} sec: "
"{} p: {} q: {}",
cr_msg.key, cr_msg.security->id(), cr_msg.price, cr_msg.quantity);
ExecutionReport er = {};
std::string account_name = "ACCA1";
std::array<char, 12> an_array = {};
size_t i = 0;
for (const char c : account_name) {
an_array[i++] = c;
}
er.account_name = AccountName(an_array);
to_array(cr_msg.routing_record->account(), &er.account_name.value());
to_array(
cr_msg.routing_record->operator_id(), &er.operator_id.value());
er.order_key = cr_msg.key;
er.msg_seq_num = 0;
er.security = cr_msg.security;
er.leg_security = nullptr;
er.side = cr_msg.side;
er.time_in_force = cr_msg.time_in_force;
er.order_type = cr_msg.order_type;
er.exec_type = api::orderman::EXEC_TYPE_NEW;
er.order_status = api::orderman::NATIVE_ORDER_STATUS_NEW;
er.manual_order_indicator = api::orderman::MANUAL_ORDER_INDICATOR_NO;
ExchangeOrderID64 eoid = ExchangeOrderID64(me->exchange_oid++);
ExchangeOrderIDVar oid = eoid;
er.exchange_order_id = oid;
er.price = cr_msg.price;
er.quantity = cr_msg.quantity;
er.filled_quantity = Quantity(0);
er.last_shares = Quantity(0);
er.msg = "Message Placed";
er.exchange = api::VENUE_SIM;
trace::CorID cid = {};
me->exe_reports.push_back(er);
const auto &er_pheap = me->exe_reports.back();
me->on_exe_report(er_pheap, cid);
} else if (std::holds_alternative<CancelOrderMsg>(m)) {
CancelOrderMsg cxl_m = std::get<CancelOrderMsg>(m);
for (auto &er : me->exe_reports) {
if (er.order_key == cxl_m.key) {
er.order_status = api::orderman::NATIVE_ORDER_STATUS_CANCELED;
er.msg = "Cancelled";
me->on_exe_report(er, {});
return;
}
}
} else if (std::holds_alternative<CancelReplaceOrderMsg>(m)) {
CancelReplaceOrderMsg cxl_r_msg = std::get<CancelReplaceOrderMsg>(m);
CreateOrderMsg cr_msg = cxl_r_msg.create_fields;
for (auto &er : me->exe_reports) {
if (er.order_key == cr_msg.key) {
er.order_status = api::orderman::NATIVE_ORDER_STATUS_REPLACED;
er.msg = "Replaced";
er.price = cr_msg.price;
er.quantity = cr_msg.quantity;
me->on_exe_report(er, {});
return;
}
}
}
EMCallbackMsg cb_msg = {};
// keep popping messages until no more
while (me->em_cb_queue.try_pop(cb_msg)) {
LOG(OrderMan, Info,
"EMExecutionGateway::dispatch_incoming_fix_messages dispatched cb "
"for key: {}",
cb_msg.order_key.value());
_process_cb_and_fire_er(cb_msg);
}
}
@@ -159,11 +180,25 @@ void EMExecutionGateway::send_fix(const jetfix::OutFIXPtr &, trace::CorID) {
void EMExecutionGateway::send_msgs(
std::vector<OrderMsg> const &msg_vec, trace::CorID) {
// this is where it will be sent to the exchange
LOG(OrderMan, Info, "EMExecutionGateway::send_msgs count: {}",
msg_vec.size());
if (!_init()) {
LOG(OrderMan, Error, "EMExecutionGateway::send_msgs order_mix not set");
}
LOG(OrderMan, Info,
"EMExecutionGateway::send_msgs count: {} order_mux initialized: {}",
msg_vec.size(), me->order_mux != nullptr);
for (auto &m : msg_vec) {
me->buffered_msgs.emplace_back(m);
if (std::holds_alternative<CreateOrderMsg>(m)) {
const CreateOrderMsg &cr_msg = std::get<CreateOrderMsg>(m);
_send_create(cr_msg);
} else if (std::holds_alternative<CancelReplaceOrderMsg>(m)) {
const CancelReplaceOrderMsg &cxl_repl_msg =
std::get<CancelReplaceOrderMsg>(m);
_send_cxl_replace(cxl_repl_msg);
} else if (std::holds_alternative<CancelOrderMsg>(m)) {
const CancelOrderMsg &cxl_msg = std::get<CancelOrderMsg>(m);
_send_cxl(cxl_msg);
}
}
}
@@ -175,5 +210,153 @@ OnCancelReject &EMExecutionGateway::on_cancel_reject() {
return me->on_cancel_reject;
}
bool EMExecutionGateway::_init() {
if (me->order_mux == nullptr) {
me->order_mux = md::EmMDListener::order_mux();
if (me->order_mux != nullptr) {
me->order_mux->order_update_cb() =
[this](const auto &er, const auto &key, const auto &state) {
LOG(OrderMan, Info,
"EMExecutionGateway received order callback for key: {}",
key.value());
me->em_cb_queue.push({er, key, state});
};
}
}
return me->order_mux != nullptr;
}
// converts the CreateOrderMsg to emumba::order_entry::new_order and sends it to
// EM gateway
void EMExecutionGateway::_send_create(const CreateOrderMsg &c) {
LOG(OrderMan, Info, "EMExecutionGateway::_send_create key: {}", c.key);
emumba::order_entry::new_order new_order;
// TODO
std::string desc = c.security->glbx().security_desc();
new_order.order_def.sec_id.value() = desc;
new_order.order_def.order_side = c.side == bts::api::SIDE_BUY
? emumba::market_data::side::buy
: emumba::market_data::side::sell;
new_order.order_def.time_in_frc = emumba::order_entry::time_in_force::gtc;
// price, qty
new_order.px = emumba::market_data::price(c.price.value());
new_order.qty.value() = static_cast<double>(c.quantity.value());
// // order_def.exchange_order
emumba::order_entry::deribit_order_definition deribit_def;
emumba::order_entry::deribit_order_def_optional deribit_def_optionals;
deribit_def.ord_type = emumba::order_entry::order_type::limit_order;
deribit_def_optionals.mmp = false;
deribit_def.optional_fields = deribit_def_optionals;
new_order.order_def.exchange_order = deribit_def;
// place order now
emumba::order_entry::order_key order_key =
me->order_mux->launch_new_order(new_order);
me->order_map.insert({order_key.value(), c});
me->key_map.insert({c.key, order_key.value()});
}
void EMExecutionGateway::_send_cxl_replace(
const CancelReplaceOrderMsg &cxl_rpl) {
LOG(OrderMan, Info, "EMExecutionGateway::_send_cxl_replace key: {}",
cxl_rpl.create_fields.key);
auto it = me->key_map.find(cxl_rpl.create_fields.key);
if (it == me->key_map.end()) {
// send an er
LOG(OrderMan, Error, "Could not modify order key: {}, could not find key",
cxl_rpl.create_fields.key);
return;
}
auto em_key = it->second;
auto cr_it = me->order_map.find(em_key);
auto &cr_msg = cr_it->second;
// this is controversial: because we update the price qty right away
cr_msg = cxl_rpl.create_fields;
// how do we handle the case of partial fills here, or does EMOrder does it ?
const emumba::order_entry::order_update update = {
emumba::order_entry::order_key(em_key),
emumba::market_data::price(cxl_rpl.create_fields.price.value()),
emumba::market_data::quantity(
static_cast<double>(cxl_rpl.create_fields.quantity.value()))};
me->order_mux->update_order(update);
}
void EMExecutionGateway::_send_cxl(const CancelOrderMsg &cxl) {
LOG(OrderMan, Info, "EMExecutionGateway::_send_create key: {}", cxl.key);
auto it = me->key_map.find(cxl.key);
if (it == me->key_map.end()) {
// send an er
LOG(OrderMan, Error, "Could not cancel order key: {}, could not find key",
cxl.key);
return;
}
auto key = it->second;
me->order_mux->cancel_order(emumba::order_entry::order_key(key));
}
void EMExecutionGateway::_process_cb_and_fire_er(const EMCallbackMsg &em_cb) {
auto key = em_cb.order_key.value();
auto it = me->order_map.find(key);
if (it == me->order_map.end()) {
LOG(OrderMan, Error,
"EMExecutionGateway::_process_cb_and_fire_er key: {} not found", key);
}
auto &cr_msg = it->second;
ExecutionReport *er_p = me->exe_report_pool.construct();
ExecutionReport &er = *er_p;
to_array(cr_msg.routing_record->account(), &er.account_name.value());
to_array(cr_msg.routing_record->operator_id(), &er.operator_id.value());
er.order_key = cr_msg.key;
er.msg_seq_num = me->msg_seq_num++;
er.security = cr_msg.security;
er.leg_security = nullptr;
er.side = cr_msg.side;
er.time_in_force = cr_msg.time_in_force;
er.order_type = cr_msg.order_type;
// TODO
er.exec_type = api::orderman::ExecType::EXEC_TYPE_NEW;
er.order_status = native_order_status(em_cb.order_state);
er.manual_order_indicator =
api::orderman::ManualOrderIndicator::MANUAL_ORDER_INDICATOR_NO;
std::string exch_oid = get_exchange_oid(em_cb.order_state);
auto &er_exch_oid = std::get<ExchangeOrderID>(er.exchange_order_id).value();
to_array(exch_oid, &er_exch_oid);
er.price = cr_msg.price;
er.quantity = cr_msg.quantity;
// fractional qty
// fills
FillState &fill_state = me->fill_map[key];
double avg_fill_price = em_cb.order_state.avg_price.to_double();
double total_fills = get_quantity(em_cb.order_state.total_fills);
er.avg_price = Price(avg_fill_price);
er.filled_quantity = Quantity(static_cast<uint32_t>(total_fills));
if (fill_state.has_new_fills(total_fills)) {
er.exec_type = api::orderman::ExecType::EXEC_TYPE_PARTIAL_FILL;
if (em_cb.order_state.order_status ==
emumba::order_entry::status::completed) {
er.exec_type = api::orderman::ExecType::EXEC_TYPE_FILL;
}
auto [last_price, last_shares] =
fill_state.latest_fills(avg_fill_price, total_fills);
er.last_price = Price(last_price);
er.last_shares = Quantity(last_shares);
fill_state = {avg_fill_price, total_fills};
// TODO: this should be part of the update
utils::Uuid guid;
std::string fill_id = guid.to_text_string();
to_array(fill_id, &er.exchange_fill_id.value());
} else {
er.last_shares = Quantity(0);
}
er.max_show = Quantity(0);
er.exchange = cr_msg.security->exchange();
ExchangeTimeStamp64 now = ExchangeTimeStamp64(datetime::unix_nano_now());
er.transact_time = now;
LOG(OrderMan, Info,
"EMExecutionGateway::_process_cb_and_fire_er firing er: {}",
er.to_string());
me->on_exe_report(er, {});
}
} // namespace orderman
} // namespace bts
@@ -1,10 +1,24 @@
#pragma once
#include "IExecutionGateway.h"
#include "lib/orderman/CancelOrderMsg.h"
#include "lib/orderman/CancelReplaceOrderMsg.h"
#include "lib/orderman/CreateOrderMsg.h"
#include <bits/stdint-uintn.h>
#include <cstdint>
namespace emumba::deribit_connector::data_types {
class error;
}
namespace emumba::order_entry {
struct order_state;
}
namespace bts {
namespace orderman {
struct EMCallbackMsg;
// Wrapper around EM's order gateway. There are fix overtones to this, that are
// ignored
class EMExecutionGateway : public IExecutionGateway {
@@ -26,6 +40,13 @@ class EMExecutionGateway : public IExecutionGateway {
private:
struct PImpl;
std::unique_ptr<PImpl> me;
private:
bool _init();
void _send_create(const CreateOrderMsg &);
void _send_cxl_replace(const CancelReplaceOrderMsg &);
void _send_cxl(const CancelOrderMsg &);
void _process_cb_and_fire_er(const EMCallbackMsg &);
};
} // namespace orderman
@@ -1,6 +1,7 @@
#include "ExecutionGatewayFactory.h"
#include "lib/md/SecurityOracle.h"
#include "lib/orderman/gateways/EMExecutionGateway.h"
#include "lib/orderman/gateways/FakeExecutionGateway.h"
#include "lib/orderman/gateways/GLBXExecutionGateway.h"
#include "lib/orderman/gateways/GLBXiLink3ExecutionGateway.h"
#include "lib/orderman/gateways/ICEExecutionGateway.h"
@@ -21,6 +22,7 @@ std::unique_ptr<IExecutionGateway> ExecutionGatewayFactory::create_gateway(
return std::make_unique<ilink3::GLBXiLink3ExecutionGateway>(conn, pl, o);
else
return std::make_unique<EMExecutionGateway>(o);
// return std::make_unique<FakeExecutionGateway>(o);
// return std::make_unique<GLBXExecutionGateway>(conn, pl, o);
}
@@ -0,0 +1,190 @@
#include "FakeExecutionGateway.h"
#include "lib/api/services/AdminService.pb.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/domain_model/common.h"
#include "lib/logging/logging.h"
#include "lib/orderman/CancelOrderMsg.h"
#include "lib/orderman/CancelReplaceOrderMsg.h"
#include "lib/orderman/CreateOrderMsg.h"
#include "lib/orderman/OrderMsg.h"
#include "lib/orderman/events/CancelRejectEvent.h"
#include "lib/orderman/events/GatewayStatusChangeEvent.h"
#include "lib/orderman/events/NewAdminDataEvent.h"
#include "lib/orderman/events/NewExecutionReportEvent.h"
#include "lib/orderman/events/NewSecuritiesEvent.h"
#include "lib/orderman/orderman_utils/ExecutionReport.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/tracing/bts_trace.h"
#include "lib/utils/Dispatcher.h"
#include "lib/utils/TimeStamp.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_chrono.h"
#include "lib/utils/helper_macros.h"
#include "server/sparkd/md/platforms/emumba/IEMOrderMuxer.h"
#include <atomic>
#include <boost/pool/object_pool.hpp>
#include <cstdint>
#include <set>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
namespace bts {
namespace orderman {
struct FakeExecutionGateway::PImpl {
PImpl(md::SecurityOracle o)
: admin_data(), connection_time(), sec_oracle(o) {
LOG(OrderMan, Info, "FakeExecutionGateway::PImpl constructor");
}
std::unordered_map<SecurityKey::Value, api::Security const *> securities;
std::unordered_map<int64_t, api::Security const *> securities_by_exchange_id;
OnExeReport on_exe_report;
OnGwStatusChange on_gw_status_change;
OnCancelReject on_cancel_reject;
api::admin::AdminData admin_data;
TimeStamp connection_time;
md::SecurityOracle sec_oracle;
std::vector<OrderMsg> buffered_msgs = {};
unsigned long exchange_oid = 0;
std::vector<ExecutionReport> exe_reports = {};
IEMOrderMuxer *_order_mux = nullptr;
};
FakeExecutionGateway::FakeExecutionGateway(md::SecurityOracle o)
: IExecutionGateway(), me(new PImpl(o)) {
LOG(OrderMan, Info,
"FakeExecutionGateway::FakeExecutionGateway constructor");
}
FakeExecutionGateway::~FakeExecutionGateway() {}
void FakeExecutionGateway::start() {
LOG(OrderMan, Info, "FakeExecutionGateway::start");
}
// this is a periodic timer
void FakeExecutionGateway::dispatch_incoming_fix_messages() {
if (me->buffered_msgs.size() == 0) {
return;
}
std::vector<OrderMsg> aux_msgs = me->buffered_msgs;
me->buffered_msgs.clear();
for (OrderMsg m : aux_msgs) {
if (std::holds_alternative<CreateOrderMsg>(m)) {
CreateOrderMsg cr_msg = std::get<CreateOrderMsg>(m);
LOG(OrderMan, Info,
"FakeExecutionGateway::dispatch_incoming_fix_message key: {} sec: "
"{} p: {} q: {}",
cr_msg.key, cr_msg.security->id(), cr_msg.price, cr_msg.quantity);
ExecutionReport er = {};
std::string account_name = "ACCA1";
std::array<char, 12> an_array = {};
size_t i = 0;
for (const char c : account_name) {
an_array[i++] = c;
}
er.account_name = AccountName(an_array);
to_array(cr_msg.routing_record->account(), &er.account_name.value());
to_array(
cr_msg.routing_record->operator_id(), &er.operator_id.value());
er.order_key = cr_msg.key;
er.msg_seq_num = 0;
er.security = cr_msg.security;
er.leg_security = nullptr;
er.side = cr_msg.side;
er.time_in_force = cr_msg.time_in_force;
er.order_type = cr_msg.order_type;
er.exec_type = api::orderman::EXEC_TYPE_NEW;
er.order_status = api::orderman::NATIVE_ORDER_STATUS_NEW;
er.manual_order_indicator = api::orderman::MANUAL_ORDER_INDICATOR_NO;
ExchangeOrderID64 eoid = ExchangeOrderID64(me->exchange_oid++);
ExchangeOrderIDVar oid = eoid;
er.exchange_order_id = oid;
er.price = cr_msg.price;
er.quantity = cr_msg.quantity;
er.filled_quantity = Quantity(0);
er.last_shares = Quantity(0);
er.msg = "Message Placed";
er.exchange = api::VENUE_SIM;
trace::CorID cid = {};
me->exe_reports.push_back(er);
const auto &er_pheap = me->exe_reports.back();
LOG(OrderMan, Info,
"FakeExecutionGateway::dispatch_incoming_fix_messages er: {}",
er_pheap.to_string());
me->on_exe_report(er_pheap, cid);
} else if (std::holds_alternative<CancelOrderMsg>(m)) {
CancelOrderMsg cxl_m = std::get<CancelOrderMsg>(m);
for (auto &er : me->exe_reports) {
if (er.order_key == cxl_m.key) {
er.order_status = api::orderman::NATIVE_ORDER_STATUS_CANCELED;
er.msg = "Cancelled";
me->on_exe_report(er, {});
LOG(OrderMan, Info,
"FakeExecutionGateway::dispatch_incoming_fix_messages er: "
"{}",
er.to_string());
return;
}
}
} else if (std::holds_alternative<CancelReplaceOrderMsg>(m)) {
CancelReplaceOrderMsg cxl_r_msg = std::get<CancelReplaceOrderMsg>(m);
CreateOrderMsg cr_msg = cxl_r_msg.create_fields;
for (auto &er : me->exe_reports) {
if (er.order_key == cr_msg.key) {
er.order_status = api::orderman::NATIVE_ORDER_STATUS_REPLACED;
er.msg = "Replaced";
er.price = cr_msg.price;
er.quantity = cr_msg.quantity;
me->on_exe_report(er, {});
return;
}
}
}
}
}
void FakeExecutionGateway::on_securities(
const mercury::Update<NewSecuritiesEvent> &) {
LOG(OrderMan, Info, "FakeExecutionGateway::on_securities");
}
void FakeExecutionGateway::on_admin_data(
const mercury::Update<NewAdminDataEvent> &update) {
LOG(OrderMan, Info, "FakeExecutionGateway::on_admin_data");
if (update.events) {
for (auto const &ev : *(update.events))
me->admin_data.CopyFrom(*ev.admin_data);
}
}
void FakeExecutionGateway::send_fix(const jetfix::OutFIXPtr &, trace::CorID) {
// only deals with messages
bts_assert(false);
}
void FakeExecutionGateway::send_msgs(
std::vector<OrderMsg> const &msg_vec, trace::CorID) {
// this is where it will be sent to the exchange
LOG(OrderMan, Info, "FakeExecutionGateway::send_msgs count: {}",
msg_vec.size());
for (auto &m : msg_vec) {
me->buffered_msgs.emplace_back(m);
}
}
OnExeReport &FakeExecutionGateway::on_exe_report() { return me->on_exe_report; }
OnGwStatusChange &FakeExecutionGateway::on_gw_status_change() {
return me->on_gw_status_change;
}
OnCancelReject &FakeExecutionGateway::on_cancel_reject() {
return me->on_cancel_reject;
}
} // namespace orderman
} // namespace bts
@@ -0,0 +1,32 @@
#pragma once
#include "IExecutionGateway.h"
namespace bts {
namespace orderman {
// Wrapper around EM's order gateway. There are fix overtones to this, that are
// ignored
class FakeExecutionGateway : public IExecutionGateway {
public:
FakeExecutionGateway(md::SecurityOracle);
virtual ~FakeExecutionGateway();
void start() override;
void dispatch_incoming_fix_messages() override;
void on_securities(const mercury::Update<NewSecuritiesEvent> &) override;
void on_admin_data(const mercury::Update<NewAdminDataEvent> &) override;
void send_fix(const jetfix::OutFIXPtr &fix, trace::CorID trace) override;
void send_msgs(std::vector<OrderMsg> const &, trace::CorID) override;
OnExeReport &on_exe_report() override;
OnGwStatusChange &on_gw_status_change() override;
OnCancelReject &on_cancel_reject() override;
private:
struct PImpl;
std::unique_ptr<PImpl> me;
};
} // namespace orderman
} // namespace bts
@@ -1,5 +1,6 @@
#include "ExecutionReport.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/logging/logging.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include <sstream>
@@ -23,7 +24,11 @@ std::string ExecutionReport::to_string() const {
<< " order_status: "
<< bts::api::orderman::NativeOrderStatus_Name(order_status)
<< " price: " << price.value() << " quantity: " << quantity.value()
<< " filled_quantity: " << filled_quantity.value();
<< " filled_quantity: " << filled_quantity.value()
<< " avg_price: " << avg_price.value()
<< " last_shares: " << last_shares.value()
<< " last_price: " << last_price.value() << " msg: " << msg
<< " exchange: " << bts::api::Venue_Name(exchange);
return rv.str();
}
+264 -244
View File
@@ -28,6 +28,7 @@
#include "lib/utils/bts_chrono.h"
#include "server/sparkd/md/platforms/emumba/EmMDListener.h"
#include <algorithm>
#include <bits/stdint-uintn.h>
#include <string>
#include <sys/time.h>
@@ -79,7 +80,7 @@ struct EMNativeOrder::PImpl {
: services(nullptr), session_services(), sec(nullptr),
previous_working_position(0), definition(), state(),
exchange_order_id() {}
bool inited = false;
OrderServices *services;
SessionServices *session_services;
@@ -97,7 +98,6 @@ struct EMNativeOrder::PImpl {
bool buffered_cancel = false;
std::optional<api::orderman::Update> buffered_update;
RoutingRecord routing_record;
bool stop_order_still_has_stop_px = true;
};
EMNativeOrder::EMNativeOrder() : me(new PImpl()) {}
@@ -108,22 +108,30 @@ api::orderman::OrderDefinition const &EMNativeOrder::definition() const {
return me->definition;
}
// Construction, the order is not yet live and it may never
// be. This can be slow. This is the first call
void EMNativeOrder::on_init_new(
api::orderman::OrderDefinition const &def,
const PreActivationOrderServices &serv) {
bts_assert(!me->inited);
me->inited = true;
LOG(OrderMan, Info,
"EMNativeOrder::on_init_new key: {} sec_key: {} user: {} account: {}",
key(), def.security_key(), def.user(), def.account());
me->definition = def;
me->sec = serv.sec_db.resolve(SecurityKey(def.security_key()));
// Check for invariants, if not met, reject the order
// 1. Sec can be resolved
// 2. Order is either Limit or Market
// 3. Routing Record can be constructed (serv.order_router.get_routing_record
// returns a valid record)
// Else, transition to ORDER_STATUS_INACTIVE, and set native strate
if (!me->sec) {
auto msg = fmt::format("Unknown security: {}", def.security_key());
me->state.set_last_msg(msg);
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
return;
}
switch (def.custom_def().custom_case()) {
case CustomOrderDefinition::kMarket:
me->state.mutable_market();
@@ -131,16 +139,12 @@ void EMNativeOrder::on_init_new(
case CustomOrderDefinition::kLimit:
me->state.mutable_limit();
break;
case CustomOrderDefinition::kStop:
case CustomOrderDefinition::kStopLimit: {
default: {
auto msg = "Order type not supported at this venue";
me->state.set_last_msg(msg);
me->state.set_last_msg("Order type not supported at this venue");
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
return;
}
default:
bts_assert(false);
break;
}
auto rq = serv.order_router.get_routing_record(
UserID(def.user_id()), AccountID(def.account_id()), *me->sec);
@@ -151,34 +155,32 @@ void EMNativeOrder::on_init_new(
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
return;
}
// this is the initial state the order starts with
// Successful order always starts in ORDER_STATUS_INACTIVE
transition(ORDER_STATUS_INACTIVE);
auto &native_state = get_native_state(me->state);
me->routing_record = rq.routing_record;
*native_state.mutable_routing_record() = rq.routing_record;
LOG(OrderMan, Info, "EMNativeOrder::on_init_new routing_record: {}",
utils::pb::to_string(me->routing_record));
LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} routing_record: {}",
key(), utils::pb::to_string(me->routing_record));
}
void EMNativeOrder::on_init_recovered(
api::orderman::OrderRecord const &rec,
const PreActivationOrderServices &serv) {
bts_assert(!me->inited);
me->inited = true;
auto const &def = rec.def();
me->definition = def;
me->state = rec.state();
me->sec = serv.sec_db.resolve(SecurityKey(def.security_key()));
me->previous_working_position = Quantity(0);
transition(
OrderStatus::ORDER_STATUS_COMPLETED, "Recoveredorders are not handled");
transition_to_error(
NativeOrderState::SUB_ERROR_UNKNOWN_SECURITY,
"EMNativeOrder - Not handling recovery yet");
OrderStatus::ORDER_STATUS_ERROR, "Recovered Orders are not handled");
}
OrderOpResult EMNativeOrder::on_activate(
Price p, Quantity q, OrderServices &services) {
bts_assert(me->inited);
LOG(OrderMan, Info, "EMNativeOrder::on_activate key: {} p: {} q: {}", key(),
p, q);
bts_assert(!me->services);
@@ -188,41 +190,31 @@ OrderOpResult EMNativeOrder::on_activate(
case ORDER_STATUS_INACTIVE: {
// this is a brand new order
// _on_activate sets the price, quantity
result = _on_activate(Warn, Info, p, q, services);
if (result.ok()) {
CreateOrderMsg c_msg = {};
_create_create_msg(c_msg);
transition(ORDER_STATUS_PENDING_WORKING);
me->services->queue_order_msg(*me->session_services, c_msg);
me->services->governor(*me->session_services).record_sent();
me->state.set_status(ORDER_STATUS_PENDING_WORKING);
LOG(OrderMan, Info,
"EMNativeOrder::on_activate sent new order with key {} to gateway",
"EMNativeOrder::on_activate sent new order with key {} to "
"gateway",
key().value());
// Early return so we skip the expensive report_state()
// call. It is OK to spkip it because we are bound to report
// our state once the excange aknowledges the order.
// call. It is OK to skip it because we are bound to report
// our state once the excange acknowledges the order.
update_working_position();
return OrderOpResult{};
} else {
report_state();
return result;
}
// When the order fails its limits checks we fall through the
// switch to report the error state at the end of this function
break;
}
// all cases below are for orders recovered from disk, since on_init_new's
// success => ORDER_STATUS_INACTIVE
case ORDER_STATUS_WORKING:
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
// control will only reach here if on_init_new failed, or it was a recocered
// order, in which case we are already in a terminal state, hence nothing to
default:
break;
}
report_state();
@@ -241,32 +233,22 @@ OrderOpResult EMNativeOrder::on_update(Price p, Quantity q) {
OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) {
LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} update: {}",
key().value(), utils::pb::to_string(update));
auto p = Price(update.price());
auto q = Quantity(update.quantity());
auto new_p = Price(update.price());
auto new_q = Quantity(update.quantity());
LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}",
key().value(), p, q);
auto scoped_log =
me->services->log_scope("NativeOrder::on_update", key().value());
key().value(), new_p, new_q);
auto result = OrderOpResult{};
// the only state where we consider an update is ORDER_STATUS_WORKING
switch (me->state.status()) {
case ORDER_STATUS_WORKING: {
auto previous_working_qty = 0;
if (me->state.quantity() > me->state.filled_quantity())
previous_working_qty =
me->state.quantity() - me->state.filled_quantity();
auto current_working_qty = 0;
if (q.value() > me->state.filled_quantity())
current_working_qty = q.value() - me->state.filled_quantity();
auto curr_working_qty = _working_qty();
auto potential_working_qty = 0;
if (new_q.value() > me->state.filled_quantity())
potential_working_qty = new_q.value() - me->state.filled_quantity();
auto lqr = me->services->limiter().can_update_order(
AccountID(me->definition.account_id()), *me->sec,
me->definition.side(), Quantity(previous_working_qty),
Quantity(current_working_qty));
me->definition.side(), Quantity(curr_working_qty),
Quantity(potential_working_qty));
// are we under the position limits?
if (!lqr.ok()) {
@@ -275,95 +257,32 @@ OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) {
LOG(OrderMan, Error,
"Order update failed due to limit breach. Order: {} Msg: {}",
key().value(), lqr.error_msg);
ignore_or_cancel(msg, ORDER_ERROR_LIMIT_BREACH, &result);
break;
}
// are we under the messaging threshold?
if (!me->services->governor(*me->session_services).can_send()) {
LOG(OrderMan, Warn,
"Cannot update order {} because of messaging limits. ",
key().value());
auto msg = "Messaging threshold breached";
ignore_or_cancel(msg, ORDER_ERROR_MESSAGING_LIMIT_BREACH, &result);
break;
}
// if (update.has_custom()) {
// bts_assert(
// update.custom().custom_case() ==
// me->definition.custom_def().custom_case());
// if (update.custom().custom_case() == CustomOrderDefinition::kStop) {
// // Stop orders do not have prices until they are triggered
// if (!stop_order_has_been_triggered()) {
// auto const &stop = update.custom().stop();
// auto stop_px = Price(stop.stop_price());
// me->definition.mutable_custom_def()
// ->mutable_stop()
// ->set_stop_price(stop_px.value());
// me->services->report_definition(me->definition);
// me->encoder->update_cancel_replace_stop_px(
// stop_px, me->price_encoding_precision);
// }
// } else if (
// update.custom().custom_case() ==
// CustomOrderDefinition::CustomOrderDefinition::kStopLimit) {
// if (!stop_order_has_been_triggered()) {
// auto const &stop_limit = update.custom().stop_limit();
// auto stop_px = Price(stop_limit.stop_price());
// me->definition.mutable_custom_def()
// ->mutable_stop_limit()
// ->set_stop_price(stop_px.value());
// me->services->report_definition(me->definition);
// me->encoder->update_cancel_replace_stop_px(
// stop_px, me->price_encoding_precision);
// }
// } else if (
// update.custom().custom_case() ==
// CustomOrderDefinition::kGlbxIceberg) {
// // GLBX Iceberg
// auto const &ib = update.custom().glbx_iceberg();
// if (ib.max_show_quantity() == 0 ||
// ib.max_show_quantity() > pow(10, max_show_sz()) - 1) {
// auto msg = fmt::format(
// "Invalid max show size: {}", ib.max_show_quantity());
// ignore_or_cancel(msg, ORDER_ERROR_INVALID_PARAMETER, &result);
// break;
// }
// me->encoder->update_cancel_replace_max_show(
// Quantity(ib.max_show_quantity()));
// }
// }
// All good
// if (is_stop_limit_order() || !is_stop_order() ||
// stop_order_has_been_triggered()) {
// // Stop orders become limit orders when triggered
// me->encoder->update_cancel_replace_encoding(
// p, me->price_encoding_precision, *me->services);
// }
CancelReplaceOrderMsg cxlr_msg = {};
_create_create_msg(cxlr_msg.create_fields);
cxlr_msg.create_fields.price = p;
cxlr_msg.create_fields.quantity = q;
me->services->queue_order_msg(*me->session_services, cxlr_msg);
CancelReplaceOrderMsg cxl_repl_msg = {};
_create_create_msg(cxl_repl_msg.create_fields);
cxl_repl_msg.create_fields.price = new_p;
cxl_repl_msg.create_fields.quantity = new_q;
me->services->queue_order_msg(*me->session_services, cxl_repl_msg);
me->services->governor(*me->session_services).record_sent();
update_working_position();
if (me->state.last_msg().size())
me->state.set_last_msg("");
// early return so we skip report_state (for speed)
// early return so we skip report_state (for speed) (an execution report
// should take care of it?)
return OrderOpResult{};
}
// the 2 other working states
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_PENDING_WORKING:
LOG(OrderMan, Warn,
@@ -371,12 +290,12 @@ OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) {
key().value(), update.quantity(), update.price());
me->buffered_update.emplace(update);
break;
// terminal states, nothing to do
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_INACTIVE:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
@@ -392,9 +311,8 @@ OrderOpResult EMNativeOrder::on_detach() { return {}; }
OrderOpResult EMNativeOrder::on_cancel() {
LOG(OrderMan, Info, "EMNativeOrder::on_cancel key: {}", key());
auto result = OrderOpResult{};
switch (me->state.status()) {
// the only state where a cancel is sent out
case ORDER_STATUS_WORKING: {
// TODO, CancelOrderMsg is not completely filled
CancelOrderMsg cxl_msg = {};
@@ -403,13 +321,12 @@ OrderOpResult EMNativeOrder::on_cancel() {
me->services->queue_order_msg(*me->session_services, cxl_msg);
break;
}
// already in a terminal state, nothing to do
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_PENDING_WORKING: {
// we buffer this, and as soon as we get the exchnage id, we cxl it
me->buffered_cancel = true;
@@ -419,7 +336,6 @@ OrderOpResult EMNativeOrder::on_cancel() {
key().value());
break;
}
case ORDER_STATUS_DISCONNECTED: {
me->buffered_cancel = true;
LOG(OrderMan, Warn,
@@ -430,6 +346,7 @@ OrderOpResult EMNativeOrder::on_cancel() {
auto msg = "Order will be canceled when re-connected";
result.error = ORDER_ERROR_GATEWAY_NOT_READY;
result.error_msg = msg;
// to print the message
transition(me->state.status(), msg);
break;
}
@@ -441,16 +358,15 @@ OrderOpResult EMNativeOrder::on_cancel() {
}
report_state();
return result;
return {};
}
void EMNativeOrder::on_attached(api::orderman::OrderDefinition const &) {
// TODO
// do nothing
}
api::orderman::OrderDefinition EMNativeOrder::on_init_from_exe_report(
ExecutionReport const &, const PreActivationOrderServices &) {
// TODO
return me->definition;
}
@@ -518,9 +434,11 @@ void EMNativeOrder::update_working_position() {
key().value(), me->definition.security_key());
}
// Returns the open position for a working order. If there are fills,
// returns the difference
Quantity EMNativeOrder::working_position() {
switch (me->state.status()) {
// working
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
@@ -528,7 +446,7 @@ Quantity EMNativeOrder::working_position() {
return Quantity(me->state.quantity() - me->state.filled_quantity());
else
return Quantity(0);
// terminal
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_COMPLETED:
@@ -556,6 +474,7 @@ OrderOpResult EMNativeOrder::_on_activate(
Price p,
Quantity q,
bts::orderman::OrderServices & /*order_services*/) {
// update state wrt price, qty, fills
me->state.set_price(p.value());
me->state.set_quantity(q.value());
me->state.set_filled_quantity(0);
@@ -566,12 +485,15 @@ OrderOpResult EMNativeOrder::_on_activate(
get_native_state(me->state).routing_record().session());
// TODO: just to get going
me->session_services = &me->services->get_session_services("sim");
// me->price_encoding_precision =
// me->services->price_encoding_precision(*me->session_services);
// is our gateway connected?
// TODO
if (false && _is_gateway_connected(me->session_services)) {
// Checks for the following:
// 1. Gateway connection
// 2. Risk (can_trade, clip, position)
// 3. Governor (orders/sec)
// If any of the above fail, it goes to terminal state
// (ORDER_STATUS_REJECTED_BY_SPARK) abd returns error
// Else, subscribes to service events (including execution report)
if (!_is_gateway_connected(me->session_services)) {
LOG(OrderMan, reject_level,
"Attempt to send order to a disconnected gateway. "
"Dropping order {}",
@@ -580,35 +502,39 @@ OrderOpResult EMNativeOrder::_on_activate(
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
return OrderOpResult{ORDER_ERROR_GATEWAY_NOT_READY, msg};
}
// this is to skip risk limits for options
bool turn_risk_off = me->sec->has_option();
// the following consults the limiter
// can the user trade ?
auto lqr = me->services->limiter().can_trade(
UserID(me->definition.user_id()),
AccountID(me->definition.account_id()));
if (turn_risk_off) {
lqr.result = Limiter::LimiterErrorCode::OK;
}
if (!lqr.ok()) {
LOG(OrderMan, reject_level,
"Unauthorized order attempted. User: {} on "
"Account: {}. Msg: {} Order: {}. Dropping order",
me->definition.user(), me->definition.account(), lqr.error_msg,
key().value());
auto msg = fmt::format("Unauthorized order: {}", lqr.error_msg);
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
return OrderOpResult{ORDER_ERROR_UNAUTHORIZED, msg};
}
// risk limits (clip size, position)
lqr = me->services->limiter().can_send_new_order(
AccountID(me->definition.account_id()), *me->sec, me->definition.side(),
q);
if (turn_risk_off) {
lqr.result = Limiter::LimiterErrorCode::OK;
}
if (!lqr.ok()) {
LOG(OrderMan, reject_level,
"New order would breach limit. User: {} Account: "
"{} Msg: {} Order: {}. Dropping order",
me->definition.user(), me->definition.account(), lqr.error_msg,
key().value());
auto msg = fmt::format("Order would breach limit: {}", lqr.error_msg);
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
return OrderOpResult{ORDER_ERROR_LIMIT_BREACH, msg};
@@ -625,7 +551,6 @@ OrderOpResult EMNativeOrder::_on_activate(
return OrderOpResult(ORDER_ERROR_MESSAGING_LIMIT_BREACH, msg);
}
// if we are here we are good.
// subscribe to usefull events
// TODO
me->exe_report_sid = me->services->subscribe_to_exe_report(
@@ -638,15 +563,13 @@ OrderOpResult EMNativeOrder::_on_activate(
// *me->session_services,
// [this](auto const &gw) { this->on_gateway_status(gw); });
// me->encoder->update_create_order_encoding(
// p, me->price_encoding_precision, q, order_services);
LOG(OrderMan, Info, "EMNativeOrder::_on_activate sucessful key: {}", key());
return OrderOpResult{};
}
// OrderState's CustomOrderState has some OrderStates' corresponding to
// NativeOrder (ex MarketOrderState, LimitOrderState etc). Each of these special
// OrderState have NativeOrderState - this function plucks that out
// OrderStates have NativeOrderState - this function plucks that out
api::orderman::NativeOrderState &EMNativeOrder::get_native_state(
api::orderman::OrderState &st) {
switch (st.custom_case()) {
@@ -689,103 +612,187 @@ void EMNativeOrder::_create_create_msg(CreateOrderMsg &c) {
c.routing_record = &me->routing_record;
}
// void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) {
// LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(),
// er.data->to_string());
// auto &state = me->state;
// auto &native_state = get_native_state(state);
// // if we have a previous state we want to ensure this execution
// // report was not already considered.
// // TODO, just id the report in EMEG
// if (_is_old_exe_report(native_state, er)) {
// LOG(OrderMan, Info,
// "Ignoring already seen execution report {} in order {}",
// er.data->msg_seq_num, key().value());
// return;
// }
// // we do not care about spread leg fills for purposes of order
// // state maintenance
// if (er.data->leg_security) {
// LOG(OrderMan, Diag, "Ignoring leg execution report for order {}",
// key().value());
// return;
// }
// native_state.set_last_msg_seq_num(er.data->msg_seq_num);
// set_last_transact_time(er.data->transact_time, &native_state);
// auto external_status = em_map_external_status(er.data->order_status);
// // filled quantity is reset back to 0 when the order is canceled
// if (external_status != ORDER_STATUS_CANCELED) {
// if (er.data->exec_type == api::orderman::EXEC_TYPE_PARTIAL_FILL ||
// er.data->exec_type == api::orderman::EXEC_TYPE_FILL) {
// bts_assert(er.data->last_shares.value());
// auto previous_avg = state.avg_price();
// auto previous_sz = state.filled_quantity();
// auto fill_price = er.data->last_price.value();
// auto fill_sz = er.data->last_shares.value();
// auto new_avg =
// ((previous_avg * previous_sz) + (fill_price * fill_sz)) /
// (previous_sz + fill_sz);
// state.set_avg_price(new_avg);
// state.set_filled_quantity(er.data->filled_quantity.value());
// state.set_last_price(er.data->last_price.value());
// }
// }
// state.set_last_msg(er.data->msg);
// native_state.set_native_status(er.data->order_status);
// native_state.set_native_type(er.data->order_type);
// native_state.set_stop_px(er.data->stop_price.value());
// // The FIX message we send for updates has to change once a stop
// // order is triggered. Post triggering we no longer can update the
// // stop px. Instead the stop order turns into a regular limit
// // order, which means we can now update the actual price.
// // TODO: stop order
// // if (is_stop_order() && stop_order_has_been_triggered() &&
// // me->stop_order_still_has_stop_px) {
// // me->stop_order_still_has_stop_px = false;
// // init_encodings();
// // }
// // bool got_first_exchange_order_id = !has_exchange_order_id();
// // if (got_first_exchange_order_id) {
// // me->exchange_order_id = er.data->exchange_order_id;
// // set_exchange_order_id(me->exchange_order_id.value(), &native_state);
// // me->encoder->update_exchange_order_id(me->exchange_order_id.value());
// // }
// if (!is_terminal_state(me->state.status())) {
// state.set_price(er.data->price.value());
// state.set_quantity(er.data->quantity.value());
// }
// switch (me->state.status()) {
// // terminal states, nothing can change them
// case ORDER_STATUS_COMPLETED:
// case ORDER_STATUS_CANCELED:
// return;
// // receiving an execution report does does not mean
// // we are connected
// case ORDER_STATUS_DISCONNECTED:
// break;
// case ORDER_STATUS_PENDING_WORKING:
// if (external_status == ORDER_STATUS_WORKING &&
// !_is_gateway_connected(me->session_services))
// transition(ORDER_STATUS_DISCONNECTED);
// else {
// transition(external_status);
// if (external_status == ORDER_STATUS_WORKING) {
// if (me->buffered_cancel) {
// LOG(OrderMan, Warn,
// "Applying buffered cancel to order {}, on first ack",
// key().value());
// on_cancel();
// } else if (me->buffered_update.has_value()) {
// auto update = me->buffered_update.value();
// me->buffered_update.reset();
// LOG(OrderMan, Warn,
// "Applying buffered update ({}@{}) to order {}, on "
// "first ack",
// update.quantity(), update.price(), key().value());
// on_update(update);
// }
// }
// }
// break;
// case ORDER_STATUS_WORKING:
// transition(external_status);
// break;
// case ORDER_STATUS_INACTIVE:
// case ORDER_STATUS_ERROR:
// case ORDER_STATUS_REJECTED_BY_SPARK:
// case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
// case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
// bts_assert(false);
// break;
// }
// report_state();
// // we only need the exhange order id and the routing record
// // reported once, since they are both immutable, so we clear them
// // after their first report to make subsquent state updates faster
// // if (got_first_exchange_order_id) {
// // native_state.clear_exchange_order_id();
// // native_state.mutable_routing_record()->Clear();
// // }
// }
void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) {
LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(),
er.data->to_string());
auto scoped_log =
me->services->log_scope("NativeOrder::on_exe_report", key().value());
auto &state = me->state;
auto &native_state = get_native_state(state);
// if we have a previous state we want to ensure this execution
// report was not already considered.
if (_is_old_exe_report(native_state, er)) {
LOG(OrderMan, Info,
"Ignoring already seen execution report {} in order {}",
er.data->msg_seq_num, key().value());
return;
}
// we do not care about spread leg fills for purposes of order
// state maintenance
if (er.data->leg_security) {
LOG(OrderMan, Diag, "Ignoring leg execution report for order {}",
key().value());
return;
}
native_state.set_last_msg_seq_num(er.data->msg_seq_num);
set_last_transact_time(er.data->transact_time, &native_state);
auto external_status = em_map_external_status(er.data->order_status);
// filled quantity is reset back to 0 when the order is canceled
if (external_status != ORDER_STATUS_CANCELED) {
if (er.data->exec_type == api::orderman::EXEC_TYPE_PARTIAL_FILL ||
er.data->exec_type == api::orderman::EXEC_TYPE_FILL) {
bts_assert(er.data->last_shares.value());
auto previous_avg = state.avg_price();
auto previous_sz = state.filled_quantity();
auto fill_price = er.data->last_price.value();
auto fill_sz = er.data->last_shares.value();
auto new_avg =
((previous_avg * previous_sz) + (fill_price * fill_sz)) /
(previous_sz + fill_sz);
state.set_avg_price(new_avg);
state.set_filled_quantity(er.data->filled_quantity.value());
state.set_last_price(er.data->last_price.value());
}
}
state.set_last_msg(er.data->msg);
native_state.set_native_status(er.data->order_status);
native_state.set_native_type(er.data->order_type);
native_state.set_stop_px(er.data->stop_price.value());
// The FIX message we send for updates has to change once a stop
// order is triggered. Post triggering we no longer can update the
// stop px. Instead the stop order turns into a regular limit
// order, which means we can now update the actual price.
// TODO: stop order
// if (is_stop_order() && stop_order_has_been_triggered() &&
// me->stop_order_still_has_stop_px) {
// me->stop_order_still_has_stop_px = false;
// init_encodings();
// }
// bool got_first_exchange_order_id = !has_exchange_order_id();
// if (got_first_exchange_order_id) {
// me->exchange_order_id = er.data->exchange_order_id;
// set_exchange_order_id(me->exchange_order_id.value(), &native_state);
// me->encoder->update_exchange_order_id(me->exchange_order_id.value());
// }
if (!is_terminal_state(me->state.status())) {
state.set_price(er.data->price.value());
state.set_quantity(er.data->quantity.value());
}
switch (me->state.status()) {
// terminal states, nothing can change them
case api::orderman::ORDER_STATUS_INACTIVE:
// as soon an order is sent we get leave this state, so there is no way we
// should get an er while in this state
bts_assert(false);
break;
// terminal state already, nothing to do
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
return;
// receiving an execution report does does not mean
// we are connected
case ORDER_STATUS_ERROR:
LOG(OrderMan, Error,
"Received er: {} for key: {} while in terminal state",
er.data->to_string(), key());
break;
// receiving an execution report does does not mean
// we are connected
case api::orderman::ORDER_STATUS_WORKING:
me->state.set_price(er.data->price.value());
me->state.set_quantity(er.data->quantity.value());
_absorb_fill(*er.data);
// this is where most of the action happens
transition(external_status);
break;
case ORDER_STATUS_DISCONNECTED:
// we only get out of this state via gw's connected event (not thorugh an
// order)
break;
case ORDER_STATUS_PENDING_WORKING:
if (external_status == ORDER_STATUS_WORKING &&
!_is_gateway_connected(me->session_services))
transition(ORDER_STATUS_DISCONNECTED);
else {
transition(external_status);
// deal with buffered operations
if (external_status == ORDER_STATUS_WORKING) {
if (me->buffered_cancel) {
LOG(OrderMan, Warn,
@@ -805,27 +812,18 @@ void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) {
}
break;
case ORDER_STATUS_WORKING:
transition(external_status);
break;
case ORDER_STATUS_INACTIVE:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
// it only gets rejected before the order is sent, so similiar to
// inactive, we should never get an er here
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
LOG(OrderMan, Info,
"EMNativeOrder::_on_exe_report calling report_state key: {} p: {} q: {}",
key(), me->state.price(), me->state.quantity());
report_state();
// we only need the exhange order id and the routing record
// reported once, since they are both immutable, so we clear them
// after their first report to make subsquent state updates faster
// if (got_first_exchange_order_id) {
// native_state.clear_exchange_order_id();
// native_state.mutable_routing_record()->Clear();
// }
}
bool EMNativeOrder::_is_old_exe_report(
@@ -893,5 +891,27 @@ void EMNativeOrder::ignore_or_cancel(
*out = {error, msg};
}
Quantity EMNativeOrder::_working_qty() const {
auto rv = Quantity(0);
if (me->state.quantity() > me->state.filled_quantity()) {
rv = Quantity(me->state.quantity() - me->state.filled_quantity());
}
return rv;
}
void EMNativeOrder::_absorb_fill(const ExecutionReport &er) {
if (me->state.filled_quantity() < er.filled_quantity.value()) {
// new fills
uint32_t last_fills =
er.filled_quantity.value() - me->state.filled_quantity();
double last_price = er.avg_price.value() * er.filled_quantity.value() -
me->state.avg_price() * me->state.filled_quantity();
last_price /= last_fills;
me->state.set_avg_price(er.avg_price.value());
me->state.set_filled_quantity(er.filled_quantity.value());
me->state.set_last_price(last_price);
}
}
} // namespace orderman
} // namespace bts
+3
View File
@@ -1,6 +1,7 @@
#pragma once
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/common.h"
#include "lib/orderman/CreateOrderMsg.h"
#include "lib/orderman/orders/NativeOrderBase.h"
#include "lib/tracing/PerfLog.h"
@@ -76,6 +77,8 @@ class EMNativeOrder : public NativeOrderBase {
bool _is_gateway_connected(SessionServices *) const;
void ignore_or_cancel(
std::string const &, api::orderman::OrderError, OrderOpResult *out);
Quantity _working_qty() const;
void _absorb_fill(const ExecutionReport &report);
};
} // namespace orderman
@@ -43,6 +43,8 @@ using namespace emumba::deribit_connector;
namespace bts::md {
std::atomic<orderman::IEMOrderMuxer *> EmMDListener::_order_mux = nullptr;
// To test order entry, reads from a file every minute. If it is different
// perform
class TempOrderGateway {
@@ -69,7 +71,14 @@ class TempOrderGateway {
return rv;
}
void act_on_last_oi() {
emumba::order_entry::order_key act_on_last_oi() {
last_oi = read_oi();
auto *po = last_oi.mutable_place_order();
po->set_instrument("BTC-24JUN22-50000-C");
po->set_price(0.080);
po->set_qty(1.0);
po->set_is_buy(true);
if (last_oi.has_place_order()) {
const auto &p_ord = last_oi.place_order();
bts_assert(!p_ord.instrument().empty());
@@ -107,6 +116,7 @@ class TempOrderGateway {
emumba::order_entry::order_key order_key =
order_gtwy->launch_new_order(my_order);
LOG(md, Info, "Order placed key: {}", order_key.value());
return order_key;
} else if (last_oi.has_modify_order()) {
const auto &m_ord = last_oi.modify_order();
emumba::order_entry::order_update ord_update;
@@ -114,11 +124,15 @@ class TempOrderGateway {
ord_update.px->from_double(m_ord.new_price());
ord_update.qty = emumba::market_data::quantity(m_ord.new_qty());
order_gtwy->update_order(ord_update);
return ord_update.ord_key;
} else if (last_oi.has_cancel_order()) {
const auto &c_ord = last_oi.cancel_order();
int64_t key = (int64_t)c_ord.order_key();
order_gtwy->cancel_order(emumba::order_entry::order_key(key));
auto em_key = emumba::order_entry::order_key(key);
order_gtwy->cancel_order(em_key);
return em_key;
}
return emumba::order_entry::order_key(0);
}
void do_work() {
@@ -331,6 +345,8 @@ struct EmMDListener::PImpl {
TempOrderGateway temp_order_gtwy = {};
MDArray bids = {};
MDArray asks = {};
orderman::OnEMOrderUpdate order_update_cb;
orderman::IEMOrderMuxerSync *order_sync;
explicit PImpl(EmumbaSecurityIndex &index_a, MDProducer &md_producer_a)
: index(index_a), md_producer(md_producer_a) {}
};
@@ -349,6 +365,38 @@ EmMDListener::EmMDListener(EmumbaSecurityIndex &index, MDProducer &md_producer)
void run(__attribute__((unused)) const std::string &config_path) {}
emumba::order_entry::order_key EmMDListener::launch_new_order(
const emumba::order_entry::new_order &order) {
const std::string &def =
std::get<std::string>(order.order_def.sec_id.value());
auto qty = std::get<double>(order.qty.value());
LOG(OrderMan, Info, "EmMDListener::launch_new_order sec: {} p: {} q: {}",
def, order.px->to_double(), qty);
return me->order_gtwy->launch_new_order(order);
}
bool EmMDListener::update_order(const emumba::order_entry::order_update &u) {
double q = std::get<double>(u.qty.value());
LOG(OrderMan, Info, "EmMDListener::update_order key: {} p: {} q: {}",
u.ord_key.value(), u.px.value().to_double(), q);
return me->order_gtwy->update_order(u);
}
bool EmMDListener::cancel_order(const emumba::order_entry::order_key &key) {
LOG(OrderMan, Info, "EmMDListener::cancel_order key: {}", key.value());
return me->temp_order_gtwy.order_gtwy->cancel_order(key);
}
void EmMDListener::register_callback(orderman::OnEMOrderUpdate &) {}
orderman::OnEMOrderUpdate &EmMDListener::order_update_cb() {
return me->order_update_cb;
}
void EmMDListener::register_order_sync(
orderman::IEMOrderMuxerSync *order_sync) {
me->order_sync = order_sync;
}
/* #region Unused functions */
// Order Entry Callbacks
void EmMDListener::on_account_summary(
@@ -371,12 +419,13 @@ void EmMDListener::on_order_update(
order_state.exchange_order_state);
LOG(OrderMan, Info,
"EmMDListener::on_order_update ec.value: {} ec.message: {} key: {} "
"exchange_key: {}"
" exchange_key: {}"
"status: {} fills: {} filled_pr: {}",
ec.value(), ec.message(), order_key.value(),
exchange_order_state.exchange_order_id,
static_cast<int>(order_state.order_status), d_qty,
order_state.avg_price.to_double());
me->order_update_cb(ec, order_key, order_state);
}
void EmMDListener::on_cancel_all_orders(
@@ -547,7 +596,7 @@ void EmMDListener::on_quote(
void _log_book(
EmumbaSecurityData *s_data, const emumba::market_data::order_book &book) {
if (s_data->handle.security().type == api::SECURITYTYPE_OPTION) {
LOG(md, Diag, "BookTop sec: {} bid: {}/{} ask: {}/{}",
LOG(md, Info, "BookTop sec: {} bid: {}/{} ask: {}/{}",
std::string(s_data->handle.security().security_desc()),
book.bids.level[0].px.to_double(), book.bids.level[0].direct_qty,
book.asks.level[0].px.to_double(), book.asks.level[0].direct_qty);
@@ -635,6 +684,7 @@ void EmMDListener::on_error(
void EmMDListener::set_handler(
emumba::deribit_connector::deribit_handler *handler,
emumba::deribit_connector::trading_session_interface *order_gtway) {
_order_mux = this;
me->handler = handler;
me->order_gtwy = order_gtway;
me->temp_order_gtwy.init(order_gtway);
@@ -1,5 +1,6 @@
#pragma once
#include "EmumbaSecurityIndex.h"
#include "IEMOrderMuxer.h"
#include "lib/domain_model/SecurityKey.h"
#include <emumba-deribit-connector/deribit_handler.h>
#include <emumba-deribit-connector/deribit_listener.h>
@@ -16,11 +17,21 @@ class MDProducer;
class FixedSecurity;
struct DescSearchResult;
class EmMDListener : public emumba::deribit_connector::deribit_listener {
class EmMDListener : public emumba::deribit_connector::deribit_listener,
public orderman::IEMOrderMuxer {
public:
EmMDListener(EmumbaSecurityIndex &index, MDProducer &md_producer);
static EmMDListener *singleton_instance();
// Run the connector
void run(const std::string &config_path);
// IEMOrderMuxer interface
emumba::order_entry::order_key launch_new_order(
const emumba::order_entry::new_order &order) override;
bool update_order(const emumba::order_entry::order_update &update) override;
bool cancel_order(const emumba::order_entry::order_key &key) override;
void register_callback(orderman::OnEMOrderUpdate &) override;
orderman::OnEMOrderUpdate &order_update_cb() override;
void register_order_sync(orderman::IEMOrderMuxerSync*) override;
// Order Entry Callbacks
void on_account_summary(
@@ -148,10 +159,12 @@ class EmMDListener : public emumba::deribit_connector::deribit_listener {
void set_handler(
emumba::deribit_connector::deribit_handler *handler,
emumba::deribit_connector::trading_session_interface *order_gtway);
static IEMOrderMuxer *order_mux() { return _order_mux; }
private:
struct PImpl;
std::unique_ptr<PImpl> me;
static std::atomic<orderman::IEMOrderMuxer *> _order_mux;
};
} // namespace bts::md
@@ -0,0 +1,34 @@
#pragma once
#include "EmumbaSecurityIndex.h"
#include <emumba-deribit-connector/deribit_handler.h>
#include <emumba-deribit-connector/deribit_listener.h>
#include <emumba-deribit-connector/order_entry_common.h>
#include <emumba-deribit-connector/trading_session_interface.h>
namespace bts::orderman {
using OnEMOrderUpdate = std::function<void(
const emumba::deribit_connector::data_types::error &,
const emumba::order_entry::order_key &,
const emumba::order_entry::order_state &)>;
class IEMOrderMuxerSync{
virtual void on_order_update(
const emumba::deribit_connector::data_types::error &,
const emumba::order_entry::order_key &,
const emumba::order_entry::order_state &) = 0;
};
class IEMOrderMuxer {
public:
virtual emumba::order_entry::order_key launch_new_order(
const emumba::order_entry::new_order &order) = 0;
virtual bool update_order(
const emumba::order_entry::order_update &update) = 0;
virtual bool cancel_order(const emumba::order_entry::order_key &key) = 0;
virtual OnEMOrderUpdate &order_update_cb() = 0;
virtual void register_callback(OnEMOrderUpdate &) = 0;
virtual void register_order_sync(IEMOrderMuxerSync*) = 0;
};
} // namespace bts::orderman