Deribit orders (mostly) work
This commit is contained in:
1 parent
32c4d05106
commit
64240c5f3b
15 files changed
+889
-327
No files matched your search
@@ -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,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,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;
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
Reference in new issue
Block a user