378 lines
13 KiB
C++
378 lines
13 KiB
C++
#include "ExchangeSimApplication.h"
|
|
#include "lib/md/SecurityDB.h"
|
|
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/md/MDProducer.h"
|
|
#include "lib/md/Shm/FixedSecurity.h"
|
|
#include "lib/md/get_symbols.h"
|
|
#include "lib/utils/datetime.h"
|
|
#include "lib/domain_model/Security.h"
|
|
#include "lib/md/Shm/MDStructure.h"
|
|
|
|
#include <boost/date_time/posix_time/posix_time.hpp>
|
|
#include <quickfix/fix42/ExecutionReport.h>
|
|
#include <quickfix/fix42/OrderCancelReplaceRequest.h>
|
|
|
|
namespace bts {
|
|
namespace sim {
|
|
|
|
GCC_DIAG_OFF("-Wdeprecated")
|
|
GCC_DIAG_OFF("-Wignored-qualifiers")
|
|
|
|
void ExchangeSimApplication::onLogon(const FIX::SessionID &) {}
|
|
|
|
void ExchangeSimApplication::onLogout(const FIX::SessionID &) {}
|
|
|
|
void ExchangeSimApplication::fromApp(
|
|
const FIX::Message &message,
|
|
const FIX::SessionID &sessionID) throw(FIX::FieldNotFound,
|
|
FIX::IncorrectDataFormat,
|
|
FIX::IncorrectTagValue,
|
|
FIX::UnsupportedMessageType) {
|
|
crack(message, sessionID);
|
|
}
|
|
|
|
void ExchangeSimApplication::onMessage(const FIX42::NewOrderSingle &message,
|
|
const FIX::SessionID &) {
|
|
FIX::SenderCompID senderCompID;
|
|
FIX::TargetCompID targetCompID;
|
|
FIX::SenderSubID senderSubID;
|
|
FIX::ClOrdID clOrdID;
|
|
FIX::Account account;
|
|
FIX::SecurityDesc sec_desc;
|
|
FIX::Side side;
|
|
FIX::OrdType ordType;
|
|
FIX::Price price;
|
|
FIX::OrderQty orderQty;
|
|
FIX::TimeInForce timeInForce(FIX::TimeInForce_DAY);
|
|
FIX::ManualOrderIndicator moi;
|
|
|
|
message.getHeader().get(senderCompID);
|
|
message.getHeader().get(targetCompID);
|
|
message.getHeader().get(senderSubID);
|
|
message.get(clOrdID);
|
|
message.get(account);
|
|
message.get(sec_desc);
|
|
message.get(side);
|
|
message.get(ordType);
|
|
if (ordType == FIX::OrdType_LIMIT)
|
|
message.get(price);
|
|
message.get(orderQty);
|
|
message.getFieldIfSet(timeInForce);
|
|
|
|
message.getField(moi);
|
|
LOG(ExSim, Info, "Got new order: {}", clOrdID.getString());
|
|
|
|
try {
|
|
if (timeInForce != FIX::TimeInForce_DAY)
|
|
throw std::logic_error("Unsupported TIF, use Day");
|
|
|
|
Order order(clOrdID, sec_desc, account, senderCompID, targetCompID,
|
|
senderSubID, convert(side), convert(ordType), price,
|
|
(long)orderQty, convert(moi));
|
|
|
|
processOrder(order);
|
|
update_md(sec_desc);
|
|
} catch (std::exception &e) {
|
|
rejectOrder(senderCompID, senderSubID, targetCompID, clOrdID, sec_desc,
|
|
side, account, e.what());
|
|
}
|
|
}
|
|
|
|
void ExchangeSimApplication::onMessage(
|
|
const FIX42::OrderCancelReplaceRequest &message, const FIX::SessionID &) {
|
|
FIX::Price price;
|
|
FIX::OrderQty orderQty;
|
|
FIX::ClOrdID clOrdID;
|
|
FIX::SecurityDesc sec_desc;
|
|
FIX::Side side;
|
|
FIX::SenderCompID senderCompID;
|
|
FIX::SenderSubID senderSubID;
|
|
FIX::TargetCompID targetCompID;
|
|
FIX::Account account;
|
|
|
|
message.getHeader().get(senderCompID);
|
|
message.getHeader().get(senderSubID);
|
|
message.getHeader().get(targetCompID);
|
|
message.get(clOrdID);
|
|
message.get(price);
|
|
message.get(orderQty);
|
|
message.get(sec_desc);
|
|
message.get(side);
|
|
message.get(account);
|
|
|
|
LOG(ExSim, Info, "Got order change: {} {}@{}", clOrdID.getString(), orderQty,
|
|
price);
|
|
try {
|
|
Order &order = m_orderMatcher.find(sec_desc, convert(side), clOrdID);
|
|
order.update(price, orderQty);
|
|
updateOrder(order, FIX::OrdStatus_REPLACED);
|
|
|
|
std::queue<Order> orders;
|
|
m_orderMatcher.match(order.getSecDesc(), orders);
|
|
|
|
while (orders.size()) {
|
|
fillOrder(orders.front());
|
|
orders.pop();
|
|
}
|
|
update_md(sec_desc);
|
|
} catch (std::exception &e) {
|
|
rejectOrder(senderCompID, senderSubID, targetCompID, clOrdID, sec_desc,
|
|
side, account, e.what());
|
|
}
|
|
}
|
|
|
|
void ExchangeSimApplication::onMessage(const FIX42::OrderCancelRequest &message,
|
|
const FIX::SessionID &) {
|
|
FIX::OrigClOrdID origClOrdID;
|
|
FIX::SecurityDesc sec_desc;
|
|
FIX::Side side;
|
|
|
|
message.get(origClOrdID);
|
|
message.get(sec_desc);
|
|
message.get(side);
|
|
|
|
LOG(ExSim, Info, "Got order cancellation for: {}", origClOrdID.getString());
|
|
try {
|
|
processCancel(origClOrdID, sec_desc, convert(side));
|
|
update_md(sec_desc);
|
|
} catch (std::exception &) {
|
|
}
|
|
}
|
|
|
|
void ExchangeSimApplication::updateOrder(const Order &order, char status) {
|
|
FIX::TargetCompID targetCompID(order.getOwner());
|
|
FIX::SenderCompID senderCompID(order.getTarget());
|
|
FIX::TargetSubID(order.getSenderSubID());
|
|
|
|
FIX42::ExecutionReport fixOrder;
|
|
fixOrder.set(FIX::OrderID("12345678901234567"));
|
|
fixOrder.set(FIX::ExecID(m_generator.genExecutionID()));
|
|
fixOrder.set(FIX::ExecTransType(FIX::ExecTransType_NEW));
|
|
fixOrder.set(FIX::ExecType(status));
|
|
fixOrder.set(FIX::OrdStatus(status));
|
|
fixOrder.set(FIX::Account(order.getAccount()));
|
|
fixOrder.set(FIX::SecurityDesc(order.getSecDesc()));
|
|
fixOrder.set(FIX::Side(convert(order.getSide())));
|
|
fixOrder.set(FIX::LeavesQty(order.getOpenQuantity()));
|
|
fixOrder.set(FIX::CumQty(order.getExecutedQuantity()));
|
|
fixOrder.set(FIX::AvgPx(order.getAvgExecutedPrice()));
|
|
fixOrder.set(FIX::ClOrdID(order.getClientID()));
|
|
fixOrder.set(FIX::OrderQty(order.getQuantity()));
|
|
fixOrder.set(FIX::TimeInForce(FIX::TimeInForce_DAY));
|
|
fixOrder.set(FIX::OrdType(convert(order.getType())));
|
|
fixOrder.set(FIX::Price(order.getPrice()));
|
|
fixOrder.set(FIX::OrderQty(order.getQuantity()));
|
|
|
|
fixOrder.setField(convert(order.getMOI()));
|
|
|
|
boost::posix_time::ptime now =
|
|
boost::posix_time::second_clock::universal_time();
|
|
fixOrder.set(FIX::TransactTime(
|
|
FIX::UtcTimeStamp(now.time_of_day().hours(), now.time_of_day().minutes(),
|
|
now.time_of_day().seconds(), now.date().day(),
|
|
now.date().month(), now.date().year()),
|
|
true));
|
|
if (status == FIX::OrdStatus_FILLED ||
|
|
status == FIX::OrdStatus_PARTIALLY_FILLED) {
|
|
fixOrder.set(FIX::LastShares(order.getLastExecutedQuantity()));
|
|
fixOrder.set(FIX::LastPx(order.getLastExecutedPrice()));
|
|
}
|
|
|
|
fixOrder.getHeader().set(FIX::TargetSubID(order.getSenderSubID()));
|
|
try {
|
|
FIX::Session::sendToTarget(fixOrder, senderCompID, targetCompID);
|
|
} catch (FIX::SessionNotFound &) {
|
|
}
|
|
}
|
|
|
|
void ExchangeSimApplication::rejectOrder(
|
|
const FIX::SenderCompID &sender, const FIX::SenderSubID &sender_sub_id,
|
|
const FIX::TargetCompID &target, const FIX::ClOrdID &clOrdID,
|
|
const FIX::SecurityDesc &symbol, const FIX::Side &side,
|
|
const std::string &account, const std::string &message) {
|
|
FIX::TargetCompID targetCompID(sender.getValue());
|
|
FIX::SenderCompID senderCompID(target.getValue());
|
|
|
|
FIX42::ExecutionReport fixOrder;
|
|
fixOrder.set(FIX::OrderID("12345678901234567"));
|
|
fixOrder.set(FIX::ExecID(m_generator.genExecutionID()));
|
|
fixOrder.set(FIX::ExecTransType(FIX::ExecTransType_NEW));
|
|
fixOrder.set(FIX::ExecType(FIX::ExecType_REJECTED));
|
|
fixOrder.set(FIX::OrdStatus(FIX::ExecType_REJECTED));
|
|
fixOrder.set(symbol);
|
|
fixOrder.set(FIX::Account(account));
|
|
fixOrder.set(side);
|
|
fixOrder.set(FIX::LeavesQty(0));
|
|
fixOrder.set(FIX::Price(0));
|
|
fixOrder.set(FIX::OrderQty(0));
|
|
fixOrder.set(FIX::CumQty(0));
|
|
fixOrder.set(FIX::LastShares(0));
|
|
fixOrder.set(FIX::AvgPx(0));
|
|
fixOrder.set(FIX::LastPx(0));
|
|
fixOrder.set(FIX::TimeInForce(FIX::TimeInForce_DAY));
|
|
fixOrder.set(clOrdID);
|
|
fixOrder.set(FIX::Text(message));
|
|
fixOrder.set(FIX::OrdType(FIX::OrdType_LIMIT));
|
|
fixOrder.setField(FIX::ManualOrderIndicator(true));
|
|
|
|
fixOrder.getHeader().set(FIX::TargetSubID(sender_sub_id.getValue()));
|
|
|
|
boost::posix_time::ptime now =
|
|
boost::posix_time::second_clock::universal_time();
|
|
fixOrder.set(FIX::TransactTime(
|
|
FIX::UtcTimeStamp(now.time_of_day().hours(), now.time_of_day().minutes(),
|
|
now.time_of_day().seconds(), now.date().day(),
|
|
now.date().month(), now.date().year()),
|
|
true));
|
|
try {
|
|
FIX::Session::sendToTarget(fixOrder, senderCompID, targetCompID);
|
|
} catch (FIX::SessionNotFound &) {
|
|
}
|
|
}
|
|
|
|
void ExchangeSimApplication::processOrder(const Order &order) {
|
|
if (m_orderMatcher.insert(order)) {
|
|
acceptOrder(order);
|
|
|
|
std::queue<Order> orders;
|
|
m_orderMatcher.match(order.getSecDesc(), orders);
|
|
|
|
while (orders.size()) {
|
|
fillOrder(orders.front());
|
|
orders.pop();
|
|
}
|
|
} else
|
|
rejectOrder(order);
|
|
}
|
|
|
|
void ExchangeSimApplication::processCancel(const std::string &id,
|
|
const std::string &symbol,
|
|
Order::Side side) {
|
|
Order &order = m_orderMatcher.find(symbol, side, id);
|
|
order.cancel();
|
|
cancelOrder(order);
|
|
m_orderMatcher.erase(order);
|
|
}
|
|
|
|
Order::Side ExchangeSimApplication::convert(const FIX::Side &side) {
|
|
switch (side) {
|
|
case FIX::Side_BUY:
|
|
return Order::buy;
|
|
case FIX::Side_SELL:
|
|
return Order::sell;
|
|
default:
|
|
throw std::logic_error("Unsupported Side, use buy or sell");
|
|
}
|
|
}
|
|
|
|
Order::Type ExchangeSimApplication::convert(const FIX::OrdType &ordType) {
|
|
switch (ordType) {
|
|
case FIX::OrdType_LIMIT:
|
|
return Order::limit;
|
|
default:
|
|
throw std::logic_error("Unsupported Order Type, use limit");
|
|
}
|
|
}
|
|
|
|
FIX::Side ExchangeSimApplication::convert(Order::Side side) {
|
|
switch (side) {
|
|
case Order::buy:
|
|
return FIX::Side(FIX::Side_BUY);
|
|
case Order::sell:
|
|
return FIX::Side(FIX::Side_SELL);
|
|
default:
|
|
throw std::logic_error("Unsupported Side, use buy or sell");
|
|
}
|
|
}
|
|
|
|
FIX::OrdType ExchangeSimApplication::convert(Order::Type type) {
|
|
switch (type) {
|
|
case Order::limit:
|
|
return FIX::OrdType(FIX::OrdType_LIMIT);
|
|
default:
|
|
throw std::logic_error("Unsupported Order Type, use limit");
|
|
}
|
|
}
|
|
|
|
FIX::ManualOrderIndicator
|
|
ExchangeSimApplication::convert(const Order::MOI &moi) {
|
|
switch (moi) {
|
|
case Order::moi_yes:
|
|
return FIX::ManualOrderIndicator(true);
|
|
default:
|
|
return FIX::ManualOrderIndicator(false);
|
|
}
|
|
}
|
|
|
|
Order::MOI
|
|
ExchangeSimApplication::convert(const FIX::ManualOrderIndicator &moi) {
|
|
if (moi.getValue())
|
|
return Order::moi_yes;
|
|
else
|
|
return Order::moi_no;
|
|
}
|
|
|
|
ExchangeSimApplication::ExchangeSimApplication() :
|
|
producer(co2::PLATFORM_SIM),
|
|
handles(),
|
|
timer(utils::Dispatcher::background(), 200, [=](){ producer.heartbeat(); })
|
|
{
|
|
std::set<md::UserSymbol> symbols;
|
|
md::get_system_md_symbols(symbols);
|
|
md::db::load_securities(symbols, [this](const api::Security &s) {
|
|
if (s.exchange() == api::VENUE_GLBX) {
|
|
md::with_security_like(s,[this,s] (auto &fs) {
|
|
auto new_s = s;
|
|
*new_s.mutable_glbx()->mutable_security_desc() = std::string("sim:") + s.glbx().security_desc();
|
|
*new_s.mutable_symbol() = s.symbol();
|
|
md::convert_security(new_s, fs, true);
|
|
md::MDProducerHandle handle = producer.add_security(fs);
|
|
auto sec_desc = securities::descriptor(new_s);
|
|
handles.insert(make_pair(sec_desc, handle));
|
|
});
|
|
}});
|
|
}
|
|
|
|
void ExchangeSimApplication::update_md(std::string const&sec_desc)
|
|
{
|
|
auto it = handles.find(sec_desc);
|
|
if (it != handles.end()) {
|
|
|
|
auto &handle = it->second;
|
|
auto book = m_orderMatcher.get_book(sec_desc);
|
|
|
|
auto price_factor = pow(10, handle.security().display_factor);
|
|
auto n_bids = book.bids.size();
|
|
for (uint i = 0; i < std::min(md::COCONUT_MAX_DEPTH,(uint32_t) n_bids); i++) {
|
|
auto p = book.bids[i].price*price_factor;
|
|
auto psz = md::PriceSize::from_double<7> (p,book.bids[i].size);
|
|
LOG(ExSim, Info, "Updating market data for {}. Depth: {} : Buy {}@{}",
|
|
sec_desc,i,book.bids[i].size,p);
|
|
handle.update_bid (utils::TimeStamp::now(), psz,i);
|
|
}
|
|
for (uint i = n_bids; i < md::COCONUT_MAX_DEPTH; i++) {
|
|
auto psz = md::PriceSize::from_double<7> (os::nan(),0);
|
|
handle.update_bid (utils::TimeStamp::now(), psz,i);
|
|
}
|
|
auto n_asks = book.asks.size();
|
|
for (uint i = 0; i < std::min(md::COCONUT_MAX_DEPTH,(uint32_t) n_asks); i++) {
|
|
auto p = book.asks[i].price*price_factor;
|
|
auto psz = md::PriceSize::from_double<7> (p,book.asks[i].size);
|
|
LOG(ExSim, Info, "Updating market data for {}. Depth: {} : Sell {}@{}",
|
|
sec_desc,i,book.asks[i].size,p);
|
|
handle.update_ask (utils::TimeStamp::now(), psz,i);
|
|
}
|
|
for (uint i = n_asks; i < md::COCONUT_MAX_DEPTH; i++) {
|
|
auto psz = md::PriceSize::from_double<7> (os::nan(),0);
|
|
handle.update_ask (utils::TimeStamp::now(), psz,i);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
GCC_DIAG_RESTORE()
|
|
GCC_DIAG_RESTORE()
|
|
}
|
|
}
|