#include "IcebergOrder.h" #include "lib/config/config.h" #include "lib/config/protos/orderman_cfg.pb.h" #include "lib/logging/logging.h" #include "lib/mercury/events/TimerEvent.h" #include "lib/orderman/actors/order_manager/OrderBuilder.h" #include "lib/utils/PBUtils.h" #include "lib/utils/bts_chrono.h" #include namespace bts { namespace orderman { using namespace api::orderman; struct IcebergOrder::ActiveChild { ActiveChild() {} ChildOrder order; api::orderman::OrderState state; OrderKey key; void clear() { state = api::orderman::OrderState(); key = null_order_key(); } }; enum class IcebergOrder::WorkingSubStatus { WORKING, PAUSED }; struct IcebergOrder::PImpl { PImpl() : services(nullptr), child(), working_sub_status(WorkingSubStatus::PAUSED), start_of_pause(Timer::now()) {} OrderServices *services; api::orderman::OrderDefinition def; api::orderman::OrderState state; OrderBuilder child_builder; ActiveChild child; Quantity show_quantity; WorkingSubStatus working_sub_status; TimeStamp start_of_pause; uint32_t pause_between_orders; }; IcebergOrder::IcebergOrder() : me(new PImpl()) {} IcebergOrder::~IcebergOrder() {} api::orderman::OrderDefinition const &IcebergOrder::definition() const { return me->def; } void IcebergOrder::on_init_new(api::orderman::OrderDefinition const &def, const PreActivationOrderServices &services) { me->def = def; me->state.mutable_iceberg(); auto const &iceberg_def = def.custom_def().iceberg(); me->show_quantity = Quantity(iceberg_def.show_quantity()); me->pause_between_orders = config::get().default_iceberg_pause_secs(); auto child_def = def; *child_def.mutable_custom_def() = iceberg_def.child(); if (me->show_quantity.value() != 0) { me->child_builder = OrderBuilder( key(), child_def, services, std::max((size_t)1, (size_t)(me->show_quantity).value() / 10)); transition(ORDER_STATUS_INACTIVE); } else { auto msg = fmt::format("Show quantity must be greater than 0"); me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); } } void IcebergOrder::on_init_recovered(api::orderman::OrderRecord const &rec, const PreActivationOrderServices &) { auto const &def = rec.def(); me->def = def; me->state = rec.state(); switch (me->state.status()) { case ORDER_STATUS_WORKING: case ORDER_STATUS_DISCONNECTED: { auto msg = "System restarted with active iceberg order"; me->state.set_last_msg(msg); transition(ORDER_STATUS_ERROR, msg); break; } // terminal states case ORDER_STATUS_ERROR: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: break; case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } void IcebergOrder::on_activate(Price p, Quantity q, OrderServices &services, trace::CorID const &) { bts_assert(!me->services); me->services = &services; me->child_builder.activate(services); switch (me->state.status()) { case ORDER_STATUS_INACTIVE: me->state.set_price(p.value()); me->state.set_quantity(q.value()); if (me->pause_between_orders) services.subscribe_to_time( [this](auto const &time) { this->on_time(time); }); services.subscribe_to_child_updates( [this](auto const &os) { this->on_child_order_update(os); }); transition(ORDER_STATUS_WORKING); me->working_sub_status = WorkingSubStatus::WORKING; send_next_child_order(); break; // these are not possible since the on_init_recovered code // would have transitioned us to error already case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: { bts_assert(false); break; } // terminal states case ORDER_STATUS_ERROR: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: break; case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); } void IcebergOrder::on_update(Price p, Quantity q, trace::CorID const &) { switch (me->state.status()) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: LOG(OrderMan, Info, "Updating Iceberg order {} to price {} quantity {}", key().value(), p.value(), q.value()); me->state.set_price(p.value()); me->state.set_quantity(q.value()); break; case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: transition(me->state.status(), "Cannot update order"); break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); } void IcebergOrder::on_crack(trace::CorID const &) {} void IcebergOrder::on_cancel(trace::CorID const &) { switch (me->state.status()) { case ORDER_STATUS_WORKING: LOG(OrderMan, Info, "Canceling Iceberg Order {}", key().value()); me->child.order.cancel(); transition(ORDER_STATUS_CANCELED); break; case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: transition(me->state.status(), "Cannot cancel order"); break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); } void IcebergOrder::transition(api::orderman::OrderStatus new_status, std::string const &msg) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); LOG(OrderMan, Info, "Transitioning iceberg order {} from {} to {}. Msg: {}", key().value(), from, to, msg); me->state.set_last_msg(msg); me->state.set_status(new_status); } void IcebergOrder::transition(api::orderman::OrderStatus new_status) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); LOG(OrderMan, Info, "Transitioning iceberg order {} from {} to {}", key().value(), from, to); me->state.set_status(new_status); } void IcebergOrder::report_state() { if (me->child.state.filled_quantity()) { api::orderman::OrderState merged_state; merge_states(me->state, me->child.state, &merged_state); me->services->report_state(merged_state); } else me->services->report_state(me->state); } void IcebergOrder::merge_states(api::orderman::OrderState const &iceberg_state, api::orderman::OrderState const &child_state, api::orderman::OrderState *merged) { auto child_order_fills = child_state.filled_quantity(); auto child_order_avg_price = child_state.avg_price(); auto child_order_last_price = child_state.last_price(); auto iceberg_fills = iceberg_state.filled_quantity(); auto iceberg_avg_price = iceberg_state.avg_price(); *merged = iceberg_state; merged->set_filled_quantity(child_order_fills + iceberg_fills); merged->set_last_price(child_order_last_price); merged->set_avg_price((child_order_fills * child_order_avg_price + iceberg_fills * iceberg_avg_price) / (child_order_fills + iceberg_fills)); } void IcebergOrder::send_next_child_order() { bts_assert(me->state.quantity() > me->state.filled_quantity()); auto remaining = me->state.quantity() - me->state.filled_quantity(); auto to_send = std::min(remaining, me->show_quantity.value()); me->child.order = me->child_builder.build(); me->child.key = me->child.order.key(); LOG(OrderMan, Info, "Iceberg order {} creating new child order {} with size " "{} price {}. Filled {} so far out of {}", key().value(), me->child.key.value(), to_send, me->state.price(), me->state.filled_quantity(), me->state.quantity()); me->child.order.activate(Price(me->state.price()), Quantity(to_send), trace::CorID()); } void IcebergOrder::on_child_order_update(OrderStateUpdateEvent const &ev) { switch (me->state.status()) { case ORDER_STATUS_WORKING: if (ev.key == me->child.key) { me->child.state = ev.rebuild_state(); switch (ev.status) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: // nothing to do but report new state break; case ORDER_STATUS_COMPLETED: { api::orderman::OrderState merged_state; merge_states(me->state, me->child.state, &merged_state); me->state = merged_state; me->child.clear(); if (me->state.quantity() > me->state.filled_quantity()) { if (me->pause_between_orders) { me->working_sub_status = WorkingSubStatus::PAUSED; me->start_of_pause = Timer::now(); } else send_next_child_order(); } else transition(ORDER_STATUS_COMPLETED); break; } case ORDER_STATUS_CANCELED: LOG(OrderMan, Info, "Unexpected cancel of child {} in Iceberg Order {}. Canceling " "parent", ev.key.value(), key().value()); transition(ORDER_STATUS_CANCELED); break; case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_ERROR: me->child.clear(); transition(ORDER_STATUS_ERROR, "Unexpected child order state"); break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } else { LOG(OrderMan, Info, "Iceberg order {} received update for non active child order {}." "update state = {}", key().value(), me->child.key.value(), utils::pb::to_string(ev.rebuild_state())); } break; case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_COMPLETED: break; case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); } void IcebergOrder::on_time(mercury::TimerEvent const &t) { bts_assert(me->pause_between_orders); if (sec_diff(t.ts, me->start_of_pause) >= me->pause_between_orders && me->state.status() == ORDER_STATUS_WORKING && me->working_sub_status == WorkingSubStatus::PAUSED) { me->working_sub_status = WorkingSubStatus::WORKING; send_next_child_order(); } } } // namespace orderman } // namespace bts