code/flash/providers/vast/api.py

"""Thin Vast.ai REST client (no SDK state): offer search + instance lifecycle.

Mirrors ``providers/runpod/api.py``: stdlib urllib only, hardened retries, and nothing
persisted locally — a fresh process can list/destroy any instance using only the
persisted ids + VAST_API_KEY. Only ``verified`` DATACENTER offers are searched (the
server-side ``datacenter`` hosting-type filter is applied, since run secrets ship to the
box); callers re-check hosting_type + verification + the reliability floor client-side.
"""

from __future__ import annotations

import time
import urllib.error
import urllib.request
from typing import Any

from flash.providers._http import RestClient

VAST_BASE = "https://console.vast.ai/api"


class VastApiError(RuntimeError):
    pass


# Shared urllib client (path form: callers pass paths joined onto VAST_BASE).
# Env-only by design, like RUNPOD_API_KEY: the operator sets VAST_API_KEY on the
# control-plane host; it is never written to config files or shipped to workers.
_CLIENT = RestClient(
    env_var="VAST_API_KEY",
    error_cls=VastApiError,
    base_url=VAST_BASE,
    missing_key_message=("VAST_API_KEY not configured on the control-plane host"),
)


def _api_key() -> str:
    return _CLIENT.api_key()


def _request(path: str, method: str = "GET", body: dict | None = None, timeout: float = 30.0):
    return _CLIENT.request(path, method=method, body=body, timeout=timeout)


def request_with_retries(
    path: str,
    method: str = "GET",
    body: dict | None = None,
    retries: int = 4,
    base_delay: float = 2.0,
) -> Any:
    """REST call hardened against transient network/5xx blips (jittered backoff)."""
    return _CLIENT.request_with_retries(
        path, method=method, body=body, retries=retries, base_delay=base_delay
    )


# ---------------------------------------------------------------------------
# Offer search
# ---------------------------------------------------------------------------
def search_offers(
    min_vram_mb: int,
    *,
    min_disk_gb: float = 0,
    min_reliability: float = 0.95,
    limit: int = 64,
    extra_q: dict | None = None,
) -> list[dict]:
    """Rentable single-GPU offers from verified DATACENTER hosts, cheapest first.

    ``datacenter`` here is Vast's hosting-type filter (professional datacenters vs
    consumer/hobbyist machines); results additionally carry ``hosting_type`` which
    callers re-check (``usable_offers``) — never trust one filter layer alone.
    """
    # Apply Vast's server-side datacenter-only filter (hosting_type==1). usable_offers now rejects
    # community/marketplace hosts unconditionally (run secrets ship to the box), so a mixed search
    # would risk filling the price-sorted limit=64 page with community offers and reporting "no
    # usable offers" even when verified-datacenter capacity exists just past the page. Filtering
    # server-side keeps the page full of datacenter offers; usable_offers still re-checks
    # hosting_type + verification + the reliability floor (belt and suspenders).
    q: dict[str, Any] = {
        "verified": {"eq": True},
        "datacenter": {"eq": True},
        "rentable": {"eq": True},
        "num_gpus": {"eq": 1},
        "gpu_ram": {"gte": int(min_vram_mb)},
        "reliability2": {"gte": float(min_reliability)},
        "type": "ask",
        "order": [["dph_total", "asc"]],
        "limit": int(limit),
    }
    if min_disk_gb:
        q["disk_space"] = {"gte": float(min_disk_gb)}
    if extra_q:
        q.update(extra_q)
    out = request_with_retries("/v0/search/asks/", method="PUT", body={"q": q})
    offers = out.get("offers") if isinstance(out, dict) else None
    return offers if isinstance(offers, list) else []


