Files
spark/src/sdk/examples/order_plugin_example.cpp
T
2018-11-13 22:41:54 +00:00

386 lines
12 KiB
C++

#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<PImpl> 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<bts::order_example::DynamicIcebergOrder>(); });
LOG(Plugin,Info, "Initialized order_plugin_example.so");
}