Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,7 @@

_lock = threading.RLock()
_bridge_ok: bool | None = None
_bridge_ok_at: float = 0.0
_viewer_status: str | None = None
_viewer_last_probe_at = 0.0
_viewer_process: subprocess.Popen | None = None
Expand All @@ -42,6 +43,11 @@
VIEWER_PROBE_TTL_SEC = 30.0
VIEWER_START_LOCK_TIMEOUT_SEC = 20.0
VIEWER_START_LOCK_STALE_SEC = 60.0
# Bound how long a cached `_bridge_ok` answer is trusted. Without this, a
# single transient `_node_available()` failure during gateway startup
# (subprocess race, `.env` loaded after the first probe) would pin the
# provider to "unavailable" for the lifetime of the process — see #1797.
BRIDGE_OK_TTL_SEC = 60.0


@contextlib.contextmanager
Expand Down Expand Up @@ -153,22 +159,39 @@ def ensure_bridge_running(*, probe_only: bool = False) -> bool:
``probe_only=True`` performs a lightweight availability check without
launching a long-lived subprocess. This is what
``MemTensorProvider.is_available`` calls during Hermes startup.

The cached answer is honoured only inside ``BRIDGE_OK_TTL_SEC``; once
it expires we revalidate. A transient ``_node_available()`` failure
therefore self-heals on the next probe instead of permanently
disabling the provider (see issue #1797).
"""
global _bridge_ok
global _bridge_ok, _bridge_ok_at
with _lock:
if _bridge_ok is not None and probe_only:
now = time.time()
if _bridge_ok is not None and probe_only and (now - _bridge_ok_at) < BRIDGE_OK_TTL_SEC:
return _bridge_ok
script = _bridge_script()
if not script.exists():
logger.warning("MemOS: bridge script missing at %s", script)
_bridge_ok = False
_bridge_ok_at = now
return False
if not _node_available():
logger.warning("MemOS: Node.js not found on PATH")
_bridge_ok = False
return False
_bridge_ok = True
return True
if _node_available():
_bridge_ok = True
_bridge_ok_at = now
return True
# Node binary check just failed. A MemOS bridge already running on
# :18800 is definitive proof Node works on this host (the daemon
# itself was launched via Node); trust it and recover rather than
# report unavailable forever.
if _probe_viewer() == "running_memos":
_bridge_ok = True
_bridge_ok_at = now
return True
logger.warning("MemOS: Node.js not found on PATH")
_bridge_ok = False
_bridge_ok_at = now
return False


def _probe_viewer() -> str:
Expand Down Expand Up @@ -331,9 +354,10 @@ def ensure_viewer_daemon(*, probe_only: bool = False) -> bool:

def shutdown_bridge() -> None:
"""Best-effort cleanup; each client owns its own subprocess."""
global _bridge_ok
global _bridge_ok, _bridge_ok_at
with _lock:
_bridge_ok = None
_bridge_ok_at = 0.0


def wait_for_process_exit(pid: int, timeout: float = 5.0) -> bool:
Expand Down
138 changes: 138 additions & 0 deletions apps/memos-local-plugin/tests/python/test_bridge_client.py
Original file line number Diff line number Diff line change
Expand Up @@ -743,5 +743,143 @@ def busy_lock():
popen.assert_not_called()


class BridgeOkCacheTests(unittest.TestCase):
"""Regression tests for issue #1797.

`ensure_bridge_running(probe_only=True)` used to cache a `False`
result permanently. These tests pin down the new contract: cache
entries have a TTL, and a running MemOS bridge on :18800 is a
fallback signal that Node works on this host even if a transient
`_node_available()` call failed.
"""

def setUp(self) -> None:
# Make sure each test starts from a clean module-level cache.
daemon_manager_mod._bridge_ok = None
daemon_manager_mod._bridge_ok_at = 0.0
# Pretend the compiled bridge script exists so the "script
# missing" early-return does not steal the test.
self._script_patch = patch.object(
daemon_manager_mod,
"_bridge_script",
return_value=Path("/fake/bridge.cjs"),
)
self._script_patch.start()
self._exists_patch = patch.object(Path, "exists", return_value=True)
self._exists_patch.start()

def tearDown(self) -> None:
self._exists_patch.stop()
self._script_patch.stop()
daemon_manager_mod._bridge_ok = None
daemon_manager_mod._bridge_ok_at = 0.0

def test_probe_only_when_cache_empty_revalidates(self) -> None:
with (
patch.object(daemon_manager_mod, "_node_available", return_value=True) as node,
patch.object(daemon_manager_mod, "_probe_viewer") as probe,
):
self.assertTrue(daemon_manager_mod.ensure_bridge_running(probe_only=True))
node.assert_called_once()
probe.assert_not_called()

def test_cached_false_returns_immediately_within_ttl(self) -> None:
# Seed the cache with a fresh False as if a transient failure occurred.
now = 1_000_000.0
with (
patch.object(daemon_manager_mod.time, "time", return_value=now),
patch.object(daemon_manager_mod, "_node_available", return_value=False),
patch.object(daemon_manager_mod, "_probe_viewer", return_value="free"),
):
self.assertFalse(daemon_manager_mod.ensure_bridge_running(probe_only=True))

# Within TTL, _node_available must NOT be called again — the cached
# False is returned directly.
with (
patch.object(daemon_manager_mod.time, "time", return_value=now + 1.0),
patch.object(daemon_manager_mod, "_node_available") as node,
patch.object(daemon_manager_mod, "_probe_viewer") as probe,
):
self.assertFalse(daemon_manager_mod.ensure_bridge_running(probe_only=True))
node.assert_not_called()
probe.assert_not_called()

def test_cached_false_expires_after_ttl_and_recovers(self) -> None:
now = 2_000_000.0
# Seed cache with a False at t=now.
with (
patch.object(daemon_manager_mod.time, "time", return_value=now),
patch.object(daemon_manager_mod, "_node_available", return_value=False),
patch.object(daemon_manager_mod, "_probe_viewer", return_value="free"),
):
self.assertFalse(daemon_manager_mod.ensure_bridge_running(probe_only=True))

# After TTL + 1s, Node is now reachable. probe_only=True must
# revalidate and switch the cache to True.
with (
patch.object(
daemon_manager_mod.time,
"time",
return_value=now + daemon_manager_mod.BRIDGE_OK_TTL_SEC + 1.0,
),
patch.object(daemon_manager_mod, "_node_available", return_value=True),
):
self.assertTrue(daemon_manager_mod.ensure_bridge_running(probe_only=True))
# And the value is cached.
self.assertTrue(daemon_manager_mod._bridge_ok)

def test_running_bridge_overrides_failed_node_probe(self) -> None:
# A live MemOS bridge is definitive proof Node worked; trust it
# even if `_node_available` returns False (e.g. env-var race).
now = 3_000_000.0
with (
patch.object(daemon_manager_mod.time, "time", return_value=now),
patch.object(daemon_manager_mod, "_node_available", return_value=False),
patch.object(daemon_manager_mod, "_probe_viewer", return_value="running_memos"),
):
self.assertTrue(daemon_manager_mod.ensure_bridge_running(probe_only=True))
self.assertTrue(daemon_manager_mod._bridge_ok)
self.assertEqual(daemon_manager_mod._bridge_ok_at, now)

def test_shutdown_bridge_resets_cache_and_timestamp(self) -> None:
now = 4_000_000.0
with (
patch.object(daemon_manager_mod.time, "time", return_value=now),
patch.object(daemon_manager_mod, "_node_available", return_value=True),
):
self.assertTrue(daemon_manager_mod.ensure_bridge_running(probe_only=True))

self.assertIsNotNone(daemon_manager_mod._bridge_ok)
self.assertGreater(daemon_manager_mod._bridge_ok_at, 0.0)

daemon_manager_mod.shutdown_bridge()
self.assertIsNone(daemon_manager_mod._bridge_ok)
self.assertEqual(daemon_manager_mod._bridge_ok_at, 0.0)

# After reset, the next probe must call `_node_available` again.
with (
patch.object(daemon_manager_mod.time, "time", return_value=now + 1.0),
patch.object(daemon_manager_mod, "_node_available", return_value=True) as node,
):
self.assertTrue(daemon_manager_mod.ensure_bridge_running(probe_only=True))
node.assert_called_once()

def test_full_call_always_revalidates(self) -> None:
# `probe_only=False` (called from `MemTensorProvider.initialize`)
# must bypass the cache and refresh.
now = 5_000_000.0
# Pre-seed a stale True.
daemon_manager_mod._bridge_ok = True
daemon_manager_mod._bridge_ok_at = now - 1.0
with (
patch.object(daemon_manager_mod.time, "time", return_value=now),
patch.object(daemon_manager_mod, "_node_available", return_value=False) as node,
patch.object(daemon_manager_mod, "_probe_viewer", return_value="free"),
):
self.assertFalse(daemon_manager_mod.ensure_bridge_running())
node.assert_called_once()
self.assertFalse(daemon_manager_mod._bridge_ok)


if __name__ == "__main__":
unittest.main()
Loading