zapret-kvn/xray_fluent/updates/share_wiring.py
2026-11-08 14:45:18 -05:00

269 lines
12 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.

"""Раздача обновлений в Zapret KVN: что подставить в общий ``SharingService``.
Сама раздача (сервер файлов, поиск соседей, правило брандмауэра) лежит в общем
ядре ``zapret_update`` (``share_*``) и одинакова с Zapret 2 GUI. Здесь только
то, что знает одна эта программа: где она стоит, как называется продукт, откуда
взять включённость, подписанный список версии и куда писать журнал.
Подписанный список установленной версии лежит в ``data/runtime``: папка
``data`` обновление не трогает. Списка нет или он от другой версии — программа
берёт его сама, как только последний выпуск совпал с запущенной версией.
"""
from __future__ import annotations
import logging
import sys
import threading
from pathlib import Path
from types import SimpleNamespace
from zapret_update import share_adopt, share_discover, share_internet, share_manifest, share_peers, share_service
from zapret_update.manifest import MAX_MANIFEST_BYTES, ManifestError, load_signed
from ..constants import APP_VERSION, BASE_DIR
from .installer.plan import APP_EXE_NAME
from .signed_release import CHANNEL, MAX_SIGNATURE_BYTES, PRODUCT, TRUSTED_KEYS, signed_asset_urls
_log = logging.getLogger(__name__)
INSTALLED_LIST = ("data", "runtime", "installed-manifest.json")
PEER_BOOK = ("data", "runtime", "update-peers.json")
_lock = threading.Lock()
_service: share_service.SharingService | None = None
_enabled = True
_internet = False
_book: share_peers.PeerBook | None = None
_book_lock = threading.Lock()
def is_enabled() -> bool:
return _enabled
def is_internet_enabled() -> bool:
return _internet
def peer_book() -> share_peers.PeerBook:
"""Книга соседей по интернету: в ``data/runtime``, которую обновление не трогает."""
global _book
with _book_lock:
if _book is None:
usable = sys.platform == "win32" and (BASE_DIR / APP_EXE_NAME).is_file()
_book = share_peers.PeerBook(Path(BASE_DIR).joinpath(*PEER_BOOK) if usable else None)
return _book
def registry_bases() -> list[str]:
"""Где сервер очереди ведёт книгу раздающих: тот же адрес, что и у вопроса об обновлениях."""
from . import release_watch, site_names
url = site_names.resolve(release_watch.WAIT_URL)
return [url[: -len("/wait")]] if url.endswith("/wait") else []
def activity_snapshot() -> dict:
"""Что показывает вкладка «Кто подключается»: состояние раздачи и журнал событий.
Только читает уже созданное в памяти (службу не создаёт и на диск не ходит): вкладка
спрашивает это каждые пару секунд. Службы ещё нет — «пока ничего».
"""
service = _service
if service is None:
return {"available": False}
side = service._internet
mapping = getattr(side, "mapping", None) if side is not None else None
notes = [text for _when, text in list(service.notes) + (list(side.notes) if side is not None else [])]
return {
"available": True,
"lan_port": service.port,
"lan_switch": service.switches[0],
"internet_switch": service.switches[1],
"internet_running": service.internet_running,
"internet_address": f"{mapping.external_ip}:{mapping.external_port}" if mapping is not None else "",
"notes": notes[-6:],
"events": service.activity.snapshot(),
"summary": service.activity.summary(),
}
def clear_activity() -> None:
if _service is not None:
_service.activity.clear()
def manifest_blob():
"""Подписанный список своей версии (текст и подпись) для соседей без доступа к серверам; нет — ``None``."""
path = Path(BASE_DIR).joinpath(*INSTALLED_LIST)
try:
return path.read_bytes(), path.with_name(path.name + ".sig").read_bytes()
except OSError:
return None
def update_from_peers():
"""Новая версия, названная соседями по интернету, когда сервер выпусков не ответил; иначе ``None``.
Работает только при включённой раздаче через интернет. Обновление собирается из
ПРОВЕРЕННОГО подписанного списка (имя архива, размер, SHA-256, файлы), а адрес архива —
обычный адрес выпуска на Forgejo, собранный здесь, а не присланный соседом.
"""
if not _internet:
return None
from urllib.parse import quote
from .app_updater import FORGEJO_HOST, FORGEJO_RELEASE_DOWNLOAD_PREFIXES, AppUpdate, SignedFile
neighbours = share_internet.find_internet_neighbours(peer_book(), PRODUCT, None, bases=registry_bases())
found = share_manifest.fetch_from_peers(
neighbours, trusted=TRUSTED_KEYS, product=PRODUCT, channel=CHANNEL, current_version=APP_VERSION
)
if found is None or found.manifest.installer is None:
return None
manifest, archive = found.manifest, found.manifest.installer
tag = f"v{manifest.version}"
return AppUpdate(
version=manifest.version,
tag=tag,
download_url=f"https://{FORGEJO_HOST}{FORGEJO_RELEASE_DOWNLOAD_PREFIXES[0]}{quote(tag, safe='')}/{quote(archive.name, safe='')}",
size=archive.size,
notes="",
digest_sha256=archive.sha256,
files=tuple(SignedFile(item.path, item.size, item.sha256) for item in manifest.files),
manifest=manifest,
)
def internet_finder(version: str):
"""Поиск соседей по интернету для запасного пути или ``None``, если человек не включил раздачу."""
if not _internet:
return None
return lambda: share_internet.find_internet_neighbours(peer_book(), PRODUCT, version, bases=registry_bases())
def installed_manifest(root: Path):
"""Подписанный список установленной версии или ``None``."""
path = Path(root).joinpath(*INSTALLED_LIST)
try:
return load_signed(
path.read_bytes(),
path.with_name(path.name + ".sig").read_bytes(),
trusted=TRUSTED_KEYS,
product=PRODUCT,
channel=CHANNEL,
allow_same=True,
)
except (OSError, ValueError):
return None
def _lookup(_channel: str):
"""Новейший выпуск, как его видит проверка обновления (Forgejo и зеркала)."""
from .app_updater import _ReleaseClient
client = _ReleaseClient(None)
try:
data = client.fetch_release()
except Exception as exc: # noqa: BLE001
return SimpleNamespace(release=None, error=str(exc))
release = {
"version": str(data.get("tag_name") or "").lstrip("v"),
"assets": list(data.get("assets") or []),
"client": client,
}
return SimpleNamespace(release=release, error="")
def _fetch(release, *, channel: str, current_version: str, allow_same: bool):
"""Подписанный список этого выпуска: с байтами и подписью, чтобы сохранить."""
from .app_updater import _is_trusted_release_url
manifest_url, signature_url = signed_asset_urls(release["assets"], _is_trusted_release_url)
if not manifest_url or not signature_url:
raise ManifestError("в выпуске нет подписанного списка", "nosig")
client = release["client"]
raw = client.fetch_signed(manifest_url, MAX_MANIFEST_BYTES)
signature = client.fetch_signed(signature_url, MAX_SIGNATURE_BYTES)
manifest = load_signed(
raw, signature, trusted=TRUSTED_KEYS, product=PRODUCT, channel=CHANNEL,
newer_than=current_version, allow_same=allow_same,
)
return SimpleNamespace(manifest=manifest, raw=bytes(raw), signature=bytes(signature))
def default_service() -> share_service.SharingService:
global _service
with _lock:
if _service is None:
root = BASE_DIR if sys.platform == "win32" and (BASE_DIR / APP_EXE_NAME).is_file() else None
report = _log.info
exe = (root / APP_EXE_NAME) if root else None
side = share_internet.InternetSide(
product=PRODUCT,
book=peer_book(),
bases=registry_bases,
open_firewall=(
lambda port: share_service.windows_open_firewall(
exe, name=share_service.FIREWALL_RULE_NAME_INTERNET, remote="any", port=port
)
)
if exe
else None,
close_firewall=lambda: share_service.windows_close_firewall(share_service.FIREWALL_RULE_NAME_INTERNET),
report=report,
)
_service = share_service.SharingService(
root=root,
enabled=is_enabled,
load_installed=lambda: installed_manifest(root) if root else None,
product=PRODUCT,
current_version=APP_VERSION,
adopt=lambda: share_adopt.adopt_installed_list(
root,
channel=CHANNEL,
version=APP_VERSION,
list_path=INSTALLED_LIST,
lookup=_lookup,
fetch=_fetch,
report=report,
)
if root
else None,
exe_path=exe,
private_network=share_service.windows_private_network,
open_firewall=share_service.windows_open_firewall,
discovery_port=share_discover.DISCOVERY_PORT_KVN,
report=report,
internet_enabled=is_internet_enabled,
internet=side,
manifest_blob=manifest_blob,
)
return _service
def apply_setting(enabled: bool, internet: bool = False, *, wait: bool = False) -> None:
"""Выключатели изменились (или программа запустилась): включить или закрыть обе раздачи.
Поход в сеть и Windows-команды идут в фоновом потоке, чтобы окно не ждало.
"""
global _enabled, _internet
_enabled, _internet = bool(enabled), bool(internet)
def run() -> None:
try:
default_service().refresh()
except Exception as exc: # noqa: BLE001 — раздача не должна ронять программу
_log.warning("[share] раздача обновлений не переключилась: %s", exc)
thread = threading.Thread(target=run, name="update-share", daemon=True)
thread.start()
if wait:
thread.join()
__all__ = [
"INSTALLED_LIST", "activity_snapshot", "apply_setting", "clear_activity", "default_service", "installed_manifest", "internet_finder", "is_enabled",
"is_internet_enabled", "manifest_blob", "peer_book", "registry_bases", "update_from_peers",
]