main.py

# app.py
import os
import json
import hashlib
import shutil
import threading
import subprocess
from pathlib import Path
from flask import Flask, request, jsonify
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Tuple, Optional

# -------------------- 配置（按需修改） --------------------
BASEDIR = Path("/hdd/Restoration/Inference/LQ")          # 存放原始待复原图片的根目录：BASEDIR/{image_id}
HQ_BASE = Path("/hdd/Restoration/Inference/LQ")          # 存放高质量参考图：HQ_BASE/{image_id}
CACHE_DIR = Path("/hdd/Restoration/Inference/Cache")      # 缓存中间输出与评分
LOG_DIR = Path("/hdd/Restoration/Inference/log")
LOG_DIR.mkdir(parents=True, exist_ok=True)
CACHE_DIR.mkdir(parents=True, exist_ok=True)

# GPU 配置：按实际机器设置可用 GPU id 列表
GPU_IDS = [0, 1]   # 例如有两块 GPU：0 和 1

# 可选：如果模型脚本名与 env 不完全对应，可在这里指定精确映射，例如:
MODEL_SCRIPT_MAP = {"restormer": "restormer_api.py", "xrestormer": "x_restormer_api.py"}
MODEL_ENV_MAP = {"restormer": "restormer", "xrestormer": "basicsr"}  # env 名称映射
# 指定 score 脚本路径（假设在 PATH 或可通过相对路径调用）
SCORE_SCRIPT = "score.py"  # 使用方式：python score.py --input {img} --hq {hq_img}
# ---------------------------------------------------------

app = Flask(__name__)

# 简单日志函数
def log(msg: str):
    print(msg)
    with open(LOG_DIR / "server.log", "a", encoding="utf-8") as f:
        f.write(msg + "\n")

# ---------------- GPU 资源池 ----------------
class GPUManager:
    def __init__(self, gpu_ids: List[int]):
        self.gpu_ids = gpu_ids
        self.locks = {g: threading.Lock() for g in gpu_ids}
        self.condition = threading.Condition()
        self.in_use = set()  # set of gpu ids currently used

    def acquire(self, blocking=True, timeout=None) -> Optional[int]:
        """
        Acquire an available GPU id. Blocks until one is available (if blocking True).
        Returns gpu_id or None if cannot acquire.
        """
        with self.condition:
            # wait until some GPU is free
            if not blocking:
                for g in self.gpu_ids:
                    if g not in self.in_use:
                        self.in_use.add(g)
                        return g
                return None
            else:
                # blocking: wait until any GPU is free
                while True:
                    for g in self.gpu_ids:
                        if g not in self.in_use:
                            self.in_use.add(g)
                            return g
                    if timeout is not None:
                        # wait with timeout
                        self.condition.wait(timeout=timeout)
                        # after wait, try again and possibly exit if timed out
                        # (loop will repeat until timeout logic in caller)
                    else:
                        self.condition.wait()

    def release(self, gpu_id: int):
        with self.condition:
            if gpu_id in self.in_use:
                self.in_use.remove(gpu_id)
            self.condition.notify_all()

# single GPU manager for the service
gpu_manager = GPUManager(GPU_IDS)

# ---------------- 缓存管理 ----------------
# Cache key design:
# - For intermediate after running models [m1, m2, ..., mi] on image_id:
#   cache_dir = CACHE_DIR / image_id / "{hash_of_prefix_sequence}"
#   store output image as "output.png" (or keep original ext), and metadata.json for score (if computed)
# We'll store mapping info for readability: meta.json contains {"models": [...], "image_id": "..."}
def seq_hash(models: List[str]) -> str:
    hasher = hashlib.sha256()
    hasher.update("||".join(models).encode("utf-8"))
    return hasher.hexdigest()[:16]

def get_cache_path(image_id: str, models_prefix: List[str]) -> Path:
    h = seq_hash(models_prefix)
    return CACHE_DIR / image_id / h

def cache_exists(image_id: str, models_prefix: List[str]) -> bool:
    p = get_cache_path(image_id, models_prefix)
    return (p / "output.png").exists()

def read_cached_score(image_id: str, models_prefix: List[str]) -> Optional[float]:
    p = get_cache_path(image_id, models_prefix) / "meta.json"
    if p.exists():
        try:
            j = json.loads(p.read_text(encoding="utf-8"))
            return j.get("score")
        except Exception:
            return None
    return None

