Compare commits

...
8 Commits
Author SHA1 Message Date
Denozordec 80cd3a18d7 fix(network): исправить исходный адрес пинга и обновление фильтров
Docker images / prepare-release (push) Successful in 13s
Docker images / backend-test (push) Successful in 10m58s
Docker images / frontend-image (push) Successful in 3m56s
Docker images / updater-image (push) Successful in 2m37s
Docker images / netflow-agent-image (push) Successful in 39s
Docker images / backend-image (push) Successful in 3m56s
Docker images / publish-release (push) Successful in 12s
Docker images / notify-webhook (push) Successful in 2s
Оставить выбор исходного адреса пинга маршрутизатору. Читать правила и рекурсивные шлюзы последовательно, сохранить кэш при конфликте блокировки.
2026-11-22 20:47:38 +07:00
Denozordec f5914b634a fix(mcp): учесть модуль политики в тестах маршрутизации
Docker images / prepare-release (push) Successful in 12s
Docker images / backend-test (push) Successful in 10m46s
Docker images / backend-image (push) Successful in 3m6s
Docker images / frontend-image (push) Successful in 3m23s
Docker images / updater-image (push) Successful in 1m45s
Docker images / netflow-agent-image (push) Successful in 36s
Docker images / notify-webhook (push) Successful in 2s
Docker images / publish-release (push) Successful in 10s
2026-11-22 19:48:17 +07:00
Denozordec aac425c7b2 feat(mcp): расширить управление сетью и исправить разрезы трафика
Docker images / prepare-release (push) Successful in 13s
Docker images / backend-test (push) Failing after 10m39s
Docker images / backend-image (push) Skipped
Docker images / frontend-image (push) Successful in 3m11s
Docker images / updater-image (push) Successful in 1m56s
Docker images / netflow-agent-image (push) Successful in 37s
Docker images / publish-release (push) Skipped
Docker images / notify-webhook (push) Skipped
Добавить переименование интерфейсов и возможность отключать лимиты частоты для сервисных аккаунтов.

Уточнить дедупликацию, учёт интерфейсов и геоданных, фильтрацию сессий и карту потоков.
2026-11-22 19:24:49 +07:00
Denozordec d255694cda fix(mcp): исправить проверку зависимостей туннеля на больших таблицах маршрутов
Docker images / prepare-release (push) Successful in 11s
Docker images / backend-test (push) Successful in 10m41s
Docker images / frontend-image (push) Successful in 2m13s
Docker images / updater-image (push) Successful in 1m17s
Docker images / netflow-agent-image (push) Successful in 33s
Docker images / backend-image (push) Successful in 1m58s
Docker images / publish-release (push) Successful in 11s
Docker images / notify-webhook (push) Successful in 2s
2026-11-22 17:51:05 +07:00
Denozordec e85e347cbe fix(traffic): исправить пики, историю и итоги трафика
Docker images / prepare-release (push) Successful in 12s
Docker images / backend-test (push) Successful in 10m29s
Docker images / frontend-image (push) Successful in 2m55s
Docker images / updater-image (push) Successful in 1m38s
Docker images / netflow-agent-image (push) Successful in 32s
Docker images / backend-image (push) Successful in 3m38s
Docker images / publish-release (push) Successful in 12s
Docker images / notify-webhook (push) Successful in 2s
2026-11-22 16:57:52 +07:00
Denozordec 165f5e1260 fix(ipsec): исправить сверку списка файлов при экспорте сертификатов
Docker images / prepare-release (push) Successful in 11s
Docker images / backend-test (push) Successful in 10m23s
Docker images / backend-image (push) Successful in 2m35s
Docker images / frontend-image (push) Successful in 2m38s
Docker images / updater-image (push) Successful in 1m7s
Docker images / netflow-agent-image (push) Successful in 32s
Docker images / notify-webhook (push) Successful in 2s
Docker images / publish-release (push) Successful in 10s
2026-11-22 15:36:37 +07:00
Denozordec 1af3755a77 fix(ipsec): восстановить создание клиентов и экспорт сертификатов
Docker images / prepare-release (push) Successful in 11s
Docker images / backend-test (push) Successful in 12m5s
Docker images / frontend-image (push) Successful in 2m29s
Docker images / updater-image (push) Successful in 40s
Docker images / netflow-agent-image (push) Successful in 32s
Docker images / backend-image (push) Successful in 2m16s
Docker images / publish-release (push) Successful in 11s
Docker images / notify-webhook (push) Successful in 2s
2026-11-22 14:24:19 +07:00
Denozordec 42efc3191b fix(netflow): устранить двойной учёт потоков туннеля
Docker images / prepare-release (push) Successful in 11s
Docker images / backend-test (push) Successful in 11m32s
Docker images / frontend-image (push) Successful in 2m20s
Docker images / updater-image (push) Successful in 41s
Docker images / netflow-agent-image (push) Successful in 34s
Docker images / backend-image (push) Successful in 2m14s
Docker images / publish-release (push) Successful in 12s
Docker images / notify-webhook (push) Successful in 2s
2026-11-22 13:48:18 +07:00
85 changed files with 1692 additions and 385 deletions

No files matched your search

