Files
spark/src/server/sparkd/cmds/AutoCert.cpp
T
2018-05-15 11:58:26 -04:00

694 lines
23 KiB
C++

#include "AutoCert.h"
#include "lib/utils/PBUtils.h"
#include "server/sparkd/cmds/CmdRegistry.h"
#include "lib/utils/bts_chrono.h"
#include "lib/utils/datetime.h"
#include "server/sparkd/jetfix/common/InMsgBuffer.h"
#include "lib/utils/SecureLogon.h"
#include "server/sparkd/jetfix/codec/i32_toa.h"
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <sys/select.h>
namespace bts {
namespace cmd {
unsigned int their_sn;
unsigned int last_received_sn;
void reset_sn(std::string const &session = "99") {
std::ofstream seq("/home/ppinto/seq_num_" + session);
seq << 1;
}
int get_next_sn(std::string const &session = "99") {
int result = 0;
{
std::ifstream seq("/home/ppinto/seq_num_" + session);
seq >> result;
}
{
std::ofstream seq("/home/ppinto/seq_num_" + session);
seq << 1 + result;
}
return result;
}
std::string make_resend_req(int seqnum, int last_seq_num_processed, int begin_s,
int end_s, std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto body = fmt::format("35=2\001"
"34={}\001" // sn
"369={}\001" // their sn
"52={}\001" // time
"49=MBX004N\001"
"56=CME\001"
"142=US,NC\001"
"7={}\001" // begin
"16={}\001" // end
"50=BTS\001"
"57={}\001",
seq_num_str, last_seq_num_str, time_str, begin_s,
end_s, target_subid);
return body;
}
std::string make_hb(int seqnum, int last_seq_num_processed,
std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto body =
fmt::format("35=0\001"
"34={}\001" // sn
"369={}\001" // their sn
"52={}\001" // time
"49=MBX004N\001"
"56=CME\001"
"142=US,NC\001"
"50=BTS\001"
"57={}\001",
seq_num_str, last_seq_num_str, time_str, target_subid);
return body;
}
std::string make_hb(int seqnum, int last_seq_num_processed,
std::string const &test_id,
std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto body = fmt::format("35=0\001"
"34={}\001" // sn
"369={}\001" // their sn
"52={}\001" // time
"49=MBX004N\001"
"56=CME\001"
"112={}\001"
"142=US,NC\001"
"50=BTS\001"
"57={}\001",
seq_num_str, last_seq_num_str, time_str, test_id,
target_subid);
return body;
}
std::string make_logon(int seqnum, int last_seq_num_processed,
std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto ld = bts::glbx::calculate_hmac("MBX", seq_num_str, "MBX004N", "BTS",
time_str, target_subid, "30", "US,NC",
last_seq_num_str, "O2", "1.0", "BTS");
auto body = fmt::format("35=A\001"
"34={}\001" // sn
"369={}\001" // their sn
"52={}\001" // time
"49=MBX004N\001"
"56=CME\001"
"142=US,NC\001"
"50=BTS\001"
"98=0\001"
"108=30\001"
"1603=O2\001"
"1604=1.0\001"
"1605=BTS\001"
"354={}\001" // encoded text len;
"355={}\001" // encoded text
"1400=CME-1-SHA-256\001"
"1401={}\001" // sig size
"1402={}\001"
"57={}\001",
seq_num_str, last_seq_num_str, time_str,
ld.access_key.size(), ld.access_key,
ld.signature.size(), ld.signature, target_subid);
return body;
}
std::string add_header_footer(std::string const &body) {
std::string body_size_str(6, ' ');
i32_toa(body.size(), &body_size_str[0], 6);
auto prelude = fmt::format("8=FIX.4.2\001"
"9={}\001{}",
body_size_str, body);
int32_t chk = 0;
for (auto c : prelude)
chk += c;
std::string check_sum_str(3, ' ');
i32_toa((unsigned int)(chk % 256), &check_sum_str[0], 3);
return fmt::format("{}10={}\001", prelude, check_sum_str);
}
using boost::asio::ip::tcp;
void send(tcp::socket &socket, std::string const &body,
std::string const &session = "99") {
auto all = add_header_footer(body);
std::ofstream f("/home/ppinto/fix_log_" + session,
std::fstream::out | std::fstream::app);
f << all << "\n";
boost::asio::write(socket, boost::asio::buffer(all.data(), all.size()));
std::replace(all.begin(), all.end(), '\001', '|');
std::cout << "> " << all << "\n";
}
std::string receive(tcp::socket &s, std::string const &session = "99") {
std::string buffer(1024, ' ');
std::string str;
auto terminator_len = strlen("\00110=000\001");
for (uint32_t i = 0;; i++) {
bts_assert(i < buffer.size());
s.read_some(boost::asio::buffer(&buffer[i], 1));
if (i > terminator_len && buffer[i] == 1) {
auto sub_str = buffer.substr(i - terminator_len + 1, terminator_len);
if (sub_str.substr(0, 4) == "\00110=") {
str = buffer.substr(0, i);
break;
}
}
}
std::ofstream f("/home/ppinto/fix_log_" + session,
std::fstream::out | std::fstream::app);
f << str << "\n";
f.flush();
auto human_str = str;
std::replace(human_str.begin(), human_str.end(), '\001', '|');
std::cout << "< " << human_str << "\n";
jetfix::InMsgBuffer parser(str);
last_received_sn = parser.get_seq_num();
if (parser.type() == jetfix::MessageTypes::TestRequest) {
auto req_id = parser.get_test_req_id();
send(s, make_hb(get_next_sn(session), last_received_sn, req_id, session),
session);
}
return str;
}
void DetectAGapAndReceiveGapFill() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
auto their_new_sn = jetfix::InMsgBuffer(msg).get_seq_num();
// send gap resolution req
send(socket, make_resend_req(get_next_sn(), their_sn, their_sn + 1,
their_new_sn, "99"));
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::SeqReset);
auto new_sn = jetfix::InMsgBuffer(msg).get_new_seq_no();
bts::sleep_for(30s);
// send hb with the right sn
send(socket, make_hb(get_next_sn(), new_sn - 1, "99"));
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
their_new_sn = jetfix::InMsgBuffer(msg).get_seq_num();
send(socket, make_hb(get_next_sn(), their_new_sn, "99"));
do {
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), new_sn - 1, "99"));
} while (true);
}
void ProcessingMessageGapsOfMoreThan2500Messages() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
auto their_new_sn = jetfix::InMsgBuffer(msg).get_seq_num();
while (their_new_sn > their_sn) {
// send gap resolution req
send(socket,
make_resend_req(get_next_sn(), their_sn, their_sn + 1,
std::min(their_sn + 2500, their_new_sn), "99"));
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() !=
jetfix::MessageTypes::SeqReset);
their_sn = jetfix::InMsgBuffer(msg).get_new_seq_no();
}
bts::sleep_for(30s);
// send hb with the right sn
send(socket, make_hb(get_next_sn(), their_sn, "99"));
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
their_sn = jetfix::InMsgBuffer(msg).get_seq_num();
send(socket, make_hb(get_next_sn(), their_sn, "99"));
do {
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
} while (true);
}
std::string make_order(int seqnum, int last_seq_num_processed,
std::string const &sec_desc,
std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto body = fmt::format("35=D\001" // MsgType
"34={}\001" // Seqnum
"369={}\001" // LastSeqNumProcessed
"52={}\001" // SendingTime
"50=BTS\001" // SenderSubID
"49=MBX004N\001" // SenderCompID
"56=CME\001" // TargetCompID
"142=US,NC\001" // SenderLocationID
"1=BTS\001" // Account
"54=1\001" // Side
"1028=Y\001" // ManualOrderIndicator
"204=1\001" // CustomerOrFirm
"9702=1\001" // CTICode
"107={}\001" // SecurityDesc
"11=1\001" // ClOrdId
"38=6\001" // Quantity
"40=2\001" // OrdType
"44=25\001" // Price
"60={}\001" // TransactTime
"57={}\001" // TargetSubID
,
seq_num_str, last_seq_num_str, time_str, sec_desc,
time_str, target_subid);
return body;
}
std::string make_seq_reset(int seqnum, int last_seq_num_processed,
int new_seq_no, std::string const &target_subid) {
std::string seq_num_str(9, ' ');
i32_toa(seqnum, &seq_num_str[0], 9);
std::string last_seq_num_str(9, ' ');
i32_toa(last_seq_num_processed, &last_seq_num_str[0], 9);
auto time_str = datetime::FIX_timestamp(datetime::now());
auto body = fmt::format("35=4\001" // MsgType
"34={}\001" // Seqnum
"369={}\001" // LastSeqNumProcessed
"52={}\001" // SendingTime
"50=BTS\001" // SenderSubID
"49=MBX004N\001" // SenderCompID
"56=CME\001" // TargetCompID
"142=US,NC\001" // SenderLocationID
"122={}\001" // OrigSendTime
"43=N\001" // PossibleDupFlag
"123=Y\001" // GapFilFlag
"36={}\001" // GapFilFlag
"57=99\001" // TargetSubID
,
seq_num_str, last_seq_num_str, time_str, time_str,
new_seq_no, target_subid);
return body;
}
void ReceivingAndProcessingMultipleGaps() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
// logged in, send order
uint32_t previous_sn = 0;
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
// process messages until we notice a gap
do {
previous_sn = last_received_sn;
msg = receive(socket);
} while ((last_received_sn - previous_sn) == 1);
// send resend request
auto end_of_gap = last_received_sn - 1;
send(socket, make_resend_req(get_next_sn(), their_sn, previous_sn + 1,
end_of_gap, "99"));
auto er1 = receive(socket);
auto er2 = receive(socket);
// 2nd gap
send(socket, make_resend_req(get_next_sn(), their_sn, last_received_sn - 1,
last_received_sn - 1, "99"));
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
}
void RespondToResendRequest() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
// logged in, send order
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
// wait for receive request
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() !=
jetfix::MessageTypes::ResendRequest);
auto start = jetfix::InMsgBuffer(msg).get_begin_seq_no();
auto sn = get_next_sn();
send(socket, make_seq_reset(start, last_received_sn, sn, "99"));
bts::sleep_for(30s);
send(socket, make_hb(sn, their_sn, "99"));
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
}
void BiDirectionalResendRequestScenario() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
// logged in, send 4 orders
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
uint32_t previous_sn = 0;
// process messages until we notice a gap
do {
previous_sn = last_received_sn;
msg = receive(socket);
} while ((last_received_sn - previous_sn) == 1);
// send resend request
auto end_of_gap = last_received_sn - 1;
send(socket, make_resend_req(get_next_sn(), their_sn, previous_sn + 1,
end_of_gap, "99"));
// process messages until we notice a resend req
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() !=
jetfix::MessageTypes::ResendRequest);
auto start = jetfix::InMsgBuffer(msg).get_begin_seq_no();
auto sn = get_next_sn();
send(socket, make_seq_reset(start, last_received_sn, sn, "99"));
bts::sleep_for(30s);
send(socket, make_hb(sn, their_sn, "99"));
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
}
void ProcessRealTimeMessagesDuringAResendResponse() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
std::string msg;
do {
msg = receive(socket);
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
// logged in, send 4 orders
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
send(socket, make_order(get_next_sn(), last_received_sn, "0GLBX8", "99"));
uint32_t previous_sn = 0;
// process messages until we notice a gap
do {
previous_sn = last_received_sn;
msg = receive(socket);
} while ((last_received_sn - previous_sn) == 1);
// send resend request
auto end_of_gap = last_received_sn - 1;
send(socket, make_resend_req(get_next_sn(), their_sn, previous_sn + 1,
end_of_gap, "99"));
// get 2 msgs
receive(socket);
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
bts::sleep_for(30s);
send(socket, make_hb(get_next_sn(), their_sn, "99"));
receive(socket);
}
void ProcessSequenceStreamsBasedOnSessionAndMarketSegment() {
boost::filesystem::remove("/home/ppinto/fix_log_70");
boost::filesystem::remove("/home/ppinto/fix_log_99");
reset_sn();
reset_sn("70");
std::thread t([]() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.199", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn(), their_sn, "99"));
auto logon_ack = receive(socket);
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn(), their_sn, "99"));
for (;;) {
fd_set readSet;
FD_ZERO(&readSet);
FD_SET(STDIN_FILENO, &readSet);
struct timeval tv = {0, 10000}; // 10 seconds, 0 microseconds;
if (select(STDIN_FILENO + 1, &readSet, NULL, NULL, &tv) < 0)
perror("select");
if (FD_ISSET(STDIN_FILENO, &readSet))
break;
else
receive(socket);
}
send(socket,
make_order(get_next_sn("99"), last_received_sn, "1ZWU9", "99"));
while (true)
receive(socket);
});
std::thread t2([]() {
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query("69.50.112.183", "61920");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
send(socket, make_logon(get_next_sn("70"), their_sn, "70"), "70");
auto logon_ack = receive(socket, "70");
their_sn = jetfix::InMsgBuffer(logon_ack).get_seq_num();
bts::sleep_for(30s);
// send hb
send(socket, make_hb(get_next_sn("70"), their_sn, "70"), "70");
std::string msg;
do {
msg = receive(socket, "70");
} while (jetfix::InMsgBuffer(msg).type() != jetfix::MessageTypes::HB);
send(socket,
make_order(get_next_sn("70"), last_received_sn, "1AJCH0", "70"),
"70");
while (true)
receive(socket, "70");
});
t.join();
t2.join();
}
int AutoCert::execute(std::vector<std::string> const &) {
ProcessSequenceStreamsBasedOnSessionAndMarketSegment();
return 0;
}
std::string AutoCert::help() {
return "Provide control over JetFIX so that we can go through AutoCert";
}
}
}