163 lines
11 KiB
TypeScript
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() }
|
|
},
|
|
})
|
|
}
|