driverclient 0.2.0__py3-none-any.whl

driverclient/ops/install.py

@@ -0,0 +1,276 @@
+"""
+client/ops/install.py — Resolve then download + install drivers from local repo.
+
+Download pipeline:
+  ALL driver downloads across ALL category levels are submitted to the thread
+  pool simultaneously at t=0.  Installation proceeds level-by-level in
+  dependency order; within each level every driver installs as soon as its
+  own download finishes — no waiting for the slowest download in that level.
+
+  Chipset installs at t=2s while firmware/storage/network are still
+  downloading in parallel.
+
+Public API:
+    resolve_and_install(force=False) -> InstallResult
+"""
+import shutil
+import subprocess
+import time
+import uuid
+from collections import defaultdict
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from driverclient import events
+from driverclient.config import get
+from driverclient.core.http import http_download_retry, http_post_retry
+from driverclient.ops.resolve import ResolveResult, resolve
+
+# Install order: lower number first (hardware dependency)
+_CATEGORY_ORDER: dict[str, int] = {
+    "chipset": 0, "firmware": 1, "storage": 2,
+    "network": 3, "display": 5, "audio": 6, "other": 10,
+}
+
+
+@dataclass
+class DriverResult:
+    binding_id:  str
+    success:     bool
+    error:       str = ""
+    duration_ms: int = 0
+
+
+@dataclass
+class InstallResult:
+    installed_ok:   list[DriverResult] = field(default_factory=list)
+    install_failed: list[DriverResult] = field(default_factory=list)
+    trace_id:       str                = ""
+
+    @property
+    def ok_count(self)   -> int: return len(self.installed_ok)
+    @property
+    def fail_count(self) -> int: return len(self.install_failed)
+
+
+def resolve_and_install(force: bool = False) -> InstallResult:
+    """
+    Run resolve (or load cache) then download + install all available drivers.
+    Returns InstallResult.
+    """
+    cfg    = get()
+    result = resolve(force=force)
+
+    if not result.has_drivers:
+        events.done("install", "[install] Nothing to install — all drivers up to date",
+                    total=0)
+        return InstallResult(trace_id=result.trace_id)
+
+    session_id = str(uuid.uuid4())
+    work_dir   = Path(cfg.get("work_dir", "C:\\DriverServer\\client\\staging")) / session_id
+    work_dir.mkdir(parents=True, exist_ok=True)
+
+    events.start("install",
+                 f"[install] {len(result.drivers)} driver(s) — starting parallel downloads…",
+                 total=len(result.drivers))
+    all_results = _stream_install(result.drivers, work_dir, cfg)
+
+    shutil.rmtree(work_dir, ignore_errors=True)
+
+    installed_ok   = [r for r in all_results if r.success]
+    install_failed = [r for r in all_results if not r.success]
+
+    _confirm(result.trace_id, installed_ok, install_failed, cfg)
+
+    events.done("install",
+                f"[install] Done — {len(installed_ok)} ok  {len(install_failed)} failed",
+                total=len(all_results), ok=len(installed_ok), failed=len(install_failed))
+    for r in install_failed:
+        events.error("install", f"  ✗ {r.binding_id}: {r.error}",
+                     binding_id=r.binding_id, error=r.error)
+
+    return InstallResult(
+        installed_ok=installed_ok,
+        install_failed=install_failed,
+        trace_id=result.trace_id,
+    )
+
+
+# ── Streaming pipeline ──────────────────────────────────────────────────────────
+
+def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverResult]:
+    """
+    Submit ALL downloads (all levels) simultaneously, then install level-by-level.
+    Each driver installs the moment its own download Future completes.
+    """
+    repo_url = cfg["local_repo_url"]
+    parallel = cfg.get("parallel_downloads", 6)
+
+    by_level                 = _dedup_and_group(drivers)
+    executor                 = ThreadPoolExecutor(max_workers=parallel)
+    future_info, level_futs  = _submit_all_downloads(by_level, base, repo_url, cfg, executor)
+
+    all_results: list[DriverResult] = []
+    for level in sorted(by_level):
+        events.progress("install",
+                        f"[install] {_level_label(level)} ({len(level_futs[level])} driver(s))…",
+                        category=_level_label(level), count=len(level_futs[level]))
+        for fut in as_completed(level_futs[level]):
+            all_results.append(_process_completed(fut, future_info, cfg))
+
+    executor.shutdown(wait=False)
+    return all_results
+
+
+def _dedup_and_group(drivers: list[dict]) -> dict[int, list[dict]]:
+    """Deduplicate by binding_id, then bucket by category level."""
+    seen: set[str] = set()
+    by_level: dict[int, list[dict]] = defaultdict(list)
+    for d in drivers:
+        bid = d.get("binding_id") or d.get("package_id", "")
+        if bid and bid not in seen:
+            seen.add(bid)
+            level = _CATEGORY_ORDER.get(d.get("category", "other"), 10)
+            by_level[level].append(d)
+    return by_level
+
+
+def _submit_all_downloads(
+    by_level: dict[int, list[dict]],
+    base: Path,
+    repo_url: str,
+    cfg: dict,
+    executor: ThreadPoolExecutor,
+) -> tuple[dict[Future, tuple[int, dict]], dict[int, list[Future]]]:
+    """Submit every driver download to the pool at once. Returns lookup maps."""
+    future_info:  dict[Future, tuple[int, dict]] = {}
+    level_futs:   dict[int, list[Future]]        = defaultdict(list)
+    for level in sorted(by_level):
+        for driver in by_level[level]:
+            fut = executor.submit(_download_driver, driver, base, repo_url, cfg)
+            future_info[fut] = (level, driver)
+            level_futs[level].append(fut)
+    return future_info, level_futs
+
+
+def _process_completed(
+    fut: Future,
+    future_info: dict[Future, tuple[int, dict]],
+    cfg: dict,
+) -> DriverResult:
+    """Handle one completed download Future: install if ok, return DriverResult."""
+    _, driver = future_info[fut]
+    bid = driver.get("binding_id", "")
+    cat = driver.get("category", "other")
+
+    try:
+        dest, dl_ok = fut.result()
+    except Exception as e:
+        return DriverResult(binding_id=bid, success=False, error=str(e))
+
+    if not dl_ok:
+        return DriverResult(binding_id=bid, success=False, error="download_failed")
+
+    t0 = time.monotonic()
+    ok, err = _install_driver(driver, dest, cfg)
+    dur = int((time.monotonic() - t0) * 1000)
+    line = f"  {'✓' if ok else '✗'} [{cat}] {bid}  ({dur}ms)"
+    emit = events.ok if ok else events.error
+    emit("install", line, binding_id=bid, category=cat, duration_ms=dur, error=err)
+    return DriverResult(binding_id=bid, success=ok, error=err, duration_ms=dur)
+
+
+def _download_driver(driver: dict, base: Path, repo_url: str,
+                     cfg: dict) -> tuple[Path, bool]:
+    """Download all files for one driver. Returns (dest_dir, success)."""
+    bid    = driver.get("binding_id") or driver.get("package_id", "")
+    pkg_id = driver["package_id"]
+    dest   = base / bid
+    dest.mkdir(parents=True, exist_ok=True)
+
+    ok = True
+    for f in driver.get("files", []):
+        url  = f"{repo_url}/files/{pkg_id}/{f['filename']}"
+        path = dest / f["filename"]
+        if not http_download_retry(url, path, f["sha256"],
+                                   timeout=cfg["timeout_long"]):
+            ok = False
+
+    return dest, ok
+
+
+def _level_label(level: int) -> str:
+    labels = {0: "chipset", 1: "firmware", 2: "storage",
+              3: "network", 5: "display", 6: "audio", 10: "other"}
+    return labels.get(level, f"level-{level}")
+
+
+# ── Driver installation ─────────────────────────────────────────────────────────
+
+def _install_driver(driver: dict, driver_dir: Path, cfg: dict) -> tuple[bool, str]:
+    install_type = driver.get("install_type", "inf_silent")
+
+    try:
+        if install_type == "inf_silent":
+            inf_files = list(driver_dir.glob("*.inf"))
+            if not inf_files:
+                return False, "No INF file found"
+            r = subprocess.run(
+                ["pnputil", "/add-driver", str(inf_files[0]), "/install", "/subdirs"],
+                capture_output=True, text=True,
+                timeout=cfg["timeout_long"],
+            )
+            return r.returncode == 0, r.stdout[:200] if r.returncode != 0 else ""
+
+        if install_type == "exe_silent":
+            exe_files = list(driver_dir.glob("*.exe"))
+            if not exe_files:
+                return False, "No EXE file found"
+            flags = driver.get("install_flags", "/S")
+            r = subprocess.run(
+                [str(exe_files[0])] + flags.split(),
+                capture_output=True,
+                timeout=cfg["timeout_install"],
+            )
+            return r.returncode == 0, ""
+
+        if install_type == "firmware_flash":
+            inf_files = list(driver_dir.glob("*.inf"))
+            if not inf_files:
+                return False, "No firmware INF"
+            r = subprocess.run(
+                ["pnputil", "/add-driver", str(inf_files[0]), "/install"],
+                capture_output=True, text=True,
+                timeout=cfg["timeout_long"],
+            )
+            return r.returncode == 0, ""
+
+    except subprocess.TimeoutExpired:
+        return False, "Install timed out"
+    except Exception as e:
+        return False, str(e)
+
+    return False, f"Unknown install_type: {install_type}"
+
+
+# ── Confirm ─────────────────────────────────────────────────────────────────────
+
+def _confirm(trace_id: str, ok: list[DriverResult], fail: list[DriverResult],
+             cfg: dict) -> None:
+    try:
+        results = (
+            [{"binding_id": r.binding_id, "success": True} for r in ok]
+            + [{"binding_id": r.binding_id, "success": False,
+                "error": getattr(r, "error", None)} for r in fail]
+        )
+        http_post_retry(
+            f"{cfg['local_repo_url']}/submit/confirm/{trace_id}",
+            {
+                "machine_id": cfg.get("machine_id", ""),
+                "results": results,
+            },
+            timeout=cfg["timeout_short"],
+        )
+    except Exception:
+        pass

