Changed dynamic order example to use a Join and the new API.

This commit is contained in:
Pedro Pinto committed 2019-04-26 13:16:42 -04:00
1 parent 85b6103944
commit 992b64c08a
8 files changed
+355 -358

No files matched your search

+281 -339
View File
@@ -1,12 +1,13 @@
#include "lib/config/config.h"
#include "lib/config/protos/system.pb.h"
#include "spark/lib/logging/logging.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/config/config.h"
#include "spark/lib/config/protos/system.pb.h"
#include "spark/lib/domain_model/Security.h"
#include "spark/lib/orderman/orders/algo/IAlgoOrder.h"
#include "spark/lib/orderman/orders/algo/IAlgoServices.h"
#include "spark/lib/plugin/SparkServices.h"
#include "spark/lib/orderman/order_factory/IOrderFactory.h"
#include "spark/lib/orderman/orderman_utils/Book.h"
#include "spark/lib/utils/PBUtils.h"
#include "spark/lib/orderman/orders/PreActivationOrderServices.h"
using namespace bts::api::orderman;
using namespace bts::orderman;
@@ -14,374 +15,315 @@ using namespace bts::orderman;
namespace bts {
namespace order_example {
class DynamicIcebergOrder : public DynamicOrder {
// Join starts working N ticks away from the market (usually) and then
// watches for the opposite inside to become same side inside market;
// if there is then enough size on that market, it will join.
class DynamicJoin : public IAlgoOrder {
public:
DynamicIcebergOrder();
~DynamicIcebergOrder();
OrderDefinition const &definition() const;
void on_init_new(OrderDefinition const &,
const PreActivationOrderServices &) override;
void on_init_recovered(OrderRecord const &,
const PreActivationOrderServices &) override;
OrderOpResult on_activate(Price, Quantity, OrderServices &) override;
OrderOpResult on_update(Price, Quantity) override;
OrderOpResult on_cancel() override;
DynamicJoin();
~DynamicJoin();
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_book(SecurityKey, Book const &) override;
void on_child_change(OrderKey, ChildState 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;
enum class Status;
struct PImpl;
std::unique_ptr<PImpl> me;
IAlgoServices &algo_services() const;
void try_to_join();
};
struct DynamicIcebergOrder::ActiveChild {
ActiveChild() {}
ChildOrder order;
api::orderman::OrderState state;
void clear() { state = api::orderman::OrderState(); }
// The tree stages our algo goes through. We start by waiting to
// observe the book for our security (WAITING_FOR_MD). Once we have a
// book we use it to derive our target price and we continue to
// monitor the book to see if we should join the market
// (WAITING_TO_JOIN). Once the size and price constraints are met we
// jump to the target price and (JOINED). We remain in the JOINED
// state until our order is filled or canceled.
enum class DynamicJoin::Status { WAITING_FOR_MD, WAITING_TO_JOIN, JOINED };
// All state information needed for this algo
struct DynamicJoin::PImpl {
IAlgoServices *algo_services;
Quantity min_quantity_to_join;
Status status = Status::WAITING_FOR_MD;
OrderKey child_key = null_order_key();
ChildTemplate *child_template = nullptr;
Book book_at_inception;
Book last_book;
};
struct DynamicIcebergOrder::PImpl {
PImpl() : services(nullptr), child() {}
DynamicJoin::DynamicJoin() : me(new PImpl()) {}
DynamicJoin::~DynamicJoin() {}
IAlgoServices &DynamicJoin::algo_services() const { return *me->algo_services; }
OrderServices *services;
api::orderman::OrderDefinition def;
api::orderman::OrderState state;
OrderBuilder child_builder;
ActiveChild child;
Quantity show_quantity;
};
// This is called outside of the latency sensitive path
// once. Expensive initialization should be done here, rather than the
// in do_launch()
OrderOpResult DynamicJoin::do_before_launch(IBeforeLaunchAlgoServices &serv) {
auto &def = serv.definition();
bts_assert(def.has_custom_def());
bts_assert(def.custom_def().has_dynamic());
DynamicIcebergOrder::DynamicIcebergOrder() : me(new PImpl()) {}
DynamicIcebergOrder::~DynamicIcebergOrder() {}
api::orderman::OrderDefinition const &DynamicIcebergOrder::definition() const {
return me->def;
}
// Validate our parameters, returning an error if we find a
// problem. If an error is returned here the order will be
// abandoned.
auto &params = def.custom_def().dynamic().order_params();
auto mqi = params.find("Min Quantity");
if (mqi == params.end() || mqi->second.as_uint32() == 0)
return OrderOpResult{
ORDER_ERROR_INVALID_ORDER_DEFINITON,
"Min Quantity parameter must be defined and non zero"};
void DynamicIcebergOrder::on_init_new(
api::orderman::OrderDefinition const &def,
const PreActivationOrderServices &services) {
me->def = def;
me->state.mutable_dynamic();
me->min_quantity_to_join = Quantity(mqi->second.as_uint32());
auto const &iceberg_def = def.custom_def().dynamic();
me->show_quantity =
Quantity(iceberg_def.order_params().at("show_size").as_uint32());
if (!serv.is_attaching()) {
// If we are not attaching, create a child template so we can
// quickly launch our child when the time comes.
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.order_factory,
std::max((size_t)1, (size_t)(me->show_quantity).value() / 10));
transition(ORDER_STATUS_INACTIVE);
// We will be sending a limit order with the same side,
// security, trader, account, etc, as this algo order, so just
// copy our definition to the child definition to start with.
auto child_def = def;
// Now add a limit order component to mark our child as a limit
// order. Limit orders do not require any extra parameters
// beyond those already inherited from this algo order
// (i.e. beyond what we obtained through serv.definition()) so
// we can just use a default constructed LimitOrderDefinition.
*child_def.mutable_custom_def()->mutable_limit() = LimitOrderDefinition{};
// Now just build and cache the order template for future use
me->child_template = &(serv.make_child_template(child_def));
} 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);
// If we are attaching to an existing order then we do not need
// to spawn a new child, so there is nothing to do here.
}
// All is good, return a default constructed OrderOpResult which
// indicates success.
return {};
}
void DynamicIcebergOrder::on_init_recovered(
api::orderman::OrderRecord const &rec, const PreActivationOrderServices &) {
auto const &def = rec.def();
me->def = def;
me->state = rec.state();
// Called in the latency sensitive path, once, when the algo is first
// launched.
void DynamicJoin::do_launch(IAlgoServices &services) {
// Cache our algo services
me->algo_services = &services;
switch (me->state.status()) {
LOG(OrderMan, Diag, "Lauching DynamicJoin k: {} ",
algo_services().order_key().value());
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;
// Launch our child order
me->child_key =
services.launch_child(*me->child_template, algo_services().price(),
algo_services().quantity());
// Subscribe to market data
services.subscribe_book(SecurityKey(algo_services().security().id()));
}
// Called in the latency sensitive path, once, when the algo is first
// launched. In this case the algo is provided with an existing order
// it is now responsible for managing.
void DynamicJoin::do_launch_attached(IAlgoServices &services,
OrderKey attached_order, ChildState st) {
// The order was launched and attached to an existing order, with
// key k and current state st
// Cache our algo services
me->algo_services = &services;
LOG(OrderMan, Diag,
"Lauching DynamicJoin k: {} Attached to existing order: {}",
algo_services().order_key().value(), attached_order.value());
// Cache the key of the attached order we will be managing
me->child_key = attached_order;
// Subscribe to market data
services.subscribe_book(SecurityKey(services.security().id()));
// Simulate a child change so we can update our own state to
// reflect that of the child order we attached to. From this point
// forward there is no distinction between an algo instance that
// spawned a child and one that attached to an existing order.
on_child_change(attached_order, st);
}
// Called when a human (or a supervising algo) updates a parameter for
// this algo. The implementation should validate the update and
// depending on the validation outcome either apply the update or
// terminate the algo.
void DynamicJoin::do_update(api::orderman::Update const &update) {
LOG(OrderMan, Diag, "DynamicJoin k: {} receiving update: {}",
algo_services().order_key().value(), utils::pb::to_string(update));
// Validate update
if (update.quantity() == 0) {
// An invalid update has been detected so we terminate the
// algo, signaling an error. Any child orders launched by
// this algo will also be terminated.
algo_services().terminate_error("Invalid update");
return;
}
// 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;
}
}
// Updates have two parts, a standard part consisting of price and
// size and present in all updates, and an optional part that is
// specific to the algo in question. Below we check for the
// existance of this optional part and validate if present.
bool has_new_min_qty = false;
if (update.has_custom()) {
auto &params = update.custom().dynamic().order_params();
auto mqi = params.find("Min Quantity");
OrderOpResult DynamicIcebergOrder::on_activate(Price p, Quantity q,
OrderServices &services) {
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.subscribe_to_child_updates(
[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();
return OrderOpResult();
}
OrderOpResult DynamicIcebergOrder::on_update(Price p, Quantity q) {
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();
return OrderOpResult();
}
OrderOpResult DynamicIcebergOrder::on_cancel() {
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();
return OrderOpResult();
}
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()));
if (mqi == params.end() || mqi->second.as_uint32() == 0) {
algo_services().terminate_error(
"Minimum quantity to join must be greater than 0");
return;
}
break;
has_new_min_qty = true;
me->min_quantity_to_join = Quantity(mqi->second.as_uint32());
}
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_COMPLETED:
break;
// Update is good, forward it to our child
Update child_update;
child_update.set_price(update.price());
child_update.set_quantity(update.quantity());
algo_services().update_child(me->child_key, child_update);
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);
// Try to join again if conditions changed
if (me->status == Status::WAITING_TO_JOIN && has_new_min_qty)
try_to_join();
}
// Called when the book for the specified security has changed
void DynamicJoin::on_book(SecurityKey, Book const &b) {
// Cache the book, so we can reffer to it in the event of a
// parameter change that might allow us to join
me->last_book = b;
LOG(OrderMan, Diag, "DynamicJoin order {} on book. BID: {}@{} ASK: {}@{}",
algo_services().order_key().value(), b.side(api::SIDE_BUY)[0].size(),
b.side(api::SIDE_BUY)[0].price(), b.side(api::SIDE_SELL)[0].size(),
b.side(api::SIDE_SELL)[0].price());
switch (me->status) {
case Status::WAITING_FOR_MD: {
auto other_side =
securities::other_side(algo_services().definition().side());
auto &other_side_top = me->last_book.side(other_side)[0];
if (other_side_top.size() > 0) {
// First time we get the opposite side market, we will use
// this price as the target price to join at
me->status = Status::WAITING_TO_JOIN;
me->book_at_inception = b;
LOG(OrderMan, Diag,
"JoinOrder order {} receiving first book: {} Target: {}",
algo_services().order_key().value(),
me->min_quantity_to_join.value(), other_side_top.price());
try_to_join();
}
} break;
case Status::JOINED:
// Nothing to do at this point
break;
case Status::WAITING_TO_JOIN:
// Check if reached the target
try_to_join();
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);
// Given the current book, our target price and our min quantity
// parameter, check if its time to join
void DynamicJoin::try_to_join() {
bts_assert(me->status == Status::WAITING_TO_JOIN);
auto my_side = algo_services().definition().side();
auto other_side = securities::other_side(my_side);
auto &my_side_psz = me->last_book.side(my_side)[0];
auto &opposite_at_inception_psz = me->book_at_inception.side(other_side)[0];
if (my_side_psz.size() &&
my_side_psz.size() >= me->min_quantity_to_join.value() &&
securities::is_equal_or_better(
my_side, Price(my_side_psz.price()),
Price(opposite_at_inception_psz.price()))) {
// Time to update our child to join the market
Update child_update;
child_update.set_price(my_side_psz.price());
child_update.set_quantity(algo_services().quantity().value());
algo_services().update_child(me->child_key, child_update);
me->status = Status::JOINED;
LOG(OrderMan, Diag, "DynamicJoin order {} joined: {}@{}",
algo_services().order_key().value(),
algo_services().quantity().value(), my_side_psz.price());
} else {
LOG(OrderMan, Diag,
"JoinOrder order {} still waiting to join. Order: {}@{} Top of "
"the book: {}@{} Target: {}@{}",
algo_services().order_key().value(),
algo_services().quantity().value(), algo_services().price().value(),
my_side_psz.size(), my_side_psz.price(),
me->min_quantity_to_join.value(), opposite_at_inception_psz.price());
}
}
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);
}
// Our child reported a change:
void DynamicJoin::on_child_change(OrderKey, ChildState const &st) {
// Our fill quantity and price is always a reflection of our
// child's state
algo_services().update_fill_state(st.total_fills, st.last_price);
} // namespace order_example
} // namespace bts
DynamicOrderDescriptor get_dynamic_iceberg_order_desc() {
DynamicOrderDescriptor desc;
// order type name
desc.set_dynamic_order_type("dice");
// 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;
switch (st.status) {
case ChildStatus::WORKING:
// Child order is still working, nothing to do
return;
case ChildStatus::COMPLETED:
// Child order completed, we should also complete
algo_services().complete();
return;
case ChildStatus::CANCELED:
// Child order unexpectedly canceled, signal an error and
// terminate
algo_services().terminate_error("Unexpected child cancel");
return;
}
}
extern "C" void init_spark_plugin(bts::SparkServices &serv) {
using namespace bts;
if (config::get<config::DeploymentType>().type() == "dev") {
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");
}
// Describe our new algo order so that Spark can generate a GUI for
// it.
DynamicOrderDescriptor join_desc;
// Start by naming our order type
join_desc.set_dynamic_order_type("dyn join");
// Now add a single unsigned int parameter, Min Quantity, that will
// determine the minimum quantity that must exist in the book in
// order for us to join the market.
auto param = join_desc.add_param_desc();
param->set_param_name("Min Quantity");
param->mutable_param_type()->set_primitive(DYNAMIC_ORDER_PRIMITIVE_UINT);
// Associate the descriptor with a builder function and register
// that with the Spark server.
serv.register_dynamic_algo_order(
join_desc, []() { return std::make_unique<DynamicJoin>(); });
}
} // namespace order_example
} // namespace bts