#include "py_execution_gateway_adapter.h" #include "python_interop/execution/execution_gateway.h" #include "python_interop/execution/execution_gateway_bridge.h" #include "python_interop/execution/execution_gateway_bridge_impl.h" #include "python_interop/execution/py_cancel_order_request.h" #include "python_interop/execution/py_cancel_replace_order_request.h" #include "python_interop/execution/py_create_order_request.h" #include "python_interop/execution/py_execution_gateway.h" #include "python_interop/execution/py_execution_report.h" #include "python_interop/execution/py_position_info.h" #include "python_interop/plugin_manager.h" #include "python_interop/py_contract_price_info.h" #include "python_interop/py_contract_quantity_info.h" #include "python_interop/py_contract_specification.h" #include "python_interop/py_security.h" #include "python_interop/python_object.h" #include "spark/api/domain/Venue.h" #include "spark/api/service_helpers/AdminServiceUtils.h" #include "spark/api/services/AdminService.pb.h" #include "spark/api/services/OrderService.h" #include "spark/api/services/exec_type.h" #include "spark/api/services/native_order_status.h" #include "spark/api/services/native_order_type.h" #include "spark/api/services/time_in_force.h" #include "spark/config/protos/jetfix.pb.h" #include "spark/core/time_stamp.h" #include "spark/core/start_stop_state_machine.h" #include "spark/domain/tick_utils.h" #include "spark/domain_model/Security.h" #include "spark/domain_model/Security.pb.h" #include "spark/domain_model/SecurityType.h" #include "spark/domain_model/Side.h" #include "spark/domain_model/Venue.h" #include "spark/io/json_formatter.h" #include "spark/logging/logging.h" #include "spark/logging/trace_log.h" #include "spark/md/SecurityOracle.h" #include "spark/mercury/events/Update.h" #include "spark/orderman/CancelOrderMsg.h" #include "spark/orderman/CancelReplaceOrderMsg.h" #include "spark/orderman/CreateOrderMsg.h" #include "spark/orderman/RFQMsg.h" #include "spark/orderman/events/NewAdminDataEvent.h" #include "spark/orderman/events/NewSecuritiesEvent.h" #include "spark/orderman/gateways/IExecutionGateway.h" #include "spark/orderman/log_messages/cancel_order_log.h" #include "spark/orderman/log_messages/create_order_log.h" #include "spark/orderman/log_messages/execution_report_log.h" #include "spark/orderman/log_messages/modify_order_log.h" #include "spark/orderman/orderman_utils/ExchangePosition.h" #include "spark/orderman/orderman_utils/ExecutionReport.h" #include "spark/orderman/orderman_utils/execution_report_store.h" #include "spark/orderman/orderman_utils/orderman_common.h" #include "spark/orderman/orderman_utils/simple_validation.h" #include "spark/utils/PBUtils.h" #include "spark/utils/bts_lock_guard.h" #include "spark/utils/overloaded.h" #include "spark/utils/stopwatch.h" #include "spark/utils/string_utils.h" #include "sparkd/execution/py_execution_gateway_config.h" #include #include #include #include #include #include #include namespace bts::orderman { #define ASSERT_FN(test, fn, ...) \ bts_assert_msgf(test, "PyExecutionGatewayAdapter::" fn ". " __VA_ARGS__) #define LOG_FN(level, fn, ...) \ LOG(OrderMan, level, "PyExecutionGatewayAdapter::" fn ". " __VA_ARGS__) #define DIAG_FN(fn, ...) LOG_FN(bts::Diag, fn, __VA_ARGS__) #define INFO_FN(fn, ...) LOG_FN(bts::Info, fn, __VA_ARGS__) #define WARN_FN(fn, ...) LOG_FN(bts::Warn, fn, __VA_ARGS__) #define ERROR_FN(fn, ...) LOG_FN(bts::Error, fn, __VA_ARGS__) #define _LOG(level, ...) LOG(OrderMan, level, __VA_ARGS__) #define INFO(...) _LOG(bts::Info, __VA_ARGS__) #define ERROR(...) _LOG(bts::Error, __VA_ARGS__) #define _LOG_TRACE(level, name) \ LOG_TRACE(OrderMan, level, std::string("py_exe_gw_adapt"), std::string(name)) #define INFO_TRACE(name) _LOG_TRACE(bts::Info, name) #define WARN_TRACE(name) _LOG_TRACE(bts::Warn, name) #define ERROR_TRACE(name) _LOG_TRACE(bts::Error, name) #define _LOG_TRACE_PARAMS(level, name, params) \ LOG_TRACE_PARAMS( \ OrderMan, level, std::string("py_exe_gw_adapt"), std::string(name), \ params) #define DIAG_TRACE_PARAMS(name, params) \ _LOG_TRACE_PARAMS(bts::Diag, name, params) #define WARN_TRACE_PARAMS(name, params) \ _LOG_TRACE_PARAMS(bts::Warn, name, params) #define ERROR_TRACE_PARAMS(name, params) \ _LOG_TRACE_PARAMS(bts::Error, name, params) #define INFO_TRACE_PARAMS(name, params) \ LOG_TRACE_PARAMS( \ OrderMan, bts::Info, std::string("py_exe_gw_adapt"), std::string(name), \ params) using bts::Quantity; using bts::api::security_type_parse_smart; using bts::api::SecurityType; using bts::api::Venue; using bts::api::venue_parse_smart; using bts::api::admin::BTSAccount; using bts::api::orderman::exec_type_parse_smart; using bts::api::orderman::native_order_status_parse_smart; using bts::api::orderman::time_in_force_parse_smart; using bts::core::Delegate; using bts::core::StartStopStateMachine; using bts::core::TimeStamp; using bts::md::SecurityOracle; using bts::orderman::CancelOrderMsg; using bts::orderman::CancelReplaceOrderMsg; using bts::orderman::CreateOrderMsg; using bts::orderman::ExchangeOrderID64; using bts::orderman::ExchangePosition; using bts::orderman::ExecutionReport; using bts::orderman::ExecutionReportStore; using bts::orderman::NewAdminDataEvent; using bts::orderman::NewSecuritiesEvent; using bts::orderman::OrderKey; using bts::orderman::OrderMsg; using bts::orderman::RFQMsg; using bts::system::string_utils::parse_uint; using nlohmann::json; using python_execution::ExecutionGateway; using python_execution::ExecutionGatewayBridgeImpl; using python_execution::PyCancelOrderRequest; using python_execution::PyCancelReplaceOrderRequest; using python_execution::PyCreateOrderRequest; using python_execution::PyPositionInfo; using python_interop::PluginManager; using python_interop::PythonObjectT; using std::int64_t; using std::optional; using std::shared_ptr; using std::size_t; using std::string; using std::thread; using std::uint32_t; using std::uint64_t; using std::vector; struct ExecutionGatewayCallbacks { bts::orderman::OnExeReport exe_report; bts::orderman::OnGwStatusChange gw_status_change; bts::orderman::OnCancelReject cancel_reject; bts::orderman::OnExchangePositionState exchange_position_state; bts::orderman::OnExchangeOpenOrdersState exchange_open_orders; }; struct PyExecutionGatewayAdapter::PImpl { explicit PImpl( bts::md::SecurityOracle sec_oracle, PyExecutionGatewayConfig config, bts::config::JetFIX::Connection jetfix_connection, shared_ptr plugin_man) : sec_oracle(std::move(sec_oracle)), config(std::move(config)), name(fmt::format("{}_py_gw", string{jetfix_connection.name()})), bridge_ptr(std::make_shared( jetfix_connection.name())), bridge(*bridge_ptr), plugin_man(std::move(plugin_man)), jetfix_connection(std::make_shared( std::move(jetfix_connection))), orders(this->config.account, this->jetfix_connection) { bts_assert(this->jetfix_connection->venue() != api::VENUE_UNSET); bts_assert(!this->jetfix_connection->name().empty()); pos.exchange = this->jetfix_connection->venue(); sm.set_name(name); sm.set_subsystem(bts::log::OrderMan); sm.start_core_impl.bind<&PImpl::start_impl>(*this); sm.stop_core_impl.bind<&PImpl::stop_impl>(*this); } ~PImpl() { stop(); } enum RequestType { ORDER, POSITION, }; SecurityOracle sec_oracle; PyExecutionGatewayConfig config; std::string name; std::shared_ptr bridge_ptr; ExecutionGatewayBridgeImpl &bridge; shared_ptr plugin_man; shared_ptr jetfix_connection; optional pos_snapshot_thread; optional py_thread; bool is_ready = false; bool is_ready_dirty = false; volatile bool py_keep_going = false; uint32_t n_active = 0; core::TimeStamp last_unresolved_account_log_time; StartStopStateMachine sm; // SimpleOrderKeyMap key_map; ExecutionReportStore orders; ExecutionGatewayCallbacks callbacks; ExchangePosition pos; BTSAccount account; OnExeReport exe_report_callback; void to_exe_report( bts::orderman::ExecutionReport &er, const python_execution::PyExecutionReport &pyer, std::function find_sec) { *er.order_key = pyer.key(); er.account_name->copy_from(pyer.account()); if (std::holds_alternative(er.exchange_order_id)) { std::get(er.exchange_order_id) ->copy_from(pyer.exchange_order_id()); } else { er.exchange_order_id = ExchangeOrderID{pyer.exchange_order_id()}; } native_order_type_parse_smart(pyer.order_type(), &er.order_type); native_order_status_parse_smart(pyer.order_status(), &er.order_status); time_in_force_parse_smart(pyer.time_in_force(), &er.time_in_force); exec_type_parse_smart(pyer.exec_type(), &er.exec_type); Venue venue; bts_assert(venue_parse_smart(pyer.venue(), &venue)); SecurityType sec_type; bts_assert(security_type_parse_smart(pyer.security_type(), &sec_type)); er.security = find_sec(venue, sec_type, pyer.exchange_security_id()); er.side = pyer.is_buy() ? bts::api::SIDE_BUY : bts::api::SIDE_SELL; *er.price = pyer.price(); *er.stop_price = std::numeric_limits::quiet_NaN(); er.quantity = Quantity::create_new(pyer.quantity()); *er.avg_price = pyer.avg_filled_price(); er.filled_quantity = Quantity::create_new(pyer.filled_quantity()); *er.last_price = pyer.last_filled_price(); er.last_shares = Quantity::create_new(pyer.last_filled_quantity()); er.transact_time = ExchangeTimeStamp64{static_cast(pyer.transact_time())}; } void start() { INFO_TRACE("start"); sm.start(); } // should not be called directly (use the state machine) void start_impl() { INFO_TRACE("start_impl"); bts_assert(!py_thread); py_keep_going = true; py_thread.emplace([&]() { auto orig_signal_handler = std::signal(SIGINT, SIG_DFL); std::future>> gw_fut = plugin_man->start_execution_gateway( name, config.gateway_type, bridge_ptr); gw_fut.wait(); std::signal(SIGINT, orig_signal_handler); bridge.run_py(&py_keep_going, gw_fut.get(), [&](auto callback) { plugin_man->invoke(callback); }); }); } void stop() { INFO_TRACE("stop"); sm.stop(); } void stop_impl() { INFO_TRACE("stop_impl"); py_keep_going = false; if (py_thread) { py_thread->join(); py_thread.reset(); } } void create_order(const CreateOrderMsg &m) { LOG_CREATE_ORDER(Info, m); PyCreateOrderRequest py_req; to_py(py_req, m); bridge.on_order_msg( std::make_shared(std::move(py_req))); } void update_order(const CancelReplaceOrderMsg &m) { LOG_MODIFY_ORDER(Info, m); PyCancelReplaceOrderRequest py_req; to_py(py_req, m); bridge.on_order_msg( std::make_shared(std::move(py_req))); } void cancel_order(const CancelOrderMsg &m) { LOG_CANCEL_ORDER(Info, m); PyCancelOrderRequest req; to_py(req, m); bridge.on_order_msg( std::make_shared(std::move(req))); } void on_securities(const std::vector &secs) { std::vector> py_secs; for (const auto *sec : secs) { bts::md::py_interop::PySecurity py_sec; to_py(py_sec, *sec); py_secs.push_back(std::make_shared( std::move(py_sec))); } bridge.on_securities(std::move(py_secs)); } void dispatch_is_ready() { BTS_LOCK_GUARD(sm.mutex()); if (is_ready_dirty) { is_ready_dirty = false; callbacks.gw_status_change(is_ready); } } void from_py( const python_execution::PyExecutionReport &py_er, ExecutionReport &er) const { *er.order_key = py_er.key(); bts_assert(venue_parse_smart(py_er.venue(), &er.exchange)); SecurityType sec_type; bts_assert(security_type_parse_smart(py_er.security_type(), &sec_type)); er.transact_time = ExchangeTimeStamp64{static_cast(py_er.transact_time())}; uint64_t exch_oid; if (parse_uint(py_er.exchange_order_id(), exch_oid)) { er.exchange_order_id.emplace().value() = exch_oid; } else { er.exchange_order_id.emplace().value() = py_er.exchange_order_id(); } er.security = sec_oracle.get_security( er.exchange, sec_type, py_er.exchange_security_id()); er.leg_security = nullptr; er.side = py_er.is_buy() ? api::SIDE_BUY : api::SIDE_SELL; time_in_force_parse_smart(py_er.time_in_force(), &er.time_in_force); native_order_type_parse_smart(py_er.order_type(), &er.order_type); exec_type_parse_smart(py_er.exec_type(), &er.exec_type); native_order_status_parse_smart(py_er.order_status(), &er.order_status); er.manual_order_indicator = bts::api::orderman::MANUAL_ORDER_INDICATOR_NO; er.price.value() = py_er.price(); er.quantity = py_er.quantity(); er.filled_quantity = py_er.filled_quantity(); er.last_shares = py_er.last_filled_quantity(); er.last_price.value() = py_er.last_filled_price(); er.avg_price.value() = py_er.avg_filled_price(); er.stop_price.value() = std::numeric_limits::quiet_NaN(); const string &tx_id = py_er.transact_id(); bts_assert(tx_id.size() < er.exchange_fill_id.value().max_size()); bts_assert(!py_er.transact_id().empty()); er.exchange_fill_id->copy_from(py_er.transact_id()); er.msg = py_er.error_msg(); } void to_py( bts::md::py_interop::PySecurity &py_sec, const bts::api::Security &sec) { py_sec.set_id(sec.id()); py_sec.set_asset(sec.symbol()); py_sec.set_venue(bts::api::to_pretty(sec.exchange()).name()); py_sec.set_currency(sec.currency()); // Exchange ID and name std::string name = bts::securities::descriptor(sec); py_sec.set_exchange_id(name); py_sec.set_name(std::move(name)); // Price ticks const bts::api::ContractSpecification &spec = sec.contract_spec(); md::py_interop::PyContractSpecification py_spec; md::py_interop::PyContractPriceInfo &py_price_info = py_spec.mutable_price_infos().emplace_back(); float tick_unit; float tick_base; if (!domain::get_tick_factors(spec, tick_unit, tick_base)) { WARN_FN( "on_securities", "Failed to get price tick from {} {}. spec: {}. ", sec.exchange(), py_sec.name(), utils::pb::to_string(sec.contract_spec())); tick_unit = 0.01f; tick_base = 0.01f; } py_price_info.set_tick_unit(tick_unit); py_price_info.set_tick_base(tick_base); // Quantity ticks md::py_interop::PyContractQuantityInfo &py_qty_info = py_spec.mutable_quantity_infos().emplace_back(); if (spec.quantity_infos().empty()) { tick_unit = 1.0f; tick_base = 1.0f; WARN_FN( "on_securities", "Failed to get qty tick from {} {}. spec: {}. ", sec.exchange(), name, utils::pb::to_string(sec.contract_spec())); } else { tick_unit = spec.quantity_infos(0).tick_unit(); tick_base = spec.quantity_infos(0).tick_base(); } py_qty_info.set_tick_unit(tick_unit); py_qty_info.set_tick_base(tick_base); py_sec.set_contract_spec(std::move(py_spec)); // Spot/Future/Option switch (sec.Contract_case()) { case bts::api::Security::kSpot: { py_sec.set_spot(bts::md::py_interop::PySpot{}); break; } case bts::api::Security::kFuture: { const bts::api::FutureContract &fut = sec.future(); bts::md::py_interop::PyFuture py_fut; py_fut.set_expiration(fmt::format( "{}-{:02}-{:02}", fut.expiration_year(), fut.expiration_month(), fut.expiration_day())); py_sec.set_future(std::move(py_fut)); break; } case bts::api::Security::kOption: { const bts::api::OptionContract &opt = sec.option(); bts::md::py_interop::PyOption py_opt; py_opt.set_expiration(fmt::format( "{}-{:02}-{:02}", opt.expiration_year(), opt.expiration_month(), opt.expiration_day())); py_opt.set_strike(opt.strike()); py_opt.set_is_call(opt.call_put() == bts::api::PUTORCALL_CALL); py_sec.set_option(std::move(py_opt)); break; } default: bts_assert_msg(false, "Only spots, futures, and options supported"); break; } } void to_py(PyCreateOrderRequest &py_req, const CreateOrderMsg &msg) { py_req.set_key(msg.key.value()); py_req.set_exchange_security_id(msg.security_name()); py_req.set_venue(api::to_pretty(msg.venue()).name()); py_req.set_security_type(api::to_pretty(msg.security_type()).name()); py_req.set_is_buy(msg.side == bts::api::SIDE_BUY); py_req.set_price(msg.price.value()); py_req.set_quantity(msg.quantity.full_value_float()); py_req.set_order_type( bts::api::orderman::native_order_type_name_pretty(msg.order_type)); py_req.set_time_in_force( bts::api::orderman::time_in_force_name_pretty(msg.time_in_force)); } void to_py( PyCancelReplaceOrderRequest &py_req, const bts::orderman::CancelReplaceOrderMsg &msg) { auto &cf = msg.create_fields; py_req.set_key(cf.key.value()); py_req.set_exchange_order_id( std::to_string(msg.exchange_order_id.value())); py_req.set_exchange_security_id(cf.security_name()); py_req.set_venue(api::to_pretty(cf.venue()).name()); py_req.set_security_type(api::to_pretty(cf.security_type()).name()); py_req.set_is_buy(cf.side == bts::api::SIDE_BUY); py_req.set_price(cf.price.value()); py_req.set_quantity(cf.quantity.full_value_float()); } void to_py(PyCancelOrderRequest &py_req, const CancelOrderMsg &msg) { py_req.set_key(msg.key.value()); py_req.set_exchange_order_id( std::to_string(msg.exchange_order_id.value())); py_req.set_exchange_security_id(msg.security_name()); py_req.set_venue(bts::api::to_pretty(msg.venue()).name()); py_req.set_security_type(api::to_pretty(msg.security_type()).name()); py_req.set_is_buy(msg.side == bts::api::SIDE_BUY); } void from_py( const python_execution::PyPositionInfo &py_pos_info, ExchangePosition::UnitPosition &upos) { upos.exchange_sec_desc = py_pos_info.exchange_security_id(); double long_qty = py_pos_info.long_quantity(); if (std::isnan(long_qty)) { long_qty = 0; } double long_avg_cost = py_pos_info.long_avg_cost(); if (std::isnan(long_avg_cost)) { long_avg_cost = 0; } double short_qty = py_pos_info.short_quantity(); if (std::isnan(short_qty)) { short_qty = 0; } double short_avg_cost = py_pos_info.short_avg_cost(); if (std::isnan(short_avg_cost)) { short_avg_cost = 0; } upos.position = long_qty - short_qty; // We shouldn't combine long/short positions like this. Avg cost is // lost/meaningless when the net qty is 0. if (upos.position == 0) { *upos.avg_filled_price = std::numeric_limits::quiet_NaN(); } else { *upos.avg_filled_price = (long_avg_cost * long_qty - short_avg_cost * short_qty) / (long_qty - short_qty); } } void dispatch_order_updates() { BTS_LOCK_GUARD(sm.mutex()); std::shared_ptr py_er_p; utils::Stopwatch sw; uint32_t n_dequed = 0; uint32_t n_invalid = 0; sw.start(); while (bridge.pop_exe_report(py_er_p)) { n_dequed++; const python_execution::PyExecutionReport &py_er = *py_er_p; shared_ptr er_p = orders.update(OrderKey{py_er.key()}, [&](auto &er_p, bool) { from_py(py_er, *er_p); }); const ExecutionReport &er = *er_p; string error; if (!validate(er, error)) { LOG_EXECUTION_REPORT(Error, er_p, "INVALID_STATE", error); n_invalid++; continue; } LOG_EXECUTION_REPORT(Info, er_p); switch (er.order_status) { case api::orderman::NATIVE_ORDER_STATUS_FILLED: case api::orderman::NATIVE_ORDER_STATUS_CANCELED: case api::orderman::NATIVE_ORDER_STATUS_REJECTED: { orders.erase(er.order_key); INFO_FN( "dispatch_order_updates", "Order reached terminal state {} (id={})", er.order_status, er.exchange_order_id); break; } default: break; } INFO_FN( "dispatch_order_updates", "Firing exe report callback. {} {} {} @ {} {} (filled {}/{}, " "id={}). {} active orders", er.side, er.security_name(), er.quantity, er.price, er.order_status, er.filled_quantity, er.quantity, er.order_key, orders.size()); callbacks.exe_report(er_p, {}); } sw.stop(); if (n_dequed > 0) { INFO( R"([py_exe_gw_disp_ord_stats.json]{{ "n_active": {}, "n_dequed": {}, "n_invalid": {}, "dur": {}, "ts": {} }})", orders.size(), n_dequed, n_invalid, sw.total_elapsed().nanos(), TimeStamp::now_ns()); } } void dispatch_position_updates() { BTS_LOCK_GUARD(sm.mutex()); if (account.id() == 0 || account.name().empty()) { const auto now = core::TimeStamp::now(); if ((now - last_unresolved_account_log_time) > core::TimeSpan::from_seconds(5)) { WARN_TRACE_PARAMS( "dispatch_position_updates", fmt::format( R"({{ "venue": "{}", "cfg_acc": "{}", "msg": "Waiting for admin data to get account id" }})", api::to_pretty(pos.exchange), this->config.account)); last_unresolved_account_log_time = now; } return; } vector> py_pos_infos; utils::Stopwatch sw; uint32_t n_pos_changes = 0; sw.start(); while (bridge.pop_position_info(py_pos_infos)) { for (const shared_ptr &py_pos_info_ptr : py_pos_infos) { PyPositionInfo &py_pos_info = *py_pos_info_ptr; const string &exch_sec_id = py_pos_info.exchange_security_id(); const api::Security *sec_ptr = sec_oracle.get_security(pos.exchange, exch_sec_id); if (sec_ptr == nullptr) { WARN_TRACE_PARAMS( "dispatch_position_updates", fmt::format( R"({{ "venue": "{}", "acc": "{}", "accid": "{}", "esid": "{}", "msg": "Unresolved security" }})", api::to_pretty(pos.exchange), account.name(), account.id(), exch_sec_id)); continue; } ExchangePosition::UnitPosition *upos_ptr = nullptr; for (auto &upos : pos.total_exchange_positions) { bts_assert(upos.security != nullptr); if (upos.security->id() == sec_ptr->id()) { upos_ptr = &upos; break; } } if (upos_ptr == nullptr) { upos_ptr = &pos.total_exchange_positions.emplace_back(); upos_ptr->security = sec_ptr; upos_ptr->exchange_sec_desc = exch_sec_id; upos_ptr->account_id = account.id(); upos_ptr->account_name = account.name(); } from_py(py_pos_info, *upos_ptr); n_pos_changes++; } } if (n_pos_changes > 0) { callbacks.exchange_position_state(pos); } } }; PyExecutionGatewayAdapter::PyExecutionGatewayAdapter( SecurityOracle sec_oracle, PyExecutionGatewayConfig session_cfg, bts::config::JetFIX::Connection jetfix_connection, shared_ptr plugin_man) : me(std::make_unique( std::move(sec_oracle), std::move(session_cfg), std::move(jetfix_connection), std::move(plugin_man))) { bts_assert( me->config.account.size() <= ExecutionReport{}.account_name.value().max_size()); } PyExecutionGatewayAdapter::~PyExecutionGatewayAdapter() = default; void PyExecutionGatewayAdapter::start() { me->start(); } void PyExecutionGatewayAdapter::on_securities( const bts::mercury::Update & /*update*/) { INFO_FN( "on_securities", "t_id: {} t_name: {}", bts::os::get_thread_id(), bts::os::get_thread_name()); std::vector secs = me->sec_oracle.get_securities([&](const bts::api::Security &sec) { return sec.exchange() == me->jetfix_connection->venue(); }); me->on_securities(secs); } void PyExecutionGatewayAdapter::on_admin_data( const bts::mercury::Update &update) { INFO_FN( "on_admin_data", "t_id: {} t_name: {}", bts::os::get_thread_id(), bts::os::get_thread_name()); if (update.events == nullptr) { return; } std::lock_guard lock{me->sm.mutex()}; const auto *account = bts::admin::AdminServiceUtils::find_account( *update.events->back().admin_data, me->config.account); if (account == nullptr) { WARN_FN( "on_admin_data", "Gateway account not found. Cannot execute orders. name: '{}'", me->config.account); return; } if (me->account.name() == account->name() && me->account.id() == account->id()) { return; } me->account.CopyFrom(*account); INFO_FN("on_admin_data", "Resolved gateway account '{}'", account->name()); } void PyExecutionGatewayAdapter::send_msgs( vector const &msg_vec, bts::trace::CorID) { INFO_FN("send_msgs", "count: {}", msg_vec.size()); for (const auto &msg : msg_vec) { std::visit( bts::overloaded{ [&](const CreateOrderMsg &m) { me->create_order(m); }, [&](const CancelReplaceOrderMsg &m) { me->update_order(m); }, [&](const CancelOrderMsg &m) { me->cancel_order(m); }, [&](const RFQMsg &) { bts_assert_msg( false, "PyExecutionGatewayAdapter RFQ not implemented"); }, }, msg); } } void PyExecutionGatewayAdapter::send_fix( const bts::jetfix::OutFIXPtr &, bts::trace::CorID) { bts_assert_msg(false, "ExecutionGateway does not support fix"); } void PyExecutionGatewayAdapter::dispatch_incoming_fix_messages() { me->dispatch_is_ready(); me->dispatch_order_updates(); me->dispatch_position_updates(); } // Callbacks bts::orderman::OnExeReport &PyExecutionGatewayAdapter::on_exe_report() { return me->callbacks.exe_report; } bts::orderman::OnGwStatusChange & PyExecutionGatewayAdapter::on_gw_status_change() { return me->callbacks.gw_status_change; } bts::orderman::OnCancelReject &PyExecutionGatewayAdapter::on_cancel_reject() { return me->callbacks.cancel_reject; } bts::orderman::OnExchangePositionState & PyExecutionGatewayAdapter::on_exchange_position_state() { return me->callbacks.exchange_position_state; } bts::orderman::OnExchangeOpenOrdersState & PyExecutionGatewayAdapter::on_exchange_open_orders() { return me->callbacks.exchange_open_orders; } } // namespace bts::orderman