view | history | commit | commitdiff
Joel Grunbaum
2022-01-20 441abf1e6a15a39f1ef7bf5e4ee2a4a43bff327b
commit | author | age
16b655 1 #include "protocol.hpp"
JG 2
3 #include "book.hpp"
4 #include "cpp-httplib/httplib.h"
4fdb65 5 #include "easywsclient/easywsclient.hpp"
16b655 6 #include "json.hpp"
JG 7 #include "secrets.hpp"
8
9 #include <chrono>
4fdb65 10 #include <cstddef>
16b655 11 #include <iostream>
4fdb65 12 #include <memory>
16b655 13 #include <queue>
JG 14 #include <sstream>
4fdb65 15 #include <stdexcept>
16b655 16 #include <string>
JG 17 #include <unordered_map>
18
19 namespace protocol
20 {
21 static std::unordered_map<json::MessageTypes, book::ProductTypeEnum>
2c515f 22     mapAnnounce;
16b655 23 std::string server = std::string(HOST) + ":" + std::string(PORT);
JG 24 httplib::Client cli("http://" + server);
0b7aa0 25 std::unique_ptr<easywsclient::WebSocket> ws;
4fdb65 26
JG 27 double lastime = 0;
16b655 28
JG 29 void initialise()
30 {
2c515f 31     mapAnnounce = {{json::FUTURE_TYPE, book::FUTURE},
JG 32                    {json::SPREAD_TYPE, book::SPREAD},
33                    {json::CALL_TYPE, book::CALL},
34                    {json::PUT_TYPE, book::PUT}};
16b655 35 }
JG 36
37 std::unordered_map<std::string, book::Book> recoverBook()
38 {
2c515f 39     std::unordered_map<std::string, book::Book> bs;
JG 40     // std::ifstream sampleFile("../data.test");
41     // std::stringstream ss;
42     // ss << sampleFile.rdbuf();
43     httplib::Client cli("http://" + server);
44     auto res = cli.Get("/recover");
45     std::string l;
46     // l = ss.str();
47     l = res->body;
48     std::queue<json::Message*> a(json::parse(l));
49     while (!a.empty()) {
4fdb65 50         if (static_cast<json::FromExchange*>(a.front()) != nullptr ||
JG 51             static_cast<json::FromExchange*>(a.front())->timestamp > lastime) {
52             lastime = static_cast<json::FromExchange*>(a.front())->timestamp;
53             protocol::handleMessage(bs, a.front());
54         }
2c515f 55         delete a.front();
JG 56         a.pop();
57     }
58     return bs;
4fdb65 59 }
JG 60
0b7aa0 61 void createWebSocket()
4fdb65 62 {
0b7aa0 63     ws = std::unique_ptr<easywsclient::WebSocket>(
JG 64         easywsclient::WebSocket::pointer(easywsclient::WebSocket::from_url(
65             "ws://" + server + "/information")));
4fdb65 66     ws->poll();
0b7aa0 67 }
JG 68
69 std::deque<json::Message*>
70 catchUp(std::unordered_map<std::string, book::Book>& bs)
71 {
72     std::string feed;
73     bool gotMessage;
74     std::deque<json::Message*> out;
75     do {
76         gotMessage = false;
77         ws->poll();
78         ws->dispatch([gotMessageOut = &gotMessage, messageOut = &feed,
79                       ws = ws.get()](const std::string& message) {
80             *gotMessageOut = true;
81             *messageOut = message;
82         });
83         if (gotMessage) {
84             std::queue<json::Message*> a(json::parse(feed));
85             while (!a.empty()) {
86                 if (static_cast<json::FromExchange*>(a.front()) != nullptr ||
87                     static_cast<json::FromExchange*>(a.front())->timestamp >
88                         lastime) {
89                     lastime =
90                         static_cast<json::FromExchange*>(a.front())->timestamp;
91                 }
92                 protocol::handleMessage(bs, a.front());
93                 out.push_back(a.front());
94                 a.pop();
4fdb65 95             }
JG 96         }
0b7aa0 97     } while (gotMessage);
JG 98     return out;
16b655 99 }
JG 100
6926be 101 json::Message* addOrder(json::AddMessage& order)
16b655 102 {
6bdd28 103     std::string message = order.as_string();
2c515f 104     return send(message);
16b655 105 }
JG 106
6926be 107 json::Message* deleteOrder(json::DeleteMessage& order)
16b655 108 {
6bdd28 109     std::string message = order.as_string();
2c515f 110     return send(message);
16b655 111 }
JG 112
113 void handleMessage(std::unordered_map<std::string, book::Book>& bs,
114                    json::Message* message)
115 {
2c515f 116     if (mapAnnounce.empty()) initialise();
4fdb65 117     if (dynamic_cast<json::FromExchange*>(message) != nullptr) {
JG 118         lastime = dynamic_cast<json::FromExchange*>(message)->timestamp;
119     }
2c515f 120     switch (message->type) {
JG 121     case json::FUTURE_TYPE:
122     case json::SPREAD_TYPE:
123     case json::CALL_TYPE:
124     case json::PUT_TYPE:
611ad7 125         announce(bs, static_cast<json::AnnounceMessage*>(message));
2c515f 126         break;
JG 127     case json::SETTLEMENT:
611ad7 128         settle(bs, static_cast<json::SettleMessage*>(message));
2c515f 129         break;
JG 130     case json::ADDED:
611ad7 131         addedOrder(bs, static_cast<json::AddedMessage*>(message));
2c515f 132         break;
JG 133     case json::DELETED:
611ad7 134         deletedOrder(bs, static_cast<json::DeletedMessage*>(message));
2c515f 135         break;
JG 136     case json::TRADE:
611ad7 137         tradeOrder(bs, static_cast<json::TradeMessage*>(message));
2c515f 138         break;
JG 139     case json::BROKER_REQUEST:
140     case json::BROKER_ACK:
141     case json::BROKER_CONFIRM:
611ad7 142         broker(bs, static_cast<json::Broker*>(message));
2c515f 143         break;
JG 144     default:;
145     }
16b655 146 }
JG 147
148 void announce(std::unordered_map<std::string, book::Book>& bs,
149               json::AnnounceMessage* message)
150 {
2c515f 151     bs[message->product] =
JG 152         book::Book(mapAnnounce[message->type], message->product,
153                    message->stationId, message->unit, message->expiry,
154                    message->aggFee, message->pasFee, message->broFee);
16b655 155 }
JG 156 void settle(std::unordered_map<std::string, book::Book>& bs,
157             json::SettleMessage* message)
158 {
2c515f 159     bs.erase(message->product);
16b655 160 }
JG 161 void addedOrder(std::unordered_map<std::string, book::Book>& bs,
162                 json::AddedMessage* message)
163 {
4fdb65 164     if (message->side == book::Buy && message->resting) {
2c515f 165         book::Order t(message->price, book::Buy, message->resting,
JG 166                       message->timestamp, message->id);
167         bs[message->product].bid(t);
4fdb65 168     } else if (message->side == book::Sell && message->resting) {
2c515f 169         book::Order t(message->price, book::Sell, message->resting,
JG 170                       message->timestamp, message->id);
171         bs[message->product].ask(t);
172     }
16b655 173 }
JG 174 void deletedOrder(std::unordered_map<std::string, book::Book>& bs,
175                   json::DeletedMessage* message)
176 {
2c515f 177     if (message->side == book::Buy) {
0bef19 178         for (auto i = bs[message->product].bidSide.begin();
JG 179              i != bs[message->product].bidSide.end(); i++) {
180             if (i->id == message->id) {
181                 bs[message->product].bidSide.erase(i);
182                 break;
183             }
184         }
2c515f 185     } else {
0bef19 186         for (auto i = bs[message->product].askSide.begin();
JG 187              i != bs[message->product].askSide.end(); i++) {
188             if (i->id == message->id) {
189                 bs[message->product].askSide.erase(i);
190                 break;
191             }
192         }
16b655 193     }
JG 194 }
195 void tradeOrder(std::unordered_map<std::string, book::Book>& bs,
196                 json::TradeMessage* message)
197 {
0bef19 198     if (message->tradeType == json::BUY_AGGRESSOR) {
JG 199         if (message->passiveOrderRemaining > 0) {
200             for (auto& i : bs[message->product].askSide) {
201                 if (i.id == message->passiveOrder) {
202                     i.volume = message->passiveOrderRemaining;
203                     break;
204                 }
205             }
206         } else {
207             for (auto i = bs[message->product].askSide.begin();
208                  i != bs[message->product].askSide.end(); i++) {
209                 if (i->id == message->passiveOrder) {
210                     bs[message->product].askSide.erase(i);
211                     break;
212                 }
213             }
214         }
215     } else if (message->tradeType == json::SELL_AGGRESSOR) {
216         if (message->passiveOrderRemaining > 0) {
217             for (auto& i : bs[message->product].bidSide) {
218                 if (i.id == message->passiveOrder) {
219                     i.volume = message->passiveOrderRemaining;
220                     break;
221                 }
222             }
223         } else {
224             for (auto i = bs[message->product].bidSide.begin();
225                  i != bs[message->product].bidSide.end(); i++) {
226                 if (i->id == message->passiveOrder) {
227                     bs[message->product].bidSide.erase(i);
228                     break;
229                 }
230             }
231         }
232     }
16b655 233 }
4fdb65 234
16b655 235 void broker(std::unordered_map<std::string, book::Book>& bs,
JG 236             json::Broker* message)
237 {
238 }
239
6926be 240 json::Message* send(std::string& message)
16b655 241 {
4fdb65 242     httplib::MultipartFormDataItems a = {{"message", message, "", ""},
JG 243                                          {"username", USER, "", ""},
244                                          {"password", PASS, "", ""}};
0bef19 245     auto res = cli.Post("/execution",
JG 246                         "message=" + message + "&username=" + USER +
247                             "&password=" + PASS,
248                         "application/x-www-form-urlencoded");
6bdd28 249     std::string b = res->body;
JG 250     std::queue<json::Message*> c = json::parse(b);
251     return c.front();
16b655 252 }
JG 253
254 } // namespace protocol