Codex
369 lines
16 KiB
TypeScript
369 lines
16 KiB
TypeScript
import type { UniDeskConfig } from "./config";
|
|
import { rootPath } from "./config";
|
|
import { runCommand } from "./command";
|
|
import type { RenderedCliResult } from "./output";
|
|
import { egressBenchmarkCompactResult, egressBenchmarkDryRun, egressBenchmarkStartScript, egressBenchmarkStatusScript, type EgressBenchmarkSpec } from "./egress-proxy-benchmark";
|
|
import { egressProxyTrafficCompactResult, egressProxyTrafficScript, type EgressProxyTrafficSpec } from "./egress-proxy-traffic";
|
|
import { readSub2ApiConfig } from "./platform-infra/config";
|
|
import { resolveTarget } from "./platform-infra/manifest";
|
|
import { runK3sBuildBenchmarkCommand } from "./platform-infra-k3s-build-benchmark";
|
|
|
|
type BenchmarkAction = "benchmark" | "benchmark-status" | "benchmark-logs";
|
|
type EgressProxyAction = BenchmarkAction | "traffic";
|
|
|
|
interface BenchmarkOptions {
|
|
action: BenchmarkAction;
|
|
targetId: string;
|
|
profile: "no-mirror";
|
|
confirm: boolean;
|
|
dryRun: boolean;
|
|
samples: number;
|
|
sampleTimeoutSeconds: number;
|
|
timeoutSeconds: number;
|
|
tailLines: number;
|
|
}
|
|
|
|
interface TrafficOptions {
|
|
action: "traffic";
|
|
targetId: string;
|
|
sampleSeconds: number;
|
|
timeoutSeconds: number;
|
|
limit: number;
|
|
}
|
|
|
|
type EgressProxyOptions = BenchmarkOptions | TrafficOptions;
|
|
|
|
export async function runPlatformInfraEgressProxyCommand(_config: UniDeskConfig, args: string[]): Promise<Record<string, unknown> | RenderedCliResult> {
|
|
if (args[0] === "host") {
|
|
const { runPlatformInfraHostProxyCommand } = await import("./platform-infra-host-proxy");
|
|
return await runPlatformInfraHostProxyCommand(_config, args.slice(1));
|
|
}
|
|
if (args[0] === "k3s-build-benchmark") return runK3sBuildBenchmarkCommand(args.slice(1));
|
|
const options = parseEgressProxyOptions(args);
|
|
if (options.action === "traffic") {
|
|
const spec = platformTrafficSpec(options);
|
|
return proxyTraffic(spec, options);
|
|
}
|
|
const spec = platformBenchmarkSpec(options);
|
|
if (options.action === "benchmark-status" || options.action === "benchmark-logs") return benchmarkStatus(spec, options);
|
|
if (options.dryRun) {
|
|
return renderBenchmark({
|
|
ok: true,
|
|
command: "platform-infra egress-proxy benchmark",
|
|
mode: "dry-run",
|
|
mutation: false,
|
|
plan: egressBenchmarkDryRun(spec),
|
|
next: { confirm: `bun scripts/cli.ts platform-infra egress-proxy benchmark --target ${options.targetId} --profile ${options.profile} --confirm` },
|
|
});
|
|
}
|
|
const result = runTrans(spec.route, egressBenchmarkStartScript(spec), options.timeoutSeconds);
|
|
const parsed = parseJson(result.stdout);
|
|
return renderBenchmark({
|
|
ok: result.exitCode === 0,
|
|
command: "platform-infra egress-proxy benchmark",
|
|
mode: "async-job",
|
|
mutation: result.exitCode === 0,
|
|
target: options.targetId,
|
|
profile: options.profile,
|
|
start: typeof parsed === "object" && parsed !== null ? parsed : { stdoutPreview: result.stdout.slice(0, 2000) },
|
|
result: egressBenchmarkCompactResult(result),
|
|
});
|
|
}
|
|
|
|
function proxyTraffic(spec: EgressProxyTrafficSpec, options: TrafficOptions): RenderedCliResult {
|
|
const result = runTrans(spec.route, egressProxyTrafficScript(spec, options.sampleSeconds), options.timeoutSeconds);
|
|
const parsed = parseJson(result.stdout);
|
|
const data = typeof parsed === "object" && parsed !== null
|
|
? parsed as Record<string, unknown>
|
|
: { ok: false, reason: "traffic-output-unparseable", stdoutPreview: result.stdout.slice(0, 2000) };
|
|
return renderTraffic({
|
|
...data,
|
|
ok: result.exitCode === 0 && data.ok !== false,
|
|
command: "platform-infra egress-proxy traffic",
|
|
mode: "traffic",
|
|
target: spec.targetId,
|
|
namespace: spec.namespace,
|
|
serviceName: spec.serviceName,
|
|
servicePort: spec.port,
|
|
sampleSecondsRequested: options.sampleSeconds,
|
|
limit: options.limit,
|
|
result: egressProxyTrafficCompactResult(result),
|
|
});
|
|
}
|
|
|
|
function benchmarkStatus(spec: EgressBenchmarkSpec, options: BenchmarkOptions): RenderedCliResult {
|
|
const result = runTrans(spec.route, egressBenchmarkStatusScript(spec, options.tailLines), options.timeoutSeconds);
|
|
const parsed = parseJson(result.stdout);
|
|
const status = record(record(parsed).status);
|
|
const state = text(status.state, "unknown");
|
|
return renderBenchmark({
|
|
ok: result.exitCode === 0 && (options.action === "benchmark-logs" || state !== "failed"),
|
|
command: `platform-infra egress-proxy ${options.action}`,
|
|
mode: "status",
|
|
mutation: false,
|
|
target: options.targetId,
|
|
profile: options.profile,
|
|
job: typeof parsed === "object" && parsed !== null ? parsed : { stdoutPreview: result.stdout.slice(0, 2000) },
|
|
result: egressBenchmarkCompactResult(result),
|
|
});
|
|
}
|
|
|
|
function platformBenchmarkSpec(options: BenchmarkOptions): EgressBenchmarkSpec {
|
|
const sub2api = readSub2ApiConfig();
|
|
const target = resolveTarget(sub2api, options.targetId);
|
|
const proxy = target.egressProxy;
|
|
if (proxy === null || !proxy.enabled) throw new Error(`target ${target.id} has no enabled egressProxy`);
|
|
return {
|
|
scope: "platform-infra",
|
|
targetId: target.id,
|
|
route: target.route,
|
|
namespace: target.namespace,
|
|
serviceName: proxy.serviceName,
|
|
port: proxy.listenPort,
|
|
noProxy: proxy.noProxy,
|
|
sourceType: proxy.sourceType,
|
|
sourceRef: proxy.sourceRef,
|
|
sourceConfigRef: proxy.sourceConfigRef,
|
|
sourceFingerprint: proxy.sourceFingerprint,
|
|
profile: options.profile,
|
|
samples: options.samples,
|
|
sampleTimeoutSeconds: options.sampleTimeoutSeconds,
|
|
};
|
|
}
|
|
|
|
function platformTrafficSpec(options: TrafficOptions): EgressProxyTrafficSpec {
|
|
const sub2api = readSub2ApiConfig();
|
|
const target = resolveTarget(sub2api, options.targetId);
|
|
const proxy = target.egressProxy;
|
|
if (proxy === null || !proxy.enabled) throw new Error(`target ${target.id} has no enabled egressProxy`);
|
|
return {
|
|
scope: "platform-infra",
|
|
targetId: target.id,
|
|
route: target.route,
|
|
namespace: target.namespace,
|
|
deploymentName: proxy.deploymentName,
|
|
serviceName: proxy.serviceName,
|
|
port: proxy.listenPort,
|
|
sourceType: proxy.sourceType,
|
|
sourceRef: proxy.sourceRef,
|
|
sourceConfigRef: proxy.sourceConfigRef,
|
|
sourceFingerprint: proxy.sourceFingerprint,
|
|
};
|
|
}
|
|
|
|
function parseEgressProxyOptions(args: string[]): EgressProxyOptions {
|
|
const actionRaw = args[0] ?? "benchmark";
|
|
if (!isEgressProxyAction(actionRaw)) {
|
|
throw new Error("platform-infra egress-proxy usage: benchmark|benchmark-status|benchmark-logs|traffic|k3s-build-benchmark --target D601|D518 [--profile no-mirror|no-mirror-600m|real-deps-500m] [--sample-seconds N]");
|
|
}
|
|
const action = actionRaw;
|
|
const rest = args.slice(1);
|
|
const targetId = option(rest, "--target") ?? "D601";
|
|
if (action === "traffic") {
|
|
const sampleSeconds = positiveIntOption(rest, "--sample-seconds", 5, 45);
|
|
return {
|
|
action,
|
|
targetId,
|
|
sampleSeconds,
|
|
timeoutSeconds: positiveIntOption(rest, "--timeout-seconds", Math.min(60, sampleSeconds + 20), 60),
|
|
limit: positiveIntOption(rest, "--limit", 50, 200),
|
|
};
|
|
}
|
|
const profileRaw = option(rest, "--profile") ?? "no-mirror";
|
|
if (profileRaw !== "no-mirror") throw new Error("--profile currently supports no-mirror");
|
|
const confirm = rest.includes("--confirm");
|
|
const dryRun = rest.includes("--dry-run") || !confirm;
|
|
if (confirm && rest.includes("--dry-run")) throw new Error("benchmark accepts only one of --confirm or --dry-run");
|
|
return {
|
|
action,
|
|
targetId,
|
|
profile: profileRaw,
|
|
confirm,
|
|
dryRun: action === "benchmark" ? dryRun : false,
|
|
samples: positiveIntOption(rest, "--samples", 5, 20),
|
|
sampleTimeoutSeconds: positiveIntOption(rest, "--sample-timeout-seconds", 240, 900),
|
|
timeoutSeconds: positiveIntOption(rest, "--timeout-seconds", 30, 60),
|
|
tailLines: positiveIntOption(rest, "--tail", 40, 200),
|
|
};
|
|
}
|
|
|
|
function isEgressProxyAction(value: string): value is EgressProxyAction {
|
|
return value === "benchmark" || value === "benchmark-status" || value === "benchmark-logs" || value === "traffic";
|
|
}
|
|
|
|
function runTrans(route: string, script: string, timeoutSeconds: number) {
|
|
return runCommand(["/root/.local/bin/trans", route, "sh", "--", script], rootPath(), { timeoutMs: timeoutSeconds * 1000 });
|
|
}
|
|
|
|
function option(args: string[], name: string): string | null {
|
|
const index = args.indexOf(name);
|
|
if (index === -1) return null;
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error(`${name} requires a value`);
|
|
return value;
|
|
}
|
|
|
|
function positiveIntOption(args: string[], name: string, defaultValue: number, maxValue: number): number {
|
|
const raw = option(args, name);
|
|
if (raw === null) return defaultValue;
|
|
const value = Number.parseInt(raw, 10);
|
|
if (!Number.isInteger(value) || value < 1 || value > maxValue) throw new Error(`${name} must be an integer from 1 to ${maxValue}`);
|
|
return value;
|
|
}
|
|
|
|
function parseJson(text: string): unknown {
|
|
const trimmed = text.trim();
|
|
if (trimmed.length === 0) return null;
|
|
try { return JSON.parse(trimmed); } catch {
|
|
const start = trimmed.indexOf("{");
|
|
const end = trimmed.lastIndexOf("}");
|
|
if (start >= 0 && end > start) {
|
|
try { return JSON.parse(trimmed.slice(start, end + 1)); } catch {}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function renderBenchmark(result: Record<string, unknown>): RenderedCliResult {
|
|
const start = record(result.start);
|
|
const job = record(result.job);
|
|
const status = record(job.status);
|
|
const plan = record(result.plan);
|
|
const next = record(result.next);
|
|
const rows = Array.isArray(status.rows) ? status.rows.map(record) : [];
|
|
const target = text(result.target ?? plan.target);
|
|
const profile = text(result.profile ?? plan.profile, "no-mirror");
|
|
const statusText = text(status.state, result.ok === false ? "failed" : "ok");
|
|
const logTail = typeof job.logTail === "string" ? job.logTail.trimEnd() : "";
|
|
const lines = [
|
|
`platform-infra egress-proxy ${result.mode === "dry-run" ? "benchmark dry-run" : "benchmark"}`,
|
|
"",
|
|
...table(["TARGET", "PROFILE", "MODE", "STATUS"], [[target, profile, text(result.mode), statusText]]),
|
|
"",
|
|
rows.length === 0 ? "RESULTS\n-" : [
|
|
"RESULTS",
|
|
...table(["TEST", "SUCCESS", "SAMPLES", "P50", "P95", "FAILURES"], rows.map((row) => [
|
|
text(row.test),
|
|
text(row.success),
|
|
text(row.samples),
|
|
text(row.p50Ms),
|
|
text(row.p95Ms),
|
|
JSON.stringify(row.failureFamilies ?? {}),
|
|
])),
|
|
].join("\n"),
|
|
...(logTail.length === 0 ? [] : ["", "LOG TAIL", logTail]),
|
|
"",
|
|
"NEXT",
|
|
` ${text(next.confirm, "")}`,
|
|
` ${text(start.statusCommand, `bun scripts/cli.ts platform-infra egress-proxy benchmark-status --target ${target} --profile ${profile}`)}`,
|
|
` ${text(start.logsCommand, `bun scripts/cli.ts platform-infra egress-proxy benchmark-logs --target ${target} --profile ${profile}`)}`,
|
|
"",
|
|
"Disclosure: default output is a bounded benchmark table; Secret/proxy source values are redacted.",
|
|
].filter((line) => line !== " ");
|
|
return { ok: result.ok !== false, command: text(result.command, "platform-infra egress-proxy benchmark"), renderedText: lines.join("\n"), contentType: "text/plain" };
|
|
}
|
|
|
|
function renderTraffic(result: Record<string, unknown>): RenderedCliResult {
|
|
const totals = record(result.totals);
|
|
const source = record(result.source);
|
|
const next = record(result.next);
|
|
const clients = arrayRecords(result.clients).slice(0, Number(result.limit ?? 50));
|
|
const allClientCount = arrayRecords(result.clients).length;
|
|
const ok = result.ok !== false;
|
|
const target = text(result.target);
|
|
const reason = text(result.reason, ok ? "ok" : "failed");
|
|
const rows = clients.map((client) => {
|
|
const destinations = arrayRecords(client.topDestinations)
|
|
.map((item) => `${text(item.destination)}(${text(item.samples)})`)
|
|
.join(", ");
|
|
return [
|
|
text(client.client),
|
|
text(client.activeConnections, "0"),
|
|
rate(client.totalBps),
|
|
rate(client.uploadBps),
|
|
rate(client.downloadBps),
|
|
bytes(client.windowTotalBytes),
|
|
bytes(client.activeTotalBytes),
|
|
destinations || "-",
|
|
];
|
|
});
|
|
const lines = [
|
|
"PLATFORM-INFRA EGRESS-PROXY TRAFFIC",
|
|
"",
|
|
...table(["TARGET", "STATUS", "POD", "DURATION", "SNAPSHOTS", "ACTIVE"], [[
|
|
target,
|
|
ok ? "ok" : reason,
|
|
text(result.pod),
|
|
`${numberText(result.sampleSecondsActual, result.sampleSecondsRequested)}s`,
|
|
text(result.snapshots, "0"),
|
|
text(totals.activeConnections, "0"),
|
|
]]),
|
|
"",
|
|
"TOTALS",
|
|
...table(["SCOPE", "RATE", "WINDOW", "ACTIVE/CUMULATIVE"], [
|
|
["per-client", rate(totals.clientTotalBps), bytes(totals.clientWindowTotalBytes), bytes(totals.clientActiveTotalBytes)],
|
|
["process", rate(totals.processWindowBps), bytes(totals.processWindowTotalBytes), bytes(totals.processTotalBytes)],
|
|
]),
|
|
"",
|
|
rows.length === 0 ? "CLIENTS\n-" : [
|
|
"CLIENTS",
|
|
...table(["CLIENT", "CONNS", "TOTAL/s", "UP/s", "DOWN/s", "WINDOW", "ACTIVE_TOTAL", "TOP_DESTINATIONS"], rows),
|
|
].join("\n"),
|
|
allClientCount > clients.length ? `\nDisclosure: ${allClientCount - clients.length} more clients hidden; rerun with --limit ${Math.min(200, allClientCount)}.` : "",
|
|
"",
|
|
"SOURCE",
|
|
` target=${target} namespace=${text(result.namespace)} service=${text(result.serviceName)}:${text(result.servicePort)} controller=${text(result.controller)}`,
|
|
` sourceType=${text(source.sourceType)} sourceRef=${text(source.sourceRef)} sourceFingerprint=${text(source.sourceFingerprint)} valuesPrinted=false`,
|
|
"",
|
|
"NEXT",
|
|
` ${text(next.apply, "")}`,
|
|
` ${text(next.status, `bun scripts/cli.ts platform-infra sub2api status --target ${target} --full`)}`,
|
|
` bun scripts/cli.ts platform-infra egress-proxy traffic --target ${target} --sample-seconds 15`,
|
|
"",
|
|
"Disclosure: proxy API is read through pod loopback only. Per-client cumulative bytes are for the sample window; process cumulative is since proxy process start when reported by sing-box.",
|
|
].filter((line) => line !== " ");
|
|
return { ok, command: "platform-infra egress-proxy traffic", renderedText: lines.join("\n"), contentType: "text/plain" };
|
|
}
|
|
|
|
function table(headers: string[], rows: string[][]): string[] {
|
|
const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
|
|
const render = (row: string[]) => row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join(" ").trimEnd();
|
|
return [render(headers), ...rows.map(render)];
|
|
}
|
|
|
|
function record(value: unknown): Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
|
|
}
|
|
|
|
function arrayRecords(value: unknown): Array<Record<string, unknown>> {
|
|
return Array.isArray(value) ? value.map(record) : [];
|
|
}
|
|
|
|
function text(value: unknown, fallback = "-"): string {
|
|
if (value === undefined || value === null || value === "") return fallback;
|
|
return String(value);
|
|
}
|
|
|
|
function numberText(value: unknown, fallback: unknown): string {
|
|
const number = typeof value === "number" && Number.isFinite(value) ? value : Number(fallback);
|
|
if (!Number.isFinite(number)) return text(value);
|
|
return number.toFixed(number >= 10 ? 0 : 1).replace(/\.0$/u, "");
|
|
}
|
|
|
|
function bytes(value: unknown): string {
|
|
const number = Number(value);
|
|
if (!Number.isFinite(number) || number <= 0) return "0 B";
|
|
const units = ["B", "KiB", "MiB", "GiB", "TiB"];
|
|
let scaled = number;
|
|
let unit = 0;
|
|
while (scaled >= 1024 && unit < units.length - 1) {
|
|
scaled /= 1024;
|
|
unit += 1;
|
|
}
|
|
return `${scaled >= 10 || unit === 0 ? scaled.toFixed(0) : scaled.toFixed(1)} ${units[unit]}`;
|
|
}
|
|
|
|
function rate(value: unknown): string {
|
|
return `${bytes(value)}/s`;
|
|
}
|