Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
fix(watcher): cap success cooldown at 5 min; test the schedule without sleeping
Shane McCarroncbf379472f23
diff --git a/src/watcher/watcher.c b/src/watcher/watcher.cindex cef4fd482..3bdd1a6c3 100644--- a/src/watcher/watcher.c+++ b/src/watcher/watcher.c@@ -155,14 +155,13 @@ struct cbm_watcher {#define INDEX_FAIL_SUSTAINED 10/* Success cooldown (#2835): after a successful re-index the next poll waits- * at least INDEX_COOLDOWN_FACTOR x the index's own duration, counted from when- * the index finished, so the watcher spends at most ~1/(K+1) of wall time- * indexing one project — a 5-minute rebuild idles 15 minutes. Sub-second- * indexes stay at the plain cadence. The ceiling bounds staleness after one- * pathological run; it is NOT INDEX_FAIL_CEILING_MS (5 min), which would cut- * the cooldown of any rebuild over 100 s below K x its duration. */+ * INDEX_COOLDOWN_FACTOR x the index's own duration, counted from when the+ * index finished, so short rebuilds spend at most ~1/(K+1) of wall time+ * indexing one project. Sub-second indexes stay at the plain cadence. The+ * cooldown is capped at INDEX_FAIL_CEILING_MS (5 min) so that, under+ * continuous writes, a project never falls more than one rebuild plus five+ * minutes behind. */#define INDEX_COOLDOWN_FACTOR 3-#define INDEX_COOLDOWN_CEILING_MS 1800000 /* 30 min *//* Stale-root pruning (#286): a watched project whose root directory stays* missing is pruned — its cached DB is deleted and the watch entry removed.@@ -185,7 +184,17 @@ struct cbm_watcher {/* ── Time helper ────────────────────────────────────────────────── */+#if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS+/* Test seam: nonzero freezes the watcher's scheduling clock at this value. */+static int64_t test_clock_ns = 0;+#endif+static int64_t now_ns(void) {+#if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS+ if (test_clock_ns != 0) {+ return test_clock_ns;+ }+#endifstruct timespec ts;cbm_clock_gettime(CLOCK_MONOTONIC, &ts);return ((int64_t)ts.tv_sec * NS_PER_SEC) + ts.tv_nsec;@@ -222,8 +231,8 @@ int cbm_watcher_success_delay_ms(int interval_ms, int64_t index_elapsed_ms) {return interval_ms;}/* Divide instead of multiply so a huge elapsed cannot overflow. */- int64_t cooldown = index_elapsed_ms > INDEX_COOLDOWN_CEILING_MS / INDEX_COOLDOWN_FACTOR- ? INDEX_COOLDOWN_CEILING_MS+ int64_t cooldown = index_elapsed_ms > INDEX_FAIL_CEILING_MS / INDEX_COOLDOWN_FACTOR+ ? INDEX_FAIL_CEILING_MS: index_elapsed_ms * INDEX_COOLDOWN_FACTOR;return (int)(cooldown > interval_ms ? cooldown : interval_ms);}@@ -1912,4 +1921,19 @@ int cbm_watcher_test_pending_free_count(cbm_watcher_t *w) {cbm_mutex_unlock(&w->projects_lock);return count;}++void cbm_watcher_test_set_clock_ns(int64_t ns) {+ test_clock_ns = ns;+}++int64_t cbm_watcher_test_next_poll_ns(cbm_watcher_t *w, const char *project) {+ if (!w || !project) {+ return -1;+ }+ cbm_mutex_lock(&w->projects_lock);+ project_state_t *s = cbm_ht_get(w->projects, project);+ int64_t next = s ? s->next_poll_ns : -1;+ cbm_mutex_unlock(&w->projects_lock);+ return next;+}#endifdiff --git a/src/watcher/watcher.h b/src/watcher/watcher.hindex eb7e92915..571b20123 100644--- a/src/watcher/watcher.h+++ b/src/watcher/watcher.h@@ -145,6 +145,15 @@ int cbm_watcher_index_failure_count(cbm_watcher_t *w, const char *project_name);* otherwise unobservable — cbm_watcher_free frees the same list, so a poll* that stopped draining would neither crash nor leak. Test builds only. */int cbm_watcher_test_pending_free_count(cbm_watcher_t *w);++/* Test seam: freeze the watcher's monotonic scheduling clock at `ns`+ * (nonzero), or restore the real clock (0). Process-global; single-threaded+ * tests only. Lets a test advance time inside index_fn without sleeping. */+void cbm_watcher_test_set_clock_ns(int64_t ns);++/* Test seam: a project's scheduled next poll (monotonic ns), read under+ * projects_lock; -1 when it is not watched. */+int64_t cbm_watcher_test_next_poll_ns(cbm_watcher_t *w, const char *project);#endif/* Per-project watch status, for index_status (#2167). */@@ -197,10 +206,10 @@ int cbm_watcher_index_backoff_ms(int interval_ms, int consecutive_failures);/* Return the delay (ms) before the next poll after a SUCCESSFUL re-index that* took `index_elapsed_ms`: max(interval_ms, INDEX_COOLDOWN_FACTOR (3) x- * index_elapsed_ms), with the cooldown term capped at INDEX_COOLDOWN_CEILING_MS- * (30 min). The caller counts it from when the index finished, so the watcher- * spends at most ~1/4 of wall time indexing a project; sub-second indexes keep- * `interval_ms`.+ * index_elapsed_ms), with the cooldown term capped at INDEX_FAIL_CEILING_MS+ * (5 min). The caller counts it from when the index finished, so short+ * rebuilds spend at most ~1/4 of wall time indexing a project; sub-second+ * indexes keep `interval_ms`.* Never below `interval_ms`; overflow-safe; negative inputs act as zero. */int cbm_watcher_success_delay_ms(int interval_ms, int64_t index_elapsed_ms);diff --git a/tests/test_watcher.c b/tests/test_watcher.cindex c2796e3a6..670d4f5a2 100644--- a/tests/test_watcher.c+++ b/tests/test_watcher.c@@ -2273,15 +2273,17 @@ TEST(success_delay_fast_index_keeps_interval) {TEST(success_delay_slow_index_scales_by_factor) {ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 1667), 5001);ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 10000), 30000);- /* 5-minute rebuild → next poll 15 min after it finishes. */- ASSERT_EQ(cbm_watcher_success_delay_ms(60000, 300000), 900000);+ /* 90 s rebuild → next poll 4.5 min after it finishes. */+ ASSERT_EQ(cbm_watcher_success_delay_ms(60000, 90000), 270000);PASS();}TEST(success_delay_clamped_and_degenerate) {- ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 600000), 1800000);- ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 600001), 1800000);- ASSERT_EQ(cbm_watcher_success_delay_ms(5000, INT64_MAX), 1800000);+ /* Capped at 5 min (INDEX_FAIL_CEILING_MS) from 100 s of indexing up. */+ ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 100000), 300000);+ ASSERT_EQ(cbm_watcher_success_delay_ms(5000, 100001), 300000);+ ASSERT_EQ(cbm_watcher_success_delay_ms(60000, 300000), 300000);+ ASSERT_EQ(cbm_watcher_success_delay_ms(5000, INT64_MAX), 300000);ASSERT_EQ(cbm_watcher_success_delay_ms(5000, -1), 5000);ASSERT_EQ(cbm_watcher_success_delay_ms(5000, INT64_MIN), 5000);ASSERT_EQ(cbm_watcher_success_delay_ms(-1, 0), 0);@@ -2295,34 +2297,45 @@ TEST(success_delay_is_monotonic) {for (int64_t e = 0; e <= 2000000; e += 997) {int delay = cbm_watcher_success_delay_ms(5000, e);ASSERT_TRUE(delay >= previous);- ASSERT_TRUE(delay >= 5000 && delay <= 1800000);+ ASSERT_TRUE(delay >= 5000 && delay <= 300000);previous = delay;}PASS();}-/* Wire-up: the cooldown must be measured around the real index_fn call. An- * instant callback keeps the plain cadence (no cooldown line); a callback- * slower than interval/3 (5000/3 ms) extends it and logs once. */-static int cooldown_log_hits = 0;-static void cooldown_log_sink(const char *line) {- if (line && strstr(line, "watcher.cooldown") != NULL) {- cooldown_log_hits++;- }-}-static int slow_index_sleep_ms = 0;-static int slow_index_calls = 0;-static int slow_index_callback(const char *name, const char *path, void *ud) {+/* Wire-up: the cooldown must be measured around the real index_fn call and+ * counted from when the index finished. The watcher's clock is frozen via a+ * test seam and the callback advances it, so an index "takes" a chosen time+ * with no sleep and the scheduled poll time can be asserted exactly. */+#define COOL_NS_PER_MS 1000000LL+static int64_t cool_clock_ns = 0;+static int64_t cool_index_ms = 0;+static int cool_index_calls = 0;+static int cool_index_callback(const char *name, const char *path, void *ud) {(void)name;(void)path;(void)ud;- slow_index_calls++;- if (slow_index_sleep_ms > 0) {- cbm_usleep((unsigned)slow_index_sleep_ms * 1000U);- }+ cool_index_calls++;+ cool_clock_ns += cool_index_ms * COOL_NS_PER_MS;+ cbm_watcher_test_set_clock_ns(cool_clock_ns);return 0;}+/* Re-index once (touch + poll until the callback runs; a transient git probe+ * failure makes a poll a no-op, see the sustained-failure test) and return+ * the scheduled next poll relative to when the index finished, in ms. */+static int64_t cool_reindex_delay_ms(cbm_watcher_t *w, const char *file, const char *line,+ int64_t index_ms) {+ cool_index_ms = index_ms;+ th_append_file(file, line);+ int target = cool_index_calls + 1;+ while (cool_index_calls < target) {+ cbm_watcher_touch(w, "cool-repo");+ cbm_watcher_poll_once(w);+ }+ return (cbm_watcher_test_next_poll_ns(w, "cool-repo") - cool_clock_ns) / COOL_NS_PER_MS;+}+TEST(watcher_success_cooldown_measures_index_issue2835) {char tmpdir[256];snprintf(tmpdir, sizeof(tmpdir), "/tmp/cbm_watcher_cool_XXXXXX");@@ -2337,40 +2350,30 @@ TEST(watcher_success_cooldown_measures_index_issue2835) {wt_git(tmpdir, "add file.txt");wt_git(tmpdir, "commit -q -m init");+ cool_clock_ns = 1000LL * 1000 * COOL_NS_PER_MS; /* any nonzero start */+ cbm_watcher_test_set_clock_ns(cool_clock_ns);+ cool_index_calls = 0;+cbm_store_t *store = cbm_store_open_memory();- cbm_watcher_t *w = cbm_watcher_new(store, slow_index_callback, NULL);+ cbm_watcher_t *w = cbm_watcher_new(store, cool_index_callback, NULL);cbm_watcher_watch(w, "cool-repo", tmpdir);- slow_index_calls = 0;- slow_index_sleep_ms = 0;cbm_watcher_poll_once(w); /* baseline */- CBMLogLevel old_level = cbm_log_get_level();- cbm_log_set_level(CBM_LOG_INFO);- cooldown_log_hits = 0;- cbm_log_set_sink(cooldown_log_sink);-- /* Instant index: no cooldown. Loop on the attempt count (a transient git- * probe failure makes a poll a no-op, see the sustained-failure test). */- th_append_file(wt_path(p, sizeof(p), tmpdir, "file.txt"), "a\n");- while (slow_index_calls < 1) {- cbm_watcher_touch(w, "cool-repo");- cbm_watcher_poll_once(w);- }- int fast_hits = cooldown_log_hits;-- /* 1.8 s index → 3 x 1800 = 5400 ms > 5000 ms interval: cooldown. */- slow_index_sleep_ms = 1800;- th_append_file(wt_path(p, sizeof(p), tmpdir, "file.txt"), "b\n");- while (slow_index_calls < 2) {- cbm_watcher_touch(w, "cool-repo");- cbm_watcher_poll_once(w);- }-- cbm_log_set_sink(NULL);- cbm_log_set_level(old_level);-- ASSERT_EQ(fast_hits, 0);- ASSERT_EQ(cooldown_log_hits, 1);+ wt_path(p, sizeof(p), tmpdir, "file.txt");+ /* Instant index: plain cadence. */+ int64_t fast = cool_reindex_delay_ms(w, p, "a\n", 0);+ /* 60 s index → 3 x 60 s, counted from the END of the index (anchoring at+ * the start would give 120 s here). */+ int64_t slow = cool_reindex_delay_ms(w, p, "b\n", 60000);+ /* 200 s index → 600 s, capped at 5 min. */+ int64_t capped = cool_reindex_delay_ms(w, p, "c\n", 200000);++ /* Restore the real clock before any assert can return early. */+ cbm_watcher_test_set_clock_ns(0);++ ASSERT_EQ(fast, cbm_watcher_poll_interval_ms(1));+ ASSERT_EQ(slow, 180000);+ ASSERT_EQ(capped, 300000);cbm_watcher_free(w);cbm_store_close(store);