931 lines
29 KiB
C++
931 lines
29 KiB
C++
#include "Session.h"
|
|
|
|
#include "lib/config/config.h"
|
|
#include "lib/jetfix/codec/FIXEncodingStream.h"
|
|
#include "lib/jetfix/codec/FieldDefinitions.h"
|
|
#include "lib/jetfix/codec/MessageTypes.h"
|
|
#include "lib/jetfix/common/OutFIX.h"
|
|
#include "lib/jetfix/connection/IConnection.h"
|
|
#include "lib/jetfix/gateway/ICoreGatewayEventSink.h"
|
|
#include "lib/jetfix/store/IFIXStore.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/tracing/bts_trace.h"
|
|
#include "lib/utils/SecureLogon.h"
|
|
#include "lib/utils/TimeStamp.h"
|
|
#include "lib/utils/datetime.h"
|
|
|
|
#include "lib/config/protos/jetfix.pb.h"
|
|
|
|
#include <boost/format.hpp>
|
|
#include <regex>
|
|
#include <set>
|
|
|
|
namespace bts {
|
|
namespace jetfix {
|
|
|
|
OutFIXPtr make_logon(uint32_t seq_num, uint32_t last_seq_num_processed,
|
|
std::string const &time_str,
|
|
config::JetFIX::Connection const &session_cfg);
|
|
|
|
OutFIXPtr make_logout(config::JetFIX::Connection const &session_cfg);
|
|
OutFIXPtr make_resend_request(config::JetFIX::Connection const &session_cfg,
|
|
uint32_t min, uint32_t max);
|
|
OutFIXPtr make_hb(config::JetFIX::Connection const &session_cfg,
|
|
std::string const &req_id);
|
|
OutFIXPtr make_hb(config::JetFIX::Connection const &session_cfg);
|
|
OutFIXPtr make_test_request(config::JetFIX::Connection const &session_cfg,
|
|
std::string const &tr_id);
|
|
OutFIXPtr make_seq_reset(config::JetFIX::Connection const &session_cfg,
|
|
uint32_t end);
|
|
|
|
enum class Session::State {
|
|
WLOGON,
|
|
RECOVER,
|
|
WTR_REPLY,
|
|
READY,
|
|
TERMINATED,
|
|
WLOGOUT,
|
|
CERT_MODE
|
|
};
|
|
|
|
struct Session::RecoveryState {
|
|
RecoveryState() : buffered_msgs(), resend_request(0, 0) {}
|
|
|
|
std::map<uint32_t, InMsgBuffer> buffered_msgs;
|
|
std::pair<uint32_t, uint32_t> resend_request;
|
|
};
|
|
|
|
struct Session::PImpl {
|
|
PImpl(config::JetFIX::Connection const &cfg, IConnection &connection,
|
|
IFIXStore &store, ICoreGatewayEventSink &sink, Clock const &clock,
|
|
trace::PerfLog &perf_log)
|
|
: cfg(cfg), state(State::TERMINATED), connection(connection),
|
|
store(store), event_sink(sink), now(clock), perf_log(perf_log),
|
|
begin_of_this_session(), last_seq_num(), last_seq_num_processed(),
|
|
last_sent_msg_timestamp(), last_sent_sync_timestamp(),
|
|
last_rcvd_msg_timestamp(), start_of_logon(), start_of_logout(),
|
|
current_time(std::make_shared<std::string>(
|
|
datetime::FIX_timestamp(datetime::now()))),
|
|
recovery_state() {}
|
|
|
|
config::JetFIX::Connection cfg;
|
|
State state;
|
|
IConnection &connection;
|
|
IFIXStore &store;
|
|
ICoreGatewayEventSink &event_sink;
|
|
Clock now;
|
|
trace::PerfLog &perf_log;
|
|
uint32_t begin_of_this_session;
|
|
uint32_t last_seq_num;
|
|
uint32_t last_seq_num_processed;
|
|
utils::TimeStamp last_sent_msg_timestamp;
|
|
utils::TimeStamp last_sent_sync_timestamp;
|
|
utils::TimeStamp last_rcvd_msg_timestamp;
|
|
utils::TimeStamp start_of_logon;
|
|
utils::TimeStamp start_of_logout;
|
|
std::shared_ptr<std::string> current_time;
|
|
std::unique_ptr<RecoveryState> recovery_state;
|
|
};
|
|
|
|
Session::Session(config::JetFIX::Connection const &cfg, IConnection &connection,
|
|
IFIXStore &store, ICoreGatewayEventSink &sink,
|
|
Clock const &clock, trace::PerfLog &perf_log)
|
|
: me(new PImpl(cfg, connection, store, sink, clock, perf_log)) {}
|
|
|
|
Session::~Session() {
|
|
if (me->state != State::TERMINATED)
|
|
terminate_session(JetFIXError::ERROR_NONE);
|
|
}
|
|
|
|
void Session::start() {
|
|
bts_assert(me->state == State::TERMINATED);
|
|
me->begin_of_this_session = me->store.last_seq_num();
|
|
me->start_of_logon = me->now();
|
|
me->last_seq_num = me->begin_of_this_session;
|
|
me->last_seq_num_processed = me->store.last_seq_num_processed();
|
|
transition(State::WLOGON);
|
|
internal_send(make_logon(me->last_seq_num + 1, me->last_seq_num_processed,
|
|
*me->current_time, me->cfg));
|
|
}
|
|
|
|
void Session::send(OutFIXPtr const &msgs, trace::CorID trace) {
|
|
switch (me->state) {
|
|
case State::READY:
|
|
case State::CERT_MODE:
|
|
internal_send(trace, msgs);
|
|
break;
|
|
case State::TERMINATED:
|
|
case State::WLOGOUT:
|
|
break;
|
|
case State::WLOGON:
|
|
case State::RECOVER:
|
|
case State::WTR_REPLY:
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::send_hb() {
|
|
bts_assert(me->state == State::CERT_MODE);
|
|
internal_send(make_hb(me->cfg));
|
|
}
|
|
|
|
void Session::send_test_request() { send_sync_test_request(); }
|
|
|
|
void Session::receive(InMsgBuffer const &msg) {
|
|
me->store.store(msg);
|
|
me->last_rcvd_msg_timestamp = me->now();
|
|
|
|
if (me->state != State::WLOGON &&
|
|
msg.get_seq_num() <= me->last_seq_num_processed) {
|
|
LOG(Jetfix, Error,
|
|
"Discarding repeated message: {} sn: {} state: {} conn: {}",
|
|
(char)msg.type(), msg.get_seq_num(),
|
|
std::string(state_name(me->state)), me->cfg.name());
|
|
return;
|
|
}
|
|
|
|
switch (msg.type()) {
|
|
case MessageTypes::Logon:
|
|
on_logon(msg);
|
|
break;
|
|
case MessageTypes::Logout:
|
|
on_logout(msg);
|
|
break;
|
|
case MessageTypes::TestRequest:
|
|
on_test_request(msg);
|
|
break;
|
|
case MessageTypes::ResendRequest:
|
|
on_resend_request(msg);
|
|
break;
|
|
case MessageTypes::SeqReset:
|
|
on_seq_reset(msg);
|
|
break;
|
|
case MessageTypes::HB:
|
|
on_hb(msg);
|
|
break;
|
|
default:
|
|
on_app(msg);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Session::shutdown() {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
case State::RECOVER:
|
|
case State::WTR_REPLY:
|
|
case State::READY:
|
|
case State::CERT_MODE:
|
|
internal_send(make_logout(me->cfg));
|
|
transition(State::WLOGOUT);
|
|
break;
|
|
case State::WLOGOUT:
|
|
break;
|
|
case State::TERMINATED:
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::time(std::shared_ptr<std::string> const &time_str) {
|
|
me->current_time = time_str;
|
|
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
if (seconds_elapsed(me->start_of_logon) > me->cfg.seconds_to_logon())
|
|
logout(JetFIXError::LOGIN_TIMEOUT);
|
|
break;
|
|
case State::RECOVER:
|
|
update_resend_request_progress();
|
|
if (!resend_request_active())
|
|
send_resend_request();
|
|
break;
|
|
case State::WTR_REPLY:
|
|
if (me->cfg.auto_cert_mode()) {
|
|
if (seconds_elapsed(me->last_sent_msg_timestamp) >
|
|
me->cfg.seconds_between_hbs())
|
|
internal_send(make_hb(me->cfg));
|
|
} else {
|
|
if (seconds_elapsed(me->last_sent_sync_timestamp) >
|
|
me->cfg.seconds_between_syncs())
|
|
send_sync_test_request();
|
|
}
|
|
break;
|
|
case State::READY:
|
|
if (seconds_elapsed(me->last_sent_msg_timestamp) >
|
|
me->cfg.seconds_between_hbs())
|
|
internal_send(make_hb(me->cfg));
|
|
else if (seconds_elapsed(me->last_rcvd_msg_timestamp) >
|
|
me->cfg.seconds_between_hbs() * me->cfg.max_missed_hbs())
|
|
logout(JetFIXError::HB_TIMEOUT);
|
|
break;
|
|
case State::WLOGOUT:
|
|
if (seconds_elapsed(me->start_of_logout) > me->cfg.seconds_to_logout())
|
|
terminate_session(JetFIXError::LOGOUT_TIMEOUT);
|
|
break;
|
|
case State::TERMINATED:
|
|
case State::CERT_MODE:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::on_logon(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON: {
|
|
auto their_last = msg.get_seq_num();
|
|
auto our_last_processed = me->last_seq_num_processed;
|
|
|
|
if (me->cfg.auto_cert_mode()) {
|
|
LOG(Jetfix, Info, "Logged on in CERT mode. Seq: {} {}",
|
|
our_last_processed, their_last);
|
|
me->last_seq_num_processed = msg.get_seq_num() - 1;
|
|
deliver(msg);
|
|
me->event_sink.session_ready();
|
|
transition(State::CERT_MODE);
|
|
} else {
|
|
if (their_last <= our_last_processed)
|
|
terminate_session(
|
|
JetFIXError::INCOMING_SN_TOO_SMALL,
|
|
(boost::format(
|
|
"Incoming sequence number was %d "
|
|
"but the last one we processed was %d. "
|
|
"Most likely the FIX sequencer numbers file "
|
|
"($SPARKDATA/data/jetfix/connection_name/current/seqnum) "
|
|
"was deleted. Update this file with the correct "
|
|
"incoming sequence number (second column)") %
|
|
their_last % our_last_processed)
|
|
.str());
|
|
|
|
else if (their_last == (our_last_processed + 1)) {
|
|
transition(State::WTR_REPLY);
|
|
deliver(msg);
|
|
send_sync_test_request();
|
|
} else {
|
|
me->recovery_state.reset(new RecoveryState());
|
|
transition(State::RECOVER);
|
|
buffer(msg);
|
|
send_resend_request();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case State::RECOVER:
|
|
case State::WTR_REPLY:
|
|
case State::READY:
|
|
terminate_session(JetFIXError::UNEXPECTED_LOGON);
|
|
break;
|
|
case State::WLOGOUT:
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Session::on_logout(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(JetFIXError::LOGGED_OUT_BY_EXCHANGE,
|
|
(boost::format(". %s") % msg.get_text()).str());
|
|
break;
|
|
|
|
case State::RECOVER:
|
|
internal_send(make_logout(me->cfg));
|
|
buffer(msg);
|
|
terminate_session(JetFIXError::LOGGED_OUT_BY_EXCHANGE,
|
|
(boost::format(". %s") % msg.get_text()).str());
|
|
break;
|
|
|
|
case State::WTR_REPLY:
|
|
case State::READY:
|
|
deliver(msg);
|
|
internal_send(make_logout(me->cfg));
|
|
terminate_session(JetFIXError::LOGGED_OUT_BY_EXCHANGE,
|
|
(boost::format(". %s") % msg.get_text()).str());
|
|
break;
|
|
case State::WLOGOUT:
|
|
deliver(msg);
|
|
terminate_session(JetFIXError::ERROR_NONE);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
case State::CERT_MODE:
|
|
LOG(Jetfix, Info, "Logged out by exchange in cert mode Seq: {} {}",
|
|
me->last_seq_num, me->last_seq_num_processed);
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Session::on_test_request(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(
|
|
JetFIXError::EXPECTED_LOGON,
|
|
(boost::format("Received message type %c ") % (char)msg.type())
|
|
.str());
|
|
break;
|
|
case State::RECOVER:
|
|
internal_send(make_hb(me->cfg, msg.get_test_req_id()));
|
|
buffer(msg);
|
|
break;
|
|
|
|
case State::WTR_REPLY:
|
|
case State::CERT_MODE:
|
|
case State::READY:
|
|
if (me->state == State::CERT_MODE)
|
|
LOG(Jetfix, Info, "Received TR in Cert mode. {} {} req_id: {}",
|
|
me->last_seq_num, me->last_seq_num_processed,
|
|
msg.get_test_req_id());
|
|
|
|
deliver(msg);
|
|
internal_send(make_hb(me->cfg, msg.get_test_req_id()));
|
|
break;
|
|
case State::WLOGOUT:
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::on_resend_request(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(
|
|
JetFIXError::EXPECTED_LOGON,
|
|
(boost::format("Received message type %c ") % (int)msg.type()).str());
|
|
break;
|
|
case State::RECOVER:
|
|
case State::WTR_REPLY:
|
|
case State::CERT_MODE:
|
|
case State::READY: {
|
|
if (me->state == State::RECOVER)
|
|
buffer(msg);
|
|
else
|
|
deliver(msg);
|
|
|
|
if (me->state == State::CERT_MODE)
|
|
LOG(Jetfix, Info,
|
|
"Received resend request in Cert mode. {} {} from {} to {}",
|
|
me->last_seq_num, me->last_seq_num_processed,
|
|
msg.get_begin_seq_no(), msg.get_end_seq_no());
|
|
|
|
auto last_msg_in_request = msg.get_end_seq_no();
|
|
if (last_msg_in_request <= me->begin_of_this_session)
|
|
send_seq_reset(msg.get_begin_seq_no(), msg.get_end_seq_no());
|
|
else
|
|
logout(
|
|
JetFIXError::UNEXPECTED_RESEND_REQUEST,
|
|
(boost::format("Received resend request for messages "
|
|
"%d to %d but my initial sequence number is %d ") %
|
|
msg.get_begin_seq_no() % msg.get_end_seq_no() %
|
|
me->begin_of_this_session)
|
|
.str());
|
|
break;
|
|
}
|
|
case State::WLOGOUT:
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::on_seq_reset(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(
|
|
JetFIXError::EXPECTED_LOGON,
|
|
(boost::format("Received message type %c ") % (int)msg.type()).str());
|
|
break;
|
|
case State::RECOVER:
|
|
buffer_or_deliver(msg);
|
|
break;
|
|
case State::CERT_MODE:
|
|
LOG(Jetfix, Info, "Received seq reset in Cert mode. {} {} new_seq: {}",
|
|
me->last_seq_num, me->last_seq_num_processed, msg.get_new_seq_no());
|
|
me->last_seq_num_processed = msg.get_new_seq_no() - 1;
|
|
me->store.set_last_msg_processed(me->last_seq_num_processed);
|
|
break;
|
|
case State::WTR_REPLY:
|
|
case State::READY:
|
|
deliver(msg);
|
|
logout(JetFIXError::UNEXPECTED_SEQ_RESET);
|
|
break;
|
|
case State::WLOGOUT:
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::on_hb(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(
|
|
JetFIXError::EXPECTED_LOGON,
|
|
(boost::format("Received message type %c ") % (int)msg.type()).str());
|
|
break;
|
|
case State::RECOVER:
|
|
buffer(msg);
|
|
break;
|
|
case State::WTR_REPLY:
|
|
deliver(msg);
|
|
if (msg.has_test_req_id() && msg.get_test_req_id() == "sync") {
|
|
me->event_sink.session_ready();
|
|
transition(State::READY);
|
|
}
|
|
break;
|
|
case State::READY:
|
|
case State::CERT_MODE:
|
|
case State::WLOGOUT:
|
|
if (me->state == State::CERT_MODE)
|
|
LOG(Jetfix, Info, "Received HB in Cert mode. {} {} from {} to {}",
|
|
me->last_seq_num, me->last_seq_num_processed);
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::on_app(InMsgBuffer const &msg) {
|
|
switch (me->state) {
|
|
case State::WLOGON:
|
|
terminate_session(
|
|
JetFIXError::EXPECTED_LOGON,
|
|
(boost::format("Received message type %c ") % (int)msg.type()).str());
|
|
break;
|
|
case State::RECOVER:
|
|
buffer_or_deliver(msg);
|
|
break;
|
|
case State::WTR_REPLY:
|
|
case State::READY:
|
|
case State::WLOGOUT:
|
|
case State::CERT_MODE:
|
|
deliver(msg);
|
|
break;
|
|
case State::TERMINATED:
|
|
break;
|
|
default:
|
|
bts_assert(false);
|
|
}
|
|
}
|
|
|
|
void Session::deliver(InMsgBuffer const &msg) {
|
|
auto sn = msg.get_seq_num();
|
|
bts_assert(sn == me->last_seq_num_processed + 1);
|
|
me->last_seq_num_processed++;
|
|
me->store.set_last_msg_processed(me->last_seq_num_processed);
|
|
me->event_sink.in_msg_sequenced(msg);
|
|
}
|
|
|
|
void Session::buffer(InMsgBuffer const &msg) {
|
|
bts_assert(me->state == State::RECOVER);
|
|
bts_assert(msg.type() != MessageTypes::SeqReset);
|
|
|
|
auto sn = msg.get_seq_num();
|
|
bts_assert(sn > me->last_seq_num_processed + 1);
|
|
bts_assert(me->recovery_state);
|
|
me->recovery_state->buffered_msgs[sn] = msg;
|
|
|
|
bts_assert(me->recovery_state->buffered_msgs.begin()->first >
|
|
me->last_seq_num_processed + 1);
|
|
}
|
|
|
|
void Session::buffer_or_deliver(InMsgBuffer const &msg) {
|
|
bts_assert(me->state == State::RECOVER);
|
|
auto sn = msg.get_seq_num();
|
|
|
|
me->recovery_state->buffered_msgs[sn] = msg;
|
|
|
|
std::set<uint32_t> to_remove;
|
|
for (auto &p : me->recovery_state->buffered_msgs) {
|
|
auto sn = p.first;
|
|
auto msg = p.second;
|
|
if (sn == me->last_seq_num_processed + 1) {
|
|
to_remove.insert(sn);
|
|
deliver(msg);
|
|
if (msg.type() == MessageTypes::SeqReset) {
|
|
me->last_seq_num_processed = msg.get_new_seq_no() - 1;
|
|
me->store.set_last_msg_processed(me->last_seq_num_processed);
|
|
}
|
|
} else if (sn <= me->last_seq_num_processed) {
|
|
// a sequence reset might have advanced us past
|
|
// buffered admin messages
|
|
to_remove.insert(sn);
|
|
} else
|
|
break;
|
|
}
|
|
|
|
for (auto sn : to_remove)
|
|
me->recovery_state->buffered_msgs.erase(sn);
|
|
|
|
if (me->recovery_state->buffered_msgs.empty()) {
|
|
me->recovery_state.reset();
|
|
transition(State::WTR_REPLY);
|
|
send_sync_test_request();
|
|
}
|
|
}
|
|
|
|
void Session::internal_send(OutFIXPtr const &msgs) {
|
|
internal_send(trace::CorID{}, msgs);
|
|
}
|
|
|
|
void Session::internal_send(trace::CorID trace, OutFIXPtr const &msgs) {
|
|
IConnection::WriteVec data_vec;
|
|
bts_assert(msgs->fix.size() < IConnection::MaxWriteVecSz);
|
|
|
|
msgs->set_ts(OutFIX::PRE_STAMP, utils::TimeStamp::now());
|
|
for (size_t i = 0; i < msgs->fix.size(); i++) {
|
|
auto &s = msgs->fix[i];
|
|
me->last_seq_num = s.stamp(me->last_seq_num, me->last_seq_num_processed,
|
|
*me->current_time);
|
|
data_vec[i].first = s.data();
|
|
data_vec[i].second = s.size();
|
|
}
|
|
if (me->connection.write(data_vec, msgs->fix.size(), trace) < 0) {
|
|
terminate_session(JetFIXError::CONNECTION_ERROR);
|
|
return;
|
|
}
|
|
me->last_sent_msg_timestamp = me->now();
|
|
me->store.store(msgs);
|
|
msgs->set_ts(OutFIX::POST_STORE, utils::TimeStamp::now());
|
|
}
|
|
|
|
void Session::logout(JetFIXError::Code error) { logout(error, ""); }
|
|
|
|
void Session::logout(JetFIXError::Code error, std::string const &extra_info) {
|
|
auto level = Info;
|
|
if (error != JetFIXError::ERROR_NONE &&
|
|
error != JetFIXError::USER_DISCONNECTED)
|
|
level = Error;
|
|
else
|
|
level = Info;
|
|
|
|
LOG(Jetfix, level, "Logging out of jetfix session: {} {} conn: {}",
|
|
std::string(JetFIXError::code_msg(error)), extra_info, me->cfg.name());
|
|
|
|
me->start_of_logout = me->now();
|
|
internal_send(make_logout(me->cfg));
|
|
transition(State::WLOGOUT);
|
|
}
|
|
|
|
void Session::terminate_session(JetFIXError::Code reason) {
|
|
terminate_session(reason, "");
|
|
}
|
|
|
|
bool match_with_outgoing_sn_too_small(std::string const &msg, uint32_t *sn) {
|
|
std::string rx_str =
|
|
".*Sequence number received lower than expected. Expected "
|
|
"\\[(\\d+)\\] Received \\d+.*";
|
|
std::regex rx(rx_str);
|
|
|
|
std::smatch matches;
|
|
if (std::regex_match(msg, matches, rx)) {
|
|
*sn = std::stoi(matches[1]);
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
bool match_with_incoming_sn_too_small(std::string const &msg, uint32_t *sn) {
|
|
std::string rx_str = ".*Incoming sequence number was (\\d+) "
|
|
"but the last one we processed was .*";
|
|
|
|
std::regex rx(rx_str);
|
|
|
|
std::smatch matches;
|
|
if (std::regex_match(msg, matches, rx)) {
|
|
*sn = std::stoi(matches[1]);
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
void Session::terminate_session(JetFIXError::Code error,
|
|
std::string const &extra_info) {
|
|
me->recovery_state.reset();
|
|
|
|
auto level = Info;
|
|
if (error != JetFIXError::ERROR_NONE &&
|
|
error != JetFIXError::USER_DISCONNECTED)
|
|
level = Error;
|
|
else
|
|
level = Info;
|
|
|
|
LOG(Jetfix, level, "Jetfix session disconnected: {} {} conn: {}",
|
|
std::string(JetFIXError::code_msg(error)), extra_info, me->cfg.name());
|
|
|
|
if (me->cfg.auto_fix_seq_num()) {
|
|
if (error == JetFIXError::LOGGED_OUT_BY_EXCHANGE) {
|
|
uint32_t fixed_sn;
|
|
if (match_with_outgoing_sn_too_small(extra_info, &fixed_sn)) {
|
|
LOG(Jetfix, Warn,
|
|
"Auto fixing outgoing sequence number for {}. Sequence set to "
|
|
"{}",
|
|
me->cfg.name(), fixed_sn);
|
|
me->store.set_last_seq_num(fixed_sn - 1);
|
|
}
|
|
} else if (error == JetFIXError::INCOMING_SN_TOO_SMALL) {
|
|
uint32_t fixed_sn;
|
|
if (match_with_incoming_sn_too_small(extra_info, &fixed_sn)) {
|
|
LOG(Jetfix, Warn,
|
|
"Auto fixing incoming sequence number for {}. Sequence set to "
|
|
"{}",
|
|
me->cfg.name(), fixed_sn);
|
|
me->store.set_last_msg_processed(fixed_sn);
|
|
}
|
|
}
|
|
}
|
|
|
|
transition(State::TERMINATED);
|
|
me->event_sink.session_terminated();
|
|
}
|
|
int32_t Session::seconds_elapsed(utils::TimeStamp since) {
|
|
return (me->now() - since).seconds();
|
|
}
|
|
|
|
void Session::send_seq_reset(uint32_t sn, uint32_t new_sn) {
|
|
int end_seq_n;
|
|
if (new_sn == 0)
|
|
end_seq_n = me->last_seq_num + 1;
|
|
else
|
|
end_seq_n = new_sn + 1;
|
|
|
|
auto msg = make_seq_reset(me->cfg, end_seq_n);
|
|
auto &stream = msg->fix[0];
|
|
stream.stamp(sn - 1, me->last_seq_num_processed, *me->current_time);
|
|
IConnection::WriteVec data_vec;
|
|
data_vec[0].first = stream.data();
|
|
data_vec[0].second = stream.size();
|
|
if (me->connection.write(data_vec, 1, trace::CorID()) < 0) {
|
|
terminate_session(JetFIXError::CONNECTION_ERROR);
|
|
return;
|
|
} else {
|
|
me->last_sent_msg_timestamp = me->now();
|
|
me->store.store(msg);
|
|
}
|
|
}
|
|
|
|
void Session::send_resend_request() {
|
|
bts_assert(me->state == State::RECOVER);
|
|
bts_assert(!resend_request_active());
|
|
|
|
auto gap = find_first_incoming_msg_gap();
|
|
bts_assert(gap.first);
|
|
bts_assert(gap.second);
|
|
// adjust to exchange limit on max messages in request
|
|
if (gap.second > (gap.first + me->cfg.max_msgs_in_resend_req()))
|
|
gap.second = gap.first + me->cfg.max_msgs_in_resend_req();
|
|
|
|
LOG(Jetfix, Warn,
|
|
"Issuing recovery request in connection {} "
|
|
" asking for messages with sequence numbers from {} to {}",
|
|
me->cfg.name(), gap.first, gap.second);
|
|
|
|
internal_send(make_resend_request(me->cfg, gap.first, gap.second));
|
|
me->recovery_state->resend_request = gap;
|
|
}
|
|
|
|
void Session::send_sync_test_request() {
|
|
bts_assert(me->state == State::WTR_REPLY || me->state == State::CERT_MODE);
|
|
me->last_sent_sync_timestamp = me->now();
|
|
internal_send(make_test_request(me->cfg, "sync"));
|
|
}
|
|
|
|
void Session::update_resend_request_progress() {
|
|
bts_assert(me->state == State::RECOVER);
|
|
|
|
if (resend_request_active()) {
|
|
auto request_last = me->recovery_state->resend_request.second;
|
|
if (me->last_seq_num_processed >= request_last)
|
|
me->recovery_state->resend_request = std::make_pair(0, 0);
|
|
}
|
|
}
|
|
|
|
std::pair<uint32_t, uint32_t> Session::find_first_incoming_msg_gap() {
|
|
if (me->recovery_state->buffered_msgs.empty())
|
|
return std::make_pair(0u, 0u);
|
|
else
|
|
return std::make_pair(me->last_seq_num_processed + 1,
|
|
me->recovery_state->buffered_msgs.begin()->first -
|
|
1);
|
|
}
|
|
|
|
bool Session::resend_request_active() {
|
|
return me->recovery_state->resend_request.first != 0;
|
|
}
|
|
|
|
void Session::transition(State new_state) {
|
|
LOG(Jetfix, Warn, "Jetfix connection {} transitioning from {} to {}",
|
|
me->cfg.name(), std::string(state_name(me->state)),
|
|
std::string(state_name(new_state)));
|
|
me->state = new_state;
|
|
}
|
|
|
|
const char *Session::state_name(State state) {
|
|
switch (state) {
|
|
case State::WLOGON:
|
|
return "WLOGON";
|
|
case State::RECOVER:
|
|
return "RECOVER";
|
|
case State::WTR_REPLY:
|
|
return "WTR_REPLY";
|
|
case State::READY:
|
|
return "READY";
|
|
case State::TERMINATED:
|
|
return "TERMINATED";
|
|
case State::WLOGOUT:
|
|
return "WLOGOUT";
|
|
case State::CERT_MODE:
|
|
return "CERT_MODE";
|
|
default:
|
|
bts_assert(false);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
OutFIXPtr make_logon(uint32_t seq_num, uint32_t last_seq_num_processed,
|
|
std::string const &time_str,
|
|
config::JetFIX::Connection const &session_cfg) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::Logon);
|
|
using namespace fix;
|
|
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
buffer.add<EncryptMethod>(0);
|
|
buffer.add<HeartBtInt>(session_cfg.seconds_between_hbs());
|
|
|
|
#ifndef BTS_EDGE
|
|
const char *application = "SPARK";
|
|
#else
|
|
const char *application = "O2";
|
|
#endif
|
|
|
|
if(session_cfg.platform() == bts::config::JetFIX_Connection_JetFIXPlatform_ICE ||
|
|
session_cfg.platform() == bts::config::JetFIX_Connection_JetFIXPlatform_SIMICE)
|
|
{
|
|
std::string sender_comp_id = session_cfg.sender_subid();
|
|
buffer.add<ICEApplicationSystemName>(sender_comp_id);
|
|
buffer.add<ICEApplicationSystemVersion>("1.0");
|
|
buffer.add<ICEApplicationSystemVendor>(sender_comp_id);
|
|
|
|
buffer.add<UserName>(session_cfg.user_name());
|
|
buffer.add<RawDataLength>(session_cfg.raw_data().size());
|
|
buffer.add<RawData>(session_cfg.raw_data());
|
|
buffer.add<EncryptMethod>(0);
|
|
buffer.add<ICEStrategyPreference>(1);
|
|
buffer.add<ICETimeStampPreference>(1);
|
|
}
|
|
else
|
|
{
|
|
buffer.add<ApplicationSystemName>(application);
|
|
buffer.add<ApplicationSystemVersion>("1.0");
|
|
buffer.add<ApplicationSystemVendor>("BTS");
|
|
|
|
if (session_cfg.has_trading_session_id()) {
|
|
buffer.add<fix::NoTradingSessions>(1);
|
|
buffer.add<fix::TradingSessionID>(session_cfg.trading_session_id());
|
|
}
|
|
if (session_cfg.has_udf_support_indicator())
|
|
buffer.add<fix::UDFSupportIndicator>(session_cfg.udf_support_indicator());
|
|
|
|
if (session_cfg.use_cme_secure_logon()) {
|
|
bts_assert(session_cfg.sender_compid().size() >= 3);
|
|
auto session_id = session_cfg.sender_compid().substr(0, 3);
|
|
std::string seq_num_str(9, ' ');
|
|
i32_toa(seq_num, &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 ld = glbx::calculate_hmac(
|
|
session_id, seq_num_str, session_cfg.sender_compid(),
|
|
session_cfg.sender_subid(), time_str, session_cfg.target_subid(),
|
|
std::to_string(session_cfg.seconds_between_hbs()),
|
|
session_cfg.sender_locationid(), last_seq_num_str, application, "1.0",
|
|
"BTS");
|
|
#ifndef BTS_EDGE
|
|
LOG(Jetfix, Info, "Canonical string for secure logon: {}", ld.canonical);
|
|
#endif
|
|
buffer.add<EncodedTextLen>(ld.access_key.size());
|
|
buffer.add<EncodedText>(ld.access_key);
|
|
buffer.add<EncryptedPasswordMethod>("CME-1-SHA-256");
|
|
buffer.add<EncryptedPasswordLen>(ld.signature.size());
|
|
buffer.add<EncryptedPassword>(ld.signature);
|
|
}
|
|
else
|
|
{
|
|
buffer.add<RawDataLength>(session_cfg.raw_data().size());
|
|
buffer.add<RawData>(session_cfg.raw_data());
|
|
if(session_cfg.user_name() != "")
|
|
buffer.add<UserName>(session_cfg.user_name());
|
|
}
|
|
}
|
|
|
|
stream.close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_logout(config::JetFIX::Connection const &session_cfg) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto stream = &result->fix.back();
|
|
using namespace fix;
|
|
|
|
auto &buffer = stream->new_msg(MessageTypes::Logout);
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
stream->close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_resend_request(config::JetFIX::Connection const &session_cfg,
|
|
uint32_t min, uint32_t max) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::ResendRequest);
|
|
using namespace fix;
|
|
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
buffer.add<BeginSeqNo>(min);
|
|
buffer.add<EndSeqNo>(max);
|
|
stream.close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_hb(config::JetFIX::Connection const &session_cfg,
|
|
std::string const &req_id) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::HB);
|
|
using namespace fix;
|
|
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
buffer.add<TestReqId>(req_id);
|
|
stream.close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_hb(config::JetFIX::Connection const &session_cfg) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::HB);
|
|
buffer.add<fix::SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<fix::SenderLocationID>(session_cfg.sender_locationid());
|
|
stream.close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_test_request(config::JetFIX::Connection const &session_cfg,
|
|
std::string const &req_id) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::TestRequest);
|
|
using namespace fix;
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
buffer.add<TestReqId>(req_id);
|
|
stream.close();
|
|
return result;
|
|
}
|
|
|
|
OutFIXPtr make_seq_reset(config::JetFIX::Connection const &session_cfg,
|
|
uint32_t end) {
|
|
auto result = std::make_shared<OutFIX>(session_cfg);
|
|
auto &stream = result->fix.back();
|
|
auto &buffer = stream.new_msg(MessageTypes::SeqReset);
|
|
using namespace fix;
|
|
buffer.add<SenderSubID>(session_cfg.sender_subid());
|
|
buffer.add<SenderLocationID>(session_cfg.sender_locationid());
|
|
buffer.add<OrigSendingTime>(datetime::now());
|
|
buffer.add<PossDupFlag>(true);
|
|
buffer.add<GapFillFlag>(true);
|
|
buffer.add<NewSeqNo>(end);
|
|
stream.close();
|
|
return result;
|
|
}
|
|
} // namespace jetfix
|
|
} // namespace bts
|