zapret-kvn/xray_fluent/updates/app_updater.py
loop-uh c80fd648ee
Some checks failed
Windows project source guards / test (push) Has been cancelled
client reports: app errors not about a server (vpnbot app_error live)
Errors that are not about any server go in the same batches as
"kind": "app_error", schema 1: step, code, count since the last send,
occurred_at of the first (in the ingest's time), and for a crash only its
frames (module.function:line relative to the package, innermost first, at
most 16) -- never a message, path, user dir, address or URL. The store
counts repeats, sends one code at most once a day per app version and
keeps at most 32 for 7 days. Sources: uncaught exceptions in any thread,
a start that failed before a server was chosen (port:bind for a local
port conflict), a failed subscription fetch (HTTP class or transport, our
service's link or not, route) or parse, a failed update download or
install, TUN without administrator rights, the profile store not read or
written. Errors noted before the reporter exists go when it does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 05:26:26 -05:00

1090 lines
50 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Self-update: check Forgejo releases, download, verify and unpack.
Замену файлов выполняет ``updates.installer`` — новая сборка, запущенная
из распакованного архива.
"""
from __future__ import annotations
import errno
import hashlib
import http.client
import json
import logging
import re
import shutil
import tempfile
import threading
import time
import urllib.error
import urllib.request
import zipfile
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import quote, unquote, urlsplit
from urllib.request import Request
from ..network.http_utils import (
HttpFetchError,
HttpResponseTooLarge,
build_opener,
fetch_bytes,
)
from PyQt6.QtCore import QThread, pyqtSignal
from ..constants import APP_VERSION, BASE_DIR
from . import site_names
from .delta_zip import DeltaUnavailable, HttpRangeSource, SignedFile, prepare_delta
from .installer.plan import APP_EXE_NAME, WORK_DIR_PREFIX
from .installer.runner import STAGE_ROOT_NAME
from .signed_release import PRODUCT, signed_asset_urls, verified_manifest
from zapret_update import mirrors as git_mirrors
from zapret_update.manifest import ManifestError
FORGEJO_RELEASE_API = (
"https://iianajhlkh.zapret.moe/api/v1/repos/"
"zapretkvn/zapret-kvn/releases/latest"
)
# Canonical owner first; legacy owners stay trusted because Forgejo redirects
# renamed repos, so older releases may still reference them.
FORGEJO_RELEASE_DOWNLOAD_PREFIXES = (
"/zapretkvn/zapret-kvn/releases/download/",
"/zapretdiscordyoutube/zapret-kvn/releases/download/",
)
FORGEJO_HOST = "git.zapret.moe"
# Те же файлы выпусков лежат на GitHub (решение владельца 2026-11-03: архив обновления качается с GitHub,
# Forgejo — запасной путь; выпуски копирует forgejo_releases_to_github.py на хосте). Тот же тег и то же имя
# файла; подлинность проверяет подписанный список выпуска и SHA-256 архива.
GITHUB_RELEASE_DOWNLOAD_ORIGIN = "https://github.com/zapret-discordyoutube/zapret-kvn/releases/download/"
# Не отвечает ни одно зеркало Forgejo (и входные страницы Zapret Links не помогли): о выпуске
# спрашивается GitHub (решение владельца 2026-11-04). Подлинность та же — подписанный список выпуска.
GITHUB_RELEASE_API = "https://api.github.com/repos/zapret-discordyoutube/zapret-kvn/releases/latest"
GITHUB_REPO_URL = "https://github.com/zapret-discordyoutube/zapret-kvn"
# GitHub отдаёт файлы выпуска с github.com и перенаправляет на свои хранилища.
_GITHUB_FILE_HOSTS = frozenset({
"github.com",
"objects.githubusercontent.com",
"release-assets.githubusercontent.com",
"github-releases.githubusercontent.com",
})
# Основное имя режут по TLS; тот же Forgejo открывается под зеркалами git2, git3, …
# (список имён отдаёт сам сервер). Проверка обновления идёт под первым открытым
# именем, а ссылки на файлы выпуска остаются теми, под которым ответил сервер.
_MIRROR_LIST_TIMEOUT = 3
_MAX_MIRROR_LIST_BYTES = 64 * 1024
# Дольше этого перебор имён не идёт.
_MIRROR_ROUND_BUDGET_S = 25.0
USER_AGENT = f"ZapretKVN/{APP_VERSION}"
_UPDATE_CHECK_TIMEOUT = 8
_MAX_RELEASE_METADATA_BYTES = 1024 * 1024
_MAX_CHECKSUM_BYTES = 16 * 1024
_log = logging.getLogger(__name__)
def _resolve_extracted_app_dir(root: Path, exe_name: str) -> Path:
if (root / exe_name).is_file():
return root
child_dirs = [path for path in root.iterdir() if path.is_dir()]
if len(child_dirs) == 1 and (child_dirs[0] / exe_name).is_file():
return child_dirs[0]
for path in child_dirs:
if (path / exe_name).is_file():
return path
return root
@dataclass(slots=True)
class AppUpdate:
version: str
tag: str
download_url: str
size: int
notes: str
digest_sha256: str = ""
# Файлы сборки из подписанного списка выпуска (путь, размер, SHA-256).
# Есть они — часть обновления можно докачать без полного архива.
files: tuple[SignedFile, ...] = ()
# Проверенный список выпуска целиком (общее ядро zapret_update): в нём же
# размеры файлов в хранилище и заплатки от прежних версий.
manifest: object = None
# Выпуск назвал GitHub, потому что ни одно имя нашего сервера не ответило: тогда и архив
# сначала просится у GitHub, а не у недоступного сервера.
from_github: bool = False
@dataclass(slots=True)
class PreparedUpdate:
"""Скачанное, проверенное и распакованное обновление, готовое к установке."""
version: str
# Распакованная сборка: каталог с ZapretKVN.exe новой версии.
source_dir: Path
# Временный каталог загрузки целиком.
work_dir: Path
class UpdateRejected(Exception):
"""Архив непригоден, и повторная загрузка этого не исправит.
``code`` — короткая причина для сервера обновлений (``why``).
"""
def __init__(self, message: str, code: str = "bad") -> None:
super().__init__(message)
self.code = code
# Сбои, от которых помогает другой путь скачивания (напрямую / через прокси):
# сеть, ответ сервера, обрыв или неполный кусок архива.
_NETWORK_ERRORS = (OSError, http.client.HTTPException, ValueError, RuntimeError)
class DownloadFailed(RuntimeError):
"""Архив не скачался ни одним путём."""
def download_failure_code(exc: BaseException) -> str:
"""Короткая причина, почему обновление не скачалось или не распаковалось."""
if isinstance(exc, UpdateRejected):
return exc.code
if isinstance(exc, zipfile.BadZipFile):
return "badzip"
if isinstance(exc, OSError) and getattr(exc, "errno", None) == errno.ENOSPC:
return "disk"
if isinstance(exc, DownloadFailed):
return "net"
return "other"
def _note_update_failure(failure: str) -> None:
"""A failed download or check of an update as an app error (vpnbot «app_error live» 2026-11-20): its short code."""
try:
from ..client_reports import app_errors
found = app_errors.code("update", failure or "other")
if found:
app_errors.note(app_errors.AppError(app_errors.STEP_UPDATE, found))
except Exception:
pass
_SEMVER_RE = re.compile(r"(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?")
def _parse_semver(version: str) -> tuple[int, int, int, list[str]] | None:
match = _SEMVER_RE.search(version.strip().lstrip("v"))
if not match:
return None
major, minor, patch, suffix = match.groups()
prerelease = suffix.split(".") if suffix else []
return int(major), int(minor), int(patch), prerelease
def _compare_prerelease(left: list[str], right: list[str]) -> int:
if not left and not right:
return 0
if not left:
return 1
if not right:
return -1
for left_part, right_part in zip(left, right):
if left_part == right_part:
continue
left_is_num = left_part.isdigit()
right_is_num = right_part.isdigit()
if left_is_num and right_is_num:
left_num = int(left_part)
right_num = int(right_part)
if left_num != right_num:
return 1 if left_num > right_num else -1
continue
if left_is_num != right_is_num:
return -1 if left_is_num else 1
return 1 if left_part > right_part else -1
if len(left) == len(right):
return 0
return 1 if len(left) > len(right) else -1
def _is_newer_version(latest: str, current: str) -> bool:
latest_parts = _parse_semver(latest)
current_parts = _parse_semver(current)
if latest_parts is None or current_parts is None:
return latest.strip().lstrip("v") != current.strip().lstrip("v")
latest_core = latest_parts[:3]
current_core = current_parts[:3]
if latest_core != current_core:
return latest_core > current_core
return _compare_prerelease(latest_parts[3], current_parts[3]) > 0
def _extract_digest(value: str) -> str:
text = value.strip().lower()
if text.startswith("sha256:"):
text = text.split(":", 1)[1].strip()
match = re.search(r"(?<![0-9a-f])[0-9a-f]{64}(?![0-9a-f])", text)
return match.group(0) if match else ""
def _sha256_file(file_path: Path) -> str:
digest = hashlib.sha256()
with open(file_path, "rb") as file:
while True:
chunk = file.read(1024 * 1024)
if not chunk:
break
digest.update(chunk)
return digest.hexdigest()
def _is_trusted_release_url(url: str) -> bool:
try:
parsed = urlsplit(url)
port = parsed.port
except ValueError:
return False
return (
parsed.scheme.lower() == "https"
and git_mirrors.is_git_host((parsed.hostname or "").lower())
and parsed.username is None
and parsed.password is None
and port in {None, 443}
and parsed.path.startswith(FORGEJO_RELEASE_DOWNLOAD_PREFIXES)
)
def github_asset_url(download_url: str) -> str:
"""Адрес того же файла выпуска на GitHub по проверенному адресу на Forgejo; пусто — не выходит."""
try:
path = unquote(urlsplit(download_url).path)
except ValueError:
return ""
for prefix in FORGEJO_RELEASE_DOWNLOAD_PREFIXES:
if path.startswith(prefix):
tag, _, name = path[len(prefix):].partition("/")
if tag and name and "/" not in name:
return f"{GITHUB_RELEASE_DOWNLOAD_ORIGIN}{quote(tag, safe='')}/{quote(name, safe='')}"
return ""
def is_trusted_github_file_url(url: str) -> bool:
"""Файл выпуска, пришедший с GitHub: только https и его собственные хосты."""
try:
parsed = urlsplit(url)
port = parsed.port
except ValueError:
return False
return (
parsed.scheme.lower() == "https"
and (parsed.hostname or "").lower() in _GITHUB_FILE_HOSTS
and parsed.username is None
and parsed.password is None
and port in {None, 443}
)
def normalize_github_release(payload: dict) -> dict:
"""Ответ GitHub о выпуске в виде ответа Forgejo, который разбирает остальной код.
Адреса файлов записываются как у Forgejo: проверки доверия и подписи идут как
обычно, а скачивание само берёт тот же файл с GitHub (``github_asset_url``).
"""
tag = str(payload.get("tag_name") or "")
if not tag or "/" in tag or ".." in tag:
raise ValueError("GitHub вернул выпуск без корректного тега")
assets = []
for asset in payload.get("assets") or []:
name = str(asset.get("name") or "")
if not name or "/" in name or name.startswith("."):
continue
assets.append({
"name": name,
"size": asset.get("size") or 0,
"digest": str(asset.get("digest") or ""),
"browser_download_url": (
f"https://{FORGEJO_HOST}{FORGEJO_RELEASE_DOWNLOAD_PREFIXES[0]}"
f"{quote(tag, safe='')}/{quote(name, safe='')}"
),
})
return {"tag_name": tag, "assets": assets}
def _is_trusted_release_api_url(url: str) -> bool:
try:
parsed = urlsplit(url)
port = parsed.port
expected = urlsplit(FORGEJO_RELEASE_API)
except ValueError:
return False
return (
parsed.scheme.lower() == "https"
and git_mirrors.is_git_host((parsed.hostname or "").lower())
and parsed.username is None
and parsed.password is None
and port in {None, 443}
and parsed.path.rstrip("/") == expected.path.rstrip("/")
)
class _ReleaseClient:
"""Small, retrying transport for release metadata and checksums."""
def __init__(self, proxy_url: str | None = None):
self._proxy_url = proxy_url
# Выпуск взят с GitHub: его файлы и качаются оттуда в первую очередь.
self.github_fallback = False
self._mirrors = git_mirrors.MirrorList(
self._fetch_mirror_list,
report=lambda message: _log.info("[update] Forgejo, имена сервера: %s", message),
)
def _fetch_mirror_list(self, url: str) -> bytes | None:
"""Список имён сервера: одна короткая попытка на каждом маршруте."""
response = fetch_bytes(
Request(url, headers={"Accept": "application/json", "User-Agent": USER_AGENT}),
timeout=_MIRROR_LIST_TIMEOUT,
max_bytes=_MAX_MIRROR_LIST_BYTES,
proxy_url=self._proxy_url,
attempts_per_route=1,
prefer_proxy=bool(self._proxy_url),
)
return response.data
def _fetch(self, request: Request, *, max_bytes: int):
return fetch_bytes(
request,
timeout=_UPDATE_CHECK_TIMEOUT,
max_bytes=max_bytes,
proxy_url=self._proxy_url,
attempts_per_route=2,
# A connected app already has an explicit, verified local route;
# use it first so a broken public DNS/backend does not stall UI.
prefer_proxy=bool(self._proxy_url),
# Forgejo can return a route/region-specific legal-policy response.
# Do not retry it on the same route; fail over to the other egress.
fallback_http_statuses=frozenset({451}),
)
def fetch_release(self) -> dict:
try:
response = self._fetch_release_response()
except HttpFetchError as mirrors_failed:
return self._release_from_github(mirrors_failed)
if not _is_trusted_release_api_url(response.final_url):
raise ValueError("Сервер обновлений перенаправил запрос на недоверенный адрес")
payload = json.loads(response.data.decode("utf-8"))
if not isinstance(payload, dict):
raise ValueError("Сервер обновлений вернул некорректный ответ")
return payload
def _release_from_github(self, mirrors_failed: HttpFetchError) -> dict:
"""Ни одно зеркало не ответило по сети: тот же выпуск спрашивается у GitHub."""
_log.warning("[update] Зеркала Forgejo не ответили, выпуск спрашивается у GitHub")
try:
response = self._fetch(
Request(GITHUB_RELEASE_API, headers={"Accept": "application/vnd.github+json", "User-Agent": USER_AGENT}),
max_bytes=_MAX_RELEASE_METADATA_BYTES,
)
if urlsplit(response.final_url).hostname != "api.github.com":
raise ValueError("GitHub перенаправил запрос на недоверенный адрес")
payload = json.loads(response.data.decode("utf-8"))
if not isinstance(payload, dict):
raise ValueError("GitHub вернул некорректный ответ")
release = normalize_github_release(payload)
except (HttpFetchError, ValueError) as github_error:
_log.warning("[update] GitHub тоже не помог: %s: %s", type(github_error).__name__, github_error)
raise mirrors_failed from github_error
self.github_fallback = True
_log.info("[update] Выпуск %s получен с GitHub", release["tag_name"])
return release
def _fetch_release_file(self, url: str, max_bytes: int):
"""Файл выпуска: Forgejo, а при отказе сети — тот же файл на GitHub (с GitHub первым, если выпуск оттуда)."""
github = github_asset_url(url)
routes = [url]
if github:
routes = [github, url] if self.github_fallback else [url, github]
last_error: HttpFetchError | None = None
for route in routes:
try:
response = self._fetch(Request(route, headers={"User-Agent": USER_AGENT}), max_bytes=max_bytes)
except HttpFetchError as exc:
last_error = exc
continue
if not (_is_trusted_release_url(response.final_url) or is_trusted_github_file_url(response.final_url)):
raise ValueError("Файл выпуска перенаправлен на недоверенный адрес")
return response
raise last_error # type: ignore[misc] # routes не пуст: хотя бы один отказ записан
def _fetch_release_response(self):
"""Ответ о последнем выпуске под первым открытым именем сервера.
Следующее имя пробуется только когда не удался ни один маршрут (сеть,
TLS): ответ сервера вроде 404 одинаков под любым именем.
"""
started = time.monotonic()
last_error: BaseException | None = None
for host in self._mirrors.hosts():
request = Request(
git_mirrors.with_host(FORGEJO_RELEASE_API, host),
headers={"Accept": "application/json", "User-Agent": USER_AGENT},
)
try:
response = self._fetch(request, max_bytes=_MAX_RELEASE_METADATA_BYTES)
except HttpFetchError as exc:
last_error = exc
self._mirrors.note_failure(host, exc)
if time.monotonic() - started >= _MIRROR_ROUND_BUDGET_S:
break
continue
self._mirrors.remember(host)
site_names.remember(host)
return response
# Ни одно имя не ответило: список имён мог устареть.
self._mirrors.forget()
raise last_error if last_error is not None else ValueError("Нет ни одного имени сервера обновлений")
def fetch_signed(self, url: str, max_bytes: int) -> bytes:
if not _is_trusted_release_url(url):
raise ValueError("Forgejo вернул недоверенную ссылку на список выпуска")
return self._fetch_release_file(url, max_bytes).data
def fetch_checksum(self, url: str) -> str:
if not _is_trusted_release_url(url):
raise ValueError("Forgejo вернул недоверенную ссылку на контрольную сумму")
response = self._fetch_release_file(url, _MAX_CHECKSUM_BYTES)
return response.data.decode("utf-8", errors="replace")
def _find_available_update(proxy_url: str | None = None) -> AppUpdate | None:
client = _ReleaseClient(proxy_url)
try:
data = client.fetch_release()
except Exception:
# Ни Forgejo, ни зеркала не ответили: если человек включил раздачу через интернет,
# новую версию могут назвать соседи (их подписанный список проверяется той же подписью).
from . import share_wiring
try:
from_peers = share_wiring.update_from_peers()
except Exception as exc: # noqa: BLE001 — соседи не обязаны помогать
_log.info("[update] Соседи по интернету не помогли: %s", exc)
from_peers = None
if from_peers is None:
raise
_log.info("[update] Сервер выпусков не ответил; версию %s назвали соседи по интернету", from_peers.version)
return from_peers
tag = str(data.get("tag_name") or "")
if not _is_newer_version(tag, APP_VERSION):
return None
asset = None
for candidate in data.get("assets", []):
name = str(candidate.get("name") or "").lower()
if name.endswith(".zip") and "windows" in name and "x64" in name:
asset = candidate
break
if not asset:
raise ValueError(f"Релиз {tag} найден, но отсутствует Windows zip-архив")
asset_url = str(asset.get("browser_download_url") or "")
if not _is_trusted_release_url(asset_url):
raise ValueError(f"Релиз {tag} содержит недоверенную ссылку на архив")
digest = _extract_digest(str(asset.get("digest") or ""))
if not digest:
asset_name = str(asset.get("name") or "")
sidecar = None
for suffix in (".sha256", ".dgst"):
expected = f"{asset_name}{suffix}".lower()
sidecar = next(
(
candidate for candidate in data.get("assets", [])
if str(candidate.get("name") or "").lower() == expected
),
None,
)
if sidecar:
break
if sidecar:
sidecar_url = str(sidecar.get("browser_download_url") or "")
digest = _extract_digest(client.fetch_checksum(sidecar_url))
if not digest:
raise ValueError(f"Релиз {tag} найден, но архив не содержит SHA-256")
# Что качать, подтверждает только подписанный список выпуска: сумма и
# размер из Forgejo лишь сверяются с ним.
version = tag.lstrip("v")
manifest_url, signature_url = signed_asset_urls(list(data.get("assets", [])), _is_trusted_release_url)
try:
manifest = verified_manifest(
version=version,
current_version=APP_VERSION,
manifest_url=manifest_url,
signature_url=signature_url,
fetch=client.fetch_signed,
)
except ManifestError as exc:
raise UpdateRejected(f"Релиз {tag} не прошёл проверку подписи: {exc}", exc.code) from None
archive = manifest.installer
size = int(asset.get("size") or 0)
if archive.name != str(asset.get("name") or "") or archive.sha256 != digest or (size and archive.size != size):
raise UpdateRejected(f"Forgejo описал архив {tag} иначе, чем подписанный список выпуска", "sign")
return AppUpdate(
version=version,
tag=tag,
download_url=asset_url,
size=archive.size,
notes=str(data.get("body") or ""),
digest_sha256=archive.sha256,
files=tuple(SignedFile(item.path, item.size, item.sha256) for item in manifest.files),
manifest=manifest,
from_github=client.github_fallback,
)
def _describe_update_check_error(error: BaseException, *, has_proxy: bool) -> str:
if isinstance(error, HttpFetchError):
if any(
isinstance(cause, urllib.error.HTTPError) and cause.code == 451
for cause in error.causes
):
if has_proxy:
return (
"Сервер обновлений недоступен в текущем регионе. "
"Переключитесь на другой сервер и повторите попытку."
)
return (
"Сервер обновлений недоступен напрямую в текущем регионе. "
"Подключитесь к серверу и повторите попытку."
)
if has_proxy:
return (
"Не удалось связаться с сервером обновлений напрямую и через прокси. "
"Проверьте подключение или переключитесь на рабочий сервер."
)
return (
"Сервер обновлений временно не отвечает. "
"Проверьте подключение и повторите попытку."
)
if isinstance(error, HttpResponseTooLarge):
return "Сервер обновлений вернул слишком большой ответ"
if isinstance(error, json.JSONDecodeError):
return "Сервер обновлений вернул некорректный ответ"
if isinstance(error, urllib.error.HTTPError):
return f"Сервер обновлений ответил с ошибкой HTTP {error.code}"
if isinstance(error, (urllib.error.URLError, TimeoutError, ConnectionError, OSError)):
return (
"Не удалось установить защищённое соединение с сервером обновлений. "
"Проверьте подключение и повторите попытку."
)
return str(error) or "Не удалось проверить обновления"
class UpdateChecker(QThread):
"""Check the project Forgejo for a newer release."""
result = pyqtSignal(object) # AppUpdate | None
error = pyqtSignal(str)
def __init__(self, proxy_url: str | None = None, parent=None):
super().__init__(parent)
self._proxy_url = proxy_url
def run(self) -> None:
try:
self.result.emit(_find_available_update(self._proxy_url))
except Exception as exc:
_log.warning("Update check failed: %s", exc, exc_info=True)
self.error.emit(
_describe_update_check_error(exc, has_proxy=bool(self._proxy_url))
)
return
_DOWNLOAD_TIMEOUT = 30 # seconds — per socket operation (connect + each read)
_NUM_SEGMENTS = 4 # parallel download segments
_CHUNK_SIZE = 1024 * 1024 # 1 MB
def _format_megabytes(size: int) -> str:
return f"{size / (1024 * 1024):.1f}".replace(".", ",") + " МБ"
def _purge_stale_update_dirs(prefix: str = WORK_DIR_PREFIX, keep: int = 0) -> int:
"""Удалить каталоги прошлых загрузок.
Каждый хранит архив и распакованную сборку — сотни мегабайт; прерванные
попытки без уборки накапливали у пользователей гигабайты.
"""
root = Path(tempfile.gettempdir())
removed = 0
try:
candidates = sorted(
(item for item in root.glob(f"{prefix}*") if item.is_dir()),
key=lambda item: item.stat().st_mtime,
reverse=True,
)
except OSError:
return 0
for stale in candidates[keep:]:
before = stale.exists()
shutil.rmtree(stale, ignore_errors=True)
if before and not stale.exists():
removed += 1
return removed
class UpdateDownloader(QThread):
"""Download, verify and unpack the update."""
progress = pyqtSignal(int) # percent 0-100
status = pyqtSignal(str) # human-readable status message
finished_ok = pyqtSignal()
error = pyqtSignal(str)
def __init__(
self,
update: AppUpdate,
proxy_url: str | None = None,
parent=None,
app_dir: Path | None = None,
):
super().__init__(parent)
self._update = update
self._proxy_url = proxy_url
# Установленная копия: из неё берутся файлы, не изменившиеся в новой версии.
self._app_dir = BASE_DIR if app_dir is None else app_dir
self.prepared: PreparedUpdate | None = None
# Какой ступенью скачано (files/parts/setup) и сколько байт — для отчёта серверу.
self.via = ""
self.downloaded = 0
# Сбой, который повторится при любой следующей загрузке этого же
# архива (контрольная сумма, содержимое). Сетевые ошибки — нет.
self.failure_permanent = False
# Короткая причина неудачи для сервера обновлений.
self.failure_code = ""
@property
def update(self) -> AppUpdate:
return self._update
# ── download helpers ────────────────────────────────────────
def _build_opener(self, proxy_url: str | None) -> urllib.request.OpenerDirector:
if proxy_url:
handler = urllib.request.ProxyHandler({"http": proxy_url, "https": proxy_url})
return build_opener(handler)
return build_opener(urllib.request.ProxyHandler({}))
def _supports_range(self, url: str, opener: urllib.request.OpenerDirector) -> tuple[bool, int]:
"""HEAD request to check Range support and get Content-Length."""
req = Request(url, method="HEAD", headers={"User-Agent": USER_AGENT})
with opener.open(req, timeout=_DOWNLOAD_TIMEOUT) as resp:
accepts = resp.headers.get("Accept-Ranges", "").lower()
length = int(resp.headers.get("Content-Length", 0))
return accepts == "bytes" and length > 0, length
def _download_segment(
self,
url: str,
proxy_url: str | None,
start: int,
end: int,
seg_path: Path,
seg_index: int,
lock: threading.Lock,
progress_arr: list[int],
total: int,
) -> None:
"""Download one segment with Range header."""
opener = self._build_opener(proxy_url)
expected_length = end - start + 1
req = Request(url, headers={
"User-Agent": USER_AGENT,
"Range": f"bytes={start}-{end}",
})
with opener.open(req, timeout=_DOWNLOAD_TIMEOUT) as resp:
status_code = getattr(resp, "status", None)
content_range = resp.headers.get("Content-Range", "")
if status_code != 206 or not content_range.startswith(f"bytes {start}-{end}/"):
raise RuntimeError("Сервер некорректно ответил на Range-запрос")
downloaded = 0
with open(seg_path, "wb") as f:
while True:
chunk = resp.read(_CHUNK_SIZE)
if not chunk:
break
f.write(chunk)
downloaded += len(chunk)
with lock:
progress_arr[seg_index] += len(chunk)
done = sum(progress_arr)
self.progress.emit(int(done * 100 / total))
if downloaded != expected_length:
raise RuntimeError("Сервер вернул неполный фрагмент архива")
def _download_single(self, url: str, opener: urllib.request.OpenerDirector, zip_path: Path) -> None:
"""Single-connection fallback download."""
req = Request(url, headers={"User-Agent": USER_AGENT})
with opener.open(req, timeout=_DOWNLOAD_TIMEOUT) as resp:
total = int(resp.headers.get("Content-Length", 0))
downloaded = 0
with open(zip_path, "wb") as f:
while True:
chunk = resp.read(_CHUNK_SIZE)
if not chunk:
if downloaded == 0:
raise TimeoutError("Сервер не отдаёт данные")
break
f.write(chunk)
downloaded += len(chunk)
if total > 0:
self.progress.emit(int(downloaded * 100 / total))
def _archive_urls(self) -> tuple[str, ...]:
"""Откуда качать архив: сначала наш сервер (Forgejo, под которым ответила проверка), затем копия на GitHub.
Наш сервер быстрее GitHub, а GitHub с российских адресов часто отдаёт файл тонкой струйкой:
сокет не отваливается по таймауту, а полоса показывает 0% (решение владельца 2026-11-08,
раньше с 2026-11-03 порядок был обратным). Исключение: выпуск назван GitHub, когда сервер
не отвечает, тогда сначала GitHub.
"""
github = github_asset_url(self._update.download_url)
if not github:
return (self._update.download_url,)
if self._update.from_github:
return (github, self._update.download_url)
return (self._update.download_url, github)
def _download(self, zip_path: Path, proxy_url: str | None, url: str | None = None) -> None:
"""Download update zip with multi-segment acceleration.
Tries parallel Range-based download first; falls back to single
connection if the server doesn't support Range requests.
"""
url = url or self._update.download_url
opener = self._build_opener(proxy_url)
# Check if server supports Range requests
try:
supports_range, total = self._supports_range(url, opener)
except Exception:
supports_range, total = False, 0
if not supports_range or total == 0 or total < _NUM_SEGMENTS * _CHUNK_SIZE:
_log.info("Server does not support Range or file too small — single download")
self._download_single(url, opener, zip_path)
return
# Split into segments
seg_size = total // _NUM_SEGMENTS
segments: list[tuple[int, int]] = []
for i in range(_NUM_SEGMENTS):
start = i * seg_size
end = total - 1 if i == _NUM_SEGMENTS - 1 else (i + 1) * seg_size - 1
segments.append((start, end))
# Prepare temp segment files
seg_dir = zip_path.parent / "_segments"
seg_dir.mkdir(exist_ok=True)
seg_paths = [seg_dir / f"seg_{i}" for i in range(_NUM_SEGMENTS)]
lock = threading.Lock()
progress_arr = [0] * _NUM_SEGMENTS
# Download segments in parallel
try:
with ThreadPoolExecutor(max_workers=_NUM_SEGMENTS) as pool:
futures = []
for i, (start, end) in enumerate(segments):
fut = pool.submit(
self._download_segment,
url, proxy_url, start, end,
seg_paths[i], i, lock, progress_arr, total,
)
futures.append(fut)
# Re-raise any segment exception
for fut in futures:
fut.result()
# Concatenate segments into final file
with open(zip_path, "wb") as out:
for sp in seg_paths:
with open(sp, "rb") as seg_f:
shutil.copyfileobj(seg_f, out)
except Exception as exc:
_log.warning("Segmented download failed, falling back to single download: %s", exc)
if zip_path.exists():
zip_path.unlink()
self.progress.emit(0)
self._download_single(url, opener, zip_path)
finally:
# Clean up segment temp files
shutil.rmtree(seg_dir, ignore_errors=True)
# ── thread entry ────────────────────────────────────────────
def run(self) -> None:
work_dir: Path | None = None
try:
_purge_stale_update_dirs()
work_dir = Path(tempfile.mkdtemp(prefix=WORK_DIR_PREFIX))
archive = work_dir / "update.zip"
# Лестница: хранилище с заплатками (меньше всего байт) → куски
# архива по Range → архив целиком.
source_dir = self._try_store() or self._try_delta(work_dir)
if source_dir is None:
self.via, self.downloaded = "setup", int(self._update.size)
self._fetch(archive)
self._verify(archive)
source_dir = self._unpack(archive, work_dir / "extracted")
# Дальше архив не нужен, а места занимает столько же, сколько сборка.
archive.unlink(missing_ok=True)
self.prepared = PreparedUpdate(self._update.version, source_dir, work_dir)
except Exception as exc:
self.failure_permanent = isinstance(exc, (UpdateRejected, zipfile.BadZipFile))
self.failure_code = download_failure_code(exc)
_note_update_failure(self.failure_code)
if work_dir is not None:
shutil.rmtree(work_dir, ignore_errors=True)
self.error.emit(str(exc) or "Не удалось подготовить обновление")
return
self.finished_ok.emit()
def _routes(self) -> list[tuple[str, str | None]]:
routes: list[tuple[str, str | None]] = [("Загрузка напрямую...", None)]
if self._proxy_url:
routes.append(("Загрузка через прокси...", self._proxy_url))
return routes
def _try_store(self) -> Path | None:
"""Собрать новую версию из хранилища выпуска: изменившиеся файлы и заплатки.
Хранилище и порядок те же, что у Zapret 2 GUI (общее ядро
``zapret_update``). Куски лежат в ``data/runtime/app_update/store-<версия>``:
оборванная загрузка продолжается и после перезапуска программы.
``None`` — у выпуска нет хранилища или загрузка не удалась; тогда
следующая ступень — куски архива по Range.
"""
manifest = self._update.manifest
files = getattr(manifest, "files", ())
if not files or not all(entry.zsize for entry in files):
return None
from zapret_update import fetch, plan as update_plan, share_client, stage, store
from . import share_wiring
cache = self._app_dir / "data" / "runtime" / STAGE_ROOT_NAME / f"store-{self._update.version}"
# Соседи по сети ищутся в фоне, пока считается план (zapret_update.share_*);
# выключатель в настройках отключает и раздачу, и этот вопрос.
neighbours = share_client.start_search(PRODUCT, self._update.version, enabled=share_wiring.is_enabled())
try:
self.status.emit("Сравнение с установленной версией...")
planned = update_plan.make_plan(
manifest, self._app_dir, hashes=update_plan.HashCache(cache.parent / "hashes.json")
)
except (update_plan.PlanError, OSError) as exc:
_log.info("[update] Хранилище выпуска не подходит: %s", exc)
return None
# Имя сервера — то, под которым ответила проверка обновления (основное режут по TLS).
store_host = git_mirrors.host_of(self._update.download_url)
if not git_mirrors.is_git_host(store_host):
store_host = FORGEJO_HOST
url_for = lambda name: store.forgejo_url(f"https://{store_host}", "zapretkvn", "zapret-kvn", name) # noqa: E731
sources = [fetch.Source("Forgejo", url_for)]
if self._proxy_url:
sources.append(fetch.Source("Forgejo через прокси", url_for, proxy=self._proxy_url))
self.status.emit(
f"Загрузка изменений: {_format_megabytes(planned.download_size)} из {_format_megabytes(self._update.size)}..."
)
self.progress.emit(0)
share_client.fill_from_neighbours(
planned,
work_dir=cache,
search=neighbours,
cancelled=self.isInterruptionRequested,
on_stage=self.status.emit,
report=_log.info,
)
def download():
return fetch.fetch_plan(
planned,
root=self._app_dir,
work_dir=cache,
sources=sources,
timeout=_DOWNLOAD_TIMEOUT,
cancelled=self.isInterruptionRequested,
progress=lambda done, total: self.progress.emit(min(99, int(done * 100 / max(1, total)))),
)
try:
try:
ready = download()
except fetch.FetchError:
# Серверы файлы не отдали: если человек включил раздачу по интернету, берём недостающее
# у таких же копий. Пока серверы живы, адрес человека соседям по интернету не показывается.
find = share_wiring.internet_finder(self._update.version)
if find is None:
raise
taken = share_client.fill_from_internet(
planned, work_dir=cache, find=find, cancelled=self.isInterruptionRequested,
on_stage=self.status.emit, report=_log.info,
)
if not taken.files:
raise
ready = download()
tree = stage.build_stage(planned, root=self._app_dir, ready=ready, stage_dir=cache / "tree")
except Exception as exc: # noqa: BLE001 — любой сбой ведёт на следующую ступень
_log.warning("[update] Загрузка из хранилища не удалась, пробуем куски архива: %s", exc)
return None
if not (tree / APP_EXE_NAME).is_file():
_log.warning("[update] В собранной из хранилища версии нет %s", APP_EXE_NAME)
return None
self.via, self.downloaded = "files", int(planned.download_size)
kinds: dict[str, int] = {}
for item in planned.want:
if item.patch is not None:
kinds[item.patch.kind] = kinds.get(item.patch.kind, 0) + 1
detail = f" ({', '.join(f'{kind} {count}' for kind, count in sorted(kinds.items()))})" if kinds else ""
_log.info(
"[update] Из хранилища: скачано %d из %d байт (файлов %d, заплаток %d%s, без изменений %d)",
planned.download_size, self._update.size, len(planned.want),
sum(kinds.values()), detail, len(planned.keep),
)
self.progress.emit(100)
return tree
def _try_delta(self, work_dir: Path) -> Path | None:
"""Собрать новую сборку, докачав только изменившиеся файлы.
``None`` — частичная загрузка не получилась по любой причине, и вызывающий
код скачивает архив целиком. Целостность держится на подписанном
списке выпуска, см. ``delta_zip``.
"""
update = self._update
if not update.files or update.size <= 0:
return None
for url in self._archive_urls():
source_dir = self._try_delta_from(url, work_dir)
if source_dir is not None:
return source_dir
return None
def _try_delta_from(self, url: str, work_dir: Path) -> Path | None:
"""Частичная загрузка из одного места (GitHub или Forgejo); ``None`` — не вышло."""
update = self._update
destination = work_dir / "extracted"
for status, proxy_url in self._routes():
self.status.emit("Сравнение с установленной версией...")
self.progress.emit(0)
source = HttpRangeSource(
url,
self._build_opener(proxy_url),
total=update.size,
user_agent=USER_AGENT,
timeout=_DOWNLOAD_TIMEOUT,
)
try:
stats = prepare_delta(
source=source,
total_size=update.size,
signed=update.files,
local_root=self._app_dir,
destination=destination,
work_dir=work_dir / "_delta",
announce=lambda wanted, full: self.status.emit(
f"Загрузка изменений: {_format_megabytes(wanted)} из {_format_megabytes(full)}..."
),
progress=lambda done, wanted: self.progress.emit(min(99, int(done * 100 / max(1, wanted)))),
)
source_dir = _resolve_extracted_app_dir(destination, APP_EXE_NAME)
if not (source_dir / APP_EXE_NAME).is_file():
raise DeltaUnavailable(f"в собранной версии нет {APP_EXE_NAME}")
except _NETWORK_ERRORS as exc:
_log.warning("[update] Частичная загрузка не удалась (%s): %s", status, exc)
shutil.rmtree(destination, ignore_errors=True)
continue
except DeltaUnavailable as exc:
_log.info("[update] Частичная загрузка не подходит, качаем архив целиком: %s", exc)
shutil.rmtree(destination, ignore_errors=True)
return None
except Exception:
_log.warning("[update] Частичная загрузка сорвалась, качаем архив целиком", exc_info=True)
shutil.rmtree(destination, ignore_errors=True)
return None
_log.info(
"[update] Частичная загрузка: скачано %d из %d байт (файлов из архива %d, из установленной копии %d, запросов %d)",
stats.downloaded, stats.full_size, stats.fetched_files, stats.reused_files, stats.requests,
)
self.via, self.downloaded = "parts", int(stats.downloaded)
self.progress.emit(100)
return source_dir
shutil.rmtree(destination, ignore_errors=True)
return None
def _fetch(self, archive: Path) -> None:
"""Скачать архив напрямую, а при неудаче — через активный прокси."""
routes = self._routes()
for url in self._archive_urls():
from_github = url != self._update.download_url
for status, proxy_url in routes:
self.status.emit(status)
self.progress.emit(0)
try:
self._download(archive, proxy_url, url)
except _NETWORK_ERRORS as exc:
# Другой путь помогает только от сетевых сбоев; ошибка в самой
# программе поднимается как есть, а не выдаётся за «нет сети».
_log.warning("[update] Архив не скачался (%s%s): %s", status, ", GitHub" if from_github else "", exc)
archive.unlink(missing_ok=True)
continue
expected = _extract_digest(self._update.digest_sha256)
if from_github and expected and _sha256_file(archive).lower() != expected:
# Копия на GitHub не та — берём файл с Forgejo, а не отказываем в обновлении.
_log.warning("[update] Архив с GitHub не сошёлся по SHA-256, качаем с Forgejo")
archive.unlink(missing_ok=True)
break
return
if self._proxy_url:
raise DownloadFailed(
"Не удалось скачать обновление ни напрямую, ни через прокси.\n"
"Переключитесь на рабочий сервер и попробуйте снова."
)
raise DownloadFailed(
"Не удалось скачать обновление.\n"
"Переключитесь на рабочий сервер и попробуйте снова."
)
def _verify(self, archive: Path) -> None:
self.status.emit("Проверка архива...")
expected = _extract_digest(self._update.digest_sha256)
if not expected:
raise UpdateRejected("У релизного архива отсутствует SHA-256", "meta")
if _sha256_file(archive).lower() != expected:
raise UpdateRejected("Контрольная сумма архива не совпадает", "hash")
self.progress.emit(100)
def _unpack(self, archive: Path, destination: Path) -> Path:
self.status.emit("Распаковка...")
with zipfile.ZipFile(archive, "r") as bundle:
bundle.extractall(destination)
source_dir = _resolve_extracted_app_dir(destination, APP_EXE_NAME)
if not (source_dir / APP_EXE_NAME).is_file():
raise UpdateRejected(f"Архив обновления не содержит {APP_EXE_NAME}", "badzip")
return source_dir