def write_cache(image_id: str, models_prefix: List[str], output_image_path: Path, score: Optional[float]=None, extra_meta: dict=None):
    p = get_cache_path(image_id, models_prefix)
    p.mkdir(parents=True, exist_ok=True)
    # copy image into cache as output.png
    target = p / "output.png"
    if output_image_path != target:
        shutil.copy2(output_image_path, target)
    meta = {"models": models_prefix, "image_id": image_id}
    if score is not None:
        meta["score"] = score
    if extra_meta:
        meta.update(extra_meta)
    (p / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

# per-cache lock to avoid concurrent writes to same key
_cache_locks = {}
_cache_locks_lock = threading.Lock()
def get_cache_lock(image_id: str, prefix_hash: str) -> threading.Lock:
    key = f"{image_id}_{prefix_hash}"
    with _cache_locks_lock:
        if key not in _cache_locks:
            _cache_locks[key] = threading.Lock()
        return _cache_locks[key]

# ----------------- 调用外部模型与评分 -----------------
def model_env_from_model_name(model_name: str) -> str:
    """
    Given 'restormer.derain' -> returns 'restormer' as env name.
    If model name contains dash like 'x-restormer.dehaze', returns 'x-restormer'.
    """
    if "." in model_name:
        return model_name.split(".", 1)[0]
    return model_name

def script_for_repo(repo: str) -> str:
    """
    Return script filename for a given repo. Use MODEL_SCRIPT_MAP override if provided.
    Default: {repo}_api.py
    """
    if repo in MODEL_SCRIPT_MAP:
        return MODEL_SCRIPT_MAP[repo]
    # sanitize repo to be filename-friendly (replace ':' etc if necessary)
    return f"{repo}_api.py"

def env_for_repo(repo: str) -> str:
    """
    Return script filename for a given repo. Use MODEL_ENV_MAP override if provided.
    Default: {repo}_api.py
    """
    if repo in MODEL_ENV_MAP:
        return MODEL_ENV_MAP[repo]
    # sanitize repo to be filename-friendly (replace ':' etc if necessary)
    return repo

def run_model_process(model_fullname: str, input_image: Path, output_image: Path, gpu_id: int, timeout: int=3600) -> Tuple[bool, str]:
    """
    Run the model subprocess with CUDA_VISIBLE_DEVICES set to gpu_id.
    Returns (success, stdout+stderr)
    """
    repo_name = model_env_from_model_name(model_fullname)
    script = script_for_repo(repo_name)
    env_name = env_for_repo(repo_name)
    # Prepare command using conda run -n {env} python {script} ...
    # Example: conda run -n restormer python restormer_api.py --input {input} --output {output} --model restormer.derain
    cmd = ["conda", "run", "-n", env_name, "python", script,
           "--input", str(input_image),
           "--output", str(output_image),
           "--model", model_fullname]

    env = os.environ.copy()
    env["CUDA_VISIBLE_DEVICES"] = str(gpu_id)

    log(f"[MODEL] Running {cmd} with GPU={gpu_id}")
    try:
        proc = subprocess.run(cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout, check=False)
        output = proc.stdout.decode("utf-8", errors="replace")
        success = proc.returncode == 0
        if success:
            log(f"[MODEL] Success: {model_fullname} -> {output_image}")
        else:
            log(f"[MODEL] Failed ({proc.returncode}): {model_fullname}\n{output}")
        return success, output
    except subprocess.TimeoutExpired as e:
        log(f"[MODEL] Timeout running {model_fullname}: {e}")
        return False, f"timeout: {e}"
    except Exception as e:
        log(f"[MODEL] Exception running {model_fullname}: {e}")
        return False, str(e)

def run_score(output_image: Path, hq_image: Path, timeout: int = 300) -> Tuple[bool, Optional[float], str]:
    """
    Call score.py --input {output_image} --hq {hq_image} and parse stdout for numeric score.
    Returns (success, score_or_None, raw_output)
    """
    cmd = ["python", SCORE_SCRIPT, "--input", str(output_image), "--hq", str(hq_image)]
    try:
        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout, check=False)
        out = proc.stdout.decode("utf-8", errors="replace")
        if proc.returncode != 0:
            log(f"[SCORE] score.py failed: {out}")
            return False, None, out
        # parse numeric score: try to find the first number in output
        import re
        m = re.search(r"([-+]?\d*\.\d+|\d+)", out)
        if m:
            score = float(m.group(0))
            return True, score, out
        else:
            return True, None, out
    except subprocess.TimeoutExpired as e:
        log(f"[SCORE] Timeout: {e}")
        return False, None, f"timeout: {e}"
    except Exception as e:
        log(f"[SCORE] Exception: {e}")
        return False, None, str(e)

