Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(storage): 修复快速重启时向量存储锁竞争问题 (#343)

Qin Haojie976a04566dc8
diff --git a/openviking/service/core.py b/openviking/service/core.py
index 31f4c3a79..47cf8f71f 100644
--- a/openviking/service/core.py
+++ b/openviking/service/core.py
@@ -292,6 +292,9 @@ class OpenVikingService:
self._transaction_manager.stop()
self._transaction_manager = None
+ if self._vikingdb_manager:
+ self._vikingdb_manager.mark_closing()
+
if self._queue_manager:
self._queue_manager.stop()
self._queue_manager = None
diff --git a/openviking/storage/collection_schemas.py b/openviking/storage/collection_schemas.py
index ba09d49ea..b12c8e66d 100644
--- a/openviking/storage/collection_schemas.py
+++ b/openviking/storage/collection_schemas.py
@@ -157,6 +157,11 @@ class TextEmbeddingHandler(DequeueHandlerBase):
embedding_msg = EmbeddingMsg.from_dict(queue_data)
inserted_data = embedding_msg.context_data
+ if getattr(self._vikingdb, "is_closing", False):
+ logger.debug("Skip embedding dequeue during shutdown")
+ self.report_success()
+ return None
+
# Only process string messages
if not isinstance(embedding_msg.message, str):
logger.debug(f"Skipping non-string message type: {type(embedding_msg.message)}")
@@ -222,6 +227,10 @@ class TextEmbeddingHandler(DequeueHandlerBase):
self.report_error(str(db_err), data)
return None
except Exception as db_err:
+ if getattr(self._vikingdb, "is_closing", False):
+ logger.debug(f"Skip embedding write during shutdown: {db_err}")
+ self.report_success()
+ return None
logger.error(f"Failed to write to vector database: {db_err}")
import traceback
diff --git a/openviking/storage/vikingdb_manager.py b/openviking/storage/vikingdb_manager.py
index 2b68b6a11..32458bda7 100644
--- a/openviking/storage/vikingdb_manager.py
+++ b/openviking/storage/vikingdb_manager.py
@@ -51,9 +51,18 @@ class VikingDBManager(VikingVectorIndexBackend):
self._queue_manager = queue_manager
self._closing = False
+ def mark_closing(self) -> None:
+ """Mark the manager as entering shutdown flow.
+
+ Queue workers may still be draining messages before the backend is
+ finally closed. Handlers should check ``is_closing`` and stop writing
+ into vector storage to avoid lock contention during rapid restart.
+ """
+ self._closing = True
+
async def close(self) -> None:
"""Close storage connection and release resources."""
- self._closing = True
+ self.mark_closing()
try:
# We do NOT stop the queue manager here as it is an injected dependency
# and should be managed by the creator (OpenVikingService).
diff --git a/tests/storage/test_collection_schemas.py b/tests/storage/test_collection_schemas.py
new file mode 100644
index 000000000..c538f3b6b
--- /dev/null
+++ b/tests/storage/test_collection_schemas.py
@@ -0,0 +1,106 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from openviking.models.embedder.base import EmbedResult
+from openviking.storage.collection_schemas import TextEmbeddingHandler
+from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
+
+
+class _DummyEmbedder:
+ def __init__(self):
+ self.calls = 0
+
+ def embed(self, text: str) -> EmbedResult:
+ self.calls += 1
+ return EmbedResult(dense_vector=[0.1, 0.2])
+
+
+class _DummyConfig:
+ def __init__(self, embedder: _DummyEmbedder):
+ self.storage = SimpleNamespace(vectordb=SimpleNamespace(name="context"))
+ self.embedding = SimpleNamespace(
+ dimension=2,
+ get_embedder=lambda: embedder,
+ )
+
+
+def _build_queue_payload() -> dict:
+ msg = EmbeddingMsg(
+ message="hello",
+ context_data={
+ "id": "id-1",
+ "uri": "viking://resources/sample",
+ "account_id": "default",
+ "abstract": "sample",
+ },
+ )
+ return {"data": json.dumps(msg.to_dict())}
+
+
+async def test_embedding_handler_skip_all_work_when_manager_is_closing(monkeypatch):
+ class _ClosingVikingDB:
+ is_closing = True
+
+ async def upsert(self, _data): # pragma: no cover - should never run
+ raise AssertionError("upsert should not be called during shutdown")
+
+ embedder = _DummyEmbedder()
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.get_openviking_config",
+ lambda: _DummyConfig(embedder),
+ )
+
+ handler = TextEmbeddingHandler(_ClosingVikingDB())
+ status = {"success": 0, "error": 0}
+ handler.set_callbacks(
+ on_success=lambda: status.__setitem__("success", status["success"] + 1),
+ on_error=lambda *_: status.__setitem__("error", status["error"] + 1),
+ )
+
+ result = await handler.on_dequeue(_build_queue_payload())
+
+ assert result is None
+ assert embedder.calls == 0
+ assert status["success"] == 1
+ assert status["error"] == 0
+
+
+async def test_embedding_handler_treats_shutdown_write_lock_as_success(monkeypatch):
+ class _ClosingDuringUpsertVikingDB:
+ def __init__(self):
+ self.is_closing = False
+ self.calls = 0
+
+ async def upsert(self, _data):
+ self.calls += 1
+ self.is_closing = True
+ raise RuntimeError("IO error: lock /tmp/LOCK: already held by process")
+
+ embedder = _DummyEmbedder()
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.get_openviking_config",
+ lambda: _DummyConfig(embedder),
+ )
+
+ vikingdb = _ClosingDuringUpsertVikingDB()
+ handler = TextEmbeddingHandler(vikingdb)
+ status = {"success": 0, "error": 0}
+ handler.set_callbacks(
+ on_success=lambda: status.__setitem__("success", status["success"] + 1),
+ on_error=lambda *_: status.__setitem__("error", status["error"] + 1),
+ )
+
+ result = await handler.on_dequeue(_build_queue_payload())
+
+ assert result is None
+ assert vikingdb.calls == 1
+ assert embedder.calls == 1
+ assert status["success"] == 1
+ assert status["error"] == 0