Some checks failed
Windows project source guards / test (push) Failing after 8m21s
В каталог «Через этот узел» добавлен Gemini. Сайт gemini.google.com проверяется как остальные (время до первого байта), а регион отдельным одним запросом к generativelanguage.googleapis.com/v1beta/models: статус 400, 403 или 451 вместе с текстом «user location is not supported» значит, что из страны узла сервис не работает; обычный 403 без этого текста (нужен ключ) значит, что регион поддерживается. Так же устроена проверка Gemini на Android. Новый вердикт «region» (в строке карточки отмечается как «не открывается», в подробностях словами: нужен узел в другой стране) приоритетнее оценки скорости, но не прячет узел, который не открывает сайт совсем. Запрос региона делается только если сайт открылся, поэтому сбой узла не выдаётся за блок по стране; ошибка самого запроса вердикт не меняет. Тесты: test_service_check с 22 до 39 (вывод по региону, разбор ответа, сбои и отмена, порядок запросов), весь набор 1985 тестов без падений. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
324 lines
15 KiB
Python
324 lines
15 KiB
Python
"""Что открывается через узел: проверка известных сервисов по качеству ответов, а не по одному байту.
|
||
|
||
Раньше узел проверялся запросом ``generate_204`` и скоростью файла: «живой» узел мог отдавать YouTube
|
||
или Discord с паузами или не пускать к ним вовсе. Здесь через уже поднятый временный прокси к каждому
|
||
сервису идёт короткая серия запросов по одному соединению, и по времени до первого байта решается:
|
||
|
||
- ``ok`` — ответы быстрые;
|
||
- ``slow`` — обычный запрос ждёт больше двух с половиной секунд;
|
||
- ``pause`` — один-два запроса ждали секунды, остальные получили ответ за доли секунды (так видео «замирает»);
|
||
- ``partial`` — открывается не каждое имя сервиса;
|
||
- ``blocked`` — не открылось ни одно имя;
|
||
- ``region`` — имена открываются, но сервис сам не пускает из страны узла (Gemini отвечает «user location
|
||
is not supported»): это не сбой узла, а вывод по одному запросу с разбором статуса и текста ответа.
|
||
|
||
Сбор (запросы) и вывод (``judge``) разделены: вывод проверяется без сети.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import http.client
|
||
import socket
|
||
import ssl
|
||
import statistics
|
||
import time
|
||
from collections.abc import Callable
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
from dataclasses import dataclass
|
||
|
||
__all__ = [
|
||
"GeoRule",
|
||
"GeoRun",
|
||
"SERVICES",
|
||
"ServiceSpec",
|
||
"ServiceVerdict",
|
||
"check_all",
|
||
"judge",
|
||
"probe_endpoint",
|
||
"probe_geo",
|
||
"summary_text",
|
||
]
|
||
|
||
CODE_OK = "ok"
|
||
CODE_SLOW = "slow"
|
||
CODE_PAUSE = "pause"
|
||
CODE_PARTIAL = "partial"
|
||
CODE_BLOCKED = "blocked"
|
||
CODE_REGION = "region"
|
||
CODE_UNKNOWN = "unknown"
|
||
|
||
# Сколько запросов по одному соединению; первый (с подключением и рукопожатием) во время не входит.
|
||
REQUESTS_PER_ENDPOINT = 5
|
||
CONNECT_TIMEOUT_S = 6.0
|
||
READ_TIMEOUT_S = 6.0
|
||
# Пауза — запрос ждал не меньше этого и не меньше чем в столько раз дольше обычного.
|
||
PAUSE_MS = 2500.0
|
||
PAUSE_RATIO = 20.0
|
||
SLOW_MEDIAN_MS = 2500.0
|
||
# Сколько служб проверять одновременно: каждая — своё соединение через один и тот же прокси.
|
||
PARALLEL = 6
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class GeoRule:
|
||
"""Один запрос, по ответу которого видно, что сервис не работает из страны узла.
|
||
|
||
Блок по региону приходит не обрывом, а обычным ответом: [statuses] и [marker] (строчными буквами)
|
||
в тексте ответа вместе значат «из этой страны нельзя». Тот же статус без текста региона (например,
|
||
403 «нужен ключ») означает, что регион поддерживается.
|
||
"""
|
||
|
||
host: str
|
||
path: str
|
||
statuses: frozenset[int]
|
||
marker: str
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class ServiceSpec:
|
||
key: str
|
||
title: str
|
||
# (хост, путь): каждое имя сервиса, которое должно открываться.
|
||
endpoints: tuple[tuple[str, str], ...]
|
||
# Проверки региона; делаются только если имена сервиса открылись.
|
||
geo: tuple[GeoRule, ...] = ()
|
||
|
||
|
||
SERVICES: tuple[ServiceSpec, ...] = (
|
||
ServiceSpec("youtube", "YouTube", (("www.youtube.com", "/generate_204"), ("i.ytimg.com", "/generate_204"))),
|
||
ServiceSpec("discord", "Discord", (("discord.com", "/"), ("gateway.discord.gg", "/"), ("cdn.discordapp.com", "/"))),
|
||
ServiceSpec("telegram", "Telegram", (("telegram.org", "/"), ("web.telegram.org", "/"))),
|
||
ServiceSpec("instagram", "Instagram", (("www.instagram.com", "/"),)),
|
||
ServiceSpec("facebook", "Facebook", (("www.facebook.com", "/"),)),
|
||
ServiceSpec("x", "X", (("x.com", "/"),)),
|
||
ServiceSpec("whatsapp", "WhatsApp", (("web.whatsapp.com", "/"),)),
|
||
ServiceSpec("spotify", "Spotify", (("www.spotify.com", "/"),)),
|
||
ServiceSpec("chatgpt", "ChatGPT", (("chatgpt.com", "/"),)),
|
||
# Без ключа API отвечает 403 там, где регион поддерживается; 400 «user location is not supported» там, где нет.
|
||
ServiceSpec(
|
||
"gemini",
|
||
"Gemini",
|
||
(("gemini.google.com", "/"),),
|
||
geo=(
|
||
GeoRule(
|
||
"generativelanguage.googleapis.com",
|
||
"/v1beta/models",
|
||
frozenset({400, 403, 451}),
|
||
"user location is not supported",
|
||
),
|
||
),
|
||
),
|
||
ServiceSpec("twitch", "Twitch", (("www.twitch.tv", "/"),)),
|
||
ServiceSpec("linkedin", "LinkedIn", (("www.linkedin.com", "/"),)),
|
||
)
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class ServiceVerdict:
|
||
key: str
|
||
code: str
|
||
text: str = ""
|
||
ttfb_median_ms: float = 0.0
|
||
ttfb_max_ms: float = 0.0
|
||
|
||
def as_dict(self) -> dict:
|
||
return {
|
||
"key": self.key,
|
||
"code": self.code,
|
||
"text": self.text,
|
||
"ttfb_median_ms": round(self.ttfb_median_ms),
|
||
"ttfb_max_ms": round(self.ttfb_max_ms),
|
||
}
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class EndpointRun:
|
||
"""Итог серии запросов к одному имени: время до первого байта у каждого удавшегося запроса и сбой, если был."""
|
||
|
||
host: str
|
||
ttfb_ms: tuple[float, ...] = ()
|
||
failed: bool = False
|
||
reason: str = ""
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class GeoRun:
|
||
"""Итог запроса региона: ``blocked`` — сервис ответил «из вашей страны нельзя»; ``failed`` — узнать не удалось."""
|
||
|
||
host: str
|
||
blocked: bool = False
|
||
status: int = 0
|
||
failed: bool = False
|
||
reason: str = ""
|
||
|
||
|
||
def _open_connection(proxy_host: str, proxy_port: int, host: str) -> http.client.HTTPSConnection:
|
||
connection = http.client.HTTPSConnection(
|
||
proxy_host, proxy_port, timeout=CONNECT_TIMEOUT_S, context=ssl.create_default_context()
|
||
)
|
||
connection.set_tunnel(host, 443, headers={"User-Agent": _USER_AGENT})
|
||
return connection
|
||
|
||
|
||
_USER_AGENT = (
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
|
||
)
|
||
|
||
|
||
def probe_endpoint(
|
||
proxy_host: str,
|
||
proxy_port: int,
|
||
host: str,
|
||
path: str,
|
||
*,
|
||
cancelled: Callable[[], bool] = lambda: False,
|
||
connect: Callable[..., http.client.HTTPSConnection] = _open_connection,
|
||
clock: Callable[[], float] = time.perf_counter,
|
||
) -> EndpointRun:
|
||
"""Серия запросов по одному соединению через прокси. Время — от отправки запроса до заголовков ответа."""
|
||
times: list[float] = []
|
||
try:
|
||
connection = connect(proxy_host, proxy_port, host)
|
||
except (OSError, ValueError) as error:
|
||
return EndpointRun(host, failed=True, reason=str(error)[:80])
|
||
try:
|
||
for number in range(REQUESTS_PER_ENDPOINT):
|
||
if cancelled():
|
||
break
|
||
started = clock()
|
||
try:
|
||
connection.request("GET", path, headers={"User-Agent": _USER_AGENT, "Accept": "*/*"})
|
||
response = connection.getresponse()
|
||
response.read(8192)
|
||
except (OSError, http.client.HTTPException, ssl.SSLError, socket.timeout) as error:
|
||
if not times:
|
||
return EndpointRun(host, failed=True, reason=type(error).__name__)
|
||
# Соединение оборвалось посреди серии: что успели, то и есть.
|
||
return EndpointRun(host, tuple(times[1:] if len(times) > 1 else times), failed=True, reason=type(error).__name__)
|
||
times.append((clock() - started) * 1000)
|
||
# Сервис, который закрывает соединение после ответа, серию не продолжит: хватит одного замера.
|
||
if response.will_close and number == 0:
|
||
break
|
||
finally:
|
||
try:
|
||
connection.close()
|
||
except OSError:
|
||
pass
|
||
# Первый запрос по новому соединению — с подключением и рукопожатием: в оценку пауз не входит.
|
||
return EndpointRun(host, tuple(times[1:] if len(times) > 1 else times))
|
||
|
||
|
||
def probe_geo(
|
||
proxy_host: str,
|
||
proxy_port: int,
|
||
rule: GeoRule,
|
||
*,
|
||
cancelled: Callable[[], bool] = lambda: False,
|
||
connect: Callable[..., http.client.HTTPSConnection] = _open_connection,
|
||
) -> GeoRun:
|
||
"""Один запрос региона через прокси: блок виден по статусу и тексту ответа, а не по обрыву."""
|
||
if cancelled():
|
||
return GeoRun(rule.host, failed=True, reason="cancelled")
|
||
try:
|
||
connection = connect(proxy_host, proxy_port, rule.host)
|
||
except (OSError, ValueError) as error:
|
||
return GeoRun(rule.host, failed=True, reason=str(error)[:80])
|
||
try:
|
||
connection.request("GET", rule.path, headers={"User-Agent": _USER_AGENT, "Accept": "*/*"})
|
||
response = connection.getresponse()
|
||
status = int(response.status)
|
||
body = response.read(8192)
|
||
except (OSError, http.client.HTTPException, ssl.SSLError, socket.timeout, ValueError) as error:
|
||
return GeoRun(rule.host, failed=True, reason=type(error).__name__)
|
||
finally:
|
||
try:
|
||
connection.close()
|
||
except OSError:
|
||
pass
|
||
text = body.decode("utf-8", errors="replace").lower() if isinstance(body, (bytes, bytearray)) else ""
|
||
return GeoRun(rule.host, blocked=status in rule.statuses and rule.marker in text, status=status)
|
||
|
||
|
||
def judge(spec: ServiceSpec, runs: list[EndpointRun], geo_runs: list[GeoRun] | tuple[GeoRun, ...] = ()) -> ServiceVerdict:
|
||
"""Вывод по сервису из серий по всем его именам. Новых запросов не делает."""
|
||
if not runs:
|
||
return ServiceVerdict(spec.key, CODE_UNKNOWN, "не проверялся")
|
||
opened = [run for run in runs if run.ttfb_ms]
|
||
if not opened:
|
||
reason = next((run.reason for run in runs if run.reason), "")
|
||
return ServiceVerdict(spec.key, CODE_BLOCKED, f"не открывается через этот узел{f' ({reason})' if reason else ''}")
|
||
closed = [run.host for run in runs if not run.ttfb_ms]
|
||
all_times = [value for run in opened for value in run.ttfb_ms]
|
||
median = statistics.median(all_times)
|
||
worst = max(all_times)
|
||
# Блок по региону точнее любой оценки скорости: сервис отвечает, но из страны узла не пускает.
|
||
region = next((run for run in geo_runs if run.blocked), None)
|
||
if region is not None:
|
||
return ServiceVerdict(
|
||
spec.key,
|
||
CODE_REGION,
|
||
f"сервис не работает из страны этого узла (ответ {region.status} от {region.host}); нужен узел в другой стране",
|
||
median,
|
||
worst,
|
||
)
|
||
if closed:
|
||
return ServiceVerdict(spec.key, CODE_PARTIAL, f"не открылось: {', '.join(closed)}", median, worst)
|
||
if len(all_times) >= 3 and worst >= PAUSE_MS and worst >= PAUSE_RATIO * max(median, 1.0) and median < 1200:
|
||
return ServiceVerdict(
|
||
spec.key, CODE_PAUSE, f"ответы идут с паузами: обычно {median:.0f} мс, но один ждал {worst / 1000:.1f} с", median, worst
|
||
)
|
||
if median >= SLOW_MEDIAN_MS:
|
||
return ServiceVerdict(spec.key, CODE_SLOW, f"отвечает медленно: обычно {median / 1000:.1f} с до первого байта", median, worst)
|
||
return ServiceVerdict(spec.key, CODE_OK, f"ответы быстрые: обычно {median:.0f} мс", median, worst)
|
||
|
||
|
||
def check_service(
|
||
proxy_host: str,
|
||
proxy_port: int,
|
||
spec: ServiceSpec,
|
||
*,
|
||
cancelled=lambda: False,
|
||
probe=probe_endpoint,
|
||
geo_probe=probe_geo,
|
||
) -> ServiceVerdict:
|
||
runs = [probe(proxy_host, proxy_port, host, path, cancelled=cancelled) for host, path in spec.endpoints]
|
||
# Регион спрашиваем, только если имена сервиса открылись: иначе причина в узле, а не в стране.
|
||
geo_runs = (
|
||
[geo_probe(proxy_host, proxy_port, rule, cancelled=cancelled) for rule in spec.geo]
|
||
if spec.geo and any(run.ttfb_ms for run in runs)
|
||
else []
|
||
)
|
||
return judge(spec, runs, geo_runs)
|
||
|
||
|
||
def check_all(
|
||
proxy_host: str,
|
||
proxy_port: int,
|
||
*,
|
||
services: tuple[ServiceSpec, ...] = SERVICES,
|
||
cancelled: Callable[[], bool] = lambda: False,
|
||
probe=probe_endpoint,
|
||
geo_probe=probe_geo,
|
||
) -> dict[str, ServiceVerdict]:
|
||
"""Все сервисы каталога через один поднятый прокси; по ``PARALLEL`` одновременно."""
|
||
with ThreadPoolExecutor(max_workers=PARALLEL, thread_name_prefix="service-check") as pool:
|
||
futures = {
|
||
spec.key: pool.submit(
|
||
check_service, proxy_host, proxy_port, spec, cancelled=cancelled, probe=probe, geo_probe=geo_probe
|
||
)
|
||
for spec in services
|
||
}
|
||
return {key: future.result() for key, future in futures.items()}
|
||
|
||
|
||
def summary_text(verdicts: dict[str, dict] | dict[str, ServiceVerdict]) -> str:
|
||
"""Одна строка для карточки узла: значок и название каждого сервиса, о проблемах — словами."""
|
||
icons = {
|
||
CODE_OK: "✓", CODE_SLOW: "⚠", CODE_PAUSE: "⚠", CODE_PARTIAL: "⚠", CODE_BLOCKED: "✗", CODE_REGION: "✗", CODE_UNKNOWN: "?",
|
||
}
|
||
titles = {spec.key: spec.title for spec in SERVICES}
|
||
parts = []
|
||
for key, verdict in verdicts.items():
|
||
code = verdict.code if isinstance(verdict, ServiceVerdict) else str(verdict.get("code") or CODE_UNKNOWN)
|
||
parts.append(f"{icons.get(code, '?')} {titles.get(key, key)}")
|
||
return " ".join(parts)
|