Compare commits
4
Commits
b36ce50e12
..
master
| Author | SHA1 | Date | |
|---|---|---|---|
 ddadmin
|
203e515479 | ||
|
ddadmin
|
45938cde98 | ||
|
ddadmin
|
384b4f215f | ||
|
ddadmin
|
b34eb6ac4c |
No files matched your search
+10
@@ -0,0 +1,10 @@
|
||||
# Термины dotfiles
|
||||
|
||||
## Прокси
|
||||
|
||||
**Профиль прокси** — именованный набор настроек одного прокси: его тип,
|
||||
адрес и порт для приложений, исключения и, для управляемого Xray, VLESS-ссылка.
|
||||
Не следует называть профилем только VLESS-ссылку.
|
||||
|
||||
**VLESS-ссылка** — параметры подключения к удалённому серверу VLESS.
|
||||
Она не задаёт локальный порт прокси и исключения для приложений.
|
||||
@@ -4,6 +4,9 @@
|
||||
|
||||
Статус: реализовано; 2026-09-28 упрощено по принципу ниже
|
||||
|
||||
Расширение от 2026-11-02:
|
||||
[пользовательские профили и системная служба](2026-11-02-proxy-client-profiles-service-design.md).
|
||||
|
||||
Точное поведение, форматы, сообщения и команды описаны в коде,
|
||||
`proxy-client --help` и [`proxy-client/README.md`](../../proxy-client/README.md).
|
||||
Здесь — то, чего по коду не видно: задача, границы, выбор и его причины, риски.
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
# Профили proxy-client и системная служба
|
||||
|
||||
Дата: 2026-11-02
|
||||
|
||||
Статус: реализовано; запуск после загрузки ОС и восстановление настоящей
|
||||
службы systemd требуют отдельной проверки на Linux-ВМ.
|
||||
|
||||
## Задача и границы
|
||||
|
||||
На Linux-ВМ, компьютерах и ноутбуках нужен прокси, доступный после загрузки
|
||||
без входа пользователя и ручного запуска. Приложения уже знают его адрес.
|
||||
Одновременно пользователь должен иметь возможность запустить другой прокси
|
||||
на другом порту в открытом терминале.
|
||||
|
||||
Это расширяет [первоначальный дизайн](2026-07-15-proxy-client-design.md):
|
||||
добавляет системную службу и несколько пользовательских профилей.
|
||||
Остальные ограничения и принцип личного инструмента сохраняются.
|
||||
Термины определены в [CONTEXT.md](../../CONTEXT.md).
|
||||
|
||||
Не добавляем несколько системных экземпляров, фоновый пользовательский режим,
|
||||
TUN, системную маршрутизацию, автоматический выбор прокси или поддержку Windows.
|
||||
Для системного режима требуется systemd; ручной режим сохраняет независимость
|
||||
от него. Пакет по-прежнему можно использовать отдельно от остальных dotfiles.
|
||||
|
||||
## Пользовательские профили
|
||||
|
||||
Профиль по умолчанию сохраняет нынешние файлы
|
||||
`~/.config/proxy-client/config` и `default.url`. Отсутствие выбора профиля
|
||||
не меняет поведения существующих команд, включая прежний внешний прокси
|
||||
при отсутствии конфигурации. Учитываются существующие настройки XDG.
|
||||
|
||||
Дополнительные профили размещаются в
|
||||
`~/.config/proxy-client/profiles/<имя>/`, каждый со своими `config` и
|
||||
`default.url`. Имя `default` обозначает существующий профиль по умолчанию.
|
||||
Неизвестное имя даёт ошибку, а не переход к другому профилю.
|
||||
|
||||
Один общий параметр выбора профиля действует на запуск, остановку, проверку,
|
||||
вывод окружения и запуск дочерних команд. Существующий выбор файла VLESS-ссылки
|
||||
через `start -f` остаётся разовым переопределением ссылки выбранного профиля.
|
||||
Bash-команды без явного выбора продолжают использовать профиль по умолчанию.
|
||||
|
||||
Каждый профиль получает собственные сведения о процессе, блокировку и
|
||||
сгенерированный JSON. Запуск и остановка одного не затрагивают остальные.
|
||||
Два экземпляра могут работать одновременно, если их локальные порты различны.
|
||||
Занятый порт даёт ошибку; чужой процесс не останавливается.
|
||||
|
||||
Ручной запуск остаётся на переднем плане, с выводом в терминал и остановкой
|
||||
через Ctrl+C либо команду остановки выбранного профиля. Само обращение к прокси
|
||||
через `run` или `env` ничего не запускает.
|
||||
|
||||
## Bash-команды
|
||||
|
||||
`proxy_on` без параметров выбирает профиль по умолчанию, с `--profile` —
|
||||
именованный. Он меняет только окружение текущего терминала после успешной
|
||||
проверки. `proxy_off` очищает переменные, но не останавливает процессы.
|
||||
`myip` использует текущее окружение.
|
||||
|
||||
`pclaude` и `pcodex` принимают ведущий `--proxy-profile` для выбора профиля.
|
||||
Без него остаётся профиль по умолчанию; остальные аргументы и код возврата
|
||||
дочерней программы сохраняются. Обычный `--profile` относится к дочерней
|
||||
программе. Bash-модуль передаёт выбор CLI и не дублирует правила профилей.
|
||||
|
||||
Выбор через `proxy_on` не меняет профиль по умолчанию: обычная команда
|
||||
наследует окружение, а обёртка с префиксом `p` явно выбирает свой профиль.
|
||||
Это различие должно быть показано в README пакета.
|
||||
|
||||
## Системная служба
|
||||
|
||||
Одна служба `proxy-client.service` читает один комплект настроек из
|
||||
`/etc/proxy-client/`. Ей не нужны именованные профили или домашний каталог
|
||||
пользователя. Исполняемые файлы устанавливаются в системное расположение,
|
||||
без ссылок на пользовательский каталог исходников. Xray работает под отдельной
|
||||
непривилегированной учётной записью и слушает только loopback.
|
||||
|
||||
Временные файлы процесса, блокировка и сгенерированный JSON находятся в
|
||||
закрытом `/run/proxy-client/`. Секреты доступны только администратору и
|
||||
служебной учётной записи. Пользовательские команды остановки не управляют
|
||||
системным экземпляром: за него отвечает systemd.
|
||||
|
||||
Установка оформляется одной подкомандой `service install`. В терминале она
|
||||
собирает недостающие настройки, показывает план и после подтверждения
|
||||
выполняет полный переход на службу. `--yes` (`--auto-yes`) принимает план
|
||||
без вопроса. Без терминала для нового подключения нужен закрытый `--file`;
|
||||
секрет не передаётся в argv или окружении. В терминале применяется скрытый
|
||||
ввод. Новый профиль получает адрес `127.0.0.1` и порт `12334` по умолчанию.
|
||||
|
||||
Для переноса используются сохранённые `config` и `default.url` выбранного
|
||||
профиля; `--file` переопределяет ссылку. Xray ищется в `~/.local/bin`, затем
|
||||
в `PATH` и системной установке. Если его нет, скачивается закреплённая версия
|
||||
с проверкой SHA-256. Параметр `--xray` позволяет указать бинарник явно.
|
||||
|
||||
Полный переход состоит из подготовки снимка, проверки Xray, установки
|
||||
системных файлов, остановки выбранного ручного процесса и запуска службы.
|
||||
Домашний `config` меняется на `external` только после проверки активного
|
||||
состояния службы и доступности её порта; прежний файл сохраняется рядом.
|
||||
Остановка пользовательского процесса и изменение домашнего профиля
|
||||
выполняются без повышения прав. Sudo применяется только к системной части.
|
||||
|
||||
Закрытый снимок `service-setup.json` в каталоге состояния профиля позволяет
|
||||
продолжить незавершённый переход. Он содержит исходный домашний config,
|
||||
подготовленный config, VLESS-ссылку и путь для ручного восстановления;
|
||||
права файла `600`, каталога `700`. При повторе домашние и системные настройки
|
||||
сверяются со снимком до остановки процессов. Изменённые настройки не
|
||||
перезаписываются, исходный файл VLESS-ссылки тоже проверяется. Ошибка конфликта
|
||||
указывает команду удаления снимка, чтобы начать заново с текущими настройками;
|
||||
этот сброс не меняет сами настройки и процессы. После успеха снимок удаляется.
|
||||
Ошибка запуска сохраняет
|
||||
прежний домашний профиль; восстановление ручного процесса требует явной
|
||||
команды, прежние соединения не восстанавливаются.
|
||||
|
||||
Наличие системных файлов само по себе не означает завершённый переход:
|
||||
если домашний профиль ещё `xray`, мастер сверяет его с системным и завершает
|
||||
перенос. Другой профиль не заменяет существующие системные настройки.
|
||||
После завершённого перехода настройки службы самостоятельны. Обычное
|
||||
обновление сохраняет их и включает перезапуск в подтверждаемый план;
|
||||
домашний профиль не меняется и может отсутствовать.
|
||||
|
||||
`--install-only`, `--config-dir` и `--root`
|
||||
сохраняют режим установки файлов без мастера. Он требует готовых настроек
|
||||
и Xray. Флаги `--enable`, `--start`, `--restart` задают действия явно.
|
||||
`--root` не допускает действий с systemd. В этом режиме установка сама
|
||||
домашний профиль не меняет и ручной процесс не останавливает.
|
||||
Без терминала и без явного выбора режима команда завершается с подсказкой.
|
||||
|
||||
Systemd отвечает за запуск, остановку и перезапуск после аварии. Явная
|
||||
остановка должна оставлять службу остановленной до следующего запуска.
|
||||
Если автозапуск включён, после перезагрузки она запускается снова.
|
||||
|
||||
Отсутствие внешней сети при загрузке не должно приводить к окончательному
|
||||
отказу службы. Готовность локального порта и доступность удалённого маршрута
|
||||
различаются: автозапуск не гарантирует успешность первого запроса любого
|
||||
приложения. Для приложений, не умеющих повторять запрос, порядок запуска и
|
||||
ожидание готовности потребуют отдельной настройки.
|
||||
|
||||
## Журналы и совместная работа
|
||||
|
||||
Вывод службы направляется в journald. Отдельный текстовый журнал и собственная
|
||||
ротация не нужны. Хранение между загрузками зависит от настройки journald;
|
||||
установщик проверяет её и сообщает результат, не меняя глобальную политику
|
||||
журналирования машины. Секреты не должны попадать в журнал.
|
||||
|
||||
Если системная служба занимает порт прежнего пользовательского Xray, второй
|
||||
запуск на этом порту завершается ошибкой. Чтобы использовать системный прокси
|
||||
через пользовательские команды, подходит профиль типа `external`. Для второго
|
||||
Xray нужен другой порт. Мастер меняет домашний профиль по подтверждённому
|
||||
плану; режим установки только файлов его не меняет.
|
||||
|
||||
## Устройство модулей
|
||||
|
||||
Применяем `codebase-design`: выбор профиля и все его пути должны определяться
|
||||
в одном месте, чтобы команды не повторяли правила размещения файлов.
|
||||
Пути, правила доступа к профилю, вывод Xray и подсказка остановки собраны
|
||||
в неизменяемый контекст запуска. Он создаётся при выборе пользовательского
|
||||
или системного режима и явно передаётся функциям. Управление процессом
|
||||
использует готовые значения, без глобального переключателя режима.
|
||||
Системная установка скрывает размещение, права и взаимодействие с systemd
|
||||
за небольшим интерфейсом; не копирует разбор VLESS и управление Xray.
|
||||
Внутри модуль отделяет подготовку плана от его применения: план хранит
|
||||
снимок настроек и исходного процесса, применение управляет порядком
|
||||
действий и возобновлением. Проверки проходят через публичный CLI.
|
||||
Внешние команды подменяются через `PATH`, терминальный ввод, сокеты и загрузка
|
||||
архива — подменой функций стандартной библиотеки в тестовом `sitecustomize`.
|
||||
Разбор настроек и работа с файлами выполняются настоящим кодом.
|
||||
|
||||
Не вводим обобщённую поддержку других менеджеров служб и дополнительные
|
||||
слои ради возможного будущего использования. Реально различаются
|
||||
пользовательское и системное размещение, а также способ управления процессом.
|
||||
|
||||
## Проверки
|
||||
|
||||
Согласованы три интерфейса для новых тестов TDD:
|
||||
|
||||
1. CLI пользовательских профилей: прежнее поведение без имени, выбор
|
||||
именованного профиля, два одновременных процесса, независимая остановка,
|
||||
отказ при занятом порте и правильное окружение дочерней команды.
|
||||
2. Установка службы через CLI и управление через systemd: размещение файлов,
|
||||
сохранение настроек при повторной установке, явное включение автозапуска,
|
||||
запуск и остановка, восстановление после аварии и доступность журналов.
|
||||
|
||||
3. Bash-команды: выбор профиля, передача аргументов и кода возврата,
|
||||
сохранение окружения при ошибке и отсутствие остановки процессов.
|
||||
|
||||
Тесты проверяют наблюдаемое поведение через эти интерфейсы, а не внутренние
|
||||
функции и последовательности их вызовов. Идём по одному сценарию:
|
||||
падающий тест, минимальная реализация, следующий сценарий.
|
||||
|
||||
Локальные проверки используют временные каталоги, синтетические профили и
|
||||
подставные внешние программы. Это не доказывает работу настоящего systemd.
|
||||
Окончательная проверка системного режима нужна в отдельной Linux-среде
|
||||
с systemd: запуск до входа пользователя после загрузки, восстановление после
|
||||
аварии, явная остановка и одновременная работа ручного экземпляра.
|
||||
Изменение текущей машины или её перезагрузка не входят в проверку по умолчанию.
|
||||
|
||||
Проверка после cross-review 2026-11-04: полный набор под псевдотерминалом
|
||||
прошёл на Python 3.8 и 3.14 — по 108 тестов, ещё 12 проверок Bash-команд
|
||||
и 6 проверок пользовательского установщика.
|
||||
Мастер проверен через CLI: настройка с нуля, перенос, обновление, отмена,
|
||||
отказы и продолжение перехода. Скрытый ввод проверен в псевдотерминале.
|
||||
Системные действия и скачивание в этих тестах подменены; настоящие службы
|
||||
не запускались. Shellcheck в среде отсутствует.
|
||||
|
||||
При первоначальной реализации отдельно проверены Bash-команды вместе
|
||||
с настоящим CLI и двумя локальными тестовыми портами. Unit прошёл статическую
|
||||
проверку в изолированном корне с тестовыми базовыми target-файлами.
|
||||
Эти результаты не заменяют проверку загрузки ОС.
|
||||
|
||||
## Документация и альтернативы
|
||||
|
||||
Подробные инструкции размещены в
|
||||
[`proxy-client/README.md`](../../proxy-client/README.md): профили, системная
|
||||
установка и обновление, управление, автозапуск, журналы и диагностика.
|
||||
В корневом README достаточно существующей ссылки на пакет. Этот документ
|
||||
хранит причины решений; рабочие команды и примеры живут в README пакета.
|
||||
|
||||
Пользовательская служба с linger позволила бы запускать прокси до входа,
|
||||
но выбрано явное разделение системных и домашних настроек. Несколько
|
||||
именованных системных служб пока не нужны. Запуск в терминале сохраняется
|
||||
для дополнительных прокси, но сам по себе не решает задачу загрузки машины.
|
||||
|
||||
Правила systemd сверены с документацией
|
||||
[каталогов службы](https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html#RuntimeDirectory=),
|
||||
[перезапуска](https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html#Restart=)
|
||||
и [хранения журналов](https://www.freedesktop.org/software/systemd/man/latest/journald.conf.html#Storage=).
|
||||
@@ -32,8 +32,12 @@ _proxy_apply_env() {
|
||||
}
|
||||
|
||||
proxy_on() {
|
||||
if (( $# != 0 )) && { (( $# != 2 )) || [[ "$1" != --profile || -z "${2:-}" ]]; }; then
|
||||
echo "Использование: proxy_on [--profile NAME]" >&2
|
||||
return 2
|
||||
fi
|
||||
local output
|
||||
if ! output="$(_proxy_cli env)" || ! _proxy_apply_env "$output"; then
|
||||
if ! output="$(_proxy_cli "$@" env)" || ! _proxy_apply_env "$output"; then
|
||||
echo "Ошибка: прокси не включён" >&2
|
||||
return 1
|
||||
fi
|
||||
@@ -53,7 +57,16 @@ _proxy_run() {
|
||||
return 2
|
||||
fi
|
||||
shift
|
||||
_proxy_cli run -- "$command_name" "$@"
|
||||
local -a profile_args=()
|
||||
if [[ "${1:-}" == --proxy-profile ]]; then
|
||||
if (( $# < 2 )) || [[ -z "$2" ]]; then
|
||||
echo "Ошибка: --proxy-profile требует имя профиля" >&2
|
||||
return 2
|
||||
fi
|
||||
profile_args=(--profile "$2")
|
||||
shift 2
|
||||
fi
|
||||
_proxy_cli "${profile_args[@]}" run -- "$command_name" "$@"
|
||||
}
|
||||
|
||||
pclaude() { _proxy_run claude "$@"; }
|
||||
|
||||
@@ -13,7 +13,9 @@ import argparse
|
||||
import configparser
|
||||
import fcntl
|
||||
import hashlib
|
||||
import getpass
|
||||
import http.client
|
||||
import io
|
||||
import ipaddress
|
||||
import json
|
||||
import os
|
||||
@@ -28,8 +30,11 @@ import tempfile
|
||||
import time
|
||||
import urllib.request
|
||||
import uuid
|
||||
import warnings
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
from dataclasses import dataclass
|
||||
from typing import Optional
|
||||
from urllib.parse import parse_qsl, unquote, urlsplit
|
||||
|
||||
|
||||
@@ -120,23 +125,57 @@ class VlessProfile:
|
||||
return self.query["security"]
|
||||
|
||||
|
||||
def config_home():
|
||||
root = os.environ.get("XDG_CONFIG_HOME")
|
||||
return (Path(root).expanduser() if root else Path.home() / ".config") / "proxy-client"
|
||||
@dataclass(frozen=True)
|
||||
class RuntimeContext:
|
||||
"""Размещение и правила выбранного запуска; создаётся до выполнения команды."""
|
||||
|
||||
config_dir: Path
|
||||
state_dir: Path
|
||||
xray_path: Optional[Path]
|
||||
profile_forbidden_mode: int
|
||||
profile_repair: str
|
||||
xray_output: Optional[int]
|
||||
stop_hint: str
|
||||
|
||||
@property
|
||||
def state_path(self):
|
||||
return self.state_dir / "state.json"
|
||||
|
||||
@property
|
||||
def generated_config_path(self):
|
||||
return self.state_dir / "client.json"
|
||||
|
||||
|
||||
def state_home():
|
||||
root = os.environ.get("XDG_STATE_HOME")
|
||||
base = Path(root).expanduser() if root else Path.home() / ".local/state"
|
||||
return base / "proxy-client"
|
||||
def user_context(profile="default", home=None):
|
||||
if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]{0,63}", profile):
|
||||
raise ProxyError("недопустимое имя профиля")
|
||||
config_root = os.environ.get("XDG_CONFIG_HOME")
|
||||
state_root = os.environ.get("XDG_STATE_HOME")
|
||||
home = home if home is not None else Path.home()
|
||||
config_dir = (Path(config_root).expanduser() if config_root else home / ".config") / "proxy-client"
|
||||
state_dir = (Path(state_root).expanduser() if state_root else home / ".local/state") / "proxy-client"
|
||||
stop_hint = "Ctrl+C или proxy-client stop"
|
||||
if profile != "default":
|
||||
config_dir = config_dir / "profiles" / profile
|
||||
state_dir = state_dir / "profiles" / profile
|
||||
if not (config_dir / "config").is_file():
|
||||
raise ProxyError("неизвестный профиль: {}".format(profile))
|
||||
stop_hint = "Ctrl+C или proxy-client --profile {} stop".format(profile)
|
||||
return RuntimeContext(config_dir, state_dir, None, 0o077,
|
||||
"chmod 600 {0}", None, stop_hint)
|
||||
|
||||
|
||||
def state_path():
|
||||
return state_home() / "state.json"
|
||||
|
||||
|
||||
def generated_config_path():
|
||||
return state_home() / "client.json"
|
||||
def service_context(arguments):
|
||||
config_dir = Path(arguments.config_dir)
|
||||
state_dir = Path(arguments.runtime_dir)
|
||||
xray_path = Path(arguments.xray)
|
||||
if not all(path.is_absolute() for path in (config_dir, state_dir, xray_path)):
|
||||
raise ProxyError("системные пути должны быть абсолютными")
|
||||
if not (config_dir / "config").is_file():
|
||||
raise ProxyError("нет системного config")
|
||||
return RuntimeContext(config_dir, state_dir, xray_path, 0o037,
|
||||
"sudo chown root:proxy-client {0}; sudo chmod 640 {0}",
|
||||
subprocess.DEVNULL, "sudo systemctl stop proxy-client")
|
||||
|
||||
|
||||
def validate_address(value):
|
||||
@@ -157,8 +196,8 @@ def validate_address(value):
|
||||
raise ProxyError("поле address должно быть IP-адресом или простым ASCII-именем")
|
||||
|
||||
|
||||
def load_config():
|
||||
path = config_home() / "config"
|
||||
def load_config(context):
|
||||
path = context.config_dir / "config"
|
||||
if not path.exists():
|
||||
if path.is_symlink():
|
||||
raise ProxyError("машинный конфиг {} ссылается на отсутствующий файл".format(path))
|
||||
@@ -173,7 +212,10 @@ def load_config():
|
||||
|
||||
def parse_config(text):
|
||||
parser = configparser.ConfigParser(interpolation=None, empty_lines_in_values=False)
|
||||
parser.read_string(text, source="config")
|
||||
try:
|
||||
parser.read_string(text, source="config")
|
||||
except configparser.Error:
|
||||
raise ProxyError("неверный формат config; ожидается секция [proxy] с параметрами") from None
|
||||
if parser.sections() != ["proxy"]:
|
||||
raise ProxyError("нужна ровно одна секция [proxy]")
|
||||
section = parser["proxy"]
|
||||
@@ -225,9 +267,9 @@ def check_reachable(config):
|
||||
)
|
||||
|
||||
|
||||
def check_proxy(config):
|
||||
def check_proxy(config, context):
|
||||
if config.proxy_type == "xray":
|
||||
require_supervised_xray(config)
|
||||
require_supervised_xray(config, context)
|
||||
check_reachable(config)
|
||||
|
||||
|
||||
@@ -274,13 +316,15 @@ def write_private_json(path, value):
|
||||
path.chmod(0o600)
|
||||
|
||||
|
||||
def load_profile(path):
|
||||
def load_profile(path, context):
|
||||
# Права проверяем у конечного файла: у симлинка они ничего не значат.
|
||||
resolved = path.expanduser().resolve(strict=True)
|
||||
if resolved.stat().st_mode & 0o077:
|
||||
if resolved.stat().st_mode & context.profile_forbidden_mode:
|
||||
target = shlex.quote(str(resolved))
|
||||
repair = context.profile_repair.format(target)
|
||||
raise ProxyError(
|
||||
"файл профиля {} доступен другим пользователям; выполните: chmod 600 {}".format(
|
||||
resolved, shlex.quote(str(resolved))
|
||||
"файл профиля {} доступен другим пользователям; выполните: {}".format(
|
||||
resolved, repair
|
||||
)
|
||||
)
|
||||
lines = [line.strip() for line in resolved.read_text(encoding="utf-8").splitlines()]
|
||||
@@ -531,8 +575,8 @@ def build_xray_config(profile, local_address, local_port):
|
||||
}
|
||||
|
||||
|
||||
def resolve_xray():
|
||||
found = shutil.which("xray")
|
||||
def resolve_xray(context):
|
||||
found = str(context.xray_path) if context.xray_path is not None else shutil.which("xray")
|
||||
if found is None:
|
||||
raise ProxyError("xray не найден в PATH; установите его: proxy-client install")
|
||||
return str(Path(found).resolve(strict=True))
|
||||
@@ -607,7 +651,8 @@ def install_xray(destination, downloader):
|
||||
shutil.rmtree(str(staging), ignore_errors=True)
|
||||
|
||||
|
||||
def command_install(replace=False, downloader=download_file):
|
||||
def command_install(replace=False, downloader=download_file, context=None):
|
||||
context = context if context is not None else user_context()
|
||||
destination = Path.home() / ".local/bin/xray"
|
||||
if destination.is_dir():
|
||||
raise ProxyError("назначение {} является каталогом".format(destination))
|
||||
@@ -624,7 +669,7 @@ def command_install(replace=False, downloader=download_file):
|
||||
else:
|
||||
install_xray(destination, downloader)
|
||||
print("Xray {} установлен: {}".format(XRAY_VERSION, destination))
|
||||
if managed_xray_running():
|
||||
if managed_xray_running(context):
|
||||
print("Работающий Xray остался прежним; перезапустите proxy-client start")
|
||||
found = shutil.which("xray")
|
||||
if found is None or Path(found).resolve() != destination.resolve():
|
||||
@@ -651,8 +696,8 @@ def run_xray_test(path, config_path):
|
||||
raise ProxyError("созданная конфигурация не прошла xray run -test")
|
||||
|
||||
|
||||
def read_state():
|
||||
path = state_path()
|
||||
def read_state(context):
|
||||
path = context.state_path
|
||||
try:
|
||||
state = json.loads(path.read_text(encoding="utf-8"))
|
||||
keys = ("supervisor_pid", "xray_pid", "xray_path", "address", "port")
|
||||
@@ -685,32 +730,32 @@ def supervisor_running(state):
|
||||
return b"proxy-client" in cmdline
|
||||
|
||||
|
||||
def remove_state_files():
|
||||
for path in (state_path(), generated_config_path()):
|
||||
def remove_state_files(context):
|
||||
for path in (context.state_path, context.generated_config_path):
|
||||
try:
|
||||
path.unlink()
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
|
||||
|
||||
def managed_state():
|
||||
def managed_state(context):
|
||||
"""Состояние работающего Xray; устаревшие служебные файлы удаляет."""
|
||||
state = read_state()
|
||||
state = read_state(context)
|
||||
if not xray_running(state):
|
||||
remove_state_files()
|
||||
remove_state_files(context)
|
||||
raise ProxyError("управляемый Xray не запущен; устаревшие служебные файлы удалены")
|
||||
return state
|
||||
|
||||
|
||||
def managed_xray_running():
|
||||
def managed_xray_running(context):
|
||||
try:
|
||||
return xray_running(read_state())
|
||||
return xray_running(read_state(context))
|
||||
except ProxyError:
|
||||
return False
|
||||
|
||||
|
||||
def require_supervised_xray(config):
|
||||
state = managed_state()
|
||||
def require_supervised_xray(config, context):
|
||||
state = managed_state(context)
|
||||
if not supervisor_running(state):
|
||||
raise ProxyError(
|
||||
"Xray работает без proxy-client start (его процесс завершён); "
|
||||
@@ -720,7 +765,7 @@ def require_supervised_xray(config):
|
||||
raise ProxyError(
|
||||
"Xray запущен на {}:{}, а {} указывает {}:{}; чтобы применить конфиг, "
|
||||
"выполните proxy-client stop, затем proxy-client start".format(
|
||||
state["address"], state["port"], config_home() / "config",
|
||||
state["address"], state["port"], context.config_dir / "config",
|
||||
config.address, config.port,
|
||||
)
|
||||
)
|
||||
@@ -756,9 +801,9 @@ def check_port_available(address, port):
|
||||
raise ProxyError("локальный порт {} занят или недоступен".format(port))
|
||||
|
||||
|
||||
def acquire_start_lock():
|
||||
private_directory(state_home())
|
||||
lock = (state_home() / "lock").open("a")
|
||||
def acquire_start_lock(context):
|
||||
private_directory(context.state_dir)
|
||||
lock = (context.state_dir / "lock").open("a")
|
||||
try:
|
||||
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except BlockingIOError:
|
||||
@@ -832,8 +877,8 @@ def interrupt(_signum, _frame):
|
||||
raise KeyboardInterrupt
|
||||
|
||||
|
||||
def command_status(config):
|
||||
check_proxy(config)
|
||||
def command_status(config, context):
|
||||
check_proxy(config, context)
|
||||
if config.proxy_type == "external":
|
||||
print("{} (external) доступен по адресу {}:{}".format(config.name, config.address, config.port))
|
||||
else:
|
||||
@@ -841,21 +886,21 @@ def command_status(config):
|
||||
return 0
|
||||
|
||||
|
||||
def command_env(config):
|
||||
check_proxy(config)
|
||||
def command_env(config, context):
|
||||
check_proxy(config, context)
|
||||
lines = ["{}={}".format(key, value) for key, value in environment_values(config)]
|
||||
sys.stdout.write("\n".join(lines) + "\n")
|
||||
return 0
|
||||
|
||||
|
||||
def command_run(config, remainder):
|
||||
def command_run(config, remainder, context):
|
||||
if not remainder or remainder[0] != "--" or len(remainder) == 1:
|
||||
raise ProxyError("использование: proxy-client run -- COMMAND ARG...")
|
||||
command = remainder[1:]
|
||||
if shutil.which(command[0]) is None:
|
||||
sys.stderr.write("Ошибка: команда не найдена в PATH: {}\n".format(command[0]))
|
||||
return 127
|
||||
check_proxy(config)
|
||||
check_proxy(config, context)
|
||||
child_environment = os.environ.copy()
|
||||
child_environment.update(dict(environment_values(config)))
|
||||
try:
|
||||
@@ -866,10 +911,10 @@ def command_run(config, remainder):
|
||||
return exit_code(completed.returncode)
|
||||
|
||||
|
||||
def command_start(config, profile_file):
|
||||
def command_start(config, profile_file, context):
|
||||
if config.proxy_type != "xray":
|
||||
raise ProxyError(
|
||||
"start доступен только для type=xray; измените {}".format(config_home() / "config")
|
||||
"start доступен только для type=xray; измените {}".format(context.config_dir / "config")
|
||||
)
|
||||
try:
|
||||
loopback = ipaddress.ip_address(config.address).is_loopback
|
||||
@@ -877,39 +922,43 @@ def command_start(config, profile_file):
|
||||
loopback = False
|
||||
if not loopback:
|
||||
raise ProxyError("для type=xray поле address должно быть loopback-адресом, например 127.0.0.1")
|
||||
lock = acquire_start_lock()
|
||||
lock = acquire_start_lock(context)
|
||||
try:
|
||||
return run_managed_xray(config, profile_file)
|
||||
return run_managed_xray(config, profile_file, context)
|
||||
finally:
|
||||
lock.close()
|
||||
|
||||
|
||||
def run_managed_xray(config, profile_file):
|
||||
if state_path().exists():
|
||||
if xray_running(read_state()):
|
||||
def run_managed_xray(config, profile_file, context):
|
||||
if context.state_path.exists():
|
||||
if xray_running(read_state(context)):
|
||||
raise ProxyError(
|
||||
"Xray остался от прошлого proxy-client start; сначала выполните proxy-client stop"
|
||||
)
|
||||
remove_state_files()
|
||||
remove_state_files(context)
|
||||
check_port_available(ipaddress.ip_address(config.address), config.port)
|
||||
profile_path = Path(profile_file) if profile_file else config_home() / "default.url"
|
||||
profile = load_profile(profile_path)
|
||||
executable = resolve_xray()
|
||||
profile_path = Path(profile_file) if profile_file else context.config_dir / "default.url"
|
||||
profile = load_profile(profile_path, context)
|
||||
executable = resolve_xray(context)
|
||||
check_xray_version(executable)
|
||||
write_private_json(
|
||||
generated_config_path(), build_xray_config(profile, config.address, config.port)
|
||||
context.generated_config_path, build_xray_config(profile, config.address, config.port)
|
||||
)
|
||||
child = None
|
||||
try:
|
||||
run_xray_test(executable, generated_config_path())
|
||||
run_xray_test(executable, context.generated_config_path)
|
||||
print("Xray: {} ({})".format(executable, XRAY_VERSION))
|
||||
print_summary(profile, config.port)
|
||||
# SIGTERM (от proxy-client stop) и SIGHUP обрабатываем как Ctrl+C.
|
||||
signal.signal(signal.SIGTERM, interrupt)
|
||||
signal.signal(signal.SIGHUP, interrupt)
|
||||
child = subprocess.Popen([executable, "run", "-c", str(generated_config_path())])
|
||||
child = subprocess.Popen(
|
||||
[executable, "run", "-c", str(context.generated_config_path)],
|
||||
stdout=context.xray_output,
|
||||
stderr=context.xray_output,
|
||||
)
|
||||
write_private_json(
|
||||
state_path(),
|
||||
context.state_path,
|
||||
{
|
||||
"supervisor_pid": os.getpid(),
|
||||
"xray_pid": child.pid,
|
||||
@@ -924,8 +973,8 @@ def run_managed_xray(config, profile_file):
|
||||
raise ProxyError("Xray не открыл локальный порт {}".format(config.port))
|
||||
diagnose_ip(config)
|
||||
print(
|
||||
"Управляемый Xray работает на {}:{}; остановка: Ctrl+C или proxy-client stop".format(
|
||||
config.address, config.port
|
||||
"Управляемый Xray работает на {}:{}; остановка: {}".format(
|
||||
config.address, config.port, context.stop_hint
|
||||
),
|
||||
flush=True,
|
||||
)
|
||||
@@ -940,11 +989,11 @@ def run_managed_xray(config, profile_file):
|
||||
except subprocess.TimeoutExpired:
|
||||
child.kill()
|
||||
child.wait()
|
||||
remove_state_files()
|
||||
remove_state_files(context)
|
||||
|
||||
|
||||
def command_stop():
|
||||
state = managed_state()
|
||||
def command_stop(context):
|
||||
state = managed_state(context)
|
||||
# Живой супервизор сам остановит Xray; иначе Xray гасим напрямую.
|
||||
running_supervisor = supervisor_running(state)
|
||||
target = state["supervisor_pid"] if running_supervisor else state["xray_pid"]
|
||||
@@ -958,17 +1007,574 @@ def command_stop():
|
||||
os.kill(state["xray_pid"], signal.SIGKILL)
|
||||
if not wait_until(stopped, STOP_TIMEOUT):
|
||||
raise ProxyError("управляемый Xray не остановился за {} с".format(2 * STOP_TIMEOUT + 1))
|
||||
remove_state_files()
|
||||
remove_state_files(context)
|
||||
print("Управляемый Xray остановлен")
|
||||
return 0
|
||||
|
||||
|
||||
SERVICE_UNIT = """# Managed by proxy-client
|
||||
[Unit]
|
||||
Description=Proxy client (Xray)
|
||||
After=network.target
|
||||
StartLimitIntervalSec=0
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=proxy-client
|
||||
Group=proxy-client
|
||||
RuntimeDirectory=proxy-client
|
||||
RuntimeDirectoryMode=0700
|
||||
UMask=0077
|
||||
ExecStart=/usr/local/lib/proxy-client/proxy-client service run
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
TimeoutStopSec=15
|
||||
StandardOutput=journal
|
||||
StandardError=journal
|
||||
NoNewPrivileges=yes
|
||||
ProtectSystem=strict
|
||||
ProtectHome=yes
|
||||
PrivateTmp=yes
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
"""
|
||||
|
||||
|
||||
def report_journal_storage(root):
|
||||
# Приоритет каталогов соответствует journald.conf; одноимённый drop-in
|
||||
# из /etc перекрывает поставляемый системой файл.
|
||||
directories = ["usr/lib/systemd", "usr/local/lib/systemd", "run/systemd", "etc/systemd"]
|
||||
main = next((root / directory / "journald.conf"
|
||||
for directory in reversed(directories)
|
||||
if (root / directory / "journald.conf").exists()), None)
|
||||
dropins = {}
|
||||
for directory in directories:
|
||||
for path in (root / directory / "journald.conf.d").glob("*.conf"):
|
||||
dropins[path.name] = path
|
||||
storage = None
|
||||
for path in ([main] if main else []) + [dropins[name] for name in sorted(dropins)]:
|
||||
section = ""
|
||||
for line in path.read_text().splitlines():
|
||||
line = line.strip()
|
||||
if line.startswith("["):
|
||||
section = line
|
||||
elif section == "[Journal]" and re.match(r"Storage\s*=", line):
|
||||
storage = line.split("=", 1)[1].strip() or None
|
||||
if storage is None:
|
||||
print("journald: Storage не задан; сохранение журнала зависит от сборки systemd. "
|
||||
"Проверьте journalctl --list-boots после перезагрузки.")
|
||||
return
|
||||
persistent = storage == "persistent" or (
|
||||
storage == "auto" and (root / "var/log/journal").is_dir())
|
||||
print("journald: Storage={}; журнал {} между загрузками (по конфигурации).".format(
|
||||
storage, "сохраняется" if persistent else "не сохраняется"))
|
||||
|
||||
|
||||
def make_install_directory(path):
|
||||
if path.is_dir():
|
||||
return
|
||||
make_install_directory(path.parent)
|
||||
path.mkdir()
|
||||
path.chmod(0o755)
|
||||
|
||||
|
||||
def install_file(target, data, mode):
|
||||
make_install_directory(target.parent)
|
||||
descriptor, temporary = tempfile.mkstemp(prefix=".install-", dir=str(target.parent))
|
||||
try:
|
||||
with os.fdopen(descriptor, "wb") as stream:
|
||||
stream.write(data)
|
||||
os.fchmod(stream.fileno(), mode)
|
||||
os.replace(temporary, str(target))
|
||||
finally:
|
||||
if os.path.exists(temporary):
|
||||
os.unlink(temporary)
|
||||
|
||||
|
||||
def service_config(text):
|
||||
config = parse_config(text)
|
||||
try:
|
||||
loopback = ipaddress.ip_address(config.address).is_loopback
|
||||
except ValueError:
|
||||
loopback = False
|
||||
if config.proxy_type != "xray" or not loopback:
|
||||
raise ProxyError("службе нужен type=xray и loopback-адрес")
|
||||
return config
|
||||
|
||||
|
||||
def validate_service_source(source):
|
||||
missing = [name for name in ("config", "default.url") if not (source / name).is_file()]
|
||||
if missing:
|
||||
raise ProxyError("не хватает настроек {} в {}; запустите proxy-client service install "
|
||||
"в терминале для настройки или укажите готовый --config-dir".format(
|
||||
", ".join(missing), source))
|
||||
config = service_config((source / "config").read_text(encoding="utf-8"))
|
||||
load_profile(source / "default.url", user_context())
|
||||
return config
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ServiceSetupPlan:
|
||||
"""Снимок перехода; config_text=None означает обновление без изменения HOME."""
|
||||
context: RuntimeContext
|
||||
original_config: Optional[bytes]
|
||||
config_text: Optional[str]
|
||||
profile_text: Optional[str]
|
||||
manual_state: Optional[dict] = None
|
||||
resume: bool = False
|
||||
recovery_file: Optional[str] = None
|
||||
source_profile: Optional[str] = None
|
||||
|
||||
|
||||
def service_is_installed(root):
|
||||
manifest = root / "usr/local/lib/proxy-client/installed.json"
|
||||
return manifest.is_file() or manifest.with_name("installed.pending.json").is_file()
|
||||
|
||||
|
||||
def render_machine_config(config, proxy_type):
|
||||
parser = configparser.ConfigParser(interpolation=None)
|
||||
parser["proxy"] = {"type": proxy_type, "name": config.name,
|
||||
"address": config.address, "port": str(config.port),
|
||||
"no_proxy_extra": ",".join(config.no_proxy_extra)}
|
||||
output = io.StringIO()
|
||||
parser.write(output)
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
def setup_reset_hint(context):
|
||||
snapshot = context.state_dir / "service-setup.json"
|
||||
return ("Чтобы начать заново, удалите только снимок: rm -- {}\n"
|
||||
"Системные и домашние настройки эта команда не меняет.").format(shlex.quote(str(snapshot)))
|
||||
|
||||
|
||||
def check_setup_source(plan):
|
||||
path = Path(plan.source_profile) if plan.source_profile else plan.context.config_dir / "default.url"
|
||||
if plan.source_profile:
|
||||
changed = not path.is_file() or path.read_text(encoding="utf-8").strip() != plan.profile_text
|
||||
if not changed:
|
||||
load_profile(path, plan.context)
|
||||
else:
|
||||
changed = path.exists() or path.is_symlink()
|
||||
if changed:
|
||||
raise ProxyError("исходный файл VLESS-ссылки изменился; переход остановлен. " +
|
||||
setup_reset_hint(plan.context))
|
||||
|
||||
|
||||
def prepare_service_setup(args):
|
||||
context = user_context(args.profile)
|
||||
pending = context.state_dir / "service-setup.json"
|
||||
if pending.exists():
|
||||
if pending.is_symlink() or pending.stat().st_mode & 0o077:
|
||||
raise ProxyError("снимок перехода должен быть обычным закрытым файлом: {}".format(pending))
|
||||
if args.profile_file or args.port is not None:
|
||||
raise ProxyError("есть незавершённый переход; повторите без --file и --port. " +
|
||||
setup_reset_hint(context))
|
||||
try:
|
||||
data = json.loads(pending.read_text(encoding="utf-8"))
|
||||
original = data["original_config"].encode() if data["original_config"] is not None else None
|
||||
service_config(data["config_text"])
|
||||
parse_vless(data["profile_text"])
|
||||
source_profile = data["source_profile"]
|
||||
if source_profile is not None and not isinstance(source_profile, str):
|
||||
raise ValueError("неверный путь источника")
|
||||
except (KeyError, TypeError, ValueError, AttributeError, ProxyError, configparser.Error):
|
||||
raise ProxyError("снимок незавершённого перехода повреждён или устарел: {}. ".format(pending) +
|
||||
setup_reset_hint(context))
|
||||
manual_state = read_state(context) if managed_xray_running(context) else None
|
||||
plan = ServiceSetupPlan(context, original, data["config_text"], data["profile_text"],
|
||||
manual_state, True, data.get("recovery_file"), source_profile)
|
||||
check_setup_source(plan)
|
||||
return plan
|
||||
config_path = context.config_dir / "config"
|
||||
original = config_path.read_bytes() if config_path.exists() else None
|
||||
config = parse_config(original.decode("utf-8")) if original is not None else None
|
||||
# Установленные файлы ещё не означают завершённый переход из ручного режима.
|
||||
if (Path("/") / "usr/local/lib/proxy-client/installed.json").is_file() and (
|
||||
config is None or config.proxy_type != "xray"):
|
||||
if args.profile_file or args.port is not None:
|
||||
raise ProxyError("настройки службы уже существуют; измените /etc/proxy-client, "
|
||||
"обновление сохраняет их")
|
||||
return ServiceSetupPlan(context, None, None, None)
|
||||
if config_path.is_symlink():
|
||||
raise ProxyError("домашний config является симлинком; используйте --install-only")
|
||||
profile_path = Path(args.profile_file).expanduser() if args.profile_file else context.config_dir / "default.url"
|
||||
if profile_path.is_symlink() and not profile_path.exists():
|
||||
raise ProxyError("{} — битый симлинк; исправьте ссылку или выберите другой --file".format(profile_path))
|
||||
source_profile = None
|
||||
if profile_path.is_file():
|
||||
load_profile(profile_path, context)
|
||||
profile_text = profile_path.read_text(encoding="utf-8").strip()
|
||||
source_profile = str(profile_path.absolute())
|
||||
elif args.profile_file or not sys.stdin.isatty():
|
||||
raise ProxyError("нет VLESS-ссылки; укажите закрытый файл через --file или запустите в терминале")
|
||||
else:
|
||||
# getpass не должен переходить к видимому вводу, если терминал недоступен.
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error", getpass.GetPassWarning)
|
||||
try:
|
||||
profile_text = getpass.getpass("VLESS-ссылка (ввод скрыт): ").strip()
|
||||
except getpass.GetPassWarning:
|
||||
raise ProxyError("скрытый ввод недоступен; передайте ссылку через закрытый --file")
|
||||
parse_vless(profile_text)
|
||||
if config is None or config.proxy_type != "xray":
|
||||
port = DEFAULT_PORT if args.port is None else args.port
|
||||
if args.port is None and not args.yes:
|
||||
raw = input("Локальный порт [{}]: ".format(DEFAULT_PORT)).strip()
|
||||
if raw:
|
||||
try:
|
||||
port = int(raw)
|
||||
except ValueError:
|
||||
raise ProxyError("порт должен быть числом от 1 до 65535")
|
||||
config = ProxyConfig("xray", "Xray", "127.0.0.1", port,
|
||||
config.no_proxy_extra if config else DEFAULT_NO_PROXY_EXTRA)
|
||||
elif args.port is not None:
|
||||
config.port = args.port
|
||||
text = render_machine_config(config, "xray")
|
||||
service_config(text)
|
||||
manual_state = read_state(context) if managed_xray_running(context) else None
|
||||
return ServiceSetupPlan(context, original, text, profile_text, manual_state,
|
||||
recovery_file=str(profile_path.resolve()) if args.profile_file else None,
|
||||
source_profile=source_profile)
|
||||
|
||||
|
||||
def find_service_xray(explicit, home, root):
|
||||
if explicit:
|
||||
path = Path(explicit)
|
||||
if not path.is_absolute():
|
||||
raise ProxyError("xray должен быть абсолютным путём")
|
||||
return path
|
||||
local = home / ".local/bin/xray"
|
||||
if local.is_file():
|
||||
return local
|
||||
found = shutil.which("xray")
|
||||
if found:
|
||||
return Path(found).resolve()
|
||||
installed = root / "usr/local/lib/proxy-client/xray"
|
||||
return installed if installed.is_file() else None
|
||||
|
||||
|
||||
def service_systemctl(*arguments, check=True):
|
||||
return subprocess.run(["sudo", "--", "systemctl", *arguments], check=check)
|
||||
|
||||
|
||||
def service_ready(config):
|
||||
return subprocess.run(["systemctl", "is-active", "--quiet", "proxy-client.service"],
|
||||
check=False).returncode == 0 and port_open(config.address, config.port)
|
||||
|
||||
|
||||
def switch_home_to_service(plan):
|
||||
path = plan.context.config_dir / "config"
|
||||
config = service_config(plan.config_text)
|
||||
replacement = render_machine_config(config, "external").encode()
|
||||
current = path.read_bytes() if path.exists() else None
|
||||
if not path.is_symlink() and current == replacement:
|
||||
return
|
||||
if path.is_symlink() or current != plan.original_config:
|
||||
raise ProxyError("домашний config изменился во время установки; он оставлен без изменений. " +
|
||||
setup_reset_hint(plan.context))
|
||||
private_directory(plan.context.config_dir)
|
||||
if plan.original_config is not None:
|
||||
descriptor, backup = tempfile.mkstemp(prefix="config.before-service.", dir=str(path.parent))
|
||||
with os.fdopen(descriptor, "wb") as stream:
|
||||
stream.write(plan.original_config)
|
||||
print("Прежний config сохранён: {}".format(backup))
|
||||
install_file(path, replacement, 0o600)
|
||||
|
||||
|
||||
def apply_service_setup(args, plan, xray):
|
||||
if plan.config_text is None:
|
||||
with tempfile.TemporaryDirectory(prefix="proxy-service-update-") as temporary:
|
||||
if xray is None:
|
||||
xray = Path(temporary) / "xray"
|
||||
install_xray(xray, download_file)
|
||||
options = vars(args).copy()
|
||||
options.update(config_dir=str(plan.context.config_dir), xray=str(xray),
|
||||
profile="default", enable=True, start=False, restart=True)
|
||||
result = service_install(argparse.Namespace(**options))
|
||||
if result == 0:
|
||||
print("Служба обновлена и готова; её настройки и домашний профиль сохранены.")
|
||||
return result
|
||||
config = service_config(plan.config_text)
|
||||
check_setup_source(plan)
|
||||
config_path = plan.context.config_dir / "config"
|
||||
current = config_path.read_bytes() if config_path.exists() else None
|
||||
if config_path.is_symlink() or current not in (
|
||||
plan.original_config, render_machine_config(config, "external").encode()):
|
||||
raise ProxyError("домашний config изменился; переход остановлен без его замены. " +
|
||||
setup_reset_hint(plan.context))
|
||||
replacing_installed = service_is_installed(Path("/"))
|
||||
if not replacing_installed and (plan.manual_state is None or (config.address, config.port) != (
|
||||
plan.manual_state["address"], plan.manual_state["port"])):
|
||||
check_port_available(ipaddress.ip_address(config.address), config.port)
|
||||
with tempfile.TemporaryDirectory(prefix="proxy-service-") as temporary:
|
||||
source = Path(temporary)
|
||||
install_file(source / "config", plan.config_text.encode(), 0o600)
|
||||
install_file(source / "default.url", (plan.profile_text + "\n").encode(), 0o600)
|
||||
if xray is None:
|
||||
print("Скачивание проверенного Xray {}…".format(XRAY_VERSION))
|
||||
xray = source / "xray"
|
||||
install_xray(xray, download_file)
|
||||
check_xray_version(str(xray))
|
||||
generated = source / "client.json"
|
||||
write_private_json(generated, build_xray_config(parse_vless(plan.profile_text),
|
||||
config.address, config.port))
|
||||
run_xray_test(str(xray), generated)
|
||||
private_directory(plan.context.state_dir)
|
||||
pending = plan.context.state_dir / "service-setup.json"
|
||||
install_file(pending, json.dumps({
|
||||
"original_config": plan.original_config.decode() if plan.original_config is not None else None,
|
||||
"config_text": plan.config_text, "profile_text": plan.profile_text,
|
||||
"recovery_file": plan.recovery_file,
|
||||
"source_profile": plan.source_profile,
|
||||
}).encode(), 0o600)
|
||||
options = vars(args).copy()
|
||||
options.update(config_dir=str(source), xray=str(xray), profile="default",
|
||||
enable=False, start=False, restart=False, expect_profile=True)
|
||||
result = service_install(argparse.Namespace(**options))
|
||||
if result:
|
||||
if pending.exists():
|
||||
sys.stderr.write("Снимок сохранён для повторной попытки. " +
|
||||
setup_reset_hint(plan.context) + "\n")
|
||||
return result
|
||||
check_setup_source(plan)
|
||||
if managed_xray_running(plan.context):
|
||||
if read_state(plan.context) != plan.manual_state:
|
||||
raise ProxyError("ручной Xray изменился во время установки; переход остановлен")
|
||||
command_stop(plan.context)
|
||||
try:
|
||||
if replacing_installed:
|
||||
service_systemctl("stop", "proxy-client.service")
|
||||
check_port_available(ipaddress.ip_address(config.address), config.port)
|
||||
service_systemctl("enable", "--now", "proxy-client.service")
|
||||
if not wait_until(lambda: service_ready(config), 10):
|
||||
raise ProxyError("служба не стала готова")
|
||||
except (ProxyError, OSError, subprocess.CalledProcessError, KeyboardInterrupt) as error:
|
||||
cleanup = service_systemctl("disable", "--now", "proxy-client.service", check=False)
|
||||
recovery = ["proxy-client"]
|
||||
if args.profile != "default":
|
||||
recovery.extend(["--profile", args.profile])
|
||||
recovery.append("start")
|
||||
if plan.recovery_file:
|
||||
recovery.extend(["-f", plan.recovery_file])
|
||||
hint = (" Ручной Xray остановлен; вернуть его: {}.".format(
|
||||
" ".join(shlex.quote(part) for part in recovery)) if plan.manual_state else "")
|
||||
if cleanup.returncode:
|
||||
hint += " Не удалось отключить службу; выполните sudo systemctl disable --now proxy-client."
|
||||
raise ProxyError("переход не завершён; домашний config не изменён. "
|
||||
"Проверьте sudo journalctl -u proxy-client -b." + hint) from error
|
||||
try:
|
||||
switch_home_to_service(plan)
|
||||
except (ProxyError, OSError) as error:
|
||||
raise ProxyError("служба уже запущена, но домашний профиль не удалось переключить: {}".format(error))
|
||||
pending.unlink()
|
||||
print("Служба готова на {}:{}. Домашний профиль переключён на external.".format(
|
||||
config.address, config.port))
|
||||
return 0
|
||||
|
||||
|
||||
def setup_service(args):
|
||||
if os.geteuid() == 0:
|
||||
raise ProxyError("для настройки и перехода запустите proxy-client service install без sudo; "
|
||||
"для установки только файлов используйте --install-only")
|
||||
plan = prepare_service_setup(args)
|
||||
xray = find_service_xray(args.xray, Path.home(), Path("/"))
|
||||
if xray is None:
|
||||
print("Xray {} будет скачан и проверен перед установкой.".format(XRAY_VERSION))
|
||||
if plan.config_text is None:
|
||||
print("План: обновить и перезапустить службу, включить автозапуск; настройки сохранить.")
|
||||
else:
|
||||
config = service_config(plan.config_text)
|
||||
print("План: установить системную службу на {}:{}, включить автозапуск "
|
||||
"и переключить текущий профиль.".format(config.address, config.port))
|
||||
if plan.original_config and parse_config(plan.original_config.decode()).proxy_type == "external":
|
||||
print("Текущий внешний прокси будет заменён локальной службой; прежний config сохранится.")
|
||||
if plan.resume:
|
||||
print("Продолжение незавершённого перехода; изменённые настройки не будут заменены.")
|
||||
if plan.manual_state is not None:
|
||||
print("После установки файлов выбранный ручной Xray будет остановлен; "
|
||||
"текущие соединения прервутся.")
|
||||
if not args.yes and input("Продолжить? [y/N]: ").strip().lower() not in ("y", "yes", "д", "да"):
|
||||
print("Установка отменена.")
|
||||
return 0
|
||||
return apply_service_setup(args, plan, xray)
|
||||
|
||||
|
||||
def command_service_install(args):
|
||||
if args.port is not None and not 1 <= args.port <= 65535:
|
||||
raise ProxyError("порт должен быть числом от 1 до 65535")
|
||||
if args.yes and (args.root or args.install_only or args.config_dir):
|
||||
raise ProxyError("--yes нельзя совмещать с --root, --install-only или --config-dir")
|
||||
if (args.profile_file or args.port is not None) and (args.root or args.install_only or args.config_dir):
|
||||
raise ProxyError("--file и --port относятся к настройке; их нельзя совмещать "
|
||||
"с --root, --install-only или --config-dir")
|
||||
if args.yes or (sys.stdin.isatty() and not args.root and not args.install_only
|
||||
and not args.config_dir):
|
||||
return setup_service(args)
|
||||
if not (args.root or args.install_only or args.config_dir):
|
||||
raise ProxyError("без терминала выберите --yes для полного перехода "
|
||||
"или --install-only для установки только файлов")
|
||||
return service_install(args)
|
||||
|
||||
|
||||
def service_install(args):
|
||||
if args.config_dir and args.profile != "default":
|
||||
raise ProxyError("выберите --profile или --config-dir, не оба сразу")
|
||||
root = Path(args.root) if args.root else Path("/")
|
||||
if not root.is_absolute():
|
||||
raise ProxyError("root должен быть абсолютным путём")
|
||||
if args.root and (args.enable or args.start or args.restart):
|
||||
raise ProxyError("--root несовместим с --enable, --start и --restart")
|
||||
home = Path.home()
|
||||
if os.geteuid() == 0 and "SUDO_UID" in os.environ and (not args.config_dir or not args.xray):
|
||||
import pwd
|
||||
try:
|
||||
home = Path(pwd.getpwuid(int(os.environ["SUDO_UID"])).pw_dir)
|
||||
except (ValueError, KeyError):
|
||||
raise ProxyError("не удалось определить пользователя sudo; укажите --config-dir и --xray")
|
||||
source = Path(args.config_dir) if args.config_dir else user_context(args.profile, home=home).config_dir
|
||||
xray = find_service_xray(args.xray, home, root)
|
||||
if xray is None:
|
||||
raise ProxyError("Xray не найден; запустите proxy-client service install в терминале "
|
||||
"для настройки или выполните proxy-client install")
|
||||
if not all(path.is_absolute() for path in (source, xray, root)):
|
||||
raise ProxyError("config-dir, xray и root должны быть абсолютными путями")
|
||||
if not service_is_installed(root):
|
||||
validate_service_source(source)
|
||||
if not args.root and os.geteuid() != 0:
|
||||
# Пути выбираем до sudo: оно сбрасывает HOME, XDG и PATH.
|
||||
command = ["sudo", "--", sys.executable, str(Path(__file__).resolve()),
|
||||
"service", "install", "--config-dir", str(source), "--xray", str(xray)]
|
||||
if args.enable:
|
||||
command.append("--enable")
|
||||
if args.start:
|
||||
command.append("--start")
|
||||
if args.restart:
|
||||
command.append("--restart")
|
||||
if args.expect_profile:
|
||||
command.append("--expect-profile")
|
||||
print("Установка системной службы через sudo.", flush=True)
|
||||
return exit_code(subprocess.run(command, check=False).returncode)
|
||||
settings = root / "etc/proxy-client"
|
||||
# При обновлении служба уже имеет собственные настройки вне HOME.
|
||||
config_path = settings / "config" if (settings / "config").exists() else source / "config"
|
||||
config = service_config(config_path.read_text(encoding="utf-8"))
|
||||
profile_path = settings / "default.url" if (settings / "default.url").exists() else source / "default.url"
|
||||
profile_context = service_context(argparse.Namespace(config_dir=config_path.parent,
|
||||
runtime_dir=root / "run/proxy-client", xray=xray)) if profile_path.parent == settings else user_context()
|
||||
profile = load_profile(profile_path, profile_context)
|
||||
if args.expect_profile:
|
||||
expected_config = validate_service_source(source)
|
||||
expected_profile = load_profile(source / "default.url", user_context())
|
||||
if vars(config) != vars(expected_config) or build_xray_config(profile, config.address, config.port) != \
|
||||
build_xray_config(expected_profile, expected_config.address, expected_config.port):
|
||||
raise ProxyError("системные настройки отличаются от снимка перехода; они оставлены без изменений. "
|
||||
"Для их смены отредактируйте /etc/proxy-client отдельно")
|
||||
check_xray_version(str(xray))
|
||||
with tempfile.TemporaryDirectory(prefix="proxy-service-test-") as temporary:
|
||||
generated = Path(temporary) / "client.json"
|
||||
write_private_json(generated, build_xray_config(profile, config.address, config.port))
|
||||
run_xray_test(str(xray), generated)
|
||||
files = {
|
||||
"usr/local/lib/proxy-client/proxy-client": (Path(__file__).read_bytes(), 0o755),
|
||||
"usr/local/lib/proxy-client/xray": (xray.read_bytes(), 0o755),
|
||||
"etc/systemd/system/proxy-client.service": (SERVICE_UNIT.encode(), 0o644),
|
||||
"usr/lib/sysusers.d/proxy-client.conf": (
|
||||
b'u proxy-client - "Proxy client" /nonexistent /usr/sbin/nologin\n', 0o644),
|
||||
}
|
||||
manifest = root / "usr/local/lib/proxy-client/installed.json"
|
||||
pending = manifest.with_name("installed.pending.json")
|
||||
# До любой записи проверяем все назначения и компоненты пути.
|
||||
targets = [root / name for name in files] + [
|
||||
manifest, pending, settings, settings / "config", settings / "default.url"]
|
||||
for target in targets:
|
||||
if any(part.is_symlink() for part in [target, *target.parents]):
|
||||
raise ProxyError("установка через симлинк запрещена: {}".format(target))
|
||||
owned = json.loads(manifest.read_text()) if manifest.exists() else {}
|
||||
interrupted = json.loads(pending.read_text()) if pending.exists() else {}
|
||||
for name in files:
|
||||
target = root / name
|
||||
if target.exists() and (
|
||||
not target.is_file() or
|
||||
hashlib.sha256(target.read_bytes()).hexdigest() not in
|
||||
[owned.get(name)] + interrupted.get(name, [])
|
||||
):
|
||||
raise ProxyError("чужой или изменённый файл: {}".format(target))
|
||||
if not manifest.exists() and not pending.exists() and settings.exists():
|
||||
raise ProxyError("чужой каталог настроек: {}".format(settings))
|
||||
make_install_directory(manifest.parent)
|
||||
manifest.parent.chmod(0o755)
|
||||
# До замены сохраняем допустимые старые и новые хеши. После сбоя повтор
|
||||
# распознает уже записанную часть, не принимая произвольные чужие файлы.
|
||||
planned = {}
|
||||
for name, (data, _) in files.items():
|
||||
target = root / name
|
||||
planned[name] = [hashlib.sha256(data).hexdigest()]
|
||||
if target.exists():
|
||||
planned[name].append(hashlib.sha256(target.read_bytes()).hexdigest())
|
||||
install_file(pending, json.dumps(planned).encode(), 0o644)
|
||||
for name, (data, mode) in files.items():
|
||||
install_file(root / name, data, mode)
|
||||
settings.mkdir(parents=True, exist_ok=True)
|
||||
settings.chmod(0o750)
|
||||
for name in ("config", "default.url"):
|
||||
target = settings / name
|
||||
if not target.exists():
|
||||
install_file(target, (source / name).read_bytes(), 0o640)
|
||||
install_file(manifest, json.dumps({
|
||||
name: hashlib.sha256(data).hexdigest() for name, (data, _) in files.items()
|
||||
}).encode(), 0o644)
|
||||
pending.unlink()
|
||||
if not args.root:
|
||||
import grp
|
||||
subprocess.run(["systemd-sysusers", "/usr/lib/sysusers.d/proxy-client.conf"], check=True)
|
||||
gid = grp.getgrnam("proxy-client").gr_gid
|
||||
for path in (settings, settings / "config", settings / "default.url"):
|
||||
os.chown(str(path), 0, gid)
|
||||
subprocess.run(["systemctl", "daemon-reload"], check=True)
|
||||
if args.enable:
|
||||
subprocess.run(["systemctl", "enable", "proxy-client.service"], check=True)
|
||||
if args.start:
|
||||
subprocess.run(["systemctl", "start", "proxy-client.service"], check=True)
|
||||
if args.restart:
|
||||
subprocess.run(["systemctl", "stop", "proxy-client.service"], check=True)
|
||||
check_port_available(ipaddress.ip_address(config.address), config.port)
|
||||
subprocess.run(["systemctl", "start", "proxy-client.service"], check=True)
|
||||
if not wait_until(lambda: service_ready(config), 10):
|
||||
raise ProxyError("служба не стала готова; проверьте sudo journalctl -u proxy-client -b")
|
||||
print("Файлы службы установлены.")
|
||||
report_journal_storage(root)
|
||||
return 0
|
||||
|
||||
|
||||
def build_parser():
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="proxy-client",
|
||||
description="Безопасный запуск команд через явно настроенный прокси.",
|
||||
)
|
||||
parser.add_argument("--profile", default="default", help="имя пользовательского профиля")
|
||||
subparsers = parser.add_subparsers(dest="subcommand")
|
||||
service = subparsers.add_parser("service", help="системная служба")
|
||||
actions = service.add_subparsers(dest="service_action", required=True)
|
||||
serve = actions.add_parser("run", help="запуск из systemd")
|
||||
serve.add_argument("--config-dir", default="/etc/proxy-client")
|
||||
serve.add_argument("--runtime-dir", default="/run/proxy-client")
|
||||
serve.add_argument("--xray", default="/usr/local/lib/proxy-client/xray")
|
||||
setup = actions.add_parser("install", help="установить системную службу")
|
||||
setup.add_argument("--config-dir", help="каталог настроек (по умолчанию текущий профиль)")
|
||||
setup.add_argument("--xray", help="готовый Xray (по умолчанию ~/.local/bin/xray или PATH)")
|
||||
setup.add_argument("--root", help="изолированный корень без systemctl")
|
||||
setup.add_argument("--enable", action="store_true")
|
||||
setup.add_argument("--start", action="store_true")
|
||||
setup.add_argument("--restart", action="store_true", help="перезапустить и проверить готовность службы")
|
||||
setup.add_argument("--yes", "--auto-yes", action="store_true",
|
||||
help="принять план полного перехода без вопроса")
|
||||
setup.add_argument("--install-only", action="store_true",
|
||||
help="установить файлы без мастера и переключения домашнего профиля")
|
||||
setup.add_argument("-f", "--file", dest="profile_file", help="закрытый файл VLESS-ссылки для настройки")
|
||||
setup.add_argument("--port", type=int, help="локальный порт при настройке (по умолчанию 12334)")
|
||||
setup.add_argument("--expect-profile", action="store_true", help=argparse.SUPPRESS)
|
||||
install_parser = subparsers.add_parser("install", help="установить проверенный Xray")
|
||||
install_parser.add_argument(
|
||||
"--replace", action="store_true", help="заменить существующий ~/.local/bin/xray"
|
||||
@@ -992,20 +1598,31 @@ def main():
|
||||
return 2
|
||||
|
||||
try:
|
||||
if arguments.subcommand == "service":
|
||||
if arguments.service_action == "install":
|
||||
return command_service_install(arguments)
|
||||
if arguments.profile != "default":
|
||||
raise ProxyError("service run не использует пользовательские профили")
|
||||
context = service_context(arguments)
|
||||
return command_start(load_config(context), None, context)
|
||||
context = user_context(arguments.profile)
|
||||
if arguments.subcommand == "install":
|
||||
return command_install(arguments.replace)
|
||||
return command_install(arguments.replace, context=context)
|
||||
if arguments.subcommand == "stop":
|
||||
return command_stop()
|
||||
config = load_config()
|
||||
return command_stop(context)
|
||||
config = load_config(context)
|
||||
if arguments.subcommand == "status":
|
||||
return command_status(config)
|
||||
return command_status(config, context)
|
||||
if arguments.subcommand == "env":
|
||||
return command_env(config)
|
||||
return command_env(config, context)
|
||||
if arguments.subcommand == "run":
|
||||
return command_run(config, arguments.arguments)
|
||||
return command_run(config, arguments.arguments, context)
|
||||
if arguments.subcommand == "start":
|
||||
return command_start(config, arguments.profile_file)
|
||||
except (ProxyError, OSError) as error:
|
||||
return command_start(config, arguments.profile_file, context)
|
||||
except (EOFError, KeyboardInterrupt):
|
||||
sys.stderr.write("Установка или команда прервана пользователем.\n")
|
||||
return 130
|
||||
except (ProxyError, OSError, ValueError, subprocess.CalledProcessError) as error:
|
||||
sys.stderr.write("Ошибка: {}\n".format(error))
|
||||
return 1
|
||||
return 2
|
||||
|
||||
+259
-7
@@ -1,7 +1,7 @@
|
||||
# proxy-client
|
||||
|
||||
`proxy-client` — переносимый Linux/Bash-интерфейс для запуска команд через
|
||||
внешний прокси или через управляемый пользовательский Xray. Он добавляет команды
|
||||
внешний прокси или через управляемый Xray. Он добавляет команды
|
||||
`proxy_on`, `proxy_off`, `pclaude` и `pcodex`, но не подменяет обычные `claude`
|
||||
и `codex`.
|
||||
|
||||
@@ -78,7 +78,7 @@ source ~/.bash_custom
|
||||
|
||||
## Как выбирается прокси
|
||||
|
||||
Режим определяется только машинным файлом
|
||||
Без выбора профиля режим определяется файлом
|
||||
`~/.config/proxy-client/config`:
|
||||
|
||||
| Машинный конфиг | Используется | Что запускать |
|
||||
@@ -212,14 +212,55 @@ proxy-client install
|
||||
proxy-client start
|
||||
```
|
||||
|
||||
Другой закрытый профиль можно выбрать без замены `default.url`:
|
||||
Другой файл VLESS-ссылки можно выбрать без замены `default.url`:
|
||||
|
||||
```bash
|
||||
proxy-client start -f ~/.config/proxy-client/work.url
|
||||
```
|
||||
|
||||
Для переключения профиля сначала выполните `proxy-client stop`. Все файлы с
|
||||
настоящими VLESS-ссылками должны иметь права `600` и не должны попадать в Git.
|
||||
Для смены ссылки работающего экземпляра сначала выполните `proxy-client stop`.
|
||||
Все файлы с настоящими VLESS-ссылками должны иметь права `600` и не должны
|
||||
попадать в Git.
|
||||
|
||||
## Именованные профили
|
||||
|
||||
Профиль объединяет настройки локального входа, исключения и, для Xray,
|
||||
VLESS-ссылку. Без указания имени используется `default`: прежние `config` и
|
||||
`default.url` остаются на своих местах. Дополнительные профили живут в
|
||||
`~/.config/proxy-client/profiles/<имя>/`. При заданном `XDG_CONFIG_HOME`
|
||||
вместо `~/.config` используется этот каталог.
|
||||
|
||||
Например, создайте профиль `work`:
|
||||
|
||||
```bash
|
||||
mkdir -p ~/.config/proxy-client/profiles/work
|
||||
cp ~/.config/proxy-client/examples/config.xray ~/.config/proxy-client/profiles/work/config
|
||||
$EDITOR ~/.config/proxy-client/profiles/work/config
|
||||
```
|
||||
|
||||
В `config` задайте свободный порт, например `12335`, если основной прокси
|
||||
занимает `12334`. Поместите VLESS-ссылку в `profiles/work/default.url` и
|
||||
ограничьте доступ:
|
||||
|
||||
```bash
|
||||
chmod 600 ~/.config/proxy-client/profiles/work/default.url
|
||||
proxy-client --profile work start
|
||||
```
|
||||
|
||||
Команда остаётся в терминале. В другом терминале можно проверить или
|
||||
остановить именно этот профиль:
|
||||
|
||||
```bash
|
||||
proxy-client --profile work status
|
||||
proxy-client --profile work stop
|
||||
```
|
||||
|
||||
Параметр `--profile` ставится перед подкомандой. Неизвестный профиль даёт
|
||||
ошибку; перехода на `default` нет. Разные профили могут работать одновременно
|
||||
на разных портах. Остановка одного не затрагивает остальные.
|
||||
|
||||
`start -f FILE` переопределяет только файл ссылки выбранного профиля на этот
|
||||
запуск. Его порт и исключения по-прежнему берутся из `config`.
|
||||
|
||||
## Ежедневное использование
|
||||
|
||||
@@ -243,6 +284,24 @@ proxy-client start -f ~/.config/proxy-client/work.url
|
||||
обёрнуты и не выполняют предварительную проверку, но после `proxy_on` наследуют
|
||||
прокси-переменные, как и любой другой дочерний процесс.
|
||||
|
||||
Для именованного профиля:
|
||||
|
||||
```bash
|
||||
proxy_on --profile work
|
||||
pclaude --proxy-profile work
|
||||
pcodex --proxy-profile work --search
|
||||
proxy-client --profile work run -- COMMAND ARG...
|
||||
```
|
||||
|
||||
У `pclaude` и `pcodex` параметр `--proxy-profile` должен быть первым.
|
||||
Обычный `--profile` передаётся запускаемой программе.
|
||||
|
||||
`proxy_on --profile work` меняет окружение терминала, но не профиль по
|
||||
умолчанию: обычный `codex` наследует это окружение, а `pcodex` без параметра
|
||||
выберет `default`. `proxy_off` только очищает переменные — работающие прокси,
|
||||
включая системную службу, остаются запущенными. `myip` использует текущее
|
||||
окружение.
|
||||
|
||||
### Жизненный цикл Xray
|
||||
|
||||
```bash
|
||||
@@ -253,7 +312,7 @@ proxy-client stop
|
||||
```
|
||||
|
||||
`start` сначала проверяет версию и конфигурацию Xray, затем остаётся на переднем
|
||||
плане. Systemd, фоновый автозапуск и скрытый запуск из `run` не используются.
|
||||
плане. Скрытого запуска из `run` нет; системная служба устанавливается отдельно.
|
||||
Один loopback-порт принимает HTTP CONNECT и SOCKS5.
|
||||
|
||||
Остановить Xray можно двумя способами: `Ctrl+C` в окне `start` или
|
||||
@@ -262,7 +321,200 @@ proxy-client stop
|
||||
остаться работать: `status` и `env` тогда сообщат об ошибке, а `stop` добьёт его
|
||||
и уберёт файлы. `stop` работает и после изменения машинного типа на `external`.
|
||||
|
||||
Второй `start`, пока первый работает, завершится ошибкой.
|
||||
Второй `start` того же профиля, пока первый работает, завершится ошибкой.
|
||||
|
||||
## Системная служба
|
||||
|
||||
Этот режим нужен, когда приложения должны получать прокси после загрузки
|
||||
Linux, до входа пользователя. Требуются systemd, `systemd-sysusers` и права
|
||||
администратора для установки. Служба одна; именованные профили остаются
|
||||
пользовательскими.
|
||||
|
||||
### Установка и переход из tmux
|
||||
|
||||
Запустите от своего пользователя, без `sudo`:
|
||||
|
||||
```bash
|
||||
proxy-client service install
|
||||
```
|
||||
|
||||
В терминале команда показывает план и просит одно подтверждение.
|
||||
Если настроек нет, она запросит VLESS-ссылку скрытым вводом и предложит
|
||||
локальный порт `12334`. Если Xray отсутствует, скачает закреплённую версию
|
||||
и проверит контрольную сумму. Ссылка не попадает в аргументы процессов и журнал.
|
||||
|
||||
Если профиль уже настроен, используются его `config` и `default.url`.
|
||||
После подтверждения команда проверяет конфигурацию Xray, устанавливает
|
||||
системные файлы через `sudo`, останавливает свой ручной Xray и запускает службу
|
||||
с автозапуском. Текущие соединения при переходе прервутся. Чужой процесс,
|
||||
занимающий порт, команда не останавливает.
|
||||
|
||||
Когда служба активна и локальный порт доступен, домашний `config` переключается
|
||||
на `type=external`. Поэтому `proxy_on`, `status` и `run` сразу работают со
|
||||
службой. Прежний файл сохраняется рядом как `config.before-service.*`.
|
||||
Готовность локального порта не гарантирует доступность удалённого сервера.
|
||||
|
||||
Если файлы службы уже установлены через `--install-only`, но домашний профиль
|
||||
ещё имеет `type=xray`, мастер завершит перенос. Сначала он проверит совпадение
|
||||
настроек с системными; другой профиль не заменит уже настроенную службу.
|
||||
|
||||
Для именованного профиля:
|
||||
|
||||
```bash
|
||||
proxy-client --profile work service install
|
||||
```
|
||||
|
||||
Для принятия плана без вопроса есть `--yes` и его синоним `--auto-yes`:
|
||||
|
||||
```bash
|
||||
proxy-client service install --yes
|
||||
```
|
||||
|
||||
При настройке с нуля без терминала передайте закрытый файл со ссылкой:
|
||||
|
||||
```bash
|
||||
chmod 600 ~/connection.url
|
||||
proxy-client service install --auto-yes --file ~/connection.url --port 12334
|
||||
```
|
||||
|
||||
`--file` также подходит, если ручной Xray запускался с разовой ссылкой
|
||||
через `start -f`. Без него берётся сохранённый `default.url`.
|
||||
`--yes` принимает план, но не заменяет ввод недостающей ссылки и не отменяет
|
||||
проверки или запрос пароля `sudo`.
|
||||
|
||||
### Ошибка или прерывание
|
||||
|
||||
До успешной установки системных файлов ручной Xray продолжает работать.
|
||||
Если запуск службы не удался после его остановки, домашний профиль остаётся
|
||||
прежним. Команда пытается отключить неудачно запущенную службу и показывает,
|
||||
как вернуть ручной запуск. Восстановить прежние соединения и процесс в tmux
|
||||
автоматически нельзя.
|
||||
|
||||
Повторите `proxy-client service install`: незавершённый переход продолжится
|
||||
по закрытому снимку `service-setup.json` в каталоге состояния выбранного
|
||||
профиля. Снимок содержит VLESS-ссылку, имеет права `600` в каталоге `700`
|
||||
и удаляется после успеха. Если домашние или системные настройки успели
|
||||
измениться, команда остановится, чтобы их не затереть. Проверяется также
|
||||
исходный `default.url` или файл, переданный через `--file`, до остановки
|
||||
ручного Xray. После запуска служба использует свою копию ссылки; позднее
|
||||
изменение исходной ссылки не отменяет завершение перехода.
|
||||
|
||||
Чтобы отказаться от старого снимка и прочитать текущие настройки заново,
|
||||
удалите только `service-setup.json`: точную команду `rm -- …` CLI печатает
|
||||
при конфликте. Для профиля по умолчанию без переопределения XDG это:
|
||||
|
||||
```bash
|
||||
rm -- ~/.local/state/proxy-client/service-setup.json
|
||||
proxy-client service install
|
||||
```
|
||||
|
||||
Сброс снимка не меняет домашние файлы, настройки службы и работающие процессы.
|
||||
Если системные настройки уже отличаются от желаемых, их нужно изменить
|
||||
отдельно в `/etc/proxy-client` — мастер их не перезаписывает.
|
||||
|
||||
### Только установка файлов
|
||||
|
||||
Для прежнего режима без мастера и переключения домашнего профиля:
|
||||
|
||||
```bash
|
||||
proxy-client service install --install-only
|
||||
```
|
||||
|
||||
Без терминала явно выберите `--yes` для полного перехода или `--install-only`
|
||||
для установки файлов; команда без выбора режима завершится с подсказкой.
|
||||
Режим установки файлов требует готовые
|
||||
настройки и Xray, а при их отсутствии выдаёт подсказку до вызова `sudo`.
|
||||
`--enable`, `--start` и `--restart` явно включают автозапуск, запуск сейчас
|
||||
или перезапуск с проверкой готовности. Без этих флагов служба не запускается.
|
||||
|
||||
Xray ищется в `~/.local/bin`, затем в `PATH` и системной установке.
|
||||
Параметр `--xray FILE` переопределяет выбор. Для установки из произвольного
|
||||
каталога есть `--config-dir DIR`: он тоже выбирает режим установки файлов.
|
||||
Пути должны быть абсолютными; `--config-dir` несовместим с именованным
|
||||
`--profile`. Прямой запуск через `sudo` подходит для `--install-only`;
|
||||
нестандартный каталог XDG в этом случае задавайте через `--config-dir`.
|
||||
|
||||
### Доступ к прокси
|
||||
|
||||
Xray слушает только числовой loopback-адрес: `127.0.0.1` или `::1`.
|
||||
Проверка выполняется при установке и каждом запуске. Адреса всех интерфейсов
|
||||
(`0.0.0.0`, `::`) и локальной сети не принимаются. Другие процессы на этой же
|
||||
машине могут пользоваться прокси.
|
||||
|
||||
Установщик копирует настройки в `/etc/proxy-client/`, а CLI и Xray — в
|
||||
`/usr/local/lib/proxy-client/`. Служба больше не зависит от домашнего каталога.
|
||||
Изменения исходного пользовательского профиля на неё не влияют. Системные
|
||||
настройки имеют владельца `root`, группу `proxy-client` и права `640`;
|
||||
каталог — `750`. Процесс работает под отдельным пользователем `proxy-client`.
|
||||
Временные файлы находятся в закрытом `/run/proxy-client/`.
|
||||
|
||||
Управление и журнал:
|
||||
|
||||
```bash
|
||||
sudo systemctl status proxy-client
|
||||
sudo systemctl stop proxy-client
|
||||
sudo systemctl start proxy-client
|
||||
sudo systemctl restart proxy-client
|
||||
sudo journalctl -u proxy-client -b
|
||||
sudo journalctl -u proxy-client -f
|
||||
```
|
||||
|
||||
Для изменения настроек отредактируйте `/etc/proxy-client/config` или
|
||||
`/etc/proxy-client/default.url` с правами администратора, затем перезапустите
|
||||
службу. Сохраняйте владельца, группу и права файлов.
|
||||
|
||||
После аварии systemd повторяет запуск с паузой в пять секунд. Явная команда
|
||||
`stop` оставляет службу остановленной, но не отменяет запуск при следующей
|
||||
загрузке. Чтобы отключить автозапуск и остановить её сразу:
|
||||
|
||||
```bash
|
||||
sudo systemctl disable --now proxy-client
|
||||
```
|
||||
|
||||
Чтобы включить обратно:
|
||||
|
||||
```bash
|
||||
sudo systemctl enable --now proxy-client
|
||||
```
|
||||
|
||||
При обновлении повторите команду из актуальной копии пакета:
|
||||
|
||||
```bash
|
||||
proxy-client service install
|
||||
```
|
||||
|
||||
Мастер предложит обновить и перезапустить службу. Настройки в
|
||||
`/etc/proxy-client` сохраняются, домашний профиль не меняется и может
|
||||
отсутствовать. Без терминала используйте `--yes` для этого же действия.
|
||||
Режим `--install-only` по-прежнему не перезапускает службу без явного флага.
|
||||
|
||||
Чужие или вручную изменённые исполняемые файлы и unit-файл установщик
|
||||
не заменяет; изменения параметров systemd делайте через
|
||||
`sudo systemctl edit proxy-client`. Файлы заменяются
|
||||
по одному атомарно, общего отката всей установки при сбое нет. После
|
||||
устранения причины сбоя повторите установку: журнал незавершённой установки
|
||||
позволяет продолжить её, сохраняя проверку принадлежности файлов.
|
||||
|
||||
Вывод CLI поступает в journald. Сырой вывод Xray в системном режиме подавлен,
|
||||
чтобы сообщения с фрагментами конфигурации не раскрывали секреты; детальные
|
||||
сетевые журналы Xray поэтому недоступны. Установщик сообщает настройку хранения
|
||||
journald, но не меняет её. Сохранение журнала после перезагрузки зависит от
|
||||
настроек машины; проверить предыдущие загрузки можно через
|
||||
`sudo journalctl --list-boots`.
|
||||
|
||||
Открытый локальный порт не гарантирует доступность удалённого сервера.
|
||||
На ноутбуке сеть может появиться позже службы. Приложениям без повторения
|
||||
запросов понадобится отдельная настройка ожидания готовности.
|
||||
|
||||
Для `proxy_on`, `pclaude`, `pcodex` и `run` системная служба — внешний прокси:
|
||||
укажите в нужном пользовательском профиле `type = external`, адрес
|
||||
`127.0.0.1` и порт службы. Дополнительный профиль типа `xray` запускайте вручную
|
||||
на другом порту. Пользовательский `stop` системной службой не управляет.
|
||||
|
||||
Для проверки размещения файлов без установки на машину есть
|
||||
`service install --config-dir DIR --xray FILE --root /absolute/staging`.
|
||||
Этот режим не вызывает systemd, не создаёт системную учётную запись и не
|
||||
назначает ей владельцев; он несовместим с `--enable` и `--start`.
|
||||
|
||||
## Прокси в настройках Codex и Claude Code
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ from urllib.parse import quote
|
||||
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
CLI = REPO_ROOT / "proxy-client/.local/bin/proxy-client"
|
||||
CLI = Path(os.environ.get("PROXY_CLIENT_TEST_CLI", str(REPO_ROOT / "proxy-client/.local/bin/proxy-client")))
|
||||
UUID = "11111111-2222-4333-8444-555555555555"
|
||||
PATH_SECRET = "/tenant/PATH_SENTINEL_a1b2"
|
||||
PROFILE = (
|
||||
@@ -28,7 +28,7 @@ REALITY_PROFILE = (
|
||||
"vless://{}@edge.example:443?type=tcp&security=reality&encryption=none"
|
||||
"&flow=xtls-rprx-vision&sni=front.example&fp=chrome&pbk={}&sid={}#Synthetic"
|
||||
).format(UUID, PBK, SID)
|
||||
READY = "остановка: Ctrl+C или proxy-client stop"
|
||||
READY = "Управляемый Xray работает на"
|
||||
|
||||
# Поддельный Xray — симлинк на интерпретатор Python: тогда /proc/PID/exe
|
||||
# совпадает с разрешённым путём к xray, как у настоящего бинарника.
|
||||
@@ -102,6 +102,56 @@ class ManagedXrayTest(unittest.TestCase):
|
||||
self.write_machine_config()
|
||||
self.profile = self.write_profile(self.config_dir / "default.url")
|
||||
|
||||
def test_profiles_run_independently_and_export_selected_environment(self):
|
||||
first = self.start()
|
||||
named = self.config_dir / "profiles/second"
|
||||
named.mkdir(parents=True)
|
||||
second_port = free_port()
|
||||
(named / "config").write_text(
|
||||
(self.config_dir / "config").read_text().replace(str(self.port), str(second_port)))
|
||||
# Переопределение -f должно работать без default.url у второго профиля.
|
||||
second = self.start("-f", str(self.profile), cli_prefix=["--profile", "second", "start"])
|
||||
self.assertIn("proxy-client --profile second stop", self.start_output)
|
||||
status = self.run_cli("--profile", "second", "status")
|
||||
self.assertEqual(status.returncode, 0, status.stderr)
|
||||
env = self.run_cli("--profile", "second", "env")
|
||||
self.assertIn("127.0.0.1:" + str(second_port), env.stdout)
|
||||
run = self.run_cli("--profile", "second", "run", "--", sys.executable,
|
||||
"-c", "import os,sys; print(os.environ['HTTP_PROXY']); sys.exit(23)")
|
||||
self.assertEqual(run.returncode, 23, run.stderr)
|
||||
self.assertIn("127.0.0.1:" + str(second_port), run.stdout)
|
||||
collision = self.run_cli("--profile", "second", "start", "-f", str(self.profile))
|
||||
self.assertEqual(collision.returncode, 1)
|
||||
stopped = self.run_cli("--profile", "second", "stop")
|
||||
self.assertEqual(stopped.returncode, 0, stopped.stderr)
|
||||
second.communicate(timeout=10)
|
||||
self.assertIsNone(first.poll())
|
||||
self.assertEqual(self.run_cli("--profile", "default", "status").returncode, 0)
|
||||
self.assertEqual(self.run_cli("stop").returncode, 0)
|
||||
first.communicate(timeout=10)
|
||||
|
||||
def test_service_run_uses_explicit_paths_and_pinned_binary(self):
|
||||
runtime = self.root / "service-runtime"
|
||||
process = self.start(cli_prefix=[
|
||||
"service", "run", "--config-dir", str(self.config_dir),
|
||||
"--runtime-dir", str(runtime), "--xray", str(self.xray),
|
||||
], PATH="/usr/bin:/bin")
|
||||
self.assertTrue((runtime / "state.json").exists())
|
||||
self.assertFalse(self.state_dir.exists())
|
||||
process.terminate()
|
||||
process.communicate(timeout=10)
|
||||
self.assertEqual(process.returncode, 0)
|
||||
self.assertFalse((runtime / "client.json").exists())
|
||||
|
||||
def test_system_profile_permission_hint_preserves_group_read(self):
|
||||
self.profile.chmod(0o644)
|
||||
result = self.run_cli("service", "run", "--config-dir", str(self.config_dir),
|
||||
"--runtime-dir", str(self.root / "system-runtime"),
|
||||
"--xray", str(self.xray))
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn("chmod 640", result.stderr)
|
||||
self.assertIn("chown root:proxy-client", result.stderr)
|
||||
|
||||
def write_machine_config(self, address="127.0.0.1"):
|
||||
self.config_dir.mkdir(parents=True, exist_ok=True)
|
||||
(self.config_dir / "config").write_text(
|
||||
@@ -126,10 +176,10 @@ class ManagedXrayTest(unittest.TestCase):
|
||||
check=False,
|
||||
)
|
||||
|
||||
def start(self, *arguments, **environment):
|
||||
def start(self, *arguments, cli_prefix=None, **environment):
|
||||
"""Запускает start и ждёт строку готовности; возвращает процесс."""
|
||||
process = subprocess.Popen(
|
||||
[str(CLI), "start"] + list(arguments),
|
||||
[str(CLI)] + (cli_prefix or ["start"]) + list(arguments),
|
||||
cwd=str(self.root),
|
||||
env=dict(self.environment, **environment),
|
||||
text=True,
|
||||
|
||||
@@ -33,8 +33,13 @@ assert_eq() {
|
||||
PROXY_CLIENT_BIN="$TEST_ROOT/proxy-client"
|
||||
cat > "$PROXY_CLIENT_BIN" <<'EOF'
|
||||
#!/usr/bin/env bash
|
||||
if [ -n "${FAKE_CALL_LOG:-}" ]; then
|
||||
printf '<%s>\n' "$@" >> "$FAKE_CALL_LOG"
|
||||
fi
|
||||
if [ "$1" = env ]; then
|
||||
printf '%s\n' "$FAKE_ENV_OUTPUT"
|
||||
elif [ "$#" -eq 3 ] && [ "$1" = --profile ] && [ "$2" = work ] && [ "$3" = env ]; then
|
||||
printf '%s\n' "$FAKE_PROFILE_ENV_OUTPUT"
|
||||
else
|
||||
printf '<%s>\n' "$@"
|
||||
fi
|
||||
@@ -69,6 +74,42 @@ source "$SHELL_MODULE"
|
||||
)
|
||||
ok "proxy_on применяет восемь переменных"
|
||||
|
||||
# Выбор профиля меняет окружение только текущей оболочки.
|
||||
(
|
||||
unset "${PROXY_KEYS[@]}"
|
||||
FAKE_ENV_OUTPUT="$VALID_ENV" \
|
||||
FAKE_PROFILE_ENV_OUTPUT='HTTP_PROXY=http://work.test:4321
|
||||
HTTPS_PROXY=http://work.test:4321
|
||||
ALL_PROXY=socks5://work.test:4321
|
||||
NO_PROXY=work.test,localhost
|
||||
http_proxy=http://work.test:4321
|
||||
https_proxy=http://work.test:4321
|
||||
all_proxy=socks5://work.test:4321
|
||||
no_proxy=work.test,localhost' \
|
||||
proxy_on --profile work >/dev/null
|
||||
assert_eq http://work.test:4321 "$HTTP_PROXY" "proxy_on не выбрал профиль work"
|
||||
assert_eq socks5://work.test:4321 "$all_proxy" "SOCKS выбранного профиля"
|
||||
assert_eq work.test,localhost "$NO_PROXY" "исключения выбранного профиля"
|
||||
)
|
||||
ok "proxy_on выбирает именованный профиль"
|
||||
|
||||
# Неверный синтаксис proxy_on отклоняется до изменения окружения.
|
||||
assert_invalid_proxy_on() (
|
||||
for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
|
||||
local rc=0
|
||||
FAKE_ENV_OUTPUT="$VALID_ENV" proxy_on "$@" >/dev/null 2>&1 || rc=$?
|
||||
assert_eq 2 "$rc" "proxy_on принял неверные аргументы: $*"
|
||||
for key in "${PROXY_KEYS[@]}"; do
|
||||
assert_eq old "${!key}" "$key изменился после неверных аргументов"
|
||||
done
|
||||
)
|
||||
assert_invalid_proxy_on env
|
||||
assert_invalid_proxy_on --profile
|
||||
assert_invalid_proxy_on --profile ""
|
||||
assert_invalid_proxy_on --profile work extra
|
||||
assert_invalid_proxy_on --unknown work
|
||||
ok "proxy_on отклоняет неверные аргументы без изменения окружения"
|
||||
|
||||
# Ошибка CLI или непонятный вывод не меняют окружение ни на одну переменную.
|
||||
for case_spec in "1|$VALID_ENV" "0|$VALID_ENV
|
||||
EXTRA_PROXY=bad" "0|BROKEN-LINE"; do
|
||||
@@ -85,15 +126,33 @@ EXTRA_PROXY=bad" "0|BROKEN-LINE"; do
|
||||
done
|
||||
ok "неуспешный env не меняет окружение"
|
||||
|
||||
# Даже пригодный вывод не применяется, если проверка выбранного прокси не прошла.
|
||||
(
|
||||
for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
|
||||
unset no_proxy
|
||||
if FAKE_RC=1 FAKE_PROFILE_ENV_OUTPUT="$VALID_ENV" proxy_on --profile work >/dev/null 2>&1; then
|
||||
fail "proxy_on принял отказ проверки выбранного профиля"
|
||||
fi
|
||||
for key in "${PROXY_KEYS[@]}"; do
|
||||
if [[ "$key" == no_proxy ]]; then
|
||||
[ -z "${!key+set}" ] || fail "$key появился после ошибки"
|
||||
else
|
||||
assert_eq old "${!key}" "$key изменился после ошибки выбранного профиля"
|
||||
fi
|
||||
done
|
||||
)
|
||||
ok "отказ проверки выбранного профиля сохраняет окружение"
|
||||
|
||||
# proxy_off очищает оба регистра.
|
||||
(
|
||||
for key in "${PROXY_KEYS[@]}"; do export "$key=x"; done
|
||||
proxy_off >/dev/null
|
||||
FAKE_CALL_LOG="$TEST_ROOT/off-calls" proxy_off >/dev/null
|
||||
[ ! -e "$TEST_ROOT/off-calls" ] || fail "proxy_off вызвал CLI"
|
||||
for key in "${PROXY_KEYS[@]}"; do
|
||||
[ -z "${!key+set}" ] || fail "$key не очищен"
|
||||
done
|
||||
)
|
||||
ok "proxy_off очищает восемь переменных"
|
||||
ok "proxy_off очищает восемь переменных без вызова CLI"
|
||||
|
||||
# Обёртки передают CLI команду, аргументы и код возврата без искажений.
|
||||
(
|
||||
@@ -116,6 +175,60 @@ ok "proxy_off очищает восемь переменных"
|
||||
)
|
||||
ok "pclaude и pcodex передают аргументы и код выхода"
|
||||
|
||||
# Ведущий --proxy-profile относится к прокси, обычный --profile — к программе.
|
||||
(
|
||||
for wrapper in pclaude pcodex; do
|
||||
rc=0
|
||||
output="$(FAKE_RC=42 "$wrapper" --proxy-profile work --profile personal "a b" "")" || rc=$?
|
||||
assert_eq 42 "$rc" "$wrapper не сохранил код возврата с профилем"
|
||||
assert_eq $'<--profile>\n<work>\n<run>\n<-->\n<'"${wrapper#p}"$'>\n<--profile>\n<personal>\n<a b>\n<>' "$output" \
|
||||
"$wrapper исказил выбор профиля или аргументы ребенка"
|
||||
done
|
||||
)
|
||||
ok "обёртки выбирают профиль прокси и сохраняют аргументы ребенка"
|
||||
|
||||
# Отсутствующее имя профиля не должно запускать дочернюю команду.
|
||||
(
|
||||
for wrapper in pclaude pcodex; do
|
||||
for empty_name in missing empty; do
|
||||
args=(--proxy-profile)
|
||||
if [[ "$empty_name" == empty ]]; then args+=(""); fi
|
||||
rc=0
|
||||
output="$("$wrapper" "${args[@]}" 2>/dev/null)" || rc=$?
|
||||
assert_eq 2 "$rc" "$wrapper принял --proxy-profile без имени"
|
||||
assert_eq "" "$output" "$wrapper вызвал CLI без имени профиля"
|
||||
done
|
||||
done
|
||||
)
|
||||
ok "обёртки отклоняют --proxy-profile без имени"
|
||||
|
||||
# Только ведущий --proxy-profile выбирает профиль прокси.
|
||||
(
|
||||
for wrapper in pclaude pcodex; do
|
||||
output="$("$wrapper" --profile personal --proxy-profile child "a b" "")"
|
||||
assert_eq $'<run>\n<-->\n<'"${wrapper#p}"$'>\n<--profile>\n<personal>\n<--proxy-profile>\n<child>\n<a b>\n<>' "$output" \
|
||||
"$wrapper забрал аргументы ребенка"
|
||||
done
|
||||
)
|
||||
ok "обычный --profile и неведущий --proxy-profile остаются ребенку"
|
||||
|
||||
# Запуск с профилем не меняет окружение вызывающей оболочки.
|
||||
(
|
||||
for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
|
||||
unset no_proxy
|
||||
for wrapper in pclaude pcodex; do
|
||||
"$wrapper" --proxy-profile work >/dev/null
|
||||
for key in "${PROXY_KEYS[@]}"; do
|
||||
if [[ "$key" == no_proxy ]]; then
|
||||
[ -z "${!key+set}" ] || fail "$wrapper экспортировал $key"
|
||||
else
|
||||
assert_eq old "${!key}" "$wrapper изменил $key"
|
||||
fi
|
||||
done
|
||||
done
|
||||
)
|
||||
ok "обёртки сохраняют окружение вызывающей оболочки"
|
||||
|
||||
# .bash_custom подключает и общие функции, и proxy-модуль.
|
||||
(
|
||||
home="$TEST_ROOT/home"
|
||||
|
||||
@@ -0,0 +1,353 @@
|
||||
"""Публичный CLI профилей и установка в изолированный корень."""
|
||||
import os
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
CLI = Path(__file__).resolve().parents[1] / 'proxy-client/.local/bin/proxy-client'
|
||||
|
||||
|
||||
class ProfilesServiceTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(tmp.cleanup)
|
||||
self.root = Path(tmp.name)
|
||||
self.config = self.root / 'config/proxy-client'
|
||||
self.config.mkdir(parents=True)
|
||||
self.env = dict(os.environ, HOME=str(self.root), XDG_CONFIG_HOME=str(self.root / 'config'),
|
||||
XDG_STATE_HOME=str(self.root / 'state'))
|
||||
|
||||
def cli(self, *args):
|
||||
return subprocess.run([str(CLI), *map(str, args)], env=self.env,
|
||||
stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=15)
|
||||
|
||||
def test_unknown_profile_never_falls_back_even_for_stop(self):
|
||||
for command in ('status', 'env', 'run', 'start', 'stop'):
|
||||
result = self.cli('--profile', 'missing', command)
|
||||
self.assertEqual(result.returncode, 1, result.stderr)
|
||||
self.assertIn('неизвестный профиль', result.stderr)
|
||||
result = self.cli('--profile', '../escape', 'stop')
|
||||
self.assertEqual(result.returncode, 1)
|
||||
self.assertIn('имя профиля', result.stderr)
|
||||
|
||||
def install_args(self):
|
||||
source = self.root / 'source'
|
||||
source.mkdir(exist_ok=True)
|
||||
(source / 'config').write_text('[proxy]\ntype=xray\nname=Service\nno_proxy_extra=\naddress=127.0.0.1\nport=12345\n')
|
||||
(source / 'default.url').write_text(
|
||||
'vless://11111111-2222-4333-8444-555555555555@cdn.example:443'
|
||||
'?type=xhttp&security=tls&encryption=none&sni=cdn.example&fp=chrome&path=%2Ftest\n')
|
||||
(source / 'default.url').chmod(0o600)
|
||||
xray = self.root / 'xray'
|
||||
xray.write_text('#!/bin/sh\n[ "$1" != version ] || echo "Xray 26.10.10 (fake)"\nexit 0\n')
|
||||
xray.chmod(0o755)
|
||||
return ['service', 'install', '--config-dir', source, '--xray', xray,
|
||||
'--root', self.root / 'stage']
|
||||
|
||||
def test_staged_install_is_standalone_and_preserves_config(self):
|
||||
args = self.install_args()
|
||||
result = self.cli(*args)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
stage = self.root / 'stage'
|
||||
unit = (stage / 'etc/systemd/system/proxy-client.service').read_text()
|
||||
self.assertIn('User=proxy-client', unit)
|
||||
self.assertIn('Restart=on-failure', unit)
|
||||
self.assertIn('RuntimeDirectoryMode=0700', unit)
|
||||
self.assertIn('StandardOutput=journal', unit)
|
||||
self.assertNotIn(str(self.root), unit)
|
||||
self.assertTrue((stage / 'usr/local/lib/proxy-client/xray').is_file())
|
||||
self.assertTrue((stage / 'usr/lib/sysusers.d/proxy-client.conf').is_file())
|
||||
config = stage / 'etc/proxy-client/config'
|
||||
config.write_text(config.read_text() + '# preserved\n')
|
||||
result = self.cli(*args)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn('# preserved', config.read_text())
|
||||
self.assertEqual((stage / 'etc/proxy-client/default.url').stat().st_mode & 0o777, 0o640)
|
||||
self.assertIn('journald', result.stdout)
|
||||
|
||||
def test_install_defaults_copy_current_profile_and_local_xray(self):
|
||||
args = self.install_args()
|
||||
source, xray = args[3], args[5]
|
||||
for name in ('config', 'default.url'):
|
||||
(source / name).replace(self.config / name)
|
||||
local_xray = self.root / '.local/bin/xray'
|
||||
local_xray.parent.mkdir(parents=True)
|
||||
xray.replace(local_xray)
|
||||
result = self.cli('service', 'install', '--root', self.root / 'stage')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
settings = self.root / 'stage/etc/proxy-client'
|
||||
for name in ('config', 'default.url'):
|
||||
self.assertEqual((self.config / name).read_bytes(), (settings / name).read_bytes())
|
||||
self.assertEqual(local_xray.read_bytes(),
|
||||
(self.root / 'stage/usr/local/lib/proxy-client/xray').read_bytes())
|
||||
|
||||
def test_missing_settings_fail_before_sudo(self):
|
||||
args = self.install_args()
|
||||
fake = self.root / 'fake-os'
|
||||
fake.mkdir()
|
||||
(fake / 'sitecustomize.py').write_text('import os\nos.geteuid = lambda: 1000\n')
|
||||
log = self.root / 'sudo-called'
|
||||
sudo = fake / 'sudo'
|
||||
sudo.write_text('#!/bin/sh\ntouch "$TEST_SUDO_LOG"\nexit 23\n')
|
||||
sudo.chmod(0o755)
|
||||
self.env.update(PYTHONPATH=str(fake), TEST_SUDO_LOG=str(log),
|
||||
PATH=str(fake) + os.pathsep + os.environ['PATH'])
|
||||
result = self.cli('service', 'install', '--install-only', '--xray', args[5])
|
||||
self.assertEqual(1, result.returncode, result.stderr)
|
||||
self.assertIn('настрой', result.stderr)
|
||||
self.assertIn('терминал', result.stderr)
|
||||
self.assertNotIn('No such file', result.stderr)
|
||||
self.assertFalse(log.exists())
|
||||
|
||||
def test_install_can_select_named_profile(self):
|
||||
args = self.install_args()
|
||||
named = self.config / 'profiles/work'
|
||||
named.parent.mkdir(parents=True)
|
||||
args[3].rename(named)
|
||||
result = self.cli('--profile', 'work', 'service', 'install', '--xray', args[5],
|
||||
'--root', self.root / 'stage')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual((named / 'config').read_bytes(),
|
||||
(self.root / 'stage/etc/proxy-client/config').read_bytes())
|
||||
ambiguous = self.cli('--profile', 'work', *args)
|
||||
self.assertEqual(1, ambiguous.returncode)
|
||||
self.assertIn('--config-dir', ambiguous.stderr)
|
||||
|
||||
def test_install_resolves_user_paths_before_sudo(self):
|
||||
args = self.install_args()
|
||||
for name in ('config', 'default.url'):
|
||||
(args[3] / name).replace(self.config / name)
|
||||
local_xray = self.root / '.local/bin/xray'
|
||||
local_xray.parent.mkdir(parents=True)
|
||||
args[5].replace(local_xray)
|
||||
fake = self.root / 'fake-os'
|
||||
fake.mkdir()
|
||||
(fake / 'sitecustomize.py').write_text('import os\nos.geteuid = lambda: 1000\n')
|
||||
sudo = fake / 'sudo'
|
||||
sudo.write_text('#!/usr/bin/env python3\nimport json, os, sys\n'
|
||||
'open(os.environ["TEST_SUDO_ARGS"], "w").write(json.dumps(sys.argv[1:]))\n'
|
||||
'sys.exit(23)\n')
|
||||
sudo.chmod(0o755)
|
||||
log = self.root / 'sudo-args.json'
|
||||
self.env.update(PYTHONPATH=str(fake), TEST_SUDO_ARGS=str(log),
|
||||
PATH=str(fake) + os.pathsep + os.environ['PATH'])
|
||||
result = self.cli('service', 'install', '--install-only', '--enable', '--start')
|
||||
self.assertEqual(23, result.returncode, result.stderr)
|
||||
command = json.loads(log.read_text())
|
||||
self.assertEqual(['service', 'install', '--config-dir', str(self.config),
|
||||
'--xray', str(local_xray), '--enable', '--start'], command[3:])
|
||||
self.assertEqual('--', command[0])
|
||||
self.assertEqual(str(CLI.resolve()), command[2])
|
||||
|
||||
def test_direct_sudo_uses_invoking_users_home(self):
|
||||
args = self.install_args()
|
||||
source = self.root / '.config/proxy-client'
|
||||
source.parent.mkdir()
|
||||
args[3].rename(source)
|
||||
xray = self.root / '.local/bin/xray'
|
||||
xray.parent.mkdir(parents=True)
|
||||
args[5].replace(xray)
|
||||
fake = self.root / 'fake-os'
|
||||
fake.mkdir()
|
||||
(fake / 'sitecustomize.py').write_text(
|
||||
'import os, pwd, types\nos.geteuid = lambda: 0\n'
|
||||
'def user(uid):\n'
|
||||
' assert uid == 12345\n'
|
||||
' return types.SimpleNamespace(pw_dir=os.environ["TEST_USER_HOME"])\n'
|
||||
'pwd.getpwuid = user\n')
|
||||
self.env.pop('XDG_CONFIG_HOME')
|
||||
self.env.update(HOME=str(self.root / 'root-home'), SUDO_UID='12345',
|
||||
TEST_USER_HOME=str(self.root), PYTHONPATH=str(fake))
|
||||
result = self.cli('service', 'install', '--root', self.root / 'stage')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual((source / 'config').read_bytes(),
|
||||
(self.root / 'stage/etc/proxy-client/config').read_bytes())
|
||||
|
||||
def test_install_refuses_foreign_files_before_writing(self):
|
||||
args = self.install_args()
|
||||
target = self.root / 'stage/etc/systemd/system/proxy-client.service'
|
||||
target.parent.mkdir(parents=True)
|
||||
target.write_text('foreign unit')
|
||||
result = self.cli(*args)
|
||||
self.assertEqual(result.returncode, 1)
|
||||
self.assertEqual(target.read_text(), 'foreign unit')
|
||||
self.assertFalse((self.root / 'stage/usr/local/lib/proxy-client/xray').exists())
|
||||
|
||||
def test_install_reports_journal_storage_without_changing_policy(self):
|
||||
args = self.install_args()
|
||||
policy = self.root / 'stage/etc/systemd/journald.conf.d/storage.conf'
|
||||
policy.parent.mkdir(parents=True)
|
||||
policy.write_text('[Journal]\nStorage=volatile\n')
|
||||
result = self.cli(*args)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn('Storage=volatile', result.stdout)
|
||||
self.assertIn('не сохраняется', result.stdout)
|
||||
self.assertEqual(policy.read_text(), '[Journal]\nStorage=volatile\n')
|
||||
|
||||
def test_update_does_not_require_original_home_profile(self):
|
||||
args = self.install_args()
|
||||
first = self.cli(*args)
|
||||
self.assertEqual(0, first.returncode, first.stderr)
|
||||
for path in (self.root / 'source').iterdir():
|
||||
path.unlink()
|
||||
(self.root / 'source').rmdir()
|
||||
updated = self.cli(*args)
|
||||
self.assertEqual(0, updated.returncode, updated.stderr)
|
||||
|
||||
def test_default_update_preserves_service_settings_without_home_files(self):
|
||||
args = self.install_args()
|
||||
first = self.cli(*args)
|
||||
self.assertEqual(0, first.returncode, first.stderr)
|
||||
settings = self.root / 'stage/etc/proxy-client'
|
||||
saved = {name: (settings / name).read_bytes() for name in ('config', 'default.url')}
|
||||
for path in args[3].iterdir():
|
||||
path.unlink()
|
||||
args[3].rmdir()
|
||||
args[5].unlink()
|
||||
# В PATH только Python для shebang тестового CLI; Xray там отсутствует.
|
||||
path = self.root / 'path'
|
||||
path.mkdir()
|
||||
(path / 'python3').symlink_to(sys.executable)
|
||||
self.env['PATH'] = str(path)
|
||||
updated = self.cli('service', 'install', '--root', self.root / 'stage')
|
||||
self.assertEqual(0, updated.returncode, updated.stderr)
|
||||
for name, data in saved.items():
|
||||
self.assertEqual(data, (settings / name).read_bytes())
|
||||
|
||||
def test_unspecified_journal_storage_is_not_guessed(self):
|
||||
result = self.cli(*self.install_args())
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('Storage не задан', result.stdout)
|
||||
|
||||
def test_restrictive_umask_keeps_service_executable_accessible(self):
|
||||
args = self.install_args()
|
||||
result = subprocess.run(['bash', '-c', 'umask 077; exec "$@"', 'bash',
|
||||
str(CLI), *map(str, args)], env=self.env,
|
||||
capture_output=True, text=True, timeout=15)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
stage = self.root / 'stage'
|
||||
for name in ('usr', 'usr/local', 'usr/local/lib', 'usr/local/lib/proxy-client'):
|
||||
self.assertEqual(0o755, (stage / name).stat().st_mode & 0o777, name)
|
||||
|
||||
def test_interrupted_install_or_update_can_be_retried(self):
|
||||
args = self.install_args()
|
||||
injection = self.root / 'fault'
|
||||
injection.mkdir()
|
||||
(injection / 'sitecustomize.py').write_text(
|
||||
'import os, errno\noriginal = os.replace\n'
|
||||
'def replace(src, dst):\n'
|
||||
' if str(dst).endswith("/xray"):\n'
|
||||
' raise OSError(errno.ENOSPC, "synthetic disk full")\n'
|
||||
' return original(src, dst)\n'
|
||||
'os.replace = replace\n')
|
||||
candidate = self.root / 'new-cli'
|
||||
candidate.write_bytes(CLI.read_bytes() + b'\n# next release\n')
|
||||
candidate.chmod(0o755)
|
||||
for updating in (False, True):
|
||||
with self.subTest(updating=updating):
|
||||
args[-1] = self.root / ('update' if updating else 'fresh')
|
||||
if updating:
|
||||
result = self.cli(*args)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
command = [str(candidate), *map(str, args)]
|
||||
failed = subprocess.run(command, env=dict(self.env, PYTHONPATH=str(injection)),
|
||||
capture_output=True, text=True, timeout=15)
|
||||
self.assertNotEqual(0, failed.returncode)
|
||||
retried = subprocess.run(command, env=self.env, capture_output=True,
|
||||
text=True, timeout=15)
|
||||
self.assertEqual(0, retried.returncode, retried.stderr)
|
||||
|
||||
def test_system_actions_require_explicit_flags(self):
|
||||
args = self.install_args()[:-2]
|
||||
stage = self.root / 'system'
|
||||
fake = self.root / 'system-api'
|
||||
fake.mkdir()
|
||||
log = self.root / 'actions'
|
||||
# Подмена только ОС: корень файловой системы, root/group API и
|
||||
# внешние systemd-команды. CLI и установщик выполняются целиком.
|
||||
(fake / 'sitecustomize.py').write_text('''
|
||||
import os, pathlib, grp, types
|
||||
stage = os.environ['TEST_INSTALL_ROOT']
|
||||
OriginalPath = type(pathlib.Path())
|
||||
class StagedPath:
|
||||
home = staticmethod(OriginalPath.home)
|
||||
def __new__(cls, *parts, **kwargs):
|
||||
if parts == ('/',):
|
||||
parts = (stage,)
|
||||
return OriginalPath(*parts, **kwargs)
|
||||
pathlib.Path = StagedPath
|
||||
os.geteuid = lambda: 0
|
||||
def group(name):
|
||||
assert os.path.exists(os.environ['TEST_INSTALL_ROOT'] + '/group-created')
|
||||
return types.SimpleNamespace(gr_gid=os.getgid())
|
||||
grp.getgrnam = group
|
||||
def chown(path, uid, gid):
|
||||
assert str(path).startswith(stage + '/')
|
||||
assert os.path.exists(stage + '/group-created')
|
||||
with open(os.environ['TEST_ACTION_LOG'], 'a') as stream:
|
||||
stream.write('chown ' + os.path.basename(path) + '\\n')
|
||||
os.chown = chown
|
||||
''')
|
||||
for command in ('systemd-sysusers', 'systemctl'):
|
||||
path = fake / command
|
||||
path.write_text('#!/bin/sh\n'
|
||||
'printf "%s %s\\n" "${0##*/}" "$*" >> "$TEST_ACTION_LOG"\n'
|
||||
'if [ "${0##*/}" = systemd-sysusers ]; then\n'
|
||||
' touch "$TEST_INSTALL_ROOT/group-created"\nfi\n')
|
||||
path.chmod(0o755)
|
||||
env = dict(self.env, PYTHONPATH=str(fake), TEST_INSTALL_ROOT=str(stage),
|
||||
TEST_ACTION_LOG=str(log), PATH=str(fake) + ':' + os.environ['PATH'])
|
||||
for flags in ([], ['--enable'], ['--start'], ['--enable', '--start']):
|
||||
with self.subTest(flags=flags):
|
||||
log.write_text('')
|
||||
result = subprocess.run([str(CLI), *map(str, args), *flags], env=env,
|
||||
capture_output=True, text=True, timeout=15)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
calls = log.read_text().splitlines()
|
||||
self.assertTrue(calls[0].startswith('systemd-sysusers '), calls)
|
||||
self.assertEqual(['chown proxy-client', 'chown config', 'chown default.url'], calls[1:4])
|
||||
self.assertIn('systemctl daemon-reload', calls)
|
||||
self.assertEqual('--enable' in flags, 'systemctl enable proxy-client.service' in calls)
|
||||
self.assertEqual('--start' in flags, 'systemctl start proxy-client.service' in calls)
|
||||
self.assertFalse(any('restart' in call for call in calls))
|
||||
|
||||
def test_invalid_service_requests_do_not_install_files(self):
|
||||
args = self.install_args()
|
||||
for extra in (['--enable'], ['--start']):
|
||||
result = self.cli(*args, *extra)
|
||||
self.assertNotEqual(0, result.returncode)
|
||||
self.assertFalse((self.root / 'stage').exists())
|
||||
result = self.cli('--profile', 'work', *args)
|
||||
self.assertNotEqual(0, result.returncode)
|
||||
self.assertFalse((self.root / 'stage').exists())
|
||||
config = self.root / 'source/config'
|
||||
original = config.read_text()
|
||||
for invalid in [original.replace('type=xray', 'type=external')] + [
|
||||
original.replace('127.0.0.1', address)
|
||||
for address in ('0.0.0.0', '::', '192.0.2.1', '2001:db8::1', 'localhost')]:
|
||||
config.write_text(invalid)
|
||||
result = self.cli(*args)
|
||||
self.assertNotEqual(0, result.returncode)
|
||||
self.assertFalse((self.root / 'stage').exists())
|
||||
|
||||
def test_manual_and_service_run_reject_non_loopback_before_start(self):
|
||||
args = self.install_args()
|
||||
config_path = args[3] / 'config'
|
||||
original = config_path.read_text()
|
||||
for name in ('config', 'default.url'):
|
||||
(args[3] / name).replace(self.config / name)
|
||||
runtime = self.root / 'service-runtime'
|
||||
commands = [('start',), ('service', 'run', '--config-dir', self.config,
|
||||
'--runtime-dir', runtime, '--xray', args[5])]
|
||||
for address in ('0.0.0.0', '::', '192.0.2.1', '2001:db8::1', 'localhost'):
|
||||
(self.config / 'config').write_text(original.replace('127.0.0.1', address))
|
||||
for command in commands:
|
||||
with self.subTest(address=address, command=command):
|
||||
result = self.cli(*command)
|
||||
self.assertEqual(1, result.returncode, result.stderr)
|
||||
self.assertIn('loopback', result.stderr)
|
||||
self.assertFalse(runtime.exists())
|
||||
self.assertFalse((self.root / 'state').exists())
|
||||
@@ -0,0 +1,520 @@
|
||||
"""Интерактивная установка через CLI; системные действия подменены."""
|
||||
import json
|
||||
import hashlib
|
||||
import os
|
||||
import pty
|
||||
import select
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
|
||||
CLI = Path(__file__).resolve().parents[1] / 'proxy-client/.local/bin/proxy-client'
|
||||
URL = ('vless://11111111-2222-4333-8444-555555555555@cdn.example:443'
|
||||
'?type=xhttp&security=tls&encryption=none&sni=cdn.example&fp=chrome&path=%2FSECRET')
|
||||
CONFIG = '[proxy]\ntype=xray\nname=Test\naddress=127.0.0.1\nport=12334\nno_proxy_extra=.example\n'
|
||||
|
||||
|
||||
class ServiceSetupTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temporary.cleanup)
|
||||
self.root = Path(temporary.name)
|
||||
self.config = self.root / 'config/proxy-client'
|
||||
self.config.mkdir(parents=True)
|
||||
self.fake = self.root / 'bin'
|
||||
self.fake.mkdir()
|
||||
self.log = self.root / 'actions'
|
||||
self.stage = self.root / 'system'
|
||||
self.env = dict(os.environ, HOME=str(self.root / 'home'),
|
||||
XDG_CONFIG_HOME=str(self.root / 'config'),
|
||||
XDG_STATE_HOME=str(self.root / 'state'),
|
||||
PYTHONPATH=str(self.fake), TEST_ROOT=str(self.root),
|
||||
PATH=str(self.fake) + os.pathsep + os.defpath)
|
||||
(self.fake / 'python3').symlink_to(sys.executable)
|
||||
(self.fake / 'sitecustomize.py').write_text('''
|
||||
import os, sys, pathlib, getpass, grp, types, socket, urllib.request, io
|
||||
OriginalPath = type(pathlib.Path())
|
||||
class StagedPath:
|
||||
home = staticmethod(OriginalPath.home)
|
||||
def __new__(cls, *parts, **kwargs):
|
||||
if parts == ('/',):
|
||||
parts = (os.environ['TEST_ROOT'] + '/system',)
|
||||
return OriginalPath(*parts, **kwargs)
|
||||
pathlib.Path = StagedPath
|
||||
os.geteuid = lambda: 0 if os.environ.get('TEST_PRIVILEGED') else 1000
|
||||
sys.stdin.isatty = lambda: not os.environ.get('TEST_PRIVILEGED') and not os.environ.get('TEST_NO_TTY')
|
||||
if not os.environ.get('TEST_REAL_GETPASS'):
|
||||
getpass.getpass = lambda prompt: input(prompt)
|
||||
grp.getgrnam = lambda name: types.SimpleNamespace(gr_gid=os.getgid())
|
||||
def chown(path, uid, gid):
|
||||
assert str(path).startswith(os.environ['TEST_ROOT'] + '/system/')
|
||||
os.chown = chown
|
||||
class LocalSocket:
|
||||
def __init__(self, *args, **kwargs): pass
|
||||
def __enter__(self): return self
|
||||
def __exit__(self, *args): pass
|
||||
def close(self): pass
|
||||
def setsockopt(self, *args): pass
|
||||
def bind(self, address):
|
||||
busy = os.environ.get('TEST_PORT_BUSY')
|
||||
if busy == 'manual':
|
||||
busy = os.path.exists(os.environ['TEST_ROOT'] + '/manual-active')
|
||||
if busy: raise OSError('busy')
|
||||
socket.socket = LocalSocket
|
||||
def connect(*args, **kwargs):
|
||||
if not os.path.exists(os.environ['TEST_ROOT'] + '/system/active'):
|
||||
raise OSError('not ready')
|
||||
return LocalSocket()
|
||||
socket.create_connection = connect
|
||||
original_readlink = os.readlink
|
||||
original_read_bytes = OriginalPath.read_bytes
|
||||
def readlink(path, *args, **kwargs):
|
||||
if str(path) == '/proc/4321/exe':
|
||||
if not os.path.exists(os.environ['TEST_ROOT'] + '/manual-active'): raise FileNotFoundError()
|
||||
return os.environ['TEST_ROOT'] + '/bin/xray'
|
||||
return original_readlink(path, *args, **kwargs)
|
||||
def read_bytes(path):
|
||||
if str(path) == '/proc/4322/cmdline':
|
||||
if not os.path.exists(os.environ['TEST_ROOT'] + '/manual-active'): raise FileNotFoundError()
|
||||
return b'proxy-client start'
|
||||
return original_read_bytes(path)
|
||||
os.readlink = readlink
|
||||
OriginalPath.read_bytes = read_bytes
|
||||
def kill(pid, signum):
|
||||
assert not os.environ.get('TEST_PRIVILEGED'), 'нельзя останавливать пользовательский процесс от root'
|
||||
assert pid == 4322, 'чужой PID'
|
||||
os.unlink(os.environ['TEST_ROOT'] + '/manual-active')
|
||||
with open(os.environ['TEST_ROOT'] + '/actions', 'a') as stream:
|
||||
stream.write('["manual-stop"]\\n')
|
||||
os.kill = kill
|
||||
def urlopen(url, **kwargs):
|
||||
if os.environ.get('TEST_DOWNLOAD_FAIL'): raise OSError('download failed')
|
||||
with open(os.environ['TEST_ROOT'] + '/actions', 'a') as stream:
|
||||
stream.write('["download"]\\n')
|
||||
suffix = 'digest' if url.endswith('.dgst') else 'archive'
|
||||
return io.BytesIO(open(os.environ['TEST_ROOT'] + '/' + suffix, 'rb').read())
|
||||
urllib.request.urlopen = urlopen
|
||||
''')
|
||||
self.executable('sudo', '''#!/usr/bin/env python3
|
||||
import json, os, sys
|
||||
args = sys.argv[1:]
|
||||
with open(os.environ['TEST_ROOT'] + '/actions', 'a') as stream:
|
||||
stream.write(json.dumps(['sudo'] + args) + '\\n')
|
||||
if os.environ.get('TEST_FAIL_SUDO'): sys.exit(23)
|
||||
if args[0] == '--': args.pop(0)
|
||||
os.environ['TEST_PRIVILEGED'] = '1'
|
||||
os.environ['HOME'] = os.environ['TEST_ROOT'] + '/root-home'
|
||||
os.environ.pop('XDG_CONFIG_HOME', None)
|
||||
os.environ.pop('XDG_STATE_HOME', None)
|
||||
os.execvpe(args[0], args, os.environ)
|
||||
''')
|
||||
self.executable('systemd-sysusers', '#!/bin/sh\nexit 0\n')
|
||||
self.executable('systemctl', '''#!/usr/bin/env python3
|
||||
import json, os, sys
|
||||
from pathlib import Path
|
||||
root = Path(os.environ['TEST_ROOT'])
|
||||
with (root / 'actions').open('a') as stream:
|
||||
stream.write(json.dumps(['systemctl'] + sys.argv[1:]) + '\\n')
|
||||
action = sys.argv[1]
|
||||
active = root / 'system/active'
|
||||
if action in ('start', 'restart') or (action == 'enable' and '--now' in sys.argv):
|
||||
if os.environ.get('TEST_FAIL_START'): sys.exit(1)
|
||||
if not os.environ.get('TEST_NOT_READY'): active.touch()
|
||||
if os.environ.get('TEST_CHANGE_LINK_AT_START'):
|
||||
link = root / 'config/proxy-client/default.url'
|
||||
link.write_text(link.read_text().replace('cdn.example:443', 'after-start.example:443'))
|
||||
if (action == 'stop' or (action == 'disable' and '--now' in sys.argv)) and active.exists(): active.unlink()
|
||||
if action == 'is-active': sys.exit(0 if active.exists() else 1)
|
||||
''')
|
||||
self.executable('xray', '#!/bin/sh\n'
|
||||
'[ "$1" != version ] || echo "Xray 26.10.10 (fake)"\nexit 0\n')
|
||||
|
||||
def executable(self, name, text):
|
||||
path = self.fake / name
|
||||
path.write_text(text)
|
||||
path.chmod(0o755)
|
||||
|
||||
def ready_profile(self):
|
||||
(self.config / 'config').write_text(CONFIG)
|
||||
(self.config / 'default.url').write_text(URL + '\n')
|
||||
(self.config / 'default.url').chmod(0o600)
|
||||
|
||||
def running_profile(self):
|
||||
self.ready_profile()
|
||||
state = self.root / 'state/proxy-client'
|
||||
state.mkdir(parents=True, exist_ok=True)
|
||||
(state / 'state.json').write_text(json.dumps({
|
||||
'supervisor_pid': 4322, 'xray_pid': 4321, 'xray_path': str(self.fake / 'xray'),
|
||||
'address': '127.0.0.1', 'port': 12334}))
|
||||
(self.root / 'manual-active').touch()
|
||||
|
||||
def cli(self, answers='', *args):
|
||||
return subprocess.run([str(CLI), 'service', 'install', *args], input=answers,
|
||||
env=self.env, capture_output=True, text=True, timeout=20)
|
||||
|
||||
def test_declining_plan_changes_nothing(self):
|
||||
self.ready_profile()
|
||||
result = self.cli('n\n')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('отменена', result.stdout)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertFalse(self.stage.exists())
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
|
||||
def test_fresh_setup_collects_settings_without_writing_before_confirmation(self):
|
||||
result = self.cli(URL + '\n\nn\n')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('12334', result.stdout)
|
||||
self.assertIn('отменена', result.stdout)
|
||||
self.assertNotIn(URL, result.stdout + result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertEqual([], list(self.config.iterdir()))
|
||||
|
||||
def test_dangling_profile_symlink_is_reported_before_secret_input(self):
|
||||
(self.config / 'config').write_text(CONFIG)
|
||||
(self.config / 'default.url').symlink_to(self.root / 'missing.url')
|
||||
result = self.cli(URL + '\ny\n')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('битый симлинк', result.stderr)
|
||||
self.assertNotIn('ввод скрыт', result.stdout)
|
||||
self.assertNotIn('rm -- ', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertFalse((self.root / 'state/proxy-client/service-setup.json').exists())
|
||||
|
||||
def test_fresh_setup_installs_starts_and_configures_shell_profile(self):
|
||||
result = self.cli(URL + '\n\ny\n')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
settings = self.stage / 'etc/proxy-client'
|
||||
self.assertIn('type = xray', (settings / 'config').read_text())
|
||||
self.assertEqual(URL + '\n', (settings / 'default.url').read_text())
|
||||
self.assertEqual(0o640, (settings / 'default.url').stat().st_mode & 0o777)
|
||||
home_config = (self.config / 'config').read_text()
|
||||
self.assertIn('type = external', home_config)
|
||||
self.assertIn('address = 127.0.0.1', home_config)
|
||||
self.assertIn('port = 12334', home_config)
|
||||
self.assertTrue((self.stage / 'active').exists())
|
||||
self.assertNotIn(URL, result.stdout + result.stderr + self.log.read_text())
|
||||
|
||||
def test_readiness_check_does_not_request_sudo(self):
|
||||
self.ready_profile()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
actions = [json.loads(line) for line in self.log.read_text().splitlines()]
|
||||
self.assertIn(['systemctl', 'is-active', '--quiet', 'proxy-client.service'], actions)
|
||||
self.assertFalse(any(action[0] == 'sudo' and 'is-active' in action for action in actions))
|
||||
|
||||
def test_yes_accepts_file_without_a_terminal(self):
|
||||
self.env['TEST_NO_TTY'] = '1'
|
||||
profile = self.root / 'connection.url'
|
||||
profile.write_text(URL + '\n')
|
||||
profile.chmod(0o600)
|
||||
result = self.cli('', '--auto-yes', '--file', str(profile), '--port', '12335')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertNotIn('Продолжить?', result.stdout)
|
||||
self.assertIn('port = 12335', (self.config / 'config').read_text())
|
||||
self.assertNotIn(URL, result.stdout + result.stderr + self.log.read_text())
|
||||
|
||||
def test_no_terminal_requires_an_explicit_installation_mode(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_NO_TTY'] = '1'
|
||||
result = self.cli('')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('--yes', result.stderr)
|
||||
self.assertIn('--install-only', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertFalse(self.stage.exists())
|
||||
self.assertTrue((self.root / 'manual-active').exists())
|
||||
|
||||
def test_update_keeps_system_settings_without_home_profile(self):
|
||||
self.ready_profile()
|
||||
first = self.cli('y\n')
|
||||
self.assertEqual(0, first.returncode, first.stderr)
|
||||
settings = self.stage / 'etc/proxy-client'
|
||||
before = {name: (settings / name).read_bytes() for name in ('config', 'default.url')}
|
||||
for path in self.config.iterdir():
|
||||
path.unlink()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('обнов', result.stdout.lower())
|
||||
for name, content in before.items():
|
||||
self.assertEqual(content, (settings / name).read_bytes())
|
||||
self.assertFalse((self.config / 'config').exists())
|
||||
|
||||
def test_migration_stops_only_own_process_after_files_are_installed(self):
|
||||
self.running_profile()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertFalse((self.root / 'manual-active').exists())
|
||||
actions = [json.loads(line) for line in self.log.read_text().splitlines()]
|
||||
self.assertLess(actions.index(['systemctl', 'daemon-reload']), actions.index(['manual-stop']))
|
||||
self.assertLess(actions.index(['manual-stop']),
|
||||
actions.index(['systemctl', 'enable', '--now', 'proxy-client.service']))
|
||||
backups = list(self.config.glob('config.before-service.*'))
|
||||
self.assertEqual(1, len(backups))
|
||||
self.assertEqual(CONFIG, backups[0].read_text())
|
||||
self.assertIn('type = external', (self.config / 'config').read_text())
|
||||
|
||||
def test_install_only_can_be_completed_by_the_wizard(self):
|
||||
self.running_profile()
|
||||
first = self.cli('', '--install-only')
|
||||
self.assertEqual(0, first.returncode, first.stderr)
|
||||
self.env['TEST_PORT_BUSY'] = 'manual'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertFalse((self.root / 'manual-active').exists())
|
||||
self.assertTrue((self.stage / 'active').exists())
|
||||
self.assertIn('type = external', (self.config / 'config').read_text())
|
||||
|
||||
def test_installed_different_profile_is_not_replaced_or_stopped(self):
|
||||
self.running_profile()
|
||||
first = self.cli('', '--install-only')
|
||||
self.assertEqual(0, first.returncode, first.stderr)
|
||||
system_config = self.stage / 'etc/proxy-client/config'
|
||||
changed = system_config.read_text().replace('12334', '12335')
|
||||
system_config.write_text(changed)
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode, result.stderr)
|
||||
self.assertTrue((self.root / 'manual-active').exists())
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
self.assertEqual(changed, system_config.read_text())
|
||||
self.assertNotIn('["systemctl", "stop"', self.log.read_text())
|
||||
snapshot = self.root / 'state/proxy-client/service-setup.json'
|
||||
self.assertTrue(snapshot.exists())
|
||||
self.assertIn('rm -- ' + str(snapshot), result.stderr)
|
||||
self.assertIn('/etc/proxy-client', result.stderr)
|
||||
|
||||
def test_start_failure_preserves_home_and_explains_recovery(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
self.assertIn('proxy-client start', result.stderr)
|
||||
self.assertIn('disable', self.log.read_text())
|
||||
self.assertEqual([], list(self.config.glob('config.before-service.*')))
|
||||
|
||||
def test_missing_xray_is_downloaded_and_verified_before_installation(self):
|
||||
binary = (self.fake / 'xray').read_bytes()
|
||||
(self.fake / 'xray').unlink()
|
||||
with zipfile.ZipFile(str(self.root / 'archive'), 'w') as archive:
|
||||
archive.writestr('xray', binary)
|
||||
digest = hashlib.sha256((self.root / 'archive').read_bytes()).hexdigest()
|
||||
(self.root / 'digest').write_text('SHA2-256= ' + digest + '\n')
|
||||
self.ready_profile()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual(binary, (self.stage / 'usr/local/lib/proxy-client/xray').read_bytes())
|
||||
actions = [json.loads(line) for line in self.log.read_text().splitlines()]
|
||||
self.assertEqual(['download'], actions[0])
|
||||
self.assertFalse((self.root / 'home/.local/bin/xray').exists())
|
||||
|
||||
def test_retry_after_failed_start_completes_the_transition(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
self.assertEqual(1, self.cli('', '--yes').returncode)
|
||||
self.env.pop('TEST_FAIL_START')
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('type = external', (self.config / 'config').read_text())
|
||||
|
||||
def test_file_option_cannot_be_silently_ignored_in_install_only_mode(self):
|
||||
self.ready_profile()
|
||||
result = self.cli('', '--install-only', '--file', str(self.config / 'default.url'))
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('--file', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
|
||||
def test_update_downloads_missing_binary_without_asking_for_profile(self):
|
||||
self.ready_profile()
|
||||
self.assertEqual(0, self.cli('', '--yes').returncode)
|
||||
binary = (self.fake / 'xray').read_bytes()
|
||||
(self.fake / 'xray').unlink()
|
||||
(self.stage / 'usr/local/lib/proxy-client/xray').unlink()
|
||||
with zipfile.ZipFile(str(self.root / 'archive'), 'w') as archive:
|
||||
archive.writestr('xray', binary)
|
||||
digest = hashlib.sha256((self.root / 'archive').read_bytes()).hexdigest()
|
||||
(self.root / 'digest').write_text('SHA2-256= ' + digest + '\n')
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual(binary, (self.stage / 'usr/local/lib/proxy-client/xray').read_bytes())
|
||||
|
||||
def test_preparation_failures_do_not_stop_manual_process(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_FAIL_SUDO'] = '1'
|
||||
failed = self.cli('', '--yes')
|
||||
self.assertEqual(23, failed.returncode, failed.stderr)
|
||||
self.assertTrue((self.root / 'manual-active').exists())
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
pending = self.root / 'state/proxy-client/service-setup.json'
|
||||
self.assertEqual(0o600, pending.stat().st_mode & 0o777)
|
||||
self.env.pop('TEST_FAIL_SUDO')
|
||||
(self.fake / 'xray').unlink()
|
||||
self.env['TEST_DOWNLOAD_FAIL'] = '1'
|
||||
failed = self.cli('', '--yes')
|
||||
self.assertEqual(1, failed.returncode)
|
||||
self.assertTrue((self.root / 'manual-active').exists())
|
||||
self.assertFalse(self.stage.exists())
|
||||
|
||||
def test_retry_from_scratch_uses_private_snapshot_without_new_secret_input(self):
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
failed = self.cli(URL + '\n\ny\n')
|
||||
self.assertEqual(1, failed.returncode, failed.stderr)
|
||||
self.assertFalse((self.config / 'config').exists())
|
||||
self.env.pop('TEST_FAIL_START')
|
||||
self.env['TEST_NO_TTY'] = '1'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('type = external', (self.config / 'config').read_text())
|
||||
self.assertFalse((self.root / 'state/proxy-client/service-setup.json').exists())
|
||||
|
||||
def test_changed_link_blocks_stale_snapshot_and_reset_uses_new_settings(self):
|
||||
self.ready_profile()
|
||||
self.env['TEST_FAIL_SUDO'] = '1'
|
||||
self.assertEqual(23, self.cli('', '--yes').returncode)
|
||||
self.env.pop('TEST_FAIL_SUDO')
|
||||
changed = URL.replace('cdn.example:443', 'new.example:443')
|
||||
(self.config / 'default.url').write_text(changed + '\n')
|
||||
before = self.log.read_bytes()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode, result.stderr)
|
||||
self.assertIn('ссылки изменился', result.stderr)
|
||||
snapshot = self.root / 'state/proxy-client/service-setup.json'
|
||||
self.assertIn('rm -- ' + str(snapshot), result.stderr)
|
||||
self.assertFalse(self.stage.exists())
|
||||
self.assertEqual(before, self.log.read_bytes())
|
||||
snapshot.unlink() # Пользователь явно сбросил снимок по подсказке CLI.
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual(changed + '\n', (self.stage / 'etc/proxy-client/default.url').read_text())
|
||||
|
||||
def test_link_edit_after_service_start_does_not_abort_the_confirmed_transition(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_CHANGE_LINK_AT_START'] = '1'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn('type = external', (self.config / 'config').read_text())
|
||||
self.assertIn('after-start.example', (self.config / 'default.url').read_text())
|
||||
self.assertEqual(URL + '\n', (self.stage / 'etc/proxy-client/default.url').read_text())
|
||||
self.assertFalse((self.root / 'state/proxy-client/service-setup.json').exists())
|
||||
|
||||
def test_pending_override_explains_how_to_reset_the_snapshot(self):
|
||||
self.ready_profile()
|
||||
self.env['TEST_FAIL_SUDO'] = '1'
|
||||
self.assertEqual(23, self.cli('', '--yes').returncode)
|
||||
result = self.cli('', '--yes', '--port', '12335')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('rm -- ', result.stderr)
|
||||
|
||||
def test_retry_refuses_changed_system_settings_before_stopping_manual_process(self):
|
||||
self.running_profile()
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
self.assertEqual(1, self.cli('', '--yes').returncode)
|
||||
self.env.pop('TEST_FAIL_START')
|
||||
self.running_profile()
|
||||
config = self.stage / 'etc/proxy-client/config'
|
||||
changed = config.read_text().replace('12334', '12335')
|
||||
config.write_text(changed)
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('отличаются от снимка', result.stderr)
|
||||
self.assertTrue((self.root / 'manual-active').exists())
|
||||
self.assertEqual(changed, config.read_text())
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
|
||||
def test_bad_url_and_invalid_port_do_not_install(self):
|
||||
result = self.cli('not-a-vless-link\n')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertNotIn('not-a-vless-link', result.stdout + result.stderr)
|
||||
result = self.cli('', '--yes', '--port', '0')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertFalse(self.stage.exists())
|
||||
|
||||
def test_foreign_port_is_never_stopped(self):
|
||||
self.ready_profile()
|
||||
self.env['TEST_PORT_BUSY'] = '1'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('занят', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
|
||||
def test_corrupt_transition_snapshot_gets_clear_error(self):
|
||||
self.ready_profile()
|
||||
pending = self.root / 'state/proxy-client/service-setup.json'
|
||||
pending.parent.mkdir(parents=True)
|
||||
pending.write_text('{}')
|
||||
pending.chmod(0o600)
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('снимок', result.stderr)
|
||||
self.assertNotIn('Traceback', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
|
||||
def test_retry_does_not_accept_a_foreign_listener_as_the_service(self):
|
||||
self.ready_profile()
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
self.assertEqual(1, self.cli('', '--yes').returncode)
|
||||
self.env.pop('TEST_FAIL_START')
|
||||
self.env['TEST_PORT_BUSY'] = '1'
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertEqual(CONFIG, (self.config / 'config').read_text())
|
||||
|
||||
def test_malformed_config_does_not_expose_its_contents(self):
|
||||
(self.config / 'config').write_text('PRIVATE_SENTINEL_not_ini\n')
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertNotIn('PRIVATE_SENTINEL', result.stdout + result.stderr)
|
||||
self.assertNotIn('Traceback', result.stderr)
|
||||
self.assertFalse(self.log.exists())
|
||||
|
||||
def test_retry_keeps_custom_file_in_manual_recovery_command(self):
|
||||
self.running_profile()
|
||||
custom = self.root / 'custom.url'
|
||||
(self.config / 'default.url').rename(custom)
|
||||
self.env['TEST_FAIL_START'] = '1'
|
||||
self.assertEqual(1, self.cli('', '--yes', '--file', str(custom)).returncode)
|
||||
self.running_profile()
|
||||
(self.config / 'default.url').unlink()
|
||||
result = self.cli('', '--yes')
|
||||
self.assertEqual(1, result.returncode)
|
||||
self.assertIn('proxy-client start -f ' + str(custom), result.stderr)
|
||||
|
||||
def test_secret_input_is_not_echoed_in_a_real_terminal(self):
|
||||
master, slave = pty.openpty()
|
||||
self.addCleanup(os.close, master)
|
||||
process = subprocess.Popen([str(CLI), 'service', 'install'], stdin=slave,
|
||||
stdout=slave, stderr=slave, start_new_session=True,
|
||||
env=dict(self.env, TEST_REAL_GETPASS='1'))
|
||||
os.close(slave)
|
||||
output = bytearray()
|
||||
def until(prompt):
|
||||
deadline = time.monotonic() + 10
|
||||
while prompt.encode() not in output:
|
||||
if time.monotonic() > deadline:
|
||||
self.fail('не появился запрос ввода: ' + prompt)
|
||||
if select.select([master], [], [], 0.1)[0]:
|
||||
output.extend(os.read(master, 4096))
|
||||
try:
|
||||
until('ввод скрыт')
|
||||
os.write(master, (URL + '\n').encode())
|
||||
until('Локальный порт')
|
||||
os.write(master, b'\n')
|
||||
until('Продолжить?')
|
||||
os.write(master, b'n\n')
|
||||
self.assertEqual(0, process.wait(timeout=10))
|
||||
self.assertNotIn(URL.encode(), output)
|
||||
self.assertFalse(self.log.exists())
|
||||
finally:
|
||||
if process.poll() is None:
|
||||
process.kill()
|
||||
process.wait()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user