#include "protocol.hpp"
|
|
#include "book.hpp"
|
#include "cpp-httplib/httplib.h"
|
#include "easywsclient/easywsclient.hpp"
|
#include "json.hpp"
|
#include "secrets.hpp"
|
|
#include <chrono>
|
#include <cstddef>
|
#include <iostream>
|
#include <memory>
|
#include <queue>
|
#include <sstream>
|
#include <stdexcept>
|
#include <string>
|
#include <unordered_map>
|
|
namespace protocol
|
{
|
static std::unordered_map<json::MessageTypes, book::ProductTypeEnum>
|
mapAnnounce;
|
std::string server = std::string(HOST) + ":" + std::string(PORT);
|
httplib::Client cli("http://" + server);
|
std::unique_ptr<easywsclient::WebSocket> ws;
|
|
double lastime = 0;
|
|
void initialise()
|
{
|
mapAnnounce = {{json::FUTURE_TYPE, book::FUTURE},
|
{json::SPREAD_TYPE, book::SPREAD},
|
{json::CALL_TYPE, book::CALL},
|
{json::PUT_TYPE, book::PUT}};
|
}
|
|
std::unordered_map<std::string, book::Book> recoverBook()
|
{
|
std::unordered_map<std::string, book::Book> bs;
|
// std::ifstream sampleFile("../data.test");
|
// std::stringstream ss;
|
// ss << sampleFile.rdbuf();
|
httplib::Client cli("http://" + server);
|
auto res = cli.Get("/recover");
|
std::string l;
|
// l = ss.str();
|
l = res->body;
|
std::queue<json::Message*> a(json::parse(l));
|
while (!a.empty()) {
|
if (static_cast<json::FromExchange*>(a.front()) != nullptr ||
|
static_cast<json::FromExchange*>(a.front())->timestamp > lastime) {
|
lastime = static_cast<json::FromExchange*>(a.front())->timestamp;
|
protocol::handleMessage(bs, a.front());
|
}
|
delete a.front();
|
a.pop();
|
}
|
return bs;
|
}
|
|
void createWebSocket()
|
{
|
ws = std::unique_ptr<easywsclient::WebSocket>(
|
easywsclient::WebSocket::pointer(easywsclient::WebSocket::from_url(
|
"ws://" + server + "/information")));
|
ws->poll();
|
}
|
|
std::deque<json::Message*>
|
catchUp(std::unordered_map<std::string, book::Book>& bs)
|
{
|
std::string feed;
|
bool gotMessage;
|
std::deque<json::Message*> out;
|
do {
|
gotMessage = false;
|
ws->poll();
|
ws->dispatch([gotMessageOut = &gotMessage, messageOut = &feed,
|
ws = ws.get()](const std::string& message) {
|
*gotMessageOut = true;
|
*messageOut = message;
|
});
|
if (gotMessage) {
|
std::queue<json::Message*> a(json::parse(feed));
|
while (!a.empty()) {
|
if (static_cast<json::FromExchange*>(a.front()) != nullptr ||
|
static_cast<json::FromExchange*>(a.front())->timestamp >
|
lastime) {
|
lastime =
|
static_cast<json::FromExchange*>(a.front())->timestamp;
|
}
|
protocol::handleMessage(bs, a.front());
|
out.push_back(a.front());
|
a.pop();
|
}
|
}
|
} while (gotMessage);
|
return out;
|
}
|
|
json::Message* addOrder(json::AddMessage& order)
|
{
|
std::string message = order.as_string();
|
return send(message);
|
}
|
|
json::Message* deleteOrder(json::DeleteMessage& order)
|
{
|
std::string message = order.as_string();
|
return send(message);
|
}
|
|
void handleMessage(std::unordered_map<std::string, book::Book>& bs,
|
json::Message* message)
|
{
|
if (mapAnnounce.empty()) initialise();
|
if (dynamic_cast<json::FromExchange*>(message) != nullptr) {
|
lastime = dynamic_cast<json::FromExchange*>(message)->timestamp;
|
}
|
switch (message->type) {
|
case json::FUTURE_TYPE:
|
case json::SPREAD_TYPE:
|
case json::CALL_TYPE:
|
case json::PUT_TYPE:
|
announce(bs, static_cast<json::AnnounceMessage*>(message));
|
break;
|
case json::SETTLEMENT:
|
settle(bs, static_cast<json::SettleMessage*>(message));
|
break;
|
case json::ADDED:
|
addedOrder(bs, static_cast<json::AddedMessage*>(message));
|
break;
|
case json::DELETED:
|
deletedOrder(bs, static_cast<json::DeletedMessage*>(message));
|
break;
|
case json::TRADE:
|
tradeOrder(bs, static_cast<json::TradeMessage*>(message));
|
break;
|
case json::BROKER_REQUEST:
|
case json::BROKER_ACK:
|
case json::BROKER_CONFIRM:
|
broker(bs, static_cast<json::Broker*>(message));
|
break;
|
default:;
|
}
|
}
|
|
void announce(std::unordered_map<std::string, book::Book>& bs,
|
json::AnnounceMessage* message)
|
{
|
bs[message->product] =
|
book::Book(mapAnnounce[message->type], message->product,
|
message->stationId, message->unit, message->expiry,
|
message->aggFee, message->pasFee, message->broFee);
|
}
|
void settle(std::unordered_map<std::string, book::Book>& bs,
|
json::SettleMessage* message)
|
{
|
bs.erase(message->product);
|
}
|
void addedOrder(std::unordered_map<std::string, book::Book>& bs,
|
json::AddedMessage* message)
|
{
|
if (message->side == book::Buy && message->resting) {
|
book::Order t(message->price, book::Buy, message->resting,
|
message->timestamp, message->id);
|
bs[message->product].bid(t);
|
} else if (message->side == book::Sell && message->resting) {
|
book::Order t(message->price, book::Sell, message->resting,
|
message->timestamp, message->id);
|
bs[message->product].ask(t);
|
}
|
}
|
void deletedOrder(std::unordered_map<std::string, book::Book>& bs,
|
json::DeletedMessage* message)
|
{
|
if (message->side == book::Buy) {
|
for (auto i = bs[message->product].bidSide.begin(); i != bs[message->product].bidSide.end(); i++) {
|
if (i->id == message->id) {
|
bs[message->product].bidSide.erase(i);
|
break;
|
}
|
}
|
} else {
|
for (auto i = bs[message->product].askSide.begin(); i != bs[message->product].askSide.end(); i++) {
|
if (i->id == message->id) {
|
bs[message->product].askSide.erase(i);
|
break;
|
}
|
}
|
}
|
}
|
void tradeOrder(std::unordered_map<std::string, book::Book>& bs,
|
json::TradeMessage* message)
|
{
|
if (message->tradeType == json::BUY_AGGRESSOR) {
|
if (message->passiveOrderRemaining > 0) {
|
for (auto& i : bs[message->product].askSide) {
|
if (i.id == message->passiveOrder) {
|
i.volume = message->passiveOrderRemaining;
|
break;
|
}
|
}
|
} else {
|
for (auto i = bs[message->product].askSide.begin(); i != bs[message->product].askSide.end(); i++) {
|
if (i->id == message->passiveOrder) {
|
bs[message->product].askSide.erase(i);
|
break;
|
}
|
}
|
}
|
} else if (message->tradeType == json::SELL_AGGRESSOR) {
|
if (message->passiveOrderRemaining > 0) {
|
for (auto& i : bs[message->product].bidSide) {
|
if (i.id == message->passiveOrder) {
|
i.volume = message->passiveOrderRemaining;
|
break;
|
}
|
}
|
} else {
|
for (auto i = bs[message->product].bidSide.begin(); i != bs[message->product].bidSide.end(); i++) {
|
if (i->id == message->passiveOrder) {
|
bs[message->product].bidSide.erase(i);
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
void broker(std::unordered_map<std::string, book::Book>& bs,
|
json::Broker* message)
|
{
|
}
|
|
json::Message* send(std::string& message)
|
{
|
httplib::MultipartFormDataItems a = {{"message", message, "", ""},
|
{"username", USER, "", ""},
|
{"password", PASS, "", ""}};
|
auto res = cli.Post("/execution", a);
|
std::string b = res->body;
|
std::queue<json::Message*> c = json::parse(b);
|
return c.front();
|
}
|
|
} // namespace protocol
|
