diff --git a/.kiro/specs/xce-test-cli-ux/tasks.md b/.kiro/specs/xce-test-cli-ux/tasks.md index a91aa2fc..820ae79b 100644 --- a/.kiro/specs/xce-test-cli-ux/tasks.md +++ b/.kiro/specs/xce-test-cli-ux/tasks.md @@ -91,7 +91,7 @@ - _Requirements: 11.1, 11.3, 11.4, 11.5, 11.6, 11.7, 11.8_ - _Boundary: Bug-1711 Fixes_ -- [ ] 2.6 (P) Fix bug-1557's join maxmem default +- [x] 2.6 (P) Fix bug-1557's join maxmem default - Correct the simulated worker-join command's default memory value to the codebase's current bytes-canonical convention - Observable completion: joining a simulated worker without specifying memory reports the corrected byte-scale default instead of the stale value - _Requirements: 12.1_ @@ -178,6 +178,7 @@ ## Implementation Notes - `src/tools/xce-build.sh controller asan xce.build --incremental` writes its build dir at `src/xce.build/` (relative to the script's own location), not a repo-root `xce.build/` — meson logs are at `src/xce.build/meson-logs/testlog.txt`. (task 1.1) - New Unity test files need two wiring points, not just meson.build's source list: also register an `extern void test_(void);` + `TEST(test_);` in `src/controller/testsuite/controller_test.c`, mirroring the existing `test_rcfile` registration, or the suite silently never runs. (task 1.1) +- `cmd_join_worker`'s sibling fields `maxswap`/`maxtmp` have the exact same stale-MB-scale bug as bug-1557's `maxmem` (1024/2048 bytes instead of KB/MB-appropriate values) but were deliberately left unfixed here: `USAGE_JOIN_WORKER` currently documents these exact stale values accurately, so fixing only the code would create a new code/docs mismatch outside this task's mandate. Worth a coordinated follow-up bug fixing both fields' defaults and their help text together. A new `test_join_worker_sibling_defaults_unchanged` test locks in today's values so that follow-up isn't confused with this task's maxmem-specific assertions. (task 2.6) - When a fix touches a pure function stuck inside `test.c` (no networking/REPL/global-state dependency), extract it into its own module with a standalone meson `test()` target rather than settling for a throwaway/manual verification — this codebase already has two precedents for exactly this (`resval_typeresolve.c`, `misc.c`'s runusage helpers; now also `joblist_display.c` for `worker_status_str`/`job_state_str`/`format_job_time`). `test.c` itself is never linked into `controller_unit_test`, so this extract-to-standalone-module pattern is the only way to get permanent automated coverage for such functions — a scratch/deleted verification harness is not sufficient and will be sent back on review. `cmd_reslist`/`joblist_query`/`cmd_getconf`'s table-printing bodies remain genuinely untestable without a live cluster (fetch+print are inlined together, confirmed on review) and stay uncovered by permanent tests for now. (task 2.5) - `cmd_source` translates `rcfile_load`'s raw positive "aborted" return to `-1` rather than forwarding it verbatim, because `preprocess_and_run` only treats a *negative* return as failure (`if (rc < 0)`) — forwarding the raw positive value would let an enclosing `source` line silently read a transitively-aborted nested source as success. No test yet exercises this specific nested-abort-propagation case (all 3 required scenarios pass either way) — worth a dedicated test in Validation phase (4.3 or nearby). (task 2.4) - libedit (this project's pinned NetBSD libedit 3.1) provides GNU-readline-compatible `rl_attempted_completion_function`/`rl_completion_matches` verbatim — confirmed against the actual linked header, not assumed. An ambiguous match needs a SECOND consecutive Tab to list candidates (standard readline/bash double-Tab convention) — later black-box tests using Tab must account for this. Also: `test_test_cli.c`'s `clitest_spawn()` disabling kernel ECHO also silently suppressed libedit's own completion feedback in this libedit build (bug-1792) — use the new `clitest_spawn_ex(sess, path, argv, disable_echo)` with `disable_echo=false` for any future test that needs to observe libedit UI behavior (completion, etc.), not just raw command output. (task 2.3) diff --git a/.wolf/buglog.json b/.wolf/buglog.json index 6281c076..cc759169 100644 --- a/.wolf/buglog.json +++ b/.wolf/buglog.json @@ -15989,7 +15989,7 @@ "error_message": "xce_test's `worker` -> `join` command defaults to maxmem=64 -- discovered while writing/verifying detailed `help join` text", "file": "src/controller/testsuite/test.c (cmd_join_worker, hostattrs_t attrs initializer)", "root_cause": "attrs.maxmem = 64 was a reasonable default back when maxmem was MB-scale (64 MB); this session's earlier fix converted maxmem's canonical unit to bytes (node_information.c/xcecd.c/resources.yaml) but never touched this test-tool default, which is now a nonsensical 64 BYTES of RAM. Purely a manual-test-tool default (join is used to simulate a worker joining without a real xcecd), not a production code path -- callers who don't pass -m get an obviously-wrong but harmless value.", - "fix": "Not fixed -- out of scope for the help-text task that surfaced it (help text correctly documents the actual current default, 64, which is itself the bug). Should become e.g. 64 * 1024 * 1024 (64MB, matching the old intent) to stay consistent with the rest of this session's bytes-canonical convention.", + "fix": "FIXED (2026-09-09, xce-test-cli-ux task 2.6). cmd_join_worker default changed to 64 * 1024 * 1024 (64MB in bytes). Extracted into join_worker_parse_attrs() (join_worker_args.c) with a permanent regression test asserting the corrected default. Verified live: workerlist reports MaxMem: 64.00 MB after a no-'-m' join (was would-be 64.00 B). USAGE_JOIN_WORKER doc update tracked separately under xce-test-cli-ux Requirement 12.2 (task 3.5).", "tags": [ "test-tool", "xce_test", @@ -21513,6 +21513,29 @@ "related_bugs": [], "occurrences": 1, "last_seen": "2026-09-09T12:40:00.000Z" + }, + { + "id": "bug-1793", + "timestamp": "2026-09-09T16:24:19Z", + "error_message": "xce_test's worker->join command's maxswap (1024) and maxtmp (2048) defaults have the same stale-MB-scale bug as bug-1557's maxmem -- discovered while fixing bug-1557 (xce-test-cli-ux task 2.6)", + "file": "src/controller/testsuite/join_worker_args.c (join_worker_parse_attrs, hostattrs_t default initialization)", + "root_cause": "Same root cause as bug-1557: maxswap/maxtmp were reasonable defaults (1KB/2KB) back when these fields were a smaller unit, but an earlier session converted maxswap/maxtmp to bytes-canonical (confirmed via resources.yaml 'max swap/tmp disk space in bytes' and hardware_monitor.c's raw-byte sysinfo()/statvfs() computations) without updating this test-tool default. 1024 bytes of swap / 2048 bytes of tmp are just as nonsensical as the old maxmem=64 bytes.", + "fix": "NOT FIXED -- deliberately deferred (xce-test-cli-ux task 2.6). USAGE_JOIN_WORKER's help text currently documents these exact stale values accurately, so fixing only the code without also fixing the docs would create a new code/docs mismatch outside task 2.6's Requirement-12.1-scoped mandate (which covers maxmem only). Recommended: a coordinated fix changing both defaults (e.g. maxswap to a byte-scale value matching typical swap sizing, maxtmp similarly) AND USAGE_JOIN_WORKER's documented defaults, together. A regression test (test_join_worker_sibling_defaults_unchanged in test_join_worker_args.c) currently locks in today's stale values specifically so a future fix here doesn't collide with bug-1557's maxmem-specific test assertions -- update/remove that test's maxswap/maxtmp assertions when this bug is actually fixed.", + "tags": [ + "controller", + "testsuite", + "xce_test", + "cmd_join_worker", + "stale-default", + "units", + "unfixed", + "deferred" + ], + "related_bugs": [ + "bug-1557" + ], + "occurrences": 1, + "last_seen": "2026-09-09T16:24:19Z" } ] } diff --git a/src/controller/meson.build b/src/controller/meson.build index df325eed..b45ed21a 100644 --- a/src/controller/meson.build +++ b/src/controller/meson.build @@ -55,7 +55,7 @@ controller = executable('xce_controller', link_args: wrap_link_args, install: true) -xce_test_src = [ 'testsuite/test.c', 'testsuite/waldump.c', 'testsuite/walcompare.c', 'testsuite/snapverify.c', 'testsuite/snapdiff.c', 'testsuite/configcompare.c', 'testsuite/resval_typeresolve.c', 'testsuite/joblist_display.c', 'testsuite/rcfile.c', 'testsuite/flagspec.c', 'testsuite/interruptcall.c', 'testsuite/confirm.c', 'testsuite/listfmt_json.c'] +xce_test_src = [ 'testsuite/test.c', 'testsuite/waldump.c', 'testsuite/walcompare.c', 'testsuite/snapverify.c', 'testsuite/snapdiff.c', 'testsuite/configcompare.c', 'testsuite/resval_typeresolve.c', 'testsuite/joblist_display.c', 'testsuite/join_worker_args.c', 'testsuite/rcfile.c', 'testsuite/flagspec.c', 'testsuite/interruptcall.c', 'testsuite/confirm.c', 'testsuite/listfmt_json.c'] # BSD-licensed readline replacement (scheduler-core spec, task 12.1 review # finding): GNU readline is GPL; xce_test's REPL only needs readline()/ @@ -423,3 +423,29 @@ test('joblist display test', joblist_display_unit_test, timeout: 60, env: ['ASAN_OPTIONS=detect_leaks=0']) +# xce-test-cli-ux task 2.6 remediation: join_worker_args.c is a small, +# dependency-light module (no networking/REPL/global state) extracted from +# test.c's cmd_join_worker() specifically so the bug-1557 maxmem-default fix +# can be unit-tested in isolation -- test.c itself cannot be white-box +# included into a Unity test, same rationale as joblist_display_unit_test/ +# resval_typeresolve_unit_test above. Standalone binary (not folded into +# controller_unit_test_src) since it has zero dependency on +# controller.c/cluster.c internals, mirroring those tests' own +# standalone-binary rationale. +join_worker_args_unit_test_src = [ + 'testsuite/test_join_worker_args.c', + 'testsuite/join_worker_args.c', +] + +join_worker_args_unit_test = executable('join_worker_args_unit_test', + join_worker_args_unit_test_src, + include_directories: [incdir], + dependencies: controller_unit_test_deps, + c_args: ['-DXCE_TESTING'], + install: false) + +test('join worker args test', join_worker_args_unit_test, + suite: 'controller', + timeout: 60, + env: ['ASAN_OPTIONS=detect_leaks=0']) + diff --git a/src/controller/testsuite/join_worker_args.c b/src/controller/testsuite/join_worker_args.c new file mode 100644 index 00000000..3787f746 --- /dev/null +++ b/src/controller/testsuite/join_worker_args.c @@ -0,0 +1,70 @@ +/* join_worker_args.c -- xce-test-cli-ux task 2.6 remediation (bug-1557 fix) + * + * See join_worker_args.h for the full extraction rationale. Verbatim + * extraction of test.c's cmd_join_worker() parsing/defaulting block -- no + * behavior change from the pre-extraction version. + */ +#include "join_worker_args.h" + +#include +#include +#include +#include /* getopt, optarg, optind */ + +int join_worker_parse_attrs(int argc, char* argv[], hostattrs_t* attrs) +{ + int opt; + + if (attrs == NULL) { + return -EINVAL; + } + + /* bug-1557: maxmem is bytes-canonical (see resources.yaml, hardware_ + * monitor.c's total_memory) -- this default used to read plain "64" + * back when maxmem was MB-scale (64 MB); an earlier session converted + * the codebase's canonical unit to bytes but missed this test-tool + * default, leaving it at a nonsensical 64 BYTES. Expressed here as + * 64 * 1024 * 1024 (64MB in bytes) to preserve the original intent, + * matching this file's own byte-constant convention (see test.c's + * main() `logsize = 64 * 1024 * 1024`). */ + attrs->cpufactor = 1.0; + attrs->maxcpus = 4; + attrs->maxmem = 64 * 1024 * 1024; + attrs->maxswap = 1024; + attrs->maxtmp = 2048; + attrs->ndisks = 1; + + attrs->hostmodel = "Intel64"; + attrs->hosttype = "LINUX64"; + + optind = 1; + + while ((opt = getopt(argc, argv, "f:c:m:s:t:d:")) != -1) { + switch (opt) { + case 'f': + attrs->cpufactor = atof(optarg); + break; + case 'c': + attrs->maxcpus = atoi(optarg); + break; + case 'm': + attrs->maxmem = atoi(optarg); + break; + case 's': + attrs->maxswap = atoi(optarg); + break; + case 't': + attrs->maxtmp = atoi(optarg); + break; + case 'd': + attrs->ndisks = atoi(optarg); + break; + default: + printf(" join [-f cpufactor] [-c maxcpus] [-m maxmem] [-s maxswap] " + "[-t maxtmp] [-d ndisks]\n"); + return -EINVAL; + } + } + + return 0; +} diff --git a/src/controller/testsuite/join_worker_args.h b/src/controller/testsuite/join_worker_args.h new file mode 100644 index 00000000..4891b04a --- /dev/null +++ b/src/controller/testsuite/join_worker_args.h @@ -0,0 +1,40 @@ +#ifndef JOIN_WORKER_ARGS_H +#define JOIN_WORKER_ARGS_H + +/* join_worker_args.h -- xce-test-cli-ux task 2.6 remediation (bug-1557 fix) + * + * Extracted from test.c's cmd_join_worker(): the pure argument-parsing/ + * defaulting block that populates a hostattrs_t (xce/types.h) from argc/argv, + * including the bug-1557 maxmem default fix. This block runs entirely before + * cmd_join_worker's only network call (xcecli_join()) and touches no + * active_ctx, REPL state, or any global beyond the standard `optind` reset + * every other cmd_ handler in this file already performs -- the same + * isolation rationale as joblist_display.c's extraction (task 2.5) and + * resval_typeresolve.c's (resource-value-verification task 1.1). + * + * test.c's cmd_join_worker() calls this directly in place of its old inline + * parsing block, then proceeds to xcecli_join() exactly as before -- no + * behavior change to the network-call phase, extraction only. + */ + +#include "xce/types.h" /* hostattrs_t */ + +/* Parse join's CLI flags ("-f cpufactor -c maxcpus -m maxmem -s maxswap + * -t maxtmp -d ndisks") into `*attrs`, first defaulting every field + * (including the bug-1557-corrected maxmem default of 64 * 1024 * 1024 + * bytes -- see the in-body comment in join_worker_args.c for the full + * bytes-vs-MB history) and then overriding any field whose flag was given. + * + * Resets `optind` to 1 before parsing, matching this file's own convention + * for repeated in-process command invocations (see cmd_jobfinish's comment + * on the same convention). + * + * Returns 0 on success. Returns -EINVAL on an unrecognized flag or a NULL + * `attrs`, leaving `*attrs` fully defaulted (and possibly partially + * overridden by whichever flags were already parsed before the + * unrecognized one) -- callers must not use `*attrs` after a nonzero + * return. On a parse error, this function itself prints the same usage + * string cmd_join_worker printed before extraction. */ +int join_worker_parse_attrs(int argc, char* argv[], hostattrs_t* attrs); + +#endif /* JOIN_WORKER_ARGS_H */ diff --git a/src/controller/testsuite/test.c b/src/controller/testsuite/test.c index 8dfdb29f..bb810cf9 100644 --- a/src/controller/testsuite/test.c +++ b/src/controller/testsuite/test.c @@ -35,6 +35,8 @@ #include "confirm.h" /* destructive-command confirmation gate (xce-test-cli-ux task 2.1) */ #include "joblist_display.h" /* worker_status_str/job_state_str/format_job_time * (xce-test-cli-ux task 2.5 remediation) */ +#include "join_worker_args.h" /* join_worker_parse_attrs (xce-test-cli-ux + * task 2.6 remediation, bug-1557) */ #include "rcfile.h" /* startup rc-file path resolution + loading (xce-test-rc-file task 2.2) */ #include "resval_typeresolve.h" /* resval_resolve_type (resource-value-verification task 2.1) */ #include "xce/cluster.h" /* xce_parse_peers, xce_cluster_config_t */ @@ -3363,46 +3365,19 @@ int cmd_join_worker(int argc, char* argv[]) { int rc; int role; - int opt; - hostattrs_t attrs = { .cpufactor = 1.0, - .maxcpus = 4, - .maxmem = 64, - .maxswap = 1024, - .maxtmp = 2048, - .ndisks = 1 }; + hostattrs_t attrs; role = HostRole_worker; - optind = 1; - - attrs.hostmodel = "Intel64"; - attrs.hosttype = "LINUX64"; - - while ((opt = getopt(argc, argv, "f:c:m:s:t:d:")) != -1) { - switch (opt) { - case 'f': - attrs.cpufactor = atof(optarg); - break; - case 'c': - attrs.maxcpus = atoi(optarg); - break; - case 'm': - attrs.maxmem = atoi(optarg); - break; - case 's': - attrs.maxswap = atoi(optarg); - break; - case 't': - attrs.maxtmp = atoi(optarg); - break; - case 'd': - attrs.ndisks = atoi(optarg); - break; - default: - printf(" join [-f cpufactor] [-c maxcpus] [-m maxmem] [-s maxswap] " - "[-t maxtmp] [-d ndisks]\n"); - return -EINVAL; - } + /* xce-test-cli-ux task 2.6 remediation (bug-1557): the argument-parsing/ + * defaulting block (including the maxmem default fix) is extracted into + * join_worker_args.c/.h so it can be unit-tested in isolation from this + * function's REPL/network state -- see join_worker_args.h for the full + * rationale. This is a structural extraction only; the parsing/defaulting + * behavior and everything from xcecli_join() onward are unchanged. */ + rc = join_worker_parse_attrs(argc, argv, &attrs); + if (rc < 0) { + return rc; } rc = xcecli_join(active_ctx->ctx, role, &attrs); diff --git a/src/controller/testsuite/test_join_worker_args.c b/src/controller/testsuite/test_join_worker_args.c new file mode 100644 index 00000000..42872dc4 --- /dev/null +++ b/src/controller/testsuite/test_join_worker_args.c @@ -0,0 +1,129 @@ +/* test_join_worker_args.c -- xce-test-cli-ux task 2.6 remediation + * (bug-1557 fix) + * + * Unity unit tests for join_worker_args.c's join_worker_parse_attrs(), + * extracted from test.c's cmd_join_worker() (see join_worker_args.h for the + * full extraction rationale). This is the permanent, automated regression + * guard for bug-1557 (join's stale maxmem default): review had confirmed + * the fix value/unit were already correct in cmd_join_worker, but rejected + * that task for lacking a permanent test given a genuine testable seam + * existed -- this file is that test. + * + * Standalone Unity main (this binary is its own test executable -- see + * meson.build's join_worker_args_unit_test), mirroring + * joblist_display_unit_test's/resval_typeresolve_unit_test's own pattern. + */ +#include +#include +#include + +#include + +#include "join_worker_args.h" +#include "xce/types.h" /* hostattrs_t */ + +/* Requirement 12.1's actual regression guard: no -m flag given must default + * maxmem to 64 * 1024 * 1024 (64 MB expressed in the codebase's + * bytes-canonical unit) -- not the pre-bug-1557 nonsensical 64 bytes. */ +static void test_join_worker_default_maxmem_is_64mb_in_bytes(void) +{ + char* argv[] = { "join" }; + hostattrs_t attrs; + int rc = join_worker_parse_attrs(1, argv, &attrs); + + TEST_ASSERT_EQUAL_INT(0, rc); + /* This Unity build has double-precision assertions disabled -- use + * TEST_ASSERT_EQUAL_FLOAT (this file's own convention, matching + * test_listfmt_json.c/test_wal_job_rusage_fact.c) instead. 64 * 1024 * + * 1024 is an exact power of two, so the float round-trip is exact. */ + TEST_ASSERT_EQUAL_FLOAT_MESSAGE( + (float)(64 * 1024 * 1024), (float)attrs.maxmem, + "join's default maxmem must be 64 * 1024 * 1024 bytes (bug-1557, " + "Requirement 12.1)"); +} + +/* Proves the flag-parsing itself still works after extraction, not just the + * default: -m must override the default exactly. */ +static void test_join_worker_dash_m_overrides_default(void) +{ + char* argv[] = { "join", "-m", "12345" }; + hostattrs_t attrs; + int rc = join_worker_parse_attrs(3, argv, &attrs); + + TEST_ASSERT_EQUAL_INT(0, rc); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE( + 12345.0f, (float)attrs.maxmem, + "-m must override join's default maxmem"); +} + +/* Fail-loud behavior (matching this file's error-handling convention + * elsewhere): an unrecognized flag must return the negative-errno error + * code, not silently succeed with a partially-parsed attrs. */ +static void test_join_worker_unrecognized_flag_returns_einval(void) +{ + char* argv[] = { "join", "-z", "bogus" }; + hostattrs_t attrs; + int rc = join_worker_parse_attrs(3, argv, &attrs); + + TEST_ASSERT_EQUAL_INT(-EINVAL, rc); +} + +/* A NULL attrs pointer must also fail loud rather than crash. */ +static void test_join_worker_null_attrs_returns_einval(void) +{ + char* argv[] = { "join" }; + int rc = join_worker_parse_attrs(1, argv, NULL); + + TEST_ASSERT_EQUAL_INT(-EINVAL, rc); +} + +/* Documents/locks in the CURRENT (still-buggy, unchanged-by-this-task) + * default values of maxcpus/maxswap/maxtmp -- the sibling same-class fields + * task 2.6's implementer correctly declined to touch (a separate, + * recommended follow-up bug covers them). If someone later fixes those + * fields, THIS test's assertions (specific to maxmem) must not be confused + * with assertions on those separate fields. */ +static void test_join_worker_sibling_defaults_unchanged(void) +{ + char* argv[] = { "join" }; + hostattrs_t attrs; + int rc = join_worker_parse_attrs(1, argv, &attrs); + + TEST_ASSERT_EQUAL_INT(0, rc); + TEST_ASSERT_EQUAL_INT_MESSAGE( + 4, attrs.maxcpus, + "maxcpus default is unchanged by task 2.6 (bug-1557 scoped to " + "maxmem only)"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE( + 1024.0f, (float)attrs.maxswap, + "maxswap's still-buggy default is intentionally unchanged by task " + "2.6 -- separate follow-up bug covers it"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE( + 2048.0f, (float)attrs.maxtmp, + "maxtmp's still-buggy default is intentionally unchanged by task " + "2.6 -- separate follow-up bug covers it"); +} + +/* ------------------------------------------------------------------ */ +/* Standalone Unity main (this binary is its own test executable -- see */ +/* meson.build's join_worker_args_unit_test) */ +/* ------------------------------------------------------------------ */ + +void setUp(void) { return; } +void tearDown(void) { return; } + +int main(void) +{ + printf("\n>> xce-test-cli-ux task 2.6 remediation: join_worker_args " + "join_worker_parse_attrs (bug-1557)\n\n"); + + UNITY_BEGIN(); + + RUN_TEST(test_join_worker_default_maxmem_is_64mb_in_bytes); + RUN_TEST(test_join_worker_dash_m_overrides_default); + RUN_TEST(test_join_worker_unrecognized_flag_returns_einval); + RUN_TEST(test_join_worker_null_attrs_returns_einval); + RUN_TEST(test_join_worker_sibling_defaults_unchanged); + + return UNITY_END(); +}