Files
MikrotikManager/backend/src/services/traffic-freshness.ts
T

60 lines
4.8 KiB
TypeScript

import type { TrafficObservations } from "./traffic-rate.js"
export type TrafficCurrentState = "current" | "unknown" | "pending" | "error" | "stale" | "disabled"
export interface TrafficAttempt {
serverUpdatedAt: string | Date; lastAttemptAt: string | Date; lastSucceededAt: string | Date | null; status: string; error: string | null
}
/** Interface running is a native state; enabled WG peer is only configuration, not handshake proof. */
export function trafficBindingStatus(last: { sampledAt: string; countersKnown: boolean; statusKnown: boolean; running: boolean; disabled: boolean } | undefined,
peer: boolean, server: { enabled: boolean; updatedAt: string | Date },
settings: { enabled: boolean; intervalSec: number } | undefined, attempt: TrafficAttempt | undefined, now: number): "online" | "offline" | "unknown" {
if (!last?.countersKnown || !last.statusKnown) return "unknown"
const observed = applyTrafficFreshness({ rxNow: true, txNow: true, rxSeries: [], txSeries: [], sampledAt: last.sampledAt }, server, settings, attempt, now)
if (observed.currentState !== "current") return "unknown"
if (last.disabled || !last.running) return "offline"
return peer ? "unknown" : "online"
}
export function mergeTrafficObservations(parts: TrafficObservations[]): TrafficObservations {
const oldest = (key: "sampledAt" | "lastAttemptAt" | "lastSucceededAt" | "expiresAt") => {
const times = parts.map(p => Date.parse(p[key] ?? ""))
return times.length && times.every(Number.isFinite) ? new Date(Math.min(...times)).toISOString() : null
}
const states: TrafficCurrentState[] = ["error", "pending", "stale", "disabled", "unknown"]
const intervals = parts.map(p => p.measurementIntervalMs)
return { rxNow: !!parts.length && parts.every(p => p.rxNow), txNow: !!parts.length && parts.every(p => p.txNow),
rxSeries: Array.from({ length: parts[0]?.rxSeries.length ?? 60 }, (_, i) => !!parts.length && parts.every(p => p.rxSeries[i])),
txSeries: Array.from({ length: parts[0]?.txSeries.length ?? 60 }, (_, i) => !!parts.length && parts.every(p => p.txSeries[i])),
sampledAt: oldest("sampledAt"), expiresAt: oldest("expiresAt"), lastAttemptAt: oldest("lastAttemptAt"), lastSucceededAt: oldest("lastSucceededAt"),
currentState: parts.length ? states.find(state => parts.some(p => p.currentState === state)) ?? "current" : "unknown",
error: parts.find(p => p.error)?.error ?? null,
...(intervals.some(v => v !== undefined) ? {measurementIntervalMs: intervals.every(v => typeof v === "number" && Number.isFinite(v) && v > 0) ? Math.max(...intervals as number[]) : null} : {}),
}
}
export function applyTrafficFreshness(observations: TrafficObservations,
server: { enabled: boolean; updatedAt: string | Date },
settings: { enabled: boolean; intervalSec: number } | undefined,
attempt: TrafficAttempt | undefined, now: number): TrafficObservations {
const period = Math.max(5, settings?.intervalSec ?? 30) * 1000
const time = (raw: string | Date | null | undefined) => raw instanceof Date ? raw.getTime() : Date.parse(raw ?? "")
const attemptMs = time(attempt?.lastAttemptAt), successMs = time(attempt?.lastSucceededAt)
const interval = observations.measurementIntervalMs
const intervalUnknown = interval !== undefined && (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0 || interval > 3 * period)
let currentState: TrafficCurrentState = "unknown"
if (!server.enabled || settings?.enabled === false) currentState = "disabled"
else if (settings && attempt && time(attempt.serverUpdatedAt) === time(server.updatedAt)) {
if (!Number.isFinite(attemptMs) || attemptMs > now + period || now - attemptMs > 3 * period) currentState = "stale"
else if (attempt.status === "pending") currentState = "pending"
else if (attempt.status === "error") currentState = "error"
else if (attempt.status === "ok" && successMs === attemptMs &&
!intervalUnknown && Date.parse(observations.sampledAt ?? "") === successMs && (observations.rxNow || observations.txNow)) currentState = "current"
}
return { ...observations,
expiresAt: Number.isFinite(attemptMs + 3 * period) && Math.abs(attemptMs + 3 * period) <= 8.64e15 ? new Date(attemptMs + 3 * period).toISOString() : null,
rxNow: currentState === "current" && observations.rxNow,
txNow: currentState === "current" && observations.txNow,
currentState, lastAttemptAt: Number.isFinite(attemptMs) ? new Date(attemptMs).toISOString() : null,
lastSucceededAt: Number.isFinite(successMs) ? new Date(successMs).toISOString() : null,
error: attempt?.error ?? (intervalUnknown ? "Интервал между измерениями слишком велик или неизвестен. История и учтённый объём сохранены; для текущей скорости нужны соседние свежие измерения." : null),
}
}