Files
MikrotikManager/backend/src/services/server-probe-storage-host-io.ts
T

168 lines
10 KiB
TypeScript

/** Shared opt-in v2 I/O. Request budgets own no backend; SQL leases do.
* Transport and callbacks are trusted source composition, never request JSON. */
import { AsyncLocalStorage } from "node:async_hooks"
import type { PoolClient } from "pg"
import { McpError } from "../modules/mcp/security.js"
import type { ServerProbeJournal } from "./server-probe-execution.js"
import { createSqlServerProbeJournal, type ServerProbeJournalContext, type ServerProbeJournalDependencies } from "./server-probe-journal.js"
import { createServerProbeStorageJournalAdapter } from "./server-probe-storage-journal-adapter.js"
import { connectProbeStorage } from "./server-probe-storage-connection.js"
import { ProbeStorageUnknown, validateProbeStoragePolicy, type ProbeStorageConnection, type ProbeStoragePolicy, type ProbeStorageOptions } from "./server-probe-journal-maintenance.js"
interface Lease { sql: ProbeStorageConnection; client: Pick<PoolClient, "query">; active: boolean }
interface RequestWindow extends ProbeStorageOptions { active: boolean; parent?: RequestWindow }
export type ProbeStorageHostLimits = Omit<ProbeStoragePolicy, "retentionDays">
export interface ProbeStorageJournalExecution { signal?: AbortSignal; deadlineAt?: number }
export type ProbeStorageHostJournal = (context: ServerProbeJournalContext, dependencies: Pick<ServerProbeJournalDependencies, "assertAuthority">, execution?: ProbeStorageJournalExecution) => ServerProbeJournal
const denied = (): never => { throw new McpError("STATE_CONFLICT", "Контекст хранилища диагностики завершён или не подтверждён", 409) }
const combined = (...values: (AbortSignal | undefined)[]) => {
const signals = [...new Set(values.filter((value): value is AbortSignal => !!value))]
return signals.length > 1 ? AbortSignal.any(signals) : signals[0]
}
/** Covers MTU's 260s budget without extending private plan or original authority. */
export function serverProbeStorageJournalDeadline(authorityExpiresAt: number, preparedExpiresAt: number, now = Date.now()) {
const deadlineAt = Math.min(now + 300000, authorityExpiresAt, preparedExpiresAt)
if (![now, authorityExpiresAt, preparedExpiresAt, deadlineAt].every(Number.isSafeInteger) || deadlineAt <= now) return denied()
return deadlineAt
}
export function createProbeStorageHostIo(limits: ProbeStorageHostLimits, transport: "mcp" | "rest") {
if (transport !== "mcp" && transport !== "rest") return denied()
const configured = Object.freeze({ ...limits }), leases = new AsyncLocalStorage<Lease>(), requests = new AsyncLocalStorage<RequestWindow>()
const storagePolicy = (retention: unknown): ProbeStoragePolicy => validateProbeStoragePolicy({ retention_days: retention,
global_bytes: configured.globalBytes, owner_bytes: configured.ownerBytes, global_files: configured.globalFiles,
owner_files: configured.ownerFiles, global_admissions: configured.globalAdmissions, owner_admissions: configured.ownerAdmissions })
storagePolicy(30)
const checkWindow = (value: RequestWindow | undefined) => {
for (let ancestor = value; ancestor; ancestor = ancestor.parent) if (!ancestor.active) return denied()
return value
}
const request = () => checkWindow(requests.getStore())
const current = () => {
request()
const lease = leases.getStore()
if (lease && !lease.active) return denied()
return lease
}
// This layer owns every backend it acquires. Borrowed planner transactions
// remain caller-owned and are never silently released or independently raced.
const owned = async <T>(options: ProbeStorageOptions, work: () => Promise<T>): Promise<T> => {
if (current()) return denied()
const ownerWindow = request()
const physical = await connectProbeStorage(options)
let inTransaction = false, broken = false
const sql: ProbeStorageConnection = {
async query(text, values, queryOptions) {
checkWindow(ownerWindow)
if (!lease?.active || broken) return denied()
if (/^BEGIN\b/i.test(text)) inTransaction = true
try {
const result = await physical.query(text, values, queryOptions)
if (text === "COMMIT" || text === "ROLLBACK") inTransaction = false
return result
} catch (error) { broken = true; physical.release(true); throw error }
},
release(unsafe) { if (unsafe) { broken = true; physical.release(true) } },
}
const lease: Lease = { active: true, sql, client: { query: sql.query as PoolClient["query"] } }
// Bound the whole fixed callback too: owner checks may await local crypto
// or revocation files between SQL statements. Late continuations retain an
// inactive facade and cannot resume SQL after this method has returned.
let abort!: () => void
const stopped = new Promise<never>((_resolve, reject) => {
abort = () => { broken = true; lease.active = false; physical.release(true); reject(new ProbeStorageUnknown()) }
})
const timer = setTimeout(abort, Math.max(1, options.deadlineAt - Date.now()))
options.signal?.addEventListener("abort", abort, { once: true })
try {
const completion = Promise.race([Promise.resolve().then(() => {
checkWindow(ownerWindow)
if (!lease.active || options.signal?.aborted || Date.now() >= options.deadlineAt) throw new ProbeStorageUnknown()
return leases.run(lease, work)
}), stopped])
if (options.signal?.aborted || Date.now() >= options.deadlineAt) abort()
const result = await completion
if (!lease.active || options.signal?.aborted || Date.now() >= options.deadlineAt) { broken = true; throw new ProbeStorageUnknown() }
return result
} finally {
clearTimeout(timer); options.signal?.removeEventListener("abort", abort)
lease.active = false; physical.release(broken || inTransaction)
}
}
const metadataOptions = (extra?: ProbeStorageOptions): ProbeStorageOptions => {
const window = request()
return { deadlineAt: Math.min(Date.now() + 10000, window?.deadlineAt ?? Infinity, extra?.deadlineAt ?? Infinity),
signal: combined(window?.signal, extra?.signal) }
}
const query = async (text: string, values?: unknown[]) => {
const lease = current()
return lease ? lease.sql.query(text, values) : owned(metadataOptions(), () => current()!.sql.query(text, values))
}
const journal: ProbeStorageHostJournal = (rawContext, dependencies, execution) => {
if (rawContext.identity.kind !== transport) return denied()
const context = structuredClone(rawContext), options = { deadlineAt: serverProbeStorageJournalDeadline(context.identity.expiresAt, execution?.deadlineAt ?? NaN), signal: execution?.signal }
let durable: ServerProbeJournal | undefined, busy = false
const run = async <T>(quarantine: boolean, work: (value: ServerProbeJournal) => Promise<T>): Promise<T> => {
if (busy || current()) return denied()
busy = true
try {
// Cleanup deliberately excludes the aborted/expired request window.
return await owned(quarantine ? { deadlineAt: Date.now() + 10000, signal: AbortSignal.timeout(10000) } : options, async () => {
if (!durable) {
const readPolicy = async () => {
const rows = (await query("SELECT enabled,requests_retention_days FROM mcp_settings WHERE id=1")).rows
if (rows.length !== 1 || transport === "mcp" && rows[0].enabled !== true) return denied()
return storagePolicy(rows[0].requests_retention_days)
}
const policy = await readPolicy()
const boundary = createServerProbeStorageJournalAdapter(context, { policy, readPolicy, options,
assertAuthority: dependencies.assertAuthority,
connect: async () => { const lease = current(); if (!lease) return denied(); return lease.sql } })
durable = createSqlServerProbeJournal(context, { assertAuthority: dependencies.assertAuthority, storageBoundary: boundary })
}
return work(durable)
})
} finally { busy = false }
}
return Object.freeze<ServerProbeJournal>({
claim: value => run(false, actual => actual.claim(value)),
intent: value => run(false, actual => actual.intent(value)),
received: value => run(false, actual => actual.received(value)),
finish: value => run(false, actual => actual.finish(value)),
quarantine: value => run(true, actual => actual.quarantine(value)),
read: (receiptId, proof) => run(false, actual => actual.read(receiptId, proof)),
})
}
return {
query, rows: async (text: string, values: unknown[]) => (await query(text, values)).rows,
currentClient: () => current()?.client,
assertOutside() { if (current()) return denied() },
journal,
async runRequest<T>(options: ProbeStorageOptions, work: () => Promise<T>): Promise<T> {
if (current()) return denied()
const parent = request()
if (!Number.isSafeInteger(options.deadlineAt)) return denied()
const window: RequestWindow = { active: true, parent,
deadlineAt: Math.min(options.deadlineAt, Date.now() + 300000, parent?.deadlineAt ?? Infinity),
signal: combined(options.signal, parent?.signal) }
try { return await requests.run(window, work) } finally { window.active = false }
},
async withClient<T>(work: (client: Pick<PoolClient, "query">) => Promise<T>, options?: ProbeStorageOptions): Promise<T> {
const lease = current()
return lease ? work(lease.client) : owned(metadataOptions(options), () => work(current()!.client))
},
async withBorrowed<T>(client: Pick<PoolClient, "query">, work: () => Promise<T>): Promise<T> {
if (current()) return denied()
const ownerWindow = request()
const sql: ProbeStorageConnection = { query: (text, values) => {
checkWindow(ownerWindow)
if (!lease.active) return denied()
return client.query(text, values)
}, release: () => denied() }
const lease: Lease = { active: true, client: { query: sql.query as PoolClient["query"] }, sql }
try { return await leases.run(lease, work) } finally { lease.active = false }
},
}
}