Fixed the shared data problem that was crashing O'Grady.

This commit is contained in:
Pedro Pinto committed 2018-06-22 16:22:27 -04:00
1 parent 2b2eaac979
commit 3b3d44d6f6
8 files changed
+68 -67

No files matched your search

@@ -1,10 +1,10 @@
#include "OrderStore.h"
#include "lib/utils/PBUtils.h"
#include "server/sparkd/persistence/SqliteStore.h"
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/orderman/events/StoredOrderEvent.h"
#include "lib/utils/PBUtils.h"
#include "server/sparkd/orderman/events/OrderStateUpdateEvent.h"
#include "server/sparkd/orderman/events/StoredOrderEvent.h"
#include "server/sparkd/persistence/SqliteStore.h"
#include <unordered_set>
@@ -13,74 +13,74 @@ namespace orderman {
static auto const orders_ns = "orders";
struct OrderStore::PImpl
{
PImpl() :
known_orders(),
store(new persistence::SqliteStore("orders")),
order_stream()
{}
struct OrderStore::PImpl {
PImpl()
: known_orders(), store(new persistence::SqliteStore("orders")),
order_stream() {}
const GatewayName gw_name;
std::unordered_map<OrderKey,std::unique_ptr<api::orderman::OrderRecord>> known_orders;
std::unordered_map<OrderKey, google::protobuf::Timestamp> known_orders;
std::unique_ptr<persistence::IStore> store;
mercury::Stream<StoredOrderEvent> order_stream;
};
OrderStore::OrderStore () : me (new PImpl()) {}
OrderStore::~OrderStore () {}
OrderStore::OrderStore() : me(new PImpl()) {}
OrderStore::~OrderStore() {}
void OrderStore::init()
{
void OrderStore::init() {
api::orderman::OrderRecord rec;
std::vector<StoredOrderEvent> stored_batch;
auto all = me->store->retrieve_all()[orders_ns];
for (auto const &kvp : all)
if (utils::pb::from_string<api::orderman::OrderRecord> (kvp.second,&rec)) {
for (auto const &kvp : all)
if (utils::pb::from_string<api::orderman::OrderRecord>(kvp.second,
&rec)) {
auto ok = OrderKey(std::stoi(kvp.first));
auto order_record = std::make_unique<api::orderman::OrderRecord> (rec);
stored_batch.emplace_back(*order_record.get());
me->known_orders[ok] = std::move(order_record);
}
else
LOG(OrderMan,Error,
stored_batch.emplace_back(rec);
me->known_orders[ok] = rec.state().created();
} else
LOG(OrderMan, Error,
"Could not recover order {} from storage. "
"This should be investigated", kvp.first);
"This should be investigated",
kvp.first);
me->order_stream = make_stream<StoredOrderEvent> ();
LOG(OrderMan,Info,
"Order Store published {} orders recoved from disk", all.size());
publish_batch(me->order_stream,stored_batch);
subscribe<OrderStateUpdateEvent> ([this] (auto const&ev) {this->on_order_state_update(ev);});
me->order_stream = make_stream<StoredOrderEvent>();
LOG(OrderMan, Info, "Order Store published {} orders recoved from disk",
all.size());
publish_batch(me->order_stream, stored_batch);
subscribe<OrderStateUpdateEvent>(
[this](auto const &ev) { this->on_order_state_update(ev); });
}
void OrderStore::on_order_state_update(mercury::Update<OrderStateUpdateEvent> const&u)
{
void OrderStore::on_order_state_update(
mercury::Update<OrderStateUpdateEvent> const &u) {
if (u.events)
for (auto const &ev : *u.events) {
auto &ptr = me->known_orders[ev.key];
auto new_order = !ptr;
if (new_order) {
ptr.reset (new api::orderman::OrderRecord());
*ptr->mutable_def() = *ev.definition;
ptr->set_key(ev.key.value());
ptr->set_parent_key(ev.parent_key.value());
*ptr->mutable_state()->mutable_created() = utils::pb::pb_now();
}
auto created = ptr->state().created();
*ptr->mutable_state() = ev.state;
*ptr->mutable_state()->mutable_created() = created;
*ptr->mutable_state()->mutable_last_change() = utils::pb::pb_now();
auto k = std::to_string(ptr->key());
auto v = utils::pb::to_string(*ptr);
if (new_order)
me->store->insert(orders_ns,k,v);
else
me->store->update(orders_ns,k,v);
publish(me->order_stream,*ptr.get());
api::orderman::OrderRecord order;
order.set_key(ev.key.value());
order.set_parent_key(ev.parent_key.value());
*order.mutable_def() = *ev.definition;
*order.mutable_state() = ev.state;
*order.mutable_state()->mutable_last_change() = utils::pb::pb_now();
auto it = me->known_orders.find(ev.key);
if (it == me->known_orders.end()) {
// new order
auto now = utils::pb::pb_now();
me->known_orders[ev.key] = now;
*order.mutable_state()->mutable_created() = now;
me->store->insert(orders_ns, std::to_string(order.key()),
utils::pb::to_string(order));
} else {
*order.mutable_state()->mutable_created() = it->second;
me->store->update(orders_ns, std::to_string(order.key()),
utils::pb::to_string(order));
}
LOG(OrderMan, Diag, "Storing order {}", utils::pb::to_string(order));
publish(me->order_stream, order);
}
}
}}
} // namespace orderman
} // namespace bts
@@ -92,10 +92,10 @@ void ServiceBridge::on(mercury::Update<StoredOrderEvent> const &update) {
bool was_ready = is_ready();
me->have_orders = true;
std::vector<api::orderman::OrderRecord const *> orders;
std::vector<api::orderman::OrderRecord> orders;
orders.reserve(update.events->size());
for (auto ev : *(update.events)) {
me->known_orders.insert(OrderKey(ev.order_record->key()));
me->known_orders.insert(OrderKey(ev.order_record.key()));
orders.push_back(ev.order_record);
}
me->on_orders(orders);
@@ -39,8 +39,8 @@ public:
template <class EV> using OnEv = std::function<void(EV const&)>;
using OnReady = std::function<void()>;
using OnOrders = std::function<void (std::vector<api::orderman::OrderRecord const*> )>;
using OnFills = std::function<void (std::vector<api::orderman::Fill const*> )>;
using OnOrders = std::function<void (std::vector<api::orderman::OrderRecord> const& )>;
using OnFills = std::function<void (std::vector<api::orderman::Fill const*> const&)>;
ServiceBridge(OnReady const&, OnOrders const&, OnFills const&);
void init() override;
@@ -6,6 +6,7 @@
#include "server/sparkd/orderman/actors/order_manager/OrderServicesData.h"
#include "server/sparkd/orderman/events/NewAdminDataEvent.h"
#include "server/sparkd/orderman/events/OrderManagerReadyEvent.h"
#include "server/sparkd/orderman/events/StoredOrderEvent.h"
#include "server/sparkd/orderman/order_factory/OrderFactory.h"
#include "server/sparkd/orderman/orders/Order.h"
#include "server/sparkd/securities/ISecurityDB.h"
@@ -96,8 +97,8 @@ void OrderManager::on_order_recovery(
// recover orders from disk
for (auto const &ev : *(update.events)) {
auto &order =
me->services_data.order_factory.recover(*ev.order_record);
auto const &ostate = ev.order_record->state();
me->services_data.order_factory.recover(ev.order_record);
auto const &ostate = ev.order_record.state();
OrderInfo oi{order, me->services_data};
auto serv_ptr = oi.order_services.get();
me->orders[order.key()] = std::move(oi);
@@ -24,7 +24,6 @@
#include "server/sparkd/orderman/events/NewSecuritiesEvent.h"
#include "server/sparkd/orderman/events/OrderStateUpdateEvent.h"
#include "server/sparkd/orderman/events/OutFIXMsgEvent.h"
#include "server/sparkd/orderman/events/StoredOrderEvent.h"
#include "server/sparkd/orderman/events/UpdateOrderEvent.h"
#include "server/sparkd/orderman/limiter/Limiter.h"
#include "server/sparkd/orderman/order_router/OrderRouter.h"
@@ -5,6 +5,7 @@
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/mercury/synopsis/MergeByKey.h"
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/mercury/events/Event.h"
namespace bts {
namespace orderman {
@@ -14,10 +15,10 @@ class StoredOrderEvent : public mercury::Event <StoredOrderEvent>
public:
using SynopsisPolicy = mercury::MergeByKey<StoredOrderEvent>;
StoredOrderEvent(api::orderman::OrderRecord &record) : order_record(&record) {}
StoredOrderEvent(api::orderman::OrderRecord const &record) : order_record(record) {}
auto key() const {return order_record->key();}
api::orderman::OrderRecord *order_record;
auto key() const {return order_record.key();}
api::orderman::OrderRecord order_record;
};
}}
@@ -110,7 +110,7 @@ OrderServiceServer::~OrderServiceServer() {
}
void OrderServiceServer::on_orders(
std::vector<api::orderman::OrderRecord const *> const &orders) {
std::vector<api::orderman::OrderRecord> const &orders) {
LOG(OrderMan, Info, "Received order update for publishing");
std::vector<api::orderman::OrderRecord> created;
created.reserve(orders.size());
@@ -118,12 +118,12 @@ void OrderServiceServer::on_orders(
updated.reserve(orders.size());
for (auto const &rec : orders) {
auto const &k = OrderKey(rec->key());
auto const &k = OrderKey(rec.key());
if (me->known_orders.count(k) == 0) {
me->known_orders.insert(k);
created.push_back(*rec);
created.push_back(rec);
} else
updated.push_back(*rec);
updated.push_back(rec);
}
LOG(OrderMan, Info,
@@ -27,7 +27,7 @@ public:
private:
struct PImpl;
std::unique_ptr<PImpl> me;
void on_orders(std::vector<api::orderman::OrderRecord const*> const&);
void on_orders(std::vector<api::orderman::OrderRecord> const&);
void on_fills (std::vector<api::orderman::Fill const*> const&);
};