zapret-kvn/xray_fluent/network/service_check.py
loop-uh e8ad0b1911
Some checks failed
Windows project source guards / test (push) Failing after 8m21s
Gemini в проверке сервисов: узел, который открывает сайт, но не пускает из своей страны
В каталог «Через этот узел» добавлен 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>
2026-11-04 11:04:24 -05:00

324 lines
15 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.

"""Что открывается через узел: проверка известных сервисов по качеству ответов, а не по одному байту.
Раньше узел проверялся запросом ``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)