driverclient/ops/resolve.py

@@ -0,0 +1,147 @@
+"""
+client/ops/resolve.py — Scan hardware then query local repo.
+
+Identifies which drivers are available in the repo (ready to install)
+and which HWIDs the repo has no package for (not_found).
+
+Results saved to ds_resolve.json so install / capture ops can consume
+them without re-running this step.
+
+Public API:
+    resolve(force=False) -> ResolveResult
+"""
+import json
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from driverclient import events
+from driverclient.config import get
+from driverclient.core.http import http_post_retry
+from driverclient.ops.scan import ScanResult, scan
+
+
+@dataclass
+class ResolveResult:
+    drivers:    list[dict]  = field(default_factory=list)
+    not_found:  list[str]   = field(default_factory=list)
+    trace_id:   str         = ""
+    machine_id: str         = ""
+    timestamp:  str         = ""
+
+    @property
+    def has_drivers(self) -> bool:
+        return bool(self.drivers)
+
+    @property
+    def has_missing(self) -> bool:
+        return bool(self.not_found)
+
+
+def resolve(force: bool = False) -> ResolveResult:
+    """
+    Load (or run) a hardware scan, then POST to /resolve.
+    Returns ResolveResult with drivers[] and not_found[].
+    Saves result to ds_resolve.json.
+    """
+    cfg = get()
+
+    if not force:
+        cached = _load_cache(cfg)
+        if cached:
+            _print_summary(cached)
+            return cached
+
+    scan_result: ScanResult = scan(force=force)
+    return _query_repo(scan_result, cfg, force)
+
+
+def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResult:
+    repo_url   = cfg["local_repo_url"]
+    session_id = str(uuid.uuid4())
+
+    payload = {
+        "machine_id":         scan_result.machine_id,
+        "session_id":         session_id,
+        "vendor":             scan_result.vendor,
+        "model":              scan_result.model,
+        "os_build":           scan_result.os_build,
+        "arch":               scan_result.arch,
+        "firmware_version":   scan_result.firmware_version,
+        "hwids":              scan_result.all_hwids,
+        "installed_versions": scan_result.installed_versions,
+        "force":              force or cfg.get("force_resolve", False),
+    }
+
+    events.start("resolve", f"[resolve] Querying {repo_url}/resolve …",
+                 total=len(scan_result.all_hwids))
+    t0 = time.monotonic()
+
+    resp    = http_post_retry(f"{repo_url}/resolve", payload,
+                              timeout=cfg["timeout_medium"])
+    elapsed = int((time.monotonic() - t0) * 1000)
+
+    result = ResolveResult(
+        drivers=resp.get("drivers", []),
+        not_found=resp.get("not_found", []),
+        trace_id=resp.get("trace_id", ""),
+        machine_id=scan_result.machine_id,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    total_hwids     = resp.get("total_hwids", len(scan_result.all_hwids))
+    already_current = resp.get("already_current", 0)
+
+    events.done(
+        "resolve",
+        f"[resolve] HWIDs: {total_hwids}  |  "
+        f"Already current: {already_current}  |  "
+        f"To install: {len(result.drivers)}  |  "
+        f"Not found: {len(result.not_found)}  ({elapsed}ms)",
+        total=total_hwids, already_current=already_current,
+        to_install=len(result.drivers), not_found=len(result.not_found),
+        elapsed_ms=elapsed,
+    )
+
+    _save_cache(result, cfg)
+    return result
+
+
+# ── Cache ──────────────────────────────────────────────────────────────────────
+
+def _cache_path(cfg: dict) -> Path:
+    return Path(cfg.get("cache_dir", "C:\\ProgramData\\DriverServer")) / "ds_resolve.json"
+
+
+def _load_cache(cfg: dict) -> ResolveResult | None:
+    path = _cache_path(cfg)
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        ts   = datetime.fromisoformat(data.get("timestamp", "2000-01-01T00:00:00+00:00"))
+        ttl  = cfg.get("cache_ttl_minutes", 15)
+        if datetime.now(timezone.utc) - ts > timedelta(minutes=ttl):
+            return None
+        return ResolveResult(**data)
+    except Exception:
+        return None
+
+
+def _save_cache(result: ResolveResult, cfg: dict) -> None:
+    path = _cache_path(cfg)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(asdict(result), indent=2))
+    except Exception:
+        pass
+
+
+def _print_summary(r: ResolveResult) -> None:
+    events.done(
+        "resolve",
+        f"[resolve] (cached)  To install: {len(r.drivers)}  |  Not found: {len(r.not_found)}",
+        to_install=len(r.drivers), not_found=len(r.not_found), cached=True,
+    )