zapretgui/tests/test_update_share_activity.py
loop-uh 0a2460692d
All checks were successful
Zapret source guards / validate (push) Successful in 7s
Windows-сборка / Dev Dev 21.1.7.235 опубликован
Страница «Кто подключается»: видно, кто и откуда берёт файлы обновления у этого компьютера
Раздача работала без окон, и человек не видел, что происходит. Теперь на странице
«Серверы» есть кнопка «Кто подключается» (вложенная страница с хлебными крошками):

- состояние раздачи по сети и через интернет (порт, ваш адрес для других);
- что сказала программа, если часть раздачи не работает (например, роутер отказал);
- журнал обращений: когда, откуда (локальная сеть или интернет), с какого адреса,
  что просили (файл из подписанного списка, обмен адресами, подписанный список,
  вопрос в сети «у кого есть версия?»), сколько байт ушло и чем кончилось; свои
  скачивания у других тоже видны («От вас»);
- журнал хранится только в памяти, пока программа запущена: адреса на диск не пишутся;
  кнопка «Очистить журнал». Страну и город не показываем: офлайн-базы адресов в проекте нет.

Журнал ведёт общее ядро (share_activity), поэтому его получит и Zapret KVN.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-08 13:27:17 -05:00

230 lines
9 KiB
Python

