127 lines
3.7 KiB
C++
127 lines
3.7 KiB
C++
#include "Spartan.h"
|
|
|
|
#include "lib/api/service_helpers/AdminServiceUtils.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/config/protos/spartan.pb.h"
|
|
#include "server/sparkd/cmds/spartan_tas/algo/TASOrderReactor.h"
|
|
#include "server/sparkd/cmds/spartan_tas/algo/TASTriggerDef.h"
|
|
#include "server/sparkd/cmds/spartan_tas/util/SecurityDB.h"
|
|
#include "server/sparkd/user/AdminServiceDB.h"
|
|
#include "server/sparkd/cmds/spartan_tas/util/PCapReader.h"
|
|
#include "server/sparkd/cmds/spartan_tas/util/MDPParser.h"
|
|
#include "server/sparkd/cmds/spartan_tas/util/MDPWriter.h"
|
|
|
|
namespace bts {
|
|
namespace cmd {
|
|
|
|
using namespace spartan;
|
|
|
|
std::vector<TASTriggerDef>
|
|
build_trigger_defs(config::SpartanTASCfg const &cfg) {
|
|
auto user_name = cfg.user();
|
|
auto account = cfg.account();
|
|
auto admin = admin::AdminServiceDB().retrieve();
|
|
bts_assert(admin.has_value());
|
|
SecurityDB db;
|
|
|
|
std::vector<TASTriggerDef> result;
|
|
auto get_trigger = [&result](std::string const &group_symbol) {
|
|
for (auto &t : result)
|
|
if (t.group_symbol == group_symbol)
|
|
return &t;
|
|
result.push_back(TASTriggerDef{group_symbol, {}});
|
|
return &result.back();
|
|
};
|
|
|
|
for (auto const &t : cfg.tas_trigger()) {
|
|
auto const &sym = t.symbol();
|
|
auto sec = db.query_single([&sym](auto const &sec) {
|
|
return sec.has_glbx() && securities::descriptor(sec) == sym;
|
|
});
|
|
bts_assert(sec);
|
|
admin::AdminServiceOperationResult result;
|
|
auto rr = admin::AdminServiceUtils::get_routing_record(
|
|
admin.value(), account, user_name, *sec, result);
|
|
bts_assert_msg(result.is_success(), result.error_text());
|
|
|
|
auto sec_trigger = TASTriggerDef::SecTrigger{*sec, rr, {}};
|
|
sec_trigger.side.set(
|
|
api::Side::SIDE_BUY,
|
|
TASTriggerDef::Side{t.buy().quantity(), t.buy().ticks_away()});
|
|
sec_trigger.side.set(
|
|
api::Side::SIDE_SELL,
|
|
TASTriggerDef::Side{t.sell().quantity(), t.sell().ticks_away()});
|
|
auto trigger = get_trigger(sec->glbx().cme_symbol());
|
|
trigger->sec_triggers.push_back(sec_trigger);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int Spartan::run_from_pcap(std::vector<std::string> const &args) {
|
|
if (args.size() != 2)
|
|
return 1;
|
|
|
|
auto triggers = build_trigger_defs(config::get<config::SpartanTASCfg>());
|
|
bts_assert(triggers.size());
|
|
TASOrderReactor reactor(triggers);
|
|
|
|
utils::PCapReader pcap_reader(args[1]);
|
|
utils::MDPParser parser;
|
|
|
|
parser.set_handler<mktdata::SecurityStatus30>(
|
|
[&reactor](auto const &sec_status) {
|
|
reactor.on_security_status(sec_status);
|
|
});
|
|
|
|
pcap_reader.on_packet() = [&parser](auto const &bytes) {
|
|
parser.on_bytes(bytes);
|
|
};
|
|
|
|
while (pcap_reader.read_next())
|
|
if (!reactor.do_work())
|
|
break;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int Spartan::parse_pcap(std::vector<std::string> const &args) {
|
|
if (args.size() != 2 && args.size() != 3)
|
|
return 1;
|
|
std::cout << "[\n";
|
|
utils::MDPParser parser;
|
|
utils::MDPWriter writer(std::cout, parser);
|
|
utils::PCapReader pcap_reader(
|
|
args[1], args.size() == 3 ? std::string("net ") + args[2] : "");
|
|
|
|
pcap_reader.on_packet() = [&parser](auto const &bytes) {
|
|
if (parser.on_bytes(bytes))
|
|
std::cout << ",\n";
|
|
};
|
|
while (pcap_reader.read_next())
|
|
;
|
|
std::cout << "]\n";
|
|
return 0;
|
|
}
|
|
|
|
int Spartan::execute(std::vector<std::string> const &args) {
|
|
auto error = 1;
|
|
if (args.size() > 0) {
|
|
if (args[0] == "parse_pcap")
|
|
error = parse_pcap(args);
|
|
else if (args[0] == "run_from_pcap")
|
|
error = run_from_pcap(args);
|
|
}
|
|
if (error)
|
|
std::cout << help();
|
|
return error;
|
|
}
|
|
|
|
std::string Spartan::help() {
|
|
return fmt::format(
|
|
"\tparse_pcap file [filter]\n\trun_from_pcap pcap_file\n");
|
|
}
|
|
|
|
} // namespace cmd
|
|
} // namespace bts
|