Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
6.6 KB
Raw Blame
"""Shared pieces for the update tests: stub engine packages, signed archives, a feed folder and a local HTTP server that
supports Range requests and can cut a transfer short. Nothing here touches the network beyond 127.0.0.1."""

from __future__ import annotations

import base64
import hashlib
import json
import os
import re
import sys
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "packaging"))

import feed_tool  # noqa: E402
import package_engine  # noqa: E402
from strata_control import components, signing  # noqa: E402

WINDOWS = os.name == "nt"

GOOD_ENGINE = (
    "import sys, os\nfrom pathlib import Path\n"
    "Path(os.environ['FAKE_ENGINE_MARK']).write_text(os.path.abspath(__file__) + '\\n' + ' '.join(sys.argv[1:]))\n"
    "if '--version' in sys.argv:\n    print('strata-engine stub'); sys.exit(0)\n"
    "print('READY 4096 stop', flush=True)\n"
    "for line in sys.stdin:\n"
    "    if line.strip() == 'QUIT': break\n"
    "    if line.startswith(('GEN ', 'BGEN ')):\n"
    "        slot = int(line.split()[1]) if line.startswith('BGEN ') else None\n"
    "        print('T 97', flush=True)\n"
    "        print('DONE 1 1 1.0 1.0 length 0 0 0', flush=True)\n"
    "        if slot is not None: print(f'BADM {slot} 0', flush=True)\n")
BAD_ENGINE = "import sys\nif '--version' in sys.argv:\n    sys.exit(0)\nsys.exit(3)\n"      # starts, then dies before READY


def make_key() -> dict:
    return signing.generate_key()


def trusted_of(key: dict) -> dict:
    return {key["key_id"]: base64.b64decode(key["public"])}


def build_package(parent: Path, version: str, *, engine_source: str = GOOD_ENGINE, key: dict | None = None,
                  backend: str = "cuda", variant: str = "cuda13", build_id: str | None = None, archs=("sm_86", "compute_89"),
                  min_driver=None, padding: int = 0) -> Path:
    """A schema-2 package made by the real packager (a stub engine behind a manifest-declared entrypoint). `padding` bytes of
    an incompressible 'library' make the archive big enough for a transfer to be cut part-way."""
    src = parent / f"src-{version}-{variant}"
    src.mkdir(parents=True)
    (src / "engine_main.py").write_text(engine_source, encoding="utf-8")
    if WINDOWS:
        entry = "strata.cmd"
        (src / entry).write_bytes(f'@echo off\r\n"{sys.executable}" "%~dp0engine_main.py" %*\r\n'.encode())
        library = "cudart64_13.dll"
    else:
        entry = "strata"
        (src / entry).write_text(f'#!/bin/sh\nexec "{sys.executable}" "$(dirname "$0")/engine_main.py" "$@"\n')
        (src / entry).chmod(0o755)
        library = "libcudart.so.13"
    (src / library).write_bytes(os.urandom(padding) if padding else b"a runtime library the stub never loads " * 50)
    out = parent / "built"
    out.mkdir(exist_ok=True)
    folder = package_engine.build(src, backend, version, components.host_platform(), out, entry=entry, archs=tuple(archs),
                                  min_driver=min_driver or {"nvidia": "580.65"}, build_id=build_id or f"stub-{version}",
                                  variant=variant, include=["engine_main.py"])
    if key is not None:
        feed_tool.sign_package(folder, key)
    return folder


def minisign_pair() -> tuple[str, bytes]:
    """(Tauri-style public key value, 32-byte seed): a TEST minisign key, ED25519 with the BLAKE2b-prehash 'ED' mode."""
    seed = os.urandom(32)
    public = signing.public_from_seed(seed)
    key_id = os.urandom(8)
    text = "untrusted comment: minisign public key: TEST\n" + base64.b64encode(b"Ed" + key_id + public).decode() + "\n"
    return base64.b64encode(text.encode()).decode(), key_id + seed


def minisign_sign(blob: bytes, key_id_and_seed: bytes, comment: str = "timestamp:1") -> str:
    key_id, seed = key_id_and_seed[:8], key_id_and_seed[8:]
    digest = hashlib.blake2b(blob, digest_size=64).digest()
    sig = signing.sign_raw(seed, digest)
    trusted = comment.encode()
    global_sig = signing.sign_raw(seed, sig + trusted)
    text = ("untrusted comment: signature from minisign secret key\n" + base64.b64encode(b"ED" + key_id + sig).decode() + "\n"
            f"trusted comment: {comment}\n" + base64.b64encode(global_sig).decode() + "\n")
    return base64.b64encode(text.encode()).decode()


class FeedServer:
    """Serves `root` on 127.0.0.1 with Range support. `cut` = {path-suffix: bytes}: the first response for that path stops after
    that many bytes (once), closing the connection. `requests` records (method, path, range)."""

    def __init__(self, root: Path):
        self.root = Path(root)
        self.requests: list[tuple[str, str, str | None]] = []
        self.cut: dict[str, int] = {}
        outer = self

        class Handler(BaseHTTPRequestHandler):
            def log_message(self, *args):
                pass

            def do_GET(self):
                rng = self.headers.get("Range")
                outer.requests.append(("GET", self.path, rng))
                target = (outer.root / self.path.lstrip("/")).resolve()
                if outer.root.resolve() not in target.parents or not target.is_file():
                    self.send_error(404)
                    return
                data = target.read_bytes()
                start, status = 0, 200
                if rng:
                    match = re.fullmatch(r"bytes=(\d+)-", rng)
                    if match:
                        start, status = int(match.group(1)), 206
                body = data[start:]
                self.send_response(status)
                self.send_header("Content-Length", str(len(body)))
                if status == 206:
                    self.send_header("Content-Range", f"bytes {start}-{len(data) - 1}/{len(data)}")
                self.end_headers()
                limit = next((n for suffix, n in list(outer.cut.items()) if self.path.endswith(suffix)), None)
                if limit is not None:
                    del outer.cut[next(s for s in outer.cut if self.path.endswith(s))]
                    self.wfile.write(body[:limit])
                    self.wfile.flush()
                    self.connection.close()
                    return
                self.wfile.write(body)

        self.server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)

    @property
    def url(self) -> str:
        return f"http://127.0.0.1:{self.server.server_address[1]}"

    def __enter__(self):
        self.thread.start()
        return self

    def __exit__(self, *exc):
        self.server.shutdown()
        self.server.server_close()
        return False