from __future__ import annotations
"""Журнал раздачи: кто к нам обращался и к кому ходили мы (только в памяти, без записи на диск)."""
import hashlib
import http.client
import os
import socket
import time
from types import SimpleNamespace
import pytest
from zapret_update import share_activity, share_cert, share_discover, share_prefill, share_serve, share_service
from zapret_update.manifest import FileEntry
from zapret_update.plan import UpdatePlan, Want
BIG = 64 * 1024
def test_log_keeps_newest_first_and_a_fixed_number_of_events() -> None:
log = share_activity.ActivityLog(3, now=iter(range(1, 100)).__next__)
for index in range(5):
log.add("in", "lan", f"10.0.0.{index}", "file", f"f{index}", index)
events = log.snapshot()
assert [e.peer for e in events] == ["10.0.0.4", "10.0.0.3", "10.0.0.2"] and events[0].when > events[1].when
log.clear()
assert log.snapshot() == []
def test_long_text_is_cut_and_sizes_are_never_negative() -> None:
log = share_activity.ActivityLog()
log.add("in", "lan", "x" * 500, "file", "y" * 900, -5)
event = log.snapshot()[0]
assert len(event.peer) <= 64 and len(event.detail) <= 200 and event.size == 0
def test_summary_counts_visitors_bytes_and_internet_events() -> None:
log = share_activity.ActivityLog()
log.add("in", "lan", "10.0.0.1", "search") # вопрос в сети — не гость
log.add("in", "lan", "10.0.0.2", "file", "a", 100)
log.add("in", "internet", "93.184.216.34", "file", "b", 200)
log.add("in", "internet", "93.184.216.34", "peers", "", 30)
log.add("in", "lan", "10.0.0.3", "file", "c", 999, "not_found") # не отдано: в байты не идёт
log.add("out", "lan", "10.0.0.9", "file", "d", 50)
log.add("out", "lan", "10.0.0.9", "file", "e", 70, "failed")
assert log.summary() == {"events": 7, "visitors": 3, "given_bytes": 330, "taken_bytes": 50, "internet_events": 2}
def _server(tmp_path, *, tls=False, via="lan", **kw):
data = os.urandom(BIG)
(tmp_path / "a.bin").write_bytes(data)
entry = FileEntry("_internal/a.bin", len(data), hashlib.sha256(data).hexdigest(), len(data))
(tmp_path / "_internal").mkdir()
(tmp_path / "_internal" / "a.bin").write_bytes(data)
log = share_activity.ActivityLog()
server = share_serve.ShareServer(
share_serve.InstalledFiles(tmp_path, [entry]), host="127.0.0.1", allow_loopback=True, activity=log, via=via,
ssl_context=share_cert.server_context() if tls else None, **kw,
)
server.start()
return server, log, entry
def _get(server, target, *, tls=False):
connection = (
http.client.HTTPSConnection("127.0.0.1", server.port, timeout=5, context=share_cert.client_context())
if tls else http.client.HTTPConnection("127.0.0.1", server.port, timeout=5)
)
connection.request("GET", target)
reply = connection.getresponse()
body = reply.read()
connection.close()
return reply.status, body
def test_file_request_is_recorded_with_the_name_from_the_signed_list_and_the_size(tmp_path) -> None:
server, log, entry = _server(tmp_path)
try:
assert _get(server, share_serve.ROUTE + entry.sha256)[0] == 200
for _ in range(40):
if log.snapshot():
break
time.sleep(0.05)
finally:
server.stop()
event = log.snapshot()[0]
assert (event.direction, event.via, event.peer, event.what) == ("in", "lan", "127.0.0.1", "file")
assert (event.detail, event.size, event.result) == ("_internal/a.bin", BIG, "ok")
def test_refused_missing_and_foreign_requests_are_recorded_too(tmp_path) -> None:
data = os.urandom(10)
(tmp_path / "x.bin").write_bytes(data)
log = share_activity.ActivityLog()
strict = share_serve.ShareServer( # loopback не разрешён: чужой адрес
share_serve.InstalledFiles(tmp_path, []), host="127.0.0.1", activity=log
)
strict.start()
try:
assert _get(strict, "/anything")[0] == 403
finally:
strict.stop()
open_server, log2, _ = _server(tmp_path / "o") if (tmp_path / "o").mkdir() is None else None
try:
assert _get(open_server, share_serve.ROUTE + "f" * 64)[0] == 404
assert _get(open_server, "/nonsense")[0] == 404
for _ in range(40):
if len(log2.snapshot()) >= 2:
break
time.sleep(0.05)
finally:
open_server.stop()
assert [(e.what, e.result) for e in log.snapshot()] == [("request", "refused")]
assert sorted((e.what, e.result) for e in log2.snapshot()) == [("file", "not_found"), ("request", "not_found")]
def test_internet_server_labels_its_events_and_records_peer_exchange_and_the_signed_list(tmp_path) -> None:
server, log, _ = _server(
tmp_path, tls=True, via="internet", peers_provider=lambda: [("93.184.216.34", 45000)], identity=("p", "1"),
manifest_provider=lambda: (b"LIST", b"SIG"),
)
try:
assert _get(server, share_peers_route(), tls=True)[0] == 200
assert _get(server, share_manifest_route(), tls=True)[0] == 200
for _ in range(40):
if len(log.snapshot()) >= 2:
break
time.sleep(0.05)
finally:
server.stop()
assert sorted((e.via, e.what, e.result) for e in log.snapshot()) == [("internet", "manifest", "ok"), ("internet", "peers", "ok")]
assert all(e.size > 0 for e in log.snapshot())
def share_peers_route():
from zapret_update import share_peers
return share_peers.PEERS_ROUTE
def share_manifest_route():
from zapret_update import share_manifest
return share_manifest.MANIFEST_ROUTE
def test_a_receiver_that_leaves_halfway_is_recorded_as_interrupted(tmp_path) -> None:
data = os.urandom(48 * 1024 * 1024)
(tmp_path / "big.bin").write_bytes(data)
entry = FileEntry("big.bin", len(data), hashlib.sha256(data).hexdigest(), len(data))
log = share_activity.ActivityLog()
server = share_serve.ShareServer(
share_serve.InstalledFiles(tmp_path, [entry]), host="127.0.0.1", allow_loopback=True, activity=log
)
server.start()
try:
sock = socket.create_connection(("127.0.0.1", server.port), timeout=5)
sock.sendall(f"GET {share_serve.ROUTE}{entry.sha256} HTTP/1.0\r\n\r\n".encode())
sock.recv(4096)
sock.close() # ушёл, не дочитав
for _ in range(100):
if log.snapshot():
break
time.sleep(0.05)
finally:
server.stop()
event = log.snapshot()[0]
assert event.result == "interrupted" and 0 < event.size < len(data)
def test_responder_records_who_asked_in_the_network() -> None:
log = share_activity.ActivityLog()
responder = share_discover.Responder("p", "1", 47000, host="127.0.0.1", port=0, allow_loopback=True, activity=log)
responder.start()
try:
found = share_discover.find_neighbours(
"p", "1", timeout=1, targets=[("127.0.0.1", responder.port)], sources=["127.0.0.1"], allow_loopback=True
)
assert found
finally:
responder.stop()
event = log.snapshot()[0]
assert (event.direction, event.via, event.what, event.peer) == ("in", "lan", "search", "127.0.0.1")
def test_our_own_downloads_are_recorded_as_outgoing(tmp_path) -> None:
server, _, entry = _server(tmp_path / "n") if (tmp_path / "n").mkdir() is None else None
log = share_activity.ActivityLog()
try:
neighbour = share_discover.Neighbour("127.0.0.1", server.port)
missing = FileEntry("_internal/missing.bin", 200_000, "e" * 64, 200_000)
share_prefill.prefill_from_neighbours(
UpdatePlan(version="x", want=[Want(entry), Want(missing)]), work_dir=tmp_path / "w", neighbours=[neighbour],
activity=log, threads=1,
)
finally:
server.stop()
seen = {(e.detail, e.result): e for e in log.snapshot()}
assert seen[("_internal/a.bin", "ok")].size == BIG and seen[("_internal/a.bin", "ok")].direction == "out"
assert ("_internal/missing.bin", "not_found") in seen
assert {e.via for e in log.snapshot()} == {"lan"}
def test_service_gives_one_log_to_its_servers_and_responder(tmp_path) -> None:
seen = {}
class Net:
running = False
def start(self, files, version, manifest_provider=None, activity=None):
seen["activity"] = activity
self.running = True
return True
def stop(self):
self.running = False
service = share_service.SharingService(
root=tmp_path, enabled=lambda: True, load_installed=lambda: SimpleNamespace(files=(), version="1"),
product="p", current_version="1", discovery_port=0, host="127.0.0.1", allow_loopback=True,
internet_enabled=lambda: True, internet=Net(),
)
try:
assert service.refresh() is True
assert seen["activity"] is service.activity
assert service._server.activity is service.activity and service._server.via == "lan"
assert service._responder._activity is service.activity
finally:
service.stop()