Files
MikrotikManager/backend/src/services/bandwidth-operator-registry.ts
T

163 lines
11 KiB
TypeScript

/** Explicit operator-only bridge. No startup/runtime registration, default
* source, keys or SQL. Source must pin the FULL installed registry catalog;
* the old managed-only source cannot admit external MAC domains by fallback. */
import { isDeepStrictEqual } from "node:util"
import type { BandwidthScope } from "./bandwidth-admission.js"
import type { ProbeStorageConnection } from "./server-probe-journal-maintenance.js"
import type { BandwidthNodeProofInput } from "./bandwidth-node-source.js"
import { createBandwidthNodeRegistry, type BandwidthNodeRegistryReceipt } from "./bandwidth-node-registry.js"
import { createBandwidthExternalNodeRegistry, type BandwidthExternalNodeRegistryReceipt } from "./bandwidth-external-node-registry.js"
import type { BandwidthNodeObservationEvidence } from "./bandwidth-node-observation.js"
import { assertBandwidthOperatorEnrollmentCoordinator, type createBandwidthOperatorEnrollmentPrerequisite } from "./bandwidth-operator-enrollment.js"
type Coordinator = ReturnType<typeof createBandwidthOperatorEnrollmentPrerequisite>
type Inspection = Awaited<ReturnType<Coordinator["inspect"]>>
export interface BandwidthOperatorRegistrySession {
readonly connection: ProbeStorageConnection
binding(): Promise<{ installationId: string; issuerKeySha256: string; quiescenceProof: string }>
keyedProof(purpose: string, value: unknown): Promise<string>
keyedProofs?(inputs: readonly BandwidthNodeProofInput[]): Promise<readonly string[]>
close(): void
}
export interface BandwidthOperatorRegistryDependencies {
coordinator: Coordinator
source: { open(scope: BandwidthScope, dispatchGuard: () => Promise<void>): Promise<BandwidthOperatorRegistrySession> }
}
export class BandwidthOperatorRegistryError extends Error {
readonly code: string = "BANDWIDTH_OPERATOR_REGISTRY_REFUSED"
readonly automaticReplay = false
constructor() { super("Операторская регистрация bandwidth не подтверждена") }
}
/** Successful COMMIT followed by failed original-authority confirmation must
* be reconciled, never automatically replayed with a new alias/node. */
export class BandwidthOperatorRegistryUnknown extends BandwidthOperatorRegistryError {
override readonly code = "BANDWIDTH_OPERATOR_REGISTRY_UNKNOWN"
}
const refuse = (): never => { throw new BandwidthOperatorRegistryError() }
function captureScope(raw: BandwidthScope): Readonly<BandwidthScope> {
if (!raw || typeof raw !== "object" || Object.getPrototypeOf(raw) !== Object.prototype
|| Reflect.ownKeys(raw).length !== Object.keys(raw).length
|| Object.keys(raw).some(key => !["deadlineAt", "signal"].includes(key))
|| Object.values(Object.getOwnPropertyDescriptors(raw)).some(field => !("value" in field) || !field.enumerable)
|| !Number.isSafeInteger(raw.deadlineAt) || raw.signal !== undefined && !(raw.signal instanceof AbortSignal)) return refuse()
return Object.freeze({ deadlineAt: raw.deadlineAt, signal: raw.signal })
}
function managedEvidence(value: Inspection): BandwidthNodeObservationEvidence {
const { version: _version, peerRef, ...evidence } = value.evidence
if (peerRef.kind !== "server") return refuse()
return Object.freeze({ ...evidence, version: 1, serverId: peerRef.serverId })
}
/** Trusted server composition only. register accepts an existing opaque
* prerequisite and scope; callers cannot pass factories, SQL, guards or keys. */
export function createBandwidthOperatorRegistry(dependencies: BandwidthOperatorRegistryDependencies) {
assertBandwidthOperatorEnrollmentCoordinator(dependencies.coordinator)
const inspect = dependencies.coordinator.inspect.bind(dependencies.coordinator)
const open = dependencies.source.open.bind(dependencies.source)
return Object.freeze({
async register(prerequisite: unknown, rawScope: BandwidthScope): Promise<Readonly<BandwidthNodeRegistryReceipt | BandwidthExternalNodeRegistryReceipt>> {
const input = captureScope(rawScope), original = await inspect(prerequisite, input)
// Never renew the observation/operator grant when opening another lease.
const scope = Object.freeze({ deadlineAt: Math.min(input.deadlineAt, original.authority.expiresAt, original.evidence.expiresAt), signal: input.signal })
const originalPeer = original.evidence.peerRef
let session: BandwidthOperatorRegistrySession | undefined, closed = false, commitStarted = false
const live = () => { if (closed || scope.signal?.aborted || Date.now() >= scope.deadlineAt) refuse() }
const check = async () => {
live(); const current = await inspect(prerequisite, scope); live()
if (current.observation !== original.observation || !isDeepStrictEqual(current, original)) refuse()
return current
}
const frameScope = (requested: BandwidthScope) => {
live()
if (!Number.isSafeInteger(requested.deadlineAt) || requested.deadlineAt > scope.deadlineAt || requested.deadlineAt <= Date.now()
|| requested.signal !== scope.signal || requested.signal?.aborted) refuse()
}
let release!: () => void
const stopped = new Promise<never>((_resolve, reject) => { release = () => { closed = true; session?.close(); reject(commitStarted ? new BandwidthOperatorRegistryUnknown() : new BandwidthOperatorRegistryError()) } })
const timer = setTimeout(release, Math.max(1, scope.deadlineAt - Date.now()))
scope.signal?.addEventListener("abort", release, { once: true })
const run = async () => {
try {
await check()
const opened = await open(scope, async () => { await check() })
// A late open may have acquired a lease after cancellation; destroy it.
if (closed) { opened.close(); return refuse() }
session = opened
const binding = opened.binding.bind(opened), keyedProof = opened.keyedProof.bind(opened), close = opened.close.bind(opened)
const keyedProofs = opened.keyedProofs?.bind(opened)
const query = opened.connection.query.bind(opened.connection), free = opened.connection.release.bind(opened.connection)
const expectedRoot = { installationId: original.authority.installationId, issuerKeySha256: original.authority.issuerKeySha256, quiescenceProof: original.authority.quiescenceProof }
await check(); const actualRoot = await binding(); await check()
if (Object.entries(expectedRoot).some(([key, value]) => actualRoot[key as keyof typeof expectedRoot] !== value)) refuse()
let borrowed = false
const connection: ProbeStorageConnection = Object.freeze({
query: async (text: string, values?: unknown[], options?: { signal?: AbortSignal; timeoutMs: number }) => {
await check(); if (text === "COMMIT") commitStarted = true
const result = await query(text, values, options); await check(); return result
}, release: (destroy?: boolean) => { free(destroy) },
})
const common = {
now: Date.now,
connect: async () => { await check(); if (borrowed) refuse(); borrowed = true; return connection },
keyedProof: async (purpose: string, value: unknown) => { await check(); const result = await keyedProof(purpose, value); await check(); return result },
...(keyedProofs ? { keyedProofs: async (inputs: readonly BandwidthNodeProofInput[]) => { await check(); const result = await keyedProofs(inputs); await check(); return result } } : {}),
}
let receipt: Readonly<BandwidthNodeRegistryReceipt | BandwidthExternalNodeRegistryReceipt>
if (originalPeer.kind === "server") {
const expected = managedEvidence(original)
const registry = createBandwidthNodeRegistry({ ...common,
async inspectAndAuthorize(action, observation, requestedId, requested) {
frameScope(requested)
const current = await check(); frameScope(requested)
const evidence = managedEvidence(current)
if (action !== "register" || observation !== original.observation || requestedId !== undefined && requestedId !== originalPeer.serverId
|| !isDeepStrictEqual(evidence, expected)) refuse()
// Both fields derive synchronously from this ONE genuine fresh
// inspection; this frame is never retained for another guard.
return Object.freeze({ action, observation, scope: requested, serverId: originalPeer.serverId, evidence, authority: current.authority })
},
// Projection/equality is synchronous: one fresh inspect is both
// its before/after boundary. Do not repeat identical file IO.
inspect: async observation => { await check(); if (observation !== original.observation) refuse(); return managedEvidence(original) },
authorize: async (action, serverId, _scope, evidence) => {
await check(); if (action !== "register" || serverId !== originalPeer.serverId || !isDeepStrictEqual(evidence, expected)) refuse()
return original.authority
},
})
receipt = await registry.register(original.observation, scope)
} else {
const registry = createBandwidthExternalNodeRegistry({ ...common,
async inspectAndAuthorize(action, observation, requestedId, requested) {
frameScope(requested)
const current = await check(); frameScope(requested)
if (action !== "register" || observation !== original.observation || requestedId !== undefined && requestedId !== originalPeer.enrollmentId
|| !isDeepStrictEqual(current.evidence, original.evidence)) refuse()
return Object.freeze({ action, observation, scope: requested, enrollmentId: originalPeer.enrollmentId, evidence: current.evidence, authority: current.authority })
},
inspect: async observation => { await check(); if (observation !== original.observation) refuse(); return original.evidence },
authorize: async (action, enrollmentId, _scope, evidence) => {
await check(); if (action !== "register" || enrollmentId !== originalPeer.enrollmentId || !isDeepStrictEqual(evidence, original.evidence)) refuse()
return original.authority
},
})
receipt = await registry.register(original.observation, scope)
}
try { await check() } catch { throw new BandwidthOperatorRegistryUnknown() }
close(); return receipt
} catch (error) {
// The older managed factory does not distinguish post-COMMIT
// refusal. The bridge must retain uncertainty for BOTH peer kinds.
if (commitStarted) {
if (error && typeof error === "object" && "code" in error && String(error.code).endsWith("UNKNOWN")
&& "automaticReplay" in error && error.automaticReplay === false) throw error
throw new BandwidthOperatorRegistryUnknown()
}
throw error
} finally { session?.close() }
}
try { return await Promise.race([run(), stopped]) }
finally { clearTimeout(timer); scope.signal?.removeEventListener("abort", release); closed = true; session?.close() }
},
})
}