Auto-install the DLSS toolchain on Windows + NVIDIA RTX
`airdef.py game` no longer needs manual SDK setup. On Windows with an RTX adapter, when neither DLSS_SDK nor VULKAN_SDK is set, it downloads only the files dlss_wgpu reads: - NVIDIA/DLSS at the newest stable v310.9.x tag (GitHub API; pinned v310.9.1 when the API fails): include/*.h, both x64 static libs and the runtime rel/nvngx_dlss.dll (~67 MB once), laid out under .horizon-cache/dlss-sdk/<tag>/ exactly as valid_dlss_sdk expects. - KhronosGroup/Vulkan-Headers include/ under .horizon-cache/vulkan-headers/<tag>/Include/, since build.rs uses headers only and links no Vulkan library. The resolved roots are passed to cargo as DLSS_SDK/VULKAN_SDK, and after a successful dlss build the fresh nvngx_dlss.dll is copied beside the built horizon-client.exe. Explicit DLSS_SDK/VULKAN_SDK (and the sdk argument) keep priority and disable auto-download for that component. Any network or layout failure warns and falls back to --features mods/native TAAU instead of failing the build; non-Windows and non-RTX take the old mods path with no network access. valid_dlss_sdk now looks for the real nvsdk_ngx*.h names instead of the nonexistent nvngx*.h glob, so a genuine SDK (and the downloaded cache) is recognised at all. Tests cover tag selection and fallback, selective layout + marker cache hit, damaged/partial caches, streamed download and truncation, Vulkan Include layout, plan env wiring, explicit-env precedence, failure to mods, and DLL placement beside the client. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
+330
-29
@@ -2,7 +2,7 @@
|
||||
"""AirDef: сборка, установка и запуск на Windows, macOS и Linux. Только стандартная библиотека Python.
|
||||
|
||||
python3 tools/airdef.py fork # инициализировать закреплённый сабмодуль Horizon (horizon/)
|
||||
python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX с DLSS SDK добавляет feature dlss
|
||||
python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX сам скачивает DLSS SDK
|
||||
python3 tools/airdef.py mod # собрать мод airdef.hmod — нужен Rust с wasm32
|
||||
python3 tools/airdef.py install # положить мод в папку игры и включить
|
||||
python3 tools/airdef.py play [аргументы игры] # запустить форк на папке игры
|
||||
@@ -12,8 +12,10 @@
|
||||
python3 tools/airdef.py test-budgets # тяжёлый WASM budget сценарий + JSON provenance
|
||||
|
||||
Переменные окружения: HORIZON_HOME (папка игры), HORIZON_RESOURCES (подготовленные ресурсы
|
||||
Minecraft 26.3), AIRDEF_GAME (готовый horizon-client вместо собранного), DLSS_SDK и VULKAN_SDK
|
||||
(сборка game с feature dlss на Windows + NVIDIA RTX).
|
||||
Minecraft 26.3), AIRDEF_GAME (готовый horizon-client вместо собранного).
|
||||
На Windows + NVIDIA RTX сборка с DLSS (feature dlss) сама скачивает DLSS SDK и заголовки Vulkan
|
||||
в .horizon-cache/ и кладёт nvngx_dlss.dll рядом с horizon-client.exe. Явные DLSS_SDK и VULKAN_SDK
|
||||
по-прежнему имеют приоритет над автоскачиванием; при сбое сети собирается обычный mods/TAAU.
|
||||
"""
|
||||
import glob
|
||||
import hashlib
|
||||
@@ -25,6 +27,7 @@ import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import urllib.request
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
|
||||
@@ -102,8 +105,231 @@ def fork():
|
||||
sys.exit(f"horizon/: ожидался {expected}, получен {current}")
|
||||
|
||||
|
||||
DLSS_SDK_URL = "https://github.com/NVIDIA/DLSS/tree/v310.9.1"
|
||||
DLSS_SDK_URL = "https://github.com/NVIDIA/DLSS"
|
||||
DLSS_TAGS_API = "https://api.github.com/repos/NVIDIA/DLSS/tags?per_page=30"
|
||||
DLSS_RAW = "https://raw.githubusercontent.com/NVIDIA/DLSS/{tag}/{path}"
|
||||
DLSS_TAG_PINNED = "v310.9.1"
|
||||
# Автоскачивание берёт только стабильные v310.9.x; закреплённая версия — резерв при сбое API.
|
||||
DLSS_TAG = re.compile(r"^v310\.9\.(\d+)$")
|
||||
DLSS_INCLUDE_FALLBACK = (
|
||||
"nvsdk_ngx.h", "nvsdk_ngx_defs.h", "nvsdk_ngx_defs_dlssd.h", "nvsdk_ngx_defs_dlssg.h",
|
||||
"nvsdk_ngx_defs_vk.h", "nvsdk_ngx_helpers.h", "nvsdk_ngx_helpers_cuda.h",
|
||||
"nvsdk_ngx_helpers_d3d.h", "nvsdk_ngx_helpers_dlssd.h", "nvsdk_ngx_helpers_dlssd_cuda.h",
|
||||
"nvsdk_ngx_helpers_dlssd_d3d.h", "nvsdk_ngx_helpers_dlssd_vk.h", "nvsdk_ngx_helpers_dlssg.h",
|
||||
"nvsdk_ngx_helpers_dlssg_d3d.h", "nvsdk_ngx_helpers_dlssg_vk.h", "nvsdk_ngx_helpers_vk.h",
|
||||
"nvsdk_ngx_loader.h", "nvsdk_ngx_params.h", "nvsdk_ngx_params_dlssd.h",
|
||||
"nvsdk_ngx_params_dlssg.h", "nvsdk_ngx_standalone_common.h", "nvsdk_ngx_standalone_cuda.h",
|
||||
"nvsdk_ngx_vk.h",
|
||||
)
|
||||
# dlss_wgpu линкует static-библиотеку (nvsdk_ngx_d, либо nvsdk_ngx_s при crt-static).
|
||||
DLSS_LIBS = ("lib/Windows_x86_64/x64/nvsdk_ngx_d.lib", "lib/Windows_x86_64/x64/nvsdk_ngx_s.lib")
|
||||
DLSS_RUNTIME = "lib/Windows_x86_64/rel/nvngx_dlss.dll"
|
||||
|
||||
VULKAN_SDK_URL = "https://vulkan.lunarg.com/sdk/home"
|
||||
VULKAN_TAG_PINNED = "vulkan-sdk-1.4.363.0"
|
||||
VULKAN_RAW = "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/{tag}/include/{path}"
|
||||
# build.rs использует только заголовки ({VULKAN_SDK}/Include), полный LunarG SDK не нужен.
|
||||
VULKAN_HEADERS = (
|
||||
"vulkan/vulkan.h", "vulkan/vulkan_core.h", "vulkan/vk_platform.h",
|
||||
"vk_video/vulkan_video_codec_av1std.h", "vk_video/vulkan_video_codec_av1std_decode.h",
|
||||
"vk_video/vulkan_video_codec_av1std_encode.h", "vk_video/vulkan_video_codec_h264std.h",
|
||||
"vk_video/vulkan_video_codec_h264std_decode.h", "vk_video/vulkan_video_codec_h264std_encode.h",
|
||||
"vk_video/vulkan_video_codec_h265std.h", "vk_video/vulkan_video_codec_h265std_decode.h",
|
||||
"vk_video/vulkan_video_codec_h265std_encode.h", "vk_video/vulkan_video_codec_vp9std.h",
|
||||
"vk_video/vulkan_video_codec_vp9std_decode.h", "vk_video/vulkan_video_codecs_common.h",
|
||||
)
|
||||
|
||||
CACHE = ROOT / ".horizon-cache"
|
||||
DLSS_CACHE = CACHE / "dlss-sdk"
|
||||
VULKAN_CACHE = CACHE / "vulkan-headers"
|
||||
INSTALL_MARKER = "airdef-install.json"
|
||||
|
||||
|
||||
class DownloadError(RuntimeError):
|
||||
"""Сеть или неполный файл при автоскачивании; вызывающий код откатывается на mods."""
|
||||
|
||||
|
||||
def open_url(url):
|
||||
request = urllib.request.Request(url, headers={"User-Agent": "airdef-dlss-autoinstall"})
|
||||
return urllib.request.urlopen(request, timeout=120)
|
||||
|
||||
|
||||
def github_json(url):
|
||||
with open_url(url) as response:
|
||||
return json.load(response)
|
||||
|
||||
|
||||
def download(url, dest):
|
||||
"""Один файл потоком во временный .part и атомарная замена; прогресс для больших файлов."""
|
||||
dest = Path(dest)
|
||||
dest.parent.mkdir(parents=True, exist_ok=True)
|
||||
part = dest.with_name(dest.name + ".part")
|
||||
try:
|
||||
try:
|
||||
response = open_url(url)
|
||||
except Exception as exc:
|
||||
raise DownloadError(f"{url}: {exc}") from exc
|
||||
with response, open(part, "wb") as out:
|
||||
total = int(response.headers.get("Content-Length") or 0)
|
||||
big = total >= 8_000_000
|
||||
if big:
|
||||
print(f" {dest.name}: {total / 1e6:.1f} МБ", flush=True)
|
||||
done, step = 0, 0
|
||||
while True:
|
||||
chunk = response.read(1 << 20)
|
||||
if not chunk:
|
||||
break
|
||||
out.write(chunk)
|
||||
done += len(chunk)
|
||||
if big and done * 10 // total > step:
|
||||
step = done * 10 // total
|
||||
print(f" {dest.name}: {min(step * 10, 100)}%", flush=True)
|
||||
if total and done < total:
|
||||
raise DownloadError(f"{url}: получено {done} из {total} байт")
|
||||
os.replace(part, dest)
|
||||
finally:
|
||||
if part.exists():
|
||||
part.unlink()
|
||||
|
||||
|
||||
def dlss_latest_tag():
|
||||
"""Новейший стабильный тег v310.9.x с GitHub; при сбое API — закреплённый v310.9.1."""
|
||||
try:
|
||||
tags = github_json(DLSS_TAGS_API)
|
||||
except Exception as exc:
|
||||
print(f"Внимание: не удалось получить теги DLSS ({exc}); беру {DLSS_TAG_PINNED}.", flush=True)
|
||||
return DLSS_TAG_PINNED
|
||||
versions = []
|
||||
for entry in tags if isinstance(tags, list) else []:
|
||||
name = entry.get("name", "") if isinstance(entry, dict) else ""
|
||||
match = DLSS_TAG.match(name)
|
||||
if match:
|
||||
versions.append((int(match.group(1)), name))
|
||||
if not versions:
|
||||
print(f"Внимание: среди тегов DLSS нет v310.9.x; беру {DLSS_TAG_PINNED}.", flush=True)
|
||||
return DLSS_TAG_PINNED
|
||||
return max(versions)[1]
|
||||
|
||||
|
||||
def dlss_include_files(tag):
|
||||
"""Список include/*.h тега из API; при сбое — закреплённый набор v310.9.x."""
|
||||
try:
|
||||
entries = github_json(f"https://api.github.com/repos/NVIDIA/DLSS/contents/include?ref={tag}")
|
||||
names = [entry["name"] for entry in entries if isinstance(entry, dict)
|
||||
and str(entry.get("name", "")).endswith(".h")]
|
||||
if names:
|
||||
return names
|
||||
except Exception:
|
||||
pass
|
||||
return list(DLSS_INCLUDE_FALLBACK)
|
||||
|
||||
|
||||
def read_marker(path):
|
||||
"""Манифест установки в кэше (версия, размер DLL); None, если его нет или он битый."""
|
||||
try:
|
||||
return json.loads((Path(path) / INSTALL_MARKER).read_text(encoding="utf-8"))
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def dlss_sdk_complete(path) -> bool:
|
||||
"""Полный набор для сборки: include, обе static .lib и runtime DLL."""
|
||||
path = Path(path)
|
||||
return valid_dlss_sdk(path) and all((path / rel).is_file() for rel in DLSS_LIBS + (DLSS_RUNTIME,))
|
||||
|
||||
|
||||
def dlss_tag_key(name):
|
||||
match = DLSS_TAG.match(name)
|
||||
return int(match.group(1)) if match else -1
|
||||
|
||||
|
||||
def cached_dlss_sdk():
|
||||
"""Самый новый полностью скачанный SDK в кэше или None."""
|
||||
if not DLSS_CACHE.is_dir():
|
||||
return None
|
||||
for path in sorted(DLSS_CACHE.iterdir(), key=lambda p: dlss_tag_key(p.name), reverse=True):
|
||||
state = read_marker(path)
|
||||
if state and state.get("tag") == path.name and dlss_sdk_complete(path):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
def install_dlss_sdk(tag=None):
|
||||
"""Скачивает только нужные файлы NVIDIA/DLSS в .horizon-cache/dlss-sdk/<tag>.
|
||||
|
||||
Раскладка ровно та, которую ожидает dlss_wgpu: include/nvsdk_ngx*.h и lib/Windows_x86_64/{x64,rel}.
|
||||
"""
|
||||
tag = tag or dlss_latest_tag()
|
||||
dest = DLSS_CACHE / tag
|
||||
state = read_marker(dest)
|
||||
if state and state.get("tag") == tag and dlss_sdk_complete(dest):
|
||||
print(f"DLSS SDK {tag}: уже в кэше {dest}", flush=True)
|
||||
return dest
|
||||
print(f"DLSS SDK {tag}: скачиваю заголовки, .lib и nvngx_dlss.dll (~67 МБ) с {DLSS_SDK_URL}", flush=True)
|
||||
staging = DLSS_CACHE / f".{tag}.part"
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
try:
|
||||
for name in dlss_include_files(tag):
|
||||
download(DLSS_RAW.format(tag=tag, path=f"include/{name}"), staging / "include" / name)
|
||||
for rel in DLSS_LIBS + (DLSS_RUNTIME,):
|
||||
download(DLSS_RAW.format(tag=tag, path=rel), staging / rel)
|
||||
if not dlss_sdk_complete(staging):
|
||||
raise DownloadError(f"DLSS SDK {tag}: после скачивания нет полного набора include/ и lib/Windows_x86_64")
|
||||
(staging / INSTALL_MARKER).write_text(json.dumps({
|
||||
"tag": tag, "source": DLSS_SDK_URL,
|
||||
"dll_bytes": (staging / DLSS_RUNTIME).stat().st_size}, indent=2) + "\n", encoding="utf-8")
|
||||
shutil.rmtree(dest, ignore_errors=True)
|
||||
staging.rename(dest)
|
||||
except Exception:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
raise
|
||||
print(f"DLSS SDK {tag}: готов, {dest}", flush=True)
|
||||
return dest
|
||||
|
||||
|
||||
def vulkan_headers_ok(path) -> bool:
|
||||
"""dlss_wgpu ищет Include/vulkan/vulkan.h (Windows) или include/vulkan/vulkan.h."""
|
||||
if not path:
|
||||
return False
|
||||
path = Path(path)
|
||||
return any((path / part).is_file() for part in
|
||||
("Include/vulkan/vulkan.h", "include/vulkan/vulkan.h"))
|
||||
|
||||
|
||||
def vulkan_cache_ok(path, tag) -> bool:
|
||||
state = read_marker(path)
|
||||
return bool(state) and state.get("tag") == tag and vulkan_headers_ok(path) \
|
||||
and (Path(path) / "Include" / "vk_video" / "vulkan_video_codecs_common.h").is_file()
|
||||
|
||||
|
||||
def cached_vulkan_headers():
|
||||
path = VULKAN_CACHE / VULKAN_TAG_PINNED
|
||||
return path if vulkan_cache_ok(path, VULKAN_TAG_PINNED) else None
|
||||
|
||||
|
||||
def install_vulkan_headers(tag=VULKAN_TAG_PINNED):
|
||||
"""Только заголовки Khronos в <cache>/Include: build.rs линкует Vulkan-библиотеку сам."""
|
||||
dest = VULKAN_CACHE / tag
|
||||
if vulkan_cache_ok(dest, tag):
|
||||
print(f"Vulkan-заголовки {tag}: уже в кэше {dest}", flush=True)
|
||||
return dest
|
||||
print(f"Vulkan-заголовки {tag}: скачиваю include/ (полный LunarG SDK не нужен)", flush=True)
|
||||
staging = VULKAN_CACHE / f".{tag}.part"
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
try:
|
||||
for rel in VULKAN_HEADERS:
|
||||
download(VULKAN_RAW.format(tag=tag, path=rel), staging / "Include" / rel)
|
||||
if not vulkan_headers_ok(staging):
|
||||
raise DownloadError(f"Vulkan-заголовки {tag}: после скачивания нет Include/vulkan/vulkan.h")
|
||||
(staging / INSTALL_MARKER).write_text(json.dumps({"tag": tag, "source": VULKAN_SDK_URL},
|
||||
indent=2) + "\n", encoding="utf-8")
|
||||
shutil.rmtree(dest, ignore_errors=True)
|
||||
staging.rename(dest)
|
||||
except Exception:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
raise
|
||||
print(f"Vulkan-заголовки {tag}: готовы, {dest}", flush=True)
|
||||
return dest
|
||||
|
||||
|
||||
def gpu_names():
|
||||
@@ -134,13 +360,13 @@ def rtx_gpu(names) -> bool:
|
||||
|
||||
|
||||
def valid_dlss_sdk(path) -> bool:
|
||||
"""Каталоги, без которых dlss_wgpu не соберётся: include/nvngx*.h и lib/Windows_x86_64/x64."""
|
||||
return bool(path) and (path / "include").is_dir() and list((path / "include").glob("nvngx*.h")) \
|
||||
"""Каталоги, без которых dlss_wgpu не соберётся: include/nvsdk_ngx*.h и lib/Windows_x86_64/x64."""
|
||||
return bool(path) and (path / "include").is_dir() and list((path / "include").glob("nvsdk_ngx*.h")) \
|
||||
and (path / "lib" / "Windows_x86_64" / "x64").is_dir()
|
||||
|
||||
|
||||
def dlss_sdk_path():
|
||||
"""Корень NVIDIA DLSS SDK v310.9.1 или None."""
|
||||
"""Корень уже установленного NVIDIA DLSS SDK (DLSS_SDK, ROOT/DLSS, Program Files) или None."""
|
||||
candidates = []
|
||||
if os.environ.get("DLSS_SDK"):
|
||||
candidates.append(Path(os.environ["DLSS_SDK"]))
|
||||
@@ -154,47 +380,122 @@ def dlss_sdk_path():
|
||||
return None
|
||||
|
||||
|
||||
def dlss_build_features(system=None, gpus=None, sdk=None) -> str:
|
||||
"""Features сборки клиента: 'mods,dlss' только на Windows + RTX при готовом SDK, иначе 'mods'.
|
||||
def _auto_install(install, label):
|
||||
"""Автоскачивание не должно ломать сборку: любая ошибка — предупреждение и mods/TAAU."""
|
||||
try:
|
||||
return install()
|
||||
except Exception as exc:
|
||||
print(f"Внимание: {label} не скачался: {exc}", flush=True)
|
||||
return None
|
||||
|
||||
Нет SDK на Windows + RTX — предупреждение с инструкцией и обычная сборка без DLSS.
|
||||
|
||||
def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict:
|
||||
"""Features сборки и окружение DLSS_SDK/VULKAN_SDK для Windows + NVIDIA RTX.
|
||||
|
||||
Возвращает {"features", "env", "sdk", "dll"}. Без явного SDK на Windows + RTX сам скачивает
|
||||
DLSS SDK и заголовки Vulkan в .horizon-cache. Явные DLSS_SDK/VULKAN_SDK (или аргумент sdk)
|
||||
имеют приоритет и отключают автоскачивание; неполный явный путь — предупреждение и mods.
|
||||
"""
|
||||
plan = {"features": "mods", "env": {}, "sdk": None, "dll": None}
|
||||
system = platform.system() if system is None else system
|
||||
if system != "Windows":
|
||||
return "mods"
|
||||
return plan
|
||||
names = gpu_names() if gpus is None else gpus
|
||||
if not rtx_gpu(names):
|
||||
return "mods"
|
||||
if sdk is None:
|
||||
sdk_root = dlss_sdk_path()
|
||||
else:
|
||||
return plan
|
||||
|
||||
env_sdk = os.environ.get("DLSS_SDK")
|
||||
explicit_sdk = sdk is not None or bool(env_sdk)
|
||||
if sdk is not None:
|
||||
candidate = Path(sdk)
|
||||
sdk_root = candidate if valid_dlss_sdk(candidate) else None
|
||||
vulkan = os.environ.get("VULKAN_SDK")
|
||||
# dlss_wgpu ищет заголовки Vulkan в Include (Windows) или include.
|
||||
vulkan_ok = bool(vulkan) and any((Path(vulkan) / part).is_file() for part in
|
||||
("Include/vulkan/vulkan.h", "include/vulkan/vulkan.h"))
|
||||
elif env_sdk:
|
||||
candidate = Path(env_sdk)
|
||||
sdk_root = candidate if valid_dlss_sdk(candidate) else None
|
||||
else:
|
||||
sdk_root = dlss_sdk_path() or cached_dlss_sdk()
|
||||
if sdk_root is None:
|
||||
sdk_root = _auto_install(install_dlss_sdk, "NVIDIA DLSS SDK")
|
||||
|
||||
env_vulkan = os.environ.get("VULKAN_SDK")
|
||||
explicit_vulkan = bool(env_vulkan)
|
||||
if env_vulkan:
|
||||
vulkan_root = Path(env_vulkan) if vulkan_headers_ok(env_vulkan) else None
|
||||
else:
|
||||
vulkan_root = cached_vulkan_headers()
|
||||
if vulkan_root is None:
|
||||
vulkan_root = _auto_install(install_vulkan_headers, "Vulkan-заголовки")
|
||||
|
||||
missing = []
|
||||
if sdk_root is None:
|
||||
missing.append(f"NVIDIA DLSS SDK v310.9.1 (переменная DLSS_SDK, {DLSS_SDK_URL})")
|
||||
if not vulkan_ok:
|
||||
missing.append(f"Vulkan SDK (переменная VULKAN_SDK, {VULKAN_SDK_URL})")
|
||||
missing.append("NVIDIA DLSS SDK")
|
||||
if vulkan_root is None:
|
||||
missing.append("заголовки Vulkan")
|
||||
if missing:
|
||||
print("Внимание: NVIDIA RTX найден, но DLSS-сборка пропущена — нет " + " и ".join(missing) + ".",
|
||||
flush=True)
|
||||
print(" DLSS SDK: скачай v310.9.1 и задай DLSS_SDK на корень SDK (include/ и lib/).", flush=True)
|
||||
print(" Vulkan SDK: установи и задай VULKAN_SDK на корень SDK.", flush=True)
|
||||
if explicit_sdk or explicit_vulkan:
|
||||
print(" DLSS_SDK/VULKAN_SDK заданы, но путь неполный. Убери их, и airdef.py скачает SDK сам.",
|
||||
flush=True)
|
||||
else:
|
||||
print(" Автоскачивание не удалось: проверь сеть/прокси и повтори сборку.", flush=True)
|
||||
print(f" Вручную: DLSS SDK {DLSS_SDK_URL} (переменная DLSS_SDK), Vulkan SDK или только "
|
||||
f"заголовки (VULKAN_SDK, {VULKAN_SDK_URL}).", flush=True)
|
||||
print(" Собираю --features mods: DLSS выключен, native TAAU остаётся.", flush=True)
|
||||
return "mods"
|
||||
return plan
|
||||
|
||||
plan.update(features="mods,dlss", sdk=sdk_root, dll=Path(sdk_root) / DLSS_RUNTIME,
|
||||
env={"DLSS_SDK": str(sdk_root), "VULKAN_SDK": str(vulkan_root)})
|
||||
print(f"DLSS: NVIDIA RTX, SDK {sdk_root}; собираю --features mods,dlss", flush=True)
|
||||
print(" nvngx_dlss.dll положи рядом с horizon-client.exe; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True)
|
||||
return "mods,dlss"
|
||||
print(" nvngx_dlss.dll из SDK кладу рядом с horizon-client.exe после сборки; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True)
|
||||
return plan
|
||||
|
||||
|
||||
def dlss_build_features(system=None, gpus=None, sdk=None) -> str:
|
||||
"""Строка features для cargo build: 'mods,dlss' только на Windows + RTX с полным SDK."""
|
||||
return dlss_build_plan(system=system, gpus=gpus, sdk=sdk)["features"]
|
||||
|
||||
|
||||
def built_client_candidates():
|
||||
paths = []
|
||||
if os.environ.get("AIRDEF_GAME"):
|
||||
paths.append(Path(os.environ["AIRDEF_GAME"]))
|
||||
paths += [FORK / "target" / "fast" / ("horizon-client" + EXE), ROOT / ("horizon-client" + EXE)]
|
||||
return paths
|
||||
|
||||
|
||||
def place_dlss_runtime(sdk_root):
|
||||
"""Копирует свежий nvngx_dlss.dll из SDK рядом с собранным horizon-client.exe."""
|
||||
dll = Path(sdk_root) / DLSS_RUNTIME
|
||||
if not dll.is_file():
|
||||
print(f"Внимание: в SDK {sdk_root} нет {DLSS_RUNTIME}; положи nvngx_dlss.dll рядом с клиентом вручную.",
|
||||
flush=True)
|
||||
return None
|
||||
for exe in built_client_candidates():
|
||||
if not exe.is_file():
|
||||
continue
|
||||
target = exe.with_name(dll.name)
|
||||
try:
|
||||
# Всегда свежая DLL: старый nvngx_dlss.dll рядом с клиентом не должен пережить пересборку.
|
||||
shutil.copy2(dll, target)
|
||||
print(f" nvngx_dlss.dll ({dll.stat().st_size / 1e6:.1f} МБ) рядом с {exe}", flush=True)
|
||||
return target
|
||||
except OSError as exc:
|
||||
print(f"Внимание: не удалось положить {dll.name} рядом с {exe}: {exc}", flush=True)
|
||||
print("Внимание: собранный horizon-client.exe не найден; nvngx_dlss.dll нужно положить рядом с ним вручную.",
|
||||
flush=True)
|
||||
return None
|
||||
|
||||
|
||||
def game():
|
||||
fork()
|
||||
run([cargo(), "build", "--profile", "fast", "-p", "horizon-client", "--features", dlss_build_features()],
|
||||
cwd=FORK)
|
||||
plan = dlss_build_plan()
|
||||
env = dict(os.environ)
|
||||
env.update(plan["env"])
|
||||
run([cargo(), "build", "--profile", "fast", "-p", "horizon-client", "--features", plan["features"]],
|
||||
cwd=FORK, env=env)
|
||||
if plan["sdk"] is not None:
|
||||
place_dlss_runtime(plan["sdk"])
|
||||
|
||||
|
||||
def built_game() -> Path:
|
||||
|
||||
+338
-3
@@ -2,6 +2,7 @@
|
||||
import contextlib
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
@@ -69,7 +70,7 @@ class DlssBuildFeatureTests(unittest.TestCase):
|
||||
self.root = Path(self.tmp.name)
|
||||
self.sdk = self.root / "DLSS"
|
||||
(self.sdk / "include").mkdir(parents=True)
|
||||
(self.sdk / "include" / "nvngx_dlss.h").write_text("")
|
||||
(self.sdk / "include" / "nvsdk_ngx.h").write_text("")
|
||||
(self.sdk / "lib" / "Windows_x86_64" / "x64").mkdir(parents=True)
|
||||
self.vulkan = self.root / "VulkanSDK"
|
||||
(self.vulkan / "Include" / "vulkan").mkdir(parents=True)
|
||||
@@ -80,7 +81,9 @@ class DlssBuildFeatureTests(unittest.TestCase):
|
||||
|
||||
def features(self, **kwargs):
|
||||
out = io.StringIO()
|
||||
with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan)}), contextlib.redirect_stdout(out):
|
||||
# Пустые DLSS_SDK/VULKAN_SDK — «не заданы»: автоскачивание в этих тестах не нужно.
|
||||
with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": ""}), \
|
||||
contextlib.redirect_stdout(out):
|
||||
return airdef.dlss_build_features(**kwargs), out.getvalue()
|
||||
|
||||
def test_non_windows_is_mods_even_with_rtx_and_sdk(self):
|
||||
@@ -125,12 +128,344 @@ class DlssBuildFeatureTests(unittest.TestCase):
|
||||
|
||||
def test_game_builds_with_the_detected_feature_string(self):
|
||||
commands = []
|
||||
plan = {"features": "mods,dlss", "env": {}, "sdk": self.sdk, "dll": None}
|
||||
with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \
|
||||
patch.object(airdef, "run", side_effect=lambda cmd, cwd=None, env=None: commands.append(cmd)), \
|
||||
patch.object(airdef, "dlss_build_features", return_value="mods,dlss"):
|
||||
patch.object(airdef, "dlss_build_plan", return_value=plan), \
|
||||
patch.object(airdef, "place_dlss_runtime"):
|
||||
airdef.game()
|
||||
self.assertEqual(commands[-1][-1], "mods,dlss")
|
||||
|
||||
|
||||
class FakeResponse:
|
||||
"""Мини-ответ urlopen: поток чтения и Content-Length, как у настоящего HTTP-ответа."""
|
||||
|
||||
def __init__(self, payload, total=None):
|
||||
self.payload = payload
|
||||
self.pos = 0
|
||||
self.headers = {"Content-Length": str(len(payload) if total is None else total)}
|
||||
|
||||
def read(self, size=-1):
|
||||
chunk = self.payload[self.pos:self.pos + size]
|
||||
self.pos += len(chunk)
|
||||
return chunk
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, *exc):
|
||||
return False
|
||||
|
||||
|
||||
class DownloadTests(unittest.TestCase):
|
||||
"""download(): поток, атомарная замена и явная ошибка на неполном файле."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-download-test-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.root = Path(self.tmp.name)
|
||||
|
||||
def test_download_writes_file_and_leaves_no_part(self):
|
||||
with patch.object(airdef, "open_url", return_value=FakeResponse(b"payload")):
|
||||
airdef.download("https://example.invalid/a.bin", self.root / "sub" / "a.bin")
|
||||
self.assertEqual((self.root / "sub" / "a.bin").read_bytes(), b"payload")
|
||||
self.assertFalse((self.root / "sub" / "a.bin.part").exists())
|
||||
|
||||
def test_truncated_download_fails_without_placing_the_file(self):
|
||||
with patch.object(airdef, "open_url", return_value=FakeResponse(b"short", total=100)):
|
||||
with self.assertRaises(airdef.DownloadError):
|
||||
airdef.download("https://example.invalid/a.bin", self.root / "a.bin")
|
||||
self.assertFalse((self.root / "a.bin").exists())
|
||||
self.assertFalse((self.root / "a.bin.part").exists())
|
||||
|
||||
def test_network_error_is_wrapped_as_download_error(self):
|
||||
with patch.object(airdef, "open_url", side_effect=OSError("no route")):
|
||||
with self.assertRaises(airdef.DownloadError):
|
||||
airdef.download("https://example.invalid/a.bin", self.root / "a.bin")
|
||||
|
||||
|
||||
class DlssVersionTests(unittest.TestCase):
|
||||
"""Выбор тега: самый новый v310.9.x, при сбое API — закреплённый v310.9.1."""
|
||||
|
||||
def test_picks_newest_v310_9_x(self):
|
||||
tags = [{"name": "v310.9.9"}, {"name": "v310.9.16"}, {"name": "v310.7.0"}, {"name": "docs"}]
|
||||
with patch.object(airdef, "github_json", return_value=tags), contextlib.redirect_stdout(io.StringIO()):
|
||||
self.assertEqual(airdef.dlss_latest_tag(), "v310.9.16")
|
||||
|
||||
def test_api_failure_falls_back_to_pinned_tag(self):
|
||||
out = io.StringIO()
|
||||
with patch.object(airdef, "github_json", side_effect=OSError("rate limited")), \
|
||||
contextlib.redirect_stdout(out):
|
||||
self.assertEqual(airdef.dlss_latest_tag(), airdef.DLSS_TAG_PINNED)
|
||||
self.assertIn("v310.9.1", out.getvalue())
|
||||
|
||||
def test_include_list_comes_from_api(self):
|
||||
entries = [{"name": "nvsdk_ngx.h"}, {"name": "README.md"}]
|
||||
with patch.object(airdef, "github_json", return_value=entries):
|
||||
self.assertEqual(airdef.dlss_include_files("v310.9.16"), ["nvsdk_ngx.h"])
|
||||
|
||||
def test_include_list_falls_back_to_pinned_names(self):
|
||||
with patch.object(airdef, "github_json", side_effect=OSError("offline")):
|
||||
names = airdef.dlss_include_files("v310.9.16")
|
||||
self.assertIn("nvsdk_ngx.h", names)
|
||||
self.assertIn("nvsdk_ngx_helpers_vk.h", names)
|
||||
self.assertIn("nvsdk_ngx_helpers_dlssd_vk.h", names)
|
||||
|
||||
|
||||
class DlssAutoInstallTests(unittest.TestCase):
|
||||
"""install_dlss_sdk/install_vulkan_headers: раскладка кэша, маркер и повторное использование."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-install-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.cache = Path(self.tmp.name)
|
||||
self.dlss_cache = self.cache / "dlss-sdk"
|
||||
self.vulkan_cache = self.cache / "vulkan-headers"
|
||||
self.downloads = []
|
||||
self.offline = set()
|
||||
patches = [
|
||||
patch.object(airdef, "DLSS_CACHE", self.dlss_cache),
|
||||
patch.object(airdef, "VULKAN_CACHE", self.vulkan_cache),
|
||||
patch.object(airdef, "dlss_latest_tag", return_value="v310.9.16"),
|
||||
patch.object(airdef, "dlss_include_files",
|
||||
return_value=["nvsdk_ngx.h", "nvsdk_ngx_helpers_vk.h"]),
|
||||
patch.object(airdef, "download", side_effect=self.fake_download),
|
||||
]
|
||||
for item in patches:
|
||||
item.start()
|
||||
self.addCleanup(item.stop)
|
||||
|
||||
def fake_download(self, url, dest):
|
||||
if url in self.offline:
|
||||
raise airdef.DownloadError(f"{url}: simulated offline")
|
||||
self.downloads.append((url, Path(dest)))
|
||||
Path(dest).parent.mkdir(parents=True, exist_ok=True)
|
||||
Path(dest).write_bytes(b"binary" * 4)
|
||||
|
||||
def test_dlss_install_lays_out_exactly_what_build_rs_needs(self):
|
||||
root = airdef.install_dlss_sdk()
|
||||
self.assertEqual(root, self.dlss_cache / "v310.9.16")
|
||||
expected = ["include/nvsdk_ngx.h", "include/nvsdk_ngx_helpers_vk.h",
|
||||
*airdef.DLSS_LIBS, airdef.DLSS_RUNTIME]
|
||||
for rel in expected:
|
||||
self.assertTrue((root / rel).is_file(), rel)
|
||||
marker = json.loads((root / airdef.INSTALL_MARKER).read_text(encoding="utf-8"))
|
||||
self.assertEqual(marker["tag"], "v310.9.16")
|
||||
self.assertEqual(marker["dll_bytes"], 24)
|
||||
self.assertEqual(len(self.downloads), len(expected))
|
||||
self.assertTrue(all("/v310.9.16/" in url for url, _ in self.downloads))
|
||||
self.assertEqual([p.name for p in self.dlss_cache.iterdir()], ["v310.9.16"])
|
||||
|
||||
def test_second_install_is_a_cache_hit_without_downloads(self):
|
||||
first = airdef.install_dlss_sdk()
|
||||
count = len(self.downloads)
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
second = airdef.install_dlss_sdk()
|
||||
self.assertEqual(first, second)
|
||||
self.assertEqual(len(self.downloads), count)
|
||||
self.assertIn("кэше", out.getvalue())
|
||||
|
||||
def test_failed_download_removes_staging_and_installs_nothing(self):
|
||||
dll_url = airdef.DLSS_RAW.format(tag="v310.9.16", path=airdef.DLSS_RUNTIME)
|
||||
self.offline.add(dll_url)
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
with self.assertRaises(airdef.DownloadError):
|
||||
airdef.install_dlss_sdk()
|
||||
self.assertFalse((self.dlss_cache / "v310.9.16").exists())
|
||||
self.assertEqual([p.name for p in self.dlss_cache.iterdir()], [])
|
||||
|
||||
def test_damaged_cache_is_reinstalled(self):
|
||||
root = airdef.install_dlss_sdk()
|
||||
(root / airdef.DLSS_RUNTIME).unlink()
|
||||
count = len(self.downloads)
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
airdef.install_dlss_sdk()
|
||||
self.assertTrue((root / airdef.DLSS_RUNTIME).is_file())
|
||||
self.assertGreater(len(self.downloads), count)
|
||||
|
||||
def test_vulkan_headers_land_under_capital_include(self):
|
||||
root = airdef.install_vulkan_headers()
|
||||
self.assertEqual(root, self.vulkan_cache / airdef.VULKAN_TAG_PINNED)
|
||||
self.assertTrue((root / "Include" / "vulkan" / "vulkan.h").is_file())
|
||||
self.assertTrue((root / "Include" / "vk_video" / "vulkan_video_codecs_common.h").is_file())
|
||||
self.assertTrue((root / airdef.INSTALL_MARKER).is_file())
|
||||
count = len(self.downloads)
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
self.assertEqual(airdef.install_vulkan_headers(), root)
|
||||
self.assertEqual(len(self.downloads), count)
|
||||
|
||||
|
||||
class DlssBuildPlanTests(unittest.TestCase):
|
||||
"""План сборки: автоскачивание, приоритет явных переменных и деградация до mods."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-plan-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.root = Path(self.tmp.name)
|
||||
self.sdk = self.root / "DLSS"
|
||||
(self.sdk / "include").mkdir(parents=True)
|
||||
(self.sdk / "include" / "nvsdk_ngx.h").write_text("")
|
||||
(self.sdk / "lib" / "Windows_x86_64" / "x64").mkdir(parents=True)
|
||||
(self.sdk / airdef.DLSS_RUNTIME).parent.mkdir(parents=True)
|
||||
(self.sdk / airdef.DLSS_RUNTIME).write_bytes(b"dll")
|
||||
self.vulkan = self.root / "VulkanSDK"
|
||||
(self.vulkan / "Include" / "vulkan").mkdir(parents=True)
|
||||
(self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("")
|
||||
|
||||
def plan(self, env=None, **kwargs):
|
||||
out = io.StringIO()
|
||||
baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "AIRDEF_GAME": ""}
|
||||
baseline.update(env or {})
|
||||
with patch.dict(os.environ, baseline), contextlib.redirect_stdout(out):
|
||||
return airdef.dlss_build_plan(**kwargs), out.getvalue()
|
||||
|
||||
def test_non_windows_never_downloads(self):
|
||||
with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")):
|
||||
plan, output = self.plan(system="Darwin", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertEqual(plan["env"], {})
|
||||
self.assertEqual(output, "")
|
||||
|
||||
def test_windows_without_rtx_never_downloads(self):
|
||||
with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")):
|
||||
plan, output = self.plan(system="Windows", gpus=["Intel(R) UHD Graphics 770"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertEqual(output, "")
|
||||
|
||||
def test_windows_rtx_auto_installs_and_wires_env(self):
|
||||
with patch.object(airdef, "dlss_sdk_path", return_value=None), \
|
||||
patch.object(airdef, "cached_dlss_sdk", return_value=None), \
|
||||
patch.object(airdef, "cached_vulkan_headers", return_value=None), \
|
||||
patch.object(airdef, "install_dlss_sdk", return_value=self.sdk) as dlss_install, \
|
||||
patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan) as vulkan_install:
|
||||
plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
dlss_install.assert_called_once_with()
|
||||
vulkan_install.assert_called_once_with()
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)})
|
||||
self.assertEqual(plan["sdk"], self.sdk)
|
||||
self.assertEqual(plan["dll"], self.sdk / airdef.DLSS_RUNTIME)
|
||||
self.assertIn("mods,dlss", output)
|
||||
|
||||
def test_install_failure_degrades_to_mods_with_warning(self):
|
||||
with patch.object(airdef, "dlss_sdk_path", return_value=None), \
|
||||
patch.object(airdef, "cached_dlss_sdk", return_value=None), \
|
||||
patch.object(airdef, "cached_vulkan_headers", return_value=None), \
|
||||
patch.object(airdef, "install_dlss_sdk", side_effect=airdef.DownloadError("нет сети")), \
|
||||
patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan):
|
||||
plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertEqual(plan["env"], {})
|
||||
self.assertIsNone(plan["sdk"])
|
||||
self.assertIn("не скачался", output)
|
||||
self.assertIn("нет сети", output)
|
||||
self.assertIn("TAAU", output)
|
||||
|
||||
def test_explicit_env_wins_and_skips_download(self):
|
||||
env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)}
|
||||
with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")):
|
||||
plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["env"], env)
|
||||
self.assertEqual(plan["sdk"], self.sdk)
|
||||
|
||||
def test_explicit_but_invalid_env_does_not_silently_download(self):
|
||||
env = {"DLSS_SDK": str(self.root / "missing"), "VULKAN_SDK": str(self.vulkan)}
|
||||
with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")):
|
||||
plan, output = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertIn("путь неполный", output)
|
||||
|
||||
def test_cached_sdk_is_used_without_download(self):
|
||||
with patch.object(airdef, "dlss_sdk_path", return_value=None), \
|
||||
patch.object(airdef, "cached_dlss_sdk", return_value=self.sdk), \
|
||||
patch.object(airdef, "cached_vulkan_headers", return_value=self.vulkan), \
|
||||
patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")):
|
||||
plan, _ = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["sdk"], self.sdk)
|
||||
|
||||
def test_game_passes_env_and_copies_dll_after_success(self):
|
||||
plan = {"features": "mods,dlss", "env": {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)},
|
||||
"sdk": self.sdk, "dll": self.sdk / airdef.DLSS_RUNTIME}
|
||||
calls = []
|
||||
|
||||
def fake_run(cmd, cwd=None, env=None):
|
||||
calls.append({"cmd": cmd, "cwd": cwd, "env": env})
|
||||
|
||||
with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \
|
||||
patch.object(airdef, "dlss_build_plan", return_value=plan), \
|
||||
patch.object(airdef, "run", side_effect=fake_run), \
|
||||
patch.object(airdef, "place_dlss_runtime") as place:
|
||||
airdef.game()
|
||||
self.assertEqual(calls[0]["cmd"][-1], "mods,dlss")
|
||||
self.assertEqual(calls[0]["env"]["DLSS_SDK"], str(self.sdk))
|
||||
self.assertEqual(calls[0]["env"]["VULKAN_SDK"], str(self.vulkan))
|
||||
place.assert_called_once_with(self.sdk)
|
||||
|
||||
def test_game_without_dlss_does_not_touch_the_runtime_dll(self):
|
||||
plan = {"features": "mods", "env": {}, "sdk": None, "dll": None}
|
||||
with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \
|
||||
patch.object(airdef, "dlss_build_plan", return_value=plan), \
|
||||
patch.object(airdef, "run"), patch.object(airdef, "place_dlss_runtime") as place:
|
||||
airdef.game()
|
||||
place.assert_not_called()
|
||||
|
||||
|
||||
class PlaceDlssRuntimeTests(unittest.TestCase):
|
||||
"""nvngx_dlss.dll кладётся рядом с собранным клиентом; без клиента — только предупреждение."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-place-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.root = Path(self.tmp.name)
|
||||
self.fork = self.root / "horizon"
|
||||
self.sdk = self.root / "DLSS"
|
||||
(self.sdk / airdef.DLSS_RUNTIME).parent.mkdir(parents=True)
|
||||
(self.sdk / airdef.DLSS_RUNTIME).write_bytes(b"fresh-dlss-dll")
|
||||
self.patches = [
|
||||
patch.object(airdef, "ROOT", self.root),
|
||||
patch.object(airdef, "FORK", self.fork),
|
||||
patch.dict(os.environ, {"AIRDEF_GAME": ""}),
|
||||
]
|
||||
for item in self.patches:
|
||||
item.start()
|
||||
self.addCleanup(item.stop)
|
||||
|
||||
def build(self):
|
||||
exe = self.fork / "target" / "fast" / ("horizon-client" + airdef.EXE)
|
||||
exe.parent.mkdir(parents=True)
|
||||
exe.write_bytes(b"exe")
|
||||
return exe
|
||||
|
||||
def test_dll_lands_beside_the_built_client(self):
|
||||
exe = self.build()
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
target = airdef.place_dlss_runtime(self.sdk)
|
||||
self.assertEqual(target, exe.with_name("nvngx_dlss.dll"))
|
||||
self.assertEqual(target.read_bytes(), b"fresh-dlss-dll")
|
||||
self.assertIn("nvngx_dlss.dll", out.getvalue())
|
||||
|
||||
def test_stale_dll_is_replaced_by_the_fresh_one(self):
|
||||
exe = self.build()
|
||||
target = exe.with_name("nvngx_dlss.dll")
|
||||
target.write_bytes(b"stale-dll-here")
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
airdef.place_dlss_runtime(self.sdk)
|
||||
self.assertEqual(target.read_bytes(), b"fresh-dlss-dll")
|
||||
|
||||
def test_missing_client_warns_instead_of_failing(self):
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
self.assertIsNone(airdef.place_dlss_runtime(self.sdk))
|
||||
self.assertIn("вручную", out.getvalue())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
Reference in New Issue
Block a user