Files
spark/src/lib/orderman/orders/IcebergOrder.cpp
T
2019-01-18 18:37:32 -05:00

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