# ---------------------------------------------------------------------------
# Instances
# ---------------------------------------------------------------------------
def create_instance(
    offer_id: int,
    *,
    image: str,
    disk_gb: float,
    env: dict[str, str],
    onstart: str,
    label: str,
    runtype: str = "args",
) -> int:
    """Rent an offer -> instance id. Raises VastApiError on rejection (offer taken).

    Default ``args`` runtype (verified live): the script IS the container command
    (``bash -c``), so the job needs no SSH key on the account, the container's
    lifecycle is the job's lifecycle, and the Vast-injected CONTAINER_API_KEY /
    CONTAINER_ID env vars are available for the self-destroy backstop. ``ssh``
    runtype requires an SSH key attached to the Vast account.
    """
    body = {
        "client_id": "me",
        "image": image,
        "disk": float(disk_gb),
        "env": dict(env),
        "label": label,
        "runtype": runtype,
    }
    # The worker image is PUBLIC, so Vast pulls it with no docker-login (no image_login / pull
    # token is ever shipped to the untrusted host).
    if runtype == "args":
        body["args"] = ["bash", "-c", onstart]
    else:
        body["onstart"] = onstart
    # NON-IDEMPOTENT: ``PUT /asks/{id}`` rents a NEW instance every time it succeeds.
    # A blind retry on a timeout where Vast actually accepted the first request would
    # double-provision (two billed instances, one invisible to our handle). So this
    # call is NOT retried — a transient failure surfaces to deploy_and_submit, which
    # walks to the next offer, and to the orchestrator, which consumes a run retry; a
    # duplicate paid instance is the worse failure. (Idempotent calls — search,
    # detail, destroy — keep their retries.)
    out = request_with_retries(f"/v0/asks/{int(offer_id)}/", method="PUT", body=body, retries=0)
    if not isinstance(out, dict) or not out.get("success"):
        raise VastApiError(f"create_instance({offer_id}) rejected: {out}")
    instance_id = out.get("new_contract")
    if not instance_id:
        raise VastApiError(f"create_instance({offer_id}): no instance id in response: {out}")
    return int(instance_id)


def get_instance(instance_id: int) -> dict | None:
    """Instance detail dict, or None once it no longer exists (destroyed).

    The v0 detail route answers 200 with ``{"instances": null}`` for unknown ids
    (verified live) — that is the "gone" signal, not a 404.
    """
    try:
        out = request_with_retries(f"/v0/instances/{int(instance_id)}/")
    except VastApiError as e:
        if "404" in str(e):
            return None
        raise
    if isinstance(out, dict):
        if "instances" in out:
            inst = out["instances"]
            return inst if isinstance(inst, dict) else None
        return out
    return None


def list_instances() -> list[dict]:
    # The v0 list route is deprecated (410 "use /api/v1/instances/", verified live);
    # detail/destroy remain on v0.
    out = request_with_retries("/v1/instances/")
    inst = out.get("instances") if isinstance(out, dict) else None
    return inst if isinstance(inst, list) else []


def instance_logs(instance_id: int, tail: int = 400, wait_s: float = 20.0) -> str | None:
    """Container log tail via the logs API (request -> poll the result URL).

    The only place early-bootstrap failures (pip/env errors before the worker can
    reach HF) are visible. Best-effort: returns None when logs are unavailable
    (e.g. the instance is already destroyed); never raises.
    """
    try:
        out = request_with_retries(
            f"/v0/instances/request_logs/{int(instance_id)}/",
            method="PUT",
            body={"tail": str(int(tail))},
            retries=1,
        )
        url = out.get("result_url") if isinstance(out, dict) else None
        if not url:
            return None
        deadline = time.time() + wait_s
        while time.time() < deadline:
            try:
                with urllib.request.urlopen(url, timeout=15) as resp:
                    body = resp.read().decode(errors="replace")
                if body.strip():
                    return body
            except urllib.error.HTTPError as e:
                if e.code != 404:  # 404 = not materialized yet
                    return None
            time.sleep(2.0)
    except Exception:
        return None
    return None


def destroy_instance(instance_id: int) -> bool:
    """Destroy (and stop billing for) an instance. Best-effort: never raises."""
    try:
        request_with_retries(f"/v0/instances/{int(instance_id)}/", method="DELETE", retries=2)
        return True
    except Exception:
        return False