dandri/pyxis
1
0
Fork 0
mirror of https://github.com/torlando-tech/pyxis.git synced 2026-08-28 13:34:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
main
pyxis/tests/native/nomadnet_x86_flow/client.cpp
T

718 lines
32 KiB
C++
Raw Permalink Blame History

#include <microStore/Adapters/UniversalFileSystem.h>
#include <microStore/FileSystem.h>
#include <UDPInterface.h>
#include <microReticulum.h>
#include "TCPClientInterface.h"
#include "NomadNetActionMailbox.h"
#include "NomadNetDocument.h"
#include "NomadNetCompactPage.h"
#include "NomadNetForm.h"
#include "NomadNetHistory.h"
#include "NomadNetLibrary.h"
#include "NomadNetMailbox.h"
#include "NomadNetOwner.h"
#include "NomadNetPartialController.h"
#include "NomadNetPartialScheduler.h"
#include "NomadNetProtocol.h"
#include "NomadNetUrl.h"
#include "BuildManifest.h"
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
namespace NN = UI::LXMF::NomadNet;
static RNS::Reticulum reticulum({RNS::Type::NONE});
static RNS::Interface network_interface({RNS::Type::NONE});
static TCPClientInterface* tcp_interface = nullptr;
static RNS::Destination destination({RNS::Type::NONE});
static RNS::Link active_link({RNS::Type::NONE});
static RNS::RequestReceipt receipt({RNS::Type::NONE});
static RNS::Identity local_identity({RNS::Type::NONE});
static NN::AsyncMailbox mailbox;
static NN::ActionMailbox actions;
static std::string scenario;
static std::string destination_hex;
static std::string expected_destination_hex;
static bool announce_seen = false;
static bool link_established = false;
static bool request_started = false;
static double request_started_at = 0.0;
static bool application_deadline_fired = false;
static bool completed = false;
static bool passed = false;
static bool progress_seen = false;
static int progress_callbacks = 0;
static bool cancellation_started = false;
static double cancellation_at = 0.0;
static int stale_callback_rejections = 0;
static bool resource_started = false;
static bool resource_progress = false;
static bool receipt_failed = false;
static bool pending_empty = false;
static bool link_closed = false;
static int link_callbacks = 0;
static int reuse_requests = 0;
static NN::PageHistory owner_history;
static NN::PageHistory::PendingOpen owner_pending_history;
static int owner_requests = 0;
static bool owner_submit = false;
static bool owner_history_bytes = false;
static bool owner_retained_link = false;
static bool owner_back_restored = false;
static bool owner_reload_reused = false;
static NN::ExternalVector<uint8_t> owner_first_request;
static NN::OwnerController owner;
static NN::PartialScheduler partial_scheduler;
static NN::PartialController partial_controller;
static NN::PartialRequest partial_request;
static NN::CompactPage partial_page;
static bool partial_live = false;
class ScreenSubmissionSource final : public NN::OwnerSubmissionSource {
public:
explicit ScreenSubmissionSource(const char* value) : _value(value) {}
bool prepare_submission(uint16_t, uint32_t, std::string& target,
NN::ExternalVector<uint8_t>& output,
NN::FormEncodeResult& result) override {
NN::DocumentParser parser;
const auto document = parser.parse(
"`<name`Initial> `<!|password`Initial> "
"`<?|color|red|*`Red> `<?|color|blue|*`Blue> "
"`[:/page/form.mu`name|password|color|fixed=yes`Submit]");
NN::CompactPage page;
NN::FormState state;
if (!page.assign(document) || !state.assign(page) ||
!state.set_value(0, _value) || !state.set_value(1, "example-pass")) {
result = NN::FormEncodeResult::ALLOCATION_FAILED;
return false;
}
result = state.encode("name|password|color|fixed=yes", output);
target = destination_hex + ":/page/form.mu";
return result == NN::FormEncodeResult::OK;
}
private:
const char* _value;
};
static bool prepare_form_request(NN::ExternalVector<uint8_t>& output) {
NN::DocumentParser parser;
const auto document = parser.parse(
"`<name`Initial> `<!|password`Initial> "
"`<?|color|red|*`Red> `<?|color|blue|*`Blue>");
NN::CompactPage page;
NN::FormState state;
if (!page.assign(document) || !state.assign(page) ||
!state.set_value(0, "Example User") ||
!state.set_value(1, "example-pass")) return false;
return state.encode("name|password|color|fixed=yes", output) ==
NN::FormEncodeResult::OK;
}
static std::vector<uint8_t> bytes_vector(const RNS::Bytes& bytes) {
if (bytes.size() == 0) return {};
return std::vector<uint8_t>(bytes.data(), bytes.data() + bytes.size());
}
static void fail(const char* message) {
std::printf("FAIL %s\n", message);
completed = true;
passed = false;
}
static bool validate_page(const RNS::Bytes& response, bool expect_large) {
NN::ResponseBuffer normalized;
if (!NN::normalize_response(response.data(), response.size(), normalized)) {
fail("response normalization");
return false;
}
const std::string source(reinterpret_cast<const char*>(normalized.bytes().data()), normalized.size());
NN::Document document = NN::DocumentParser().parse(source);
if (document.malformed || document.truncated || document.blocks.empty()) {
fail("Micron parse");
return false;
}
const bool form_scenario = scenario == "form-anonymous" || scenario == "form-identified" ||
scenario == "owner-form-history";
const char* marker = form_scenario ? "Form response" :
(expect_large ? "Resource-backed page" : "Immediate page");
std::string lan_heading;
if (scenario == "lan") {
for (const auto& block : document.blocks) {
if (block.type != NN::BlockType::HEADING) continue;
for (const auto& run : block.runs) lan_heading += run.text;
if (!lan_heading.empty()) break;
}
std::printf("LAN PAGE bytes=%zu blocks=%zu links=%zu heading=%s\n",
normalized.size(), document.blocks.size(), document.links.size(),
lan_heading.c_str());
if (source.empty()) {
fail("LAN page empty");
return false;
}
marker = lan_heading.empty() ? "NomadNet LAN page" : lan_heading.c_str();
} else if (source.find(marker) == std::string::npos) {
fail("page content marker");
return false;
}
const std::string path = form_scenario ? "/page/form.mu" :
scenario == "lan" ? "/page/index.mu" :
scenario == "near-limit" ? "/page/near-limit.mu" :
(expect_large ? "/page/resource.mu" : "/page/immediate.mu");
const std::string url = destination_hex + ":" + path;
NN::Url parsed;
std::string error;
if (!NN::Url::parse(url, parsed, error) || parsed.destination_hex != destination_hex || parsed.path != path) {
fail("absolute URL parse");
return false;
}
NN::Url relative;
if (!NN::Url::parse(":/page/next.mu", relative, error, destination_hex) ||
relative.destination_hex != destination_hex || relative.path != "/page/next.mu") {
fail("relative URL parse");
return false;
}
NN::Library library;
if (!library.hear_node(destination_hex, "x86 NomadNet peer", 100, 1) ||
!library.record_page(url, marker, 101) ||
!library.set_page_saved(url, true)) {
fail("library record/save");
return false;
}
const auto encoded = library.encode();
NN::Library restored;
if (encoded.empty() || !restored.decode(encoded.data(), encoded.size()) ||
!restored.page_saved(url) || restored.nodes().size() != 1 || restored.pages().size() != 1) {
fail("library persistence reload");
return false;
}
// Exercise the Save -> Back ordering used by the owner loop. Save remains
// durable work, but the terminal action is guaranteed to follow it.
if (scenario == "owner-form-history") return true;
if (!actions.publish(NN::UserActionKind::SAVE, url) ||
!actions.publish(NN::UserActionKind::BACK, "")) {
fail("Save/Back publication");
return false;
}
NN::UserAction action;
if (!actions.pop(action) || action.kind != NN::UserActionKind::SAVE ||
!actions.pop(action) || action.kind != NN::UserActionKind::BACK) {
fail("Save/Back ordering");
return false;
}
return true;
}
static void on_response(const RNS::RequestReceipt& callback_receipt) {
const RNS::Bytes token = callback_receipt.get_request_id();
const RNS::Bytes response = callback_receipt.get_response();
if (!mailbox.publish_response(bytes_vector(token), response.data(), response.size(),
callback_receipt.response_transfer_size())) {
++stale_callback_rejections;
}
}
static void on_failed(const RNS::RequestReceipt& callback_receipt) {
const auto token = bytes_vector(callback_receipt.get_request_id());
const bool published = callback_receipt.response_size() > NN::AsyncMailbox::MAX_WIRE_BYTES
? mailbox.publish_oversized(token, callback_receipt.response_size())
: mailbox.publish_failed(token);
if (!published) {
++stale_callback_rejections;
}
}
static void on_progress(const RNS::RequestReceipt& callback_receipt) {
++progress_callbacks;
std::printf("CALLBACK progress status=%d transfer=%zu response=%llu progress=%.3f\n",
static_cast<int>(callback_receipt.get_status()),
callback_receipt.response_transfer_size(),
static_cast<unsigned long long>(callback_receipt.response_size()),
callback_receipt.get_progress());
if (!mailbox.publish_progress(bytes_vector(callback_receipt.get_request_id()),
callback_receipt.response_transfer_size())) {
++stale_callback_rejections;
}
}
static void on_resource_progress(const RNS::Resource& resource) {
const float progress = resource.get_progress();
if (progress <= 0.0f || progress >= 1.0f) return;
resource_progress = true;
std::printf("RESOURCE progress=%.3f transfer=%zu data=%zu\n",
progress, resource.get_transfer_size(), resource.get_data_size());
if (scenario == "cancel" && !cancellation_started) {
actions.publish(NN::UserActionKind::BACK, "");
}
}
static void on_resource_started(const RNS::Resource& resource) {
resource_started = true;
std::printf("RESOURCE started transfer=%zu data=%zu\n",
resource.get_transfer_size(), resource.get_data_size());
const_cast<RNS::Resource&>(resource).set_progress_callback(on_resource_progress);
}
static void on_link_closed(RNS::Link& closed_link) {
if (!mailbox.publish_link(bytes_vector(closed_link.link_id()), false)) {
++stale_callback_rejections;
}
}
static bool owner_request_data(const NN::ExternalVector<uint8_t>& request_data,
RNS::Link* established = nullptr) {
RNS::Link& request_link = established ? *established : active_link;
receipt = request_link.request(RNS::Bytes("/page/form.mu"),
RNS::Bytes(request_data.data(), request_data.size()), on_response, on_failed,
on_progress, 8.0, NN::AsyncMailbox::MAX_WIRE_BYTES);
if (!receipt) return false;
mailbox.expect_request(bytes_vector(receipt.get_request_id()));
request_started = true;
request_started_at = RNS::Utilities::OS::time();
++owner_requests;
return true;
}
static bool owner_request_current(RNS::Link* established = nullptr) {
return owner_request_data(owner_history.current_request_data(), established);
}
static bool service_submit_through_owner(const char* name, RNS::Link* established = nullptr) {
NN::UserAction action;
if (!actions.pop(action) || action.kind != NN::UserActionKind::SUBMIT) return false;
ScreenSubmissionSource screen(name);
auto command = owner.service(action, owner_history, screen, 0);
if (command.result != NN::OwnerResult::REQUEST) return false;
owner_submit = true;
if (owner_requests == 0) owner_first_request.assign(
command.request_data.begin(), command.request_data.end());
owner_pending_history = std::move(command.pending_history);
return owner_pending_history.ready() && owner_request_data(command.request_data, established);
}
static void on_link_established(RNS::Link& established_link) {
// Link construction invokes this callback before the assigning expression
// completes; take the established production handle before owner requests.
active_link = established_link;
link_established = true;
++link_callbacks;
mailbox.begin(bytes_vector(established_link.link_id()));
established_link.set_resource_started_callback(on_resource_started);
std::string path;
double timeout = 8.0;
if (scenario == "partial") {
const std::string source = "Before\n`{" + destination_hex +
":/page/partial.mu}\nAfter";
const NN::Document document = NN::DocumentParser().parse(source);
const auto nil = NN::no_form_request_data();
if (document.malformed || document.partials.size() != 1 ||
!partial_page.assign(document)) {
fail("partial base parse");
return;
}
partial_scheduler.configure(partial_page, 1U, 0U);
partial_controller.reset_page(document.source_bytes);
if (!partial_scheduler.poll(0U, true, true, partial_request) ||
!partial_controller.prepare(partial_request, partial_page,
nil.data(), nil.size())) {
fail("partial lease preparation");
return;
}
path = "/page/partial.mu";
} else if (scenario == "immediate") path = "/page/immediate.mu";
else if (scenario == "reuse") path = "/page/reuse-first.mu";
else if (scenario == "lan") path = "/page/index.mu";
else if (scenario == "resource") path = "/page/resource.mu";
else if (scenario == "near-limit") path = "/page/near-limit.mu";
else if (scenario == "oversized") path = "/page/oversized.mu";
else if (scenario == "cancel") path = "/page/cancel.mu";
else if (scenario == "form-anonymous" || scenario == "form-identified" ||
scenario == "owner-form-history")
path = "/page/form.mu";
else {
path = "/page/missing.mu";
timeout = 1.5;
}
NN::ExternalVector<uint8_t> request_data;
if (scenario == "owner-form-history") {
if (!actions.publish_submit(0, 1) ||
!service_submit_through_owner("Example User", &established_link)) {
fail("production-owner initial Submit");
}
return;
} else if (scenario == "form-anonymous" || scenario == "form-identified") {
if (!prepare_form_request(request_data)) {
fail("form request encoding");
return;
}
if (scenario == "form-identified") established_link.identify(local_identity);
} else {
const auto nil = NN::no_form_request_data();
request_data.assign(nil.begin(), nil.end());
}
receipt = established_link.request(RNS::Bytes(path),
RNS::Bytes(request_data.data(), request_data.size()),
on_response, on_failed, on_progress, timeout,
scenario == "partial"
? NN::PartialController::MAX_RESPONSE_WIRE_BYTES
: NN::AsyncMailbox::MAX_WIRE_BYTES);
NN::clear_encoded_form(request_data);
if (!receipt) {
fail("request creation");
return;
}
mailbox.expect_request(bytes_vector(receipt.get_request_id()));
request_started = true;
if (scenario == "reuse") ++reuse_requests;
request_started_at = RNS::Utilities::OS::time();
}
class NomadAnnounceHandler : public RNS::AnnounceHandler {
public:
NomadAnnounceHandler() : RNS::AnnounceHandler("nomadnetwork.node") {}
void received_announce(const RNS::Bytes& destination_hash,
const RNS::Identity& identity,
const RNS::Bytes&) override {
if (announce_seen) return;
if (!expected_destination_hex.empty() && destination_hash.toHex() != expected_destination_hex) return;
announce_seen = true;
destination_hex = destination_hash.toHex();
if (!RNS::Transport::has_path(destination_hash)) {
fail("announce did not install local path");
return;
}
destination = RNS::Destination(identity, RNS::Type::Destination::OUT,
RNS::Type::Destination::SINGLE,
"nomadnetwork", "node");
mailbox.prepare(0, scenario == "partial"
? NN::PartialController::MAX_RESPONSE_WIRE_BYTES
: NN::AsyncMailbox::MAX_WIRE_BYTES);
active_link = RNS::Link(destination, on_link_established, on_link_closed);
// Deliberately no link.identify(): ordinary Pyxis page retrieval is anonymous.
}
};
static RNS::HAnnounceHandler announce_handler(new NomadAnnounceHandler());
static void consume_event() {
NN::AsyncMailbox::Event event;
if (!mailbox.take(event)) return;
switch (event.kind) {
case NN::AsyncMailbox::Kind::PROGRESS:
progress_seen = true;
break;
case NN::AsyncMailbox::Kind::RESPONSE: {
if (scenario == "cancel") {
fail("response arrived after Back cancellation");
return;
}
const RNS::Bytes response(event.data.data(), event.data.size());
if (scenario == "partial") {
NN::ResponseBuffer normalized;
NN::CompactPage candidate;
if (!partial_controller.active() ||
!partial_controller.matches(partial_request) ||
!NN::normalize_response(response.data(), response.size(), normalized) ||
normalized.size() > NN::PartialController::MAX_RESPONSE_BYTES) {
fail("partial response ownership");
return;
}
const std::string source(
reinterpret_cast<const char*>(normalized.bytes().data()),
normalized.size());
const NN::Document fragment = NN::DocumentParser().parse(source);
if (fragment.malformed || fragment.truncated ||
!partial_controller.can_accept_fragment(
partial_request.partial_index, normalized.size()) ||
candidate.assign_replacing_partial(
partial_page, partial_request.partial_index, fragment,
NN::PartialController::MAX_EXPANDED_SOURCE_BYTES) !=
NN::PartialReplaceResult::APPLIED ||
!partial_controller.commit_fragment(
partial_request.partial_index, normalized.size())) {
fail("partial transactional replacement");
return;
}
partial_page = std::move(candidate);
std::string rendered;
for (const auto& run : partial_page.runs()) {
const auto text = partial_page.text(run);
rendered.append(text.data(), text.size());
}
partial_live = rendered.find("Peer-refreshed fragment") != std::string::npos &&
partial_scheduler.complete(partial_request, true, 1U);
partial_controller.abandon_request();
passed = partial_live;
completed = true;
if (!passed) fail("partial rendered content");
break;
}
const bool expected_resource = scenario == "resource" || scenario == "near-limit" ||
(scenario == "reuse" && reuse_requests == 2);
if (expected_resource && progress_callbacks == 0) {
fail("Resource response had no progress callback");
return;
}
passed = validate_page(response, expected_resource);
if (!passed) return;
if (scenario == "owner-form-history") {
if (owner_pending_history.ready()) {
if (!owner_history.commit(std::move(owner_pending_history))) {
fail("production-owner response history commit");
return;
}
owner_history_bytes = owner_history.current_has_request_data();
}
const bool retained_owner = NN::OwnerController::retain_active_link(
destination_hex, destination_hex,
active_link && active_link.status() == RNS::Type::Link::ACTIVE);
if (owner_requests < 3 &&
(!retained_owner || !active_link.pending_requests().empty())) {
fail("owner response did not retain active Link");
return;
}
if (owner_requests < 3) owner_retained_link = true;
if (owner_requests == 1) {
mailbox.prepare();
if (!actions.publish_submit(0, 2) ||
!service_submit_through_owner("Changed User")) {
fail("production-owner changed Submit");
}
break;
}
if (owner_requests == 2) {
NN::UserAction back_action;
back_action.kind = NN::UserActionKind::BACK;
ScreenSubmissionSource unused("unused");
auto back_command = owner.service(back_action, owner_history, unused, 0);
if (back_command.result != NN::OwnerResult::REQUEST ||
!back_command.pending_history.ready()) {
fail("production-owner Back history restore");
return;
}
if (back_command.request_data != owner_first_request) {
fail("production-owner Back exact request bytes");
return;
}
if (!owner_history.commit(std::move(back_command.pending_history)) ||
owner_history.current_request_data() != owner_first_request) {
fail("production-owner Back publication commit");
return;
}
owner_back_restored = true;
NN::UserAction reload_action;
reload_action.kind = NN::UserActionKind::RELOAD;
auto reload_command = owner.service(reload_action, owner_history, unused, 0);
mailbox.prepare();
owner_reload_reused = reload_command.result == NN::OwnerResult::REQUEST &&
reload_command.request_data == owner_first_request && owner_request_current();
if (!owner_reload_reused) fail("production-owner Reload request");
break;
}
if (owner_requests != 3 || link_callbacks != 1) {
fail("production-owner retained-Link Reload invariants");
return;
}
completed = true;
break;
}
if (scenario == "reuse" && reuse_requests == 1) {
if (!active_link || active_link.status() != RNS::Type::Link::ACTIVE ||
!active_link.pending_requests().empty()) {
fail("first reuse request did not conclude on active Link");
return;
}
mailbox.prepare();
active_link.set_resource_started_callback(on_resource_started);
const auto nil = NN::no_form_request_data();
receipt = active_link.request(RNS::Bytes("/page/reuse-second.mu"),
RNS::Bytes(nil.data(), nil.size()), on_response, on_failed,
on_progress, 8.0, NN::AsyncMailbox::MAX_WIRE_BYTES);
if (!receipt) {
fail("second request creation on retained Link");
return;
}
mailbox.expect_request(bytes_vector(receipt.get_request_id()));
++reuse_requests;
request_started_at = RNS::Utilities::OS::time();
break;
}
if (scenario == "reuse" &&
(reuse_requests != 2 || link_callbacks != 1 ||
!active_link.pending_requests().empty())) {
fail("same-destination Link reuse invariants");
return;
}
completed = true;
break;
}
case NN::AsyncMailbox::Kind::FAILED:
if (scenario != "timeout") {
fail("unexpected request failure");
return;
}
passed = true;
completed = true;
break;
case NN::AsyncMailbox::Kind::OVERSIZED:
std::printf("EVENT oversized transfer=%zu\n", event.transfer_size);
if (scenario == "oversized" && event.transfer_size > NN::AsyncMailbox::MAX_WIRE_BYTES) {
passed = true;
completed = true;
} else {
fail("unexpected oversized response");
}
break;
case NN::AsyncMailbox::Kind::LINK_CLOSED:
if (!cancellation_started && scenario != "timeout") fail("unexpected link close");
break;
default:
break;
}
}
static void service_terminal_action() {
if (!actions.terminal_pending()) return;
NN::UserAction action;
if (!actions.pop(action) || action.kind != NN::UserActionKind::BACK) {
fail("terminal Back dequeue");
return;
}
cancellation_started = true;
cancellation_at = RNS::Utilities::OS::time();
mailbox.seal();
if (active_link && active_link.status() != RNS::Type::Link::CLOSED) active_link.teardown();
if (receipt && receipt.get_status() != RNS::Type::RequestReceipt::FAILED) {
receipt.request_timed_out(RNS::PacketReceipt(RNS::Type::NONE));
}
}
static void service_application_deadline() {
application_deadline_fired = true;
mailbox.seal();
if (active_link && active_link.status() != RNS::Type::Link::CLOSED) active_link.teardown();
if (receipt && receipt.get_status() != RNS::Type::RequestReceipt::FAILED) {
receipt.request_timed_out(RNS::PacketReceipt(RNS::Type::NONE));
}
}
static bool cleanup_complete() {
receipt_failed = receipt && receipt.get_status() == RNS::Type::RequestReceipt::FAILED;
pending_empty = active_link && active_link.pending_requests().empty();
link_closed = active_link && active_link.status() == RNS::Type::Link::CLOSED;
return receipt_failed && pending_empty && link_closed && stale_callback_rejections > 0;
}
int main(int argc, char** argv) {
if (argc == 2 && std::strcmp(argv[1], "--manifest") == 0) {
std::printf("{\"schema\":1,\"base\":\"%s\",\"branch\":\"%s\","
"\"microreticulum\":\"%s\",\"sources\":%s}\n",
PYXIS_MANIFEST_BASE, PYXIS_MANIFEST_BRANCH,
PYXIS_MANIFEST_MICRORETICULUM, PYXIS_MANIFEST_SOURCES_JSON);
return 0;
}
if (argc < 2) {
std::fprintf(stderr, "usage: %s immediate|resource|near-limit|oversized|timeout|cancel|reuse|form-anonymous|form-identified|owner-form-history|partial | lan host port destination\n", argv[0]);
return 2;
}
scenario = argv[1];
if (scenario != "immediate" && scenario != "resource" && scenario != "near-limit" &&
scenario != "oversized" &&
scenario != "timeout" && scenario != "cancel" && scenario != "reuse" &&
scenario != "form-anonymous" && scenario != "form-identified" &&
scenario != "owner-form-history" && scenario != "partial" && scenario != "lan") return 2;
if ((scenario == "lan" && argc != 5) || (scenario != "lan" && argc != 2)) return 2;
microStore::FileSystem filesystem{microStore::Adapters::UniversalFileSystem(".")};
filesystem.init();
RNS::Utilities::OS::register_filesystem(filesystem);
if (scenario == "lan") {
expected_destination_hex = argv[4];
tcp_interface = new TCPClientInterface("NomadNetLAN");
tcp_interface->set_target_host(argv[2]);
tcp_interface->set_target_port(std::stoi(argv[3]));
network_interface = RNS::Interface(tcp_interface);
} else {
network_interface = new UDPInterface();
network_interface.mode(RNS::Type::Interface::MODE_GATEWAY);
}
RNS::Transport::register_interface(network_interface);
if (!network_interface.start()) return 3;
reticulum = RNS::Reticulum();
reticulum.transport_enabled(false);
reticulum.start();
local_identity = RNS::Identity();
RNS::Transport::register_announce_handler(announce_handler);
if (scenario == "lan") {
RNS::Bytes target;
target.assignHex(expected_destination_hex.c_str());
RNS::Transport::request_path(target, network_interface);
std::printf("LAN TCP online=%d target=%s destination=%s path-requested=1\n",
network_interface.online() ? 1 : 0, argv[2], expected_destination_hex.c_str());
}
const double started_at = RNS::Utilities::OS::time();
while (!completed && RNS::Utilities::OS::time() - started_at < 15.0) {
// Mirrors the corrected firmware ordering: terminal cancellation gets
// an owner-loop chance before another inbound transport pass.
service_terminal_action();
reticulum.loop();
consume_event();
const double now = RNS::Utilities::OS::time();
if (request_started && scenario == "timeout" && !application_deadline_fired &&
now - request_started_at > 2.0) {
service_application_deadline();
}
const double cleanup_at = cancellation_started ? cancellation_at : request_started_at + 2.0;
if ((cancellation_started || application_deadline_fired) && cleanup_complete() &&
now - cleanup_at > 0.25) {
passed = scenario == "timeout" ||
(scenario == "cancel" && resource_started && resource_progress);
completed = true;
}
RNS::Utilities::OS::sleep(0.005);
}
mailbox.seal();
if (active_link && active_link.status() != RNS::Type::Link::CLOSED) active_link.teardown();
const double drain_until = RNS::Utilities::OS::time() + 0.25;
while (RNS::Utilities::OS::time() < drain_until) {
reticulum.loop();
RNS::Utilities::OS::sleep(0.005);
}
RNS::Transport::deregister_announce_handler(announce_handler);
RNS::Transport::deregister_interface(network_interface);
if (!completed) fail("scenario deadline");
cleanup_complete();
std::printf("RESULT scenario=%s announce=%d path=%d link=%d request=%d progress=%d callbacks=%d "
"cancel=%d deadline=%d resource_started=%d resource_progress=%d receipt_failed=%d "
"pending=%zu link_closed=%d stale_rejected=%d reuse_requests=%d link_callbacks=%d "
"owner_submit=%d history_bytes=%d retained_link=%d back_restored=%d reload_reused=%d partial_live=%d passed=%d\n",
scenario.c_str(), announce_seen ? 1 : 0,
destination_hex.empty() ? 0 : 1, link_established ? 1 : 0,
request_started ? 1 : 0, progress_seen ? 1 : 0, progress_callbacks,
cancellation_started ? 1 : 0, application_deadline_fired ? 1 : 0,
resource_started ? 1 : 0, resource_progress ? 1 : 0,
receipt_failed ? 1 : 0,
active_link ? active_link.pending_requests().size() : 0,
link_closed ? 1 : 0, stale_callback_rejections, reuse_requests, link_callbacks,
owner_submit ? 1 : 0, owner_history_bytes ? 1 : 0,
owner_retained_link ? 1 : 0, owner_back_restored ? 1 : 0,
owner_reload_reused ? 1 : 0, partial_live ? 1 : 0, passed ? 1 : 0);
if (scenario == "lan") {
std::printf("LAN TRANSPORT rx=%zu rxbytes=%zu tx=%zu txbytes=%zu\n",
network_interface.rx(), network_interface.rxbytes(),
network_interface.tx(), network_interface.txbytes());
}
return passed ? 0 : 1;
}
Reference in New Issue View Git Blame Copy Permalink