350 lines
11 KiB
C++
350 lines
11 KiB
C++
#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 <algorithm>
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
using namespace api::orderman;
|
|
|
|
struct IcebergOrder::ActiveChild {
|
|
ActiveChild() {}
|
|
ChildOrder order;
|
|
api::orderman::OrderState state;
|
|
void clear() { state = api::orderman::OrderState(); }
|
|
};
|
|
|
|
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 = 60;
|
|
//config::get<config::OrdermanCfg>().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();
|
|
LOG(OrderMan, Info,
|
|
"Iceberg 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), trace::CorID());
|
|
}
|
|
|
|
void IcebergOrder::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 (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.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 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
|