# sync_app.py —— 改造前，Flask同步版本
import requests
from flask import Flask, jsonify, request

app = Flask(__name__)

USER_SERVICE_URL = "http://user-svc:8001/user"
ORDER_SERVICE_URL = "http://order-svc:8002/count"
RECOMMEND_SERVICE_URL = "http://rec-svc:8003/recommend"

@app.route("/v2/user/profile")
def get_user_profile():
    user_id = request.args.get("user_id")

    # 串行调用三个下游 —— 这是性能瓶颈
    user_resp = requests.get(f"{USER_SERVICE_URL}?id={user_id}", timeout=2)
    user_data = user_resp.json()

    order_resp = requests.get(f"{ORDER_SERVICE_URL}?user_id={user_id}", timeout=2)
    order_data = order_resp.json()

    rec_resp = requests.get(f"{RECOMMEND_SERVICE_URL}?user_id={user_id}", timeout=2)
    rec_data = rec_resp.json()

    return jsonify({
        "user": user_data,
        "order_count": order_data.get("count", 0),
        "recommend": rec_data.get("items", [])
    })

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, workers=4)

# async_app.py —— 改造后，Sanic异步版本
import asyncio
import httpx
from sanic import Sanic, json
from sanic.request import Request

app = Sanic("AsyncProfileAPI")

USER_SERVICE_URL = "http://user-svc:8001/user"
ORDER_SERVICE_URL = "http://order-svc:8002/count"
RECOMMEND_SERVICE_URL = "http://rec-svc:8003/recommend"

# 控制并发数：最多同时10个请求
SEMAPHORE = asyncio.Semaphore(10)

async def fetch_with_timeout(client: httpx.AsyncClient, url: str, params: dict, timeout: float = 2.0):
    """带超时控制的异步请求，超时后返回None"""
    async with SEMAPHORE:  # 限流
        try:
            async with asyncio.timeout(timeout):  # Python 3.12 新语法
                resp = await client.get(url, params=params)
                resp.raise_for_status()
                return resp.json()
        except (httpx.TimeoutException, httpx.HTTPStatusError, asyncio.TimeoutError) as e:
            # 记录日志，但不要抛异常，返回None表示降级
            print(f"Request to {url} failed: {type(e).__name__}")
            return None

@app.get("/v2/user/profile")
async def get_user_profile(request: Request):
    user_id = request.args.get("user_id")
    if not user_id:
        return json({"error": "user_id is required"}, status=400)

    # 复用连接池，减少TCP握手
    async with httpx.AsyncClient(timeout=httpx.Timeout(3.0)) as client:
        # 并发发起三个请求
        results = await asyncio.gather(
            fetch_with_timeout(client, USER_SERVICE_URL, {"id": user_id}),
            fetch_with_timeout(client, ORDER_SERVICE_URL, {"user_id": user_id}),
            fetch_with_timeout(client, RECOMMEND_SERVICE_URL, {"user_id": user_id}),
            return_exceptions=False  # 我们不希望gather自己处理异常，已经在内部处理了
        )

    user_data, order_data, rec_data = results

    # 降级逻辑：如果某个服务挂了，返回默认值
    return json({
        "user": user_data or {"name": "Unknown", "avatar": ""},
        "order_count": order_data.get("count", 0) if order_data else 0,
        "recommend": rec_data.get("items", []) if rec_data else []
    })

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, single_process=True)

results = await asyncio.gather(*tasks, return_exceptions=True)
for r in results:
    if isinstance(r, Exception):
        # 处理异常

@app.before_server_start
async def init_client(app, loop):
    app.ctx.client = httpx.AsyncClient(
        timeout=httpx.Timeout(3.0),
        limits=httpx.Limits(max_connections=50, max_keepalive_connections=20),
        http2=True  # 支持HTTP/2，减少握手延迟
    )