Merge pull request #1438 from shashwatMishra96/fix/quarantine-exit-nonzero

fix: quarantine files on EXIT_NONZERO instead of aborting chunk

Author: DeusData

internal/cbm/cbm.c

@@ -725,6 +725,10 @@ static void cbm_test_fault_inject(const char *rel_path) {
             /* Busy-spin: the supervisor's quiet-timeout kills + reports us. */
         }
     }
+    const char *exit_on = getenv("CBM_TEST_EXIT_ON");
+    if (exit_on && exit_on[0] && strstr(rel_path, exit_on)) {
+        exit(1); /* Nonzero exit code → CBM_PROC_EXIT_NONZERO → classified as "error" */
+    }
 }
 #endif
 

src/mcp/mcp.c

@@ -7756,7 +7756,7 @@ static bool supervisor_suspect_contains(char **s, int n, const char *rel) {
     return false;
 }
 
-/* Append one quarantine entry "rel\tphase\n" (phase = "crash"|"hang") to the
+/* Append one quarantine entry "rel\tphase\n" (phase = "crash"|"hang"|"error") to the
  * quarantine list. The worker's loader parses this back and reports the skip's
  * phase in skipped[]; a bare "rel" line is still tolerated there (defaults crash). */
 static bool supervisor_append_quarantine(const char *path, const char *rel, const char *phase) {
@@ -7790,7 +7790,7 @@ cbm_mcp_supervised_result_disposition_t cbm_mcp_supervised_result_disposition(
  *   - the worker's own response on a clean first run (the common path);
  *   - after a crash/hang, the response from a clean single-threaded RECOVERY run
  *     that quarantines the culprit file(s) — status="indexed" with them listed in
- *     skipped[] as phase="crash"/"hang", and the good files indexed;
+ *     skipped[] as phase="crash"/"hang"/"error", and the good files indexed;
  *   - a best-effort PARTIAL index (one final quarantine-only run) if the recovery
  *     loop cannot converge but at least one file was quarantined;
  *   - a contained-failure response only if even that cannot produce a clean run.
@@ -7839,7 +7839,7 @@ static char *index_run_supervised(cbm_mcp_server_t *srv, const char *args) {
      * (for a hang the oldest still-open file IS the stuck one; for a crash
      * it is the longest-running suspect — the best single deterministic
      * pick). A clean run then indexes the good files and reports the
-     * quarantined ones as phase="crash"/"hang" skips via the ordinary
+     * quarantined ones as phase="crash"/"hang"/"error" skips via the ordinary
      * Stage-2 skip plumbing. The old design re-ran SINGLE-THREADED to keep
      * one exact marker; at scale that fell into the sequential crawl, went
      * quiet, was killed as a hang mid-pass, and the stale marker got FOUR
@@ -7900,13 +7900,34 @@ static char *index_run_supervised(cbm_mcp_server_t *srv, const char *args) {
             cbm_index_worker_result_free(&wr2);
             break; /* good files indexed; quarantined files reported as crash/hang */
         }
-        if (wr2.outcome == CBM_PROC_CRASH || wr2.outcome == CBM_PROC_HANG) {
+        if (wr2.outcome == CBM_PROC_CRASH || wr2.outcome == CBM_PROC_HANG ||
+            wr2.outcome == CBM_PROC_EXIT_NONZERO) {
             last_outcome = wr2.outcome;
             cbm_index_worker_result_free(&wr2);
-            /* crash vs hang: the phase this file is quarantined under and
-             * reported as in skipped[]. A fault signal → "crash"; a
-             * no-progress kill → "hang". */
-            const char *phase = (last_outcome == CBM_PROC_HANG) ? "hang" : "crash";
+            /* crash vs hang vs nonzero-exit: the phase this file is quarantined
+             * under and reported as in skipped[]. A fault signal → "crash"; a
+             * no-progress kill → "hang"; a graceful nonzero exit (e.g. an
+             * internal parse-limit/abort on a pathological file) → "error".
+             * EXIT_NONZERO is attributed via the SAME marker-journal suspect
+             * mechanism as a crash: the two-consecutive-strikes intersection
+             * below still guards against quarantining an innocent file, and a
+             * SYSTEMIC nonzero exit (e.g. a bad arg) produces no recurring
+             * suspect → the intersection is empty → give_up (correct). This
+             * makes a single pathological file skip-and-continue instead of
+             * aborting the whole chunk.
+             *
+             * Note: A deterministic first-file failure (e.g. worker crashing/exiting
+             * on the very first file every run) will progressively quarantine in-flight
+             * files until reaching the culprit. This is an existing property accepted
+             * by the crash/hang path, accepted here as a considered tradeoff. */
+            const char *phase;
+            if (last_outcome == CBM_PROC_HANG) {
+                phase = "hang";
+            } else if (last_outcome == CBM_PROC_EXIT_NONZERO) {
+                phase = "error";
+            } else {
+                phase = "crash";
+            }
             int sus_n = 0;
             char **suspects = supervisor_read_suspects(marker_path, &sus_n);
             (void)remove(marker_path); /* fresh journal for the next re-run */

src/pipeline/pass_definitions.c

@@ -723,8 +723,9 @@ int cbm_pipeline_pass_definitions(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t
             if (!phase) {
                 phase = "crash";
             }
-            const char *reason =
-                (strcmp(phase, "hang") == 0) ? "quarantined after hang" : "quarantined after crash";
+            const char *reason = (strcmp(phase, "hang") == 0)    ? "quarantined after hang"
+                                 : (strcmp(phase, "error") == 0) ? "quarantined after error"
+                                                                 : "quarantined after crash";
             cbm_pipeline_add_file_error(ctx->pipeline, rel, reason, phase);
             errors++;
             continue;

src/pipeline/pass_parallel.c

@@ -800,8 +800,9 @@ static void extract_worker(int worker_id, void *ctx_ptr) {
             if (!phase) {
                 phase = "crash";
             }
-            const char *reason =
-                (strcmp(phase, "hang") == 0) ? "quarantined after hang" : "quarantined after crash";
+            const char *reason = (strcmp(phase, "hang") == 0)    ? "quarantined after hang"
+                                 : (strcmp(phase, "error") == 0) ? "quarantined after error"
+                                                                 : "quarantined after crash";
             pp_err_add(errs, fi->rel_path, reason, phase);
             ws->errors++;
             continue;

tests/test_mcp.c

@@ -10048,6 +10048,8 @@ enum {
     IDXPAR_NO_QUARANTINE = 64, /* crasher missing from skipped[] */
     IDXPAR_INNOCENT_HIT = 65,  /* a good file was quarantined/skipped */
     IDXPAR_GOOD_MISSING = 66,  /* good file's Function absent from the store */
+    IDXPAR_NOT_ERROR = 67,     /* systemic failure did not report status error */
+    IDXPAR_OUTCOME_WRONG = 68, /* systemic failure outcome is not exit_nonzero */
 };
 
 #ifndef _WIN32
@@ -10107,6 +10109,94 @@ static int idxpar_recovery_check(const char *repo_dir) {
     free(project);
     return code;
 }
+
+static int idxpar_exit_nonzero_recovery_check(const char *repo_dir) {
+    cbm_index_supervisor_mark_host();
+    cbm_unsetenv("CBM_INDEX_SUPERVISOR");
+    cbm_setenv("CBM_INDEX_MAX_RESTARTS", "5", 1);
+    cbm_setenv("CBM_INDEX_WORKER_TIMEOUT_S", "30", 1);
+    cbm_setenv("CBM_TEST_EXIT_ON", "idxpar_exit_nonzero", 1);
+
+    int st_before = cbm_index_supervisor_spawn_st_count();
+    char *resp = cbm_mcp_index_run_supervised_path(repo_dir);
+    int st_after = cbm_index_supervisor_spawn_st_count();
+    cbm_unsetenv("CBM_TEST_EXIT_ON");
+
+    if (st_after != st_before) {
+        free(resp);
+        return IDXPAR_ST_SPAWN;
+    }
+    if (!resp) {
+        return IDXPAR_NULL_RESP;
+    }
+    bool indexed = response_contains_json_fragment(resp, "\"status\":\"indexed\"");
+    bool offender_skipped = strstr(resp, "idxpar_exit_nonzero.py") != NULL;
+    bool innocent_hit =
+        strstr(resp, "idxpar_good_a.py") != NULL || strstr(resp, "idxpar_good_b.py") != NULL;
+    bool phase_error = strstr(resp, "\"phase\":\"error\"") != NULL ||
+                       strstr(resp, "quarantined after error") != NULL;
+    free(resp);
+    if (!indexed) {
+        return IDXPAR_NOT_INDEXED;
+    }
+    if (!offender_skipped || !phase_error) {
+        return IDXPAR_NO_QUARANTINE;
+    }
+    if (innocent_hit) {
+        return IDXPAR_INNOCENT_HIT;
+    }
+
+    char *project = cbm_project_name_from_path(repo_dir);
+    cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+    int code = IDXPAR_OK;
+    if (srv && project) {
+        char q[512];
+        snprintf(q, sizeof(q),
+                 "{\"project\":\"%s\",\"name_pattern\":\"idxpar_good_fn\",\"label\":\"Function\"}",
+                 project);
+        char *sr = cbm_mcp_handle_tool(srv, "search_graph", q);
+        if (!sr || !strstr(sr, "idxpar_good_fn")) {
+            code = IDXPAR_GOOD_MISSING;
+        }
+        free(sr);
+    }
+    if (srv) {
+        cbm_mcp_server_free(srv);
+    }
+    free(project);
+    return code;
+}
+
+static int idxpar_systemic_exit_nonzero_give_up_check(const char *repo_dir) {
+    cbm_index_supervisor_mark_host();
+    cbm_unsetenv("CBM_INDEX_SUPERVISOR");
+    cbm_setenv("CBM_INDEX_MAX_RESTARTS", "5", 1);
+    cbm_setenv("CBM_INDEX_WORKER_TIMEOUT_S", "30", 1);
+    cbm_setenv("CBM_TEST_EXIT_ON", "idxpar_", 1);
+
+    char *resp = cbm_mcp_index_run_supervised_path(repo_dir);
+    cbm_unsetenv("CBM_TEST_EXIT_ON");
+
+    if (!resp) {
+        return IDXPAR_NULL_RESP;
+    }
+    bool is_error = response_contains_json_fragment(resp, "\"status\":\"error\"");
+    bool is_exit_nonzero = response_contains_json_fragment(resp, "\"outcome\":\"exit_nonzero\"");
+    bool innocent_hit =
+        strstr(resp, "idxpar_good_a.py") != NULL || strstr(resp, "idxpar_good_b.py") != NULL;
+    free(resp);
+
+    if (!is_error) {
+        return IDXPAR_NOT_ERROR;
+    }
+    if (!is_exit_nonzero) {
+        return IDXPAR_OUTCOME_WRONG;
+    }
+    if (innocent_hit) {
+        return IDXPAR_INNOCENT_HIT;
+    }
+    return IDXPAR_OK;
+}
 #endif /* !_WIN32 */
 
 /* #773: SIGABRT (invalid free in ts_stack_delete via
@@ -10422,6 +10512,155 @@ TEST(index_recovery_parallel_quarantines_crasher) {
 #endif
 }
 
+TEST(index_recovery_quarantines_exit_nonzero) {
+#ifdef _WIN32
+    SKIP_PLATFORM("parallel-recovery guard needs fork isolation (POSIX-only)");
+#else
+    char tmp_dir[CBM_SZ_256];
+    snprintf(tmp_dir, sizeof(tmp_dir), "/tmp/cbm-idxpar-exit-XXXXXX");
+    if (!cbm_mkdtemp(tmp_dir)) {
+        FAIL("mkdtemp failed");
+    }
+    char cache[CBM_SZ_256];
+    snprintf(cache, sizeof(cache), "/tmp/cbm-idxpar-exit-cache-XXXXXX");
+    if (!cbm_mkdtemp(cache)) {
+        FAIL("mkdtemp cache failed");
+    }
+    const char *saved_cache = getenv("CBM_CACHE_DIR");
+    char *saved_cache_copy = saved_cache ? cbm_strdup(saved_cache) : NULL;
+    cbm_setenv("CBM_CACHE_DIR", cache, 1);
+
+    char p1[CBM_SZ_512];
+    char p2[CBM_SZ_512];
+    char pc[CBM_SZ_512];
+    snprintf(p1, sizeof(p1), "%s/idxpar_good_a.py", tmp_dir);
+    snprintf(p2, sizeof(p2), "%s/idxpar_good_b.py", tmp_dir);
+    snprintf(pc, sizeof(pc), "%s/idxpar_exit_nonzero.py", tmp_dir);
+    FILE *f = fopen(p1, "w");
+    ASSERT_NOT_NULL(f);
+    fputs("def idxpar_good_fn():\n    return 'ok'\n", f);
+    fclose(f);
+    f = fopen(p2, "w");
+    ASSERT_NOT_NULL(f);
+    fputs("def idxpar_good_fn_b():\n    return 'ok'\n", f);
+    fclose(f);
+    f = fopen(pc, "w");
+    ASSERT_NOT_NULL(f);
+    fputs("def idxpar_bad_fn():\n    return 'exit'\n", f);
+    fclose(f);
+
+    int code = -1;
+    bool signalled = false;
+    int sig = 0;
+    fflush(NULL);
+    pid_t pid = fork();
+    if (pid == 0) {
+        alarm(120);
+        _exit(idxpar_exit_nonzero_recovery_check(tmp_dir));
+    }
+    ASSERT_TRUE(pid > 0);
+    int status = 0;
+    (void)waitpid(pid, &status, 0);
+    if (WIFEXITED(status)) {
+        code = WEXITSTATUS(status);
+    } else if (WIFSIGNALED(status)) {
+        signalled = true;
+        sig = WTERMSIG(status);
+    }
+
+    char *project = cbm_project_name_from_path(tmp_dir);
+    cleanup_project_db(cache, project);
+    free(project);
+    restore_cache_dir(saved_cache_copy);
+    free(saved_cache_copy);
+    remove(p1);
+    remove(p2);
+    remove(pc);
+    cbm_rmdir(cache);
+    cbm_rmdir(tmp_dir);
+
+    if (signalled) {
+        printf("    child killed by signal %d\n", sig);
+    } else if (code != IDXPAR_OK) {
+        printf("    child exit code %d\n", code);
+    }
+    ASSERT_FALSE(signalled);
+    ASSERT_EQ(code, IDXPAR_OK);
+    PASS();
+#endif
+}
+
+TEST(index_recovery_systemic_exit_nonzero_gives_up) {
+#ifdef _WIN32
+    SKIP_PLATFORM("parallel-recovery guard needs fork isolation (POSIX-only)");
+#else
+    char tmp_dir[CBM_SZ_256];
+    snprintf(tmp_dir, sizeof(tmp_dir), "/tmp/cbm-idxpar-sys-XXXXXX");
+    if (!cbm_mkdtemp(tmp_dir)) {
+        FAIL("mkdtemp failed");
+    }
+    char cache[CBM_SZ_256];
+    snprintf(cache, sizeof(cache), "/tmp/cbm-idxpar-sys-cache-XXXXXX");
+    if (!cbm_mkdtemp(cache)) {
+        FAIL("mkdtemp cache failed");
+    }
+    const char *saved_cache = getenv("CBM_CACHE_DIR");
+    char *saved_cache_copy = saved_cache ? cbm_strdup(saved_cache) : NULL;
+    cbm_setenv("CBM_CACHE_DIR", cache, 1);
+
+    char p1[CBM_SZ_512];
+    char p2[CBM_SZ_512];
+    snprintf(p1, sizeof(p1), "%s/idxpar_good_a.py", tmp_dir);
+    snprintf(p2, sizeof(p2), "%s/idxpar_good_b.py", tmp_dir);
+    FILE *f = fopen(p1, "w");
+    ASSERT_NOT_NULL(f);
+    fputs("def idxpar_good_fn():\n    return 'ok'\n", f);
+    fclose(f);
+    f = fopen(p2, "w");
+    ASSERT_NOT_NULL(f);
+    fputs("def idxpar_good_fn_b():\n    return 'ok'\n", f);
+    fclose(f);
+
+    int code = -1;
+    bool signalled = false;
+    int sig = 0;
+    fflush(NULL);
+    pid_t pid = fork();
+    if (pid == 0) {
+        alarm(120);
+        _exit(idxpar_systemic_exit_nonzero_give_up_check(tmp_dir));
+    }
+    ASSERT_TRUE(pid > 0);
+    int status = 0;
+    (void)waitpid(pid, &status, 0);
+    if (WIFEXITED(status)) {
+        code = WEXITSTATUS(status);
+    } else if (WIFSIGNALED(status)) {
+        signalled = true;
+        sig = WTERMSIG(status);
+    }
+
+    char *project = cbm_project_name_from_path(tmp_dir);
+    cleanup_project_db(cache, project);
+    free(project);
+    restore_cache_dir(saved_cache_copy);
+    free(saved_cache_copy);
+    remove(p1);
+    remove(p2);
+    cbm_rmdir(cache);
+    cbm_rmdir(tmp_dir);
+
+    if (signalled) {
+        printf("    child killed by signal %d\n", sig);
+    } else if (code != IDXPAR_OK) {
+        printf("    child exit code %d\n", code);
+    }
+    ASSERT_FALSE(signalled);
+    ASSERT_EQ(code, IDXPAR_OK);
+    PASS();
+#endif
+}
+
 /* ══════════════════════════════════════════════════════════════════
  *  AUTO_WATCH GATE  (distilled from PR #625)
  *
@@ -11407,6 +11646,8 @@ SUITE(mcp) {
     RUN_TEST(sequential_service_edge_props_are_valid_json_issue898);
     RUN_TEST(index_second_inprocess_run_survives_issue773);
     RUN_TEST(index_recovery_parallel_quarantines_crasher);
+    RUN_TEST(index_recovery_quarantines_exit_nonzero);
+    RUN_TEST(index_recovery_systemic_exit_nonzero_gives_up);
     RUN_TEST(tool_manage_adr_not_found_rich_error);
     RUN_TEST(tool_manage_adr_get_accepts_abs_path);
     RUN_TEST(tool_manage_adr_get_accepts_symlink_path);