- docs/production.md : seuls compose.yml, compose.reseau.yml et verifier.py vont sur le serveur ; docker compose up -d --no-build ; COMPOSE_FILE dans ~/ollama/.env ; relance par Compose plutôt que docker start ; docker logout après le pull. - verifier.py lisible par Python 3.8/3.9. - Tâches « Instance de test : arrêter » et « Ollama : arrêter ». Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
122 lines
5.0 KiB
Python
122 lines
5.0 KiB
Python
"""L'image Ollama : le script de vérification (contre un faux serveur) et les garde-fous du lancement (design §2, §5)."""
|
|
import ast
|
|
import json
|
|
import socket
|
|
import sys
|
|
import threading
|
|
import unittest
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from pathlib import Path
|
|
|
|
OLLAMA = Path(__file__).resolve().parents[1] / "ollama"
|
|
COMPOSE = OLLAMA / "compose.yml"
|
|
DOCKERFILE = OLLAMA / "Dockerfile"
|
|
sys.path.insert(0, str(OLLAMA))
|
|
from verifier import verifier # noqa: E402
|
|
|
|
|
|
class FauxOllama:
|
|
"""Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings."""
|
|
|
|
def __init__(self, modeles: list[str], dimension: int):
|
|
faux = self
|
|
self.corps_recus: list[dict] = []
|
|
|
|
class Gestion(BaseHTTPRequestHandler):
|
|
def _json(self, data: dict):
|
|
texte = json.dumps(data).encode()
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(texte)))
|
|
self.end_headers()
|
|
self.wfile.write(texte)
|
|
|
|
def do_GET(self):
|
|
self._json({"object": "list", "data": [{"id": m, "object": "model"} for m in modeles]})
|
|
|
|
def do_POST(self):
|
|
n = int(self.headers.get("Content-Length") or 0)
|
|
faux.corps_recus.append(json.loads(self.rfile.read(n)))
|
|
self._json({"object": "list", "data": [{"object": "embedding", "index": 0,
|
|
"embedding": [0.01] * dimension}]})
|
|
|
|
def log_message(self, *_):
|
|
pass
|
|
|
|
self._serveur = ThreadingHTTPServer(("127.0.0.1", 0), Gestion)
|
|
self.url = f"http://127.0.0.1:{self._serveur.server_address[1]}/v1"
|
|
threading.Thread(target=self._serveur.serve_forever, daemon=True).start()
|
|
|
|
def arreter(self):
|
|
self._serveur.shutdown()
|
|
self._serveur.server_close()
|
|
|
|
|
|
class TestVerifier(unittest.TestCase):
|
|
def faux(self, modeles: list[str], dimension: int) -> FauxOllama:
|
|
f = FauxOllama(modeles, dimension)
|
|
self.addCleanup(f.arreter)
|
|
return f
|
|
|
|
def test_modele_et_dimension_ok(self):
|
|
f = self.faux(["bge-m3:567m"], 1024)
|
|
self.assertIn("1024", verifier(f.url))
|
|
self.assertEqual(f.corps_recus[0]["model"], "bge-m3:567m")
|
|
|
|
def test_modele_absent(self):
|
|
f = self.faux(["nomic-embed-text:latest"], 1024)
|
|
with self.assertRaisesRegex(RuntimeError, "bge-m3:567m"):
|
|
verifier(f.url)
|
|
|
|
def test_mauvaise_dimension(self):
|
|
f = self.faux(["bge-m3:567m"], 768)
|
|
with self.assertRaisesRegex(RuntimeError, "768"):
|
|
verifier(f.url)
|
|
|
|
def test_adresse_injoignable(self):
|
|
with socket.socket() as s: # un port libre, que personne n'écoute une fois fermé (refus immédiat)
|
|
s.bind(("127.0.0.1", 0))
|
|
port = s.getsockname()[1]
|
|
with self.assertRaisesRegex(RuntimeError, "injoignable"):
|
|
verifier(f"http://127.0.0.1:{port}/v1")
|
|
|
|
|
|
class TestCompatibilite(unittest.TestCase):
|
|
def test_verifier_lisible_par_un_vieux_python(self): # le Python du serveur est inconnu (3.8, 3.9…)
|
|
texte = (OLLAMA / "verifier.py").read_text()
|
|
arbre = ast.parse(texte)
|
|
futur = any(isinstance(n, ast.ImportFrom) and n.module == "__future__"
|
|
and any(a.name == "annotations" for a in n.names) for n in arbre.body)
|
|
unions = [n for n in ast.walk(arbre) if isinstance(n, (ast.FunctionDef, ast.arg))
|
|
for a in [n.returns if isinstance(n, ast.FunctionDef) else n.annotation]
|
|
if a is not None and any(isinstance(b, ast.BinOp) for b in ast.walk(a))]
|
|
self.assertTrue(futur or not unions, "annotations « X | None » évaluées à la définition : Python ≥ 3.10")
|
|
|
|
|
|
class TestLancement(unittest.TestCase):
|
|
def test_port_lie_a_localhost_par_defaut(self): # Ollama n'a pas d'authentification
|
|
self.assertIn('"${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434"', COMPOSE.read_text())
|
|
self.assertNotIn("0.0.0.0:11434:", COMPOSE.read_text())
|
|
|
|
def test_redemarrage_automatique(self):
|
|
self.assertIn("restart: unless-stopped", COMPOSE.read_text())
|
|
|
|
def test_version_figee(self):
|
|
texte = DOCKERFILE.read_text()
|
|
self.assertRegex(texte, r"FROM ollama/ollama:\d+\.\d+\.\d+\s")
|
|
self.assertNotIn("latest", texte)
|
|
self.assertIn("bge-m3:567m", texte)
|
|
|
|
def test_pas_d_appel_au_nuage(self): # sans ce réglage, Ollama interroge ollama.com au démarrage
|
|
self.assertIn("OLLAMA_NO_CLOUD=1", DOCKERFILE.read_text())
|
|
|
|
def test_bibliotheques_gpu_non_livrees(self): # 4,4 Go de CUDA inutiles : bge-m3 tourne sur processeur
|
|
texte = DOCKERFILE.read_text()
|
|
self.assertIn("COPY --from=", texte)
|
|
for d in ("cuda_v12", "cuda_v13", "mlx_cuda_v13"):
|
|
self.assertIn(f"/usr/lib/ollama/{d}", texte)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|