API fully functional

Api docs (SWAGGER, REDOC) available

services/docs/main.py

@@ -0,0 +1,127 @@
+import asyncio
+import logging
+from typing import Dict, Optional
+
+import httpx
+from fastapi import FastAPI
+from fastapi.openapi.utils import get_openapi
+from fastapi.responses import JSONResponse, RedirectResponse
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger("docs")
+
+app = FastAPI(title="Unified Marriage API Docs", version="1.0.0")
+
+# Переопределяем OpenAPI, чтобы /docs использовал объединённую схему
+def custom_openapi():
+    global _cached_openapi
+    import asyncio
+    if _cached_openapi is None or len((_cached_openapi.get("paths") or {})) == 0:
+        _cached_openapi = asyncio.run(build_cache())
+    return _cached_openapi
+
+app.openapi = custom_openapi
+
+# Используем ИМЕНА КОНТЕЙНЕРОВ и внутренний порт 8000
+MICROSERVICES: Dict[str, str] = {
+    "auth":     "http://marriage_auth:8000/openapi.json",
+    "profiles": "http://marriage_profiles:8000/openapi.json",
+    "match":    "http://marriage_match:8000/openapi.json",
+    "chat":     "http://marriage_chat:8000/openapi.json",
+    "payments": "http://marriage_payments:8000/openapi.json",
+}
+
+_cached_openapi: Optional[dict] = None
+
+async def fetch_spec(client: httpx.AsyncClient, name: str, url: str, retries: int = 6, delay: float = 2.0) -> Optional[dict]:
+    for attempt in range(1, retries + 1):
+        try:
+            r = await client.get(url)
+            r.raise_for_status()
+            spec = r.json()
+            log.info("Loaded OpenAPI from %s: %s paths", name, len((spec or {}).get("paths", {}) or {}))
+            return spec
+        except Exception as e:
+            log.warning("Attempt %s/%s failed for %s: %s", attempt, retries, name, e)
+            await asyncio.sleep(delay)
+    log.error("Could not load OpenAPI from %s after %s attempts", name, retries)
+    return None
+
+def merge_specs(specs_by_name: Dict[str, Optional[dict]]) -> dict:
+    merged_paths: Dict[str, dict] = {}
+    merged_components = {"schemas": {}}
+
+    for name, spec in specs_by_name.items():
+        if not spec:
+            continue
+        for path, methods in (spec.get("paths") or {}).items():
+            merged_paths[f"/{name}{path}"] = methods
+        merged_components["schemas"].update((spec.get("components") or {}).get("schemas", {}) or {})
+
+    openapi_schema = get_openapi(
+        title="Unified Marriage API",
+        version="1.0.0",
+        description="Combined OpenAPI schema for all microservices",
+        routes=[],
+    )
+    openapi_schema["servers"] = [{"url": "http://localhost:8080"}]
+    openapi_schema["paths"] = merged_paths
+    openapi_schema["components"] = merged_components
+    return openapi_schema
+
+async def build_cache() -> dict:
+    async with httpx.AsyncClient(timeout=5.0) as client:
+        tasks = [fetch_spec(client, name, url) for name, url in MICROSERVICES.items()]
+        specs = await asyncio.gather(*tasks)
+
+    specs_by_name = dict(zip(MICROSERVICES.keys(), specs))
+    merged = merge_specs(specs_by_name)
+    log.info("Unified OpenAPI built: %s paths", len(merged.get("paths", {})))
+    return merged
+
+async def ensure_cache() -> dict:
+    """Гарантируем, что кэш непустой: если paths == 0 — пересобираем."""
+    global _cached_openapi
+    if _cached_openapi is None or len((_cached_openapi.get("paths") or {})) == 0:
+        _cached_openapi = await build_cache()
+    return _cached_openapi
+
+@app.on_event("startup")
+async def _warmup_cache():
+    """Always rebuild cache on startup so Swagger has full data."""
+    global _cached_openapi
+    try:
+        _cached_openapi = await build_cache()
+        log.info("[startup] Cache built: %s paths", len((_cached_openapi.get("paths") or {})))
+    except Exception as e:
+        log.error("[startup] Failed to build cache: %s", e)
+@app.get("/", include_in_schema=False)
+def root():
+    return RedirectResponse(url="/docs")
+
+@app.get("/_health", include_in_schema=False)
+def health():
+    return {"status": "ok", "cached_paths": len((_cached_openapi or {}).get("paths", {}))}
+
+@app.get("/debug", include_in_schema=False)
+async def debug():
+    out = {}
+    async with httpx.AsyncClient(timeout=5.0) as client:
+        for name, url in MICROSERVICES.items():
+            try:
+                r = await client.get(url)
+                out[name] = {"status": r.status_code, "len": len(r.text), "starts_with": r.text[:80]}
+            except Exception as e:
+                out[name] = {"error": str(e)}
+    return out
+
+@app.get("/refresh", include_in_schema=False)
+async def refresh():
+    global _cached_openapi
+    _cached_openapi = await build_cache()
+    return {"refreshed": True, "paths": len(_cached_openapi.get("paths", {}))}
+
+@app.get("/openapi.json", include_in_schema=False)
+async def unified_openapi():
+    data = await ensure_cache()
+    return JSONResponse(data)