diff --git a/src/lib/orderman/order_factory/DynamicAlgoBuilder.h b/src/lib/orderman/order_factory/DynamicAlgoBuilder.h new file mode 100644 index 000000000..f79c27296 --- /dev/null +++ b/src/lib/orderman/order_factory/DynamicAlgoBuilder.h @@ -0,0 +1,12 @@ +#pragma once + +#include +#include + +namespace bts { +namespace orderman { + +class IAlgoOrder; +using DynamicAlgoBuilder = std::function()>; + +}} diff --git a/src/lib/orderman/order_factory/DynamicOrderRegistry.cpp b/src/lib/orderman/order_factory/DynamicOrderRegistry.cpp index df2f1b71c..1bc03ad39 100644 --- a/src/lib/orderman/order_factory/DynamicOrderRegistry.cpp +++ b/src/lib/orderman/order_factory/DynamicOrderRegistry.cpp @@ -1,5 +1,7 @@ #include "DynamicOrderRegistry.h" #include "lib/orderman/orders/DynamicOrder.h" +#include "lib/orderman/orders/algo/AlgoWrapperOrder.h" +#include "lib/orderman/orders/algo/IAlgoOrder.h" #include @@ -22,6 +24,16 @@ void DynamicOrderRegistry::register_dynamic_order( me->dyn_orders[desc.dynamic_order_type()] = std::make_pair(b, desc); } +void DynamicOrderRegistry::register_dynamic_algo_order( + api::orderman::DynamicOrderDescriptor const &desc, + DynamicAlgoBuilder const &b) { + auto order_builder = [b]() { + return std::make_unique(b()); + }; + me->dyn_orders[desc.dynamic_order_type()] = + std::make_pair(order_builder, desc); +} + std::unique_ptr DynamicOrderRegistry::build(std::string const &dynamic_order_type) const { auto it = me->dyn_orders.find(dynamic_order_type); diff --git a/src/lib/orderman/order_factory/DynamicOrderRegistry.h b/src/lib/orderman/order_factory/DynamicOrderRegistry.h index be39a26e0..835503012 100644 --- a/src/lib/orderman/order_factory/DynamicOrderRegistry.h +++ b/src/lib/orderman/order_factory/DynamicOrderRegistry.h @@ -1,27 +1,37 @@ #pragma once +#include "lib/orderman/order_factory/DynamicAlgoBuilder.h" #include "lib/orderman/order_factory/DynamicOrderBuilder.h" + #include "lib/api/services/OrderService.pb.h" namespace bts { namespace orderman { - class DynamicOrderRegistry { -public: + public: DynamicOrderRegistry(); ~DynamicOrderRegistry(); - - void register_dynamic_order(api::orderman::DynamicOrderDescriptor const&desc, - DynamicOrderBuilder const&builder); + + // deprecated + void + register_dynamic_order(api::orderman::DynamicOrderDescriptor const &desc, + DynamicOrderBuilder const &builder); + + void register_dynamic_algo_order( + api::orderman::DynamicOrderDescriptor const &desc, + DynamicAlgoBuilder const &builder); // can return a null if no such order type exists - std::unique_ptr build(std::string const&dynamic_order_type) const; + std::unique_ptr build(std::string const &dynamic_order_type) const; - std::vector get_all_dynamic_order_types() const; -private: + std::vector + get_all_dynamic_order_types() const; + + private: struct PImpl; - std::unique_ptr me; + std::unique_ptr me; }; -}} +} // namespace orderman +} // namespace bts diff --git a/src/lib/plugin/SparkServices.cpp b/src/lib/plugin/SparkServices.cpp index 2c2a0537a..b3c74fae3 100644 --- a/src/lib/plugin/SparkServices.cpp +++ b/src/lib/plugin/SparkServices.cpp @@ -11,16 +11,22 @@ struct SparkServices::PImpl { }; SparkServices::SparkServices(orderman::DynamicOrderRegistry &r) - : me(new PImpl(r)) {} + : me(new PImpl(r)) {} SparkServices::~SparkServices() {} void SparkServices::register_dynamic_order( - api::orderman::DynamicOrderDescriptor const &desc, - std::function()> const &builder) { + api::orderman::DynamicOrderDescriptor const &desc, + std::function()> const &builder) { me->dyn_order_registry.register_dynamic_order(desc, builder); } +void SparkServices::register_dynamic_algo_order( + api::orderman::DynamicOrderDescriptor const &desc, + std::function()> const &builder) { + me->dyn_order_registry.register_dynamic_algo_order(desc, builder); +} + extern "C" void initialize_spark_plugin(SparkServices &) {} } // namespace bts diff --git a/src/lib/plugin/SparkServices.h b/src/lib/plugin/SparkServices.h index f40bf533f..70de0c9cf 100644 --- a/src/lib/plugin/SparkServices.h +++ b/src/lib/plugin/SparkServices.h @@ -9,6 +9,7 @@ namespace bts { namespace orderman { class Order; +class IAlgoOrder; class DynamicOrderRegistry; } // namespace orderman @@ -21,6 +22,9 @@ class SparkServices { api::orderman::DynamicOrderDescriptor const &desc, std::function()> const &builder); + void register_dynamic_algo_order( + api::orderman::DynamicOrderDescriptor const &desc, + std::function()> const &builder); private: struct PImpl; std::unique_ptr me; diff --git a/src/lib/plugin/plugin.cpp b/src/lib/plugin/plugin.cpp index 67e1ab16e..5cab0e815 100644 --- a/src/lib/plugin/plugin.cpp +++ b/src/lib/plugin/plugin.cpp @@ -1,14 +1,14 @@ #include "lib/logging/logging.h" -#include "lib/logging/logging.h" #include "lib/orderman/actors/order_manager/OrderBuilder.h" -#include "lib/utils/PBUtils.h" #include "lib/plugin/SparkServices.h" +#include "lib/utils/PBUtils.h" +#include "lib/config/config.h" +#include "lib/config/protos/system.pb.h" #include #include #include - namespace bts { namespace plugin { @@ -16,8 +16,10 @@ using namespace bts::orderman; void init_plugins(SparkServices &services) { - static std::vector(boost::filesystem::path(),""))> keep_alive; - + static std::vector( + boost::filesystem::path(), ""))> + keep_alive; + auto plugin_path = os::sparkd_wd() + "/plugins/"; if (!boost::filesystem::is_directory(plugin_path)) { LOG(Plugin, Info, @@ -32,6 +34,15 @@ void init_plugins(SparkServices &services) { auto &f = *iter; auto pl = f.path().string(); + + if (pl == "order_plugin_example.so" && + config::get().type() != "dev") { + LOG(Plugin, Info, + "Skipping order_plugin_example.so because we are not running in dev mode", + plugin_path); + continue; + } + LOG(Plugin, Info, "Attempting to initialize plugin {}", pl); try { auto init_plugin = boost::dll::import( diff --git a/src/sdk/examples/order_plugin_example.cpp b/src/sdk/examples/order_plugin_example.cpp index 035c7e7c7..31c180732 100644 --- a/src/sdk/examples/order_plugin_example.cpp +++ b/src/sdk/examples/order_plugin_example.cpp @@ -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 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 ¶ms = 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 ¶ms = 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().type() == "dev") { - serv.register_dynamic_order(get_dynamic_iceberg_order_desc(), []() { - return std::make_unique(); - }); - 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(); }); } + +} // namespace order_example +} // namespace bts diff --git a/src/web/CMakeDeps.cmake b/src/web/CMakeDeps.cmake index a717036b4..db1475407 100644 --- a/src/web/CMakeDeps.cmake +++ b/src/web/CMakeDeps.cmake @@ -1 +1 @@ -set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/AlgoDefinitionService.proto;../lib/api/services/AlgoService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/AuthService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataAuxiliaryService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/PositionService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/ShellLatencyService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;api/src/DynamicService.ts;api/src/ServiceContext.ts;api/src/bts_assert.ts;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/Modal.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Nav.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs;ui/src/obj/Debug/netstandard2.0/ui.AssemblyInfo.fs) \ No newline at end of file +set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/AlgoDefinitionService.proto;../lib/api/services/AlgoService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/AuthService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataAuxiliaryService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/PositionService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/ShellLatencyService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/cssstyle/scripts/run_tests.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;api/src/DynamicService.ts;api/src/ServiceContext.ts;api/src/bts_assert.ts;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/Modal.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Nav.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs;ui/src/obj/Debug/netstandard2.0/ui.AssemblyInfo.fs) \ No newline at end of file