# ---------------- 执行单个请求的主流程 ----------------
def process_restore_request(image_id: str, models: List[str]) -> dict:
    """
    Run the sequence of models for given image_id, using cache and GPU management.
    Returns a dict with result summary: { "image_id":..., "models":..., "final_cache":..., "score":..., "cached": bool, ... }
    """
    log(f"[REQ] start image_id={image_id} models={models}")

    # validate inputs
    input_image = BASEDIR / image_id
    if not input_image.exists():
        return {"error": f"BASEDIR/{image_id} not found"}

    # prepare HQ image
    hq_image = HQ_BASE / image_id
    if not hq_image.exists():
        log(f"[WARN] HQ reference not found for {image_id} at {hq_image}; scoring will fail if required")
    # Work through sequence step-by-step, using cache for prefixes
    current_input = input_image
    prefix = []
    last_cache_path = None

    for i, model in enumerate(models):
        prefix.append(model)
        # check cache for this prefix
        cache_path = get_cache_path(image_id, prefix)
        cache_output_img = cache_path / "output.png"
        prefix_hash = seq_hash(prefix)
        lock = get_cache_lock(image_id, prefix_hash)

        if cache_output_img.exists():
            log(f"[CACHE HIT] image={image_id} prefix={prefix} -> {cache_output_img}")
            current_input = cache_output_img
            last_cache_path = cache_path
            continue

        # no cache: need to run this model
        with lock:  # ensure only one thread creates this cache entry
            # double-check inside lock after obtaining it
            if cache_output_img.exists():
                log(f"[CACHE HIT after lock] image={image_id} prefix={prefix} -> {cache_output_img}")
                current_input = cache_output_img
                last_cache_path = cache_path
                continue

            # acquire GPU
            gpu_id = gpu_manager.acquire(blocking=True)
            if gpu_id is None:
                # should not happen in blocking=True, but handle defensively
                return {"error": "no GPU available"}

            try:
                # prepare a temporary output path (can be in tmp dir)
                tmp_out_dir = CACHE_DIR / "tmp" / f"{image_id}_{prefix_hash}"
                tmp_out_dir.mkdir(parents=True, exist_ok=True)
                tmp_output = tmp_out_dir / "out.png"

                success, out_log = run_model_process(model, current_input, tmp_output, gpu_id)
                if not success:
                    return {"error": f"model {model} failed", "detail": out_log}

                # after success, move tmp_output into cache location
                cache_path.mkdir(parents=True, exist_ok=True)
                shutil.copy2(tmp_output, cache_output_img)
                # record meta without score (score is only for full sequence)
                meta = {"models": prefix, "image_id": image_id}
                (cache_path / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

                log(f"[CACHE WRITE] wrote {cache_output_img}")
                current_input = cache_output_img
                last_cache_path = cache_path

            finally:
                # release GPU
                gpu_manager.release(gpu_id)

    # At this point, current_input is the image after applying full sequence
    # Check if final score cached
    final_score = None
    cached_score = read_cached_score(image_id, models)
    if cached_score is not None:
        log(f"[SCORE CACHE HIT] image={image_id} models={models} score={cached_score}")
        final_score = cached_score
        result = {
            "image_id": image_id,
            "models": models,
            "cached": True,
            "score": final_score,
            "output_image": str(get_cache_path(image_id, models) / "output.png"),
        }
        return result

    # need to run scoring (requires HQ)
    if not hq_image.exists():
        log(f"[WARN] No HQ for scoring image_id={image_id}")
        # return without score but with output path
        return {
            "image_id": image_id,
            "models": models,
            "cached": False,
            "score": None,
            "output_image": str(current_input),
            "warning": "HQ reference not found; scoring skipped"
        }

    # run scoring (we do not need GPU for scoring usually; if scoring uses GPU modify accordingly)
    success, score_val, raw = run_score(current_input, hq_image)
    if not success:
        # scoring failed; still return output path
        return {
            "image_id": image_id,
            "models": models,
            "cached": False,
            "score": None,
            "output_image": str(current_input),
            "score_error": raw
        }

    final_score = score_val
    # write final score into cache meta
    write_cache(image_id, models, Path(current_input), score=final_score)
    return {
        "image_id": image_id,
        "models": models,
        "cached": False,
        "score": final_score,
        "output_image": str(get_cache_path(image_id, models) / "output.png")
    }

# ---------------- Flask 路由 ----------------
executor = ThreadPoolExecutor(max_workers=8)  # adjust max_workers as needed

@app.route("/restore", methods=["POST"])
def restore():
    j = request.get_json(force=True)
    image_id = j.get("image_id")
    models = j.get("models")
    if not image_id or not models:
        return jsonify({"error": "missing image_id or models"}), 400
    # Validate models type
    if not isinstance(models, list):
        return jsonify({"error": "models must be an array"}), 400

    # Submit to threadpool and wait for result to support concurrent handling
    future = executor.submit(process_restore_request, image_id, models)
    try:
        result = future.result()  # wait until done (the worker thread will block waiting for GPUs if needed)
    except Exception as e:
        log(f"[ERROR] exception processing request: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({"error": "internal error", "detail": str(e)}), 500

    status_code = 200 if "error" not in result else 500
    return jsonify(result), status_code

@app.route("/status", methods=["GET"])
def status():
    return jsonify({
        "gpu_ids": GPU_IDS,
        "in_use": list(gpu_manager.in_use),
        "cache_root": str(CACHE_DIR)
    })

# ----------------- 启动 -----------------
if __name__ == "__main__":
    # for quick testing; for production use gunicorn/uwsgi and set threads/processes accordingly
    app.run(host="0.0.0.0", port=5000, threaded=True)