162 lines
5.7 KiB
C++
162 lines
5.7 KiB
C++
// Fleet overlay scoring: ReplayOptions.fleet_surprisal fills WindowSummary.fleet_bits.
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <unistd.h>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "strawberry/database.hpp"
|
|
#include "strawberry/fleet_export.hpp"
|
|
#include "strawberry/learn/replay.hpp"
|
|
#include "strawberry/store/log_store.hpp"
|
|
#include "strawberry/telemetry.hpp"
|
|
|
|
using namespace strawberry;
|
|
|
|
#define CHECK(cond) \
|
|
do { \
|
|
if (!(cond)) { \
|
|
std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
|
|
std::exit(1); \
|
|
} \
|
|
} while (0)
|
|
|
|
namespace {
|
|
|
|
constexpr int64_t kSec = 1'000'000'000;
|
|
constexpr int64_t kT0 = 1'800'000'000 * kSec;
|
|
|
|
TelemetryEvent exec(int64_t ts, int pid, const std::string& node, const std::string& parent, const std::string& exe,
|
|
const std::string& cmdline) {
|
|
ProcessExecRecord r;
|
|
r.timestamp_ns = ts;
|
|
r.pid = pid;
|
|
r.process_node_id = node;
|
|
r.parent_node_id = parent;
|
|
r.exe = exe;
|
|
r.cmdline = cmdline;
|
|
r.source = "live";
|
|
return {store::RecordType::process_exec, encode_process_exec(r)};
|
|
}
|
|
|
|
TelemetryEvent connect(int64_t ts, int pid, const std::string& address, int port) {
|
|
BehaviorEvent b;
|
|
b.type = BehaviorEvent::Type::connect;
|
|
b.timestamp_ns = static_cast<uint64_t>(ts);
|
|
b.pid = pid;
|
|
b.family = 2;
|
|
b.address = address;
|
|
b.port = static_cast<uint16_t>(port);
|
|
return {store::RecordType::connect, encode_behavior(b)};
|
|
}
|
|
|
|
std::vector<TelemetryEvent> events() {
|
|
std::vector<TelemetryEvent> ev;
|
|
ev.push_back(exec(kT0 + kSec, 300, "process_300_b_1", "", "/usr/bin/curl", "curl x"));
|
|
ev.push_back(connect(kT0 + 2 * kSec, 300, "1.2.3.4", 443));
|
|
return ev;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
learn::ReplayOptions o;
|
|
o.live = true;
|
|
o.warmup_ns = 0;
|
|
o.fleet_surprisal = [](learn::TupleKind, std::string_view) { return 7.0f; };
|
|
learn::WindowSummary captured{};
|
|
bool got = false;
|
|
o.on_window_closed = [&](const learn::ReplayWindow&, const learn::WindowSummary& s) {
|
|
captured = s;
|
|
got = true;
|
|
};
|
|
learn::Replayer r(o);
|
|
for (const auto& e : events()) r.feed(e.type, e.payload);
|
|
r.finish();
|
|
CHECK(got);
|
|
bool any = false;
|
|
for (float v : captured.fleet_bits) {
|
|
CHECK(v <= 7.0f);
|
|
if (v == 7.0f) any = true;
|
|
}
|
|
CHECK(any);
|
|
|
|
learn::ReplayOptions o2 = o;
|
|
o2.fleet_surprisal = {};
|
|
learn::WindowSummary cap2{};
|
|
bool got2 = false;
|
|
o2.on_window_closed = [&](const learn::ReplayWindow&, const learn::WindowSummary& s) {
|
|
cap2 = s;
|
|
got2 = true;
|
|
};
|
|
learn::Replayer r2(o2);
|
|
for (const auto& e : events()) r2.feed(e.type, e.payload);
|
|
r2.finish();
|
|
CHECK(got2);
|
|
for (float v : cap2.fleet_bits) CHECK(v == 0.0f);
|
|
|
|
{
|
|
// export_store with a fleet_surprisal callback populates fleet slots x[37..41].
|
|
namespace fs = std::filesystem;
|
|
const auto dir = fs::temp_directory_path() / ("sb_fleet_overlay_exp_" + std::to_string(::getpid()));
|
|
const auto out1 = fs::temp_directory_path() / ("sb_fleet_overlay_exp1_" + std::to_string(::getpid()) + ".sbx");
|
|
const auto out2 = fs::temp_directory_path() / ("sb_fleet_overlay_exp2_" + std::to_string(::getpid()) + ".sbx");
|
|
std::error_code ec;
|
|
fs::remove_all(dir, ec);
|
|
{
|
|
Database db;
|
|
CHECK(db.open(dir.string()));
|
|
auto evs = events();
|
|
CHECK(db.append_telemetry(evs, true));
|
|
db.close();
|
|
}
|
|
fleet::ExportManifest m;
|
|
m.node_uid = "n-ov";
|
|
std::string err;
|
|
auto fsur = [](learn::TupleKind, std::string_view) { return 5.0f; };
|
|
CHECK(fleet::export_store(dir.string(), m, out1.string(), err, "", fsur));
|
|
bool saw_fleet = false;
|
|
std::size_t nfeat = 0;
|
|
fleet::ExportManifest back;
|
|
CHECK(fleet::read_export_bundle(out1.string(), back, [&](uint32_t type, std::string_view payload) {
|
|
if (type == static_cast<uint32_t>(store::RecordType::export_window_feature)) {
|
|
fleet::ExportWindowFeature f;
|
|
if (fleet::decode_export_window_feature(payload, f)) {
|
|
++nfeat;
|
|
for (std::size_t i = 37; i <= 41; ++i)
|
|
if (f.features[i] == 5.0f / 16.0f) saw_fleet = true;
|
|
}
|
|
}
|
|
}));
|
|
CHECK(nfeat >= 1);
|
|
CHECK(saw_fleet);
|
|
|
|
// Control: no callback -> fleet slots all zero.
|
|
std::string err2;
|
|
CHECK(fleet::export_store(dir.string(), m, out2.string(), err2));
|
|
std::size_t nfeat2 = 0;
|
|
bool nonzero = false;
|
|
fleet::ExportManifest back2;
|
|
CHECK(fleet::read_export_bundle(out2.string(), back2, [&](uint32_t type, std::string_view payload) {
|
|
if (type == static_cast<uint32_t>(store::RecordType::export_window_feature)) {
|
|
fleet::ExportWindowFeature f;
|
|
if (fleet::decode_export_window_feature(payload, f)) {
|
|
++nfeat2;
|
|
for (std::size_t i = 37; i <= 41; ++i)
|
|
if (f.features[i] != 0.0f) nonzero = true;
|
|
}
|
|
}
|
|
}));
|
|
CHECK(nfeat2 >= 1);
|
|
CHECK(!nonzero);
|
|
fs::remove_all(dir, ec);
|
|
fs::remove(out1, ec);
|
|
fs::remove(out2, ec);
|
|
}
|
|
|
|
std::puts("ok");
|
|
return 0;
|
|
}
|