60 lines
4.8 KiB
TypeScript
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),
|
|
}
|
|
}
|