Auto-install libclang for bindgen on Windows + NVIDIA RTX
The DLSS build failed on Windows at dlss_wgpu's bindgen step: libclang.dll is neither in the DLSS SDK nor in the Vulkan headers. It is now part of the same zero-manual toolchain. Detection first, download last: an explicit LIBCLANG_PATH (directory with libclang.dll or clang.dll) wins and disables auto-install; otherwise PATH, Program Files\LLVM\bin (both Program Files roots) and LLVM shipped with Visual Studio (vswhere -find VC\Tools\Llvm\x64\bin\libclang.dll) are checked, then the cache. When nothing is found, the NuGet package libclang.runtime.win-x64 is downloaded (~34 MB, version from the flat-container index with pinned 23.1.5 fallback) and only runtimes/win-x64/native/libclang.dll (~89 MB) is extracted to .horizon-cache/libclang/<version>/ behind the existing staging + airdef-install.json marker pattern. The resolved directory is passed to cargo as LIBCLANG_PATH. libclang is resolved only when the DLSS SDK and Vulkan headers are already available, so a missing SDK never triggers a useless download. Any detection/download/extract failure warns and degrades to mods/TAAU, and non-Windows/non-RTX still returns before any network access. Tests cover PATH/Program Files/vswhere detection, explicit precedence, numeric NuGet version choice and fallback, selective extraction and marker, cache hit, damaged cache reinstall, package without the DLL, plan env wiring and failure to mods-only. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
+178
-15
@@ -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
|
||||
python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX сам скачивает DLSS SDK, Vulkan-заголовки и libclang
|
||||
python3 tools/airdef.py mod # собрать мод airdef.hmod — нужен Rust с wasm32
|
||||
python3 tools/airdef.py install # положить мод в папку игры и включить
|
||||
python3 tools/airdef.py play [аргументы игры] # запустить форк на папке игры
|
||||
@@ -13,9 +13,10 @@
|
||||
|
||||
Переменные окружения: HORIZON_HOME (папка игры), HORIZON_RESOURCES (подготовленные ресурсы
|
||||
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.
|
||||
На Windows + NVIDIA RTX сборка с DLSS (feature dlss) сама скачивает DLSS SDK, заголовки Vulkan и
|
||||
libclang для bindgen в .horizon-cache/ и кладёт nvngx_dlss.dll рядом с horizon-client.exe. Явные
|
||||
DLSS_SDK, VULKAN_SDK и LIBCLANG_PATH по-прежнему имеют приоритет над автоскачиванием; при сбое сети
|
||||
собирается обычный mods/TAAU.
|
||||
"""
|
||||
import glob
|
||||
import hashlib
|
||||
@@ -139,9 +140,19 @@ VULKAN_HEADERS = (
|
||||
"vk_video/vulkan_video_codec_vp9std_decode.h", "vk_video/vulkan_video_codecs_common.h",
|
||||
)
|
||||
|
||||
# bindgen из dlss_wgpu ищет libclang.dll; в DLSS SDK и Vulkan-заголовках его нет.
|
||||
LIBCLANG_NUGET = "libclang.runtime.win-x64"
|
||||
LIBCLANG_INDEX = "https://api.nuget.org/v3-flatcontainer/libclang.runtime.win-x64/index.json"
|
||||
LIBCLANG_PACKAGE = ("https://api.nuget.org/v3-flatcontainer/libclang.runtime.win-x64/{version}/"
|
||||
"libclang.runtime.win-x64.{version}.nupkg")
|
||||
LIBCLANG_VERSION_PINNED = "23.1.5"
|
||||
LIBCLANG_NATIVE = "runtimes/win-x64/native/libclang.dll"
|
||||
LIBCLANG_URL = "https://www.nuget.org/packages/libclang.runtime.win-x64"
|
||||
|
||||
CACHE = ROOT / ".horizon-cache"
|
||||
DLSS_CACHE = CACHE / "dlss-sdk"
|
||||
VULKAN_CACHE = CACHE / "vulkan-headers"
|
||||
LIBCLANG_CACHE = CACHE / "libclang"
|
||||
INSTALL_MARKER = "airdef-install.json"
|
||||
|
||||
|
||||
@@ -154,7 +165,8 @@ def open_url(url):
|
||||
return urllib.request.urlopen(request, timeout=120)
|
||||
|
||||
|
||||
def github_json(url):
|
||||
def fetch_json(url):
|
||||
"""JSON с GitHub API или nuget.org: общий транспорт для версий и списков файлов."""
|
||||
with open_url(url) as response:
|
||||
return json.load(response)
|
||||
|
||||
@@ -195,7 +207,7 @@ def download(url, dest):
|
||||
def dlss_latest_tag():
|
||||
"""Новейший стабильный тег v310.9.x с GitHub; при сбое API — закреплённый v310.9.1."""
|
||||
try:
|
||||
tags = github_json(DLSS_TAGS_API)
|
||||
tags = fetch_json(DLSS_TAGS_API)
|
||||
except Exception as exc:
|
||||
print(f"Внимание: не удалось получить теги DLSS ({exc}); беру {DLSS_TAG_PINNED}.", flush=True)
|
||||
return DLSS_TAG_PINNED
|
||||
@@ -214,7 +226,7 @@ def dlss_latest_tag():
|
||||
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}")
|
||||
entries = fetch_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:
|
||||
@@ -333,6 +345,132 @@ def install_vulkan_headers(tag=VULKAN_TAG_PINNED):
|
||||
return dest
|
||||
|
||||
|
||||
def version_key(text):
|
||||
"""Числовой ключ версии NuGet: 23.1.10 новее 23.1.5 (строкой было бы наоборот)."""
|
||||
numbers = tuple(int(part) for part in re.findall(r"\d+", str(text)))
|
||||
return numbers or (0,)
|
||||
|
||||
|
||||
def libclang_root(path):
|
||||
"""Каталог, в котором bindgen найдёт libclang.dll (или clang.dll), либо None."""
|
||||
if not path:
|
||||
return None
|
||||
path = Path(path)
|
||||
return path if any((path / name).is_file() for name in ("libclang.dll", "clang.dll")) else None
|
||||
|
||||
|
||||
def vs_libclang():
|
||||
"""LLVM из Visual Studio (VC\\Tools\\Llvm\\x64\\bin) через vswhere; вне Windows — None."""
|
||||
if platform.system() != "Windows":
|
||||
return None
|
||||
base = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
|
||||
vswhere = Path(base) / "Microsoft Visual Studio" / "Installer" / "vswhere.exe" if base else None
|
||||
if vswhere is None or not vswhere.is_file():
|
||||
return None
|
||||
flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
|
||||
try:
|
||||
out = subprocess.run([str(vswhere), "-products", "*", "-latest",
|
||||
"-find", "VC\\Tools\\Llvm\\x64\\bin\\libclang.dll"],
|
||||
capture_output=True, text=True, timeout=30,
|
||||
creationflags=flags, errors="replace")
|
||||
except (OSError, ValueError, subprocess.SubprocessError):
|
||||
return None
|
||||
for line in out.stdout.splitlines():
|
||||
found = libclang_root(Path(line.strip()).parent)
|
||||
if found:
|
||||
return found
|
||||
return None
|
||||
|
||||
|
||||
def system_libclang():
|
||||
"""Уже установленный libclang: PATH, Program Files\\LLVM\\bin, LLVM из Visual Studio."""
|
||||
for entry in os.environ.get("PATH", "").split(os.pathsep):
|
||||
found = libclang_root(entry)
|
||||
if found:
|
||||
return found
|
||||
for env in ("ProgramFiles", "ProgramFiles(x86)"):
|
||||
if os.environ.get(env):
|
||||
found = libclang_root(Path(os.environ[env]) / "LLVM" / "bin")
|
||||
if found:
|
||||
return found
|
||||
return vs_libclang()
|
||||
|
||||
|
||||
def libclang_latest_version():
|
||||
"""Последняя стабильная версия libclang.runtime.win-x64 с NuGet; pinned при сбое API."""
|
||||
try:
|
||||
data = fetch_json(LIBCLANG_INDEX)
|
||||
versions = [v for v in data.get("versions", [])
|
||||
if isinstance(v, str) and "-" not in v and version_key(v) != (0,)]
|
||||
except Exception as exc:
|
||||
print(f"Внимание: не удалось получить версии libclang ({exc}); беру {LIBCLANG_VERSION_PINNED}.",
|
||||
flush=True)
|
||||
return LIBCLANG_VERSION_PINNED
|
||||
if not versions:
|
||||
print(f"Внимание: NuGet не вернул стабильные версии libclang; беру {LIBCLANG_VERSION_PINNED}.",
|
||||
flush=True)
|
||||
return LIBCLANG_VERSION_PINNED
|
||||
return max(versions, key=version_key)
|
||||
|
||||
|
||||
def libclang_cache_ok(path, version):
|
||||
"""Кэш libclang: маркер этой версии и DLL того же размера (иначе — перекачать)."""
|
||||
state = read_marker(path)
|
||||
dll = Path(path) / "libclang.dll"
|
||||
return bool(state) and state.get("tag") == version and dll.is_file() \
|
||||
and state.get("dll_bytes") == dll.stat().st_size
|
||||
|
||||
|
||||
def cached_libclang():
|
||||
try:
|
||||
candidates = sorted(LIBCLANG_CACHE.iterdir(), key=lambda p: version_key(p.name), reverse=True)
|
||||
except OSError:
|
||||
return None
|
||||
for path in candidates:
|
||||
if libclang_cache_ok(path, path.name):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
def install_libclang(version=None):
|
||||
"""libclang.dll из NuGet-пакета libclang.runtime.win-x64 в .horizon-cache/libclang/<ver>.
|
||||
|
||||
Пакет (~34 МБ) распаковывается выборочно: нужен только runtimes/win-x64/native/libclang.dll.
|
||||
"""
|
||||
version = version or libclang_latest_version()
|
||||
dest = LIBCLANG_CACHE / version
|
||||
if libclang_cache_ok(dest, version):
|
||||
print(f"libclang {version}: уже в кэше {dest}", flush=True)
|
||||
return dest
|
||||
url = LIBCLANG_PACKAGE.format(version=version)
|
||||
print(f"libclang {version}: скачиваю {LIBCLANG_NUGET} (~34 МБ) с nuget.org", flush=True)
|
||||
staging = LIBCLANG_CACHE / f".{version}.part"
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
package = staging / f"libclang.runtime.win-x64.{version}.nupkg"
|
||||
try:
|
||||
download(url, package)
|
||||
with zipfile.ZipFile(package) as archive:
|
||||
with archive.open(LIBCLANG_NATIVE) as src, open(staging / "libclang.dll", "wb") as out:
|
||||
shutil.copyfileobj(src, out)
|
||||
package.unlink()
|
||||
dll = staging / "libclang.dll"
|
||||
if not dll.is_file() or dll.stat().st_size == 0:
|
||||
raise DownloadError(f"libclang {version}: в пакете нет {LIBCLANG_NATIVE}")
|
||||
(staging / INSTALL_MARKER).write_text(json.dumps({
|
||||
"tag": version, "source": LIBCLANG_URL,
|
||||
"dll_bytes": dll.stat().st_size}, indent=2) + "\n", encoding="utf-8")
|
||||
shutil.rmtree(dest, ignore_errors=True)
|
||||
staging.rename(dest)
|
||||
except (KeyError, zipfile.BadZipFile) as exc:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
raise DownloadError(f"libclang {version}: {exc}") from exc
|
||||
except Exception:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
raise
|
||||
print(f"libclang {version}: готов, {dest / 'libclang.dll'}", flush=True)
|
||||
return dest
|
||||
|
||||
|
||||
def gpu_names():
|
||||
"""Имена видеоадаптеров Windows. Сбой опроса — пустой список (это «нет DLSS», а не ошибка сборки)."""
|
||||
if platform.system() != "Windows":
|
||||
@@ -391,11 +529,12 @@ def _auto_install(install, label):
|
||||
|
||||
|
||||
def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict:
|
||||
"""Features сборки и окружение DLSS_SDK/VULKAN_SDK для Windows + NVIDIA RTX.
|
||||
"""Features сборки и окружение DLSS_SDK/VULKAN_SDK/LIBCLANG_PATH для Windows + NVIDIA RTX.
|
||||
|
||||
Возвращает {"features", "env", "sdk", "dll"}. Без явного SDK на Windows + RTX сам скачивает
|
||||
DLSS SDK и заголовки Vulkan в .horizon-cache. Явные DLSS_SDK/VULKAN_SDK (или аргумент sdk)
|
||||
имеют приоритет и отключают автоскачивание; неполный явный путь — предупреждение и mods.
|
||||
DLSS SDK, заголовки Vulkan и libclang для bindgen в .horizon-cache. Явные
|
||||
DLSS_SDK/VULKAN_SDK/LIBCLANG_PATH (или аргумент sdk) имеют приоритет и отключают автоскачивание
|
||||
своего компонента; неполный явный путь — предупреждение и mods.
|
||||
"""
|
||||
plan = {"features": "mods", "env": {}, "sdk": None, "dll": None}
|
||||
system = platform.system() if system is None else system
|
||||
@@ -427,27 +566,51 @@ def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict:
|
||||
if vulkan_root is None:
|
||||
vulkan_root = _auto_install(install_vulkan_headers, "Vulkan-заголовки")
|
||||
|
||||
# libclang нужен только bindgen'у из dlss_wgpu, поэтому качаем его лишь когда SDK и Vulkan уже есть.
|
||||
env_libclang = os.environ.get("LIBCLANG_PATH")
|
||||
explicit_libclang = bool(env_libclang)
|
||||
clang_root = None
|
||||
if sdk_root is not None and vulkan_root is not None:
|
||||
if env_libclang:
|
||||
clang_root = libclang_root(env_libclang)
|
||||
else:
|
||||
clang_root = system_libclang() or cached_libclang()
|
||||
if clang_root is None:
|
||||
clang_root = _auto_install(install_libclang, "libclang для bindgen")
|
||||
|
||||
missing = []
|
||||
if sdk_root is None:
|
||||
missing.append("NVIDIA DLSS SDK")
|
||||
if vulkan_root is None:
|
||||
missing.append("заголовки Vulkan")
|
||||
if sdk_root is not None and vulkan_root is not None and clang_root is None:
|
||||
missing.append("libclang для bindgen")
|
||||
if missing:
|
||||
print("Внимание: NVIDIA RTX найден, но DLSS-сборка пропущена — нет " + " и ".join(missing) + ".",
|
||||
flush=True)
|
||||
if explicit_sdk or explicit_vulkan:
|
||||
print(" DLSS_SDK/VULKAN_SDK заданы, но путь неполный. Убери их, и airdef.py скачает SDK сам.",
|
||||
incomplete = []
|
||||
if explicit_sdk and sdk_root is None:
|
||||
incomplete.append("DLSS_SDK")
|
||||
if explicit_vulkan and vulkan_root is None:
|
||||
incomplete.append("VULKAN_SDK")
|
||||
if explicit_libclang and clang_root is None and sdk_root is not None and vulkan_root is not None:
|
||||
incomplete.append("LIBCLANG_PATH")
|
||||
if incomplete:
|
||||
print(f" {', '.join(incomplete)}: путь неполный. Убери переменную, и airdef.py скачает всё сам.",
|
||||
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)
|
||||
f"заголовки (VULKAN_SDK, {VULKAN_SDK_URL}); libclang — winget install LLVM.LLVM "
|
||||
"(переменная LIBCLANG_PATH).", flush=True)
|
||||
print(" Собираю --features mods: DLSS выключен, native TAAU остаётся.", flush=True)
|
||||
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)
|
||||
env={"DLSS_SDK": str(sdk_root), "VULKAN_SDK": str(vulkan_root),
|
||||
"LIBCLANG_PATH": str(clang_root)})
|
||||
print(f"DLSS: NVIDIA RTX, SDK {sdk_root}, libclang {clang_root}; собираю --features mods,dlss",
|
||||
flush=True)
|
||||
print(" nvngx_dlss.dll из SDK кладу рядом с horizon-client.exe после сборки; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True)
|
||||
return plan
|
||||
|
||||
|
||||
+232
-13
@@ -8,7 +8,8 @@ from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import zipfile
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
SPEC = importlib.util.spec_from_file_location("airdef_build", Path(__file__).with_name("airdef.py"))
|
||||
airdef = importlib.util.module_from_spec(SPEC)
|
||||
@@ -75,14 +76,21 @@ class DlssBuildFeatureTests(unittest.TestCase):
|
||||
self.vulkan = self.root / "VulkanSDK"
|
||||
(self.vulkan / "Include" / "vulkan").mkdir(parents=True)
|
||||
(self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("")
|
||||
self.libclang = self.root / "LLVM" / "bin"
|
||||
self.libclang.mkdir(parents=True)
|
||||
(self.libclang / "libclang.dll").write_bytes(b"clang")
|
||||
self.libclang_patch = patch.object(airdef, "system_libclang", return_value=self.libclang)
|
||||
self.libclang_patch.start()
|
||||
|
||||
def tearDown(self):
|
||||
self.libclang_patch.stop()
|
||||
self.tmp.cleanup()
|
||||
|
||||
def features(self, **kwargs):
|
||||
out = io.StringIO()
|
||||
# Пустые DLSS_SDK/VULKAN_SDK — «не заданы»: автоскачивание в этих тестах не нужно.
|
||||
with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": ""}), \
|
||||
with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": "",
|
||||
"LIBCLANG_PATH": ""}), \
|
||||
contextlib.redirect_stdout(out):
|
||||
return airdef.dlss_build_features(**kwargs), out.getvalue()
|
||||
|
||||
@@ -189,23 +197,23 @@ class DlssVersionTests(unittest.TestCase):
|
||||
|
||||
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()):
|
||||
with patch.object(airdef, "fetch_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")), \
|
||||
with patch.object(airdef, "fetch_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):
|
||||
with patch.object(airdef, "fetch_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")):
|
||||
with patch.object(airdef, "fetch_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)
|
||||
@@ -301,6 +309,151 @@ class DlssAutoInstallTests(unittest.TestCase):
|
||||
self.assertEqual(len(self.downloads), count)
|
||||
|
||||
|
||||
class LibclangDetectionTests(unittest.TestCase):
|
||||
"""Поиск уже установленного libclang: LIBCLANG_PATH, PATH, Program Files, vswhere."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-libclang-detect-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.root = Path(self.tmp.name)
|
||||
|
||||
def test_root_accepts_libclang_or_clang_dll_only(self):
|
||||
for name in ("libclang.dll", "clang.dll"):
|
||||
folder = self.root / name.replace(".", "_")
|
||||
folder.mkdir()
|
||||
(folder / name).write_bytes(b"dll")
|
||||
self.assertEqual(airdef.libclang_root(folder), folder)
|
||||
empty = self.root / "empty"
|
||||
empty.mkdir()
|
||||
self.assertIsNone(airdef.libclang_root(empty))
|
||||
self.assertIsNone(airdef.libclang_root(""))
|
||||
|
||||
def test_path_entry_is_found(self):
|
||||
folder = self.root / "bin"
|
||||
folder.mkdir()
|
||||
(folder / "libclang.dll").write_bytes(b"dll")
|
||||
with patch.dict(os.environ, {"PATH": os.pathsep.join([str(self.root / "nothing"), str(folder)]),
|
||||
"ProgramFiles": "", "ProgramFiles(x86)": ""}):
|
||||
self.assertEqual(airdef.system_libclang(), folder)
|
||||
|
||||
def test_program_files_llvm_install_is_found(self):
|
||||
bin_dir = self.root / "LLVM" / "bin"
|
||||
bin_dir.mkdir(parents=True)
|
||||
(bin_dir / "libclang.dll").write_bytes(b"dll")
|
||||
with patch.dict(os.environ, {"PATH": "", "ProgramFiles": str(self.root), "ProgramFiles(x86)": ""}):
|
||||
self.assertEqual(airdef.system_libclang(), bin_dir)
|
||||
|
||||
def test_visual_studio_llvm_is_found_through_vswhere(self):
|
||||
bin_dir = self.root / "VC" / "Tools" / "Llvm" / "x64" / "bin"
|
||||
bin_dir.mkdir(parents=True)
|
||||
(bin_dir / "libclang.dll").write_bytes(b"dll")
|
||||
vswhere = self.root / "Microsoft Visual Studio" / "Installer" / "vswhere.exe"
|
||||
vswhere.parent.mkdir(parents=True)
|
||||
vswhere.write_bytes(b"exe")
|
||||
result = Mock(stdout=str(bin_dir / "libclang.dll") + "\n", returncode=0)
|
||||
with patch.object(airdef.platform, "system", return_value="Windows"), \
|
||||
patch.dict(os.environ, {"PATH": "", "ProgramFiles": "", "ProgramFiles(x86)": str(self.root)}), \
|
||||
patch.object(airdef.subprocess, "run", return_value=result) as run:
|
||||
self.assertEqual(airdef.system_libclang(), bin_dir)
|
||||
self.assertIn("-find", run.call_args[0][0])
|
||||
|
||||
def test_no_install_anywhere_returns_none(self):
|
||||
with patch.object(airdef.platform, "system", return_value="Windows"), \
|
||||
patch.dict(os.environ, {"PATH": "", "ProgramFiles": "", "ProgramFiles(x86)": ""}):
|
||||
self.assertIsNone(airdef.system_libclang())
|
||||
|
||||
|
||||
class LibclangVersionTests(unittest.TestCase):
|
||||
"""Версия NuGet: числовой максимум без prerelease, при сбое API — pinned 23.1.5."""
|
||||
|
||||
def test_numeric_max_not_string_max(self):
|
||||
data = {"versions": ["18.1.3.2", "23.1.5", "23.1.10", "24.0.0-preview", "junk"]}
|
||||
with patch.object(airdef, "fetch_json", return_value=data), contextlib.redirect_stdout(io.StringIO()):
|
||||
self.assertEqual(airdef.libclang_latest_version(), "23.1.10")
|
||||
|
||||
def test_api_failure_falls_back_to_pinned(self):
|
||||
out = io.StringIO()
|
||||
with patch.object(airdef, "fetch_json", side_effect=OSError("offline")), \
|
||||
contextlib.redirect_stdout(out):
|
||||
self.assertEqual(airdef.libclang_latest_version(), airdef.LIBCLANG_VERSION_PINNED)
|
||||
self.assertIn(airdef.LIBCLANG_VERSION_PINNED, out.getvalue())
|
||||
|
||||
def test_empty_version_list_falls_back_to_pinned(self):
|
||||
with patch.object(airdef, "fetch_json", return_value={"versions": []}), \
|
||||
contextlib.redirect_stdout(io.StringIO()):
|
||||
self.assertEqual(airdef.libclang_latest_version(), airdef.LIBCLANG_VERSION_PINNED)
|
||||
|
||||
|
||||
class LibclangAutoInstallTests(unittest.TestCase):
|
||||
"""NuGet-пакет: скачать, выборочно распаковать libclang.dll, кэш и повторное использование."""
|
||||
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory(prefix="airdef-libclang-install-")
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
self.cache = Path(self.tmp.name) / "libclang"
|
||||
self.downloads = []
|
||||
self.members = {airdef.LIBCLANG_NATIVE: b"clang-bytes"}
|
||||
patches = [
|
||||
patch.object(airdef, "LIBCLANG_CACHE", self.cache),
|
||||
patch.object(airdef, "libclang_latest_version", return_value="23.1.5"),
|
||||
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):
|
||||
self.downloads.append((url, Path(dest)))
|
||||
Path(dest).parent.mkdir(parents=True, exist_ok=True)
|
||||
with zipfile.ZipFile(dest, "w") as archive:
|
||||
for name, payload in self.members.items():
|
||||
archive.writestr(name, payload)
|
||||
|
||||
def test_extracts_only_the_native_dll_and_writes_marker(self):
|
||||
root = airdef.install_libclang()
|
||||
self.assertEqual(root, self.cache / "23.1.5")
|
||||
self.assertEqual((root / "libclang.dll").read_bytes(), b"clang-bytes")
|
||||
marker = json.loads((root / airdef.INSTALL_MARKER).read_text(encoding="utf-8"))
|
||||
self.assertEqual(marker["tag"], "23.1.5")
|
||||
self.assertEqual(marker["dll_bytes"], len(b"clang-bytes"))
|
||||
self.assertEqual(len(self.downloads), 1)
|
||||
self.assertIn("/23.1.5/libclang.runtime.win-x64.23.1.5.nupkg", self.downloads[0][0])
|
||||
self.assertEqual([p.name for p in self.cache.iterdir()], ["23.1.5"])
|
||||
|
||||
def test_cache_hit_skips_download(self):
|
||||
first = airdef.install_libclang()
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
second = airdef.install_libclang()
|
||||
self.assertEqual(first, second)
|
||||
self.assertEqual(len(self.downloads), 1)
|
||||
self.assertIn("кэше", out.getvalue())
|
||||
|
||||
def test_damaged_cache_is_reinstalled(self):
|
||||
root = airdef.install_libclang()
|
||||
(root / "libclang.dll").unlink()
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
airdef.install_libclang()
|
||||
self.assertTrue((root / "libclang.dll").is_file())
|
||||
self.assertEqual(len(self.downloads), 2)
|
||||
|
||||
def test_package_without_the_native_dll_fails_cleanly(self):
|
||||
self.members = {"runtimes/win-x64/native/other.dll": b"nope"}
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
with self.assertRaises(airdef.DownloadError):
|
||||
airdef.install_libclang()
|
||||
self.assertFalse((self.cache / "23.1.5").exists())
|
||||
self.assertEqual([p.name for p in self.cache.iterdir()], [])
|
||||
|
||||
def test_missing_cache_directory_is_not_an_error(self):
|
||||
self.assertIsNone(airdef.cached_libclang())
|
||||
|
||||
def test_explicit_version_selects_the_package(self):
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
airdef.install_libclang("23.1.4")
|
||||
self.assertIn("/23.1.4/libclang.runtime.win-x64.23.1.4.nupkg", self.downloads[0][0])
|
||||
|
||||
|
||||
class DlssBuildPlanTests(unittest.TestCase):
|
||||
"""План сборки: автоскачивание, приоритет явных переменных и деградация до mods."""
|
||||
|
||||
@@ -317,10 +470,17 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
self.vulkan = self.root / "VulkanSDK"
|
||||
(self.vulkan / "Include" / "vulkan").mkdir(parents=True)
|
||||
(self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("")
|
||||
self.libclang = self.root / "LLVM" / "bin"
|
||||
self.libclang.mkdir(parents=True)
|
||||
(self.libclang / "libclang.dll").write_bytes(b"clang")
|
||||
# Детект уже установленного libclang по умолчанию успешен: эти тесты не ходят в сеть.
|
||||
detection = patch.object(airdef, "system_libclang", return_value=self.libclang)
|
||||
detection.start()
|
||||
self.addCleanup(detection.stop)
|
||||
|
||||
def plan(self, env=None, **kwargs):
|
||||
out = io.StringIO()
|
||||
baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "AIRDEF_GAME": ""}
|
||||
baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "LIBCLANG_PATH": "", "AIRDEF_GAME": ""}
|
||||
baseline.update(env or {})
|
||||
with patch.dict(os.environ, baseline), contextlib.redirect_stdout(out):
|
||||
return airdef.dlss_build_plan(**kwargs), out.getvalue()
|
||||
@@ -350,7 +510,8 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
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["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan),
|
||||
"LIBCLANG_PATH": str(self.libclang)})
|
||||
self.assertEqual(plan["sdk"], self.sdk)
|
||||
self.assertEqual(plan["dll"], self.sdk / airdef.DLSS_RUNTIME)
|
||||
self.assertIn("mods,dlss", output)
|
||||
@@ -360,7 +521,8 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
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):
|
||||
patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan), \
|
||||
patch.object(airdef, "install_libclang", side_effect=AssertionError("libclang too early")):
|
||||
plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertEqual(plan["env"], {})
|
||||
@@ -370,9 +532,11 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
self.assertIn("TAAU", output)
|
||||
|
||||
def test_explicit_env_wins_and_skips_download(self):
|
||||
env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)}
|
||||
env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan),
|
||||
"LIBCLANG_PATH": str(self.libclang)}
|
||||
with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")):
|
||||
patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")), \
|
||||
patch.object(airdef, "system_libclang", side_effect=AssertionError("detection attempted")):
|
||||
plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["env"], env)
|
||||
@@ -386,7 +550,8 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
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["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan),
|
||||
"LIBCLANG_PATH": str(self.libclang)})
|
||||
|
||||
def test_explicit_but_invalid_env_does_not_silently_download(self):
|
||||
env = {"DLSS_SDK": str(self.root / "missing"), "VULKAN_SDK": str(self.vulkan)}
|
||||
@@ -405,8 +570,61 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["sdk"], self.sdk)
|
||||
|
||||
def test_libclang_auto_installed_when_not_found(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, "system_libclang", return_value=None), \
|
||||
patch.object(airdef, "cached_libclang", return_value=None), \
|
||||
patch.object(airdef, "install_libclang", return_value=self.libclang) as libclang_install:
|
||||
plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
libclang_install.assert_called_once_with()
|
||||
self.assertEqual(plan["features"], "mods,dlss")
|
||||
self.assertEqual(plan["env"]["LIBCLANG_PATH"], str(self.libclang))
|
||||
self.assertIn("libclang", output)
|
||||
|
||||
def test_libclang_failure_degrades_to_mods(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, "system_libclang", return_value=None), \
|
||||
patch.object(airdef, "cached_libclang", return_value=None), \
|
||||
patch.object(airdef, "install_libclang",
|
||||
side_effect=airdef.DownloadError("нет nuget")):
|
||||
plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"])
|
||||
self.assertEqual(plan["features"], "mods")
|
||||
self.assertEqual(plan["env"], {})
|
||||
self.assertIn("libclang", output)
|
||||
self.assertIn("нет nuget", output)
|
||||
self.assertIn("TAAU", output)
|
||||
|
||||
def test_explicit_libclang_path_wins_and_skips_detection(self):
|
||||
env = {"LIBCLANG_PATH": str(self.libclang)}
|
||||
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, "system_libclang", side_effect=AssertionError("detection attempted")), \
|
||||
patch.object(airdef, "install_libclang", 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"]["LIBCLANG_PATH"], str(self.libclang))
|
||||
|
||||
def test_explicit_invalid_libclang_env_does_not_download(self):
|
||||
env = {"LIBCLANG_PATH": str(self.root / "missing")}
|
||||
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, "system_libclang", side_effect=AssertionError("detection attempted")), \
|
||||
patch.object(airdef, "install_libclang", 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("LIBCLANG_PATH", output)
|
||||
self.assertIn("путь неполный", output)
|
||||
|
||||
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)},
|
||||
plan = {"features": "mods,dlss",
|
||||
"env": {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan),
|
||||
"LIBCLANG_PATH": str(self.libclang)},
|
||||
"sdk": self.sdk, "dll": self.sdk / airdef.DLSS_RUNTIME}
|
||||
calls = []
|
||||
|
||||
@@ -421,6 +639,7 @@ class DlssBuildPlanTests(unittest.TestCase):
|
||||
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))
|
||||
self.assertEqual(calls[0]["env"]["LIBCLANG_PATH"], str(self.libclang))
|
||||
place.assert_called_once_with(self.sdk)
|
||||
|
||||
def test_game_without_dlss_does_not_touch_the_runtime_dll(self):
|
||||
|
||||
Reference in New Issue
Block a user