Import packages/plugin/src/connection-controller.ts
This commit is contained in:
parent
8ab7f1cd98
commit
6dafbea307
|
|
@ -0,0 +1,279 @@
|
|||
import {
|
||||
MAX_SECURE_MESSAGE_BYTES,
|
||||
createRpcError,
|
||||
encodeMessage,
|
||||
type RemoteMessage,
|
||||
} from '@dsh-remote/protocol'
|
||||
import type { IdentityStore } from './identity-store.js'
|
||||
import type { SafeLogger } from './logging.js'
|
||||
import type { RpcRouter } from './rpc-router.js'
|
||||
import type { AuthenticatedPeerChannel } from './types.js'
|
||||
|
||||
interface ActiveConnection {
|
||||
channel: AuthenticatedPeerChannel
|
||||
router: RpcRouter
|
||||
unsubscribe: () => void
|
||||
}
|
||||
|
||||
export interface PeerConnectionContext {
|
||||
transportMode?: () => AuthenticatedPeerChannel['mode']
|
||||
connectionId: string
|
||||
peerDeviceId: string
|
||||
}
|
||||
|
||||
export interface ConnectedPeer {
|
||||
deviceId: string
|
||||
mode?: 'LAN' | 'P2P' | 'TURN' | 'Relay'
|
||||
}
|
||||
|
||||
/**
|
||||
* Who closed the logical peer connection. `CONNECTION_FAILED` exists as both
|
||||
* a Server-issued code and a Host fallback, so the disconnect log must name the
|
||||
* source or operators cannot tell the two paths apart.
|
||||
*/
|
||||
export interface ConnectionCloseDetail {
|
||||
closedBy: 'server' | 'host'
|
||||
retryable?: boolean
|
||||
}
|
||||
|
||||
export type RpcRouterFactory = (
|
||||
context: PeerConnectionContext,
|
||||
send: (message: RemoteMessage) => Promise<void>,
|
||||
) => RpcRouter
|
||||
|
||||
export class ConnectionController {
|
||||
private readonly active = new Map<string, ActiveConnection>()
|
||||
private acceptQueue: Promise<void> = Promise.resolve()
|
||||
|
||||
constructor(
|
||||
private readonly identities: IdentityStore,
|
||||
private readonly createRouter: RpcRouterFactory,
|
||||
private readonly logger?: SafeLogger,
|
||||
) {}
|
||||
|
||||
accept(channel: AuthenticatedPeerChannel): Promise<void> {
|
||||
const operation = this.acceptQueue.then(() => this.acceptOne(channel))
|
||||
this.acceptQueue = operation.catch(() => undefined)
|
||||
return operation
|
||||
}
|
||||
|
||||
private async acceptOne(channel: AuthenticatedPeerChannel): Promise<void> {
|
||||
if (channel.security?.protocol !== 'Noise_IK_25519_ChaChaPoly_SHA256'
|
||||
|| channel.security.connectionId === ''
|
||||
|| channel.security.membershipId === '') {
|
||||
await channel.close('SECURE_CHANNEL_FAILED')
|
||||
throw new ConnectionRejectedError('SECURE_CHANNEL_FAILED', 'The channel is missing its authenticated Noise or membership context.')
|
||||
}
|
||||
if (!this.identities.isTrusted(channel.peerDeviceId, channel.peerIdentityKey)) {
|
||||
await channel.close('PEER_IDENTITY_MISMATCH')
|
||||
throw new ConnectionRejectedError('PEER_IDENTITY_MISMATCH', 'The peer identity does not match local trust.')
|
||||
}
|
||||
const connectionId = channel.security.connectionId
|
||||
const connectionConflict = this.active.get(connectionId)
|
||||
if (connectionConflict !== undefined && connectionConflict.channel.peerDeviceId !== channel.peerDeviceId) {
|
||||
await channel.close('SECURE_CHANNEL_FAILED')
|
||||
throw new ConnectionRejectedError('SECURE_CHANNEL_FAILED', 'The connection id is already bound to another peer.')
|
||||
}
|
||||
|
||||
const replaced = [...this.active.values()].filter(connection => (
|
||||
connection.channel.peerDeviceId === channel.peerDeviceId
|
||||
|| connection.channel.security.connectionId === connectionId
|
||||
))
|
||||
if (replaced.length > 0) {
|
||||
this.logger?.warn('replacing active peer connection', {
|
||||
peerDeviceId: shortId(channel.peerDeviceId),
|
||||
replacedCount: replaced.length,
|
||||
replacedPeerDeviceIds: replaced.map(connection => shortId(connection.channel.peerDeviceId)),
|
||||
})
|
||||
}
|
||||
await Promise.all(replaced.map(connection => this.disconnect(connection, 'CONNECTION_REPLACED')))
|
||||
|
||||
const router = this.createRouter(
|
||||
{ connectionId, peerDeviceId: channel.peerDeviceId, transportMode: () => channel.mode },
|
||||
message => this.sendTo(connectionId, channel, message),
|
||||
)
|
||||
const connection: ActiveConnection = {
|
||||
channel,
|
||||
router,
|
||||
unsubscribe: () => undefined,
|
||||
}
|
||||
this.active.set(connectionId, connection)
|
||||
try {
|
||||
connection.unsubscribe = channel.onMessage(message => { void this.handle(connection, message) })
|
||||
} catch (error) {
|
||||
await this.disconnect(connection)
|
||||
throw error
|
||||
}
|
||||
this.logger?.info('peer connection accepted', {
|
||||
peerDeviceId: shortId(channel.peerDeviceId),
|
||||
connectionId: shortId(connectionId),
|
||||
mode: channel.mode,
|
||||
})
|
||||
}
|
||||
|
||||
isOnline(): boolean { return this.active.size > 0 }
|
||||
|
||||
connectionCount(): number { return this.active.size }
|
||||
|
||||
peerDeviceIds(): string[] {
|
||||
return this.connectedPeers().map(peer => peer.deviceId)
|
||||
}
|
||||
|
||||
connectedPeers(): ConnectedPeer[] {
|
||||
const peers: ConnectedPeer[] = []
|
||||
const seen = new Set<string>()
|
||||
for (const connection of this.active.values()) {
|
||||
const deviceId = connection.channel.peerDeviceId
|
||||
if (seen.has(deviceId)) continue
|
||||
seen.add(deviceId)
|
||||
peers.push({
|
||||
deviceId,
|
||||
...(connection.channel.mode === undefined ? {} : { mode: connection.channel.mode }),
|
||||
})
|
||||
}
|
||||
return peers
|
||||
}
|
||||
|
||||
peerDeviceId(): string | undefined {
|
||||
const peers = this.peerDeviceIds()
|
||||
return peers.length === 1 ? peers[0] : undefined
|
||||
}
|
||||
|
||||
connectionMode(): 'LAN' | 'P2P' | 'TURN' | 'Relay' | 'Disconnected' {
|
||||
const connection = this.active.values().next().value as ActiveConnection | undefined
|
||||
return connection?.channel.mode ?? (connection === undefined ? 'Disconnected' : 'Relay')
|
||||
}
|
||||
|
||||
async send(message: RemoteMessage): Promise<void> {
|
||||
await Promise.all([...this.active.values()].map(connection => this.sendConnection(connection, message)))
|
||||
}
|
||||
|
||||
async revoke(deviceId: string): Promise<void> {
|
||||
const revoked = [...this.active.values()].filter(connection => connection.channel.peerDeviceId === deviceId)
|
||||
await Promise.all(revoked.map(connection => this.disconnect(connection, 'DEVICE_REVOKED')))
|
||||
}
|
||||
|
||||
async closeConnection(connectionId: string, code?: string, detail?: ConnectionCloseDetail): Promise<boolean> {
|
||||
const connection = this.active.get(connectionId)
|
||||
if (connection === undefined) return false
|
||||
await this.disconnect(connection, code, detail)
|
||||
return true
|
||||
}
|
||||
|
||||
async close(): Promise<void> {
|
||||
await this.acceptQueue
|
||||
await Promise.all([...this.active.values()].map(connection => this.disconnect(connection)))
|
||||
}
|
||||
|
||||
private async handle(connection: ActiveConnection, message: RemoteMessage): Promise<void> {
|
||||
if (!this.isActive(connection)) return
|
||||
try {
|
||||
const response = await connection.router.handle(message)
|
||||
if (!this.isActive(connection)) return
|
||||
const responseBytes = encodeMessage(response).byteLength
|
||||
let outbound: RemoteMessage
|
||||
if (responseBytes <= MAX_SECURE_MESSAGE_BYTES) {
|
||||
outbound = response
|
||||
} else {
|
||||
const endpoint = extractEndpoint(message)
|
||||
this.logger?.warn('host response exceeds secure channel', {
|
||||
endpoint,
|
||||
bytes: responseBytes,
|
||||
limit: MAX_SECURE_MESSAGE_BYTES,
|
||||
})
|
||||
outbound = createRpcError(
|
||||
message.id,
|
||||
'RESPONSE_TOO_LARGE',
|
||||
'The Host response is too large for the secure Remote channel. Request a smaller page.',
|
||||
{ maxBytes: MAX_SECURE_MESSAGE_BYTES },
|
||||
true,
|
||||
)
|
||||
}
|
||||
await connection.channel.send(outbound)
|
||||
} catch (error) {
|
||||
this.logger?.warn('peer message handling failed; disconnecting', {
|
||||
peerDeviceId: shortId(connection.channel.peerDeviceId),
|
||||
reason: diagnosticReason(error),
|
||||
})
|
||||
await this.disconnect(connection)
|
||||
}
|
||||
}
|
||||
|
||||
private async sendTo(connectionId: string, channel: AuthenticatedPeerChannel, message: RemoteMessage): Promise<void> {
|
||||
const connection = this.active.get(connectionId)
|
||||
if (connection === undefined || connection.channel !== channel) {
|
||||
throw new Error('peer channel is not active')
|
||||
}
|
||||
await this.sendConnection(connection, message)
|
||||
}
|
||||
|
||||
private async sendConnection(connection: ActiveConnection, message: RemoteMessage): Promise<void> {
|
||||
if (!this.isActive(connection)) {
|
||||
throw new Error('peer channel is not active')
|
||||
}
|
||||
try {
|
||||
await connection.channel.send(message)
|
||||
} catch (error) {
|
||||
this.logger?.warn('peer send failed; disconnecting', {
|
||||
peerDeviceId: shortId(connection.channel.peerDeviceId),
|
||||
messageType: message.type,
|
||||
reason: diagnosticReason(error),
|
||||
})
|
||||
await this.disconnect(connection)
|
||||
throw error instanceof Error ? error : new Error('peer send failed', { cause: error })
|
||||
}
|
||||
}
|
||||
|
||||
private async disconnect(
|
||||
connection: ActiveConnection,
|
||||
code?: string,
|
||||
detail?: ConnectionCloseDetail,
|
||||
): Promise<void> {
|
||||
if (!this.isActive(connection)) return
|
||||
this.active.delete(connection.channel.security.connectionId)
|
||||
connection.unsubscribe()
|
||||
try {
|
||||
await connection.router.closePeerStreams()
|
||||
} finally {
|
||||
await connection.channel.close(code)
|
||||
}
|
||||
this.logger?.info('peer connection disconnected', {
|
||||
peerDeviceId: shortId(connection.channel.peerDeviceId),
|
||||
connectionId: shortId(connection.channel.security.connectionId),
|
||||
code: code ?? 'closed',
|
||||
closedBy: detail?.closedBy ?? 'host',
|
||||
...(detail?.retryable === undefined ? {} : { retryable: detail.retryable }),
|
||||
})
|
||||
}
|
||||
|
||||
private isActive(connection: ActiveConnection): boolean {
|
||||
return this.active.get(connection.channel.security.connectionId) === connection
|
||||
}
|
||||
}
|
||||
|
||||
export class ConnectionRejectedError extends Error {
|
||||
constructor(readonly code: string, message: string) { super(message) }
|
||||
}
|
||||
|
||||
function diagnosticReason(error: unknown): string {
|
||||
const message = error instanceof Error ? error.message : String(error)
|
||||
return message.replace(/\s+/g, ' ').slice(0, 160) || 'Unknown peer connection failure.'
|
||||
}
|
||||
|
||||
function extractEndpoint(message: RemoteMessage): string | undefined {
|
||||
if (!isRecord(message) || !isRecord(message.payload)) return undefined
|
||||
const payload = message.payload
|
||||
if (isRecord(payload.params)) {
|
||||
if (typeof payload.params.endpoint === 'string') return payload.params.endpoint
|
||||
if (typeof payload.params.method === 'string') return payload.params.method
|
||||
}
|
||||
if (typeof payload.endpoint === 'string') return payload.endpoint
|
||||
if (typeof payload.method === 'string') return payload.method
|
||||
return undefined
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
||||
}
|
||||
|
||||
function shortId(value: string): string { return value.length <= 12 ? value : `${value.slice(0, 8)}…${value.slice(-4)}` }
|
||||
Loading…
Reference in New Issue