fix(mcp): messages d erreur exploitables et rejeu unique sur HTTP 502/503/504 et timeout (infra-2026-10-042b)

This commit is contained in:
bolbol committed 2026-10-12 04:34:38 +02:00
1 parent cc20ccef2f
commit 67f33fc81e
2 files changed
+251 -21

No files matched your search

+122 -21
View File
@@ -5,6 +5,7 @@ Garantit côté serveur le cloisonnement strict des sphères (tt, nyora, perso,
Double contrôle d'autorisation avant et après appel à Open Notebook.
Gestion des jetons par empreinte sha256, limitation de débit et journalisation sans secrets."""
import asyncio
import contextvars
from datetime import datetime, timezone
import hashlib
@@ -39,6 +40,7 @@ ACCESS_LOG_PATH = os.path.join(LOGS_DIR, "access.log")
RATE_LIMIT_TOTAL_PER_MIN = int(os.environ.get("RATE_LIMIT_TOTAL_PER_MIN", "60"))
RATE_LIMIT_ASK_PER_MIN = int(os.environ.get("RATE_LIMIT_ASK_PER_MIN", "10"))
TIMEOUT_SECONDS = float(os.environ.get("TIMEOUT_SECONDS", "60.0"))
RETRY_DELAY_SECONDS = float(os.environ.get("RETRY_DELAY_SECONDS", "2.0"))
# ---------------------------------------------------------------- Journalisation des accès
os.makedirs(LOGS_DIR, exist_ok=True)
@@ -281,6 +283,57 @@ def check_notebook_auth(notebook_id: str, identity: str) -> dict:
return row
# ---------------------------------------------------------------- Gestion des erreurs et pannes Open Notebook
def is_timeout_exception(e: Exception) -> bool:
if isinstance(e, (httpx.TimeoutException, asyncio.TimeoutError)):
return True
name = type(e).__name__.lower()
if "timeout" in name:
return True
msg = str(e).lower()
if "délai dépassé" in msg or "timed out" in msg or "timeout" in msg:
return True
return False
def format_open_notebook_error(err_or_status: Exception | int | None, retried: bool = False) -> str:
suffix = " (après rejeu)" if retried else ""
if isinstance(err_or_status, (int, str)) and str(err_or_status).isdigit():
code = int(err_or_status)
if code in (502, 503, 504):
return (
f"Open Notebook a répondu HTTP {code}{suffix}. Un nouvel essai ultérieur peut réussir."
if retried
else f"Open Notebook a répondu HTTP {code}. Un nouvel essai peut réussir."
)
elif code == 500:
return f"Open Notebook a répondu HTTP 500{suffix}. Un nouvel essai ultérieur peut réussir."
elif 400 <= code < 500:
return f"Open Notebook a répondu HTTP {code}. Inutile de réessayer avec les mêmes paramètres."
else:
return f"Open Notebook a répondu HTTP {code}{suffix}. Un nouvel essai peut échouer."
if err_or_status is None:
return "Open Notebook injoignable. Un nouvel essai ultérieur peut réussir une fois le service rétabli."
exc = err_or_status
if is_timeout_exception(exc):
if retried:
return "Délai dépassé lors de la communication avec Open Notebook (après rejeu). Un nouvel essai ultérieur peut réussir."
return "Délai dépassé lors de la communication avec Open Notebook. Un nouvel essai peut réussir."
return "Open Notebook injoignable. Un nouvel essai ultérieur peut réussir une fois le service rétabli."
def wrap_open_notebook_exception(e: Exception, retried: bool = False) -> Exception:
if isinstance(e, (ValueError, NameError, TypeError, AttributeError)):
return e
if isinstance(e, RuntimeError) and ("délai dépassé" in str(e).lower() or "open notebook" in str(e).lower()):
return e
msg = format_open_notebook_error(e, retried=retried)
return RuntimeError(msg)
# ---------------------------------------------------------------- Client Open Notebook
def get_on_password() -> str:
try:
@@ -375,9 +428,10 @@ async def notebook_list() -> dict:
log_access(identity, "notebook_list", None, "ok", int((time.monotonic() - t0) * 1000))
return {"notebooks": results}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "notebook_list", None, status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
@mcp.tool(
@@ -401,13 +455,17 @@ async def notebook_create(sphere: str, name: str, description: str = "") -> dict
if sphere_clean not in allowed:
raise ValueError(f"Sphère non autorisée pour cette identité : {sphere}")
try:
st, rep = await on_request(
"POST",
"/notebooks",
{"name": str(name).strip(), "description": str(description).strip()}
)
except Exception as e:
raise wrap_open_notebook_exception(e, retried=False) from e
if st not in (200, 201) or not isinstance(rep, dict) or "id" not in rep:
raise RuntimeError(f"Erreur création carnet dans Open Notebook (HTTP {st})")
raise RuntimeError(format_open_notebook_error(st, retried=False))
nb_id = str(rep["id"])
create_notebook_entry(nb_id, sphere_clean, str(name).strip(), str(description).strip(), identity)
@@ -420,9 +478,10 @@ async def notebook_create(sphere: str, name: str, description: str = "") -> dict
"description": str(description).strip(),
}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "notebook_create", None, status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
@mcp.tool(
@@ -445,6 +504,7 @@ async def source_add_text(notebook_id: str, title: str, content: str) -> dict:
if len(content) > 200000:
raise ValueError("Le contenu dépasse la taille maximale autorisée de 200 000 caractères")
try:
st, rep = await on_request(
"POST",
"/sources/json",
@@ -456,8 +516,11 @@ async def source_add_text(notebook_id: str, title: str, content: str) -> dict:
"embed": True,
}
)
except Exception as e:
raise wrap_open_notebook_exception(e, retried=False) from e
if st not in (200, 201) or not isinstance(rep, dict) or "id" not in rep:
raise RuntimeError(f"Erreur ajout source dans Open Notebook (HTTP {st})")
raise RuntimeError(format_open_notebook_error(st, retried=False))
src_id = str(rep["id"])
create_source_entry(src_id, str(notebook_id).strip(), str(title).strip(), content[:300])
@@ -470,9 +533,10 @@ async def source_add_text(notebook_id: str, title: str, content: str) -> dict:
"embedded": bool(rep.get("embedded", False)),
}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "source_add_text", str(notebook_id).strip(), status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
@mcp.tool(
@@ -489,12 +553,16 @@ async def source_list(notebook_id: str) -> dict:
try:
nb = check_notebook_auth(notebook_id, identity)
nb_id_clean = str(notebook_id).strip()
try:
st, rep = await on_request(
"GET",
f"/sources?notebook_id={urllib.parse.quote(nb_id_clean)}"
)
except Exception as e:
raise wrap_open_notebook_exception(e, retried=False) from e
if st != 200 or not isinstance(rep, list):
raise RuntimeError(f"Erreur récupération sources dans Open Notebook (HTTP {st})")
raise RuntimeError(format_open_notebook_error(st, retried=False))
sources = []
for s in rep:
@@ -506,9 +574,10 @@ async def source_list(notebook_id: str) -> dict:
log_access(identity, "source_list", nb_id_clean, "ok", int((time.monotonic() - t0) * 1000))
return {"sources": sources}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "source_list", str(notebook_id).strip(), status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
@mcp.tool(
@@ -529,19 +598,46 @@ async def notebook_ask(notebook_id: str, question: str) -> dict:
raise ValueError("La question ne peut pas être vide")
chat_model = await get_default_chat_model()
st, rep = await on_request(
"POST",
"/search/ask/simple",
{
payload = {
"question": str(question).strip(),
"notebook_id": nb_id_clean,
"strategy_model": chat_model,
"answer_model": chat_model,
"final_answer_model": chat_model,
}
)
st = None
rep = None
timeout_err = None
try:
st, rep = await on_request("POST", "/search/ask/simple", payload)
except Exception as e:
if is_timeout_exception(e):
timeout_err = e
else:
raise wrap_open_notebook_exception(e, retried=False) from e
# Rejeu unique si 502, 503, 504 ou délai dépassé
if (timeout_err is not None) or (isinstance(st, int) and st in (502, 503, 504)):
await asyncio.sleep(RETRY_DELAY_SECONDS)
timeout_err = None
try:
st, rep = await on_request("POST", "/search/ask/simple", payload)
except Exception as e:
if is_timeout_exception(e):
timeout_err = e
else:
raise wrap_open_notebook_exception(e, retried=True) from e
if timeout_err is not None:
raise RuntimeError(format_open_notebook_error(timeout_err, retried=True))
if st != 200 or not isinstance(rep, dict):
raise RuntimeError(f"Erreur interrogation carnet Open Notebook (HTTP {st})")
raise RuntimeError(format_open_notebook_error(st, retried=True))
else:
if timeout_err is not None:
raise RuntimeError(format_open_notebook_error(timeout_err, retried=False))
if st != 200 or not isinstance(rep, dict):
raise RuntimeError(format_open_notebook_error(st, retried=False))
raw_answer = str(rep.get("answer", ""))
raw_sources = rep.get("sources", [])
@@ -554,11 +650,14 @@ async def notebook_ask(notebook_id: str, question: str) -> dict:
src_row = get_source(s_id)
src_nb_id = src_row["notebook_id"] if src_row else None
if not src_nb_id:
try:
st_s, s_info = await on_request("GET", f"/sources/{s_id}")
if st_s == 200 and isinstance(s_info, dict):
nbs_list = s_info.get("notebooks") or []
if nb_id_clean in nbs_list:
src_nb_id = nb_id_clean
except Exception:
pass
if src_nb_id:
nb_entry = get_notebook(src_nb_id)
@@ -577,9 +676,10 @@ async def notebook_ask(notebook_id: str, question: str) -> dict:
log_access(identity, "notebook_ask", nb_id_clean, "ok", int((time.monotonic() - t0) * 1000))
return {"answer": answer_text, "sources": filtered_sources}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "notebook_ask", str(notebook_id).strip(), status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
@mcp.tool(
@@ -684,9 +784,10 @@ async def notebook_search(query: str, notebook_id: str = "", max_results: int =
log_access(identity, "notebook_search", notebook_id, "ok", int((time.monotonic() - t0) * 1000))
return {"results": results}
except Exception as e:
status = "rate_limit_exceeded" if "débit" in str(e).lower() else "error"
clean_e = wrap_open_notebook_exception(e)
status = "rate_limit_exceeded" if "débit" in str(clean_e).lower() else "error"
log_access(identity, "notebook_search", str(notebook_id).strip(), status, int((time.monotonic() - t0) * 1000))
raise
raise clean_e from e
# ---------------------------------------------------------------- ASGI & Starlette Setup
+129
View File
@@ -10,6 +10,7 @@ import os
import tempfile
import time
import unittest
import httpx
from unittest.mock import AsyncMock, patch
import server
@@ -195,5 +196,133 @@ class TestNotebookMcp(unittest.IsolatedAsyncioTestCase):
self.assertNotIn("test_super_secret_password_1234", line)
@patch("asyncio.sleep")
@patch("server.on_request")
async def test_message_erreur_non_vide(self, mock_on_request, mock_sleep):
"""Vérifie que les erreurs (ReadTimeout, ConnectTimeout, 502 après rejeu)
produisent un message en français, jamais vide, nommant la panne et indiquant si un nouvel essai a un sens."""
server.CURRENT_IDENTITY.set("test-pilote")
server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote")
# 1. Cas ReadTimeout
mock_on_request.side_effect = httpx.ReadTimeout("")
with self.assertRaises(Exception) as ctx:
await server.notebook_ask("notebook:a1", "question test")
msg = str(ctx.exception)
self.assertTrue(len(msg) > 0, "Le message ReadTimeout ne doit pas être vide")
self.assertIn("délai dépassé", msg.lower())
self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower())
self.assertNotIn("question test", msg)
self.assertNotIn("notebook:a1", msg)
# 2. Cas ConnectTimeout
mock_on_request.side_effect = httpx.ConnectTimeout("")
with self.assertRaises(Exception) as ctx:
await server.notebook_ask("notebook:a1", "question test")
msg = str(ctx.exception)
self.assertTrue(len(msg) > 0, "Le message ConnectTimeout ne doit pas être vide")
self.assertIn("délai dépassé", msg.lower())
self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower())
self.assertNotIn("question test", msg)
self.assertNotIn("notebook:a1", msg)
# 3. Cas HTTP 502 après rejeu
mock_on_request.side_effect = None
mock_on_request.return_value = (502, "Bad Gateway")
with self.assertRaises(Exception) as ctx:
await server.notebook_ask("notebook:a1", "question test")
msg = str(ctx.exception)
self.assertTrue(len(msg) > 0, "Le message 502 ne doit pas être vide")
self.assertIn("502", msg)
self.assertIn("open notebook a répondu http 502", msg.lower())
self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower())
self.assertNotIn("question test", msg)
self.assertNotIn("notebook:a1", msg)
@patch("asyncio.sleep")
@patch("server.on_request")
async def test_rejeu_unique_sur_502(self, mock_on_request, mock_sleep):
"""Vérifie que notebook_ask rejoue une seule fois après 2 secondes sur 502."""
server.CURRENT_IDENTITY.set("test-pilote")
server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote")
# Cas 1 : 1er appel 502, 2nd appel 200 (succès après rejeu)
call_count = 0
async def fake_retry(method, path, body=None):
nonlocal call_count
if path == "/models/defaults":
return 200, {"default_chat_model": "test-model"}
if path == "/search/ask/simple":
call_count += 1
if call_count == 1:
return 502, "Bad Gateway"
return 200, {"answer": "Réponse après rejeu réussi", "sources": []}
return 404, {}
mock_on_request.side_effect = fake_retry
rep = await server.notebook_ask("notebook:a1", "question test")
self.assertEqual(rep["answer"], "Réponse après rejeu réussi")
self.assertEqual(call_count, 2, "Doit avoir été appelé exactement 2 fois (1 tentative + 1 rejeu)")
mock_sleep.assert_called_with(2.0)
# Cas 2 : les deux appels échouent en 502 (rejeu unique, arrêt à 2)
call_count_fail = 0
async def fake_both_fail(method, path, body=None):
nonlocal call_count_fail
if path == "/models/defaults":
return 200, {"default_chat_model": "test-model"}
if path == "/search/ask/simple":
call_count_fail += 1
return 502, "Bad Gateway"
return 404, {}
mock_on_request.side_effect = fake_both_fail
with self.assertRaises(Exception) as ctx:
await server.notebook_ask("notebook:a1", "question test")
self.assertEqual(call_count_fail, 2, "Doit s'arrêter après un unique rejeu (2 appels au total)")
self.assertIn("502", str(ctx.exception))
@patch("asyncio.sleep")
@patch("server.on_request")
async def test_rejeu_sur_timeout_reussi(self, mock_on_request, mock_sleep):
"""Vérifie que notebook_ask rejoue après un timeout et réussit si le second appel passe."""
server.CURRENT_IDENTITY.set("test-pilote")
server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote")
call_count = 0
async def fake_timeout_then_ok(method, path, body=None):
nonlocal call_count
if path == "/models/defaults":
return 200, {"default_chat_model": "test-model"}
if path == "/search/ask/simple":
call_count += 1
if call_count == 1:
raise httpx.ReadTimeout("timed out")
return 200, {"answer": "Réponse après timeout résolu", "sources": []}
return 404, {}
mock_on_request.side_effect = fake_timeout_then_ok
rep = await server.notebook_ask("notebook:a1", "question test")
self.assertEqual(rep["answer"], "Réponse après timeout résolu")
self.assertEqual(call_count, 2)
mock_sleep.assert_called_with(2.0)
@patch("server.on_request")
async def test_aucun_rejeu_autres_outils(self, mock_on_request):
"""Vérifie qu'aucun rejeu n'est effectué pour les autres outils (source_add_text, etc.)."""
server.CURRENT_IDENTITY.set("test-pilote")
server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote")
mock_on_request.return_value = (502, "Bad Gateway")
with self.assertRaises(Exception) as ctx:
await server.source_add_text("notebook:a1", "Titre", "Contenu")
self.assertEqual(mock_on_request.call_count, 1)
self.assertIn("502", str(ctx.exception))
if __name__ == "__main__":
unittest.main()