diff --git a/CHANGELOG.md b/CHANGELOG.md index cd53d8c..4e86a17 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,3 +9,4 @@ Andromeda стала плагином splify2: пакет `splify2` больше - Настройки плагина по схеме: мастер первой настройки и «Быстрый старт» можно выключить - Убраны вызовы прежней карточки модулей (`steer_modules`, `steer_module_add`, `steer_module_del`) - В правиле — выбор «Торренты»: как всё правило, напрямую или блокировать (ключ `torrent` ядра steer) +- «Самый быстрый» в «Куда» правила больше не сбрасывается: с одним узлом, одним своим туннелем или hysteria2 «Авто» режим переживает сохранение, а следующий отмеченный узел добавляется к набору, а не заменяет прежний diff --git a/ui/src/components/board/RuleTarget.tsx b/ui/src/components/board/RuleTarget.tsx index a2b991a..9b9e150 100644 --- a/ui/src/components/board/RuleTarget.tsx +++ b/ui/src/components/board/RuleTarget.tsx @@ -15,7 +15,7 @@ import { plainName } from '@/lib/nodename' import { devList, isPart, isTunnelKind, type Output, type Spec } from '@/lib/model' import { type Live } from '@/lib/live' import { useSubNodes, type SubNode } from '@/lib/subnodes' -import { applyTarget, EMPTY_TARGET, outputTree, sharedWith, subPickKey, targetOf, type Mode, type SubPick, type Target } from '@/lib/ruleout' +import { applyTarget, EMPTY_TARGET, outputTree, sharedWith, subPickKey, targetFits, targetOf, type Mode, type SubPick, type Target } from '@/lib/ruleout' import { S } from '@/copy' import { PluginGuard, SlotView } from '@/plugins/boundary' import { registry, useRegistry } from '@/plugins/registry' @@ -52,8 +52,13 @@ export default function RuleTarget({ spec, index, live, onSpec }: { const ch = spec.channels[index] const parsed = useMemo(() => targetOf(spec, ch.out), [spec, ch.out]) const [t, setT] = useState(() => parsed ?? structuredClone(EMPTY_TARGET)) - /* Выход сменился не отсюда (отмена, перечитывание после применения) — выбор по нему. */ - useEffect(() => { if (parsed) setT(parsed) }, [parsed]) + /* Выход сменился не отсюда (отмена, перечитывание после применения) — выбор по нему. Выход тот + * же, что даёт текущий выбор, — выбор остаётся: иначе режим перескакивал на прочитанный из спеки + * («Самый быстрый» с одним узлом читается «вручную»), и следующая отметка узла заменяла прежнюю. */ + useEffect(() => { + if (parsed) setT((cur) => (targetFits(spec, ch.out, cur) ? cur : parsed)) + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [parsed]) const [subs, setSubs] = useState(() => subsRemembered() ?? []) /* Устройства — сразу из памяти (lib/cache.ts): пилюли своих туннелей не ждут опроса. */ diff --git a/ui/src/lib/ruleout.ts b/ui/src/lib/ruleout.ts index 6f1a823..914f5a8 100644 --- a/ui/src/lib/ruleout.ts +++ b/ui/src/lib/ruleout.ts @@ -1,4 +1,4 @@ -import { DIRECT, isPart, isTunnelKind, type Output, type ProxyKind, type Spec } from '@/lib/model' +import { DIRECT, devList, ipv6Of, isPart, isTunnelKind, poolIpv6, type Ipv6Mode, type Output, type ProxyKind, type Spec } from '@/lib/model' import { outputUsers } from '@/lib/outrefs' import { directDomains } from '@/lib/rulefiles' import { pruneDnsPresets } from '@/lib/dnspresets' @@ -259,9 +259,13 @@ function buildSubs(mode: Mode, picks: SubPick[]): Built | null { * у него часть на узел. Несколько подписок или протоколов — пул latency из таких туннелей. */ const parts = runs.flatMap((r) => r.proto === 'hysteria2' && r.nodes.length > 1 ? r.nodes.map((n) => ({ ...r, nodes: [n] })) : [r]) - const lat = (r: { proto: Proto; nodes: number[] }): Partial => - r.proto !== 'hysteria2' && r.nodes.length !== 1 ? { pick: 'latency' } : {} - if (parts.length === 1) return { top: tunnel(tmp(), parts[0], lat(parts[0])), owned: [] } + /* `pick: latency` пишется и туннелю из одного узла: замерять там нечего, но без ключа набор + * читался «вручную» — выбранный режим пропадал после сохранения, а следующая отметка узла + * заменяла прежнюю вместо того, чтобы добавить. */ + const lat = (r: { proto: Proto }): Partial => (r.proto !== 'hysteria2' ? { pick: 'latency' } : {}) + /* hysteria2 одной частью (один узел или «Авто») сам режим не держит — пул latency из одной + * части: иначе набор читался бы «первым живым» или «вручную». */ + if (parts.length === 1 && parts[0].proto !== 'hysteria2') return { top: tunnel(tmp(), parts[0], lat(parts[0])), owned: [] } const top: Output = { name: tmp(), kind: 'interface', devices: [], pick: 'latency', on_fail: 'drop' } const owned = parts.map((r) => tunnel(tmp(), r, { ...lat(r), part_of: top.name })) top.devices = owned.map((p) => p.name) @@ -306,13 +310,37 @@ function buildOwn(mode: Mode, picks: string[]): Built | { ref: string } | null { return { top, owned } } +/** IPv6 своих устройств набора — как уже записано у этих устройств в спеке (`ipv6`, у `routed` — и + * `prefix`). Это настройка устройства, а не правила: без неё смена режима или пилюль в «Куда» + * пересобирала выход без ключа, и у выхода пропадало, например, `ipv6: off` — диагностика тут же + * требовала masq6 у зоны выхода. Служебные части пула по подписке (имена-заготовки) не трогаются. */ +function withDeviceIpv6(b: Built | { ref: string } | null, outs: Record): Built | { ref: string } | null { + if (!b || 'ref' in b) return b + const known = new Map() + for (const o of Object.values(outs)) { + if (o.kind !== 'interface' && o.kind !== 'awg') continue + for (const d of devList(o)) { + const v6 = ipv6Of(o, d) + if (v6 && !known.has(d)) known.set(d, { ipv6: v6, ...(v6 === 'routed' && o.prefix ? { prefix: o.prefix } : {}) }) + } + } + for (const o of [b.top, ...b.owned]) { + if (o.kind !== 'interface') continue + const ds = devList(o).filter((d) => !d.startsWith('\u0000')) + if (!ds.length || ds.length !== devList(o).length) continue + if (ds.length === 1) Object.assign(o, known.get(ds[0]) || {}) + else Object.assign(o, poolIpv6(ds, (d) => known.get(d)?.ipv6)) + } + return b +} + /** Набор правила целиком. `ref` — правило ведёт прямо в готовый выход. */ -function buildTarget(t: Target): Built | { ref: string } | null { +function buildTarget(t: Target, outs: Record = {}): Built | { ref: string } | null { const secs: (Built | { ref: string })[] = [] const s = withCountries(buildSubs(t.subs.mode, t.subs.picks), t.subs) if (s) secs.push(s) for (const w of t.warp) secs.push({ ref: w }) - const o = buildOwn(t.own.mode, t.own.picks) + const o = withDeviceIpv6(buildOwn(t.own.mode, t.own.picks), outs) if (o) secs.push(o) if (!secs.length) return null if (secs.length === 1) return secs[0] @@ -443,6 +471,21 @@ export function sharedWith(spec: Spec, index: number): string[] { return spec.channels.filter((c, k) => k !== index && c.out === out).map((c) => c.name) } +/** Даёт ли выбор `t` ровно выход `out` спеки. Один и тот же набор записывается и при разных + * режимах (один узел — что «вручную», что «первый живой»; свой туннель-выход одной пилюлей), и + * чтение спеки обратно (`targetOf`) возвращает лишь один из них. Блок «Куда» по этой проверке + * оставляет режим, который выбрал человек, вместо того чтобы перескочить на прочитанный. */ +export function targetFits(spec: Spec, out: string, t: Target): boolean { + if (t.direct || t.block) return false + const built = buildTarget(t, spec.outputs) + if (!built) return false + if ('ref' in built) return built.ref === out + if (!spec.outputs[out]) return false + const draft: Record = { ...spec.outputs, [built.top.name]: built.top } + for (const p of built.owned) draft[p.name] = p + return shape(draft, built.top.name) === shape(spec.outputs, out) +} + /** Поставить правилу `index` выбор `t`. Пустой выбор (ни пилюли, не «напрямую») спеку не меняет — * правилу нужен выход. */ export function applyTarget(spec: Spec, index: number, t: Target): Spec { @@ -467,7 +510,7 @@ export function applyTarget(spec: Spec, index: number, t: Target): Spec { /* Напрямую — домены настоящими адресами (rulefiles.directDomains). */ return { ...s2, channels: s2.channels.map((c, k) => (k === index ? directDomains(c) : c)) } } - const built = buildTarget(t) + const built = buildTarget(t, spec.outputs) if (!built) return spec if ('ref' in built) return setOut(spec, built.ref) diff --git a/ui/tests/rule-latency-mode.test.tsx b/ui/tests/rule-latency-mode.test.tsx new file mode 100644 index 0000000..1d4b02a --- /dev/null +++ b/ui/tests/rule-latency-mode.test.tsx @@ -0,0 +1,106 @@ +import { fireEvent, render, screen } from '@testing-library/preact' +import { useState } from 'preact/hooks' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import RuleTarget from '@/components/board/RuleTarget' +import { rpc } from '@/lib/rpc' +import { applyTarget, EMPTY_TARGET, targetOf, type Target } from '@/lib/ruleout' +import { decodeSpec, encodeSpec } from '@/lib/specv2' +import type { Output, Spec } from '@/lib/model' +import { live } from './fixtures' + +// «Самый быстрый» в блоке «Куда» правила не сбрасывается: ни когда выбран один узел (или одно +// устройство, или hysteria2 «Авто») и спека читается обратно, ни когда следующий узел отмечается +// после первого — он добавляется к набору, а не заменяет прежний, как при «Вручную». + +const SUB = '/etc/steer/subs/sub1' +const base = (out = 'direct'): Spec => ({ + outputs: { direct: { name: 'direct', kind: 'direct' } }, + channels: [{ name: 'a', out, match: { prefixes_files: ['/etc/steer/lists/a.lst'] } }], +} as unknown as Spec) + +beforeEach(() => { + vi.restoreAllMocks() + vi.spyOn(rpc, 'devices').mockResolvedValue({ devices: [] } as never) + vi.spyOn(rpc, 'subList').mockResolvedValue({ subs: [{ name: 'sub1', title: 'Провайдер', path: SUB, present: true, kind: 'url', url: '', used: 0 }] } as never) + vi.spyOn(rpc, 'vlessNodesOfSub').mockResolvedValue({ + nodes: [ + { index: 0, name: 'Amsterdam', host: 'a', type: 'vless', cc: 'NL' }, + { index: 1, name: 'Berlin', host: 'b', type: 'vless', cc: 'DE' }, + ], + } as never) + vi.spyOn(rpc, 'hysteria2NodesOfSub').mockResolvedValue(null as never) + vi.spyOn(rpc, 'proxyNodesOfSub').mockResolvedValue(null as never) +}) + +/** Блок «Куда», как в редакторе правила: спека живёт у родителя и приходит обратно после каждой правки. */ +function Host({ onSpec }: { onSpec: (s: Spec) => void }) { + const [spec, setSpec] = useState(base()) + return { setSpec(s); onSpec(s) }} /> +} + +describe('«Самый быстрый» в «Куда» правила', () => { + it('режим, выбранный до узлов, держится: второй узел добавляется, в спеке pick: latency', async () => { + const onSpec = vi.fn() + render() + fireEvent.click(await screen.findByRole('button', { name: 'Туннель' })) + fireEvent.click(await screen.findByRole('button', { name: 'Самый быстрый' })) + fireEvent.click(await screen.findByRole('button', { name: /Amsterdam/ })) + expect(screen.getByRole('button', { name: 'Самый быстрый' })).toHaveAttribute('aria-pressed', 'true') + fireEvent.click(screen.getByRole('button', { name: /Berlin/ })) + const s = onSpec.mock.calls.at(-1)![0] as Spec + const o = s.outputs[s.channels[0].out] + expect(o).toMatchObject({ kind: 'vless', nodes: [0, 1], pick: 'latency' }) + expect(screen.getByRole('button', { name: 'Самый быстрый' })).toHaveAttribute('aria-pressed', 'true') + }) +}) + +describe('«Самый быстрый» из одной части переживает сохранение', () => { + const one = (t: Partial): Target => ({ ...structuredClone(EMPTY_TARGET), ...t }) + const roundtrip = (t: Target) => { + const s = applyTarget(base(), 0, t) + const back = decodeSpec(JSON.parse(JSON.stringify(encodeSpec(s)))) + return { s, t: targetOf(back, back.channels[0].out)! } + } + + it('один узел vless — туннель с pick: latency', () => { + const { s, t } = roundtrip(one({ subs: { mode: 'latency', picks: [{ sub: SUB, proto: 'vless', idx: 3 }] } })) + expect(s.outputs.a).toMatchObject({ kind: 'vless', nodes: [3], pick: 'latency' }) + expect(t.subs).toMatchObject({ mode: 'latency', picks: [{ sub: SUB, proto: 'vless', idx: 3 }] }) + }) + + it('hysteria2 «Авто» — пул latency из одной части', () => { + const { s, t } = roundtrip(one({ subs: { mode: 'latency', picks: [{ sub: SUB, proto: 'hysteria2' }] } })) + expect(s.outputs.a).toMatchObject({ kind: 'interface', pick: 'latency' }) + expect(s.outputs[s.outputs.a.devices![0]]).toMatchObject({ kind: 'hysteria2', part_of: 'a' } as Partial) + expect(t.subs).toMatchObject({ mode: 'latency', picks: [{ sub: SUB, proto: 'hysteria2' }] }) + }) + + it('одно своё устройство — обычный выход-интерфейс: пула из одного устройства не заводится', () => { + const s = applyTarget(base(), 0, one({ own: { mode: 'latency', picks: ['dev:wg0'] } })) + expect(s.outputs.a).toMatchObject({ kind: 'interface', device: 'wg0' }) + expect(s.outputs.a.pick).toBeUndefined() + expect(Object.keys(encodeSpec(s).outputs as object)).not.toContain('a.wg0') + }) + + it('«Самый быстрый» на своём выходе wg0 с ipv6: off выход не трогает', () => { + const sp = { ...base('wg0'), outputs: { ...base().outputs, wg0: { name: 'wg0', kind: 'interface', device: 'wg0', ipv6: 'off', on_fail: 'drop' } } } as Spec + const s = applyTarget(sp, 0, one({ own: { mode: 'latency', picks: ['dev:wg0'] } })) + expect(s.outputs.wg0).toEqual(sp.outputs.wg0) + expect(s.channels[0].out).toBe('wg0') + }) + + it('новое устройство в наборе берёт ipv6 устройства из спеки', () => { + const sp = { ...base('wg0'), outputs: { ...base().outputs, wg0: { name: 'wg0', kind: 'interface', device: 'wg0', ipv6: 'off', on_fail: 'drop' }, wg1: { name: 'wg1', kind: 'interface', device: 'wg1', ipv6: 'off', on_fail: 'drop' } } } as Spec + const s = applyTarget(sp, 0, one({ own: { mode: 'latency', picks: ['dev:wg0', 'dev:wg1'] } })) + const o = s.outputs[s.channels[0].out] + expect(o).toMatchObject({ kind: 'interface', devices: ['wg0', 'wg1'], pick: 'latency', ipv6: 'off' }) + }) + + it('«Вручную» и «Первый живой» из одной части пишутся как прежде', () => { + const m = applyTarget(base(), 0, one({ subs: { mode: 'manual', picks: [{ sub: SUB, proto: 'vless', idx: 3 }] } })) + expect(m.outputs.a.pick).toBeUndefined() + const d = applyTarget(base(), 0, one({ own: { mode: 'order', picks: ['dev:wg0'] } })) + expect(d.outputs.a).toMatchObject({ kind: 'interface', device: 'wg0' }) + expect(d.outputs.a.pick).toBeUndefined() + }) +})