#include "spark/lib/logging/logging.h" #include "spark/lib/orderman/orders/DynamicOrder.h" #include "spark/lib/plugin/SparkServices.h" #include "spark/lib/orderman/actors/order_manager/ChildOrder.h" #include "spark/lib/orderman/actors/order_manager/OrderBuilder.h" #include "spark/lib/orderman/orders/DynamicOrder.h" #include "spark/lib/utils/PBUtils.h" using namespace bts::api::orderman; using namespace bts::orderman; namespace bts { namespace order_example { class DynamicIcebergOrder : public DynamicOrder { public: DynamicIcebergOrder(); ~DynamicIcebergOrder(); OrderDefinition const &definition() const override; void on_init_new(OrderDefinition const &, const PreActivationOrderServices &) override; void on_init_recovered(OrderRecord const &, const PreActivationOrderServices &) override; void on_activate(Price, Quantity, OrderServices &, PerfTrace const &) override; void on_update(Price, Quantity, PerfTrace const &) override; void on_crack(PerfTrace const &) override; void on_cancel(PerfTrace const &) override; private: void report_state(); void send_next_child_order(); void merge_states(OrderState const &iceberg_state, OrderState const &child_state, OrderState *merged); void on_child_order_update(OrderStateUpdateEvent const &); void transition(OrderStatus new_state, std::string const &msg); void transition(OrderStatus new_state); struct ActiveChild; struct PImpl; std::unique_ptr me; }; struct DynamicIcebergOrder::ActiveChild { ActiveChild() {} ChildOrder order; api::orderman::OrderState state; void clear() { state = api::orderman::OrderState(); } }; struct DynamicIcebergOrder::PImpl { PImpl() : services(nullptr), child() {} OrderServices *services; api::orderman::OrderDefinition def; api::orderman::OrderState state; OrderBuilder child_builder; ActiveChild child; Quantity show_quantity; }; DynamicIcebergOrder::DynamicIcebergOrder() : me(new PImpl()) {} DynamicIcebergOrder::~DynamicIcebergOrder() {} api::orderman::OrderDefinition const &DynamicIcebergOrder::definition() const { return me->def; } void DynamicIcebergOrder::on_init_new( api::orderman::OrderDefinition const &def, const PreActivationOrderServices &services) { me->def = def; me->state.mutable_dynamic(); auto const &iceberg_def = def.custom_def().dynamic(); me->show_quantity = Quantity(iceberg_def.order_params().at("show_size").as_uint32()); auto child_def = def; *child_def.mutable_custom_def() = iceberg_def.order_params().at("child").as_order_def(); 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 DynamicIcebergOrder::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 DynamicIcebergOrder::on_activate(Price p, Quantity q, OrderServices &services, PerfTrace 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()); services.child_updates.sub( key(), [this](auto const &os) { this->on_child_order_update(os); }); transition(ORDER_STATUS_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 DynamicIcebergOrder::on_update(Price p, Quantity q, PerfTrace const &) { switch (me->state.status()) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: LOG(Plugin, Info, "Updating DynamicIceberg 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 DynamicIcebergOrder::on_crack(PerfTrace const &) {} void DynamicIcebergOrder::on_cancel(PerfTrace const &) { switch (me->state.status()) { case ORDER_STATUS_WORKING: LOG(Plugin, Info, "Canceling DynamicIceberg 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 DynamicIcebergOrder::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 DynamicIcebergOrder::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 DynamicIcebergOrder::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(); LOG(Plugin, Info, "DynamicIceberg order {} creating new child order {} with size " "{} price {}. Filled {} so far out of {}", key().value(), me->child.order.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)); } void DynamicIcebergOrder::on_child_order_update( OrderStateUpdateEvent const &ev) { switch (me->state.status()) { case ORDER_STATUS_WORKING: if (ev.key == me->child.order.key()) { me->child.state = ev.rebuild_state(); switch (me->child.state.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()) send_next_child_order(); else transition(ORDER_STATUS_COMPLETED); break; } case ORDER_STATUS_CANCELED: LOG(Plugin, Info, "Unexpected cancel of child {} in DynamicIceberg 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(Plugin, Info, "DynamicIceberg order {} received update for non active child " "order{} . update state = {} ", key().value(), me->child.order.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 DynamicIcebergOrder::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(Plugin, Info, "Transitioning dynamic iceberg order {} from {} to {}. Msg: {}", key().value(), from, to, msg); me->state.set_last_msg(msg); me->state.set_status(new_status); } void DynamicIcebergOrder::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 dynamic iceberg order {} from {} to {}", key().value(), from, to); me->state.set_status(new_status); } } // namespace order_example } // namespace bts DynamicOrderDescriptor get_dynamic_iceberg_order_desc() { DynamicOrderDescriptor desc; // order type name desc.set_dynamic_order_type("DynamicIcebergOrder"); // show size auto param = desc.add_param_desc(); param->set_param_name("show_size"); param->mutable_param_type()->set_primitive(DYNAMIC_ORDER_PRIMITIVE_UINT); // child order param = desc.add_param_desc(); param->set_param_name("child"); param->mutable_param_type()->set_primitive(DYNAMIC_ORDER_PRIMITIVE_ORDER_DEF); return desc; } extern "C" void init_spark_plugin(bts::SparkServices &serv) { using namespace bts; serv.register_dynamic_order(get_dynamic_iceberg_order_desc(), []() { return std::make_unique(); }); LOG(Plugin,Info, "Initialized order_plugin_example.so"); }