+76 -31
View File
@@ -17,7 +17,7 @@ import { Separator } from "@/components/ui/separator"
import { cn } from "@/lib/utils"
import { filtersResponseSchema, filtersMutationSchema, filtersGreResponseSchema, filtersRecursiveResponseSchema } from "@/lib/filters-response"
import { firewallServersSchema } from "@/lib/firewall-response"
import { requestJson } from "@/shared/api/http-client"
import { ApiClientError, requestJson } from "@/shared/api/http-client"
import {
servers, greTunnels, serverFilterRulesets, filters as mockFiltersCatalog,
type FilterRule, type ServerFilterRuleset, type Server, type GreTunnel,
@@ -874,7 +874,7 @@ function CopyRulesSheet({
greByServer: Record<string, GreTunnel[]>
ensureGreFor?: (serverId: string) => void
recRoutesByServer: Record<string, RecursiveRouteLite[]>
ensureRecursiveFor?: (serverId: string) => void
ensureRecursiveFor?: (serverId: string) => Promise<void>
catalogReady?: GatewayReadiness
}) {
const [selected, setSelected] = useState<Set<string>>(() => new Set(sourceRules.map(r => r.id)))
@@ -1229,7 +1229,11 @@ function CopyRulesSheet({
</fieldset>
{targetId && !mappingReady && <div className="px-5 py-3 flex flex-col gap-2">
<p role="alert" className="text-sm text-destructive">Каталоги или сопоставление шлюзов не подтверждены. Копирование маршрутов заблокировано.</p>
<Button variant="outline" disabled={copying} onClick={() => { for (const id of [sourceServerId, targetId]) { ensureGreFor?.(id); ensureRecursiveFor?.(id) } }}>Обновить шлюзы</Button>
<Button variant="outline" disabled={copying} onClick={() => {
ensureGreFor?.(sourceServerId)
ensureGreFor?.(targetId)
void ensureRecursiveFor?.(sourceServerId).then(() => ensureRecursiveFor(targetId))
}}>Обновить шлюзы</Button>
</div>}
{copyError && <p role="alert" className="px-5 py-3 text-sm text-destructive">{copyError}</p>}
{copying && <p role="status" className="px-5 py-2 text-sm text-muted-foreground">Ожидание подтверждения копирования…</p>}
@@ -1268,6 +1272,28 @@ function makeApiFetch(backendUrl: string) {
}
}
const configurationBusyMessage = "Конфигурация временно занята другой операцией"
function isConfigurationBusy(error: unknown): boolean {
if (!(error instanceof ApiClientError) || error.status !== 409) return false
const payload = error.payload
return (typeof payload === "object" && payload !== null && "code" in payload && payload.code === "CONFIGURATION_BUSY")
|| /^(?:Глобальная конфигурация|Конфигурация сервера) изменяется другой операцией$/.test(error.message)
}
async function readFiltersWithRetry<T>(read: () => Promise<T>, isCurrent: () => boolean): Promise<T> {
for (const delay of [350, 1000]) {
try {
return await read()
} catch (error) {
if (!isConfigurationBusy(error) || !isCurrent()) throw error
await new Promise(resolve => setTimeout(resolve, delay))
if (!isCurrent()) throw error
}
}
return read()
}
function FiltersPage() {
const { mode, backendUrl } = useDataSource()
const mounted = useRef(true)
@@ -1336,7 +1362,10 @@ function FiltersPage() {
setGatewayReady(prev => ({ ...prev, [serverId]: { ...prev[serverId], [kind]: false } }))
try {
const path = kind === "gre" ? "/api/filters/gre-tunnels" : "/api/recursive-routes"
const payload = await apiFetch<unknown>(`${path}?serverId=${encodeURIComponent(serverId)}`)
const payload = await readFiltersWithRetry(
() => apiFetch<unknown>(`${path}?serverId=${encodeURIComponent(serverId)}`),
() => mounted.current && gatewayEpoch.current[key] === epoch,
)
if (!mounted.current || gatewayEpoch.current[key] !== epoch) return
if (kind === "gre") {
const parsed = filtersGreResponseSchema.safeParse(payload)
@@ -1352,7 +1381,9 @@ function FiltersPage() {
setGatewayErrors(prev => ({ ...prev, [serverId]: { ...prev[serverId], [kind]: undefined } }))
} catch (error) {
if (!mounted.current || gatewayEpoch.current[key] !== epoch) return
setGatewayErrors(prev => ({ ...prev, [serverId]: { ...prev[serverId], [kind]: error instanceof Error ? error.message : "Каталог шлюзов недоступен" } }))
const message = isConfigurationBusy(error) ? configurationBusyMessage
: error instanceof Error ? error.message : "Каталог шлюзов недоступен"
setGatewayErrors(prev => ({ ...prev, [serverId]: { ...prev[serverId], [kind]: message } }))
}
}, [isLive, apiFetch])
const ensureGreTunnels = useCallback((serverId: string) => loadGatewayCatalog(serverId, "gre"), [loadGatewayCatalog])
@@ -1374,7 +1405,8 @@ function FiltersPage() {
const [movePending, setMovePending] = useState(false)
const [moveError, setMoveError] = useState<string | null>(null)
const moveLock = useRef(false)
const [liveStale, setLiveStale] = useState(false)
const [rulesReadFailure, setRulesReadFailure] = useState<"busy" | "unavailable" | null>(null)
const liveStale = rulesReadFailure !== null
const readEpoch = useRef(0)
const [readyServerId, setReadyServerId] = useState<string | null>(null)
const [rulesReading, setRulesReading] = useState(false)
@@ -1394,7 +1426,7 @@ function FiltersPage() {
setRulesets(buildRulesets(servers, serverFilterRulesets))
setSelectedServerId(servers[0]?.id ?? "")
setLiveLoadState("idle")
setLiveStale(false)
setRulesReadFailure(null)
})
return
}
@@ -1454,8 +1486,9 @@ function FiltersPage() {
setReadyServerId(null)
setRulesReading(true)
try {
const payload = await apiFetch<unknown>(
`/api/filters/rules?serverId=${encodeURIComponent(serverId)}`,
const payload = await readFiltersWithRetry(
() => apiFetch<unknown>(`/api/filters/rules?serverId=${encodeURIComponent(serverId)}`),
() => mounted.current && epoch === readEpoch.current,
)
if (epoch !== readEpoch.current) return false
const parsed = filtersResponseSchema.safeParse(payload)
@@ -1469,35 +1502,47 @@ function FiltersPage() {
if (!has) return [...prev, { serverId, rules: liveRules }]
return prev.map((rs) => rs.serverId === serverId ? { ...rs, rules: liveRules } : rs)
})
setLiveStale(false)
setRulesReadFailure(null)
setReadyServerId(serverId)
setRulesReceipt(prev => ({ ...prev, [serverId]: { at: new Date().toISOString(), kind: "read" } }))
return true
} catch (err) {
if (epoch !== readEpoch.current) return false
setLiveStale(true)
toast.error("Не удалось прочитать правила с роутера", { description: String(err) })
const busy = isConfigurationBusy(err)
setRulesReadFailure(busy ? "busy" : "unavailable")
if (!busy) toast.error("Не удалось прочитать правила с роутера", {
description: err instanceof Error ? err.message : "Ошибка чтения правил",
})
return false
} finally {
if (epoch === readEpoch.current) setRulesReading(false)
}
}, [isLive, apiFetch])
const loadServerFilters = useCallback(async (serverId: string) => {
const gre = ensureGreTunnels(serverId)
const rules = loadLiveRules(serverId)
const epoch = readEpoch.current
await rules
// Both these GETs record observations under the same exclusive application lock.
if (mounted.current && epoch === readEpoch.current) await ensureRecursiveRoutes(serverId)
await gre
}, [loadLiveRules, ensureGreTunnels, ensureRecursiveRoutes])
useEffect(() => {
if (!isLive || !selectedServerId || liveLoadState !== "idle") return
if (!liveServers.some((s) => s.id === selectedServerId)) return
void Promise.all([
loadLiveRules(selectedServerId),
ensureGreTunnels(selectedServerId),
ensureRecursiveRoutes(selectedServerId),
])
}, [isLive, selectedServerId, liveLoadState, liveServers, ensureGreTunnels, ensureRecursiveRoutes, loadLiveRules])
void loadServerFilters(selectedServerId)
}, [isLive, selectedServerId, liveLoadState, liveServers, loadServerFilters])
const allServers = !isLive ? servers : liveServers
const allTunnels = !isLive ? greTunnels : (greByServer[selectedServerId] ?? [])
const selectedServer = allServers.find(s => s.id === selectedServerId) ?? allServers[0]
const totalRules = rulesets.reduce((s, r) => s + r.rules.length, 0)
const mutationsLocked = (isLive && !can("mm:filters:write")) || movePending || (isLive && (applyBusy || historyRestoring || rulesReading || readyServerId !== selectedServerId || liveStale || liveLoadState !== "idle"))
const gatewayMessages = [...new Set(Object.values(gatewayErrors[selectedServerId] ?? {}))]
.filter((message): message is string => Boolean(message) && !(rulesReadFailure === "busy" && message === configurationBusyMessage))
const gatewaysBusy = gatewayMessages.every(message => message === configurationBusyMessage)
const filterRailItems = useMemo<ServerTileItem[]>(() => (
allServers.map((s) => ({
@@ -1518,7 +1563,7 @@ function FiltersPage() {
readEpoch.current += 1
setReadyServerId(null)
setRulesReading(false)
setLiveStale(false)
setRulesReadFailure(null)
setSheetOpen(false)
setPendingDelete(null)
setDeleteError(null)
@@ -1552,7 +1597,9 @@ function FiltersPage() {
if (!mounted.current) return { ok: false, error: "Источник данных изменён" }
if (applyLock.current || applyBusy || historyRestoring) return { ok: false, error: "Дождитесь завершения текущей операции" }
if (isLive && (liveStale || liveLoadState !== "idle" || (serverId === selectedServerId && readyServerId !== serverId))) {
const error = "Роутер недоступен — изменения заблокированы"
const error = rulesReadFailure === "busy"
? configurationBusyMessage + ". Изменения недоступны до обновления правил."
: "Роутер недоступен — изменения заблокированы"
toast.error(error)
return { ok: false, error }
}
@@ -1589,23 +1636,19 @@ function FiltersPage() {
applyLock.current = false
setApplyBusy(false)
}
}, [isLive, apiFetch, applyBusy, historyRestoring, liveStale, liveLoadState, readyServerId, selectedServerId])
}, [isLive, apiFetch, applyBusy, historyRestoring, liveStale, rulesReadFailure, liveLoadState, readyServerId, selectedServerId])
const refreshFromRouter = useCallback(async () => {
if (!isLive || !selectedServerId || !mounted.current || applyLock.current || applyBusy || historyRestoring) return
applyLock.current = true
setApplyBusy(true)
try {
await loadLiveRules(selectedServerId)
await Promise.all([
ensureGreTunnels(selectedServerId),
ensureRecursiveRoutes(selectedServerId),
])
await loadServerFilters(selectedServerId)
} finally {
applyLock.current = false
setApplyBusy(false)
}
}, [isLive, selectedServerId, applyBusy, historyRestoring, loadLiveRules, ensureGreTunnels, ensureRecursiveRoutes])
}, [isLive, selectedServerId, applyBusy, historyRestoring, loadServerFilters])
useEffect(() => () => { historyEpoch.current += 1; readEpoch.current += 1 }, [selectedServerId, backendUrl, isLive])
@@ -1653,7 +1696,7 @@ function FiltersPage() {
if (!await loadLiveRules(selectedServerId)) throw new Error("Версия применена, но актуальные правила не прочитаны — обновите данные")
}
if (!mounted.current) return
setLiveStale(false)
setRulesReadFailure(null)
setReadyServerId(selectedServerId)
await loadRevisions()
if (!mounted.current) return
@@ -1879,15 +1922,17 @@ function FiltersPage() {
<Button variant="outline" size="sm" onClick={() => setLoadAttempt(n => n + 1)}>Повторить загрузку</Button>
</div>
)}
{isLive && Object.values(gatewayErrors[selectedServerId] ?? {}).some(Boolean) && <div className="border-b px-6 py-3 flex items-center gap-3">
<p role="alert" className="text-xs text-destructive">{Object.values(gatewayErrors[selectedServerId] ?? {}).filter(Boolean).join(" · ")}. Сохранены последние каталоги шлюзов.</p>
{isLive && gatewayMessages.length > 0 && <div className="border-b px-6 py-3 flex items-center gap-3">
<p role={gatewaysBusy ? "status" : "alert"} className={cn("text-xs", gatewaysBusy ? "text-muted-foreground" : "text-destructive")}>{gatewayMessages.join(" · ")}. Сохранены последние каталоги шлюзов.</p>
<Button variant="outline" size="sm" disabled={applyBusy} onClick={() => { void ensureGreTunnels(selectedServerId); void ensureRecursiveRoutes(selectedServerId) }}>Обновить шлюзы</Button>
</div>}
{isLive && rulesReading && <p role="status" className="border-b px-6 py-2 text-xs text-muted-foreground">Чтение актуальных правил устройства… Изменения временно заблокированы.</p>}
{isLive && liveStale && liveLoadState !== "error" && (
<div className="shrink-0 border-b border-amber-500/30 bg-amber-500/10 px-6 py-2.5 text-xs text-amber-700 dark:text-amber-400 flex items-center gap-2">
<AlertTriangleIcon className="size-3.5 shrink-0" />
Роутер недоступен — показан кэш. Изменения заблокированы, пока не удастся прочитать CHR.
{rulesReadFailure === "busy"
? configurationBusyMessage + ". Показаны последние правила. Изменения недоступны до обновления правил."
: "Роутер недоступен — показан кэш. Изменения заблокированы, пока не удастся прочитать CHR."}
</div>
)}
<div className="border-b px-4 py-3 flex items-center gap-3 flex-wrap shrink-0 md:px-6">
+61 -30
View File
@@ -2,7 +2,7 @@
import { useState, useMemo, useEffect, type ReactNode } from "react"
import { Alert, AlertTitle, AlertDescription } from "@/components/reui/alert"
import { projectTrafficObservations, type TrafficObservationMeta } from "@/lib/traffic-observations"
import { peakOfCombinedTraffic, projectTrafficObservations, type TrafficObservationMeta } from "@/lib/traffic-observations"
import { projectTrafficBindingStatus } from "@/lib/traffic-binding-status"
import { TrafficObservationStatus } from "@/components/traffic/traffic-observation-status"
import { TrafficDataTime } from "@/components/traffic/traffic-data-time"
@@ -25,7 +25,7 @@ import { useDataSource } from "@/lib/data-source"
import { useTrafficLive } from "@/hooks/use-traffic-live"
import { useFlowLive } from "@/hooks/use-flow-live"
import { requestJson } from "@/shared/api/http-client"
import { getFlowAnalytics, getFlowClients, getFlowExporters, getFlowMonthly, getTrafficFlows } from "@/shared/api/traffic-flow"
import { getFlowAnalytics, getFlowClients, getFlowExporters, getFlowMonthly, getTrafficFlowSettings, getTrafficFlows } from "@/shared/api/traffic-flow"
import { listServers } from "@/shared/api/servers"
import { FlowOverlaySheet } from "@/components/traffic/flow-overlay-sheet"
import { FlowAnalyticsDetail, FlowEntityCardView } from "@/components/traffic/flow-analytics-panel"
@@ -56,32 +56,31 @@ function addSeries(a: number[], b: number[]): number[] {
return a.map((v, i) => v + (b[i] ?? 0))
}
function flowIngestLine(stats: FlowStatsDto | null): string | null {
type FlowCollectorStatus = Pick<FlowStatsDto, "listenerBound" | "listenerAddress" | "packetsReceived" | "lastDatagramAt" | "lastExporterIp" | "lastError" | "collectorCountersSource">
function flowIngestLine(stats: FlowCollectorStatus | null): string | null {
if (!stats) return null
const listener = stats.listenerBound
? (stats.listenerAddress ?? "слушает")
: "не слушает"
: "приём не подтверждён"
const last = stats.lastDatagramAt
? new Date(stats.lastDatagramAt).toLocaleString("ru-RU")
: "—"
const exporter = stats.lastExporterIp ? ` · ${stats.lastExporterIp}` : ""
const err = stats.lastError ? ` · ${stats.lastError}` : ""
return `Коллектор: ${listener} · пакеты ${stats.packetsReceived ?? 0} · последний ${last}${exporter}${err}`
const hint = stats.collectorCountersSource === "last-known" ? " · последние известные данные" : ""
return `Коллектор: ${listener} · пакеты ${stats.packetsReceived ?? "—"} · последний ${last}${exporter}${hint}${err}`
}
function flowEmptyHint(stats: FlowStatsDto | null, collectorAlive?: boolean): string | undefined {
function flowEmptyHint(stats: FlowCollectorStatus | null): string | undefined {
if (!stats) return undefined
if (stats.lastError) return stats.lastError
if (stats.collectorCountersSource === "last-known") return "Текущий приём IPFIX не подтверждён."
if (stats.listenerBound === false) return "Коллектор UDP не слушает."
if (stats.packetsReceived) {
return `IPFIX приходит (${stats.lastExporterIp ?? "экспортёр"}), но сессии ещё не записаны.`
return "В выбранном интервале нет сохранённых потоков."
}
if (stats.listenerBound === false && !collectorAlive) {
return "Коллектор UDP не слушает. Подключите JH ещё раз — ingest включится автоматически."
}
if (stats.listenerBound || collectorAlive) {
return "Коллектор жив, IPFIX ещё не доходит. На jump-host у target Src должен быть 0.0.0.0 (авто)."
}
return "IPFIX ещё не доходит до коллектора. На jump-host у target Src должен быть 0.0.0.0 (авто). На хосте MM проверьте bind 10.255.254.1:4739 после wg-flow."
return stats.listenerBound ? "Коллектор слушает, датаграммы IPFIX ещё не получены." : undefined
}
// ─── data model ───────────────────────────────────────────────────────────────
@@ -803,7 +802,7 @@ export default function TrafficPage() {
const [trafficRetry, setTrafficRetry] = useState(0)
const [liveRetry, setLiveRetry] = useState(0)
const trafficKey = JSON.stringify([isLive, backendUrl, range, groupMode, trafficRetry])
const [trafficState, setTrafficState] = useState<{ key: string; status: "ready" | "error"; receivedAt?: number; error?: string } | null>(null)
const [trafficState, setTrafficState] = useState<{ key: string; status: "ready" | "error"; receivedAt?: number; peaks?: { rx: number | null; tx: number | null }; error?: string } | null>(null)
const trafficReady = trafficState?.key === trafficKey && trafficState.status === "ready"
const trafficLoading = trafficState?.key !== trafficKey
const trafficError = trafficState?.key === trafficKey ? trafficState.error : undefined
@@ -828,6 +827,12 @@ export default function TrafficPage() {
const liveBusy = isLive && groupMode === "flows" && !currentFlows
const liveError = currentFlows?.error
const flowStats = currentFlows?.stats ?? null
const [flowCollector, setFlowCollector] = useState<{ url: string; status: FlowCollectorStatus | null; receivedAt?: number } | null>(null)
const collectorReading = flowCollector?.url === backendUrl ? flowCollector : { status: flowStats, receivedAt: currentFlows?.receivedAt }
const collectorStatus: FlowCollectorStatus | null = collectorReading.status && collectorReading.receivedAt !== undefined
&& trafficClock - collectorReading.receivedAt > 35_000
? { ...collectorReading.status, listenerBound: false, collectorCountersSource: "last-known" }
: collectorReading.status
const flowExporters = useMemo(() => currentFlows?.exporters ?? [], [currentFlows])
const flowClients = useMemo(() => currentFlows?.clients ?? [], [currentFlows])
const [flowMonth, setFlowMonth] = useState(() => new Date().toISOString().slice(0, 7))
@@ -882,7 +887,7 @@ export default function TrafficPage() {
try {
const q = encodeURIComponent(targetRange === "30d" ? "24h" : targetRange)
const [srvRes, usersRes, ifacesRes] = await Promise.all([
apiFetch<{ servers: LiveTrafficServer[] }>(`/api/traffic/servers?range=${q}`),
apiFetch<{ servers: LiveTrafficServer[]; peaks?: { rx: number | null; tx: number | null } }>(`/api/traffic/servers?range=${q}`),
apiFetch<{ users: UserTraffic[] }>(`/api/traffic/users?range=${q}`),
apiFetch<{ interfaces: BoundIfaceTraffic[] }>(`/api/traffic/bound-interfaces?range=${q}`),
])
@@ -897,7 +902,7 @@ export default function TrafficPage() {
setLiveServerOwner(JSON.stringify([isLive, backendUrl]))
setLiveUsers(mappedUsers)
setLiveBoundIfaces(liveIfaces)
setTrafficState({ key, status: "ready", receivedAt: Date.now() })
setTrafficState({ key, status: "ready", receivedAt: Date.now(), peaks: srvRes.peaks })
setSelectedId((prev) => {
if (groupMode === "users") return mappedUsers.some((x) => x.id === prev) ? prev : (mappedUsers[0]?.id ?? "")
if (groupMode === "ifaces") return liveIfaces.some((x) => x.id === prev) ? prev : (liveIfaces[0]?.id ?? "")
@@ -911,6 +916,28 @@ export default function TrafficPage() {
return () => { cancelled = true }
}, [apiFetch, isLive, groupMode, backendUrl, trafficRetry, range])
useEffect(() => {
if (!isLive || groupMode !== "flows" || range === "30d") return
const controller = new AbortController()
let timer: ReturnType<typeof setTimeout>
const refresh = async () => {
try {
const status = await getTrafficFlowSettings(backendUrl, { signal: controller.signal })
if (!controller.signal.aborted) setFlowCollector({ url: backendUrl, status, receivedAt: Date.now() })
} catch {
if (!controller.signal.aborted) setFlowCollector(current => ({
url: backendUrl,
status: current?.url === backendUrl && current.status
? { ...current.status, listenerBound: false, collectorCountersSource: "last-known" }
: null,
}))
}
if (!controller.signal.aborted) timer = setTimeout(refresh, 15_000)
}
timer = setTimeout(refresh, 15_000)
return () => { controller.abort(); clearTimeout(timer) }
}, [isLive, groupMode, range, backendUrl])
useEffect(() => {
if (!isLive || effectiveMode !== "flows") return
let cancelled = false
@@ -1116,14 +1143,14 @@ export default function TrafficPage() {
: effectiveMode === "ifaces"
? activeBoundIfaces
: activeServerTraffic
const totalRx = kpiSource.every(s => s.rxNow !== null) ? kpiSource.reduce((a, s) => a + (s.rxNow ?? 0), 0) : null
const totalTx = kpiSource.every(s => s.txNow !== null) ? kpiSource.reduce((a, s) => a + (s.txNow ?? 0), 0) : null
const peakRx = kpiSource.every(s => s.rxPeak !== null) ? kpiSource.reduce((a, s) => Math.max(a, s.rxPeak ?? 0), 0) : null
const peakTx = kpiSource.every(s => s.txPeak !== null) ? kpiSource.reduce((a, s) => Math.max(a, s.txPeak ?? 0), 0) : null
const totalRx = kpiSource.length && kpiSource.every(s => s.rxNow !== null) ? kpiSource.reduce((a, s) => a + (s.rxNow ?? 0), 0) : null
const totalTx = kpiSource.length && kpiSource.every(s => s.txNow !== null) ? kpiSource.reduce((a, s) => a + (s.txNow ?? 0), 0) : null
const exactPeaks = effectiveMode === "servers" && trafficReady ? trafficState?.peaks : undefined
const peakRx = exactPeaks ? exactPeaks.rx : peakOfCombinedTraffic(kpiSource.map(s => s.rxSeries))
const peakTx = exactPeaks ? exactPeaks.tx : peakOfCombinedTraffic(kpiSource.map(s => s.txSeries))
const visibleSortFields = SORT_FIELDS.filter(s => !s.modesOnly || s.modesOnly.includes(effectiveMode))
const ingestLine = flowIngestLine(flowStats)
const collectorAlive = Boolean(flowStats?.listenerBound || flowStats?.packetsReceived)
const ingestLine = flowIngestLine(collectorStatus)
const flowError = liveError
|| flowLiveError
|| (displayedFlow?.degraded ? "Коллектор перегружен: упрощённая аналитика" : null)
@@ -1139,7 +1166,7 @@ export default function TrafficPage() {
},
{
id: "bps",
label: "Скорость",
label: "Скорость IPFIX",
value: displayedFlow ? fmtRate(displayedFlow.bpsNow / 1_000_000) : "—",
hint: flowLiveHint,
icon: <ActivityIcon className="size-4" />,
@@ -1164,29 +1191,33 @@ export default function TrafficPage() {
const counterKpiItems = [
{
id: "rx",
label: "RX",
label: "Сумма RX",
value: fmtRate(totalRx),
hint: effectiveMode === "servers" ? "Интерфейсы и туннели" : undefined,
icon: <ArrowDownIcon className="size-4" />,
iconClassName: "text-success",
},
{
id: "tx",
label: "TX",
label: "Сумма TX",
value: fmtRate(totalTx),
hint: effectiveMode === "servers" ? "Интерфейсы и туннели" : undefined,
icon: <ArrowUpIcon className="size-4" />,
iconClassName: "text-info",
},
{
id: "peak-rx",
label: "Пик RX",
label: "Пик суммы RX",
value: fmtRate(peakRx),
hint: exactPeaks ? "По общим замерам" : "По интервалам графика",
icon: <TrendingUpIcon className="size-4" />,
iconClassName: "text-warning",
},
{
id: "peak-tx",
label: "Пик TX",
label: "Пик суммы TX",
value: fmtRate(peakTx),
hint: exactPeaks ? "По общим замерам" : "По интервалам графика",
icon: <TrendingUpIcon className="size-4" />,
iconClassName: "text-warning",
},
@@ -1330,7 +1361,7 @@ export default function TrafficPage() {
))}
{!liveBusy && !liveError && (range === "30d" ? visibleMonthlyServers.length : sortedFlowCards.length) === 0 ? (
<p className="text-xs text-muted-foreground">
{range === "30d" ? (q ? "Нет серверов по этому запросу" : "В каталоге нет серверов") : flowEmptyHint(flowStats, collectorAlive) ?? "Нет экспортёров IPFIX. Подключите jump-host."}
{range === "30d" ? (q ? "Нет серверов по этому запросу" : "В каталоге нет серверов") : flowEmptyHint(collectorStatus) ?? "Нет экспортёров IPFIX."}
</p>
) : null}
</div>
@@ -1359,7 +1390,7 @@ export default function TrafficPage() {
excludeOverlay={flowExcludeOverlay}
onExcludeOverlay={setFlowExcludeOverlay}
liveHint={flowLiveHint}
emptyHint={analyticsLoading ? "Загрузка аналитики…" : currentAnalytics?.error ? "Не удалось получить данные выбранного среза" : flowEmptyHint(flowStats, collectorAlive)}
emptyHint={analyticsLoading ? "Загрузка аналитики…" : currentAnalytics?.error ? "Не удалось получить данные выбранного среза" : flowEmptyHint(collectorStatus)}
/>
</FramePanel>
</Frame>
@@ -12,6 +12,7 @@ export const ACCEPTANCE_SHARDS: Record<string, (actor: AuthUser) => Promise<unkn
acceptRouteCommunityContextMcp: async actor => (await import("./routing-community-context-acceptance.js")).acceptRouteCommunityContextMcp(actor),
acceptWireguardPeerCreation: async actor => (await import("./wireguard-peer-create-acceptance.js")).acceptWireguardPeerCreation(actor),
acceptWireguardInterfaceUpdate: async actor => (await import("./wireguard-interface-update-acceptance.js")).acceptWireguardInterfaceUpdate(actor),
acceptInterfaceRename: async actor => (await import("./interface-rename-acceptance.js")).acceptInterfaceRename(actor),
acceptWireguardImport: async actor => (await import("./wireguard-import-acceptance.js")).acceptWireguardImport(actor),
verifyMcpFlowOverlay: async actor => (await import("../../test/mcp-flow-overlay.js")).verifyMcpFlowOverlay(actor),
acceptWireguardInterfaceDeletion: async actor => (await import("./wireguard-interface-delete-acceptance.js")).acceptWireguardInterfaceDeletion(actor),
+2
View File
@@ -91,6 +91,7 @@ import { registerTerminalDiagnosticActions } from "./terminal-diagnostic-actions
import { registerEventsBatchActions } from "./events-batch-actions.js"
import { registerGlobalReconciliationActions } from "./global-reconciliation-actions.js"
import { registerWireguardInterfaceUpdateActions } from "./wireguard-interface-update-actions.js"
import { registerInterfaceRenameActions } from "./interface-rename-actions.js"
import { registerWireguardImportActions } from "./wireguard-import-actions.js"
import { registerWireguardExportActions } from "./wireguard-export-actions.js"
import { registerServerConnectionActions } from "./server-connection-actions.js"
@@ -710,6 +711,7 @@ registerTerminalDiagnosticActions(add)
registerEventsBatchActions(add)
registerGlobalReconciliationActions(add)
registerWireguardInterfaceUpdateActions(add)
registerInterfaceRenameActions(add)
registerWireguardImportActions(add)
registerServerConnectionActions(add)
registerIpsecPeerDeleteActions(add)
@@ -22,8 +22,8 @@ import { getFlowMonthly } from "../../services/traffic-flow-analytics.js"
import { readPublicTrafficSettings, updateTrafficSettings } from "../../services/traffic-collector.js"
import { readUptimeSettings, updateUptimeSettings, readProbeRows, replaceProbes } from "../../services/uptime-collector.js"
import { readSpeedProbeCatalog, replaceSpeedProbeCatalog } from "../../services/speed-probe-catalog.js"
import { getTrafficFlowSettingsRow, toTrafficFlowSettingsDto } from "../../services/traffic-flow-settings.js"
import { getFlowListenerState } from "../../services/traffic-flow-ingest.js"
import { getTrafficFlowSettingsRow } from "../../services/traffic-flow-settings.js"
import { readTrafficFlowSettingsStatus } from "../../services/traffic-flow-ingest.js"
import { withFlowConfigurationLock, getFlowHostStatus, reconcileFlowHost } from "../../services/traffic-flow-host-agent.js"
import { agentSocket } from "../../services/traffic-flow-agent-client.js"
import { getStatistics, getStatisticsPivot, pivotDimsConflict } from "../../services/statistics-aggregate.js"
@@ -185,7 +185,7 @@ export function registerApplicationActions(register: typeof add) {
change("traffic.settings.update", "mm_traffic_settings_update_plan", "План настроек сбора трафика", "mm:traffic:write", z.object({ settings: trafficSettings }).strict(), readTrafficConfiguration, async input => { const result = await updateTrafficSettings(trafficSettings.parse(input.settings)); await refreshScheduler(); return result })
query("uptime.settings.read", "mm_uptime_settings_get", "Настройки мониторинга и проб", "mm:uptime:read", async () => readUptimeSettings())
change("uptime.settings.update", "mm_uptime_settings_update_plan", "План расписания мониторинга и проб", "mm:uptime:write", z.object({ settings: uptimeSettings }).strict(), readUptimeConfiguration, async input => { const result = await updateUptimeSettings(uptimeSettings.parse(input.settings)); await refreshScheduler(); return result })
query("netflow.settings.read", "mm_netflow_settings_get", "Публичные настройки NetFlow", "mm:traffic:read", async () => toTrafficFlowSettingsDto(getFlowListenerState()))
query("netflow.settings.read", "mm_netflow_settings_get", "Публичные настройки NetFlow", "mm:traffic:read", readTrafficFlowSettingsStatus)
query("scheduler.runs", "mm_scheduler_runs_list", "История заданий", "mm:settings:admin", async input => listSchedulerRuns({ limit: Number(input.limit), offset: Number(input.offset), jobKey: input.jobKey as string | undefined }), z.object({ ...paging, jobKey: z.enum(JOB_KEYS).optional() }).strict())
query("servers.api-ping.settings.read", "mm_servers_api_ping_settings_get", "Настройки API-ping серверов", "mm:servers:read", async () => getServersApiPingSettings())
change("servers.api-ping.settings.update", "mm_servers_api_ping_settings_update_plan", "План API-ping серверов", "mm:servers:write", z.object({ settings: z.object({ enabled: z.boolean().optional(), intervalSec: z.number().int().min(10).max(86400).optional() }).strict().refine(value => Object.keys(value).length > 0) }).strict(), readServersApiPingConfiguration, async input => { const result = await updateServersApiPingSettings(input.settings as Parameters<typeof updateServersApiPingSettings>[0]); await refreshScheduler(); return result })
@@ -25,6 +25,7 @@ export function registerLegacyFlowAnalyticsAction(register: typeof add) {
{ serverIds: context.connection.policy.scope.serverIds, maxRows: 20000, authorize }), context.signal)
return {
serverId: input.serverId, source: "PostgreSQL/flow_buckets", observedAt: new Date().toISOString(), sourceWindow: result.sourceWindow,
timeBasis: result.timeBasis, admittedTotals: result.admittedTotals,
bpsNow: result.bpsNow, bytes: result.bytes, packets: result.packets, conversations: result.conversations,
uniqueSrc: result.uniqueSrc, uniqueDst: result.uniqueDst, rxSeries: result.rxSeries, txSeries: result.txSeries,
applications: result.applications, protocols: result.protocols, countries: result.countries,
@@ -68,14 +69,14 @@ export function registerFlowAnalyticsActions(register: typeof add) {
analytics[key] = value.slice(offset, offset + limit)
pages[key] = { total: value.length, nextOffset: offset + limit < value.length ? offset + limit : null }
}
// Ring rates are server context, including when the retained rows are filtered by user/interface.
// Wire rate uses interface counters. Keep rate estimates separate from retained volume.
const { bpsNow: _bpsNow, bpsWire: _bpsWire, bpsOverlay: _bpsOverlay, bytesWire: _bytesWire, live: _live, ...retained } = analytics
await authorize()
if ((await readFlowSourceLimits()).topN !== limits.topN) throw new McpError("STATE_CONFLICT", "Предел источника NetFlow изменился во время чтения", 409)
await authorize()
const output = { serverId: server.id, minutes: sourceWindow?.effectiveMinutes ?? Number(input.minutes), sourceWindow, interface: input.interface ?? null, userId: input.userId ?? null,
analytics: retained, pages, contextRates: { bpsNowEstimate: _bpsNow, bpsWireEstimate: _bpsWire, bpsOverlayEstimate: _bpsOverlay, bytesWireEstimate: _bytesWire,
listenerBound: _live, userAttributionVerified: false, semantics: "REST estimates: current server/interface ring with retained-window fallback; wire projection uses current interface snapshots" },
listenerBound: _live, userAttributionVerified: false, semantics: "REST estimates: filtered or overlay-inclusive rates use the latest complete retained minute with a window-average fallback; wire uses current interface snapshots" },
readStartedAt: startedAt, observedAt: new Date().toISOString(), live: false,
source: "retained flow_buckets plus pending; same REST analytics engine with scoped topology",
rowLimit: 20000, topRowsPerBucketLimit: Math.max(20, limits.topN), engineTopListLimit: Math.min(50, Math.max(10, limits.topN)),
+1 -1
View File
@@ -57,7 +57,7 @@ export function registerFlowLiveActions(register: typeof add) {
source: "REST live sample engine: current ring estimates and rolling flow_buckets plus pending; uncached scoped reads",
rowLimit: 20000, incomplete: true, coverageVerified: false, forwardingVerified: false, rowSumIsNetworkTotal: false,
historicalOwnershipVerified: false, currentTrafficVerified: false,
rateSemantics: "REST live rates: current server/interface ring; retained-window fallback; user filter does not attribute ring rates",
rateSemantics: "REST live rates: filtered or overlay-inclusive rates use the latest complete retained minute with a window-average fallback",
liveMeaning: "events[].data.live means listener bound; it does not prove exporter freshness or forwarding",
attribution: "current named whole-interface bindings; users with hidden bindings excluded",
collectorStarted: false, backgroundEnrichmentStarted: false }
@@ -3028,6 +3028,7 @@ try {
await soft("verifyMcpTerminalDiagnostics", async () => (await import("../../test/mcp-terminal-diagnostics.js")).verifyMcpTerminalDiagnostics(actor, app))
await soft("verifyMcpEventsBatch", async () => (await import("../../test/mcp-events-batch.js")).verifyMcpEventsBatch(actor, app))
await shardable("acceptWireguardInterfaceUpdate")
await shardable("acceptInterfaceRename")
await shardable("acceptWireguardImport")
await soft("acceptWireguardExportMcp", async () => (await import("./wireguard-export-acceptance.js")).acceptWireguardExportMcp(actor, app))
await soft("acceptProtectionRegistrationScope", async () => (await import("./protection-scope-acceptance.js")).acceptProtectionRegistrationScope(actor))
@@ -0,0 +1,110 @@
import assert from "node:assert/strict"
import { randomUUID } from "node:crypto"
import { createServer } from "node:http"
import { setTimeout as delay } from "node:timers/promises"
import { mcpConnectionCreateSchema } from "@mmapp/contracts/mcp"
import { pool } from "../../db/index.js"
import type { AuthUser } from "../../lib/permissions.js"
import { approvePlan, applyPlan, invokeMcpTool } from "./runtime.js"
import { authenticateMcpToken, createMcpConnection, setConnectionStatus } from "./store.js"
export async function acceptInterfaceRename(actor: AuthUser) {
const serverId = 174
const initial: Record<string, Record<string, string>[]> = {
"/interface": [
{ ".id": "*7", name: "wg1", type: "wg", dynamic: "false" },
{ ".id": "*8", name: "ether1", "default-name": "ether1", type: "ether" },
{ ".id": "*9", name: "radio one", type: "wifi" },
{ ".id": "*a", name: "dynamic1", type: "ppp", dynamic: "true" },
{ ".id": "*b", name: "wg1-backup", type: "wg" },
],
"/ip/address": [{ ".id": "*15", interface: "wg1", "actual-interface": "wg1", address: "192.0.2.1/30" }],
"/ipv6/address": [{ ".id": "*16", interface: "*7", address: "2001:db8::1/64" }],
"/interface/bridge/port": [{ ".id": "*14", bridge: "bridge1", interface: "ether1" }],
"/interface/wireguard/peers": [{ ".id": "*11", interface: "wg1", name: "other-site", "public-key": "fixture-public-key", "allowed-address": "192.0.2.2/32", "endpoint-port": "13235" }],
"/ip/firewall/filter": [
{ ".id": "*20", chain: "input", action: "accept", "in-interface": "wg1", protocol: "udp" },
{ ".id": "*21", chain: "forward", action: "drop", "in-interface": "!wg1", "out-interface": "wg1-backup" },
],
"/ip/route": [{ ".id": "*22", static: "true", gateway: "192.0.2.2%wg1@main", "dst-address": "198.51.100.0/24" }, ...Array.from({ length: 12_608 }, (_, i) => ({ ".id": `*r${i.toString(16)}`, dynamic: "true", gateway: "192.0.2.2%ether1" }))],
}
let rows = structuredClone(initial), reads = 0, mode: "normal" | "stale" | "lost" = "normal"
const writes: { path: string; fields: Record<string, string> }[] = []
const router = createServer(async (req, res) => {
const url = new URL(req.url ?? "/", "http://fixture.invalid"), path = url.pathname.slice(5)
res.setHeader("content-type", "application/json")
if (req.method === "GET") {
let records = rows[path] ?? []
if (url.searchParams.get("static") === "true") records = records.filter(row => row.static === "true")
const properties = url.searchParams.get(".proplist")?.split(",")
if (properties) records = records.map(row => Object.fromEntries(Object.entries(row).filter(([key]) => properties.includes(key))))
if (path === "/ip/firewall/filter") records = records.map(row => ({ ...row, packets: String(++reads) }))
res.end(JSON.stringify(records)); return
}
if (req.method !== "PATCH" || !/^\/interface\/\*[a-z0-9]+$/i.test(path)) { res.statusCode = 400; res.end("{}"); return }
let body = ""; for await (const chunk of req) body += chunk
const fields: Record<string, string> = JSON.parse(body), target = rows["/interface"].find(row => path.endsWith("/" + row[".id"]))!
const old = target.name
writes.push({ path, fields })
Object.assign(target, fields)
if (mode !== "stale") {
for (const rowsForPath of Object.values(rows)) for (const row of rowsForPath) for (const key of ["interface", "actual-interface", "in-interface", "out-interface"]) {
if (row[key] === old) row[key] = target.name
if (row[key] === "!" + old) row[key] = "!" + target.name
}
for (const row of rows["/ip/route"]) if (row.gateway.endsWith(`%${old}@main`)) row.gateway = row.gateway.replace(`%${old}@main`, `%${target.name}@main`)
}
if (mode === "lost") { req.socket.destroy(); return }
res.end(JSON.stringify(target))
})
await new Promise<void>(resolve => router.listen(0, "127.0.0.1", resolve))
let connectionId: string | undefined
const protection = randomUUID()
try {
await pool.query("INSERT INTO servers(id,name,host,port,use_ssl) VALUES($1,'interface-rename-fixture','127.0.0.1',$2,false)", [serverId, (router.address() as { port: number }).port])
const access = await createMcpConnection(mcpConnectionCreateSchema.parse({ name: "interface rename", mode: "approval", expiresAt: new Date(Date.now() + 1_800_000).toISOString(), permissions: ["mm:network:write"], scope: { serverIds: [serverId], operationIds: ["interfaces.rename"], allowGlobal: false }, limits: { callsPerMinute: 120 } }), actor)
connectionId = access.connection.id
const principal = await authenticateMcpToken(access.token)
const plan = async (iface: string, name: string) => (await invokeMcpTool(principal, "mm_interface_rename_plan", { serverId, interface: iface, name })) as { planId: string }
const execute = async (iface: string, name: string) => {
const { planId } = await plan(iface, name)
await approvePlan(planId, actor, true)
const { id } = await applyPlan(principal, planId, randomUUID())
for (let i = 0; i < 500; i++) {
const result = (await pool.query("SELECT state,error_code FROM mcp_operations WHERE id=$1", [id])).rows[0]
if (result && !["pending", "running"].includes(result.state)) return result
await delay(20)
}
throw new Error("Interface rename remains live")
}
await assert.rejects(plan("dynamic1", "renamed"), { code: "PROTECTED_OBJECT" })
await assert.rejects(plan("*7", "ether1"), { code: "STATE_CONFLICT" })
assert.equal(writes.length, 0)
await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,$3)", [protection, JSON.stringify({ kind: "ip_filter", id: "*20", serverId, protection: "deny" }), actor.id])
await assert.rejects(plan("*7", "protected-test"), { code: "PROTECTED_OBJECT" })
await pool.query("DELETE FROM mcp_protections WHERE id=$1", [protection])
assert.equal((await execute("wg1", "wg-to-msk-gw01")).state, "applied")
assert.deepEqual(writes[0], { path: "/interface/*7", fields: { name: "wg-to-msk-gw01" } })
assert.deepEqual(rows["/ip/firewall/filter"].map(row => row["in-interface"]), ["wg-to-msk-gw01", "!wg-to-msk-gw01"])
assert.equal(rows["/ip/firewall/filter"][1]["out-interface"], "wg1-backup")
assert.equal(rows["/interface/wireguard/peers"][0].interface, "wg-to-msk-gw01")
assert.equal(rows["/ipv6/address"][0].interface, "*7")
assert.equal(rows["/ip/route"][0].gateway, "192.0.2.2%wg-to-msk-gw01@main")
assert.equal((await execute("*8", "ether-wan")).state, "applied")
assert.equal(rows["/interface/bridge/port"][0].interface, "ether-wan")
assert.equal((await execute("radio one", "wifi guest")).state, "applied")
assert.equal(writes.length, 3)
mode = "stale"
assert.equal((await execute("wg-to-msk-gw01", "wg-incomplete")).error_code, "VERIFICATION_FAILED")
assert.equal(writes.length, 4)
rows = structuredClone(initial); mode = "lost"
assert.equal((await execute("wg1", "wg-unknown")).error_code, "MUTATION_OUTCOME_UNKNOWN")
assert.equal(writes.length, 5)
} finally {
await pool.query("DELETE FROM mcp_protections WHERE id=$1", [protection])
if (connectionId) await setConnectionStatus(connectionId, "paused", actor)
await pool.query("DELETE FROM servers WHERE id=$1", [serverId])
router.closeAllConnections()
await new Promise<void>((resolve, reject) => router.close(error => error ? reject(error) : resolve()))
}
}
@@ -0,0 +1,186 @@
import { z } from "zod"
import { pool } from "../../db/index.js"
import { assertVerifiedConfigurationAccess, assertVerifiedConfigurationReadAccess } from "../../services/config-mutation-policy.js"
import { greStableRows, assertGreDeleteDependencies } from "../../services/gre-mutation-state.js"
import { observedBoolean } from "../../services/ospf-observed-values.js"
import { encodeRosId, isRouterOsNativeId } from "../../services/routeros-native-paths.js"
import type { add } from "./actions.js"
import type { ChangeEvidence } from "./action-types.js"
import { rosSnapshotSourceProof, routerClient } from "./resources.js"
import { fingerprint, McpError, privateSecretFingerprint } from "./security.js"
import { registerMcpService } from "./service-registry.js"
const service = "interfaces.rename"
const name = z.string().min(1).max(100).refine(value => value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value))
const schema = z.object({ serverId: z.number().int().positive().safe(), interface: name, name }).strict()
const recordSchema = z.object({ serverId: schema.shape.serverId, id: z.string().max(200).refine(isRouterOsNativeId), from: name, to: name }).strict()
type Rename = z.infer<typeof recordSchema>
type Row = Record<string, string>
type Reference = "single" | "list" | "gateway" | "negated"
const inventory = "/interface?.proplist=.id,name,type,default-name,dynamic,builtin,default,disabled,mtu,l2mtu,comment"
const firewall = (["ip", "ipv6"] as const).flatMap(family => ["filter", "nat", "mangle", "raw"].map(table => ({
kind: `${family}_${table}`, path: `/${family}/firewall/${table}`, fields: { "in-interface": "negated", "out-interface": "negated" } as const, ordered: true,
})))
const references: { kind: string; path: string; fields: Record<string, Reference>; ordered?: boolean; wireguard?: boolean }[] = [
{ kind: "ipv4_address", path: "/ip/address", fields: { interface: "single", "actual-interface": "single" } },
{ kind: "ipv6_address", path: "/ipv6/address", fields: { interface: "single", "actual-interface": "single" } },
{ kind: "interface_list_member", path: "/interface/list/member", fields: { interface: "single" } },
{ kind: "bridge_port", path: "/interface/bridge/port", fields: { interface: "single", bridge: "single" } },
{ kind: "bridge_vlan", path: "/interface/bridge/vlan", fields: { bridge: "single", tagged: "list", untagged: "list" } },
{ kind: "vlan", path: "/interface/vlan", fields: { interface: "single" } },
{ kind: "bonding", path: "/interface/bonding", fields: { slaves: "list" } },
{ kind: "vrrp", path: "/interface/vrrp", fields: { interface: "single", "group-authority": "single" } },
{ kind: "wireguard_peer", path: "/interface/wireguard/peers?.proplist=.id,interface,name,public-key,allowed-address,endpoint-address,endpoint-port,persistent-keepalive,disabled,dynamic,comment", fields: { interface: "single" }, wireguard: true },
{ kind: "ipv4_route", path: "/ip/route?static=true", fields: { gateway: "gateway" } },
{ kind: "ipv6_route", path: "/ipv6/route?static=true", fields: { gateway: "gateway" } },
{ kind: "routing_rule", path: "/routing/rule", fields: { interface: "single" }, ordered: true },
{ kind: "vrf", path: "/ip/vrf", fields: { interfaces: "list" }, ordered: true },
{ kind: "ospf_template", path: "/routing/ospf/interface-template", fields: { interfaces: "list" }, ordered: true },
{ kind: "bfd_configuration", path: "/routing/bfd/configuration", fields: { interfaces: "list" }, ordered: true },
...firewall,
]
const fail = (code: string, message: string, status = 409) => new McpError(code, message, status)
const unstable = (path: string) => fail("STATE_UNAVAILABLE", `Не подтверждён каталог RouterOS ${path.split("?")[0]}`, 502)
const unsupported = new Set(["all", "none", "dynamic", "slave", "static", "wg-flow", "lo"])
async function catalogue(client: Awaited<ReturnType<typeof routerClient>>["client"], path: string): Promise<Row[]> {
const routes = path.endsWith("?static=true")
let raw: unknown
try { raw = await client.get<unknown>(path, 10_000, undefined, routes ? 8 * 1024 * 1024 : 1_048_576) }
catch (error) { if (error instanceof McpError) throw error; throw unstable(path) }
if (!Array.isArray(raw) || raw.length > (routes ? 50_000 : 10_000) || raw.some(row => !row || typeof row !== "object" || Array.isArray(row) || !isRouterOsNativeId(row[".id"]) || Object.values(row).some(value => typeof value !== "string")) || new Set(raw.map(row => row[".id"])).size !== raw.length) throw unstable(path)
return raw as Row[]
}
/** RouterOS can render the same typed reference as a name or a native ID. */
function interfaceRenameReference(value: string, mode: Reference, aliases: ReadonlySet<string>, replacement: string): string {
if (aliases.has(value)) return replacement
if (mode === "negated" && value.startsWith("!") && aliases.has(value.slice(1))) return `!${replacement}`
if (mode === "list" || mode === "gateway") return value.split(",").map(part => {
if (aliases.has(part)) return replacement
if (mode === "gateway") {
const match = /^([^%@]+%)?([^%@]+)(@[^%@]+)?$/.exec(part)
if (match && aliases.has(match[2])) return `${match[1] ?? ""}${replacement}${match[3] ?? ""}`
}
return part
}).join(",")
return value
}
function targetFrom(rows: Row[], identity: string) {
const target = rows.find(row => row.name === identity || row[".id"] === identity)
if (!target) throw fail("NOT_FOUND", "Интерфейс RouterOS не найден", 404)
if (!target.type || !target.name || rows.filter(row => row.name === target.name || row[".id"] === identity || row.name === identity).length !== 1) throw unstable(inventory)
if (["dynamic", "builtin", "default"].some(key => target[key] !== undefined && observedBoolean(target[key]) !== false) || unsupported.has(target.name.toLowerCase()) || target.comment === "MikrotikManager traffic-flow overlay") throw fail("PROTECTED_OBJECT", "Динамический, системный или управляемый NetFlow интерфейс нельзя переименовать этим планом")
return target
}
async function applicationReferences(move: Rename) {
const names = [move.id, move.from, move.to]
const { rows } = await pool.query<{ bound: boolean }>(`SELECT (
EXISTS(SELECT 1 FROM user_interface_bindings WHERE server_id=$1 AND interface_name=ANY($2::text[])) OR
EXISTS(SELECT 1 FROM uptime_probes WHERE src_server_id=$1 AND src_interface=ANY($2::text[])) OR
EXISTS(SELECT 1 FROM uptime_speed_probes WHERE (src_server_id=$1 AND src_interface=ANY($2::text[])) OR (dst_server_id=$1 AND dst_interface=ANY($2::text[])))
) AS bound`, [move.serverId, names])
if (rows[0]?.bound !== false) throw fail("DEPENDENCY_CONFLICT", "Имя или ID используется в настройках приложения; требуется согласованное изменение привязки")
const { rows: filters } = await pool.query<{ id: number; gateway: string; gatewayTunnelId: string }>('SELECT id, gateway, gateway_tunnel_id AS "gatewayTunnelId" FROM filter_rules WHERE server_id=$1 LIMIT 1001', [move.serverId])
if (filters.length > 1000) throw fail("STATE_UNAVAILABLE", "Не подтверждены зависимости фильтров приложения", 502)
const aliases = new Set(names)
if (filters.some(row => aliases.has(row.gatewayTunnelId) || interfaceRenameReference(row.gateway, "gateway", aliases, "\u0000") !== row.gateway)) throw fail("DEPENDENCY_CONFLICT", "Интерфейс используется BGP-фильтром приложения")
}
async function read(move: Rename, expectedSource: string, authorize: () => Promise<unknown>) {
await authorize()
const { client, server } = await routerClient(move.serverId)
if (await rosSnapshotSourceProof(server) !== expectedSource) throw fail("STATE_CONFLICT", "Источник RouterOS изменился")
const interfaces = await catalogue(client, inventory), target = targetFrom(interfaces, move.id)
if (![move.from, move.to].includes(target.name) || interfaces.some(row => row[".id"] !== move.id && row.name === move.to)) throw fail("STATE_CONFLICT", "Интерфейс изменился или новое имя уже занято")
const aliases = new Set([move.from, move.to, move.id]), current = new Set([target.name, move.id])
const marker = `\u0000${move.id}`
const affected: ChangeEvidence["objects"] = []
const sections: unknown[] = []
for (const dependency of references) {
if (dependency.wireguard && !["wg", "wireguard"].includes(target.type)) continue
await authorize()
const rows = await catalogue(client, dependency.path)
if (dependency.path.endsWith("?static=true") && rows.some(row => observedBoolean(row.dynamic) === true || observedBoolean(row.static) === false)) throw unstable(dependency.path)
const selected: Row[] = []
for (const [position, row] of rows.entries()) {
if (observedBoolean(row.dynamic) === true) continue
const projection = { ...row }
let related = false
for (const [field, mode] of Object.entries(dependency.fields)) {
if (row[field] === undefined || interfaceRenameReference(row[field], mode, aliases, marker) === row[field]) continue
if (interfaceRenameReference(row[field], mode, aliases, marker) !== interfaceRenameReference(row[field], mode, current, marker)) throw fail("DEPENDENCY_CONFLICT", `Несогласованная ссылка на интерфейс в ${dependency.path.split("?")[0]}`)
projection[field] = interfaceRenameReference(row[field], mode, current, marker)
related = true
}
if (!related) continue
affected.push({ kind: dependency.kind, id: row[".id"], serverId: move.serverId })
// These bridge VLAN memberships are derived by RouterOS from the configured ports and PVID.
if (dependency.kind === "bridge_vlan") { delete projection["current-tagged"]; delete projection["current-untagged"] }
if (dependency.ordered) projection.position = String(position)
selected.push(projection)
}
sections.push([dependency.kind, greStableRows(selected, dependency.ordered)])
}
const policyPath = "/routing/filter/rule?.proplist=.id,rule"
await authorize()
const routingFilters = await catalogue(client, policyPath)
for (const reference of [move.from, move.to]) assertGreDeleteDependencies({ dependencies: { [policyPath]: routingFilters }, bindings: [], filters: [] }, { name: reference, ".id": move.id }, "Имя интерфейса")
await applicationReferences(move)
await authorize()
if (await rosSnapshotSourceProof((await routerClient(move.serverId)).server) !== expectedSource) throw fail("STATE_CONFLICT", "Источник RouterOS изменился во время чтения")
const identities = interfaces.filter(row => row[".id"] === move.id || observedBoolean(row.dynamic) !== true)
const proof = (targetName: string) => privateSecretFingerprint(fingerprint({ interfaces: greStableRows(identities.map(row => row[".id"] === move.id ? { ...row, name: targetName } : row)), sections }), "mcp-interface-rename-v1")
return { target, affected, before: { name: target.name, proof: await proof(target.name) }, afterProof: await proof(move.to) }
}
export function registerInterfaceRenameActions(register: typeof add) {
const current = async (input: Record<string, unknown>) => (await read(recordSchema.parse(input.move), String(input.source), async () => {})).before
registerMcpService(service, {
current,
execute: async input => {
const move = recordSchema.parse(input.move), source = String(input.source)
const { client } = await routerClient(move.serverId)
try {
await client.patch(`/interface/${encodeRosId(move.id)}`, { name: move.to }, 15_000, async () => {
await assertVerifiedConfigurationAccess()
if ((await read(move, source, assertVerifiedConfigurationReadAccess)).before.proof !== input.beforeProof) throw fail("STATE_CONFLICT", "Интерфейс или его ссылки изменились перед переименованием")
await assertVerifiedConfigurationAccess()
})
} catch (error) {
if (error instanceof McpError) throw error
throw fail("MUTATION_OUTCOME_UNKNOWN", "Исход переименования не подтверждён; повтор запрещён", 503)
}
return { interfaceId: move.id, previousName: move.from, name: move.to }
},
verify: async input => {
try { return (await current(input)).proof === input.afterProof }
catch (error) { if (error instanceof McpError && error.code === "DEPENDENCY_CONFLICT") return false; throw error }
},
reconcile: async (input, authorize) => {
const { before } = await read(recordSchema.parse(input.move), String(input.source), authorize)
return { matchesOriginalState: before.proof === input.beforeProof, matchesDesiredState: before.proof === input.afterProof }
},
})
register(service, "mm_interface_rename_plan", "Переименовать интерфейс RouterOS по ID или текущему имени и проверить сохранность привязок", "network", "mm:network:write", "write", "servers", schema, {
prepare: async (input, context) => {
const request = schema.parse(input), { client, server } = await routerClient(request.serverId)
const source = await rosSnapshotSourceProof(server)
const target = targetFrom(await catalogue(client, inventory), request.interface)
if (request.name === target.name || unsupported.has(request.name.toLowerCase()) || isRouterOsNativeId(request.name)) throw fail("INVALID_INPUT", "Укажите новое незарезервированное имя интерфейса", 400)
const move = recordSchema.parse({ serverId: request.serverId, id: target[".id"], from: target.name, to: request.name })
const state = await read(move, source, async () => { context.signal?.throwIfAborted() })
if (state.before.name !== move.from) throw fail("STATE_CONFLICT", "Имя интерфейса изменилось во время подготовки")
const kind = ({ wg: "wireguard", ether: "ethernet" } as Record<string, string>)[state.target.type] ?? state.target.type
const objects = [{ kind: "server", id: String(move.serverId), serverId: move.serverId }, ...[...new Set(["interface", kind])].flatMap(kind => [move.id, move.from, move.to].map(id => ({ kind, id, serverId: move.serverId }))), ...state.affected]
return { target: { scope: "servers", serverIds: [move.serverId] }, objects, snapshots: [], before: state.before, requiresHuman: true, verificationScope: "configuration",
steps: [{ kind: "service", service, input: { serverId: move.serverId, move, source, beforeProof: state.before.proof, afterProof: state.afterProof } }],
warnings: ["Выполняется один RouterOS PATCH имени по native ID. Передача трафика может кратко прерваться.", "Проверяются идентичность интерфейса и ссылки в наблюдаемых каталогах RouterOS. Пользовательские скрипты и история метрик по имени не переписываются.", "При неясном исходе требуется сверка. Команда не повторяется автоматически."],
}
},
})
}
@@ -62,11 +62,17 @@ const router = createServer(async (req, res) => {
if (req.method === "GET") { res.end(JSON.stringify(catalogs[path] ?? [])); return }
let raw = ""; for await (const chunk of req) raw += chunk
const fields = raw ? JSON.parse(raw) as Row : {}
if (path === "/file/get" || path === "/file/print") { res.end(JSON.stringify({ ret: fakeP12 })); return }
if (path === "/file/get") {
assert(catalogs["/file"].some(row => row[".id"] === fields[".id"] && row[".id"].startsWith("**")))
res.end(JSON.stringify({ ret: fakeP12 }))
return
}
commands.push({ method: req.method!, path, ...(fields.name ? { name: fields.name } : {}) })
if (req.method === "POST" && path === "/certificate/export-certificate") {
assert(catalogs["/certificate"].some(row => row.name === fields.name))
catalogs["/file"].push({ ".id": `*new${++serial}`, name: `${fields["file-name"]}.p12`, size: String(Buffer.byteLength(fakeP12)), type: "file" })
const certificate = catalogs["/certificate"].find(row => row[".id"] === fields[".id"])
assert(certificate && !("name" in fields))
commands.at(-1)!.name = certificate.name
catalogs["/file"].unshift({ ".id": `**New${++serial}`, name: `${fields["file-name"]}.p12`, size: String(Buffer.byteLength(fakeP12)), type: "file" })
if (mode === "lost") { req.socket.destroy(); return }
} else if (req.method === "DELETE" && path.startsWith("/file/")) {
catalogs["/file"] = catalogs["/file"].filter(row => row[".id"] !== path.slice("/file/".length))
@@ -42,19 +42,30 @@ export async function acceptIpsecUserCreate(actor: AuthUser) {
if (req.method === "GET") { res.end(JSON.stringify(catalogs[path] ?? [])); return }
let raw = ""; for await (const chunk of req) raw += chunk
const fields = raw ? JSON.parse(raw) as Row : {}
if (path === "/file/get" || path === "/file/print") { res.end(JSON.stringify({ ret: fakeP12 })); return }
if (path === "/file/get") {
assert(catalogs["/file"].some(row => row[".id"] === fields[".id"] && row[".id"].startsWith("**")))
res.end(JSON.stringify({ ret: mode === "download-failed" ? "short" : fakeP12 }))
return
}
commands.push({ method: req.method!, path, fields })
// RouterOS 7.24 (stand probe 2026-11-21): no `comment` on /certificate; sign and export by `.id` only, no `name`/`days-valid`.
const refusal = req.method === "PUT" && path === "/certificate" && "comment" in fields ? "unknown parameter comment"
: path === "/certificate/sign" && ("days-valid" in fields || "name" in fields) ? ("days-valid" in fields ? "unknown parameter days-valid" : "missing =.id=")
: path === "/certificate/export-certificate" && "name" in fields ? "unknown parameter name" : undefined
if (refusal) { res.statusCode = 400; res.end(JSON.stringify({ error: 400, message: "Bad Request", detail: refusal })); return }
if ((mode === "export-refused" && path === "/certificate/export-certificate") || (mode === "cleanup-refused" && req.method === "DELETE" && path.startsWith("/file/"))) {
res.statusCode = 400; res.end(JSON.stringify({ error: 400, detail: "NEVER_NATIVE_ERROR_DETAILS" })); return
}
let result: Row = {}
if (mode !== "ignored") {
if (path === "/certificate/sign") {
const row = catalogs["/certificate"].find(row => row[".id"] === fields[".id"]); assert(row)
Object.assign(row, { ca: fields.ca, "digest-algorithm": "sha256", fingerprint: "synthetic-fingerprint", "invalid-before": "2026-01-01", "invalid-after": "2030-01-01", "private-key": "true", "serial-number": "synthetic" })
} else if (path === "/certificate/export-certificate") assert(catalogs["/certificate"].some(row => row[".id"] === fields[".id"])), catalogs["/file"].push({ ".id": `*new${++serial}`, name: `${fields["file-name"]}.p12`, size: String(Buffer.byteLength(fakeP12)), type: "file" })
} else if (path === "/certificate/export-certificate") {
assert(catalogs["/certificate"].some(row => row[".id"] === fields[".id"]))
catalogs["/file"].unshift({ ".id": `**New${++serial}`, name: `${fields["file-name"]}.p12`, size: String(Buffer.byteLength(fakeP12)), type: "file" })
if (mode === "other-file-changed") catalogs["/file"][1].size = "99"
}
else {
const catalog = Object.keys(catalogs).find(value => path === value || path.startsWith(value + "/")); assert(catalog)
if (req.method === "PUT") { result = { ".id": `*new${++serial}`, ...fields, "native-default": "NEVER_NATIVE_DEFAULT" }; catalogs[catalog].push(result) }
@@ -101,6 +112,7 @@ export async function acceptIpsecUserCreate(actor: AuthUser) {
const stored = (await query("SELECT * FROM mcp_artifacts WHERE id=$1", [saved.artifactId])).rows[0]; hidden(stored); assert.equal(stored.access_scope.kind, "ipsec-user-bundle"); assert(stored.expires_at.getTime() <= Date.now() + 900000)
const download = await portal.inject({ url: saved.downloadPath, headers }); assert.equal(download.statusCode, 200, download.body); assert.equal(download.headers["cache-control"], "private, no-store")
const bundle = download.json(); assert.equal(Buffer.from(bundle.contentB64, "base64").toString(), fakeP12); assert.equal(bundle.passphrase, "NEVER_EXPORT_PASSPHRASE")
assert.equal(JSON.parse(bundle.sswanContent).local.p12, bundle.contentB64)
assert.equal((await portal.inject({ url: saved.downloadPath, headers: { authorization: `Bearer ${token("other-owner")}` } })).statusCode, 403)
assert.equal((await portal.inject({ url: saved.downloadPath, headers: { authorization: `Bearer ${token(actor.id, ["mm:network:read"])}` } })).statusCode, 403)
const listing: { statusCode: number; body: string; json: () => { items: Array<{ id: string; artifactReceipts: Array<{ artifactId: string }> }> } } = await portal.inject({ url: `/api/mcp/operations?connectionId=${connectionId}`, headers }); assert.equal(listing.statusCode, 200, listing.body); hidden(listing.json()); assert(listing.json().items.find((row: { id: string }) => row.id === result.operation.id)!.artifactReceipts.some((row: { artifactId: string }) => row.artifactId === saved.artifactId))
@@ -110,6 +122,29 @@ export async function acceptIpsecUserCreate(actor: AuthUser) {
const response = await rest.inject({ method: "POST", url: "/api/ipsec/users", payload: { serverId, name: "Alice", authMethod, ...(staticIp ? { staticIp } : {}), ...(authMethod === "certificate" ? { daysValid: 365, passphrase: "NEVER_EXPORT_PASSPHRASE" } : { psk: "NEVER_PSK_SECRET", remoteId: "alice.example.test" }) } }); assert.equal(response.statusCode, 201, response.body)
assert.deepEqual(normalize(commands.slice(restStart)), accepted)
}
reset(); mode = "download-failed"
const failedExport = await rest.inject({ method: "POST", url: "/api/ipsec/users", payload: { serverId, name: "Alice", staticIp: "192.0.2.7" } })
assert.equal(failedExport.statusCode, 502, failedExport.body)
assert.equal(failedExport.json().state, "partial")
assert.deepEqual(catalogs["/ip/ipsec/identity"], base["/ip/ipsec/identity"])
assert.deepEqual(catalogs["/ip/ipsec/mode-config"], base["/ip/ipsec/mode-config"])
reset(); mode = "other-file-changed"
const unrelatedChange = await rest.inject({ method: "POST", url: "/api/ipsec/users", payload: { serverId, name: "Alice" } })
assert.equal(unrelatedChange.statusCode, 502)
assert.equal(unrelatedChange.json().completedCommands, 2)
assert.equal(catalogs["/file"].length, 2, "failed proof must stop before deletion")
for (const [fault, stage, completed] of [["export-refused", "экспорт .p12", 2], ["cleanup-refused", "удаление временного .p12", 3]] as const) {
reset(); mode = fault
const response = await rest.inject({ method: "POST", url: "/api/ipsec/users", payload: { serverId, name: "Alice", staticIp: "192.0.2.7" } })
assert.equal(response.statusCode, 502)
const error = response.json()
assert.equal(error.completedCommands, completed)
assert(error.error.includes(stage))
assert(error.error.includes("HTTP 400"))
hidden(error)
assert.deepEqual(catalogs["/ip/ipsec/identity"], base["/ip/ipsec/identity"])
assert.deepEqual(catalogs["/ip/ipsec/mode-config"], base["/ip/ipsec/mode-config"])
}
reset(); const rawStart = commands.length
for (const request of [{ name: "Alice" }, { name: "Alice", authMethod: "pre-shared-key", psk: "NEVER_RAW" }, { name: "Alice", privateKeyExport: true, staticIp: "bad" }]) await assert.rejects(prepare(request))
assert.equal(commands.length, rawStart)
@@ -148,5 +148,5 @@ export function createIpsecUserCreateAdapter(overrides: Partial<typeof productio
export function registerIpsecUserCreateActions(register: typeof add) {
const adapter = createIpsecUserCreateAdapter()
registerMcpService(operation, adapter.service)
register(operation, "mm_ipsec_user_create_plan", "Создать клиента IPsec с проверкой всех native-команд, явным приватным экспортом и managed-only историей", "network", "mm:network:write", "write", "servers", ipsecUserCreateActionSchema, { version: 3, prepare: adapter.prepare })
register(operation, "mm_ipsec_user_create_plan", "Создать клиента IPsec с проверкой всех native-команд, явным приватным экспортом и managed-only историей", "network", "mm:network:write", "write", "servers", ipsecUserCreateActionSchema, { version: 4, prepare: adapter.prepare })
}
@@ -10,7 +10,7 @@ assert.equal(findMcpOperation(fullFlowSettings.operation.id)?.version, 3)
assert.equal(fullFlowSettings.schema.safeParse({ settings: { collectorIp: "10.255.254.1", enabled: false, mapServiceMinSharePct: 0 } }).success, true)
assert.equal(fullFlowSettings.schema.safeParse({ topN: 10 }).success, false)
assert.equal(findAction("mm_netflow_host_keys_generate_plan").operation.id, "traffic.flow.settings.generate-keys")
assert.equal(findAction("mm_ipsec_user_create_plan").operation.version, 3)
assert.equal(findAction("mm_ipsec_user_create_plan").operation.version, 4)
assert.equal(findAction("mm_ipsec_server_init_plan").operation.version, 5)
// RouterOS 7.24 certificate bodies (no comment, sign/export by .id): earlier prepared plans need a new approval.
assert.equal(findAction("mm_ipsec_existing_certificate_export_plan").operation.version, 2)
@@ -17,11 +17,15 @@ export async function acceptOspfRouteProofMcp(actor: AuthUser) {
const router = createServer(async (req, res) => {
res.setHeader("content-type", "application/json")
if (req.method === "GET" && req.url === tablePath) { reads++; res.end(JSON.stringify(tables)); return }
if (!["/rest/routing/route", "/rest/routing/route/get"].includes(req.url ?? "")) { res.statusCode = 404; res.end("{}"); return }
const url = new URL(req.url ?? "/", "http://fixture.invalid")
if (!["/rest/routing/route", "/rest/routing/route/get"].includes(url.pathname)) { res.statusCode = 404; res.end("{}"); return }
reads++
if (beforeReply) { const hook = beforeReply; beforeReply = undefined; await hook() }
if (nativeError) { res.statusCode = 400; res.end('{"message":"NEVER_ROUTE_PROVIDER_TOKEN"}'); return }
if (req.method === "GET") { res.end(JSON.stringify(rows)); return }
if (req.method === "GET") {
if (url.searchParams.get("dst-address") !== selection.prefix || url.searchParams.get("routing-table") !== selection.table) { res.statusCode = 400; res.end("{}"); return }
res.end(JSON.stringify(rows)); return
}
let body = ""; for await (const chunk of req) body += chunk
const key = JSON.parse(body)["value-name"]
if (key === "ospf.metric" && afterMetric) { const hook = afterMetric; afterMetric = undefined; await hook() }
@@ -36,7 +36,7 @@ export function registerOspfRouteProofActions(register: typeof add) {
if (error instanceof McpError) throw error
throw new McpError("STATE_UNAVAILABLE", input.expectAbsent === true
? "Отсутствие точного префикса во всей выбранной таблице не подтверждено"
: "Активный OSPF-маршрут, его метрика или выбранный выход не подтверждены; предел источника 10000 строк и 1 МиБ", 409)
: "Активный OSPF-маршрут, его метрика или выход через указанный интерфейс не подтверждены", 409)
}
},
})
+18
View File
@@ -55,6 +55,24 @@ test("unattended plans require an explicit service policy and retain server prot
denied(input, "PROTECTED_OBJECT")
})
test("service rate exemptions keep plan size, server scope and approval checks", () => {
const input = request()
assert.equal(mcpConnectionPolicySchema.safeParse({ ...input.policy, unlimitedRates: true }).success, false)
input.policy = mcpConnectionPolicySchema.parse({ ...input.policy, authority: "service", expiresAt: MCP_SERVICE_EXPIRATION, unlimitedRates: true })
input.usage = { callsInMinute: 10_000, concurrentReads: 100, mutationsInHour: 10_000 }
const read = { ...input, operationId: "logs.query" }
assert.equal(evaluateMcpPolicy(read, now).decision, "allowed")
const mutation = mcpPolicyDecisionSchema.parse(evaluateMcpPolicy(input, now))
assert.equal(mutation.unlimitedRates, true)
assert.equal(mutation.decision, "approval-required")
denied({ ...input, objectCount: input.policy.limits.objectsPerPlan + 1 }, "PLAN_LIMIT_EXCEEDED")
denied({ ...input, target: { scope: "servers", serverIds: [99] } }, "SERVER_DENIED")
denied({ ...input, protections: [{ kind: "server", id: "1", protection: "deny" }] }, "PROTECTED_OBJECT")
delete input.policy.unlimitedRates
denied(input, "BUDGET_EXCEEDED")
denied(read, "RATE_LIMITED")
})
test("observer reads permitted logs, but cannot run bandwidth or create users", () => {
const read = request("logs.query"); read.policy.mode = "observer"
assert.equal(evaluateMcpPolicy(read, now).decision, "allowed")
+9 -3
View File
@@ -12,6 +12,10 @@ export function hasUnattendedPlanAuthority(policy: McpConnectionPolicy) {
return policy.authority === "service" && policy.mode === "autonomous" && policy.allowUnattendedPlans === true
}
export function hasUnlimitedMcpRates(policy: McpConnectionPolicy) {
return policy.authority === "service" && policy.unlimitedRates === true
}
export function operationApprovalRequirement(policy: McpConnectionPolicy, operationId: string, target: McpPolicyPreviewRequest["target"], requiresHuman?: boolean): Pick<McpPolicyPreviewRequest, "objects" | "protections"> {
if (!requiresHuman || hasUnattendedPlanAuthority(policy)) return { objects: [], protections: [] }
const objects = target.scope === "servers" ? [] : [{ kind: "mcp-operation", id: operationId }]
@@ -24,6 +28,7 @@ export function evaluateMcpPolicy(payload: McpPolicyPreviewRequest, now = new Da
const input = mcpPolicyPreviewRequestSchema.parse(payload)
if (!Number.isFinite(now.getTime())) throw new Error("Некорректное время проверки MCP")
const { policy, target, usage } = input
const unlimitedRates = hasUnlimitedMcpRates(policy)
const denied: McpPolicyDecision["reasons"] = []
const approvals: McpPolicyDecision["reasons"] = []
const deny = (code: McpPolicyReasonCode, message: string) => { denied.push({ code, message }) }
@@ -32,6 +37,7 @@ export function evaluateMcpPolicy(payload: McpPolicyPreviewRequest, now = new Da
decision: denied.length ? "denied" : approvals.length ? "approval-required" : "allowed",
reasons: [...denied, ...approvals],
limits: policy.limits,
...(unlimitedRates && { unlimitedRates: true }),
})
const operation = findMcpOperation(input.operationId)
if (!operation) {
@@ -72,15 +78,15 @@ export function evaluateMcpPolicy(payload: McpPolicyPreviewRequest, now = new Da
deny("INVALID_OBJECT_SCOPE", "Объект или зависимость находится вне области запроса")
}
if (usage.callsInMinute >= policy.limits.callsPerMinute) deny("RATE_LIMITED", "Исчерпан минутный лимит вызовов")
if (!unlimitedRates && usage.callsInMinute >= policy.limits.callsPerMinute) deny("RATE_LIMITED", "Исчерпан минутный лимит вызовов")
if (operation.effect === "read") {
if (usage.concurrentReads >= policy.limits.concurrentReads) deny("RATE_LIMITED", "Исчерпан лимит одновременного чтения")
if (!unlimitedRates && usage.concurrentReads >= policy.limits.concurrentReads) deny("RATE_LIMITED", "Исчерпан лимит одновременного чтения")
return result()
}
if (policy.mode === "observer") deny("OBSERVER_WRITE_DENIED", "Наблюдателю запрещены изменения и нагрузочные проверки")
if (!input.auditAvailable) deny("AUDIT_UNAVAILABLE", "До начала изменений требуется доступный аудит")
if (usage.mutationsInHour >= policy.limits.mutationsPerHour || usage.mutationsInHour + input.objectCount > policy.limits.mutationsPerHour) deny("BUDGET_EXCEEDED", "Недостаточно часового бюджета для всех изменений плана")
if (!unlimitedRates && (usage.mutationsInHour >= policy.limits.mutationsPerHour || usage.mutationsInHour + input.objectCount > policy.limits.mutationsPerHour)) deny("BUDGET_EXCEEDED", "Недостаточно часового бюджета для всех изменений плана")
const affectedServers = new Set([
...(target.scope === "servers" ? target.serverIds : []),
...input.objects.flatMap(object => object.serverId === undefined ? [] : [object.serverId]),
@@ -20,12 +20,12 @@ const { pool, closePool } = await import("../../db/index.js")
const { SYSTEM_DATABASE_OPERATION_LOCK, SYSTEM_DATABASE_REQUEST_LOCK, withOperationLock, withSystemDatabaseOperationLock } = await import("../../db/operation-lock.js")
const { applySqlMigrations, applyStandaloneSqlMigrations } = await import("../../db/migrate.js")
const { PARTITION_WRITER_ADVISORY_KEY } = await import("../../services/partition-write-transaction.js")
const { authenticateMcpToken, createMcpConnection, updateMcpSettings } = await import("./store.js")
const { authenticateMcpToken, createMcpConnection, updateMcpConnection, updateMcpSettings } = await import("./store.js")
const { recordUnauthorizedProtocol, reserveProtocolEnvelope } = await import("./protocol-limits.js")
const { canonicalMcpUrl, encryptSecret, tokenDigest } = await import("./security.js")
const { buildApp } = await import("../../index.js")
const { sharedDatabaseGate } = await import("../../services/shared-database-gate.js")
const { invokeMcpTool } = await import("./runtime.js")
const { applyPlan, approvePlan, invokeMcpTool } = await import("./runtime.js")
const app = await buildApp({ startScheduler: false })
try {
@@ -177,6 +177,54 @@ try {
(SELECT count(*)::int FROM mcp_requests WHERE tool='protocol:unauthorized') AS unauthorized,
(SELECT max(attempts)::int FROM mcp_unauthorized_buckets) AS attempts`)
assert.deepEqual(counts, { denied: 1, unauthorized: 1, attempts: 8 })
const serviceOwner = { ...actor, permissions: [...actor.permissions, "mm:mcp:admin", "mm:dashboard:read"] }
const settings = mcpConnectionCreateSchema.parse({ name: "Service rate fixture", authority: "service", mode: "autonomous", expiresAt: null,
permissions: ["mm:dashboard:read"], scope: { serverIds: [], operationIds: ["capabilities.read", "events.batch.append"], allowGlobal: true },
limits: { callsPerMinute: 1, concurrentReads: 1, mutationsPerHour: 1 } })
const service = await createMcpConnection(settings, serviceOwner)
const servicePrincipal = await authenticateMcpToken(service.token)
const serviceId = service.connection.id
await pool.query(`INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used)
SELECT $1,kind,date_trunc(period,now())+window_shift,10 FROM (VALUES
('calls','minute',interval '0'),('protocol','minute',interval '0'),('mutations','hour',interval '0'),
('calls','minute',interval '1 minute'),('protocol','minute',interval '1 minute'),('mutations','hour',interval '1 hour')
) AS slots(kind,period,window_shift)`, [serviceId])
const leaseId = randomUUID()
await pool.query("INSERT INTO mcp_read_leases(id,connection_id,expires_at) VALUES($1,$2,now()+interval '2 minutes')", [leaseId, serviceId])
const serviceRequest = () => app.inject({ method: "POST", url: "/mcp", headers: {
authorization: `Bearer ${service.token}`, accept: "application/json, text/event-stream", "mcp-protocol-version": "2025-06-18",
}, payload: { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} } })
try {
assert.equal((await serviceRequest()).statusCode, 429)
await assert.rejects(invokeMcpTool(servicePrincipal, "mm_capabilities_get", {}), { code: "RATE_LIMITED" })
const updated = await updateMcpConnection(serviceId, { ...settings, unlimitedRates: true }, serviceOwner)
assert.equal(updated.policy.unlimitedRates, true)
assert.equal((await authenticateMcpToken(service.token)).credentialId, servicePrincipal.credentialId)
assert.equal((await serviceRequest()).statusCode, 200)
await invokeMcpTool(servicePrincipal, "mm_capabilities_get", {})
const eventType = `service-rate-fixture-${randomUUID()}`
const plan = await invokeMcpTool(servicePrincipal, "mm_events_batch_append_plan", { events: [
{ level: "info", eventType, sourceModule: "system", title: "Service rate fixture", message: "Synthetic journal entry" },
] }) as { planId: string; state: string }
assert.equal(plan.state, "awaiting-approval")
await approvePlan(plan.planId, serviceOwner, true)
const operation = await applyPlan(servicePrincipal, plan.planId, randomUUID())
let outcome: string | undefined
for (let i = 0; i < 250; i++) {
outcome = (await pool.query("SELECT state FROM mcp_operations WHERE id=$1", [operation.id])).rows[0]?.state
if (outcome && !["pending", "running"].includes(outcome)) break
await delay(20)
}
assert.equal(outcome, "applied")
assert.equal((await pool.query("SELECT count(*)::int AS n FROM events WHERE event_type=$1", [eventType])).rows[0].n, 1)
const restored = await updateMcpConnection(serviceId, settings, serviceOwner)
assert.equal(restored.policy.unlimitedRates, undefined)
assert.equal((await serviceRequest()).statusCode, 429)
await assert.rejects(invokeMcpTool(servicePrincipal, "mm_capabilities_get", {}), { code: "RATE_LIMITED" })
} finally {
await pool.query("DELETE FROM mcp_read_leases WHERE id=$1", [leaseId])
}
console.log("MCP request accounting respects the backup/restore lock independently of the partition lease")
} finally {
await app.close()
+3 -2
View File
@@ -1,6 +1,7 @@
import { randomUUID } from "node:crypto"
import { requestAccountingWrite, validatePrincipal, type McpPrincipal } from "./store.js"
import { accessGeneration, tokenDigest } from "./security.js"
import { hasUnlimitedMcpRates } from "./policy.js"
export async function reserveProtocolEnvelope(principal: McpPrincipal) {
return requestAccountingWrite(async client => {
@@ -9,8 +10,8 @@ export async function reserveProtocolEnvelope(principal: McpPrincipal) {
const connection = await validatePrincipal(principal, client)
// Protocol negotiation and metadata have their own cap; tools retain their
// stricter policy budget. A single metadata endpoint cannot bypass limits.
const limit = Math.max(10, Math.min(3000, connection.policy.limits.callsPerMinute * 3))
const { rows } = await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'protocol',date_trunc('minute',now()),1) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=mcp_budget_buckets.used+1 WHERE mcp_budget_buckets.used<$2 RETURNING used", [connection.id, limit])
const limit = hasUnlimitedMcpRates(connection.policy) ? null : Math.max(10, Math.min(3000, connection.policy.limits.callsPerMinute * 3))
const { rows } = await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'protocol',date_trunc('minute',now()),1) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=LEAST(mcp_budget_buckets.used::bigint+1,2147483647) WHERE $2::integer IS NULL OR mcp_budget_buckets.used<$2 RETURNING used", [connection.id, limit])
if (!rows.length) {
const { rows: [denied] } = await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'protocol-denied',date_trunc('minute',now()),1) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=LEAST(mcp_budget_buckets.used+1,2147483647) RETURNING used", [connection.id])
if (denied.used === 1) await client.query("INSERT INTO mcp_requests(id,connection_id,actor_id,tool,status,input,error_code) VALUES($1,$2,$3,'protocol:rate-limit','denied','{}','RATE_LIMITED')", [randomUUID(), connection.id, connection.owner_id])
@@ -51,6 +51,7 @@ function fixture(service='routing.community') {
'./routing-profile-authority.js':{routingProfileAuthorityBindingSchema:{parse:value=>value}},
'./routing-community-scoped-request.js':{},'./routing-community-scoped-checkpoint.js':{},'./routing-community-scoped-recovery-source.js':{},
'./security.js':{fingerprint,redact,McpError,decryptSecretExisting:async value=>{decryptCalls++;return value;},privateFingerprinterExisting:async()=>{if(keyUnavailable)throw Error('key unavailable');return mac;}},
'./policy.js':{hasUnlimitedMcpRates:()=>assert.fail('Forward transport verification must not evaluate rate policy')},
'./store.js':{},'./routing-reservation-contract.js':{},'./routing-reservation-transaction.js':{},'./routing-reservation-runtime.js':{}
};
const verifier=load('routing-reservation-store.ts',providers).assertPersistentRoutingForwardTransportCharge;
@@ -18,6 +18,7 @@ import { routingReservationDeadline, transitionRoutingReservation, type RoutingR
import { routingReservationTransaction, type RoutingReservationConnect } from "./routing-reservation-transaction.js"
import { lockRoutingReservationAdmissionSource } from "./routing-reservation-runtime.js"
import type { StoredPlan } from "./store.js"
import { hasUnlimitedMcpRates } from "./policy.js"
const uuid = z.string().uuid(), proof = z.string().regex(/^[a-f0-9]{64}$/), stamp = z.string().datetime()
const principalSchema = z.object({ connectionId: uuid, credentialId: uuid, credentialExpiresAt: stamp }).strict()
@@ -271,7 +272,8 @@ async function reserveWithinOwner(db: PoolClient, operationId: string) {
// Legacy overlap stays charged, including allocations predating audit anchors.
const charges = await readHistoricalChargesWithinOwner(db, value.authority.packet.profileId, connection, createdAt, deadline)
if (charges.totalCharges + 2 > value.profile.maxSwitchesPerHour) throw fail("Insufficient durable profile switch slots")
const budget = await db.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) SELECT $1,'mutations',$2,2 WHERE $3::int>=2 ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=mcp_budget_buckets.used+2 WHERE mcp_budget_buckets.used<=$3::int-2 RETURNING used", [connection.id, budgetBucket, connection.policy.limits.mutationsPerHour])
const limit = hasUnlimitedMcpRates(connection.policy) ? null : connection.policy.limits.mutationsPerHour
const budget = await db.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) SELECT $1,'mutations',$2,2 WHERE $3::int IS NULL OR $3::int>=2 ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=LEAST(mcp_budget_buckets.used::bigint+2,2147483647) WHERE $3::int IS NULL OR mcp_budget_buckets.used<=$3::int-2 RETURNING used", [connection.id, budgetBucket, limit])
if (budget.rowCount !== 1) throw fail("Insufficient connection mutation budget for forward and inverse")
const binding = bindingSchema.parse({ revision: 1, id: randomUUID(), planId: value.row.plan_id, operationId, stepIndex: 0, sourceReceiptId: value.input.receiptId,
inverseReceiptId: randomUUID(), profileId: value.authority.packet.profileId, profileVersion: value.authority.packet.profileVersion, principal: value.principal,
@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto"
import { basename, dirname, join, resolve } from "node:path"
import { readFile, writeFile } from "node:fs/promises"
import type { PoolClient } from "pg"
import { MCP_SERVICE_EXPIRATION } from "@mmapp/contracts/mcp"
/** Actual SQL/crypto numbered-schema acceptance only; no public tool registration,
* native callback, controller tick, reservation refund or fixture DELETE. */
@@ -49,11 +50,12 @@ export async function acceptRoutingReservationSql(options: { runtimeAdmission?:
ids.push(...(await pool.query("INSERT INTO servers(name,host,port,enabled,username,password,use_ssl,verify_ssl) VALUES($1,'127.0.0.1',9,true,'SYNTHETIC','SYNTHETIC',false,true) RETURNING id", ["reservation-synthetic-" + randomUUID()])).rows.map(row => Number(row.id)))
await pool.query("UPDATE mcp_settings SET enabled=true WHERE id=1")
const contextSources = (await createRoutingSourceContext(await readRoutingEndpoints(ids))).expected
const fixture = async (mutations = 10, maxSwitches = 3, autoRecovery = true) => {
const fixture = async (mutations = 10, maxSwitches = 3, autoRecovery = true, unlimitedRates = false) => {
const connectionId = randomUUID(), credentialId = randomUUID(), profileId = randomUUID(), ownerId = "reservation-owner-" + randomUUID()
const now = Date.now(), expiresAt = new Date(now + 600000).toISOString(), generation = await security.accessGeneration()
const permissions = ["mm:network:read", "mm:network:write", "mm:filters:write"]
const policy = mcpConnectionPolicySchema.parse({ id: connectionId, version: 1, status: "active", mode: "approval", permissions, expiresAt,
const policy = mcpConnectionPolicySchema.parse({ id: connectionId, version: 1, status: "active", permissions,
...(unlimitedRates ? { authority: "service", mode: "autonomous", expiresAt: MCP_SERVICE_EXPIRATION, unlimitedRates: true } : { mode: "approval", expiresAt }),
scope: { serverIds: ids, operationIds: ["routing.analyze", "routing.community.switch", "routing.path.verify", "operations.recover"], allowGlobal: false },
limits: { callsPerMinute: 100, mutationsPerHour: mutations, concurrentReads: 4, serversPerPlan: 2, objectsPerPlan: 20 } })
await pool.query("INSERT INTO mcp_connections(id,name,owner_id,owner_permissions,policy,generation,owner_valid_until,owner_claims_issued_at) VALUES($1,'synthetic reservation',$2,$3::jsonb,$4::jsonb,$5,$6,$7)", [connectionId, ownerId, JSON.stringify(permissions), JSON.stringify(policy), generation, expiresAt, new Date(now - 1000)])
@@ -295,6 +297,13 @@ export async function acceptRoutingReservationSql(options: { runtimeAdmission?:
assert.equal(await used(f.connectionId), 2)
names.push("short by one rolling-hour profile slot across source operations")
}
{
const f = await fixture(1, 3, true, true), first = await f.makeSource(), second = await f.makeSource()
assert.equal((await store.reserve(first.operationId)).created, true)
await assert.rejects(store.reserve(second.operationId), /profile switch slots/)
assert.equal(await used(f.connectionId), 2)
names.push("unlimited service connection still obeys the routing profile switch limit")
}
{
const f = await fixture(10, 3), source = await f.makeSource()
await pool.query("UPDATE mcp_routing_profiles SET state=jsonb_build_object('switches',jsonb_build_array(to_char(clock_timestamp() AT TIME ZONE 'UTC','YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'),to_char(clock_timestamp() AT TIME ZONE 'UTC','YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'))) WHERE id=$1", [f.profileId])
+4 -4
View File
@@ -31,7 +31,7 @@ import { readPollRuntimePolicySource, type PollRuntimePolicySource } from "./pol
import { withVerifiedConfigurationChange, assertVerifiedConfigurationAccess } from "../../services/config-mutation-policy.js"
import { beginMcpOperationAdmission, insertMcpOperationAdmission, retireMcpOperationAdmission, withMcpOperationExecutionOrigin, stripMcpOperationExecutionPrivateResult, type McpOperationAdmission } from "./operation-execution-origin.js"
import { createOspfOwnerSourceGuard, verifyOspfOwnerGraph, verifyOspfOwnerGraphAtPhase } from "./ospf-owner-graph.js"
import { evaluateMcpPolicy, hasUnattendedPlanAuthority, operationApprovalRequirement } from "./policy.js"
import { evaluateMcpPolicy, hasUnattendedPlanAuthority, hasUnlimitedMcpRates, operationApprovalRequirement } from "./policy.js"
import { findAction, findActionByOperation } from "./actions.js"
import { refuseExpiredOperationReplay } from "./operation-replay-tombstones.js"
import { accessGeneration, decryptSecret, encryptSecret, fingerprint, privateSecretFingerprint, McpError, redact } from "./security.js"
@@ -138,7 +138,7 @@ async function reserveCall(principal: McpPrincipal, toolName: string, input: Rec
const result = evaluateMcpPolicy(evidence)
await client.query("INSERT INTO mcp_requests(id,connection_id,actor_id,tool,server_ids,status,input,error_code) VALUES($1,$2,$3,$4,$5,$6,$7::jsonb,$8)", [requestId, connection.id, connection.owner_id, toolName, evidence.target.scope === "servers" ? evidence.target.serverIds : [], result.decision === "denied" ? "denied" : "running", JSON.stringify(redact(input)), result.decision === "denied" ? result.reasons[0]?.code : null])
if (result.decision !== "denied") {
await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'calls',date_trunc('minute',now()),1) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=mcp_budget_buckets.used+1", [connection.id])
await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'calls',date_trunc('minute',now()),1) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=LEAST(mcp_budget_buckets.used::bigint+1,2147483647)", [connection.id])
if (action.operation.effect === "read") await client.query("INSERT INTO mcp_read_leases(id,connection_id,expires_at) VALUES($1,$2,now()+interval '2 minutes')", [requestId, connection.id])
await client.query("UPDATE mcp_connections SET last_used_at=now() WHERE id=$1", [connection.id])
}
@@ -461,8 +461,8 @@ async function admitPlan(principal: McpPrincipal, planId: string, idempotencyKey
await assertOriginalMcpTemporaryGrant(client,connection.id,principal.credentialId,originalServiceGrant)
}
const mutationCost = reservedRouting ? 2 : changeMutationCost(evidence) + (evidence.recovery ? 1 : 0)
if (input.usage.mutationsInHour + mutationCost > connection.policy.limits.mutationsPerHour) throw new McpError("BUDGET_EXCEEDED", "Недостаточно бюджета для всех шагов плана", 429)
if (!reservedRouting) await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'mutations',date_trunc('hour',now()),$2) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=mcp_budget_buckets.used+EXCLUDED.used", [connection.id, mutationCost])
if (!hasUnlimitedMcpRates(connection.policy) && input.usage.mutationsInHour + mutationCost > connection.policy.limits.mutationsPerHour) throw new McpError("BUDGET_EXCEEDED", "Недостаточно бюджета для всех шагов плана", 429)
if (!reservedRouting) await client.query("INSERT INTO mcp_budget_buckets(connection_id,kind,bucket,used) VALUES($1,'mutations',date_trunc('hour',now()),$2) ON CONFLICT(connection_id,kind,bucket) DO UPDATE SET used=LEAST(mcp_budget_buckets.used::bigint+EXCLUDED.used,2147483647)", [connection.id, mutationCost])
if (delegated) {
// Execution receipts use the delegating owner's ID. Object protections still require a human decision.
plan.evidence.approvalSource = "connection-policy"
@@ -64,6 +64,7 @@ export async function acceptServerProbeStorageHostSql() {
let raw = ""; for await (const chunk of request) raw += chunk
const body = JSON.parse(raw) as Record<string, unknown>
assert.equal(body.address, "127.0.0.1"); assert.equal(body.count, "1")
assert.equal(Object.hasOwn(body, "src-address"), false)
if (requests === 2) {
response.once("close", secondClosed)
secondValidated()
@@ -35,9 +35,11 @@ export async function acceptWireguardImport(actor: AuthUser) {
for (const hidden of [privateKey, peerOne, peerTwo, generated, content, "NEVER_IMPORT_"]) assert.equal(text.includes(hidden), false, "Public response must omit raw imported/native keys and configuration")
}
const router = createServer((req, res) => {
const path = decodeURIComponent((req.url ?? "").replace(/^\/rest/, ""))
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname)
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
res.setHeader("content-type", "application/json")
if (req.method === "GET") { reads++; if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }; res.end(JSON.stringify(rows[path])); return }
if (req.method === "GET") { reads++; if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }; res.end(JSON.stringify(selectedRows())); return }
if (!["PUT", "PATCH"].includes(req.method ?? "")) { res.statusCode = 400; res.end("{}"); return }
let raw = ""
req.on("data", chunk => { raw += chunk }); req.on("end", () => {
@@ -24,18 +24,23 @@ export async function acceptWireguardInterfaceCreation(actor: AuthUser) {
initial["/interface"] = [{ ".id": "*af", name: "wg-foreign", type: "wg" }]
initial["/ip/address"] = [{ ".id": "*vf", address: "203.0.113.2/24", interface: "ether1", dynamic: "false", disabled: "false" }]
initial["/ipv6/address"] = []
initial["/ip/route"] = Array.from({ length: 12_608 }, (_, index) => ({
".id": `*r${index.toString(16)}`, dynamic: "true", bgp: "true", gateway: "192.0.2.1", "immediate-gw": "192.0.2.1%ether1",
}))
let rows = structuredClone(initial), mode = "normal", reads = 0, commands: string[] = [], counter = 0
let afterWrite: (() => Promise<unknown>) | undefined
const reset = () => { rows = structuredClone(initial); mode = "normal"; commands = []; counter = 0; afterWrite = undefined }
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json")
const path = decodeURIComponent((req.url ?? "").slice(5))
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname)
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
if (req.method === "GET") {
reads++
if (mode === "provider-error") { res.statusCode = 400; res.end('{"message":"NEVER_PROVIDER_SECRET"}'); return }
if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }
rows["/interface/wireguard/peers"][0].rx = String(reads)
res.end(JSON.stringify(rows[path])); return
res.end(JSON.stringify(selectedRows())); return
}
const base = ["/interface/wireguard/peers", "/interface/wireguard", "/ip/address", "/ipv6/address"].find(base => path === base || path.startsWith(base + "/"))
if (!base || !["PUT", "PATCH"].includes(req.method ?? "")) { res.statusCode = 400; res.end("{}"); return }
@@ -26,7 +26,9 @@ export async function acceptWireguardInterfaceDeletion(actor: AuthUser) {
let duringRead: (() => Promise<unknown>) | undefined
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json")
const path = decodeURIComponent((req.url ?? "").slice(5))
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname)
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
if (req.method === "GET") {
gets++
const respond = () => {
@@ -34,7 +36,7 @@ export async function acceptWireguardInterfaceDeletion(actor: AuthUser) {
if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }
// Runtime traffic and DHCP lease clocks must not become configuration drift.
rows["/interface/wireguard/peers"].find(row => row[".id"] === "*pf")!.rx = String(gets)
res.end(JSON.stringify(rows[path]))
res.end(JSON.stringify(selectedRows()))
}
if (duringRead) { const hook = duringRead; duringRead = undefined; void hook().then(respond, () => { res.statusCode = 503; res.end("{}"); }); return }
respond(); return
@@ -89,7 +91,8 @@ export async function acceptWireguardInterfaceDeletion(actor: AuthUser) {
await assert.rejects(prepare(true), (error: { code?: string }) => error.code === "DEPENDENCY_CONFLICT")
assert.equal(commands.length, 0, "Native alias must not acquire cascade permission")
for (const [path, row] of [
["/interface/list/member", { interface: "wg-cascade", list: "LAN" }], ["/interface/vxlan", { interface: "wg-cascade" }], ["/ip/route", { gateway: "198.19.244.2%wg-cascade" }],
["/interface/list/member", { interface: "wg-cascade", list: "LAN" }], ["/interface/vxlan", { interface: "wg-cascade" }],
["/ip/route", { gateway: "wg-cascade" }], ["/ip/route", { dynamic: "true", "immediate-gw": "198.19.244.2%wg-cascade" }],
["/routing/filter/rule", { rule: 'set gw "wg-cascade";' }], ["/ip/firewall/filter", { "in-interface": "wg-cascade" }], ["/ip/dhcp-server", { interface: "wg-cascade" }],
["/routing/filter/rule", { rule: 'set gw "wg\\2dcascade";' }],
["/ip/ipsec/peer", { "local-address": "198.19.244.1" }], ["/routing/bgp/session", { dynamic: "true", "local.address": "2001:0db8:0244:0:0:0:0:1" }],
@@ -31,13 +31,15 @@ export async function acceptWireguardInterfaceUpdate(actor: AuthUser) {
const reset = () => { rows = structuredClone(initial); commands = []; mode = "normal"; afterWrite = undefined }
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json")
const path = decodeURIComponent((req.url ?? "").slice(5))
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname)
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
if (req.method === "GET") {
reads++
if (mode === "provider-error") { res.statusCode = 500; res.end('{"message":"NEVER_PROVIDER_SECRET"}'); return }
if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }
rows["/interface/wireguard/peers"][0].rx = String(reads)
res.end(JSON.stringify(rows[path])); return
res.end(JSON.stringify(selectedRows())); return
}
const base = ["/interface/wireguard", "/ip/address", "/ipv6/address"].find(base => path === base || path.startsWith(base + "/"))
if (!base || !["PUT", "PATCH", "DELETE"].includes(req.method ?? "")) { res.statusCode = 400; res.end("{}"); return }
@@ -33,13 +33,15 @@ export async function acceptWireguardPeerCreation(actor: AuthUser) {
const reset = () => { rows = structuredClone(initial); mode = "normal"; commands = []; afterWrite = undefined }
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json")
const path = decodeURIComponent((req.url ?? "").slice(5)), base = "/interface/wireguard/peers"
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname), base = "/interface/wireguard/peers"
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
if (req.method === "GET") {
reads++
if (mode === "provider-error" || mode === "dependency-error" && path === "/ip/address") { res.statusCode = 400; res.end('{"message":"NEVER_PROVIDER_SECRET"}'); return }
if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }
rows[base][0].rx = String(reads)
res.end(JSON.stringify(rows[path])); return
res.end(JSON.stringify(selectedRows())); return
}
if (!["PUT", "PATCH"].includes(req.method ?? "") || !(path === base || path === base + "/*c")) { res.statusCode = 400; res.end("{}"); return }
let raw = ""
@@ -32,8 +32,10 @@ export async function acceptWireguardRevisionRestore(actor:AuthUser){
const reset=()=>{rows=structuredClone(initial);commands=[];mode="normal";afterWrite=undefined}
const router=createServer(async(req,res)=>{
res.setHeader("content-type","application/json")
const path=decodeURIComponent((req.url??"").slice(5))
if(req.method==="GET"){reads++;if(!Object.hasOwn(rows,path)){res.statusCode=404;res.end("{}");return}res.end(JSON.stringify(rows[path]));return}
const [pathname, query] = (req.url ?? "").slice(5).split("?")
const path = decodeURIComponent(pathname)
const selectedRows = () => rows[path].filter(row => !query || (row.dynamic === "true") === query.startsWith("dynamic=true"))
if(req.method==="GET"){reads++;if(!Object.hasOwn(rows,path)){res.statusCode=404;res.end("{}");return}res.end(JSON.stringify(selectedRows()));return}
let raw="";for await(const chunk of req)raw+=chunk
const body=raw?JSON.parse(raw)as Record<string,string>:{},base=["/interface/wireguard/peers","/interface/wireguard","/ip/address","/ipv6/address"].find(p=>path===p||path.startsWith(p+"/"))
if(!base||!["PUT","PATCH","DELETE"].includes(req.method??"")){res.statusCode=400;res.end("{}");return}
+2 -8
View File
@@ -25,12 +25,10 @@ import { getFlowHostStatus, reconcileFlowHost, withFlowConfigurationLock } from
import {
ensureHostKeys,
getTrafficFlowSettingsRow,
toTrafficFlowSettingsDto,
} from "../services/traffic-flow-settings.js"
import {
getFlowListenerState,
drainExistingTrafficFlowWriters,
getFlowRuntimeCounters,
readTrafficFlowSettingsStatus,
purgeTrafficFlowStore,
listFlowTalkers,
} from "../services/traffic-flow-ingest.js"
@@ -168,11 +166,7 @@ const trafficFlowRoutes: FastifyPluginAsyncZod = async (app) => {
reconcile: () => withFlowConfigurationLock(reconcileFlowHost),
}))
await app.register(createTrafficFlowSettingsRoutes({
read: async () => {
const settings = await toTrafficFlowSettingsDto(getFlowListenerState())
const { packetsReceived, lastExporterIp, lastError, lastDatagramAt,dataQuality } = await getFlowRuntimeCounters()
return { ...settings, packetsReceived, lastExporterIp, lastError, lastDatagramAt,dataQuality }
},
read: readTrafficFlowSettingsStatus,
updateWithListener: updateTrafficFlowSettingsWithListener,
ensureKeys: ensureHostKeys,
hasPrivateKey: async () => Boolean((await getTrafficFlowSettingsRow()).hostPrivateKey),
+11 -3
View File
@@ -17,7 +17,8 @@ import { readTrafficLiveSample, TrafficLiveSourceChanged } from "../services/tra
import { MikrotikClient, MikrotikError } from "../services/mikrotik.js"
import { getEnabledServerById } from "../services/wireguard-live.js"
import { readTrafficCollectionContext } from "../services/traffic-collection-state.js"
import { readServerTrafficHistory, readServerTrafficInterfaces } from "../services/traffic-history-read.js"
import { readServerTrafficHistory, readServerTrafficHistoryWithSeries, readServerTrafficInterfaces } from "../services/traffic-history-read.js"
import { mergeBuiltTraffic } from "../services/traffic-rate.js"
import {
buildBoundInterfaceTraffic,
buildUserTrafficList,
@@ -93,8 +94,15 @@ const trafficRoutes: FastifyPluginAsyncZod = async (app) => {
const rangeEndMs = Date.now(), rangeStartMs = rangeEndMs - rangeToMinutes(q.range) * 60000
const allServers = await db.select().from(servers).where(eq(servers.enabled, true))
const context = await readTrafficCollectionContext(allServers.map(server => server.id))
const data = await Promise.all(allServers.map(server => readServerTrafficHistory(server, rangeStartMs, rangeEndMs, undefined, {}, context)))
return reply.send({ servers: data })
const data = await Promise.all(allServers.map(server => readServerTrafficHistoryWithSeries(server, rangeStartMs, rangeEndMs, undefined, {}, context)))
const aggregate = mergeBuiltTraffic(data.map(item => item.series))
return reply.send({
servers: data.map(item => item.history),
peaks: {
rx: aggregate.observations?.rxPeak ? aggregate.rxPeak : null,
tx: aggregate.observations?.txPeak ? aggregate.txPeak : null,
},
})
})
app.get("/traffic/servers/:id/live", async (req, reply) => {
const p = req.params as { id?: string | number }
+1 -9
View File
@@ -134,15 +134,7 @@ export function isReleasableIpsecCryptoRow(row: { name?: string; comment?: strin
return isIpsecManagedComment(row.comment) || (!row.comment?.trim() && row.name === IPSEC_COMMON_NAME)
}
export const IPSEC_CA_COMMON_NAME = "MikrotikManager IPsec CA"
/** RouterOS native id: `*<hex>` for configuration rows; RouterOS 7.24 `/file` rows use case-sensitive `**<base62>` ids
* whose length follows the file path (stand probe 2026-11-21). */
export function isRouterOsNativeId(value: unknown): value is string {
return typeof value === "string" && value.length <= 256 && /^\*\*?[a-z0-9]+$/i.test(value)
}
/** Duplicate key: hex ids compare case-insensitively without leading zeros; `**` file ids compare exactly. */
export function routerOsIdKey(value: string): string {
return value.startsWith("**") ? value : value.toLowerCase().replace(/^\*0+(?=[a-z0-9])/, "*")
}
export { isRouterOsNativeId, routerOsIdKey } from "./routeros-native-paths.js"
/** RouterOS 7.24 omits a peer `address` equal to the any-address from REST rows (stand probe 2026-11-21). */
export const IPSEC_ANY_PEER_ADDRESS = "0.0.0.0/0"
/** RouterOS 7.24 `/certificate` has no `comment` (PUT refuses it), so product certificates are recognised by their
@@ -96,12 +96,14 @@ export function normalizeIpsecExistingExportPassphrase(raw: string | undefined,
}
export function projectIpsecExistingCertificateExport(state: IpsecExistingCertificateExportState, filename: string, after: IpsecExistingCertificateExportState) {
validateIpsecExistingCertificateExportState(after)
const old = state.catalogs["/file"], candidates = after.catalogs["/file"].filter(row => row.name === filename && !old.some(prior => idKey(prior[".id"]) === idKey(row[".id"])))
const old = state.catalogs["/file"], files = after.catalogs["/file"]
const candidates = files.filter(row => row.name === filename && !old.some(prior => idKey(prior[".id"]) === idKey(row[".id"])))
if (candidates.length !== 1) throw fail("Не подтверждён единственный receipt-owned файл экспорта", "VERIFICATION_FAILED")
const row = candidates[0], size = Number(row.size)
if (!Number.isSafeInteger(size) || size <= 0 || size > MAX_OWNED_FILE_BYTES) throw fail("Размер приватного файла вне предела точного /file/get (61438 байт)", "VERIFICATION_FAILED")
const projected = structuredClone(state)
projected.catalogs["/file"].push(structuredClone(row))
// The new file can appear anywhere. The proof still checks the relative order and contents of every pre-existing row.
projected.catalogs["/file"].splice(files.indexOf(row), 0, structuredClone(row))
return { projected, file: { id: row[".id"], name: filename, size } }
}
export function projectIpsecExistingCertificateCleanup(state: IpsecExistingCertificateExportState, file: { id: string; name: string; size: number }) {
@@ -69,12 +69,13 @@ assert.throws(() => project(withCert, cert.commands[1], { observedRow: signed })
const signedState = project(withCert, cert.commands[1], { observedRow: signed, ownedCertificateIds: new Set(["*new"]) })
assert.deepEqual(signedState.catalogs["/certificate"].slice(0, 2), state.catalogs["/certificate"])
assert.throws(() => project(withCert, cert.commands[1], { observedRow: { ...signed, opaque: "changed" }, ownedCertificateIds: new Set(["*new"]) }), /исходные поля/)
const withFile = project(signedState, cert.commands[2], { assignedId: "*export", observedRow: { ".id": "*export", name: "mm-ipsec-fixture.p12", size: "256", type: "file" } })
const withFile = project(signedState, cert.commands[2], { assignedId: "*export", observedRow: { ".id": "*export", name: "mm-ipsec-fixture.p12", size: "256", type: "file" }, exportIndex: 0 })
assert.equal(withFile.catalogs["/file"][0][".id"], "*export")
assert.deepEqual(project(withFile, cert.commands[3], { assignedId: "*export" }).catalogs["/file"], state.catalogs["/file"])
assert.throws(() => project(state, psk.commands[0], { assignedId: "*l", observedRow: { ".id": "*l", ...psk.commands[0].fields } }), /ACK/)
assert.throws(() => project(state, psk.commands[0], { assignedId: "*new", observedRow: { ".id": "*new", ...psk.commands[0].fields, "remote-id": "key-id:mallory" } }), /Поля/)
const staticCert = plan(state, server, { serverId: 1, name: "Alice", staticIp: "192.0.2.7" }, "mm-ipsec-fixture")
assert.deepEqual(staticCert.commands.map(row => row.action), ["create", "create", "sign", "create", "export", "cleanup"])
assert.equal(staticCert.commands[3].fields["remote-certificate"], cert.certName)
assert.equal(staticCert.commands[3].fields["match-by"], "certificate")
assert.deepEqual(staticCert.commands.map(row => row.path), ["/certificate", "/certificate/sign", "/certificate/export-certificate", "/file", "/ip/ipsec/mode-config", "/ip/ipsec/identity"])
assert.equal(staticCert.commands[5].fields["remote-certificate"], cert.certName)
assert.equal(staticCert.commands[5].fields["match-by"], "certificate")
console.log("ipsec-user-create-model: full PSK/certificate/static/export plans and raw conservation passed")
@@ -45,6 +45,7 @@ export function planIpsecUserCreate(state: IpsecUserCreateState, server: ServerR
if (mapClients(live).some(row => row.name === body.name.trim()) || (certName && live.certs.some(row => row.name === certName))) throw fail("Клиент уже существует")
if (body.authMethod === "pre-shared-key" && live.identities.some(row => row.peer === peer.name && row["auth-method"] === "pre-shared-key" && row["remote-id"] === normalizeIpsecRemoteId(body.remoteId ?? body.name))) throw fail("Remote ID уже используется клиентом этого peer")
const commands: IpsecUserCreateCommand[] = [], seeds: Array<{ path: string; row: Row }> = []
let staticModeConfig: IpsecUserCreateCommand | undefined
const seed = (path: string, row: unknown) => { if (row) seeds.push({ path, row: row as Row }) }
seed("/ip/ipsec/peer", peer); seed("/ip/ipsec/mode-config", sharedMc)
const sharedIdentity = selectSharedIke2Identity(live.identities, names)
@@ -58,18 +59,18 @@ export function planIpsecUserCreate(state: IpsecUserCreateState, server: ServerR
if (existing && (!isManagedIpsecModeConfig(existing) || c["/ip/ipsec/identity"].some(row => row["mode-config"] === existing.name || row["mode-config"]?.toLowerCase() === existing[".id"].toLowerCase()))) throw fail("Персональный mode-config уже используется другим клиентом; адрес чужого или общего объекта изменять нельзя")
if (existing) for (const flag of ["dynamic", "builtin", "default"]) if (existing[flag] !== undefined && observedBoolean(existing[flag]) !== false) throw fail("Системный mode-config нельзя изменять", "PROTECTED_OBJECT")
seed("/ip/ipsec/mode-config", existing)
commands.push({ action: existing ? "update" : "create", path: "/ip/ipsec/mode-config", ...(existing ? { id: existing[".id"] } : {}), fields: { name: modeConfig, address: body.staticIp.trim(), responder: "yes", "address-prefix-length": "32" } })
staticModeConfig = { action: existing ? "update" : "create", path: "/ip/ipsec/mode-config", ...(existing ? { id: existing[".id"] } : {}), fields: { name: modeConfig, address: body.staticIp.trim(), responder: "yes", "address-prefix-length": "32" } }
}
if (certName) {
seed("/certificate", serverCert); seed("/certificate", c["/certificate"].find(row => row.name === caName))
commands.push({ action: "create", path: "/certificate", fields: { name: certName, "common-name": body.name.trim(), "key-size": "2048", "key-usage": "digital-signature,key-encipherment,tls-client", "days-valid": String(body.daysValid ?? 1825) } })
commands.push({ action: "sign", path: "/certificate/sign", name: certName, fields: { ca: caName! } })
}
if (body.authMethod !== "certificate" || body.staticIp || !sharedIdentity) commands.push({ action: "create", path: "/ip/ipsec/identity", fields: identityRosBody({ peerName: peer.name, modeConfig, comment: certName && !body.staticIp ? ipsecManagedComment("IKEv2 listener") : ipsecUserComment(body.name), authMethod: body.authMethod, certificate: certName ? serverCert!.name : undefined, remoteCertificate: body.staticIp ? certName : undefined, secret: body.psk, remoteId: body.authMethod === "pre-shared-key" ? body.remoteId ?? body.name : undefined, policyTemplateGroup: sharedIdentity?.["policy-template-group"] }) })
if (certName) {
if (c["/file"].some(row => row.name === `${exportPrefix}.p12`)) throw fail("Имя файла экспорта занято")
commands.push({ action: "export", path: "/certificate/export-certificate", name: `${exportPrefix}.p12`, certificate: certName, fields: { type: "pkcs12", "file-name": exportPrefix, "export-passphrase": body.passphrase ?? "" } }, { action: "cleanup", path: "/file", name: `${exportPrefix}.p12`, fields: {} })
}
// Leave the client-specific IPsec settings untouched if the private export fails.
if (staticModeConfig) commands.push(staticModeConfig)
if (body.authMethod !== "certificate" || body.staticIp || !sharedIdentity) commands.push({ action: "create", path: "/ip/ipsec/identity", fields: identityRosBody({ peerName: peer.name, modeConfig, comment: certName && !body.staticIp ? ipsecManagedComment("IKEv2 listener") : ipsecUserComment(body.name), authMethod: body.authMethod, certificate: certName ? serverCert!.name : undefined, remoteCertificate: body.staticIp ? certName : undefined, secret: body.psk, remoteId: body.authMethod === "pre-shared-key" ? body.remoteId ?? body.name : undefined, policyTemplateGroup: sharedIdentity?.["policy-template-group"] }) })
const kinds: Record<string, string> = { "/ip/ipsec/peer": "ipsec_peer", "/ip/ipsec/identity": "ipsec_identity", "/ip/ipsec/mode-config": "ipsec_mode_config", "/ip/pool": "ip_pool", "/certificate": "certificate", "/ip/ipsec/profile": "ipsec_profile", "/ip/ipsec/proposal": "ipsec_proposal", "/ip/ipsec/policy/group": "ipsec_policy_group", "/ip/ipsec/policy": "ipsec_policy" }
const refs: Record<string, string> = { peer: "/ip/ipsec/peer", "mode-config": "/ip/ipsec/mode-config", "address-pool": "/ip/pool", certificate: "/certificate", "remote-certificate": "/certificate", ca: "/certificate", profile: "/ip/ipsec/profile", proposal: "/ip/ipsec/proposal", "policy-template-group": "/ip/ipsec/policy/group" }
for (const command of commands) for (const [field, refPath] of Object.entries(refs)) {
@@ -104,7 +105,7 @@ export function planIpsecUserCreate(state: IpsecUserCreateState, server: ServerR
/** Native defaults are admitted solely for the ACK-owned newly created row.
* Signing can change only documented generated fields of that new certificate. */
export function projectIpsecUserCreate(state: IpsecUserCreateState, command: IpsecUserCreateCommand, options: { assignedId?: string; observedRow?: Row; ownedCertificateIds?: Set<string> } = {}) {
export function projectIpsecUserCreate(state: IpsecUserCreateState, command: IpsecUserCreateCommand, options: { assignedId?: string; observedRow?: Row; ownedCertificateIds?: Set<string>; exportIndex?: number } = {}) {
const next = structuredClone(state)
const path = command.action === "sign" ? "/certificate" : command.action === "export" || command.action === "cleanup" ? "/file" : command.path
const rows = next.catalogs[path]
@@ -126,11 +127,17 @@ export function projectIpsecUserCreate(state: IpsecUserCreateState, command: Ips
rows[rows.indexOf(row)] = structuredClone(observed)
} else {
const row = options.observedRow, id = options.assignedId
if (!row || !exactId(id) || row[".id"] !== id || rows.some(item => item[".id"].toLowerCase() === id.toLowerCase()) || Object.values(row).some(value => typeof value !== "string")) throw fail("Не подтверждён ACK нового объекта", "VERIFICATION_FAILED")
if (!row || !exactId(id) || row[".id"] !== id || rows.some(item => routerOsIdKey(item[".id"]) === routerOsIdKey(id)) || Object.values(row).some(value => typeof value !== "string")) throw fail("Не подтверждён ACK нового объекта", "VERIFICATION_FAILED")
for (const flag of ["dynamic", "builtin", "default"]) if (row[flag] !== undefined && observedBoolean(row[flag]) !== false) throw fail("Создан системный объект", "VERIFICATION_FAILED")
const fields = command.action === "export" ? { name: command.name! } : command.fields
for (const [key, value] of Object.entries(fields)) if (row[key] !== value && !(["disabled", "responder"].includes(key) && observedBoolean(row[key]) !== null && observedBoolean(row[key]) === observedBoolean(value))) throw fail("Поля нового объекта не подтверждены", "VERIFICATION_FAILED")
rows.push(structuredClone(row))
if (command.action === "export") {
const index = options.exportIndex
if (index === undefined || !Number.isInteger(index) || index < 0 || index > rows.length) throw fail("Не подтверждена позиция нового файла экспорта", "VERIFICATION_FAILED")
rows.splice(index, 0, structuredClone(row))
} else {
rows.push(structuredClone(row))
}
}
return next
}
+24 -10
View File
@@ -2,7 +2,7 @@ import { randomBytes, randomUUID } from "node:crypto"
import type { IpsecCertBundle } from "@mmapp/contracts/ipsec"
import { getServerRowById, type ServerRow } from "../modules/servers/repository/servers-repository.js"
import { McpError, fingerprint, privateFingerprinter } from "../modules/mcp/security.js"
import { MAX_OWNED_FILE_BYTES, MikrotikClient } from "./mikrotik.js"
import { MAX_OWNED_FILE_BYTES, MikrotikClient, MikrotikError } from "./mikrotik.js"
import { readIpsecPeerDeleteState, ipsecPeerDeleteRows } from "./ipsec-peer-delete.js"
import { ipsecUserUpdateValue } from "./ipsec-user-update.js"
import { sameWireguardEndpoint } from "./wireguard-source.js"
@@ -37,6 +37,15 @@ export async function createIpsecUserGuarded(server: ServerRow, raw: unknown, ex
let completedCommands = 0, confirmedWrites = 0, bundle: IpsecCertBundle | undefined, artifactReceipt: Record<string, unknown> | undefined
const stopped = (code: "MUTATION_OUTCOME_UNKNOWN" | "VERIFICATION_FAILED", message: string) => new IpsecUserCreateExecutionError(code, message, confirmedWrites, completedCommands, plan.commands.length)
for (const command of plan.commands) {
const stage = {
create: command.path === "/certificate" ? "создание сертификата" : command.path === "/ip/ipsec/mode-config" ? "назначение персонального IP" : "создание привязки IKEv2",
update: "обновление персонального IP",
sign: "подпись сертификата",
export: "экспорт .p12",
cleanup: "удаление временного .p12",
}[command.action]
const stoppedAtStage = (code: "MUTATION_OUTCOME_UNKNOWN" | "VERIFICATION_FAILED", detail: string) =>
stopped(code, `Создание IKEv2 остановлено на этапе «${stage}». ${detail}`)
let dispatched = false, response: unknown, assignedId: string | undefined
const fence = async () => { const fresh = await readIpsecUserCreateState(server, source); if (fresh.proof !== state.proof) throw new McpError("STATE_CONFLICT", "IPsec изменился после durable intent; команда не отправлена", 409); await source(); dispatched = true }
try {
@@ -57,7 +66,8 @@ export async function createIpsecUserGuarded(server: ServerRow, raw: unknown, ex
confirmedWrites++
} catch (error) {
if (!dispatched && !completedCommands && error instanceof McpError) throw error
throw stopped(dispatched ? "MUTATION_OUTCOME_UNKNOWN" : "VERIFICATION_FAILED", "Создание IPsec остановлено; повтор native-команды запрещён, требуется сверка")
const detail = !dispatched ? "Команда не отправлена." : error instanceof MikrotikError ? `RouterOS вернул HTTP ${error.statusCode}.` : "Ответ RouterOS не подтверждён."
throw stoppedAtStage(dispatched ? "MUTATION_OUTCOME_UNKNOWN" : "VERIFICATION_FAILED", `${detail} Перед повтором требуется сверка.`)
}
let after: IpsecUserCreateState
try {
@@ -67,23 +77,27 @@ export async function createIpsecUserGuarded(server: ServerRow, raw: unknown, ex
const deadline = Date.now() + 90000
while (!after.catalogs["/certificate"].find(row => row.name === command.name)?.["invalid-after"] && Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 1000)); after = await readIpsecUserCreateState(server, source) }
}
} catch { throw stopped("MUTATION_OUTCOME_UNKNOWN", "Команда отправлена, но read-back недоступен; повтор запрещён") }
} catch { throw stoppedAtStage("MUTATION_OUTCOME_UNKNOWN", "Команда отправлена. Не удалось перечитать состояние RouterOS.") }
let exportIndex: number | undefined
if (command.action === "export") {
const files = after.catalogs["/file"]
const candidates = files.filter(row => row.name === command.name && !state.catalogs["/file"].some(old => old[".id"] === row[".id"]))
if (candidates.length !== 1) throw stoppedAtStage("VERIFICATION_FAILED", "В списке RouterOS не найден единственный новый файл с ожидаемым именем.")
assignedId = candidates[0][".id"]
exportIndex = files.indexOf(candidates[0])
}
try {
const path = command.action === "sign" ? "/certificate" : command.action === "export" ? "/file" : command.path
if (command.action === "create") {
const ack = response as Record<string, unknown> | null
if (typeof ack?.[".id"] !== "string") throw Error("missing create ACK")
assignedId = ack[".id"]
} else if (command.action === "export") {
const candidates = after.catalogs["/file"].filter(row => row.name === command.name && !state.catalogs["/file"].some(old => old[".id"] === row[".id"]))
if (candidates.length !== 1) throw Error("missing unique export file")
assignedId = candidates[0][".id"]
}
const observedRow = after.catalogs[path].find(row => command.action === "sign" ? row.name === command.name : row[".id"] === assignedId)
const projected = projectIpsecUserCreate(state, command, { assignedId, observedRow, ownedCertificateIds })
const projected = projectIpsecUserCreate(state, command, { assignedId, observedRow, ownedCertificateIds, exportIndex })
if (await ipsecUserCreateProof(projected) !== after.proof) throw Error("configuration mismatch")
if (command.action === "create" && command.path === "/certificate") ownedCertificateIds.add(assignedId!)
} catch { throw stopped("VERIFICATION_FAILED", "Не подтверждены команда и сохранность полного состояния IPsec; повтор запрещён") }
} catch { throw stoppedAtStage("VERIFICATION_FAILED", "Проверка результата команды и состояния IPsec не пройдена.") }
state = after; completedCommands++
try {
await source(); await options.checkpoint?.({ receiptId, commandCount: plan.commands.length, completedCommands, afterProof: state.proof })
@@ -100,7 +114,7 @@ export async function createIpsecUserGuarded(server: ServerRow, raw: unknown, ex
bundle = { user: body.name, serverEndpoint: plan.serverEndpoint, filename: file.name, contentB64: p12B64, mime: "application/x-pkcs12", passphrase, sswanFilename: `${plan.certName}.sswan`, sswanContent: buildSswanConfig({ name: `IKEv2 ${plan.serverEndpoint}`, serverEndpoint: plan.serverEndpoint, serverId: plan.serverEndpoint, p12B64 }), instructions: buildClientInstructions({ userName: body.name, serverEndpoint: plan.serverEndpoint, p12Filename: file.name, passphrase, dns: plan.dns }) }
} finally { content.fill(0) }
}
} catch { throw stopped("MUTATION_OUTCOME_UNKNOWN", "Команда проверена, но checkpoint или приватный артефакт не сохранён; повтор запрещён") }
} catch { throw stoppedAtStage("MUTATION_OUTCOME_UNKNOWN", "Команда подтверждена. Не удалось прочитать приватный файл или сохранить квитанцию.") }
}
const reader = { get: async (path: string) => { await source(); if (!Object.hasOwn(state.catalogs, path)) throw new McpError("STATE_UNAVAILABLE", "Неизвестный каталог истории IPsec", 502); return structuredClone(state.catalogs[path]) } } as unknown as MikrotikClient
let historyRecorded = false
@@ -2,6 +2,7 @@ import assert from "node:assert/strict"
import { readFileSync } from "node:fs"
import test from "node:test"
import ts from "typescript"
import { isRouterOsNativeId, routerOsIdKey } from "./routeros-native-paths.js"
// Execute the actual method with inert I/O and retained buffer references, so
// cleanup is observable without intercepting global Buffer methods or networking.
@@ -10,7 +11,7 @@ const begin = source.indexOf(" async downloadOwnedFile(")
const end = source.indexOf(" /** Native text exports", begin)
assert.ok(begin > 0 && end > begin)
const script = ts.transpileModule(`
const {rosRawRequest,extractRosContentsField,MAX_OWNED_FILE_BYTES,MikrotikError}=deps;
const {rosRawRequest,extractRosContentsField,MAX_OWNED_FILE_BYTES,MikrotikError,isRouterOsNativeId,routerOsIdKey}=deps;
class Reader { params={}; get=deps.get; ${source.slice(begin, end)} }
return new Reader();
`, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.None } }).outputText
@@ -24,6 +25,8 @@ for (const mode of ["success", "raw-revoked", "decode-error", "wrong-size", "met
const reader = new Function("deps", script)({
MAX_OWNED_FILE_BYTES: 61438,
MikrotikError: class extends Error {},
isRouterOsNativeId,
routerOsIdKey,
get: async () => [{ ".id": "*owned", name: "owned.p12", size: Buffer.byteLength(secret), revision: mode === "metadata-drift" && ++metadataCalls > 1 ? "changed" : "initial" }],
rosRawRequest: async () => { reads++; return raw },
extractRosContentsField: (value: Buffer) => { assert.equal(value, raw); if (mode === "decode-error") throw Error(secret); return decoded },
@@ -4,11 +4,20 @@ import { setTimeout as delay } from "node:timers/promises"
import { MAX_OWNED_FILE_BYTES, MikrotikClient } from "./mikrotik.js"
const content = "synthetic-private-file-bytes", target = { id: "*owned", name: "owned.p12", size: Buffer.byteLength(content) }
const currentTarget = { ...target, id: "**Qo24Mn6Ay8FA4" }
let mode = "normal", allowed = true, requests: string[] = [], bodies: unknown[] = [], metadataCalls = 0, closed = false, sent = 0, controller: AbortController | undefined
const router = createServer(async (req, res) => {
const path = req.url ?? ""; requests.push(path); res.setHeader("content-type", "application/json")
if (req.method === "GET") {
metadataCalls++
if (mode.startsWith("current-id")) {
const id = mode === "current-id-replaced" && metadataCalls > 1 ? currentTarget.id.toLowerCase() : currentTarget.id
res.end(JSON.stringify([
{ ".id": id, name: target.name, size: String(target.size) },
{ ".id": currentTarget.id.toUpperCase(), name: "other.p12", size: String(target.size) },
]))
return
}
const id = mode === "replace-before" || ["replace-after", "compat-replace"].includes(mode) && metadataCalls > 1 ? "*replacement" : target.id
res.end(JSON.stringify([{ ".id": id, name: target.name, size: String(target.size), opaque: "stable" }])); return
}
@@ -39,6 +48,14 @@ try {
assert.equal((await client.downloadOwnedFile(target, { authorize })).toString(), content)
assert.deepEqual(requests, ["/rest/file", "/rest/file/get", "/rest/file"])
assert.deepEqual(bodies, [{ ".id": target.id, "value-name": "contents" }])
for (const mode of ["current-id", "current-id-replaced"]) {
reset(mode)
const request = client.downloadOwnedFile(currentTarget, { authorize })
if (mode === "current-id") assert.equal((await request).toString(), content)
else await assert.rejects(request, /ID\/name\/size/)
assert.deepEqual(requests, ["/rest/file", "/rest/file/get", "/rest/file"])
assert.deepEqual(bodies, [{ ".id": currentTarget.id, "value-name": "contents" }])
}
for (const compatibility of ["compat-400", "compat-404"]) {
reset(compatibility)
assert.equal((await client.downloadOwnedFile(target, { authorize })).toString(), content)
+4 -2
View File
@@ -6,6 +6,7 @@ import type { BandwidthNativeRequestBinder } from "./bandwidth-native-dispatch.j
import { withConfigMutationLock, withApplicationMutationLock } from "./config-mutation-lock.js"
import { executeGuardedConfigurationWrite } from "./config-mutation-policy.js"
import { exportRouterConfiguration } from "./router-config-export.js"
import { isRouterOsNativeId, routerOsIdKey } from "./routeros-native-paths.js"
import type { Server } from "../db/schema.js"
import { parseRosDataSizeBytes } from "./ros-metric-parse.js"
import { readOspfTemplateFlags } from "./ospf-template-flags.js"
@@ -1168,7 +1169,8 @@ export class MikrotikClient {
* unsupported value-name parameter permits the older .proplist spelling.
* Metadata and grants are checked around every request; never retarget by name. */
async downloadOwnedFile(target: { id: string; name: string; size: number }, control: { authorize: () => Promise<unknown>; signal?: AbortSignal; timeoutMs?: number }): Promise<Buffer> {
if (!/^\*[a-z0-9]+$/i.test(target.id) || !target.name || /[\x00-\x1f\x7f]/.test(target.name) || !Number.isSafeInteger(target.size) || target.size <= 0 || target.size > MAX_OWNED_FILE_BYTES) throw new Error("Private export must have an exact ID/name and size between 1 and 61438 bytes")
if (!isRouterOsNativeId(target.id) || !target.name || /[\x00-\x1f\x7f]/.test(target.name) || !Number.isSafeInteger(target.size) || target.size <= 0 || target.size > MAX_OWNED_FILE_BYTES) throw new Error("Private export must have an exact ID/name and size between 1 and 61438 bytes")
const idKey = routerOsIdKey(target.id)
const duration = control.timeoutMs ?? 30000
if (!Number.isSafeInteger(duration) || duration <= 0 || duration > 45000) throw new Error("Invalid private export deadline")
const deadline = Date.now() + duration, timerSignal = AbortSignal.timeout(duration)
@@ -1186,7 +1188,7 @@ export class MikrotikClient {
const rows = await this.get<unknown>("/file", remaining(), signal, 1048576)
await authorize()
if (!Array.isArray(rows) || rows.length > 2000) throw new Error("Private export metadata unavailable")
const matches = rows.filter(row => row && typeof row === "object" && (row[".id"]?.toLowerCase() === target.id.toLowerCase() || row.name === target.name))
const matches = rows.filter(row => row && typeof row === "object" && ((isRouterOsNativeId(row[".id"]) && routerOsIdKey(row[".id"]) === idKey) || row.name === target.name))
if (matches.length !== 1 || matches[0][".id"] !== target.id || matches[0].name !== target.name || Number(matches[0].size) !== target.size) throw new Error("Private export ID/name/size changed")
return JSON.stringify(matches[0])
}
+22 -1
View File
@@ -1,5 +1,5 @@
import assert from "node:assert/strict"
import { readOspfRouteProof } from "./ospf-route-proof.js"
import { readOspfRouteAbsence, readOspfRouteProof } from "./ospf-route-proof.js"
import { chrFixtureVrf } from "../modules/mcp/chr-fixture-context.js"
const selection = { prefix: "198.19.1.2/32", table: "local-vrf", interface: "owned-gre" }
@@ -10,6 +10,27 @@ const client = { get: async () => rows, post: async (_path: string, body: Record
const proof = await readOspfRouteProof(client, selection)
assert.equal(proof.metric, 60); assert.equal(JSON.stringify(proof).includes("NEVER_"), false)
const original = structuredClone(rows)
const largeRib = Array.from({ length: 12_608 }, (_, index) => ({
".id": `*r${index.toString(16)}`, "dst-address": `10.${index >> 8}.${index & 255}.0/24`, "routing-table": selection.table,
}))
const exactSelection = { ...selection, table: "test & vrf", interface: "wg test" }
const largeTableClient = {
get: async (path: string) => {
const url = new URL(path, "http://fixture.invalid")
if (url.pathname === "/routing/table") return [{ ".id": "*t", name: exactSelection.table }]
assert.equal(url.pathname, "/routing/route")
assert.equal(url.searchParams.get("routing-table"), exactSelection.table)
const prefix = url.searchParams.get("dst-address")
assert(prefix)
return [...largeRib, { ...original[0], "routing-table": exactSelection.table, "immediate-gw": exactSelection.interface }]
.filter(row => row["routing-table"] === exactSelection.table && row["dst-address"] === prefix)
},
post: async () => { throw new Error("unexpected getter") },
} as unknown as Parameters<typeof readOspfRouteProof>[0]
assert.equal((await readOspfRouteProof(largeTableClient, exactSelection)).interface, "wg test")
await assert.rejects(readOspfRouteProof(largeTableClient, { ...exactSelection, interface: "wg" }), /selected interface/)
await assert.rejects(readOspfRouteAbsence(largeTableClient, exactSelection, async () => {}), /matching route/)
assert.equal((await readOspfRouteAbsence(largeTableClient, { ...exactSelection, prefix: "198.19.1.3/32" }, async () => {})).absenceVerified, true)
rows = [{ ...original[0], ospf: "", active: "", "ospf.metric": "" }]
getters = []; assert.equal((await readOspfRouteProof(client, selection)).metric, 40); assert.deepEqual(getters, ["ospf", "active", "ospf.metric"])
for (const patch of [{ ospf: "false" }, { active: "false" }, { contribution: "unreachable" }, { "ospf.metric": "unknown" }, { "ospf.metric": "16777216" }, { "immediate-gw": "198.18.1.2%owned-gre-other" }, { "immediate-gw": "198.18.1.2%owned-gre@foreign-vrf" }]) {
+13 -3
View File
@@ -25,10 +25,18 @@ async function readBoundedRows(client: Pick<MikrotikClient, "get">, path: string
return rows
}
function routeLookupPath(prefix: string, table: string, includeScopedDestinations = false) {
const properties = ".id,dst-address,routing-table,afi,ospf,active,ospf.metric,immediate-gw,contribution"
const destination = includeScopedDestinations ? "" : `&dst-address=${encodeURIComponent(prefix)}`
return `/routing/route?.proplist=${properties}&routing-table=${encodeURIComponent(table)}${destination}`
}
export async function readOspfRouteAbsence(client: Pick<MikrotikClient, "get">, selection: { prefix: string; table: string }, beforeRead: () => Promise<unknown>) {
const prefix = canonicalOspfRouteProofPrefix(selection.prefix)
if (!prefix || !selection.table || selection.table.length > 200) throw new OspfRouteProofError("Invalid OSPF route absence context")
const routes = await readBoundedRows(client, "/routing/route", beforeRead)
// RouterOS can render link-local destinations as fe80::%interface/64.
const linkLocal = /^fe[89ab][0-9a-f]:/i.test(prefix)
const routes = await readBoundedRows(client, routeLookupPath(prefix, selection.table, linkLocal), beforeRead)
for (const row of routes) {
const observed = row["dst-address"]
const scoped = typeof observed === "string" ? /^([0-9a-f:]+)%[^/%]+(\/\d+)$/i.exec(observed) : null
@@ -52,7 +60,7 @@ export async function readOspfRouteProof(client: Pick<MikrotikClient, "get" | "p
const prefix = canonicalOspfRouteProofPrefix(selection.prefix)
if (!prefix || !selection.table || !selection.interface || selection.table.length > 200 || selection.interface.length > 200) throw new OspfRouteProofError("Invalid OSPF route proof context")
const family = isIP(prefix.split("/")[0])
const rows = await readBoundedRows(client, "/routing/route", beforeRead)
const rows = await readBoundedRows(client, routeLookupPath(prefix, selection.table), beforeRead)
const matches = rows.filter(row => {
if (row["routing-table"] !== selection.table || canonicalOspfRouteProofPrefix(row["dst-address"]) !== prefix) return false
const active = flag(row.active)
@@ -74,7 +82,9 @@ export async function readOspfRouteProof(client: Pick<MikrotikClient, "get" | "p
if (metric === null) throw new OspfRouteProofError("OSPF route metric not confirmed")
const gateway = typeof row["immediate-gw"] === "string" ? row["immediate-gw"] : ""
const context = /^([^%@]+)%([^@]+)(?:@([^@]+))?$/.exec(gateway)
if (!context || isIP(context[1]) !== family || context[2] !== selection.interface || context[3] && context[3] !== selection.table) throw new OspfRouteProofError("OSPF route does not resolve through the selected interface/VRF")
const directInterface = gateway === selection.interface && !isIP(gateway)
const scopedInterface = context && isIP(context[1]) === family && context[2] === selection.interface && (!context[3] || context[3] === selection.table)
if (!directInterface && !scopedInterface) throw new OspfRouteProofError("OSPF route does not resolve through the selected interface/VRF")
await beforeRead()
return { id: String(row[".id"]), family: family === 4 ? "ipv4" : "ipv6", prefix: selection.prefix, table: selection.table, interface: selection.interface, immediateGateway: gateway, ospf: true, active: true, metric }
}
@@ -3,6 +3,15 @@ export function encodeRosId(rosId: string): string {
return encodeURIComponent(id)
}
/** RouterOS 7.24 file IDs use case-sensitive `**<base62>` instead of the legacy single asterisk. */
export function isRouterOsNativeId(value: unknown): value is string {
return typeof value === "string" && value.length <= 256 && /^\*\*?[a-z0-9]+$/i.test(value)
}
export function routerOsIdKey(value: string): string {
return value.startsWith("**") ? value : value.toLowerCase().replace(/^\*0+(?=[a-z0-9])/, "*")
}
export const greDependencyPaths = ["/interface", "/interface/bridge/port", "/interface/vlan",
"/interface/list/member", "/ip/vrf", "/ip/route", "/ipv6/route", "/routing/filter/rule",
"/routing/ospf/interface-template", "/routing/bfd/configuration", "/routing/bgp/connection", "/routing/rule",
@@ -103,9 +103,27 @@ for (const type of ["A", "AAAA", "MX", "NS", "TXT", "CNAME", "PTR"]) {
{
const f = fixture(); f.raw([]); await failure(f.executor.execute(await f.executor.prepare(1, request("mtu"))), "MEASUREMENT_UNKNOWN"); assert.equal(f.counts().sends, 1)
}
for (const host of ["192.0.2.1", "router.example"]) {
const f = fixture()
f.source.host = host
f.raw(["192.0.2.1"])
const post = f.deps.post
f.deps.post = async (...args) => {
const source = args[2]["src-address"] ?? "10.205.1.2"
f.raw(source === "10.205.1.2"
? [{ seq: "0", ttl: "64", time: "25ms", sent: "1", received: "1", "packet-loss": "0" }]
: [{ seq: "0", status: "timeout", sent: "1", received: "0", "packet-loss": "100" }])
return post(...args)
}
const prepared = await f.executor.prepare(1, request("ping", { target: "10.205.1.1", pingCount: 1 }))
const result = await f.executor.execute(prepared)
assert.match(result.output!, /sent=1 received=1 packet-loss=0/)
assert.deepEqual(f.counts(), { sends: 1, dnsCalls: 0 })
cases++
}
{
const f = fixture(); f.source.host = "router.example"; f.sourceFailure()
const prepared = await f.executor.prepare(1, request("ping")), result = await f.executor.execute(prepared)
const prepared = await f.executor.prepare(1, request("traceroute")), result = await f.executor.execute(prepared)
assert.equal(result.state, "completed"); assert.equal(f.counts().dnsCalls, 1); assert.equal(f.counts().sends, 1)
assert.equal((f.events.find(event => event.kind === "native")!.value as { body: Record<string, string> }).body["src-address"], undefined)
assert.equal(f.events.filter(event => event.kind === "received").length, 2); cases++
@@ -137,7 +155,7 @@ for (const kind of ["claim", "intent", "receipt", "received"] as const) {
}
{
const f = fixture(); f.source.host = "router.example"; f.raw(["192.0.2.1"])
const prepared = await f.executor.prepare(1, request("ping")); f.lost("received")
const prepared = await f.executor.prepare(1, request("traceroute")); f.lost("received")
await failure(f.executor.execute(prepared), "JOURNAL_UNKNOWN"); assert.equal(f.counts().dnsCalls, 1); assert.equal(f.counts().sends, 0); assert.equal(f.events.filter(event => event.kind === "received").length, 1)
}
{
@@ -232,7 +232,8 @@ export function createServerProbeExecutor(deps: ServerProbeExecutionDependencies
}
claimed = true
let sourceIpv4: string | null = null
if (["ping", "traceroute", "mtu"].includes(plan.request.tool)) {
// Ping must let RouterOS choose the source for the route, including WireGuard.
if (plan.request.tool === "traceroute" || plan.request.tool === "mtu") {
const host = currentSource!.host.trim()
if (isIPv4(host)) sourceIpv4 = host
else {
+29 -9
View File
@@ -1,5 +1,5 @@
import { withPartitionWrite, isPartitionWriteOutcomeUnknown, PartitionWriteError, type PartitionWriteOptions } from "./partition-write-transaction.js"
import { and, asc, desc, eq, gte, lte } from "drizzle-orm"
import { and, asc, desc, eq, gte, inArray, lt, lte, sql } from "drizzle-orm"
import { executeGuardedApplicationWrite } from "./config-mutation-policy.js"
import { withApplicationCollectorLock } from "./config-mutation-lock.js"
import { db, pool } from "../db/index.js"
@@ -354,17 +354,37 @@ async function updateTrafficSettingsImpl(patch: {
return await getSettingsRow()
}
export interface TrafficHistoryReadOptions { untilIso?: string; maxRows?: number }
export interface TrafficHistoryReadOptions {
untilIso?: string
maxRows?: number
interfaceNames?: readonly string[]
interfaceCountersOnly?: boolean
precedingMaxIntervalMs?: number
}
export async function readServerSamplesInRange(serverId: number, sinceIso: string, options: TrafficHistoryReadOptions = {}) {
if (options.maxRows !== undefined && (!Number.isSafeInteger(options.maxRows) || options.maxRows < 1 || options.maxRows > 100000)) throw new Error("Некорректный предел истории трафика")
let query = db.select()
.from(trafficSamples)
.where(and(
const scope = and(
eq(trafficSamples.serverId, serverId),
options.interfaceNames === undefined ? undefined : inArray(trafficSamples.interfaceName, options.interfaceNames),
options.interfaceCountersOnly ? eq(trafficSamples.peerPublicKey, "") : undefined,
)
const inside = db.select().from(trafficSamples).where(and(scope, gte(trafficSamples.sampledAt, sinceIso),
options.untilIso === undefined ? undefined : lte(trafficSamples.sampledAt, options.untilIso)))
let query = inside.$dynamic()
if (options.precedingMaxIntervalMs !== undefined) {
const earliest = new Date(Date.parse(sinceIso) - options.precedingMaxIntervalMs).toISOString()
const priorWave = db.select({ sampledAt: trafficSamples.sampledAt }).from(trafficSamples).where(and(
eq(trafficSamples.serverId, serverId),
gte(trafficSamples.sampledAt, sinceIso),
options.untilIso === undefined ? undefined : lte(trafficSamples.sampledAt, options.untilIso),
))
.orderBy(asc(trafficSamples.sampledAt)).$dynamic()
gte(trafficSamples.sampledAt, earliest),
lt(trafficSamples.sampledAt, sinceIso),
)).orderBy(desc(trafficSamples.sampledAt)).limit(1)
// The predecessor is a single poll wave from the same SQL snapshot, even for a filtered interface.
query = query.unionAll(db.select().from(trafficSamples).where(and(scope,
gte(trafficSamples.sampledAt, earliest), lt(trafficSamples.sampledAt, sinceIso),
sql`${trafficSamples.sampledAt} = (${priorWave})`,
)))
}
query = query.orderBy(asc(trafficSamples.sampledAt))
if (options.maxRows !== undefined) query = query.limit(options.maxRows + 1)
const rows = await query
if (options.maxRows !== undefined && rows.length > options.maxRows) throw new Error("История трафика превышает предел; выберите меньший диапазон")
@@ -118,6 +118,20 @@ try {
assert.ok(filtered.bytes >= 12_000)
assert.equal(filtered.ifaces[0]?.name, "ether1")
const egress = await buildFlowAnalytics({ minutes: 5, serverId, iface: "ether2" })
assert.equal(egress.bytes, 12_000)
assert.deepEqual(egress.interfaces.map(row => [row.id, row.bytes]), [["ether2", 12_000]])
assert.equal(egress.conversationsList[0]?.accountedIface, "ether2")
assert.equal(egress.paths?.[0]?.ifaces, "ether1, ether2")
assert.equal(egress.conversationsList[0]?.dstCountry, "unknown")
assert.equal(egress.mapEdges?.[0]?.toCountry, "unknown")
for (const rows of [egress.applications, egress.categories, egress.services, egress.asns, egress.countries,
egress.mapEdges, egress.protocols, egress.sources, egress.destinations, egress.paths, egress.conversationsList, egress.interfaces]) {
assert.equal(rows?.reduce((sum, row) => sum + row.bytes, 0), egress.bytes)
}
assert.equal(egress.asns?.[0]?.id, "unknown")
assert.equal(egress.countries?.[0]?.percent, 100)
const miss = await buildFlowAnalytics({ minutes: 5, serverId, iface: "wg-flow" })
assert.equal(miss.conversations, 0)
@@ -175,7 +189,7 @@ try {
assert.equal(deduped.bytes, 12_000)
assert.equal(deduped.conversations, 1)
assert.equal(deduped.dedupApplied, true)
assert.equal(deduped.interfaces.length, 2)
assert.deepEqual(deduped.interfaces.map(row => [row.id, row.bytes]), [["ether1", 12_000]])
} finally {
resetFlowRingsForTests()
resetIfaceCacheForTests()
@@ -287,6 +301,7 @@ try {
])
const degraded = await buildFlowAnalytics({ minutes: 5, serverId, skipHeavy: true })
assert.equal(degraded.degraded, true)
assert.equal(degraded.conversations, 1)
assert.equal(degraded.conversationsList.length, 0)
assert.ok((degraded.bytes ?? 0) >= 12_000)
const exporters = await listFlowExporters(5)
+175 -101
View File
@@ -22,11 +22,12 @@ import {
listFlowRowsForWindow,
type PendingFlowRow,
} from "./traffic-flow-ingest.js"
import { flowDataEpoch, MAX_PENDING, RING_OVERLAY } from "./traffic-flow-engine.js"
import { ADMITTED_FLOW_DAY_DIM, flowDataEpoch, MAX_PENDING, OBSERVED_FLOW_IFACE_COVERAGE_DIM, OBSERVED_FLOW_IFACE_DIM } from "./traffic-flow-engine.js"
import { resolveIfaceName } from "./traffic-flow-ifaces.js"
import { factIfaceAliases } from "./traffic-flow-ifindex.js"
import { getTrafficFlowSettingsRow } from "./traffic-flow-settings.js"
import { applicationName, flowRowMatchesFilter } from "./traffic-flow-apps.js"
import { dedupFlowRowsMaxBytes, flowTupleKey } from "./traffic-flow-dedup.js"
import { collapseGreEspRows, dedupFlowRowsMaxBytes, flowTupleKey } from "./traffic-flow-dedup.js"
import { enqueueRipeMisses } from "./traffic-flow-ripe.js"
import { classifyFlowPlane, flowBps, shouldKeepPlane } from "./traffic-flow-planes.js"
import { flowRateDirection, resolveInternetDest } from "./traffic-flow-dest.js"
@@ -48,7 +49,7 @@ export interface FlowAnalyticsQuery {
serverId?: number
userId?: string
iface?: string
/** Default true: один 5-tuple = max байт по ifaces. */
/** Default true: один 5-tuple за минуту = max байт по ifaces. */
dedup?: boolean
/** Default true: скрыть GRE/WG между клиентами JH. */
excludeMesh?: boolean
@@ -106,10 +107,10 @@ async function userIfaceAllow(userId: string): Promise<Map<number, Set<string>>
return allow
}
function seriesFromRows(rows: PendingFlowRow[], minutes: number, direction: (row: PendingFlowRow) => "rx" | "tx" | "both" | null) {
function seriesFromRows(rows: PendingFlowRow[], minutes: number, direction: (row: PendingFlowRow) => "rx" | "tx" | "both" | null, now = Date.now()) {
const slots = Math.min(60, Math.max(5, minutes))
const slotMs = (minutes * 60_000) / slots
const start = Date.now() - minutes * 60_000
const start = now - minutes * 60_000
const rx = Array(slots).fill(0) as number[]
const tx = Array(slots).fill(0) as number[]
let undirectedBytes = 0
@@ -191,6 +192,35 @@ function analyticsQueryKey(q: FlowAnalyticsQuery): string {
const ANALYTICS_CACHE_TTL_MS = 2000
let analyticsCache: { key: string; at: number; dto: FlowAnalyticsDto } | null = null
async function readAdmittedFlowTotals(serverId: number, iface: string, minutes: number, now: number): Promise<FlowAnalyticsDto["admittedTotals"]> {
const end = Math.floor(now / 60_000) * 60_000
const from = new Date(end - minutes * 60_000).toISOString(), to = new Date(end).toISOString()
type Totals = { bytes: number | string; packets: number | string; count: number; missing?: number }
const params = [serverId, from, to]
const [totals] = iface
? await flowReadDbAll<Totals>(`
SELECT COALESCE(SUM(observed.bytes), 0) AS bytes, COALESCE(SUM(observed.packets), 0) AS packets,
COUNT(*)::int AS count,
COUNT(*) FILTER (WHERE coverage.bytes IS DISTINCT FROM s.bytes OR coverage.packets IS DISTINCT FROM s.packets)::int AS missing
FROM flow_minute_stats s
LEFT JOIN flow_minute_dims coverage ON coverage.server_id = s.server_id AND coverage.bucket_at = s.bucket_at
AND coverage.dim = ? AND coverage.key = 'all'
LEFT JOIN LATERAL (
SELECT SUM(d.bytes) AS bytes, SUM(d.packets) AS packets
FROM flow_minute_dims d
WHERE d.server_id = s.server_id AND d.bucket_at = s.bucket_at AND d.dim = ? AND d.key = ANY(?::text[])
) observed ON true
WHERE s.server_id = ? AND s.bucket_at >= ? AND s.bucket_at < ?
`, [OBSERVED_FLOW_IFACE_COVERAGE_DIM, OBSERVED_FLOW_IFACE_DIM, factIfaceAliases(iface, serverId), ...params])
: await flowReadDbAll<Totals>(`
SELECT COALESCE(SUM(bytes), 0) AS bytes, COALESCE(SUM(packets), 0) AS packets, COUNT(*)::int AS count
FROM flow_minute_stats WHERE server_id = ? AND bucket_at >= ? AND bucket_at < ?
`, params)
// A minute can contain writes by both old and new collectors after an upgrade.
if (!totals?.count || totals.missing) return undefined
return { bytes: flowCounter(totals.bytes), packets: flowCounter(totals.packets), from, to, minutesWithData: totals.count }
}
async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedFlowAnalyticsRead): Promise<FlowAnalyticsDto> {
const authorize = scope?.authorize ?? (async () => {})
await authorize()
@@ -198,7 +228,8 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
const top = Math.min(50, Math.max(10, settings.topN))
const windowSec = Math.max(60, q.minutes * 60)
await authorize()
const raw = await listFlowRowsForWindow(q.minutes, q.serverId, { ...(scope ? { maxRows: scope.maxRows } : {}), untilIso: new Date().toISOString() })
const now = Date.now()
const raw = await listFlowRowsForWindow(q.minutes, q.serverId, { ...(scope ? { maxRows: scope.maxRows } : {}), untilIso: new Date(now).toISOString() })
for (const row of raw) if (scope && (!scope.serverIds.includes(row.serverId) || !Number.isSafeInteger(row.bytes) || row.bytes < 0 || !Number.isSafeInteger(row.packets) || row.packets < 0)) throw new Error("Недостоверная строка аналитики NetFlow")
await authorize()
const catalog = await getServerCatalog(scope ? [q.serverId!] : undefined)
@@ -215,6 +246,23 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
if (!scope) refreshFlowCatalogInBackground()
const matchesIngress = (row: PendingFlowRow) => flowRowMatchesFilter(row, resolveIfaceName(row.serverId, row.inIface).name, q, allow)
const matchesEgress = (row: PendingFlowRow) => flowRowMatchesFilter({ serverId: row.serverId, inIface: row.outIface }, resolveIfaceName(row.serverId, row.outIface).name, q, allow)
const serverDirection = (row: PendingFlowRow) => flowRateDirection(row.serverId, row, topo, catalog.byId.get(row.serverId)?.host)
const interfaceDirection = (row: PendingFlowRow) => {
const ingress = matchesIngress(row), egress = matchesEgress(row)
return ingress === egress ? null : ingress ? "rx" : "tx"
}
const selected = ifaceFilter || allow ? raw.filter(row => matchesIngress(row) || matchesEgress(row)) : raw
const { rows, espDirections } = collapseGreEspRows(selected, ifaceFilter ? interfaceDirection : serverDirection)
const previousMinute = new Date(Math.floor(now / 60_000) * 60_000 - 60_000).toISOString()
const ifacesForWire = new Set<string>()
for (const row of selected) {
ifacesForWire.add(resolveIfaceName(row.serverId, row.inIface).name)
const egress = resolveIfaceName(row.serverId, row.outIface).name
if (egress && egress !== "—") ifacesForWire.add(egress)
}
const applications = new Map<string, { bytes: number; packets: number; label?: string }>()
const protocols = new Map<string, { bytes: number; packets: number; label?: string }>()
const sources = new Map<string, { bytes: number; packets: number; label?: string }>()
@@ -234,16 +282,12 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
const skipHeavy = Boolean(q.skipHeavy)
let bytesPayload = 0
let bytesOverlay = 0
let recentOverlayBytes = 0
let bytesMesh = 0
const ifacesForWire = new Set<string>()
for (const r of raw) {
for (const r of rows) {
const resolved = resolveIfaceName(r.serverId, r.inIface)
const outResolved = resolveIfaceName(r.serverId, r.outIface)
if (!flowRowMatchesFilter(r, resolved.name, q, allow)
&& !flowRowMatchesFilter({ serverId: r.serverId, inIface: r.outIface }, outResolved.name, q, allow)) continue
ifacesForWire.add(resolved.name)
if (outResolved.name && outResolved.name !== "—") ifacesForWire.add(outResolved.name)
const plane = classifyFlowPlane({
src: r.src,
dst: r.dst,
@@ -254,29 +298,32 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
outIface: outResolved.name,
}, topo.plane)
if (plane === "payload") bytesPayload += r.bytes
else if (plane === "overlay") bytesOverlay += r.bytes
else if (plane === "overlay") {
bytesOverlay += r.bytes
if (r.bucketAt === previousMinute) recentOverlayBytes += r.bytes
}
else if (plane === "client_mesh") bytesMesh += r.bytes
if (!shouldKeepPlane(plane, { excludeMesh, excludeOverlay })) continue
matched.push(r)
const ifaceKey = resolved.name
const prevIf = ifacesMap.get(ifaceKey) ?? { bytes: 0, packets: 0, index: resolved.index }
prevIf.bytes += r.bytes
prevIf.packets += r.packets
ifacesMap.set(ifaceKey, prevIf)
}
const working = wantDedup ? dedupFlowRowsMaxBytes(matched) : matched
const conversationsRaw = new Set(matched.map((r) => `${flowTupleKey(r)}|${r.inIface}`)).size
const conversations = wantDedup ? new Set(working.map(flowTupleKey)).size : conversationsRaw
let totalBytes = 0
let totalPackets = 0
for (const r of working) {
const resolved = resolveIfaceName(r.serverId, r.inIface)
const outResolved = resolveIfaceName(r.serverId, r.outIface)
const ingressAccounts = ifaceFilter || allow ? matchesIngress(r) : resolved.name !== "—"
const accounted = ingressAccounts ? resolved : outResolved
const ifaceTotal = ifacesMap.get(accounted.name) ?? { bytes: 0, packets: 0, index: accounted.index }
ifaceTotal.bytes += r.bytes
ifaceTotal.packets += r.packets
ifacesMap.set(accounted.name, ifaceTotal)
totalBytes += r.bytes
totalPackets += r.packets
srcs.add(r.src)
dsts.add(r.dst)
const destMeta = resolveInternetDest({
src: r.src,
dst: r.dst,
@@ -285,6 +332,7 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
dstPort: r.dstPort,
serverId: r.serverId,
inIface: resolved.name,
outIface: outResolved.name,
topo,
natSrc: r.natSrc,
natDst: r.natDst,
@@ -292,28 +340,27 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
natDstPort: r.natDstPort,
})
const ep = destMeta.endpoints
const src = ep.packetSrc || r.src
const dst = ep.packetDst || r.dst
srcs.add(src)
dsts.add(dst)
if (destMeta.dest) peers.add(destMeta.dest)
const app = applicationName(r.proto, ep.peerPort || r.dstPort, ep.otherPort || r.srcPort)
const ripe = destMeta.ripe
const classified = destMeta.classified
bump(applications, app, r.bytes, r.packets)
bump(protocols, protoName(r.proto), r.bytes, r.packets)
bump(sources, r.src, r.bytes, r.packets)
bump(destinations, r.dst, r.bytes, r.packets)
bump(sources, src, r.bytes, r.packets)
bump(destinations, dst, r.bytes, r.packets)
bump(categories, classified.category, r.bytes, r.packets)
bump(services, classified.service, r.bytes, r.packets)
if (ripe?.ok && ripe.asn) {
const asnId = String(ripe.asn)
const asnLabel = ripe.holder ? `AS${ripe.asn} ${ripe.holder}` : `AS${ripe.asn}`
bump(asns, asnId, r.bytes, r.packets, asnLabel)
}
const dstCountry = destMeta.country && destMeta.country !== "unknown" ? destMeta.country : ""
if (dstCountry) {
bump(countries, dstCountry, r.bytes, r.packets)
}
const asnId = destMeta.asn ? String(destMeta.asn) : "unknown"
const asnLabel = destMeta.asn ? `AS${destMeta.asn}${ripe?.holder ? ` ${ripe.holder}` : ""}` : "ASN неизвестен"
bump(asns, asnId, r.bytes, r.packets, asnLabel)
const dstCountry = destMeta.country || "unknown"
bump(countries, dstCountry, r.bytes, r.packets, dstCountry === "unknown" ? "Страна неизвестна" : undefined)
if (!skipHeavy) {
const outResolved = resolveIfaceName(r.serverId, r.outIface)
const plane = classifyFlowPlane({
src: r.src,
dst: r.dst,
@@ -323,11 +370,13 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
inIface: resolved.name,
outIface: outResolved.name,
}, topo.plane)
const client = resolveClient(topo, r.serverId, resolved.name)
const client = resolveClient(topo, r.serverId, resolved.name) ?? resolveClient(topo, r.serverId, outResolved.name)
const en = resolveEn(topo, r.nextHop, outResolved.name)
const ckey = wantDedup
? flowTupleKey(r)
: `${flowTupleKey(r)}|${r.inIface}`
const outIface = outResolved.name === "—" ? "" : outResolved.name
const pathKey = JSON.stringify([client?.userId ?? "unknown", r.serverId, en?.id ?? "", dst, resolved.name, outIface,
classified.service, classified.category, plane])
const ckey = JSON.stringify([flowTupleKey(r), pathKey, accounted.name, app, asnId, dstCountry, ep.internetPeer,
ep.clientIp, ep.peerPort, ep.direction, r.nextHop])
const prev = conv.get(ckey)
if (prev) {
prev.rawBytes += r.bytes
@@ -339,8 +388,8 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
conv.set(ckey, {
serverId: String(r.serverId),
serverName: nameById.get(r.serverId) ?? String(r.serverId),
src: ep.packetSrc || r.src,
dst: ep.packetDst || r.dst,
src,
dst,
proto: r.proto,
protoName: protoName(r.proto),
srcPort: r.srcPort,
@@ -350,13 +399,14 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
bps: 0,
inIface: resolved.name,
inIfaceIndex: resolved.index,
outIface: outResolved.name !== "—" ? outResolved.name : undefined,
outIface: outIface || undefined,
accountedIface: accounted.name,
nextHop: r.nextHop || undefined,
application: app,
category: classified.category,
service: classified.service,
dstCountry: dstCountry || undefined,
dstAsn: ripe?.asn || undefined,
dstCountry,
dstAsn: destMeta.asn || undefined,
clientId: client?.userId,
clientName: client?.name,
clientIp: ep.clientIp || undefined,
@@ -372,7 +422,6 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
})
}
const pathKey = `${client?.userId || "unknown"}|${r.serverId}|${en?.id || ""}|${r.dst}|${resolved.name}`
const pathPrev = pathAcc.get(pathKey)
if (pathPrev) {
pathPrev.bytes += r.bytes
@@ -382,14 +431,14 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
id: pathKey,
clientId: client?.userId || "unknown",
clientName: client?.name || "Неизвестный клиент",
ifaces: client ? [...(topo.clientIfaces.get(r.serverId) ?? [resolved.name])].join(", ") : resolved.name,
ifaces: [...new Set([resolved.name, outIface].filter(name => name && name !== "—"))].join(", ") || "—",
serverId: String(r.serverId),
serverName: nameById.get(r.serverId) ?? String(r.serverId),
inIface: resolved.name,
outIface: outResolved.name !== "—" ? outResolved.name : "",
outIface,
enId: en ? String(en.id) : "",
enName: en?.name || "",
dst: r.dst,
dst,
service: classified.service,
category: classified.category,
plane,
@@ -399,29 +448,25 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
})
}
const toCountry = dstCountry
if (toCountry) {
const fromCountry = countryById.get(r.serverId) || "UN"
const ekey = `${r.serverId}|${toCountry}`
let edge = edgeAcc.get(ekey)
if (!edge) {
edge = {
fromId: String(r.serverId),
fromLabel: nameById.get(r.serverId) ?? String(r.serverId),
fromCountry,
toCountry,
toAsn: ripe?.asn ?? 0,
category: classified.category,
bytes: 0,
bps: 0,
catBytes: new Map(),
}
edgeAcc.set(ekey, edge)
const ekey = `${r.serverId}|${dstCountry}`
let edge = edgeAcc.get(ekey)
if (!edge) {
edge = {
fromId: String(r.serverId),
fromLabel: nameById.get(r.serverId) ?? String(r.serverId),
fromCountry: countryById.get(r.serverId) || "UN",
toCountry: dstCountry,
toAsn: destMeta.asn,
category: classified.category,
bytes: 0,
bps: 0,
catBytes: new Map(),
}
edge.bytes += r.bytes
if (ripe?.asn) edge.toAsn = ripe.asn
edge.catBytes.set(classified.category, (edge.catBytes.get(classified.category) ?? 0) + r.bytes)
edgeAcc.set(ekey, edge)
}
edge.bytes += r.bytes
if (edge.toAsn !== destMeta.asn) edge.toAsn = 0
edge.catBytes.set(classified.category, (edge.catBytes.get(classified.category) ?? 0) + r.bytes)
}
}
@@ -444,24 +489,22 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
const topCategory = topLabel(categories)
const ringServer = q.serverId ?? (matched[0]?.serverId ?? 0)
const ring = ringServer
? getRingMbps(ringServer, ifaceFilter === "" ? "__all__" : (ifacesMap.get(ifaceFilter)?.index || ifaceFilter))
: { rx: Array(60).fill(0) as number[], tx: Array(60).fill(0) as number[], rxNow: 0, txNow: 0 }
const ring = ringServer && !ifaceFilter && !allow && excludeOverlay ? getRingMbps(ringServer) : null
// The live ring covers about one minute; historical charts must use the requested window.
// Keep the winning interface's individual minute buckets when deduplicating.
const chosenIfaces = wantDedup ? new Map(working.map(row => [flowTupleKey(row), row.inIface])) : null
const chartRows = chosenIfaces ? matched.filter(r => chosenIfaces.get(flowTupleKey(r)) === r.inIface) : matched
const fromBuckets = seriesFromRows(chartRows, q.minutes, row => {
const fromBuckets = seriesFromRows(working, q.minutes, row => {
if (ifaceFilter || allow) {
const ingress = flowRowMatchesFilter(row, resolveIfaceName(row.serverId, row.inIface).name, q, allow)
const egress = flowRowMatchesFilter({ serverId: row.serverId, inIface: row.outIface }, resolveIfaceName(row.serverId, row.outIface).name, q, allow)
if (ingress && egress) return "both"
const ingress = matchesIngress(row), egress = matchesEgress(row)
if (ingress && egress) {
// A repeated WAN interface in an overlay record does not prove two wire directions.
if (ifaceFilter && (row.proto === 47 || row.proto === 50)) return espDirections.get(row) ?? serverDirection(row)
return "both"
}
// At a client binding, ingress is the client's upload.
return allow && !ifaceFilter ? (ingress ? "tx" : "rx") : (ingress ? "rx" : "tx")
}
return flowRateDirection(row.serverId, row, topo, catalog.byId.get(row.serverId)?.host)
})
return espDirections.get(row) ?? serverDirection(row)
}, now)
const rxSeries = fromBuckets.rx
const txSeries = fromBuckets.tx
@@ -473,7 +516,6 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
bps: (v.bytes * 8) / windowSec,
}))
const ifaceRawBytes = [...ifacesMap.values()].reduce((a, v) => a + v.bytes, 0) || 1
const listener = getFlowListenerState()
const mapEdges: FlowMapEdge[] = [...edgeAcc.values()]
.map((e) => {
@@ -499,22 +541,30 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
.sort((a, b) => b.bytes - a.bytes)
.slice(0, top)
const overlayRing = ringServer
? getRingMbps(ringServer, RING_OVERLAY)
: { rxNow: 0, txNow: 0 }
// Filtered and overlay-inclusive rates must use the same records as their totals.
const recentBytes = ring ? 0 : working.reduce((sum, row) => sum + (row.bucketAt === previousMinute ? row.bytes : 0), 0)
const bpsNow = ring
? (!fromBuckets.undirectedBytes && (ring.rxNow + ring.txNow) * 1_000_000) || (totalBytes * 8) / windowSec
: (recentBytes * 8) / 60 || (totalBytes * 8) / windowSec
const greNames = ringServer ? enGreIfaceNames(topo, ringServer, [...ifacesForWire]) : []
await authorize()
const wire = ringServer ? await latestWireBps(ringServer, greNames, Boolean(scope)) : { bps: 0, bytes: 0 }
await authorize()
const admittedTotals = q.serverId !== undefined && !q.userId
? await readAdmittedFlowTotals(q.serverId, ifaceFilter, q.minutes, now)
: undefined
if (scope && (!Number.isSafeInteger(totalBytes) || !Number.isSafeInteger(totalPackets) || !Number.isSafeInteger(bytesPayload) || !Number.isSafeInteger(bytesOverlay) || !Number.isSafeInteger(bytesMesh))) throw new Error("Переполнение счётчика аналитики NetFlow")
await authorize()
if (scope && (!isDeepStrictEqual(topo, await loadFlowTopology(scope.serverIds, authorize)) || (await readFlowSourceLimits()).topN !== settings.topN)) throw new Error("Топология или предел источника NetFlow изменились во время чтения")
await authorize()
return {
bpsNow: (!fromBuckets.undirectedBytes && (ring.rxNow + ring.txNow) * 1_000_000) || (totalBytes * 8) / windowSec,
timeBasis: "collector-receipt",
...(admittedTotals ? { admittedTotals } : {}),
bpsNow,
bytes: totalBytes,
packets: totalPackets,
conversations: conv.size,
conversations,
conversationsRaw,
uniqueSrc: srcs.size,
uniqueDst: dsts.size,
@@ -532,7 +582,7 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
bytes: v.bytes,
packets: v.packets,
bps: (v.bytes * 8) / windowSec,
percent: (v.bytes / ifaceRawBytes) * 100,
percent: (v.bytes / (totalBytes || 1)) * 100,
})).sort((a, b) => b.bytes - a.bytes),
asns: topN(asns, windowSec, top),
countries: topN(countries, windowSec, top),
@@ -549,7 +599,7 @@ async function buildFlowAnalyticsUncached(q: FlowAnalyticsQuery, scope?: ScopedF
bytesOverlay,
bytesMesh,
bytesWire: wire.bytes,
bpsOverlay: (overlayRing.rxNow + overlayRing.txNow) * 1_000_000 || (bytesOverlay * 8) / windowSec,
bpsOverlay: (recentOverlayBytes * 8) / 60 || (bytesOverlay * 8) / windowSec,
bpsWire: wire.bps,
excludeMeshApplied: excludeMesh,
excludeOverlayApplied: excludeOverlay,
@@ -722,8 +772,8 @@ export async function getFlowMonthly(month: string, serverId?: number | readonly
if (!bounds) {
throw Object.assign(new Error("Некорректный месяц отчёта"), { statusCode: 400 })
}
const params: Array<string | number> = [bounds.start, bounds.end]
let where = "day >= ? AND day < ? AND dim IN ('country', 'service', 'asn')"
const params: Array<string | number> = [bounds.start, bounds.end, ADMITTED_FLOW_DAY_DIM]
let where = "day >= ? AND day < ? AND dim IN ('country', 'service', 'asn', ?)"
if (Array.isArray(serverId)) {
if (serverId.some(id => !Number.isSafeInteger(id) || id <= 0)) throw new Error("Некорректная область месячного NetFlow")
if (serverId.length === 0) where += " AND false"
@@ -733,38 +783,62 @@ export async function getFlowMonthly(month: string, serverId?: number | readonly
params.push(serverId as number)
}
if (options && (!Number.isSafeInteger(options.maxKeys) || options.maxKeys < 1 || options.maxKeys > 10000)) throw new Error("Некорректный предел месячных dimension keys")
if (options) params.push(options.maxKeys + 1)
if (options) params.push(options.maxKeys + 2)
const rows = await flowReadDbAll<{ dim: string; key: string; bytes: number; packets: number }>(`
SELECT dim AS dim, key AS key, SUM(bytes) AS bytes, SUM(packets) AS packets
FROM flow_daily_dims
WHERE ${where}
GROUP BY dim, key
WITH scoped AS (
SELECT server_id, day, dim, key, bytes, packets FROM flow_daily_dims WHERE ${where}
), daily AS (
SELECT server_id, day, dim, SUM(bytes) AS bytes, SUM(packets) AS packets
FROM scoped GROUP BY server_id, day, dim
), chosen AS (
SELECT DISTINCT ON (server_id, day) dim, bytes, packets
FROM daily
ORDER BY server_id, day, bytes DESC, packets DESC, CASE dim WHEN 'service' THEN 1 WHEN 'asn' THEN 2 WHEN 'country' THEN 3 ELSE 0 END
)
SELECT dim, key, SUM(bytes) AS bytes, SUM(packets) AS packets
FROM scoped WHERE dim IN ('country', 'service', 'asn') GROUP BY dim, key
UNION ALL
SELECT 'total', CASE WHEN BOOL_AND(dim NOT IN ('country','service','asn')) IS FALSE THEN 'legacy-dimensions' ELSE 'admitted-daily' END,
COALESCE(SUM(bytes), 0), COALESCE(SUM(packets), 0)
FROM chosen
${options ? "LIMIT ?" : ""}
`, params)
if (options && rows.length > options.maxKeys) throw new Error("Месячный NetFlow превышает предел dimension keys")
if (options && rows.length > options.maxKeys + 1) throw new Error("Месячный NetFlow превышает предел dimension keys")
const countries: Array<{ key: string; bytes: number; packets: number }> = []
const services: Array<{ key: string; bytes: number; packets: number }> = []
const asns: Array<{ key: string; bytes: number; packets: number }> = []
let bytes = 0
const total = rows.find(row => row.dim === "total")
if (!total) throw new Error("Месячный итог NetFlow недоступен")
const bytes = flowCounter(total.bytes)
for (const row of rows) {
const rec = { key: row.key, bytes: flowCounter(row.bytes), packets: flowCounter(row.packets) }
if (row.dim === "country") {
countries.push(rec)
bytes = flowCounter(bytes + rec.bytes)
} else if (row.dim === "service") services.push(rec)
else if (row.dim === "asn") asns.push(rec)
}
const countryBytes = flowCounterSum(countries.map(row => row.bytes))
if (countryBytes < bytes) {
const packets = Math.max(0, flowCounter(total.packets) - flowCounterSum(countries.map(row => row.packets)))
const unknown = countries.find(row => row.key === "unknown")
if (unknown) {
unknown.bytes = flowCounter(unknown.bytes + (bytes - countryBytes))
unknown.packets = flowCounter(unknown.packets + packets)
} else {
countries.push({ key: "unknown", bytes: bytes - countryBytes, packets })
}
}
const [year, monthIndex] = month.split("-").map(Number)
const leap = year! % 4 === 0 && (year! % 100 !== 0 || year! % 400 === 0)
const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][monthIndex! - 1]!
const windowSec = daysInMonth * 86_400
const countryTotal = flowCounterSum(countries.map(row => row.bytes)) || bytes || 1
return {
month,
bytes,
countries: toBreakdown(countries, countryTotal, windowSec),
services: toBreakdown(services, flowCounterSum(services.map(row => row.bytes)) || 1, windowSec),
asns: toBreakdown(asns, flowCounterSum(asns.map(row => row.bytes)) || 1, windowSec),
totalsSource: total.key === "legacy-dimensions" ? "legacy-dimensions" : "admitted-daily",
countries: toBreakdown(countries, bytes, windowSec),
services: toBreakdown(services, bytes, windowSec),
asns: toBreakdown(asns, bytes, windowSec),
}
}
@@ -1,5 +1,6 @@
import assert from "node:assert/strict"
import {
collapseGreEspRows,
dedupFlowRowsAcrossExporters,
dedupFlowRowsMaxBytes,
flowConversationKey,
@@ -36,4 +37,37 @@ assert.equal(across.length, 1)
assert.equal(across[0]?.serverId, 7)
assert.equal(across[0]?.bytes, 9_000)
const minute = "2026-11-22T06:26:00.000Z"
const nextMinute = "2026-11-22T06:27:00.000Z"
const beforeReroute = { ...a, bucketAt: minute }
const afterReroute = { ...b, bucketAt: nextMinute }
assert.deepEqual(dedupFlowRowsMaxBytes([beforeReroute, { ...b, bucketAt: minute }, afterReroute]), [
beforeReroute, afterReroute,
])
assert.deepEqual(dedupFlowRowsAcrossExporters(
[{ ...en, bucketAt: minute }, beforeReroute, afterReroute],
(x, y) => x.serverId === a.serverId ? x : y,
), [beforeReroute, afterReroute])
const gre = { ...a, bucketAt: minute, proto: 47, srcPort: 0, dstPort: 0 }
const esp = { ...gre, proto: 50, bytes: gre.bytes + gre.packets * 40, inIface: "10" }
const plain = { ...gre, dst: "198.51.100.3" }
const reverse = { ...esp, src: esp.dst, dst: esp.src }
const foreign = { ...esp, serverId: 9 }
const collapse = (rows: typeof gre[]) => collapseGreEspRows(rows, row => row.inIface === "2" ? "tx" : null)
const layerPair = collapse([gre, esp, plain, reverse, foreign])
assert.deepEqual(layerPair.rows, [esp, plain, reverse, foreign])
assert.equal(layerPair.espDirections.get(esp), "tx")
const splitGre = [{ ...gre, bytes: 8_400, packets: 7 }, { ...gre, bucketAt: nextMinute, bytes: 3_600, packets: 3 }]
const laterEsp = { ...esp, bucketAt: nextMinute }
assert.deepEqual(collapse([...splitGre, laterEsp]).rows, [laterEsp])
for (const unrelated of [
{ ...esp, packets: esp.packets - 1 },
{ ...esp, bytes: gre.bytes },
{ ...esp, bytes: gre.bytes + gre.packets * 500 },
{ ...esp, bucketAt: "2026-11-22T06:29:00.000Z" },
{ ...esp, srcPort: 123 },
]) assert.deepEqual(collapse([gre, unrelated]).rows, [gre, unrelated])
assert.deepEqual(collapseGreEspRows([gre, esp], row => row.proto === 47 ? "rx" : "tx").rows, [gre, esp])
console.log("traffic-flow-dedup.test.ts: ok")
+74 -10
View File
@@ -1,3 +1,5 @@
import { isUnspecifiedIp } from "./traffic-flow-ip.js"
export interface FlowTupleRow {
serverId: number
src: string
@@ -6,6 +8,7 @@ export interface FlowTupleRow {
srcPort: number
dstPort: number
inIface: string
bucketAt?: string
bytes: number
packets: number
}
@@ -29,7 +32,7 @@ export function dedupFlowRowsAcrossExporters<T extends FlowTupleRow>(
): T[] {
const byConv = new Map<string, T>()
for (const row of rows) {
const key = flowConversationKey(row)
const key = `${row.bucketAt ?? ""}|${flowConversationKey(row)}`
const prev = byConv.get(key)
if (!prev) {
byConv.set(key, row)
@@ -40,31 +43,92 @@ export function dedupFlowRowsAcrossExporters<T extends FlowTupleRow>(
return [...byConv.values()]
}
function ifaceKey(r: FlowTupleRow): string {
return `${flowTupleKey(r)}|${r.inIface}`
function bucketTupleKey(r: FlowTupleRow): string {
return `${r.bucketAt ?? ""}|${flowTupleKey(r)}`
}
/**
* Один 5-tuple на двух ifIndex — это один поток: сначала сумма по бакетам/iface,
* затем max байт между интерфейсами (не sum).
* Сравниваем копии 5-tuple в одном бакете: между бакетами интерфейс может меняться.
*/
export function dedupFlowRowsMaxBytes<T extends FlowTupleRow>(rows: T[]): T[] {
const byIface = new Map<string, T>()
for (const row of rows) {
const key = ifaceKey(row)
const key = `${bucketTupleKey(row)}|${row.inIface}`
const prev = byIface.get(key)
if (!prev) {
byIface.set(key, { ...row })
byIface.set(key, row)
continue
}
prev.bytes += row.bytes
prev.packets += row.packets
byIface.set(key, { ...prev, bytes: prev.bytes + row.bytes, packets: prev.packets + row.packets })
}
const byTuple = new Map<string, T>()
for (const row of byIface.values()) {
const key = flowTupleKey(row)
const key = bucketTupleKey(row)
const prev = byTuple.get(key)
if (!prev || row.bytes > prev.bytes) byTuple.set(key, row)
}
return [...byTuple.values()]
}
type TimedFlowRow = FlowTupleRow & { bucketAt: string }
type FlowDirection = "rx" | "tx"
type OverlayRows<T> = { gre: T[]; esp: T[] }
function account(rows: readonly FlowTupleRow[]) {
return rows.reduce((total, row) => ({ bytes: total.bytes + row.bytes, packets: total.packets + row.packets }), { bytes: 0, packets: 0 })
}
/** GRE and its IPsec envelope can both be exported for the same packet sequence. */
export function collapseGreEspRows<T extends TimedFlowRow>(rows: readonly T[], direction: (row: T) => FlowDirection | null) {
const groups = new Map<string, OverlayRows<T>>()
for (const row of rows) {
if ((row.proto !== 47 && row.proto !== 50) || row.srcPort !== 0 || row.dstPort !== 0 ||
row.packets <= 0 || isUnspecifiedIp(row.src) || isUnspecifiedIp(row.dst) || row.src === row.dst) continue
const key = JSON.stringify([row.serverId, row.src, row.dst])
const group = groups.get(key) ?? { gre: [], esp: [] }
if (row.proto === 47) group.gre.push(row)
else group.esp.push(row)
groups.set(key, group)
}
const copies = new Set<T>()
const espDirections = new Map<T, FlowDirection>()
const match = (gre: T[], esp: T[]) => {
if (!gre.length || !esp.length) return
const inner = account(gre), outer = account(esp)
if (inner.packets !== outer.packets) return
const overhead = (outer.bytes - inner.bytes) / inner.packets
// Keep ambiguous records. An ESP envelope adds its headers, trailer and padding.
if (overhead < 8 || overhead > 128) return
const directions = new Set([...gre, ...esp].map(direction).filter(side => side !== null))
if (directions.size > 1) return
const [side] = directions
if (side) for (const row of esp) espDirections.set(row, side)
for (const row of gre) copies.add(row)
}
for (const group of groups.values()) {
if (!group.gre.length || !group.esp.length) continue
const byMinute = new Map<string, OverlayRows<T>>()
for (const plane of ["gre", "esp"] as const) for (const row of group[plane]) {
const bucket = byMinute.get(row.bucketAt) ?? { gre: [], esp: [] }
bucket[plane].push(row)
byMinute.set(row.bucketAt, bucket)
}
const unmatched: OverlayRows<T> = { gre: [], esp: [] }
for (const [, bucket] of [...byMinute].sort(([a], [b]) => a.localeCompare(b))) {
match(bucket.gre, bucket.esp)
if (!bucket.gre.length || !copies.has(bucket.gre[0])) {
unmatched.gre.push(...bucket.gre)
unmatched.esp.push(...bucket.esp)
}
}
// The exporter can flush the two layers in different minute buckets.
if (unmatched.gre.length && unmatched.esp.length &&
Math.abs(Date.parse(unmatched.gre[0].bucketAt) - Date.parse(unmatched.esp[0].bucketAt)) <= 60_000 &&
Math.abs(Date.parse(unmatched.gre.at(-1)!.bucketAt) - Date.parse(unmatched.esp.at(-1)!.bucketAt)) <= 60_000) {
match(unmatched.gre, unmatched.esp)
}
}
return { rows: rows.filter(row => !copies.has(row)), espDirections }
}
+6 -5
View File
@@ -53,17 +53,16 @@ export function destCtxForIface(
topo: FlowTopology | null | undefined,
serverId: number,
inIface: string,
nat?: Pick<InternetDestCtx, "natSrc" | "natDst" | "natSrcPort" | "natDstPort">,
nat?: Pick<InternetDestCtx, "natSrc" | "natDst" | "natSrcPort" | "natDstPort"> & { outIface?: string },
resolveIface=canonicalFactIface,
): InternetDestCtx {
const name = resolveIface(serverId, inIface) || String(inIface ?? "").trim()
const outName = nat?.outIface ? resolveIface(serverId, nat.outIface) : ""
return {
ours: flowOursHosts(topo),
boundClient: Boolean(
topo && name && (
resolveClient(topo, serverId, name)
|| topo.clientIfaces.get(serverId)?.has(name)
),
topo && [name, outName].some(iface => iface &&
(resolveClient(topo, serverId, iface) || topo.clientIfaces.get(serverId)?.has(iface))),
),
natSrc: nat?.natSrc,
natDst: nat?.natDst,
@@ -117,6 +116,7 @@ export function resolveInternetDest(opts: {
dstPort: number
serverId: number
inIface: string
outIface?: string
topo?: FlowTopology | null
natSrc?: string
natDst?: string
@@ -127,6 +127,7 @@ export function resolveInternetDest(opts: {
classify?:typeof classifyFlowDst
}): InternetDestMeta {
const ctx = destCtxForIface(opts.topo, opts.serverId, opts.inIface, {
outIface: opts.outIface,
natSrc: opts.natSrc,
natDst: opts.natDst,
natSrcPort: opts.natSrcPort,
@@ -12,6 +12,7 @@ import * as accumulator from "./traffic-flow-fact-accumulator.js"
import * as serial from "./serial-operation.js"
import * as parse from "./traffic-flow-parse.js"
import * as ip from "./traffic-flow-ip.js"
import * as ifindex from "./traffic-flow-ifindex.js"
import { pruneRipeSqlite } from "./traffic-flow-ripe.js"
import { PARTITION_WRITER_ADVISORY_KEY } from "./partition-write-transaction.js"
@@ -51,7 +52,7 @@ const dependencies:Record<string,unknown>={
"./traffic-flow-ripe.js":{enqueueRipeMisses:()=>{throw Error("unexpected RIPE enqueue")},pruneRipeSqlite},
"./traffic-flow-settings.js":{invalidateTrafficFlowSettingsCache:()=>{}},
"./traffic-flow-ifaces.js":{maybeRefreshIfaces:async()=>{}},
"./traffic-flow-ifindex.js":{canonicalFactIface:(_server:number,iface:string)=>iface},
"./traffic-flow-ifindex.js":ifindex,
"./traffic-flow-facts-filter.js":{shouldWriteFlowFact:()=>true},
"./traffic-flow-dest.js":{flowRateDirection:()=>"tx",resolveInternetDest:()=>({dest:"",ripe:null,classified:{category:"web",service:"https"},country:"XX",asn:0})},
"./traffic-flow-topology.js":{peekFlowTopology:()=>({}),peekServerCatalog:()=>({byId:new Map([[1,{type:"router"}]])}),getServerCatalog:()=>{throw Error("unexpected catalog SQL")},loadFlowTopology:()=>{throw Error("unexpected topology SQL")}},
+29 -3
View File
@@ -15,7 +15,7 @@ import { applicationName } from "./traffic-flow-apps.js"
import { enqueueRipeMisses, pruneRipeSqlite } from "./traffic-flow-ripe.js"
import { invalidateTrafficFlowSettingsCache } from "./traffic-flow-settings.js"
import { maybeRefreshIfaces } from "./traffic-flow-ifaces.js"
import { canonicalFactIface } from "./traffic-flow-ifindex.js"
import { canonicalFactIface, resolveIfaceName } from "./traffic-flow-ifindex.js"
import { shouldWriteFlowFact } from "./traffic-flow-facts-filter.js"
import { canonicalIp } from "./traffic-flow-ip.js"
import { flowRateDirection, resolveInternetDest } from "./traffic-flow-dest.js"
@@ -44,6 +44,9 @@ export const MAX_PENDING = 50_000
export const DAILY_ASN_TOP = 500
export const DAILY_RETENTION_DAYS = 396
export const MINUTE_RETENTION_HOURS = 48
export const OBSERVED_FLOW_IFACE_DIM = "observed-iface-v1"
export const OBSERVED_FLOW_IFACE_COVERAGE_DIM = "observed-iface-coverage-v1"
export const ADMITTED_FLOW_DAY_DIM = "admitted-v1"
let pendingCap = MAX_PENDING
const ensuredParts = new Set<string>()
@@ -431,11 +434,25 @@ export function queueParsedFlows(serverId: number, flows: ParsedFlowInput[]): vo
for (const raw of flows) {
const flow = normalizeParsedFlow(raw)
const destMeta = resolveInternetDest({src:flow.src,dst:flow.dst,proto:flow.proto,srcPort:flow.srcPort,dstPort:flow.dstPort,
serverId,inIface:flow.inIface,topo,natSrc:flow.natSrc,natDst:flow.natDst,natSrcPort:flow.natSrcPort,natDstPort:flow.natDstPort})
serverId,inIface:flow.inIface,outIface:flow.outIface,topo,natSrc:flow.natSrc,natDst:flow.natDst,natSrcPort:flow.natSrcPort,natDstPort:flow.natDstPort})
const classified=destMeta.classified,country=destMeta.country
const seenIfaces = new Map<string, string>()
let interfaceUncertain = false
for (const rawIface of [flow.inIface, flow.outIface]) {
const {name, index} = resolveIfaceName(serverId, rawIface)
if (name === "—") continue
if (index && name === `#${index}`) interfaceUncertain = true
if (index || !seenIfaces.has(name)) seenIfaces.set(name, index ? String(Number(index)) : name)
}
// A cold index can be an alias of another endpoint. Keep that minute out of complete interface totals.
const observedDimensions = interfaceUncertain ? [] : [
{dim:OBSERVED_FLOW_IFACE_COVERAGE_DIM,key:"all"},
...[...seenIfaces.values()].map(key => ({dim:OBSERVED_FLOW_IFACE_DIM,key})),
]
const dims=[{dim:"proto",key:protoName(flow.proto)},{dim:"app",key:applicationName(flow.proto,flow.dstPort,flow.srcPort)},
{dim:"iface",key:flow.inIface||"__unknown__"},{dim:"category",key:classified.category},{dim:"service",key:classified.service},
...(country?[{dim:"country",key:country}]:[]),{dim:"asn",key:destMeta.asn?String(destMeta.asn):"unknown"}].map(row=>({...row,cacheKey:dimKey(serverId,bucketAt,row.dim,row.key)}))
...observedDimensions,
{dim:"country",key:country||"unknown"},{dim:"asn",key:destMeta.asn?String(destMeta.asn):"unknown"}].map(row=>({...row,cacheKey:dimKey(serverId,bucketAt,row.dim,row.key)}))
const fact:FactRow|null=shouldWriteFlowFact({serverId,serverType,inIface:flow.inIface,outIface:flow.outIface,proto:flow.proto,
srcPort:flow.srcPort,dstPort:flow.dstPort,src:flow.src,dst:flow.dst,topo,dest:destMeta.dest,
natSrc:flow.natSrc,natDst:flow.natDst,natSrcPort:flow.natSrcPort,natDstPort:flow.natDstPort})?
@@ -751,6 +768,15 @@ async function upsertMinuteAndDaily(rollup:Map<string,MinuteRollup>,dims:Map<str
uniqueDst: acc.dsts.size,
conversations: acc.conversations,
})
const day = dayKey(bucketAt ?? "")
await ensureParentPartition("flow_daily_dims", day)
await dbQuery(`
INSERT INTO flow_daily_dims (server_id, day, dim, key, bytes, packets)
VALUES (?, ?, ?, 'all', ?, ?)
ON CONFLICT(server_id, day, dim, key) DO UPDATE SET
bytes = flow_daily_dims.bytes + excluded.bytes,
packets = flow_daily_dims.packets + excluded.packets
`, [Number(serverIdRaw), day, ADMITTED_FLOW_DAY_DIM, acc.bytes, acc.packets])
}
for (const [k, acc] of dims) {
const [serverIdRaw, bucketAt, dim, key] = k.split("\0")
@@ -115,6 +115,7 @@ export function shouldWriteFlowFact(opts: {
opts.srcPort,
opts.dstPort,
destCtxForIface(opts.topo, opts.serverId, inName, {
outIface: outName,
natSrc: opts.natSrc,
natDst: opts.natDst,
natSrcPort: opts.natSrcPort,
@@ -12,19 +12,35 @@ function source(names:string[]):string {
}
function fixture() {
const original=Error("original ring validation"),ackError=Error("original transport failure"),events:string[]=[]
let badRing=false,badAck=false,quality:unknown=null
let badRing=false,badAck=false,quality:unknown=null,now=0
const run=new Function("deps",`
const exports={},flowIngestQualitySchema=deps.schema,HEARTBEAT_UNAVAILABLE="unavailable";
let lastHeartbeat=null,heartbeatFailure=null,state={bound:false,address:null},restartAttempts=4,worker={};
const FLOW_HEARTBEAT_MAX_AGE_MS=15000,performance={now:deps.now};
let lastHeartbeat=null,lastHeartbeatAt=-Infinity,heartbeatFailure=null,state={bound:false,address:null},restartAttempts=4,worker={};
const applyRingSnapshot=deps.consume,markFlowRingSnapshotUnavailable=deps.invalidate,postToWorker=deps.send;
const getEngineStats=()=>({pendingSize:0,dropped:0,packetsReceived:0});
const getTrafficFlowSettingsRow=async()=>({packetsReceived:77,lastExporterIp:null,lastError:null,lastDatagramAt:null});
${source(["applyWorkerHeartbeat","rejectWorkerHeartbeat","handleWorkerMessage","getFlowWorkerHealth","getFlowRuntimeCounters","applyHeartbeatForTests"])}
${source(["applyWorkerHeartbeat","rejectWorkerHeartbeat","handleWorkerMessage","getFlowListenerState","hasCurrentFlowHeartbeat","getFlowWorkerHealth","getFlowRuntimeCounters","applyHeartbeatForTests"])}
return {receive:handleWorkerMessage,local:applyHeartbeatForTests,inspect:()=>({lastHeartbeat,heartbeatFailure,state}),health:getFlowWorkerHealth,counters:getFlowRuntimeCounters};
`)({schema:flowIngestQualitySchema,consume:(_rows:unknown,data:unknown)=>{events.push("consume");if(badRing)throw original;quality=data},invalidate:()=>{events.push("invalidate");quality=null},send:()=>{events.push("ack");if(badAck)throw ackError}})
`)({now:()=>now,schema:flowIngestQualitySchema,consume:(_rows:unknown,data:unknown)=>{events.push("consume");if(badRing)throw original;quality=data},invalidate:()=>{events.push("invalidate");quality=null},send:()=>{events.push("ack");if(badAck)throw ackError}})
const payload=(packetsReceived=11)=>({bound:true,address:"127.0.0.1:2055",packetsReceived,lastExporterIp:"127.0.0.1",lastError:"",lastDatagramAt:"2026-10-29T10:00:00.000Z",pendingSize:1,dropped:0,rowsStored:1,workerAlive:true,rings:[],dataQuality:createFlowIngestQuality().snapshot()})
return {run,payload,events,original,ackError,ring:(value:boolean)=>{badRing=value},ack:(value:boolean)=>{badAck=value},quality:()=>quality}
return {run,payload,events,original,ackError,ring:(value:boolean)=>{badRing=value},ack:(value:boolean)=>{badAck=value},quality:()=>quality,advance:(ms:number)=>{now+=ms}}
}
test("a stale heartbeat keeps the last observed counters but cannot report a live listener", async () => {
const f = fixture()
f.run.receive({type:"heartbeat",heartbeatId:"first",payload:f.payload()})
assert.equal((await f.run.counters()).collectorCountersSource, "live")
f.advance(15_001)
assert.equal(f.run.health().bound, false)
assert.equal(f.run.health().alive, false)
const counters = await f.run.counters()
assert.equal(counters.packetsReceived, 11)
assert.equal(counters.collectorCountersSource, "last-known")
assert.equal(counters.dataQuality, null)
f.run.receive({type:"heartbeat",heartbeatId:"next",payload:f.payload(12)})
assert.equal(f.run.health().bound, true)
assert.equal((await f.run.counters()).collectorCountersSource, "live")
})
test("ring refusal is caught, marks observation unavailable, preserves original error/counters and ACKs consumption",async()=>{
const f=fixture();f.run.receive({type:"heartbeat",heartbeatId:"first",payload:f.payload()});f.events.length=0;f.ring(true)
assert.doesNotThrow(()=>f.run.receive({type:"heartbeat",heartbeatId:"bad",payload:f.payload(999)}))
@@ -11,6 +11,7 @@ import {
getFlowListenerState,
getFlowRuntimeCounters,
getFlowWorkerHealth,
readTrafficFlowSettingsStatus,
ingestParsedFlowsForServerForTests,
lastFlushUsedTransactionForTests,
maybeRefreshIfaces,
@@ -148,10 +149,16 @@ applyHeartbeatForTests({
})
assert.equal(getFlowListenerState().bound, true)
assert.equal((await getFlowRuntimeCounters()).packetsReceived, 42)
assert.equal((await getFlowRuntimeCounters()).collectorCountersSource, "live")
const settingsStatus = await readTrafficFlowSettingsStatus()
assert.equal(settingsStatus.collectorCountersSource, "live")
assert.equal(settingsStatus.packetsReceived, 42)
assert.equal(settingsStatus.listenerBound, true)
assert.equal(getFlowWorkerHealth().alive, false)
setWantListenForTests(true)
assert.equal(simulateWorkerExitForTests(), 1)
assert.equal(getFlowListenerState().bound, false)
assert.equal((await getFlowRuntimeCounters()).collectorCountersSource, "last-known")
setWantListenForTests(false)
resetFlowRingsForTests()
+34 -10
View File
@@ -40,6 +40,7 @@ import {
getTrafficFlowSettingsRow,
listHostPeers,
invalidateTrafficFlowSettingsCache,
toTrafficFlowSettingsDto,
} from "./traffic-flow-settings.js"
import { projectFlowTalkers } from "./traffic-flow-talkers-model.js"
import { resolveIfaceName } from "./traffic-flow-ifaces.js"
@@ -67,7 +68,9 @@ let listenerGeneration=0
let restartTimer: ReturnType<typeof setTimeout> | null = null
let restartAttempts = 0
let lastHeartbeat: CollectorHeartbeat | null = null
let lastHeartbeatAt = -Infinity
let heartbeatFailure:Error|null=null
const FLOW_HEARTBEAT_MAX_AGE_MS = 15_000
const HEARTBEAT_UNAVAILABLE="NetFlow: недостоверный снимок коллектора; наблюдения недоступны"
let state: FlowListenerState = { bound: false, address: null }
let wantListen = false
@@ -127,6 +130,7 @@ function applyWorkerHeartbeat(payload: CollectorHeartbeat): void {
const dataQuality=payload.dataQuality==null?null:flowIngestQualitySchema.parse(payload.dataQuality)
applyRingSnapshot(payload.rings,dataQuality)
lastHeartbeat = {...payload,dataQuality,rings:[]}
lastHeartbeatAt = performance.now()
heartbeatFailure=null
state = { bound: payload.bound, address: payload.address }
restartAttempts = 0
@@ -151,7 +155,7 @@ function handleWorkerMessage(msg: WorkerToMain): void {
}
if (msg.type === "error") {
lastHeartbeat = lastHeartbeat
? { ...lastHeartbeat, lastError: msg.payload.message, workerAlive: true }
? { ...lastHeartbeat, lastError: msg.payload.message }
: null
}
}
@@ -215,6 +219,7 @@ async function spawnWorker(authorize?: FlowLifecycleAuthorization): Promise<void
if (worker !== w) return
worker = null
state = { bound: false, address: null }
if (lastHeartbeat) lastHeartbeat = { ...lastHeartbeat, workerAlive: false, bound: false }
if (!wantListen || startupPending) return
const delay = Math.min(30_000, 1000 * 2 ** restartAttempts)
restartAttempts += 1
@@ -250,6 +255,7 @@ function stopWorkerProcess(authorize?: FlowLifecycleAuthorization): void {
// The sync public stop returns immediately; starts and DB operations drain it.
void workerLifecycle.retire(current,authorize)
worker = null
if (lastHeartbeat) lastHeartbeat = { ...lastHeartbeat, workerAlive: false, bound: false }
}
}
@@ -275,15 +281,19 @@ export function setWantListenForTests(value: boolean): void {
}
export function getFlowListenerState(): FlowListenerState {
return state
return state.bound && !hasCurrentFlowHeartbeat() ? { bound: false, address: null } : state
}
function hasCurrentFlowHeartbeat(): boolean {
return Boolean(lastHeartbeat?.workerAlive) && heartbeatFailure === null && performance.now() - lastHeartbeatAt <= FLOW_HEARTBEAT_MAX_AGE_MS
}
export function getFlowWorkerHealth(): FlowWorkerHealth {
const hb = lastHeartbeat
const mem = getEngineStats()
return {
alive: heartbeatFailure===null&&Boolean(worker) && (hb?.workerAlive ?? false),
bound: state.bound,
alive: Boolean(worker) && hasCurrentFlowHeartbeat(),
bound: getFlowListenerState().bound,
pendingSize: hb?.pendingSize ?? mem.pendingSize,
dropped: hb?.dropped ?? mem.dropped,
packetsReceived: hb?.packetsReceived ?? mem.packetsReceived,
@@ -293,17 +303,20 @@ export function getFlowWorkerHealth(): FlowWorkerHealth {
export async function getFlowRuntimeCounters() {
const hb = lastHeartbeat
if (hb) {
const current = hasCurrentFlowHeartbeat()
return {
collectorCountersSource: current ? "live" as const : "last-known" as const,
packetsReceived: hb.packetsReceived,
lastExporterIp: hb.lastExporterIp ?? null,
lastError: heartbeatFailure?HEARTBEAT_UNAVAILABLE:hb.lastError || null,
lastError: heartbeatFailure || hb.workerAlive && !current ? HEARTBEAT_UNAVAILABLE : hb.lastError || null,
lastDatagramAt: hb.lastDatagramAt ?? null,
dropped: hb.dropped ?? 0,
dataQuality:hb.dataQuality??null,
dataQuality:current ? hb.dataQuality ?? null : null,
}
}
const settings = await getTrafficFlowSettingsRow()
return {
collectorCountersSource: "last-known" as const,
packetsReceived: settings.packetsReceived,
lastExporterIp: settings.lastExporterIp ?? null,
lastError: heartbeatFailure?HEARTBEAT_UNAVAILABLE:settings.lastError || null,
@@ -313,6 +326,13 @@ export async function getFlowRuntimeCounters() {
}
}
export async function readTrafficFlowSettingsStatus() {
const settings = await toTrafficFlowSettingsDto(getFlowListenerState())
const { packetsReceived, lastExporterIp, lastError, lastDatagramAt, dataQuality, collectorCountersSource } = await getFlowRuntimeCounters()
const { bound, address } = getFlowListenerState()
return { ...settings, packetsReceived, lastExporterIp, lastError, lastDatagramAt, dataQuality, collectorCountersSource, listenerBound: bound, listenerAddress: address }
}
export async function startTrafficFlowListener(authorize?: FlowLifecycleAuthorization) {
if (databaseStop) throw new Error("NetFlow listener is paused for a database operation")
// Fence the internal stop and flush separately. The ordinary synchronous stop
@@ -546,18 +566,21 @@ export async function listStoredFlowRows(sinceIso: string, serverId?: number, op
}
export async function listFlowRowsForWindow(minutes: number, serverId?: number, options?: { maxRows?: number; untilIso?: string }): Promise<PendingFlowRow[]> {
const sinceIso = new Date(Date.now() - minutes * 60_000).toISOString()
const end = options?.untilIso === undefined ? Date.now() : Date.parse(options.untilIso)
if (!Number.isFinite(end)) throw new Error("Некорректная граница flow window")
const sinceIso = new Date(end - minutes * 60_000).toISOString()
// History remains available while the collector starts or is stopped; pending rows are merged below.
return await listStoredFlowRows(sinceIso, serverId, options)
}
export async function listFlowTalkers(minutes = 5): Promise<FlowStatsDto> {
const settings = await getTrafficFlowSettingsRow()
const runtime = await getFlowRuntimeCounters()
const rows = await listFlowRowsForWindow(minutes, undefined, { untilIso: new Date().toISOString() })
const catalog = await getServerCatalog()
const nameById = new Map([...catalog.byId].map(([id, server]) => [id, server.name]))
const projection = projectFlowTalkers(rows, minutes, settings.topN, nameById, resolveIfaceName)
const runtime = await getFlowRuntimeCounters()
const listener = getFlowListenerState()
return {
exportersOnline: projection.observedExporters,
bytesPerMin: projection.bytesPerMin,
@@ -566,12 +589,13 @@ export async function listFlowTalkers(minutes = 5): Promise<FlowStatsDto> {
topProto: projection.topProto,
talkers: projection.talkers,
dataQuality:runtime.dataQuality,
collectorCountersSource: runtime.collectorCountersSource,
lastExporterIp: runtime.lastExporterIp,
lastError: runtime.lastError,
packetsReceived: runtime.packetsReceived,
lastDatagramAt: runtime.lastDatagramAt,
listenerBound: state.bound,
listenerAddress: state.address,
listenerBound: listener.bound,
listenerAddress: listener.address,
}
}
@@ -296,6 +296,8 @@ try {
resetFlowMapHopsCacheForTests()
const six = await buildFlowMapHops({ minutes: 5, minSharePct: 5 })
assert.equal(six.totalBytes, 10_000)
const byEgress = await buildFlowMapHops({ minutes: 5, serverId: 7, iface: "gre-jh-en", minSharePct: 5 })
assert.equal(byEgress.totalBytes, six.totalBytes)
assert.equal(six.namedBytes, 600)
assert.equal(six.unclassifiedBytes, 9400)
const google = six.services?.find((s) => s.id === "svc:google")
@@ -317,6 +319,11 @@ try {
const usPath = six.countryPaths?.find((p) => p.serviceId === "cc:us" && p.enId === "9")
assert.ok(usPath)
assert.equal(usPath.clientName, "Alice")
ingestParsedFlowsForServerForTests(7, [{ ...payloadFlow("8.8.8.8", 2000), proto: 17, dstPort: 51820 }])
const mixedPeer = await buildFlowMapHops({ minutes: 5, serverId: 7, excludeOverlay: false })
assert.equal(mixedPeer.totalBytes, 12_000)
assert.equal(mixedPeer.namedBytes, 600, "WireGuard to the same peer is separate from the HTTPS service")
} finally {
resetFlowRingsForTests()
resetIfaceCacheForTests()
+27 -12
View File
@@ -8,11 +8,11 @@ import { flowRowMatchesFilter } from "./traffic-flow-apps.js"
import { OTHER_SERVICE, isNamedInternetService, mapCountryNodeId, mapCountryServiceNodeId, mapServiceNodeId, resolveRipeCountry } from "./traffic-flow-brands.js"
import type { FlowIpMeta } from "./traffic-flow-ripe.js"
import { refreshFlowCatalogInBackground } from "./traffic-flow-classify.js"
import { dedupFlowRowsAcrossExporters, dedupFlowRowsMaxBytes } from "./traffic-flow-dedup.js"
import { collapseGreEspRows, dedupFlowRowsAcrossExporters, dedupFlowRowsMaxBytes } from "./traffic-flow-dedup.js"
import { getFlowListenerState, listFlowRowsForWindow } from "./traffic-flow-ingest.js"
import { resolveIfaceName } from "./traffic-flow-ifaces.js"
import { classifyFlowPlane, shouldKeepPlane } from "./traffic-flow-planes.js"
import { destCtxForIface, mapInternetBrand } from "./traffic-flow-dest.js"
import { destCtxForIface, flowRateDirection, mapInternetBrand } from "./traffic-flow-dest.js"
import { resolveFlowEndpoints } from "./traffic-flow-ip.js"
import { geoipReadersStatus, resolveFlowIp } from "./traffic-flow-geoip.js"
import { getTrafficFlowSettingsRow } from "./traffic-flow-settings.js"
@@ -65,6 +65,7 @@ interface FromAcc {
}
interface DstAcc {
dst: string
bytes: number
proto: number
dstPort: number
@@ -316,7 +317,7 @@ function buildCountryServiceGroups(
}
function countryDestFromRipe(ripe: FlowIpMeta | null, destKey: string): { id: string; label: string; category: string } {
if (!destKey || destKey === "__other__" || !ripe?.ok) {
if (!destKey || !ripe?.ok) {
return { id: mapCountryNodeId(""), label: OTHER_SERVICE, category: MAP_COUNTRY_CATEGORY }
}
const iso = resolveRipeCountry(ripe.country, ripe.asn, ripe.holder)
@@ -440,11 +441,20 @@ async function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number
}
}
const matches = (serverId: number, iface: string) =>
flowRowMatchesFilter({ serverId, inIface: iface }, resolveIfaceName(serverId, iface).name, q, allow)
const selected = raw.filter(r => matches(r.serverId, r.inIface) || matches(r.serverId, r.outIface))
const { rows } = collapseGreEspRows(selected, r => {
if (ifaceFilter) {
const ingress = matches(r.serverId, r.inIface), egress = matches(r.serverId, r.outIface)
return ingress === egress ? null : ingress ? "rx" : "tx"
}
return flowRateDirection(r.serverId, r, topo, catalog.byId.get(r.serverId)?.host)
})
const matched = []
for (const r of raw) {
for (const r of rows) {
const resolved = resolveIfaceName(r.serverId, r.inIface)
const outResolved = resolveIfaceName(r.serverId, r.outIface)
if (!flowRowMatchesFilter(r, resolved.name, q, allow)) continue
const plane = classifyFlowPlane({
src: r.src,
dst: r.dst,
@@ -578,14 +588,17 @@ async function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number
srcPort: r.srcPort,
dstPort: r.dstPort,
ctx: destCtxForIface(topo, r.serverId, inName, {
outIface: outName,
natSrc: r.natSrc,
natDst: r.natDst,
natSrcPort: r.natSrcPort,
natDstPort: r.natDstPort,
}),
})
const dest = ep.internetPeer
const destKey = dest || "__other__"
const dst = ep.internetPeer
const dstPort = ep.peerPort || r.dstPort
const srcPort = ep.otherPort || r.srcPort
const destKey = dst ? JSON.stringify([dst, r.proto, dstPort, srcPort]) : ""
const client = resolveMapClient(topo, r.serverId, inName, outName)
const prevDst = dstAcc.get(destKey)
if (prevDst) {
@@ -593,10 +606,11 @@ async function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number
bumpFrom(prevDst, String(r.serverId), r.bytes, client)
} else {
const acc: DstAcc = {
dst,
bytes: r.bytes,
proto: r.proto,
dstPort: ep.peerPort || r.dstPort,
srcPort: ep.otherPort || r.srcPort,
dstPort,
srcPort,
fromBytes: new Map(),
}
bumpFrom(acc, String(r.serverId), r.bytes, client)
@@ -644,9 +658,10 @@ async function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number
return id
}
for (const [dst, acc] of dstAcc) {
const ripe = dst && dst !== "__other__" ? resolveFlowIp(dst) : null
const classified = dst && dst !== "__other__"
for (const acc of dstAcc.values()) {
const { dst } = acc
const ripe = dst ? resolveFlowIp(dst) : null
const classified = dst
? mapInternetBrand(dst, acc.proto, acc.dstPort, acc.srcPort, ripe)
: { service: OTHER_SERVICE, category: OTHER_SERVICE }
const svcId = mapServiceNodeId(classified.service)
@@ -9,6 +9,7 @@ import { applySqlMigrations } from '../db/migrate.js'
import { ensurePartitionFor } from '../db/partitions.js'
import { createMcpConnection,updateMcpSettings,setConnectionStatus } from '../modules/mcp/store.js'
import { mcpConnectionCreateSchema } from '@mmapp/contracts/mcp'
import type { FlowAnalyticsDto } from '@mmapp/contracts/traffic-flow'
import mcpTransport from '../routes/mcp-transport.js'
import trafficFlowRoutes from '../routes/traffic-flow.js'
import logsRoutes from '../routes/logs.js'
@@ -16,6 +17,8 @@ import trafficRoutes from '../routes/traffic.js'
import { flowReadBudget } from './traffic-flow-read-policy.js'
import { resetFlowRingsForTests,applyHeartbeatForTests } from './traffic-flow-ingest.js'
import { createFlowIngestQuality } from './traffic-flow-ingest-quality.js'
import { queueParsedFlows, strictDrainEngine } from './traffic-flow-engine.js'
import { rememberServerIfaces } from './traffic-flow-ifindex.js'
import { disableRipeEnqueueForTests } from './traffic-flow-ripe.js'
import { readFlowCatalogWindow } from './traffic-flow-catalog-read.js'
import { invalidateFlowAnalyticsCache } from './traffic-flow-analytics.js'
@@ -167,6 +170,99 @@ try{
invalidateFlowAnalyticsCache()
}
console.log('PASS five-minute REST analysis uses one latest counter per interface despite 50,010 historical samples')
const overlayBucket = new Date(Math.floor(Date.now()/60000)*60000-120000)
await ensurePartitionFor(pool,'flow_buckets','day',overlayBucket)
await pool.query(`INSERT INTO flow_buckets(server_id,bucket_at,src,dst,proto,src_port,dst_port,bytes,packets,in_iface,out_iface) VALUES
(1,$1,'192.0.2.1','203.0.113.9',47,0,0,12000,10,'gre-test','ether1'),
(1,$1,'192.0.2.1','203.0.113.9',50,0,0,12400,10,'ether1','ether1'),
(1,$1,'203.0.113.9','192.0.2.1',47,0,0,24000,20,'ether1','gre-test'),
(1,$1,'203.0.113.9','192.0.2.1',50,0,0,24800,20,'ether1','ether1'),
(1,$1,'203.0.113.10','192.0.2.1',47,0,0,1000,1,'ether1','gre-other'),
(1,$1,'203.0.113.11','203.0.113.12',50,0,0,2000,2,'ether1','ether1')`,[overlayBucket])
try {
const args={serverId:1,interface:'ether1',dedup:false,excludeOverlay:false}
const rest=await fetch(endpoint+'/api/traffic/flow/analytics?range=5m&serverId=1&iface=ether1&dedup=false&excludeOverlay=false')
assert.equal(rest.status,200,await rest.clone().text())
const filtered=await client.callTool({name:'mm_netflow_analytics_report_get',arguments:{...args,minutes:5}})
const live=await client.callTool({name:'mm_netflow_live_observe',arguments:args})
assert.ok(!filtered.isError,JSON.stringify(filtered))
assert.ok(!live.isError,JSON.stringify(live))
const mcp=(filtered.structuredContent as {result:{analytics:FlowAnalyticsDto}}).result.analytics
const sample=(live.structuredContent as {result:{events:{data:FlowAnalyticsDto}[]}}).result.events[0].data
const fromSeries=(series:number[])=>Math.round(series.reduce((sum,value)=>sum+value,0)*60*1e6/8)
for(const analytics of [await rest.json() as FlowAnalyticsDto,mcp,sample]){
assert.equal(analytics.bytes,40300,'Each overlay packet sequence contributes only the ESP bytes')
assert.equal(analytics.bytesOverlay,40200,'Plain GRE and undirected ESP remain part of the volume')
assert.equal(fromSeries(analytics.rxSeries),25900)
assert.equal(fromSeries(analytics.txSeries),12400)
assert.deepEqual(analytics.interfaces.map(row=>[row.id,row.bytes]),[['ether1',40300]])
assert.ok(analytics.conversationsList.every(row=>row.accountedIface==='ether1'))
for(const rows of [analytics.applications,analytics.categories,analytics.services,analytics.asns,analytics.countries,
analytics.mapEdges,analytics.protocols,analytics.sources,analytics.destinations,analytics.paths,analytics.conversationsList]){
assert.equal(rows?.reduce((sum,row)=>sum+row.bytes,0),analytics.bytes)
}
}
assert.equal(sample.bpsOverlay,40200*8/300)
}finally{
await pool.query("DELETE FROM flow_buckets WHERE server_id=1 AND bucket_at=$1 AND proto IN (47,50)",[overlayBucket])
invalidateFlowAnalyticsCache()
}
console.log('PASS REST and MCP history and live analytics collapse GRE/ESP and place each confirmed ESP direction once')
const completedMinute=Math.floor(Date.now()/60000)*60000-180000
rememberServerIfaces(1,[{name:'ether-audit',ifindex:'77'}])
const wallClock=Date.now
try {
Date.now=()=>completedMinute+1000
queueParsedFlows(1,Array.from({length:211},(_,i)=>({
src:'192.0.2.1',dst:'198.18.1.1',proto:6,srcPort:1000+i,dstPort:443,
bytes:i<200?100:10,packets:1,inIface:i===210?'ether-audit':'ether-heavy',outIface:i<200?'vxlan':'77',
})))
} finally {Date.now=wallClock}
await strictDrainEngine(async()=>{},[1])
const analyticsUrl=endpoint+'/api/traffic/flow/analytics?range=5m&serverId=1&excludeOverlay=false'
const ifaceUrl=analyticsUrl+'&iface=ether-audit'
const readAnalytics=async(url:string)=>{
const response=await fetch(url)
assert.equal(response.status,200,await response.clone().text())
return await response.json() as FlowAnalyticsDto
}
const admitted=await readAnalytics(analyticsUrl)
assert.equal(admitted.timeBasis,'collector-receipt')
assert.equal(admitted.admittedTotals?.bytes,20110,'the minute aggregate includes every admitted record beyond top-N')
assert.equal(admitted.admittedTotals?.packets,211)
const smallInterface=await readAnalytics(ifaceUrl)
assert.equal(smallInterface.bytes,0,'all detail rows for the small interface are below top-N')
assert.equal(smallInterface.admittedTotals?.bytes,110,'egress is included and the same ingress/egress interface is counted once')
assert.equal(smallInterface.admittedTotals?.packets,11)
const aggregateReport=await client.callTool({name:'mm_netflow_analytics_report_get',arguments:{serverId:1,minutes:5,interface:'ether-audit'}})
assert.ok(!aggregateReport.isError,JSON.stringify(aggregateReport))
assert.equal((aggregateReport.structuredContent as {result:{analytics:FlowAnalyticsDto}}).result.analytics.admittedTotals?.bytes,110)
await pool.query("UPDATE flow_minute_stats SET bytes=bytes+1 WHERE server_id=1 AND bucket_at=$1",[new Date(completedMinute)])
invalidateFlowAnalyticsCache()
assert.equal((await readAnalytics(ifaceUrl)).admittedTotals,undefined,'mixed old/new writes in one minute must not look complete')
assert.equal((await readAnalytics(analyticsUrl)).admittedTotals?.bytes,20111)
const writerMonth=new Date(completedMinute).toISOString().slice(0,7)
const authoritativeMonthly=await fetch(endpoint+'/api/traffic/flow/monthly?month='+writerMonth+'&serverId=1')
assert.equal(authoritativeMonthly.status,200,await authoritativeMonthly.clone().text())
const auditedMonth=await authoritativeMonthly.json() as {bytes:number;totalsSource:string}
assert.equal(auditedMonth.bytes,20110)
assert.equal(auditedMonth.totalsSource,'admitted-daily')
const monthBucket=new Date('2026-09-01T00:00:00Z')
await ensurePartitionFor(pool,'flow_daily_dims','month',monthBucket)
await pool.query(`INSERT INTO flow_daily_dims(server_id,day,dim,key,bytes,packets) VALUES
(1,$1,'country','US',80,8),(1,$1,'country','unknown',20,2),
(1,$1,'service','web',120,12),(1,$1,'asn','unknown',200,20),(2,$1,'asn','unknown',900,90),
(1,$1::date+1,'service','web',40,4)`,[monthBucket])
const monthly=await fetch(endpoint+'/api/traffic/flow/monthly?month=2026-09&serverId=1')
assert.equal(monthly.status,200,await monthly.clone().text())
const monthlyDto=await monthly.json() as {bytes:number;totalsSource:string;countries:{id:string;bytes:number;packets:number}[]}
assert.equal(monthlyDto.bytes,240)
assert.equal(monthlyDto.totalsSource,'legacy-dimensions')
assert.equal(monthlyDto.countries.find(row=>row.id==='unknown')?.bytes,160)
assert.equal(monthlyDto.countries.find(row=>row.id==='unknown')?.packets,16)
console.log('PASS complete archived and per-interface totals survive top-N, mixed legacy minutes stay partial, and monthly unknown geography is counted')
const globalAccess=await createMcpConnection(mcpConnectionCreateSchema.parse({name:'owned global telemetry',mode:'observer',permissions:['mm:traffic:read'],expiresAt:new Date(Date.now()+600000).toISOString(),scope:{serverIds:[1],operationIds:['traffic.flow.talkers.read','netflow.settings.read'],allowGlobal:true},limits:{callsPerMinute:240}}),actor)
const globalClient=new Client({name:'owned-global-quality',version:'1'})
try{
+24 -10
View File
@@ -4,7 +4,7 @@ import { serverSnapshots, type Server } from "../db/schema.js"
import { readServerSamplesInRange, type TrafficHistoryReadOptions } from "./traffic-collector.js"
import { readTrafficCollectionContext } from "./traffic-collection-state.js"
import { applyTrafficFreshness } from "./traffic-freshness.js"
import { buildTrafficFromSamples, isLoopbackName } from "./traffic-rate.js"
import { buildTrafficFromSamples, isLoopbackName, trafficHistoryBoundaryLimitMs } from "./traffic-rate.js"
export type TrafficHistoryServer = Pick<Server, "id" | "name" | "host" | "site" | "country" | "enabled" | "updatedAt">
type CollectionContext = Awaited<ReturnType<typeof readTrafficCollectionContext>>
@@ -12,25 +12,39 @@ type CollectionContext = Awaited<ReturnType<typeof readTrafficCollectionContext>
/** Shared application interpretation of stored counter deltas; no device polling. */
export async function readServerTrafficHistory(server: TrafficHistoryServer, rangeStartMs: number, rangeEndMs: number, onlyInterface?: string,
options: TrafficHistoryReadOptions = {}, context?: CollectionContext) {
const [rows, snapshots, collection] = await Promise.all([
readServerSamplesInRange(server.id, new Date(rangeStartMs).toISOString(), { ...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString() }),
return (await readServerTrafficHistoryWithSeries(server, rangeStartMs, rangeEndMs, onlyInterface, options, context)).history
}
export async function readServerTrafficHistoryWithSeries(server: TrafficHistoryServer, rangeStartMs: number, rangeEndMs: number, onlyInterface?: string,
options: TrafficHistoryReadOptions = {}, context?: CollectionContext) {
const collection = context ?? await readTrafficCollectionContext([server.id])
const boundaryLimitMs = trafficHistoryBoundaryLimitMs(collection.settings?.intervalSec)
const [rows, snapshots] = await Promise.all([
readServerSamplesInRange(server.id, new Date(rangeStartMs).toISOString(), {
...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString(),
interfaceNames: onlyInterface === undefined ? undefined : [onlyInterface], interfaceCountersOnly: true,
precedingMaxIntervalMs: boundaryLimitMs,
}),
db.select({ status: serverSnapshots.status, polledAt: serverSnapshots.polledAt }).from(serverSnapshots).where(eq(serverSnapshots.serverId, server.id)).orderBy(desc(serverSnapshots.polledAt)).limit(1),
context ?? readTrafficCollectionContext([server.id]),
])
const built = buildTrafficFromSamples(rows, rangeStartMs, rangeEndMs, onlyInterface, undefined, true)
const series = buildTrafficFromSamples(rows, rangeStartMs, rangeEndMs, onlyInterface, undefined, true, boundaryLimitMs)
if (series.observations) series.observations = applyTrafficFreshness(series.observations, server, collection.settings, collection.states.get(server.id), rangeEndMs)
const status = snapshots[0]?.status === "offline" ? "offline" as const : snapshots[0]?.status === "online" ? "online" as const : "degraded" as const
return {
const history = {
volumeUnit: "GiB" as const, id: String(server.id), name: server.name || server.host, site: server.site || "—", country: server.country || "UN", status,
observations: built.observations && applyTrafficFreshness(built.observations, server, collection.settings, collection.states.get(server.id), rangeEndMs),
rxNow: built.rxNow, txNow: built.txNow, rxPeak: built.rxPeak, txPeak: built.txPeak,
rxTotal: built.rxTotalGiB, txTotal: built.txTotalGiB, sessions: built.sessions, rxSeries: built.rxSeries, txSeries: built.txSeries,
observations: series.observations,
rxNow: series.rxNow, txNow: series.txNow, rxPeak: series.rxPeak, txPeak: series.txPeak,
rxTotal: series.rxTotalGiB, txTotal: series.txTotalGiB, sessions: series.sessions, rxSeries: series.rxSeries, txSeries: series.txSeries,
}
return { history, series }
}
/** Legacy interface DTO plus independent evidence for nullable MCP state. */
export async function readServerTrafficInterfaces(server: TrafficHistoryServer, rangeEndMs = Date.now(), options: TrafficHistoryReadOptions = {}) {
const rangeStartMs = rangeEndMs - 86400000
const [rows, context] = await Promise.all([readServerSamplesInRange(server.id, new Date(rangeStartMs).toISOString(), { ...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString() }), readTrafficCollectionContext([server.id])])
const [rows, context] = await Promise.all([readServerSamplesInRange(server.id, new Date(rangeStartMs).toISOString(), {
...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString(), interfaceCountersOnly: true,
}), readTrafficCollectionContext([server.id])])
const byIface = new Map<string, typeof rows>()
for (const row of rows) {
if (isLoopbackName(row.interfaceName) || row.peerPublicKey) continue
@@ -34,6 +34,8 @@ else {
await pool.query("DELETE FROM traffic_samples WHERE server_id=$1 AND (flags & 4)=0",[serverId])
await pool.query("UPDATE traffic_samples SET sampled_at=$1 WHERE server_id=$2",[new Date(Date.now()-30_000).toISOString(),serverId])
counter="3751000";const success=await collectTrafficOnce();dto=await detail();assert.equal(dto.observations.currentState,"current");assert.equal(dto.observations.rxNow,true);assert(dto.rxNow>0.9);cases++
const overview=await get("/traffic/servers?range=1h")
assert.deepEqual(overview.peaks,{rx:dto.rxPeak,tx:dto.txPeak});cases++
await pool.query("INSERT INTO scheduler_runs(id,job_key,started_at,finished_at,status,result_json) VALUES($1,'traffic',$2,$3,'ok',$4::jsonb)",[prefix+"run",success.sampledAt,new Date().toISOString(),JSON.stringify(success)])
assert.equal((await buildSignalSnapshotFromCollectors()).trafficByServer.length,1);cases++
const succeeded=dto.observations.lastSucceededAt
+13
View File
@@ -172,3 +172,16 @@ for (const minutes of [5, 15]) {
const weighted = observed([observationSample(0,0,0),observationSample(500,62_500,62_500),observationSample(1500,312_500,312_500)])
assert.equal(weighted.rxSeries[0], 1.5)
assert.equal(weighted.rxSeries[1], 2)
const boundaryRows = [observationSample(-15_000, 0, 0), observationSample(15_000, 3_750_000, 1_875_000),
observationSample(45_000, 7_500_000, 3_750_000), observationSample(75_000, 11_250_000, 5_625_000)]
const boundary = observed(boundaryRows)
assert.equal(boundary.rxTotalGiB, 5_625_000 / 1024 ** 3)
assert.equal(boundary.txTotalGiB, 2_812_500 / 1024 ** 3)
assert(boundary.observations?.rxSeries.slice(0, 45).every(Boolean))
assert(boundary.observations?.rxSeries.slice(45).every(value => !value), "History does not extend past the last poll inside the range")
const lostBoundary = observed([boundaryRows[0], { ...boundaryRows[1], continuityKnown: false }, ...boundaryRows.slice(2)])
assert.equal(lostBoundary.rxTotalGiB, 3_750_000 / 1024 ** 3)
assert(lostBoundary.observations?.rxSeries.slice(0, 15).every(value => !value))
const staleBoundary = observed([observationSample(-100_000, 0, 0), ...boundaryRows.slice(1)])
assert.equal(staleBoundary.rxTotalGiB, 3_750_000 / 1024 ** 3)
+13 -6
View File
@@ -146,6 +146,10 @@ export function sampleSeriesKey(interfaceName: string, peerPublicKey = ""): stri
return `${interfaceName}\0${peerPublicKey}`
}
export function trafficHistoryBoundaryLimitMs(intervalSec = 30): number {
return Math.max(5, intervalSec) * 3000
}
export function buildTrafficFromSamples(
rows: TrafficSampleLike[],
rangeStartMs: number,
@@ -153,6 +157,7 @@ export function buildTrafficFromSamples(
onlyInterface?: string | readonly string[],
peerPublicKey?: string,
includeObservations=false,
boundaryLimitMs = trafficHistoryBoundaryLimitMs(),
): BuiltTrafficSeries {
const empty: BuiltTrafficSeries = {
rxNow: 0,
@@ -206,9 +211,10 @@ export function buildTrafficFromSamples(
continue
}
const sorted = [...arr].sort((a, b) => Date.parse(a.sampledAt) - Date.parse(b.sampledAt))
const sorted = arr.filter(row => Date.parse(row.sampledAt) <= rangeEndMs)
.sort((a, b) => Date.parse(a.sampledAt) - Date.parse(b.sampledAt))
const last = sorted[sorted.length - 1]
if (!last) continue
if (!last || Date.parse(last.sampledAt) < rangeStartMs) continue
for (const row of sorted) {
const t = Date.parse(row.sampledAt)
if (!Number.isFinite(t) || t < rangeStartMs || t > rangeEndMs) continue
@@ -230,15 +236,16 @@ export function buildTrafficFromSamples(
const t0 = parseIsoMs(prev.sampledAt)
const t1 = parseIsoMs(cur.sampledAt)
if(Number.isFinite(Date.parse(cur.sampledAt))&&t1>=rangeStartMs&&t1<=rangeEndMs)lastAttemptAt=Math.max(lastAttemptAt??t1,t1)
if (t1 <= rangeStartMs || (t0 < rangeStartMs && t1 - t0 > boundaryLimitMs)) continue
const sameIdentity = (prev.nativeCounterIdentity ?? null) === (cur.nativeCounterIdentity ?? null)
const identityPresent = cur.continuityKnown === undefined || typeof cur.nativeCounterIdentity === "string" && cur.nativeCounterIdentity.length > 0
const countersKnown = prev.countersKnown !== false && cur.countersKnown !== false && cur.continuityKnown !== false && identityPresent && sameIdentity
const rxBps = countersKnown ? rateBpsFromDelta(prev.rxBytes, cur.rxBytes, t0, t1) : null
const txBps = countersKnown ? rateBpsFromDelta(prev.txBytes, cur.txBytes, t0, t1) : null
if (t1 >= rangeStartMs && t1 <= rangeEndMs) {
if (rxBps !== null) rxBytesDelta += cur.rxBytes - prev.rxBytes
if (txBps !== null) txBytesDelta += cur.txBytes - prev.txBytes
}
// Attribute only the in-window fraction of a measured interval and never extend beyond its next poll.
const overlap = (t1 - Math.max(t0, rangeStartMs)) / (t1 - t0)
if (rxBps !== null) rxBytesDelta += (cur.rxBytes - prev.rxBytes) * overlap
if (txBps !== null) txBytesDelta += (cur.txBytes - prev.txBytes) * overlap
if (rxBps == null && txBps == null) continue
const rxMbps = bpsToMbps(rxBps ?? 0)
const txMbps = bpsToMbps(txBps ?? 0)
@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
import fs from 'node:fs'
import vm from 'node:vm'
import ts from 'typescript'
import {buildTrafficFromSamples,mergeBuiltTraffic} from './traffic-rate.js'
import {buildTrafficFromSamples,mergeBuiltTraffic,trafficHistoryBoundaryLimitMs} from './traffic-rate.js'
import {applyTrafficFreshness,trafficBindingStatus} from './traffic-freshness.js'
const source=fs.readFileSync(new URL('./traffic-users.ts',import.meta.url),'utf8')
@@ -14,7 +14,7 @@ let calls=0,fail=false
const at=Date.parse('2026-10-13T00:00:00Z')
const users=Array.from({length:100},(_,i)=>({id:String(i),login:'user'+i,name:'User '+i,role:'user',active:true,
bindings:[{serverId:1,interfaceName:'ether1',peerPublicKey:'',userId:String(i),id:'binding'+i}]}))
const context=vm.createContext({Date,Map,Promise,buildTrafficFromSamples,mergeBuiltTraffic,applyTrafficFreshness,trafficBindingStatus,
const context=vm.createContext({Date,Map,Promise,buildTrafficFromSamples,mergeBuiltTraffic,trafficHistoryBoundaryLimitMs,applyTrafficFreshness,trafficBindingStatus,
listUsers:async()=>users,servers:{},db:{select:()=>({from:async()=>[{id:1,enabled:true,updatedAt:new Date(at).toISOString()}]})},
readTrafficCollectionContext:async()=>({settings:{enabled:true,intervalSec:30},states:new Map()}),
readServerSamplesInRange:async()=>{calls++;await new Promise(resolve=>setTimeout(resolve,5));if(fail)throw Error('fixture read failed');
+14 -3
View File
@@ -6,6 +6,7 @@ import { readServerSamplesInRange, type TrafficHistoryReadOptions } from "./traf
import {
buildTrafficFromSamples,
mergeBuiltTraffic,
trafficHistoryBoundaryLimitMs,
type BuiltTrafficSeries,
} from "./traffic-rate.js"
import { readTrafficCollectionContext } from "./traffic-collection-state.js"
@@ -82,6 +83,13 @@ export async function buildUserTrafficList(rangeStartMs: number, rangeEndMs: num
const sinceIso = new Date(rangeStartMs).toISOString()
const users = options.users ?? await listUsers()
const [context, allServers] = await Promise.all([readTrafficCollectionContext(options.serverIds), options.serverIds === undefined ? db.select().from(servers) : db.select().from(servers).where(inArray(servers.id, [...options.serverIds]))])
const boundaryLimitMs = trafficHistoryBoundaryLimitMs(context.settings?.intervalSec)
const interfacesByServer = new Map<number, Set<string>>()
for (const user of users) for (const binding of user.bindings) {
const names = interfacesByServer.get(binding.serverId) ?? new Set<string>()
names.add(binding.interfaceName)
interfacesByServer.set(binding.serverId, names)
}
const catalog = new Map(allServers.map(s => [s.id, s]))
const sampleCache = new Map<number, ReturnType<typeof readServerSamplesInRange>>()
@@ -93,18 +101,21 @@ export async function buildUserTrafficList(rangeStartMs: number, rangeEndMs: num
let pending = sampleCache.get(b.serverId)
if (!pending) {
if (options.serverIds !== undefined && !options.serverIds.includes(b.serverId)) throw new Error("Привязка вне выбранной области истории")
pending = readServerSamplesInRange(b.serverId, sinceIso, { ...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString() })
pending = readServerSamplesInRange(b.serverId, sinceIso, {
...options, untilIso: options.untilIso ?? new Date(rangeEndMs).toISOString(),
interfaceNames: [...interfacesByServer.get(b.serverId)!], precedingMaxIntervalMs: boundaryLimitMs,
})
sampleCache.set(b.serverId, pending)
}
const rows = await pending
const peerKey = b.peerPublicKey ?? ""
const built = buildTrafficFromSamples(rows, rangeStartMs, rangeEndMs, b.interfaceName, peerKey, true)
const built = buildTrafficFromSamples(rows, rangeStartMs, rangeEndMs, b.interfaceName, peerKey, true, boundaryLimitMs)
const server = catalog.get(b.serverId)
if (built.observations) built.observations = applyTrafficFreshness(built.observations,
server ?? { enabled: false, updatedAt: "" }, context.settings, context.states.get(b.serverId), rangeEndMs)
parts.push(built)
const last = [...rows.filter((r) =>
r.interfaceName === b.interfaceName && (r.peerPublicKey ?? "") === peerKey,
r.interfaceName === b.interfaceName && (r.peerPublicKey ?? "") === peerKey && Date.parse(r.sampledAt) >= rangeStartMs,
)]
.sort((a, c) => Date.parse(a.sampledAt) - Date.parse(c.sampledAt))
.at(-1)
@@ -3,12 +3,39 @@ import { EventEmitter } from "node:events"
import http from "node:http"
import { test, type TestContext } from "node:test"
import { isRouterOsPreHeaderGetReset, MikrotikClient } from "./mikrotik.js"
import { createWireguardDependencyReader } from "./wireguard-interface-delete.js"
import { createWireguardDependencyReader, readWireguardRouteDependencies } from "./wireguard-interface-delete.js"
import { assertGreDeleteDependencies } from "./gre-mutation-state.js"
import { wireguardReadDiagnostic } from "./wireguard-read-diagnostic.js"
type Outcome = "reset" | "late-reset" | "informational-reset" | "body-reset" | "ok" | "refused" | "invalid-json"
const reset = () => Object.assign(new Error("fixture reset"), { code: "ECONNRESET" })
test("large routing tables do not enter a new WireGuard snapshot and still protect existing interfaces", async () => {
const target = { ".id": "*a", name: "wg-new" }
const configured = { ".id": "*b", static: "true", gateway: "wg-new-backup" }
const learned = Array.from({ length: 12_608 }, (_, index) => ({
".id": `*r${index.toString(16)}`, dynamic: "true", "immediate-gw": "192.0.2.1%ether1",
}))
const requests: string[] = []
const read: ReturnType<typeof createWireguardDependencyReader> = async (path, query) => {
requests.push(path + query)
return query === "?static=true" ? [configured] : learned
}
const path = "/ip/route"
assert.deepEqual(await readWireguardRouteDependencies(read, path, false), [configured])
assert.deepEqual(requests, ["/ip/route?static=true"])
const assertSafe = (routes: Record<string, string>[]) => assertGreDeleteDependencies({ dependencies: { [path]: routes }, bindings: [], filters: [] }, target)
assertSafe(await readWireguardRouteDependencies(read, path, true))
assert.match(requests.at(-1)!, /^\/ip\/route\?dynamic=true&\.proplist=.*immediate-gw/)
configured.gateway = target.name
assert.throws(() => assertSafe([configured]), /используется/)
configured.gateway = "ether1"
learned[12_607]["immediate-gw"] = "192.0.2.1%wg-new"
const routes = await readWireguardRouteDependencies(read, path, true)
assert.throws(() => assertSafe(routes), /используется/)
await assert.rejects(readWireguardRouteDependencies(async () => learned, path, false), { code: "STATE_UNAVAILABLE" })
})
function fixture(t: TestContext, outcomes: Outcome[]) {
const paths: string[] = [], timeouts: number[] = []
t.mock.method(http, "request", (options: http.RequestOptions, receive: (res: unknown) => void) => {
@@ -41,22 +41,22 @@ async function source(server: ServerRow, authorize: () => Promise<unknown>) {
const fresh = await getServerRowById(server.id)
if (!fresh || !sameWireguardEndpoint(fresh, server)) throw fail("STATE_CONFLICT", "Источник WireGuard изменился")
}
function nativeRows(raw: unknown, required: string[] = []): Row[] {
if (!Array.isArray(raw) || raw.length > 2000 || raw.some(row => !row || typeof row !== "object" || Array.isArray(row) || Object.values(row).some(value => typeof value !== "string") || typeof row[".id"] !== "string" || !/^\*[a-z0-9]+$/i.test(row[".id"]) || required.some(key => !row[key]?.trim()))) throw fail("STATE_UNAVAILABLE", "Недостоверный каталог зависимостей WireGuard")
function nativeRows(raw: unknown, required: string[] = [], rowLimit = 2000): Row[] {
if (!Array.isArray(raw) || raw.length > rowLimit || raw.some(row => !row || typeof row !== "object" || Array.isArray(row) || Object.values(row).some(value => typeof value !== "string") || typeof row[".id"] !== "string" || !/^\*[a-z0-9]+$/i.test(row[".id"]) || required.some(key => !row[key]?.trim()))) throw fail("STATE_UNAVAILABLE", "Недостоверный каталог зависимостей WireGuard")
if (new Set(raw.map(row => row[".id"])).size !== raw.length) throw fail("STATE_UNAVAILABLE", "Повторяющиеся ID в каталоге WireGuard")
return raw as Row[]
}
/** Retry at most two distinct catalogue GETs per capture, with fresh source authority. */
export function createWireguardDependencyReader(client: Pick<MikrotikClient, "get">, authorizeSource: () => Promise<unknown>, now = () => performance.now()) {
const timeoutMs = 10_000, maxBytes = 1_048_576
const timeoutMs = 10_000
const unavailable = () => fail("STATE_UNAVAILABLE", "Не прочитан обязательный источник зависимостей WireGuard")
const retriedPaths = new Set<string>()
return async (path: string): Promise<unknown> => {
return async (path: string, query = "", maxBytes = 1_048_576): Promise<unknown> => {
await authorizeSource()
const deadline = now() + timeoutMs
try {
return await client.get(path, timeoutMs, undefined, maxBytes)
return await client.get(path + query, timeoutMs, undefined, maxBytes)
} catch (error) {
const retryableCatalogue = path === "/ip/address" || path === "/ipv6/address" || wireguardInterfaceDependencyPaths.includes(path)
if (retriedPaths.size >= 2 || retriedPaths.has(path) || !retryableCatalogue
@@ -67,14 +67,40 @@ export function createWireguardDependencyReader(client: Pick<MikrotikClient, "ge
const remaining = Math.floor(deadline - now())
if (remaining < 1) throw markWireguardReadFailure(unavailable(), path, 2, "read-deadline")
try {
return await client.get(path, remaining, undefined, maxBytes)
return await client.get(path + query, remaining, undefined, maxBytes)
} catch (error) {
throw markWireguardGetFailure(unavailable(), path, 2, error)
}
}
}
export async function readWireguardInterfaceDeleteState(server: ServerRow, id: string, authorize: () => Promise<unknown> = async () => {}): Promise<WireguardInterfaceDeleteState> {
const routePaths = new Set(["/ip/route", "/ipv6/route"])
const routeRowLimit = 50_000
const routeByteLimit = 8 * 1024 * 1024
export async function readWireguardRouteDependencies(read: ReturnType<typeof createWireguardDependencyReader>, path: string, existingInterface: boolean) {
const catalogue = async (query: string, dynamic: boolean) => {
const raw = await read(path, query, routeByteLimit)
if (Array.isArray(raw) && raw.length > routeRowLimit) throw markWireguardReadFailure(fail("STATE_UNAVAILABLE", "Превышен предел отфильтрованного каталога маршрутов WireGuard"), path, undefined, "catalogue-limit")
try {
const rows = nativeRows(raw, [], routeRowLimit)
if (rows.some(row => dynamic ? observedBoolean(row.dynamic) !== true : observedBoolean(row.dynamic) === true || observedBoolean(row.static) === false)) throw fail("STATE_UNAVAILABLE", "RouterOS вернул маршруты вне запрошенного фильтра")
return rows
} catch (error) {
if (!(error instanceof McpError)) throw error
throw markWireguardReadFailure(error, path, undefined, "invalid-catalogue")
}
}
const configured = await catalogue("?static=true", false)
if (!existingInterface) return configured
// Preserve checks on learned next hops before editing or removing an existing interface.
const learned = await catalogue("?dynamic=true&.proplist=.id,dynamic,connect,belongs-to,gateway,immediate-gw,vrf-interface,interface,local-address,routing-table", true)
const configuredIds = new Set(configured.map(row => row[".id"]))
if (learned.some(row => configuredIds.has(row[".id"]))) throw markWireguardReadFailure(fail("STATE_UNAVAILABLE", "Маршрут изменился во время сверки зависимостей WireGuard"), path, undefined, "invalid-catalogue")
return [...configured, ...learned]
}
export async function readWireguardInterfaceDeleteState(server: ServerRow, id: string, authorize: () => Promise<unknown> = async () => {}, includeLearnedRoutes?: boolean): Promise<WireguardInterfaceDeleteState> {
const base = await readWireguardPeerDeletionState(server, authorize), client = MikrotikClient.fromServer(server)
const readDependency = createWireguardDependencyReader(client, () => source(server, authorize))
let totalRows = base.interfaces.length + base.peers.length, bytes = Buffer.byteLength(JSON.stringify([base.interfaces, base.peers]))
@@ -93,8 +119,10 @@ export async function readWireguardInterfaceDeleteState(server: ServerRow, id: s
}
const ipv4 = await read("/ip/address", ["address", "interface"]), ipv6 = await read("/ipv6/address", ["address", "interface"])
const dependencies: Record<string, Row[]> = {}
for (const path of wireguardInterfaceDependencyPaths) dependencies[path] = await read(path, path === "/interface" ? ["name"] : [])
const parent = base.interfaces.find(row => row[".id"] === id)
for (const path of wireguardInterfaceDependencyPaths) dependencies[path] = routePaths.has(path)
? await readWireguardRouteDependencies(readDependency, path, includeLearnedRoutes ?? (parent !== undefined))
: await read(path, path === "/interface" ? ["name"] : [])
if (parent && [...ipv4, ...ipv6].filter(row => [parent.name, id].includes(row.interface) && !automaticLinkLocal(row)).length + base.peers.filter(row => [parent.name, id].includes(row.interface)).length > 49) throw fail("STATE_UNAVAILABLE", "Каскад WireGuard превышает предел зависимых объектов")
if (parent) for (const [path, rows] of [["/ip/address", ipv4], ["/ipv6/address", ipv6]] as const) for (const row of rows.filter(row => [parent.name, id].includes(row.interface))) {
try {
@@ -69,11 +69,11 @@ export const wireguardRestoreStateProof=(state:WireguardRestoreState)=>wireguard
export async function readWireguardRestoreState(server:ServerRow,beforeRead:()=>Promise<unknown>=async()=>{}) {
const deadline=Date.now()+45000
const authorize=async()=>{if(Date.now()>=deadline)throw fail("Истёк бюджет чтения WireGuard restore","STATE_UNAVAILABLE");await beforeRead();if(Date.now()>=deadline)throw fail("Истёк бюджет чтения WireGuard restore","STATE_UNAVAILABLE")}
const state=await readWireguardInterfaceDeleteState(server,"*0",authorize)
const state=await readWireguardInterfaceDeleteState(server,"*0",authorize,true)
if(new Set(state.base.interfaces.map(row=>row.name)).size!==state.base.interfaces.length||state.base.interfaces.some(row=>!row.name)||state.base.peers.some(peer=>state.base.interfaces.filter(row=>row.name===peer.interface||row[".id"]===peer.interface).length!==1))throw fail("Неоднозначные родители WireGuard")
// Selected-parent reads corroborate dynamic origins; the *0 inventory alone does not.
for(const parent of state.base.interfaces){
const selected=await readWireguardInterfaceDeleteState(server,parent[".id"],authorize),comparison=structuredClone(selected)
const selected=await readWireguardInterfaceDeleteState(server,parent[".id"],authorize,false),comparison=structuredClone(selected)
for(const resource of ["ipv4","ipv6"]as const)for(const row of comparison[resource]){const previous=state[resource].find(a=>a[".id"]===row[".id"]);if(previous?.dynamic===undefined)delete row.dynamic;else row.dynamic??=previous.dynamic}
if(await wireguardRestoreStateProof(comparison)!==await wireguardRestoreStateProof(state))throw fail("WireGuard изменился во время инвентаризации")
for(const resource of ["ipv4","ipv6"]as const)for(const row of state[resource]){const observed=selected[resource].find(a=>a[".id"]===row[".id"]&&a.interface===row.interface);if(observed?.dynamic!==undefined)row.dynamic=observed.dynamic}
+7
View File
@@ -38,6 +38,10 @@ export async function verifyMcpTrafficHistory(actor: AuthUser) {
assert.equal((await readTrafficCollectionContext([])).states.size, 0)
await assert.rejects(readServerSamplesInRange(52, previous.toISOString(), { maxRows: 1 }), /предел/)
await assert.rejects(readServerSamplesInRange(52, previous.toISOString(), { maxRows: 0 }), /предел/)
const clipped = await readServerSamplesInRange(52, new Date(previous.getTime() + 15_000).toISOString(), {
untilIso: sourceAt.toISOString(), maxRows: 2, interfaceNames: ["fixture-traffic-zero"], interfaceCountersOnly: true, precedingMaxIntervalMs: 90_000,
})
assert.deepEqual(clipped.map(row => new Date(row.sampledAt).toISOString()), [previous.toISOString(), sourceAt.toISOString()])
const access = await makeAccess([52, 54]), principal = await authenticateMcpToken(access.token)
const result = await invokeMcpTool(principal, "mm_traffic_server_history_get", { serverId: 52 }) as History
assert.equal(result.rxNowMbps, 0); assert.equal(result.txNowMbps, 0); assert.equal(result.accountedRxGiB, 0); assert.equal(result.currentState, "current"); assert.equal(result.live, false)
@@ -89,6 +93,9 @@ export async function verifyMcpTrafficHistory(actor: AuthUser) {
finally { pool.query = originalQuery; await pool.query("UPDATE servers SET host='192.0.2.52' WHERE id=52") }
await pool.query("INSERT INTO traffic_samples(server_id,interface_name,sampled_at,flags) SELECT 52,'limit-history-'||n,$1,0 FROM generate_series(1,20001) n", [sourceAt.toISOString()])
await assert.rejects(invokeMcpTool(principal, "mm_traffic_server_history_get", { serverId: 52 }), /20000/)
const filtered = await invokeMcpTool(principal, "mm_traffic_server_history_get", { serverId: 52, interface: "fixture-traffic-zero", range: "24h" }) as History
assert.equal(filtered.accountedRxGiB, 0)
assert(filtered.rxSeriesMbps.some(value => value === 0))
await pool.query("DELETE FROM traffic_samples WHERE server_id=52 AND interface_name LIKE 'limit-history-%'")
let ownerRevokedDuringRead = false
pool.query = ((...args: unknown[]) => {
+12 -5
View File
@@ -6,7 +6,7 @@ import Link from "next/link"
import { useTable, type ColumnDef } from "@tanstack/react-table"
import { BotIcon, CheckIcon, CopyIcon, PlusIcon, RefreshCwIcon, ServerIcon, ShieldIcon, StopCircleIcon } from "lucide-react"
import { toast } from "sonner"
import { mcpConnectionCreateSchema, mcpPageQuerySchema, mcpTargetSchema, type McpConnection, type McpOperationDescriptor, type McpPolicyDecision } from "@mmapp/contracts/mcp"
import { mcpConnectionCreateSchema, mcpLimitsSchema, mcpPageQuerySchema, mcpTargetSchema, type McpConnection, type McpOperationDescriptor, type McpPolicyDecision } from "@mmapp/contracts/mcp"
import { routeAiControllerBlockReason, routeAiProfileSchema, type RouteAiProfile } from "@mmapp/contracts/mcp-routing"
import { useDataSource } from "@/lib/data-source"
import { can, getClaims, getToken, hasPermission } from "@/lib/auth"
@@ -239,13 +239,15 @@ function ConnectionForm({ api, operations, editing, close, created }: { api: Mcp
const [name, setName] = useState(editing?.name ?? ""), [mode, setMode] = useState<McpConnection["policy"]["mode"]>(editing?.policy.mode ?? "observer")
const [service, setService] = useState(editing?.policy.authority === "service")
const [unattended, setUnattended] = useState(editing?.policy.allowUnattendedPlans === true)
const [unlimitedRates, setUnlimitedRates] = useState(editing?.policy.unlimitedRates === true)
const ratesDisabled = service && unlimitedRates
const [selectAllServers, setSelectAllServers] = useState(false)
const [serverIds, setServerIds] = useState(editing?.policy.scope.serverIds ?? []), [selected, setSelected] = useState<string[]>(editing?.policy.scope.operationIds ?? [])
const serverCatalog = useQuery(useCallback(signal => api.serverChoices(undefined, signal), [api]))
const [global, setGlobal] = useState(editing?.policy.scope.allowGlobal ?? false), [danger, setDanger] = useState(editing?.policy.dangerousPolicy ?? "approval")
const [dangerIds, setDangerIds] = useState(editing?.policy.autonomousDangerousOperationIds ?? [])
const [expires, setExpires] = useState(() => editing?.policy.expiresAt.slice(0, 16) ?? new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 16))
const [limits, setLimits] = useState(editing?.policy.limits ?? { callsPerMinute: 60, concurrentReads: 4, mutationsPerHour: 10, serversPerPlan: 5, objectsPerPlan: 100 })
const [limits, setLimits] = useState(() => editing?.policy.limits ?? mcpLimitsSchema.parse({}))
const permissions = getClaims()?.permissions ?? []
const eligible = operations.filter(operation => operation.implementation === "available" && operation.requiredPermissions.every(permission => hasPermission(permissions, permission)))
const selectedIds = new Set(selected)
@@ -254,7 +256,9 @@ function ConnectionForm({ api, operations, editing, close, created }: { api: Mcp
const save = async () => {
setBusy(true); setError("")
try {
const input = mcpConnectionCreateSchema.parse({ name, ...(service ? { authority: "service", mode: "autonomous", expiresAt: null, ...(unattended && { allowUnattendedPlans: true }) } : { mode, expiresAt: new Date(expires + "Z").toISOString() }), permissions: [...new Set(eligible.filter(operation => selected.includes(operation.id)).flatMap(operation => operation.requiredPermissions))], ...(selectAllServers && { selectAllServers: true }), scope: { serverIds: selectAllServers ? [] : serverIds, operationIds: selected, allowGlobal: global }, dangerousPolicy: service ? "approval" : danger, autonomousDangerousOperationIds: service || danger !== "explicit-allow" ? [] : autonomousDangerIds, limits })
const previousLimits = editing?.policy.limits ?? mcpLimitsSchema.parse({})
const savedLimits = ratesDisabled ? { ...previousLimits, serversPerPlan: limits.serversPerPlan, objectsPerPlan: limits.objectsPerPlan } : limits
const input = mcpConnectionCreateSchema.parse({ name, ...(service ? { authority: "service", mode: "autonomous", expiresAt: null, ...(unattended && { allowUnattendedPlans: true }), ...(ratesDisabled && { unlimitedRates: true }) } : { mode, expiresAt: new Date(expires + "Z").toISOString() }), permissions: [...new Set(eligible.filter(operation => selected.includes(operation.id)).flatMap(operation => operation.requiredPermissions))], ...(selectAllServers && { selectAllServers: true }), scope: { serverIds: selectAllServers ? [] : serverIds, operationIds: selected, allowGlobal: global }, dangerousPolicy: service ? "approval" : danger, autonomousDangerousOperationIds: service || danger !== "explicit-allow" ? [] : autonomousDangerIds, limits: savedLimits })
if (editing) { await api.update(editing.id, input); created() }
else { const result = await api.create(input); created(result.token) }
} catch (failure) { setError(errorText(failure)) } finally { setBusy(false) }
@@ -270,14 +274,17 @@ function ConnectionForm({ api, operations, editing, close, created }: { api: Mcp
<OperationChoices operations={eligible} selected={selected} onChange={setSelected} />
<p className="text-xs text-muted-foreground">Выбор операций учитывает права владельца. Режим, список серверов и глобальный доступ задаются отдельно. Новые инструменты нужно добавлять вручную. Для применения планов выберите также инструменты просмотра и применения.</p>
</>}
{step === 3 && <><div className="grid gap-3 sm:grid-cols-2">{Object.entries(limits).map(([key, value]) => <Field key={key} label={({ callsPerMinute: "Вызовов в минуту", concurrentReads: "Одновременных чтений", mutationsPerHour: "Изменений в час", serversPerPlan: "Серверов на план", objectsPerPlan: "Объектов на план" } as Record<string, string>)[key]}><Input type="number" min={1} value={value} onChange={event => setLimits(current => ({ ...current, [key]: Number(event.target.value) }))} /></Field>)}</div>{service ? <>
{step === 3 && <>
{service && <Choice label="Отключить квоты частоты для этого ключа" checked={unlimitedRates} onChange={setUnlimitedRates} />}
{ratesDisabled && <p className="text-sm text-muted-foreground">Вызовы, одновременные чтения и изменения в час без квот подключения. Общая ёмкость сервера и размер плана ограничены.</p>}
<div className="grid gap-3 sm:grid-cols-2">{Object.entries(limits).filter(([key]) => !ratesDisabled || key === "serversPerPlan" || key === "objectsPerPlan").map(([key, value]) => <Field key={key} label={({ callsPerMinute: "Вызовов в минуту", concurrentReads: "Одновременных чтений", mutationsPerHour: "Изменений в час", serversPerPlan: "Серверов на план", objectsPerPlan: "Объектов на план" } as Record<string, string>)[key]}><Input type="number" min={1} value={value} onChange={event => setLimits(current => ({ ...current, [key]: Number(event.target.value) }))} /></Field>)}</div>{service ? <>
<Choice label="Выполнять планы без ручного подтверждения" checked={unattended} onChange={setUnattended} />
<p className="text-sm text-muted-foreground">Действует для всех операций, выданных ключу. Клиент должен сначала показать точный план в чате. Сервер проверяет контрольную сумму плана, а публикацию сообщения обеспечивает клиент. Защита объектов сохраняется.</p>
</> : <><NativeSelect label="Опасные действия" value={danger} onChange={value => setDanger(value as typeof danger)}><option value="approval">Всегда подтверждать</option><option value="explicit-allow">Автономно для явно выбранных действий</option></NativeSelect>{danger === "explicit-allow" && <>
<p className="text-sm text-muted-foreground">В автономном режиме выбранные здесь опасные операции смогут выполняться без подтверждения, если этого не требует защита объекта или сама операция.</p>
<OperationChoices operations={dangerous} selected={autonomousDangerIds} onChange={setDangerIds} selectAllLabel="Выбрать все опасные операции" />
</>}</>}</>}
{step === 4 && <div className="space-y-3 text-sm"><p><strong>{name || "Без названия"}</strong> · {service ? "Сервисное, бессрочное" : modeLabels[mode]}</p><p>Серверы: {selectAllServers ? "все на момент сохранения" : serverIds.join(", ") || "не выбраны"}. Операций: {selected.length}. Глобальный доступ: {global ? "да" : "нет"}.</p>{service && unattended && <p>Ручное подтверждение планов отключено. Клиент публикует план в чате перед применением.</p>}{!service && mode === "autonomous" && danger === "explicit-allow" && <p>Опасных операций выбрано для автономного выполнения: {autonomousDangerIds.length}.</p>}<p>Защита объектов продолжает действовать независимо от автономных разрешений.</p><p>После сохранения проверьте конкретное действие в симуляторе на вкладке «Разрешения».</p></div>}
{step === 4 && <div className="space-y-3 text-sm"><p><strong>{name || "Без названия"}</strong> · {service ? "Сервисное, бессрочное" : modeLabels[mode]}</p><p>Серверы: {selectAllServers ? "все на момент сохранения" : serverIds.join(", ") || "не выбраны"}. Операций: {selected.length}. Глобальный доступ: {global ? "да" : "нет"}.</p>{ratesDisabled && <p>Квоты частоты для этого ключа отключены.</p>}{service && unattended && <p>Ручное подтверждение планов отключено. Клиент публикует план в чате перед применением.</p>}{!service && mode === "autonomous" && danger === "explicit-allow" && <p>Опасных операций выбрано для автономного выполнения: {autonomousDangerIds.length}.</p>}<p>Защита объектов продолжает действовать независимо от автономных разрешений.</p><p>После сохранения проверьте конкретное действие в симуляторе на вкладке «Разрешения».</p></div>}
<div className="flex flex-wrap justify-between gap-2"><Button variant="outline" disabled={busy} onClick={() => step > 1 ? setStep(step - 1) : close()}>{step > 1 ? "Назад" : "Отмена"}</Button>{step < 4 ? <Button onClick={() => setStep(step + 1)}>Далее</Button> : <Button disabled={busy} onClick={() => { void save() }}>{busy ? "Сохранение…" : "Сохранить доступ"}</Button>}</div>
</DialogContent></Dialog>
}
+1 -1
View File
@@ -66,6 +66,6 @@ export function PolicyPreviewDecision({ result }: { result: McpPolicyDecision })
return <div role="status" className="flex flex-col gap-3 rounded-md border p-3 text-sm">
<Badge variant={result.decision === "allowed" ? "success-light" : result.decision === "denied" ? "destructive-light" : "warning-light"}>{result.decision === "allowed" ? "Разрешено" : result.decision === "denied" ? "Запрещено" : "Нужно подтверждение"}</Badge>
{result.reasons.length > 0 && <ul className="list-inside list-disc space-y-1">{result.reasons.map((item, index) => <li key={`${item.code}:${index}`}>{item.message} <span className="text-xs text-muted-foreground">({item.code})</span></li>)}</ul>}
<p className="text-xs text-muted-foreground">Лимиты подключения: {result.limits.callsPerMinute} вызовов/мин · {result.limits.concurrentReads} параллельных чтения · {result.limits.mutationsPerHour} изменений/ч · до {result.limits.serversPerPlan} серверов и {result.limits.objectsPerPlan} объектов в плане.</p>
<p className="text-xs text-muted-foreground">{result.unlimitedRates ? "Квоты частоты отключены" : `${result.limits.callsPerMinute} вызовов/мин · ${result.limits.concurrentReads} одновременных чтений · ${result.limits.mutationsPerHour} изменений/ч`} · до {result.limits.serversPerPlan} серверов и {result.limits.objectsPerPlan} объектов в плане.</p>
</div>
}
+36 -17
View File
@@ -97,25 +97,32 @@ export function FlowEntityCardView({
)
}
type SessionFilter = {
kind: "application" | "category" | "service" | "asn" | "country" | "protocol" | "source" | "destination" | "iface" | "client" | "en"
type BreakdownFilter = {
kind: "application" | "category" | "service" | "asn" | "country" | "protocol" | "source" | "destination" | "iface"
value: string
label: string
serverId?: string
}
type SessionFilter = BreakdownFilter | { kind: "path"; path: FlowPathRow; label: string }
function talkerMatchesFilter(row: FlowTalkerDto, filter: SessionFilter): boolean {
switch (filter.kind) {
case "application": return row.application === filter.value
case "category": return row.category === filter.value
case "service": return row.service === filter.value
case "asn": return String(row.dstAsn ?? "") === filter.value
case "country": return row.dstCountry === filter.value
case "asn": return String(row.dstAsn ?? "unknown") === filter.value
case "country": return (!filter.serverId || row.serverId === filter.serverId) && (row.dstCountry || "unknown") === filter.value
case "protocol": return row.protoName === filter.value
case "source": return row.src === filter.value
case "destination": return row.dst === filter.value
case "iface": return row.inIface === filter.value
case "client": return (row.clientId || "unknown") === filter.value
case "en": return (row.enId || "") === filter.value
case "iface": return (row.accountedIface ?? row.inIface) === filter.value
case "path": {
const path = filter.path
return row.serverId === path.serverId && (row.clientId || "unknown") === path.clientId &&
(row.enId || "") === path.enId && row.dst === path.dst && row.inIface === path.inIface &&
(row.outIface || "") === path.outIface && row.service === path.service &&
row.category === path.category && row.plane === path.plane
}
}
}
@@ -141,7 +148,7 @@ function FlowBreakdownGrid({
cell: ({ row }) => (
<div className="flex min-w-0 flex-col gap-1">
<span className="flex items-center gap-1.5 text-sm font-medium truncate">
{country ? <Flag code={row.original.id} /> : null}
{country && /^[a-z]{2}$/i.test(row.original.id) ? <Flag code={row.original.id} /> : null}
{row.original.label}
</span>
<div className="h-1 rounded-full bg-muted overflow-hidden">
@@ -351,7 +358,7 @@ export function FlowAnalyticsDetail({
sessionFilter ? talkerMatchesFilter(row, sessionFilter) : true,
)
function pickBreakdown(kind: SessionFilter["kind"], row: FlowBreakdownRow) {
function pickBreakdown(kind: BreakdownFilter["kind"], row: FlowBreakdownRow) {
setSessionFilter({ kind, value: row.id, label: row.label })
setSlice("sessions")
}
@@ -430,6 +437,7 @@ export function FlowAnalyticsDetail({
{range === "30d" && <p className="text-sm text-muted-foreground mb-3">Календарный месяц по UTC. Фильтры интерфейса, дублей, overlay и mesh к этому отчёту не применяются.</p>}
{monthly && range === "30d" && <section aria-label="Месячный отчёт" className="flex flex-col gap-4">
<p className="text-sm">Период: {monthly.month} (UTC) · Объём: {formatBytes(monthly.bytes)}</p>
{monthly.totalsSource === "legacy-dimensions" && <p className="text-sm text-muted-foreground">Для части месяца объём оценён по сохранённым дневным сводкам.</p>}
<div><h3 className="text-sm font-medium mb-2">Страны</h3><FlowBreakdownGrid rows={monthly.countries} country monthly /></div>
<div><h3 className="text-sm font-medium mb-2">Сервисы</h3><FlowBreakdownGrid rows={monthly.services} monthly /></div>
<div><h3 className="text-sm font-medium mb-2">ASN</h3><FlowBreakdownGrid rows={monthly.asns} monthly /></div>
@@ -475,7 +483,13 @@ export function FlowAnalyticsDetail({
{analytics && <>
{analytics.sourceWindow && <p role="status" className="mb-3 text-sm text-muted-foreground">Данные за последние {analytics.sourceWindow.effectiveMinutes} мин из запрошенных {analytics.sourceWindow.requestedMinutes} мин.</p>}
<p className="mb-3 text-sm text-muted-foreground">График RX/TX показывает потоки с известным направлением. Общий объём включает также транзит с неопределённым направлением.</p>
<p className="mb-3 text-sm text-muted-foreground">
RX/TX рассчитаны по сохранённой выборке потоков с известным направлением.
{analytics.timeBasis === "collector-receipt" && " Время на графике соответствует приёму IPFIX коллектором."}
</p>
{analytics.admittedTotals && <p className="mb-3 text-sm text-muted-foreground">
Коллектор принял {formatBytes(analytics.admittedTotals.bytes)} за завершённые минуты окна. Минут с данными — {analytics.admittedTotals.minutesWithData}. Фильтры overlay, mesh и дублей к этому счётчику не применяются.
</p>}
<TrafficRxTxChart
rx={analytics?.rxSeries ?? card?.rxSeries ?? []}
tx={analytics?.txSeries ?? card?.txSeries ?? []}
@@ -489,7 +503,7 @@ export function FlowAnalyticsDetail({
items={([
{
id: "bps-now",
label: "Скорость сейчас",
label: "Скорость IPFIX",
value: fmtRate(rxNow),
hint: liveHint,
icon: <ArrowDownIcon className="size-4" />,
@@ -497,9 +511,9 @@ export function FlowAnalyticsDetail({
},
{
id: "bytes",
label: "Payload",
label: "Объём выборки",
value: formatBytes(bytes),
hint: "inner IPFIX",
hint: "Сохранённые потоки",
icon: <ArrowUpIcon className="size-4" />,
iconClassName: "text-info",
},
@@ -562,6 +576,9 @@ export function FlowAnalyticsDetail({
<p className="text-xs text-muted-foreground">Аналитика потребления</p>
{liveHint === "live" ? <Badge variant="success-light" size="sm">live</Badge> : null}
</div>
<p className="text-xs text-muted-foreground">
Разрезы рассчитаны по сохранённой выборке NetFlow. В рейтингах до 50 крупнейших строк, доли рассчитаны от всей выборки.
</p>
<Tabs value={slice} onValueChange={(v) => setSlice(String(v))} className="gap-3">
<TabsList variant="line" className="flex w-full shrink-0 flex-wrap gap-y-2 group-data-horizontal/tabs:h-auto [&_[data-slot=tabs-trigger]]:h-9 [&_[data-slot=tabs-trigger]]:flex-none">
<TabsTrigger value="applications">Приложения</TabsTrigger>
@@ -578,6 +595,7 @@ export function FlowAnalyticsDetail({
<TabsTrigger value="interfaces">Интерфейсы</TabsTrigger>
</TabsList>
<TabsContent value="applications">
<p className="mb-2 text-xs text-muted-foreground">Приложения определяются по протоколу и портам.</p>
<FlowBreakdownGrid rows={analytics?.applications ?? []} onPick={(row) => pickBreakdown("application", row)} />
</TabsContent>
<TabsContent value="categories">
@@ -595,8 +613,9 @@ export function FlowAnalyticsDetail({
<TabsContent value="map">
<FlowTrafficMap
edges={analytics?.mapEdges ?? []}
onSelectCountry={(iso) => {
setSessionFilter({ kind: "country", value: iso, label: iso })
onSelectEdge={(edge) => {
setSessionFilter({ kind: "country", value: edge.toCountry, serverId: edge.fromId,
label: edge.toCountry === "unknown" ? "Страна неизвестна" : edge.toCountry })
setSlice("sessions")
}}
/>
@@ -616,8 +635,8 @@ export function FlowAnalyticsDetail({
empty="Нет путей за период"
onPick={(row) => {
setSessionFilter({
kind: "client",
value: row.clientId,
kind: "path",
path: row,
label: `${row.clientName} → ${row.enName || row.dst}`,
})
setSlice("sessions")
+9 -9
View File
@@ -34,10 +34,10 @@ function formatBytes(n: number): string {
function FlowTrafficMap({
edges,
onSelectCountry,
onSelectEdge,
}: {
edges: FlowMapEdge[]
onSelectCountry?: (country: string) => void
onSelectEdge?: (edge: FlowMapEdge) => void
}) {
const [hover, setHover] = useState<string | null>(null)
@@ -77,7 +77,7 @@ function FlowTrafficMap({
{/^[a-z]{2}$/i.test(row.original.toCountry)
? <Flag code={row.original.toCountry} />
: null}
{row.original.toCountry}
{row.original.toCountry === "unknown" ? "Страна неизвестна" : row.original.toCountry}
{row.original.toAsn ? <span className="font-mono text-[10px] text-muted-foreground">AS{row.original.toAsn}</span> : null}
</span>
),
@@ -120,7 +120,7 @@ function FlowTrafficMap({
if (!edges.length) {
return (
<p className="text-sm text-muted-foreground py-8 text-center">
Страны подтянутся из кэша RIPEstat
Нет данных за период
</p>
)
}
@@ -150,10 +150,10 @@ function FlowTrafficMap({
className="cursor-pointer"
onMouseEnter={() => setHover(id)}
onMouseLeave={() => setHover(null)}
onClick={() => onSelectCountry?.(e.toCountry)}
onClick={() => onSelectEdge?.(e)}
>
<title>
{`${e.fromLabel} → ${e.toCountry} · ${e.category} · ${formatBytes(e.bytes)}`}
{`${e.fromLabel} → ${e.toCountry === "unknown" ? "Страна неизвестна" : e.toCountry} · ${e.category} · ${formatBytes(e.bytes)}`}
</title>
</path>
)
@@ -170,7 +170,7 @@ function FlowTrafficMap({
<g key={`d-${n.country}`}>
<circle cx={n.x} cy={n.y} r="7" className="fill-chart-2" />
<text x={n.x + 14} y={n.y + 4} className="fill-foreground text-[11px]">
{n.country}
{n.country === "unknown" ? "Без гео" : n.country}
</text>
</g>
))}
@@ -185,8 +185,8 @@ function FlowTrafficMap({
<DataGridShell
table={table}
recordCount={edges.length}
emptyMessage="Нет рёбер с известной страной"
onRowClick={(row) => onSelectCountry?.(row.toCountry)}
emptyMessage="Нет данных за период"
onRowClick={onSelectEdge}
/>
</div>
)
@@ -200,6 +200,7 @@ function NetflowSettingsContent({
? new Date(settings.lastDatagramAt).toLocaleString("ru-RU")
: settings ? "Не получен" : "—"}
{settings?.lastExporterIp ? ` · ${settings.lastExporterIp}` : ""}
{settings?.collectorCountersSource === "last-known" ? " · последние известные данные" : ""}
{settings?.lastError ? ` · ${settings.lastError}` : ""}
</p>
+3 -1
View File
@@ -123,7 +123,9 @@
В «Подключения» → «Выдать доступ» администратор MCP может выбрать «Сервисное — бессрочный автономный доступ». Выберите нужные серверы и операции. Доступ действует до отзыва и переживает истечение обычной сессии портала. По умолчанию опасные действия требуют ручного подтверждения.
На шаге 3 можно включить «Выполнять планы без ручного подтверждения». Режим действует на все выданные ключу операции. Списки серверов, права, лимиты и правила защиты объектов продолжают действовать.
На шаге 3 можно включить «Выполнять планы без ручного подтверждения». Режим действует на все выданные ключу операции. Списки серверов, права и правила защиты объектов продолжают действовать.
Опция «Отключить квоты частоты для этого ключа» доступна при создании и редактировании сервисного подключения. Она снимает квоты на HTTP-запросы MCP, вызовы инструментов, одновременные чтения и изменения в час. В API ей соответствует `unlimitedRates: true`. Ключ менять не нужно. Ограничения размера плана и общей нагрузки сервера продолжают действовать.
Если план содержит `announcement`, клиент сначала публикует отдельное сообщение в чате с ID плана, целями, изменениями и предупреждениями из `changes`. Затем вызывает `mm_change_apply` с `planId`, `idempotencyKey` и `announcedPlanDigest`, равным `announcement.digest`. Manager проверяет контрольную сумму сохранённого плана. Публикацию сообщения обеспечивает клиент. В аудите такой запуск отмечается как допуск по политике подключения.
+6 -1
View File
@@ -1,5 +1,5 @@
import assert from "node:assert/strict"
import { projectTrafficObservations } from "./traffic-observations.js"
import { peakOfCombinedTraffic, projectTrafficObservations } from "./traffic-observations.js"
const at=Date.parse("2026-10-12T12:00:00Z"),sampledAt=new Date(at).toISOString(),expiresAt=new Date(at+90_000).toISOString()
const row={rxNow:0,txNow:0,rxPeak:0,txPeak:0,rxTotal:0,txTotal:0,rxSeries:[0,0],txSeries:[0,0]}
const obs={rxNow:true,txNow:true,rxSeries:[false,true],txSeries:[false,true],sampledAt,currentState:"current",expiresAt}
@@ -16,3 +16,8 @@ const noPeak=projectTrafficObservations({...row,volumeUnit:"GiB",observations:{.
assert.equal(noPeak.rxPeak,null);assert.equal(noPeak.txPeak,null);assert.equal(noPeak.rxTotal,0)
assert.equal(projectTrafficObservations({...row,observations:{...obs,rxPeak:true,txPeak:true}},at).rxPeak,0)
console.log('aggregate peak confidence overrides bucket confidence; measured zero and volumes retained')
assert.equal(peakOfCombinedTraffic([[10, 3, 20], [4, 15, null]]), 18)
assert.equal(peakOfCombinedTraffic([[0, null], [0, 50]]), 0)
assert.equal(peakOfCombinedTraffic([[null, 10], [4, null]]), null)
assert.equal(peakOfCombinedTraffic([[2], [4, 5]]), null)
assert.equal(peakOfCombinedTraffic([]), null)
+14
View File
@@ -6,6 +6,20 @@ const meta = z.object({ rxNow: z.boolean(), txNow: z.boolean(), rxSeries: z.arra
sampledAt: timestamp, expiresAt: timestamp.optional(), lastAttemptAt: timestamp.optional(), lastSucceededAt: timestamp.optional(), error: z.string().nullable().optional(),
currentState: z.enum(["current", "unknown", "pending", "error", "stale", "disabled"]).optional() })
export type TrafficObservationMeta = z.infer<typeof meta>
/** Sum only intervals with an observation from every series. */
export function peakOfCombinedTraffic(series: readonly (readonly (number | null)[])[]): number | null {
const length = series[0]?.length
if (!length || series.some(values => values.length !== length)) return null
let peak: number | null = null
for (let index = 0; index < length; index++) {
const slots = series.map(values => values[index])
if (slots.some(value => value == null)) continue
const sum = slots.reduce<number>((total, value) => total + (value ?? 0), 0)
peak = peak === null ? sum : Math.max(peak, sum)
}
return peak
}
const metrics = z.object({ volumeUnit: z.literal("GiB").optional(), rxNow: rate, txNow: rate, rxPeak: rate, txPeak: rate, rxTotal: rate, txTotal: rate,
rxSeries: z.array(rate), txSeries: z.array(rate), observations: meta.optional() }).refine(r =>
(!r.observations || r.observations.rxSeries.length === r.rxSeries.length && r.observations.txSeries.length === r.txSeries.length &&
+5 -2
View File
@@ -36,6 +36,7 @@ export const mcpConnectionPolicySchema = z.object({
status: z.enum(["active", "paused", "revoked"]),
authority: z.literal("service").optional(),
allowUnattendedPlans: z.literal(true).optional(),
unlimitedRates: z.literal(true).optional(),
expiresAt: instant,
mode: mcpModeSchema,
permissions: uniqueStrings,
@@ -45,7 +46,7 @@ export const mcpConnectionPolicySchema = z.object({
limits: mcpLimitsSchema.default(() => mcpLimitsSchema.parse({})),
}).strict().refine(policy => policy.authority === "service"
? policy.expiresAt === MCP_SERVICE_EXPIRATION && policy.mode === "autonomous" && policy.dangerousPolicy === "approval" && !policy.autonomousDangerousOperationIds.length
: !policy.allowUnattendedPlans,
: !policy.allowUnattendedPlans && !policy.unlimitedRates,
"Некорректная политика сервисного подключения")
export const mcpTargetSchema = z.discriminatedUnion("scope", [
@@ -111,6 +112,7 @@ export const mcpPolicyDecisionSchema = z.object({
decision: z.enum(["denied", "approval-required", "allowed"]),
reasons: z.array(z.object({ code: mcpPolicyReasonCodeSchema, message: z.string() }).strict()),
limits: mcpLimitsSchema,
unlimitedRates: z.literal(true).optional(),
}).strict()
export const mcpPolicyPreviewResponseSchema = z.object({
simulation: z.literal(true),
@@ -136,6 +138,7 @@ export const mcpConnectionCreateSchema = z.object({
name: z.string().trim().min(1).max(100),
authority: z.literal("service").optional(),
allowUnattendedPlans: z.literal(true).optional(),
unlimitedRates: z.literal(true).optional(),
expiresAt: instant.nullable(),
mode: mcpModeSchema.default("observer"),
permissions: uniqueStrings,
@@ -146,7 +149,7 @@ export const mcpConnectionCreateSchema = z.object({
limits: mcpLimitsSchema.default(() => mcpLimitsSchema.parse({})),
}).strict().refine(input => input.authority === "service"
? input.expiresAt === null && input.mode === "autonomous" && input.dangerousPolicy === "approval" && !input.autonomousDangerousOperationIds.length
: input.expiresAt !== null && !input.allowUnattendedPlans, "Опция доступна только бессрочному сервисному подключению. Для личного подключения укажите срок действия.")
: input.expiresAt !== null && !input.allowUnattendedPlans && !input.unlimitedRates, "Опция доступна только бессрочному сервисному подключению. Для личного подключения укажите срок действия.")
.refine(input => !input.selectAllServers || !input.scope.serverIds.length, "Выберите все серверы или укажите конкретные ID")
export const mcpConnectionSchema = z.object({
id: z.string().uuid(), name: z.string(), ownerId: z.string(),
+12
View File
@@ -59,6 +59,7 @@ export const flowIngestQualitySchema = z.object({
export const trafficFlowSettingsDtoSchema = z.object({
dataQuality:flowIngestQualitySchema.nullable().optional(),
collectorCountersSource: z.enum(["live", "last-known"]).optional(),
enabled: z.boolean(),
collectorIp: z.string().min(1),
flowListenPort: z.number().int().positive(),
@@ -146,6 +147,7 @@ export const flowTalkerDtoSchema = z.object({
inIface: z.string(),
inIfaceIndex: z.string().optional(),
outIface: z.string().optional(),
accountedIface: z.string().optional(),
nextHop: z.string().optional(),
application: z.string().optional(),
category: z.string().optional(),
@@ -171,6 +173,7 @@ const flowSourceWindowSchema = z.object({
export const flowStatsDtoSchema = z.object({
sourceWindow: flowSourceWindowSchema.optional(),
dataQuality:flowIngestQualitySchema.nullable().optional(),
collectorCountersSource: z.enum(["live", "last-known"]).optional(),
exportersOnline: z.number().int().nonnegative(),
bytesPerMin: z.number().nonnegative(),
uniqueSrc: z.number().int().nonnegative(),
@@ -253,6 +256,14 @@ export const flowPathRowSchema = z.object({
export const flowAnalyticsDtoSchema = z.object({
sourceWindow: flowSourceWindowSchema.optional(),
timeBasis: z.literal("collector-receipt").optional(),
admittedTotals: z.object({
bytes: z.number().int().nonnegative(),
packets: z.number().int().nonnegative(),
from: z.string().datetime(),
to: z.string().datetime(),
minutesWithData: z.number().int().positive(),
}).optional(),
bpsNow: z.number().nonnegative(),
bytes: z.number().nonnegative(),
packets: z.number().nonnegative(),
@@ -309,6 +320,7 @@ export const flowClientsDtoSchema = z.object({
export const flowMonthlyDtoSchema = z.object({
month: z.string(),
bytes: z.number().nonnegative(),
totalsSource: z.enum(["admitted-daily", "legacy-dimensions"]).optional(),
countries: z.array(flowBreakdownRowSchema),
services: z.array(flowBreakdownRowSchema),
asns: z.array(flowBreakdownRowSchema),
+74
View File
@@ -59,3 +59,77 @@ for (const outcome of ["success", "error"] as const) {
await expect(page.getByRole("status").filter({ hasText: "Чтение актуальных правил устройства" })).toHaveCount(0)
})
}
test("Filters: чтение под общей блокировкой повторяется и не показывает роутер недоступным", async ({ page }) => {
const ruleset = { serverId: "1", rules: [
{ id: "saved", community: "65001:120", gateway: "", gatewayTunnelId: "", action: "blackhole", description: "Сохранённое правило" },
] }
let releaseRules!: () => void
const gate = new Promise<void>(resolve => { releaseRules = resolve })
let rulesReading = false, initial = true, overlaps = 0, greReads = 0, gatewayReads = 0
let lock: "free" | "brief" | "held" = "free", conflicts = 0
await page.route("**/health", route => route.fulfill({ json: { ok: true } }))
await page.route("**/api/**", async route => {
const { pathname, searchParams } = new URL(route.request().url())
const conflict = () => route.fulfill({ status: 409, json: { error: "Глобальная конфигурация изменяется другой операцией" } })
if (pathname === "/api/filters/rules" && searchParams.has("serverId")) {
if (lock === "held" || lock === "brief") {
conflicts++
if (lock === "brief") lock = "free"
return conflict()
}
if (initial) {
initial = false
rulesReading = true
await gate
rulesReading = false
}
return route.fulfill({ json: { rulesets: [ruleset], live: true } })
}
if (pathname === "/api/recursive-routes") {
gatewayReads++
if (rulesReading) {
overlaps++
return conflict()
}
if (lock === "held") return conflict()
return route.fulfill({ json: { routes: [] } })
}
if (pathname === "/api/filters/gre-tunnels") {
greReads++
return route.fulfill({ json: { tunnels: [] } })
}
return route.fulfill({ json: pathname === "/api/filters/rules" ? { rulesets: [ruleset], live: false }
: pathname === "/api/servers" ? [{ id: 1, name: "Роутер 1", host: "192.0.2.1", type: "jump-host", enabled: true, country: "RU", site: "TEST", asn: "", status: "online", latency: 1 }]
: pathname === "/api/auth/config" ? { required: false } : {} })
})
await page.goto("/filters")
await expect.poll(() => rulesReading && greReads > 0).toBe(true)
await expect(page.getByRole("button", { name: "Новое правило", exact: true })).toBeDisabled()
releaseRules()
await expect.poll(() => gatewayReads).toBe(1)
expect(overlaps).toBe(0)
const refresh = page.getByRole("button", { name: "Обновить", exact: true })
const add = page.getByRole("button", { name: "Новое правило", exact: true })
const busy = page.getByText("Конфигурация временно занята другой операцией. Показаны последние правила.", { exact: false })
lock = "brief"
await refresh.click()
await expect.poll(() => conflicts).toBe(1)
await expect(add).toBeEnabled()
await expect(busy).toHaveCount(0)
lock = "held"
await refresh.click()
await expect(busy).toBeVisible()
expect(conflicts).toBe(4)
await expect(add).toBeDisabled()
await expect(page.locator("tr[data-row-id]").first()).toContainText("65001:120")
await expect(page.getByText(/Роутер недоступен|ApiClientError|Не удалось прочитать правила с роутера/)).toHaveCount(0)
lock = "free"
await refresh.click()
await expect(add).toBeEnabled()
await expect(busy).toHaveCount(0)
})
+7 -1
View File
@@ -389,7 +389,7 @@ test('synthetic: edit autonomous dangerous operations by group or all at once',
}) })])
})
for (const unattended of [false, true]) test(`synthetic: issue service access with unattended plans ${unattended ? 'enabled' : 'disabled'}`, async ({ page }) => {
for (const { unattended, unlimited } of [{ unattended: true, unlimited: false }, { unattended: false, unlimited: true }]) test(`synthetic: issue service access with ${unlimited ? 'unlimited rates' : 'unattended plans'}`, async ({ page }) => {
const state = await setup(page, ['mm:mcp:admin', 'mm:servers:read'])
await page.goto('/mcp?tab=connections')
await page.getByRole('button', { name: 'Выдать доступ', exact: true }).click()
@@ -405,6 +405,11 @@ for (const unattended of [false, true]) test(`synthetic: issue service access wi
const unattendedChoice = dialog.getByRole('checkbox', { name: 'Выполнять планы без ручного подтверждения', exact: true })
await expect(unattendedChoice).not.toBeChecked()
if (unattended) await unattendedChoice.check()
const rateChoice = dialog.getByRole('checkbox', { name: 'Отключить квоты частоты для этого ключа', exact: true })
await expect(rateChoice).not.toBeChecked()
if (unlimited) await rateChoice.check()
await expect(dialog.getByLabel('Вызовов в минуту', { exact: true })).toHaveCount(unlimited ? 0 : 1)
await expect(dialog.getByLabel('Серверов на план', { exact: true })).toBeVisible()
await next.click()
await expect(dialog.getByText('Сервисное, бессрочное', { exact: false })).toBeVisible()
await dialog.getByRole('button', { name: 'Сохранить доступ', exact: true }).click()
@@ -414,6 +419,7 @@ for (const unattended of [false, true]) test(`synthetic: issue service access wi
scope: { serverIds: [1], operationIds: ['logs.query'], allowGlobal: false },
}) })])
expect(state.mutations[0].body.allowUnattendedPlans).toBe(unattended ? true : undefined)
expect(state.mutations[0].body.unlimitedRates).toBe(unlimited ? true : undefined)
})
test('synthetic: pause, resume, cancelled revoke, revoke, monitor denied outcome, stop automation', async ({ page }) => {
+23
View File
@@ -528,3 +528,26 @@ test('Flow: top-выборка и пустой локальный фильтр
await page.getByRole('button', { name: 'сбросить', exact: true }).click()
await expect(summary).toContainText('Показано 1 из 1 в выборке')
})
test('Flow: сессии фильтруются по учтённому интерфейсу и точному пути', async ({ page }) => {
const control = await setup(page)
const session = {
serverId: '1', serverName: 'Экспортёр тест', src: '192.0.2.1', dst: '198.51.100.1', proto: 6, protoName: 'TCP',
srcPort: 1234, dstPort: 443, bytes: 100, packets: 1, bps: 100, inIface: 'lan', outIface: 'wan',
accountedIface: 'wan', clientId: 'u1', service: 'Тест', category: 'Веб', plane: 'payload',
}
control.metrics = {
conversations: 2,
conversationsList: [session, { ...session, outIface: 'wan2', accountedIface: 'wan2' }],
interfaces: [{ id: 'wan', label: 'wan', bytes: 100, packets: 1, bps: 100, percent: 50 }],
paths: [{ ...session, id: 'test-path', clientName: 'Клиент тест', enId: '', enName: '', ifaces: 'lan, wan' }],
}
await page.getByRole('button', { name: '15м', exact: true }).click()
const summary = page.getByRole('status', { name: 'Выборка сессий' })
await page.getByRole('tab', { name: 'Интерфейсы', exact: true }).click()
await page.getByRole('row').filter({ hasText: 'wan' }).click()
await expect(summary).toContainText('Показано 1 из 2')
await page.getByRole('tab', { name: 'Пути', exact: true }).click()
await page.getByRole('row').filter({ hasText: 'Клиент тест' }).click()
await expect(summary).toContainText('Показано 1 из 2')
})
+10 -2
View File
@@ -15,9 +15,10 @@ for (const mode of ['servers','flows'] as const) for (const minutes of [5,15]) {
const card={id:'1',name,subtitle:'',site:'TEST',country:'RU',status:'online',rxNow:1,txNow:0,sessions:1,bytes:60000,rxSeries:[1,2,1],txSeries:[0,0,0]}
const sourceWindow=mode==='flows'&&span===15?{requestedMinutes:15,effectiveMinutes:7}:undefined
const chartMinutes=sourceWindow?.effectiveMinutes??span
const analytics={bpsNow:1000000,bytes:60000,packets:10,conversations:1,uniqueSrc:1,uniqueDst:1,topProto:'TCP',rxSeries:Array.from({length:chartMinutes},(_,i)=>1+i%3),txSeries:Array(chartMinutes).fill(0),applications:[],protocols:[],sources:[],destinations:[],interfaces:[],conversationsList:[],ifaces:[],live:false,sourceWindow}
const analytics={bpsNow:1000000,bytes:60000,packets:10,conversations:1,uniqueSrc:1,uniqueDst:1,topProto:'TCP',rxSeries:Array.from({length:chartMinutes},(_,i)=>1+i%3),txSeries:Array(chartMinutes).fill(0),applications:[],protocols:[],sources:[],destinations:[],interfaces:[],conversationsList:[],ifaces:[],live:false,sourceWindow,
timeBasis:'collector-receipt',admittedTotals:{bytes:120000,packets:20,from:new Date(end-chartMinutes*60000).toISOString(),to:new Date(end).toISOString(),minutesWithData:chartMinutes}}
if(path.endsWith('/live'))return r.fulfill({status:503,json:{error:'Live выключен в проверке истории'}})
const json=path==='/api/auth/config'?{required:false}:path==='/api/traffic/servers'?{servers:[server]}:
const json=path==='/api/auth/config'?{required:false}:path==='/api/traffic/servers'?{servers:[server],peaks:{rx:2,tx:1}}:
path==='/api/traffic/servers/1'?{server}:path==='/api/traffic/flow/exporters'?{exporters:[card]}:
path==='/api/traffic/flow/analytics'?analytics:path==='/api/traffic/flow/clients'?{clients:[]}:
path==='/api/traffic/flows'?{exportersOnline:1,bytesPerMin:1,uniqueSrc:1,uniqueDst:1,topProto:'TCP',talkers:[],listenerBound:true}:
@@ -30,6 +31,13 @@ for (const mode of ['servers','flows'] as const) for (const minutes of [5,15]) {
await page.getByRole('button',{name:`${minutes}м`,exact:true}).click()
const chart=page.getByRole('region',{name:'История RX/TX'})
await expect(chart).toBeVisible()
if(mode==='flows') {
await expect(page.getByText(/Коллектор принял 120.0 КБ/)).toBeVisible()
await expect(page.getByText('Объём выборки', {exact:true})).toBeVisible()
} else {
await expect(page.getByText('Пик суммы RX', {exact:true})).toBeVisible()
await expect(page.getByText('По общим замерам', {exact:true}).filter({visible:true})).toHaveCount(2)
}
if(mode==='flows'&&minutes===15)await expect(page.getByText('Данные за последние 7 мин из запрошенных 15 мин.')).toBeVisible()
const curves=chart.locator('path.recharts-line-curve')
await expect(curves).toHaveCount(2)