mirror of
https://github.com/xtr-dev/rondevu-client.git
synced 2025-12-10 02:43:25 +00:00
feat: v0.9.0 - durable WebRTC connections with automatic reconnection
Major refactor replacing low-level APIs with high-level durable connections.
New Features:
- Automatic reconnection with exponential backoff (1s → 2s → 4s → ... max 30s)
- Message queuing during disconnections
- Durable channels that survive connection drops
- TTL auto-refresh for services (refreshes at 80% of TTL by default)
- Full configuration of timeouts, retry limits, and queue sizes
New API:
- client.exposeService() - Create durable service with automatic TTL refresh
- client.connect() - Create durable connection with automatic reconnection
- client.connectByUuid() - Connect by service UUID
- DurableChannel - Event-based channel wrapper with message queuing
- DurableConnection - Connection manager with reconnection logic
- DurableService - Service manager with TTL auto-refresh
Files Added:
- src/durable/types.ts - Type definitions and enums
- src/durable/reconnection.ts - Exponential backoff utilities
- src/durable/channel.ts - DurableChannel class (358 lines)
- src/durable/connection.ts - DurableConnection class (441 lines)
- src/durable/service.ts - DurableService class (329 lines)
- MIGRATION.md - Comprehensive migration guide
Files Removed:
- src/services.ts - Replaced by DurableService
- src/discovery.ts - Replaced by DurableConnection
BREAKING CHANGES:
- Removed: client.services.*, client.discovery.*, client.createPeer()
- Added: client.exposeService(), client.connect(), client.connectByUuid()
- Handler signature: (channel, peer, connectionId?) → (channel, connectionId)
- Event handlers: .onmessage → .on('message')
- Services: Must call service.start() to begin accepting connections
- Connections: Must call connection.connect() to establish connection
This commit is contained in:
361
src/durable/channel.ts
Normal file
361
src/durable/channel.ts
Normal file
@@ -0,0 +1,361 @@
|
||||
/**
|
||||
* DurableChannel - Message queueing wrapper for RTCDataChannel
|
||||
*
|
||||
* Provides automatic message queuing during disconnections and transparent
|
||||
* flushing when the connection is re-established.
|
||||
*/
|
||||
|
||||
import { EventEmitter } from '../event-emitter.js';
|
||||
import {
|
||||
DurableChannelState
|
||||
} from './types.js';
|
||||
import type {
|
||||
DurableChannelConfig,
|
||||
DurableChannelEvents,
|
||||
QueuedMessage
|
||||
} from './types.js';
|
||||
|
||||
/**
|
||||
* Default configuration for durable channels
|
||||
*/
|
||||
const DEFAULT_CONFIG = {
|
||||
maxQueueSize: 1000,
|
||||
maxMessageAge: 60000, // 1 minute
|
||||
ordered: true,
|
||||
maxRetransmits: undefined
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Durable channel that survives WebRTC peer connection drops
|
||||
*
|
||||
* The DurableChannel wraps an RTCDataChannel and provides:
|
||||
* - Automatic message queuing during disconnections
|
||||
* - Queue flushing on reconnection
|
||||
* - Configurable queue size and message age limits
|
||||
* - RTCDataChannel-compatible API
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* const channel = new DurableChannel('chat', connection, {
|
||||
* maxQueueSize: 500,
|
||||
* maxMessageAge: 30000
|
||||
* });
|
||||
*
|
||||
* channel.on('message', (data) => {
|
||||
* console.log('Received:', data);
|
||||
* });
|
||||
*
|
||||
* channel.on('open', () => {
|
||||
* channel.send('Hello!');
|
||||
* });
|
||||
*
|
||||
* // Messages sent during disconnection are automatically queued
|
||||
* channel.send('This will be queued if disconnected');
|
||||
* ```
|
||||
*/
|
||||
export class DurableChannel extends EventEmitter<DurableChannelEvents> {
|
||||
readonly label: string;
|
||||
readonly config: DurableChannelConfig;
|
||||
|
||||
private _state: DurableChannelState;
|
||||
private underlyingChannel?: RTCDataChannel;
|
||||
private messageQueue: QueuedMessage[] = [];
|
||||
private queueProcessing: boolean = false;
|
||||
private _bufferedAmountLowThreshold: number = 0;
|
||||
|
||||
// Event handlers that need cleanup
|
||||
private openHandler?: () => void;
|
||||
private messageHandler?: (event: MessageEvent) => void;
|
||||
private errorHandler?: (event: Event) => void;
|
||||
private closeHandler?: () => void;
|
||||
private bufferedAmountLowHandler?: () => void;
|
||||
|
||||
constructor(
|
||||
label: string,
|
||||
config?: DurableChannelConfig
|
||||
) {
|
||||
super();
|
||||
this.label = label;
|
||||
this.config = { ...DEFAULT_CONFIG, ...config };
|
||||
this._state = DurableChannelState.CONNECTING;
|
||||
}
|
||||
|
||||
/**
|
||||
* Current channel state
|
||||
*/
|
||||
get readyState(): DurableChannelState {
|
||||
return this._state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Buffered amount from underlying channel (0 if no channel)
|
||||
*/
|
||||
get bufferedAmount(): number {
|
||||
return this.underlyingChannel?.bufferedAmount ?? 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Buffered amount low threshold
|
||||
*/
|
||||
get bufferedAmountLowThreshold(): number {
|
||||
return this._bufferedAmountLowThreshold;
|
||||
}
|
||||
|
||||
set bufferedAmountLowThreshold(value: number) {
|
||||
this._bufferedAmountLowThreshold = value;
|
||||
if (this.underlyingChannel) {
|
||||
this.underlyingChannel.bufferedAmountLowThreshold = value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send data through the channel
|
||||
*
|
||||
* If the channel is open, sends immediately. Otherwise, queues the message
|
||||
* for delivery when the channel reconnects.
|
||||
*
|
||||
* @param data - Data to send
|
||||
*/
|
||||
send(data: string | Blob | ArrayBuffer | ArrayBufferView): void {
|
||||
if (this._state === DurableChannelState.OPEN && this.underlyingChannel) {
|
||||
// Channel is open - send immediately
|
||||
try {
|
||||
this.underlyingChannel.send(data as any);
|
||||
} catch (error) {
|
||||
// Send failed - queue the message
|
||||
this.enqueueMessage(data);
|
||||
this.emit('error', error as Error);
|
||||
}
|
||||
} else if (this._state !== DurableChannelState.CLOSED) {
|
||||
// Channel is not open but not closed - queue the message
|
||||
this.enqueueMessage(data);
|
||||
} else {
|
||||
// Channel is closed - throw error
|
||||
throw new Error('Cannot send on closed channel');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the channel
|
||||
*/
|
||||
close(): void {
|
||||
if (this._state === DurableChannelState.CLOSED ||
|
||||
this._state === DurableChannelState.CLOSING) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._state = DurableChannelState.CLOSING;
|
||||
|
||||
if (this.underlyingChannel) {
|
||||
this.underlyingChannel.close();
|
||||
}
|
||||
|
||||
this._state = DurableChannelState.CLOSED;
|
||||
this.emit('close');
|
||||
}
|
||||
|
||||
/**
|
||||
* Attach to an underlying RTCDataChannel
|
||||
*
|
||||
* This is called when a WebRTC connection is established (or re-established).
|
||||
* The channel will flush any queued messages and forward events.
|
||||
*
|
||||
* @param channel - RTCDataChannel to attach to
|
||||
* @internal
|
||||
*/
|
||||
attachToChannel(channel: RTCDataChannel): void {
|
||||
// Detach from any existing channel first
|
||||
this.detachFromChannel();
|
||||
|
||||
this.underlyingChannel = channel;
|
||||
|
||||
// Set buffered amount low threshold
|
||||
channel.bufferedAmountLowThreshold = this._bufferedAmountLowThreshold;
|
||||
|
||||
// Setup event handlers
|
||||
this.openHandler = () => {
|
||||
this._state = DurableChannelState.OPEN;
|
||||
this.emit('open');
|
||||
|
||||
// Flush queued messages
|
||||
this.flushQueue().catch(error => {
|
||||
this.emit('error', error);
|
||||
});
|
||||
};
|
||||
|
||||
this.messageHandler = (event: MessageEvent) => {
|
||||
this.emit('message', event.data);
|
||||
};
|
||||
|
||||
this.errorHandler = (event: Event) => {
|
||||
this.emit('error', new Error(`Channel error: ${event.type}`));
|
||||
};
|
||||
|
||||
this.closeHandler = () => {
|
||||
if (this._state !== DurableChannelState.CLOSING &&
|
||||
this._state !== DurableChannelState.CLOSED) {
|
||||
// Unexpected close - transition to connecting (will reconnect)
|
||||
this._state = DurableChannelState.CONNECTING;
|
||||
}
|
||||
};
|
||||
|
||||
this.bufferedAmountLowHandler = () => {
|
||||
this.emit('bufferedAmountLow');
|
||||
};
|
||||
|
||||
// Attach handlers
|
||||
channel.addEventListener('open', this.openHandler);
|
||||
channel.addEventListener('message', this.messageHandler);
|
||||
channel.addEventListener('error', this.errorHandler);
|
||||
channel.addEventListener('close', this.closeHandler);
|
||||
channel.addEventListener('bufferedamountlow', this.bufferedAmountLowHandler);
|
||||
|
||||
// If channel is already open, trigger open event
|
||||
if (channel.readyState === 'open') {
|
||||
this.openHandler();
|
||||
} else if (channel.readyState === 'connecting') {
|
||||
this._state = DurableChannelState.CONNECTING;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Detach from the underlying RTCDataChannel
|
||||
*
|
||||
* This is called when a WebRTC connection drops. The channel remains alive
|
||||
* and continues queuing messages.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
detachFromChannel(): void {
|
||||
if (!this.underlyingChannel) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Remove event listeners
|
||||
if (this.openHandler) {
|
||||
this.underlyingChannel.removeEventListener('open', this.openHandler);
|
||||
}
|
||||
if (this.messageHandler) {
|
||||
this.underlyingChannel.removeEventListener('message', this.messageHandler);
|
||||
}
|
||||
if (this.errorHandler) {
|
||||
this.underlyingChannel.removeEventListener('error', this.errorHandler);
|
||||
}
|
||||
if (this.closeHandler) {
|
||||
this.underlyingChannel.removeEventListener('close', this.closeHandler);
|
||||
}
|
||||
if (this.bufferedAmountLowHandler) {
|
||||
this.underlyingChannel.removeEventListener('bufferedamountlow', this.bufferedAmountLowHandler);
|
||||
}
|
||||
|
||||
this.underlyingChannel = undefined;
|
||||
this._state = DurableChannelState.CONNECTING;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enqueue a message for later delivery
|
||||
*/
|
||||
private enqueueMessage(data: string | Blob | ArrayBuffer | ArrayBufferView): void {
|
||||
// Prune old messages first
|
||||
this.pruneOldMessages();
|
||||
|
||||
const message: QueuedMessage = {
|
||||
data,
|
||||
enqueuedAt: Date.now(),
|
||||
id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
|
||||
};
|
||||
|
||||
this.messageQueue.push(message);
|
||||
|
||||
// Handle overflow
|
||||
const maxQueueSize = this.config.maxQueueSize ?? 1000;
|
||||
if (this.messageQueue.length > maxQueueSize) {
|
||||
const excess = this.messageQueue.length - maxQueueSize;
|
||||
this.messageQueue.splice(0, excess);
|
||||
this.emit('queueOverflow', excess);
|
||||
console.warn(
|
||||
`DurableChannel[${this.label}]: Dropped ${excess} messages due to queue overflow`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Flush all queued messages through the channel
|
||||
*/
|
||||
private async flushQueue(): Promise<void> {
|
||||
if (this.queueProcessing || !this.underlyingChannel ||
|
||||
this.underlyingChannel.readyState !== 'open') {
|
||||
return;
|
||||
}
|
||||
|
||||
this.queueProcessing = true;
|
||||
|
||||
try {
|
||||
// Prune old messages before flushing
|
||||
this.pruneOldMessages();
|
||||
|
||||
// Send all queued messages
|
||||
while (this.messageQueue.length > 0) {
|
||||
const message = this.messageQueue.shift();
|
||||
if (!message) break;
|
||||
|
||||
try {
|
||||
this.underlyingChannel.send(message.data as any);
|
||||
} catch (error) {
|
||||
// Send failed - re-queue message
|
||||
this.messageQueue.unshift(message);
|
||||
throw error;
|
||||
}
|
||||
|
||||
// If buffer is getting full, wait for it to drain
|
||||
if (this.underlyingChannel.bufferedAmount > 16 * 1024 * 1024) { // 16MB
|
||||
await new Promise<void>((resolve) => {
|
||||
const checkBuffer = () => {
|
||||
if (!this.underlyingChannel ||
|
||||
this.underlyingChannel.bufferedAmount < 8 * 1024 * 1024) {
|
||||
resolve();
|
||||
} else {
|
||||
setTimeout(checkBuffer, 100);
|
||||
}
|
||||
};
|
||||
checkBuffer();
|
||||
});
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
this.queueProcessing = false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove messages older than maxMessageAge from the queue
|
||||
*/
|
||||
private pruneOldMessages(): void {
|
||||
const maxMessageAge = this.config.maxMessageAge ?? 60000;
|
||||
if (maxMessageAge === Infinity || maxMessageAge <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const now = Date.now();
|
||||
const cutoff = now - maxMessageAge;
|
||||
|
||||
const originalLength = this.messageQueue.length;
|
||||
this.messageQueue = this.messageQueue.filter(msg => msg.enqueuedAt >= cutoff);
|
||||
|
||||
const pruned = originalLength - this.messageQueue.length;
|
||||
if (pruned > 0) {
|
||||
console.warn(
|
||||
`DurableChannel[${this.label}]: Pruned ${pruned} old messages (older than ${maxMessageAge}ms)`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current queue size
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
getQueueSize(): number {
|
||||
return this.messageQueue.length;
|
||||
}
|
||||
}
|
||||
444
src/durable/connection.ts
Normal file
444
src/durable/connection.ts
Normal file
@@ -0,0 +1,444 @@
|
||||
/**
|
||||
* DurableConnection - WebRTC connection with automatic reconnection
|
||||
*
|
||||
* Manages the WebRTC peer lifecycle and automatically reconnects on
|
||||
* connection drops with exponential backoff.
|
||||
*/
|
||||
|
||||
import { EventEmitter } from '../event-emitter.js';
|
||||
import RondevuPeer from '../peer/index.js';
|
||||
import type { RondevuOffers } from '../offers.js';
|
||||
import { DurableChannel } from './channel.js';
|
||||
import { createReconnectionScheduler, type ReconnectionScheduler } from './reconnection.js';
|
||||
import {
|
||||
DurableConnectionState
|
||||
} from './types.js';
|
||||
import type {
|
||||
DurableConnectionConfig,
|
||||
DurableConnectionEvents,
|
||||
ConnectionInfo
|
||||
} from './types.js';
|
||||
|
||||
/**
|
||||
* Default configuration for durable connections
|
||||
*/
|
||||
const DEFAULT_CONFIG: Required<DurableConnectionConfig> = {
|
||||
maxReconnectAttempts: 10,
|
||||
reconnectBackoffBase: 1000,
|
||||
reconnectBackoffMax: 30000,
|
||||
reconnectJitter: 0.2,
|
||||
connectionTimeout: 30000,
|
||||
maxQueueSize: 1000,
|
||||
maxMessageAge: 60000,
|
||||
rtcConfig: {
|
||||
iceServers: [
|
||||
{ urls: 'stun:stun.l.google.com:19302' },
|
||||
{ urls: 'stun:stun1.l.google.com:19302' }
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Durable WebRTC connection that automatically reconnects
|
||||
*
|
||||
* The DurableConnection manages the lifecycle of a WebRTC peer connection
|
||||
* and provides:
|
||||
* - Automatic reconnection with exponential backoff
|
||||
* - Multiple durable channels that survive reconnections
|
||||
* - Configurable retry limits and timeouts
|
||||
* - High-level connection state events
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* const connection = new DurableConnection(
|
||||
* offersApi,
|
||||
* { username: 'alice', serviceFqn: 'chat@1.0.0' },
|
||||
* { maxReconnectAttempts: 5 }
|
||||
* );
|
||||
*
|
||||
* connection.on('connected', () => {
|
||||
* console.log('Connected!');
|
||||
* });
|
||||
*
|
||||
* connection.on('reconnecting', (attempt, max, delay) => {
|
||||
* console.log(`Reconnecting... (${attempt}/${max}, retry in ${delay}ms)`);
|
||||
* });
|
||||
*
|
||||
* const channel = connection.createChannel('chat');
|
||||
* channel.on('message', (data) => {
|
||||
* console.log('Received:', data);
|
||||
* });
|
||||
*
|
||||
* await connection.connect();
|
||||
* ```
|
||||
*/
|
||||
export class DurableConnection extends EventEmitter<DurableConnectionEvents> {
|
||||
readonly connectionId: string;
|
||||
readonly config: Required<DurableConnectionConfig>;
|
||||
readonly connectionInfo: ConnectionInfo;
|
||||
|
||||
private _state: DurableConnectionState;
|
||||
private currentPeer?: RondevuPeer;
|
||||
private channels: Map<string, DurableChannel> = new Map();
|
||||
private reconnectionScheduler?: ReconnectionScheduler;
|
||||
|
||||
// Track peer event handlers for cleanup
|
||||
private peerConnectedHandler?: () => void;
|
||||
private peerDisconnectedHandler?: () => void;
|
||||
private peerFailedHandler?: (error: Error) => void;
|
||||
private peerDataChannelHandler?: (channel: RTCDataChannel) => void;
|
||||
|
||||
constructor(
|
||||
private offersApi: RondevuOffers,
|
||||
connectionInfo: ConnectionInfo,
|
||||
config?: DurableConnectionConfig
|
||||
) {
|
||||
super();
|
||||
this.connectionId = `conn-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||||
this.config = { ...DEFAULT_CONFIG, ...config };
|
||||
this.connectionInfo = connectionInfo;
|
||||
this._state = DurableConnectionState.CONNECTING;
|
||||
}
|
||||
|
||||
/**
|
||||
* Current connection state
|
||||
*/
|
||||
getState(): DurableConnectionState {
|
||||
return this._state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if connection is currently connected
|
||||
*/
|
||||
isConnected(): boolean {
|
||||
return this._state === DurableConnectionState.CONNECTED;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a durable channel on this connection
|
||||
*
|
||||
* The channel will be created on the current peer connection if available,
|
||||
* otherwise it will be created when the connection is established.
|
||||
*
|
||||
* @param label - Channel label
|
||||
* @param options - RTCDataChannel init options
|
||||
* @returns DurableChannel instance
|
||||
*/
|
||||
createChannel(label: string, options?: RTCDataChannelInit): DurableChannel {
|
||||
// Check if channel already exists
|
||||
if (this.channels.has(label)) {
|
||||
throw new Error(`Channel with label '${label}' already exists`);
|
||||
}
|
||||
|
||||
// Create durable channel
|
||||
const durableChannel = new DurableChannel(label, {
|
||||
maxQueueSize: this.config.maxQueueSize,
|
||||
maxMessageAge: this.config.maxMessageAge,
|
||||
ordered: options?.ordered ?? true,
|
||||
maxRetransmits: options?.maxRetransmits
|
||||
});
|
||||
|
||||
this.channels.set(label, durableChannel);
|
||||
|
||||
// If we have a current peer, attach the channel
|
||||
if (this.currentPeer && this._state === DurableConnectionState.CONNECTED) {
|
||||
this.createAndAttachChannel(durableChannel, options);
|
||||
}
|
||||
|
||||
return durableChannel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an existing channel by label
|
||||
*/
|
||||
getChannel(label: string): DurableChannel | undefined {
|
||||
return this.channels.get(label);
|
||||
}
|
||||
|
||||
/**
|
||||
* Establish the initial connection
|
||||
*
|
||||
* @returns Promise that resolves when connected
|
||||
*/
|
||||
async connect(): Promise<void> {
|
||||
if (this._state !== DurableConnectionState.CONNECTING) {
|
||||
throw new Error(`Cannot connect from state: ${this._state}`);
|
||||
}
|
||||
|
||||
try {
|
||||
await this.establishConnection();
|
||||
} catch (error) {
|
||||
this._state = DurableConnectionState.DISCONNECTED;
|
||||
await this.handleDisconnection();
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the connection gracefully
|
||||
*/
|
||||
async close(): Promise<void> {
|
||||
if (this._state === DurableConnectionState.CLOSED) {
|
||||
return;
|
||||
}
|
||||
|
||||
const previousState = this._state;
|
||||
this._state = DurableConnectionState.CLOSED;
|
||||
|
||||
// Cancel any ongoing reconnection
|
||||
if (this.reconnectionScheduler) {
|
||||
this.reconnectionScheduler.cancel();
|
||||
}
|
||||
|
||||
// Close all channels
|
||||
for (const channel of this.channels.values()) {
|
||||
channel.close();
|
||||
}
|
||||
|
||||
// Close peer connection
|
||||
if (this.currentPeer) {
|
||||
await this.currentPeer.close();
|
||||
this.currentPeer = undefined;
|
||||
}
|
||||
|
||||
this.emit('state', this._state, previousState);
|
||||
this.emit('closed');
|
||||
}
|
||||
|
||||
/**
|
||||
* Establish a WebRTC connection
|
||||
*/
|
||||
private async establishConnection(): Promise<void> {
|
||||
// Create new peer
|
||||
const peer = new RondevuPeer(this.offersApi, this.config.rtcConfig);
|
||||
this.currentPeer = peer;
|
||||
|
||||
// Setup peer event handlers
|
||||
this.setupPeerHandlers(peer);
|
||||
|
||||
// Determine connection method based on connection info
|
||||
if (this.connectionInfo.uuid) {
|
||||
// Connect by UUID
|
||||
await this.connectByUuid(peer, this.connectionInfo.uuid);
|
||||
} else if (this.connectionInfo.username && this.connectionInfo.serviceFqn) {
|
||||
// Connect by username and service FQN
|
||||
await this.connectByService(peer, this.connectionInfo.username, this.connectionInfo.serviceFqn);
|
||||
} else {
|
||||
throw new Error('Invalid connection info: must provide either uuid or (username + serviceFqn)');
|
||||
}
|
||||
|
||||
// Wait for connection with timeout
|
||||
await this.waitForConnection(peer);
|
||||
|
||||
// Connection established
|
||||
this.transitionToConnected();
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to a service by UUID
|
||||
*/
|
||||
private async connectByUuid(peer: RondevuPeer, uuid: string): Promise<void> {
|
||||
// Get service details
|
||||
const response = await fetch(`${this.offersApi['baseUrl']}/services/${uuid}`);
|
||||
if (!response.ok) {
|
||||
throw new Error(`Service not found: ${uuid}`);
|
||||
}
|
||||
|
||||
const service = await response.json();
|
||||
|
||||
// Answer the offer
|
||||
await peer.answer(service.offerId, service.sdp, {
|
||||
secret: this.offersApi['credentials'].secret,
|
||||
topics: []
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to a service by username and service FQN
|
||||
*/
|
||||
private async connectByService(peer: RondevuPeer, username: string, serviceFqn: string): Promise<void> {
|
||||
// Query service to get UUID
|
||||
const response = await fetch(`${this.offersApi['baseUrl']}/index/${username}/query`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ serviceFqn })
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(`Service not found: ${username}/${serviceFqn}`);
|
||||
}
|
||||
|
||||
const { uuid } = await response.json();
|
||||
|
||||
// Connect by UUID
|
||||
await this.connectByUuid(peer, uuid);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for peer connection to establish
|
||||
*/
|
||||
private async waitForConnection(peer: RondevuPeer): Promise<void> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const timeout = setTimeout(() => {
|
||||
reject(new Error('Connection timeout'));
|
||||
}, this.config.connectionTimeout);
|
||||
|
||||
const onConnected = () => {
|
||||
clearTimeout(timeout);
|
||||
peer.off('connected', onConnected);
|
||||
peer.off('failed', onFailed);
|
||||
resolve();
|
||||
};
|
||||
|
||||
const onFailed = (error: Error) => {
|
||||
clearTimeout(timeout);
|
||||
peer.off('connected', onConnected);
|
||||
peer.off('failed', onFailed);
|
||||
reject(error);
|
||||
};
|
||||
|
||||
peer.on('connected', onConnected);
|
||||
peer.on('failed', onFailed);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Setup event handlers for peer
|
||||
*/
|
||||
private setupPeerHandlers(peer: RondevuPeer): void {
|
||||
this.peerConnectedHandler = () => {
|
||||
// Connection established - will be handled by waitForConnection
|
||||
};
|
||||
|
||||
this.peerDisconnectedHandler = () => {
|
||||
if (this._state !== DurableConnectionState.CLOSED) {
|
||||
this.handleDisconnection();
|
||||
}
|
||||
};
|
||||
|
||||
this.peerFailedHandler = (error: Error) => {
|
||||
if (this._state !== DurableConnectionState.CLOSED) {
|
||||
console.error('Peer connection failed:', error);
|
||||
this.handleDisconnection();
|
||||
}
|
||||
};
|
||||
|
||||
this.peerDataChannelHandler = (channel: RTCDataChannel) => {
|
||||
// Find matching durable channel and attach
|
||||
const durableChannel = this.channels.get(channel.label);
|
||||
if (durableChannel) {
|
||||
durableChannel.attachToChannel(channel);
|
||||
}
|
||||
};
|
||||
|
||||
peer.on('connected', this.peerConnectedHandler);
|
||||
peer.on('disconnected', this.peerDisconnectedHandler);
|
||||
peer.on('failed', this.peerFailedHandler);
|
||||
peer.on('datachannel', this.peerDataChannelHandler);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transition to connected state
|
||||
*/
|
||||
private transitionToConnected(): void {
|
||||
const previousState = this._state;
|
||||
this._state = DurableConnectionState.CONNECTED;
|
||||
|
||||
// Reset reconnection scheduler if it exists
|
||||
if (this.reconnectionScheduler) {
|
||||
this.reconnectionScheduler.reset();
|
||||
}
|
||||
|
||||
// Attach all channels to the new peer connection
|
||||
for (const [label, channel] of this.channels) {
|
||||
if (this.currentPeer) {
|
||||
this.createAndAttachChannel(channel);
|
||||
}
|
||||
}
|
||||
|
||||
this.emit('state', this._state, previousState);
|
||||
this.emit('connected');
|
||||
}
|
||||
|
||||
/**
|
||||
* Create underlying RTCDataChannel and attach to durable channel
|
||||
*/
|
||||
private createAndAttachChannel(
|
||||
durableChannel: DurableChannel,
|
||||
options?: RTCDataChannelInit
|
||||
): void {
|
||||
if (!this.currentPeer) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if peer already has this channel (received via datachannel event)
|
||||
// If not, create it
|
||||
const senders = (this.currentPeer.pc as any).getSenders?.() || [];
|
||||
const existingChannel = Array.from(senders as RTCRtpSender[])
|
||||
.map((sender) => (sender as any).channel as RTCDataChannel)
|
||||
.find(ch => ch && ch.label === durableChannel.label);
|
||||
|
||||
if (existingChannel) {
|
||||
durableChannel.attachToChannel(existingChannel);
|
||||
} else {
|
||||
// Create new channel on peer
|
||||
const rtcChannel = this.currentPeer.createDataChannel(
|
||||
durableChannel.label,
|
||||
options
|
||||
);
|
||||
durableChannel.attachToChannel(rtcChannel);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle connection disconnection
|
||||
*/
|
||||
private async handleDisconnection(): Promise<void> {
|
||||
if (this._state === DurableConnectionState.CLOSED ||
|
||||
this._state === DurableConnectionState.FAILED) {
|
||||
return;
|
||||
}
|
||||
|
||||
const previousState = this._state;
|
||||
this._state = DurableConnectionState.RECONNECTING;
|
||||
|
||||
this.emit('state', this._state, previousState);
|
||||
this.emit('disconnected');
|
||||
|
||||
// Detach all channels (but keep them alive)
|
||||
for (const channel of this.channels.values()) {
|
||||
channel.detachFromChannel();
|
||||
}
|
||||
|
||||
// Close old peer
|
||||
if (this.currentPeer) {
|
||||
await this.currentPeer.close();
|
||||
this.currentPeer = undefined;
|
||||
}
|
||||
|
||||
// Create or use existing reconnection scheduler
|
||||
if (!this.reconnectionScheduler) {
|
||||
this.reconnectionScheduler = createReconnectionScheduler({
|
||||
maxAttempts: this.config.maxReconnectAttempts,
|
||||
backoffBase: this.config.reconnectBackoffBase,
|
||||
backoffMax: this.config.reconnectBackoffMax,
|
||||
jitter: this.config.reconnectJitter,
|
||||
onReconnect: async () => {
|
||||
await this.establishConnection();
|
||||
},
|
||||
onMaxAttemptsExceeded: (error) => {
|
||||
const prevState = this._state;
|
||||
this._state = DurableConnectionState.FAILED;
|
||||
this.emit('state', this._state, prevState);
|
||||
this.emit('failed', error, true);
|
||||
},
|
||||
onBeforeAttempt: (attempt, max, delay) => {
|
||||
this.emit('reconnecting', attempt, max, delay);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Schedule reconnection
|
||||
this.reconnectionScheduler.schedule();
|
||||
}
|
||||
}
|
||||
200
src/durable/reconnection.ts
Normal file
200
src/durable/reconnection.ts
Normal file
@@ -0,0 +1,200 @@
|
||||
/**
|
||||
* Reconnection utilities for durable connections
|
||||
*
|
||||
* This module provides utilities for managing reconnection logic with
|
||||
* exponential backoff and jitter.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Calculate exponential backoff delay with jitter
|
||||
*
|
||||
* @param attempt - Current attempt number (0-indexed)
|
||||
* @param base - Base delay in milliseconds
|
||||
* @param max - Maximum delay in milliseconds
|
||||
* @param jitter - Jitter factor (0-1), e.g., 0.2 for ±20%
|
||||
* @returns Delay in milliseconds with jitter applied
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* calculateBackoff(0, 1000, 30000, 0.2) // ~1000ms ± 20%
|
||||
* calculateBackoff(1, 1000, 30000, 0.2) // ~2000ms ± 20%
|
||||
* calculateBackoff(2, 1000, 30000, 0.2) // ~4000ms ± 20%
|
||||
* calculateBackoff(5, 1000, 30000, 0.2) // ~30000ms ± 20% (capped at max)
|
||||
* ```
|
||||
*/
|
||||
export function calculateBackoff(
|
||||
attempt: number,
|
||||
base: number,
|
||||
max: number,
|
||||
jitter: number
|
||||
): number {
|
||||
// Calculate exponential delay: base * 2^attempt
|
||||
const exponential = base * Math.pow(2, attempt);
|
||||
|
||||
// Cap at maximum
|
||||
const capped = Math.min(exponential, max);
|
||||
|
||||
// Apply jitter: ± (jitter * capped)
|
||||
const jitterAmount = capped * jitter;
|
||||
const randomJitter = (Math.random() * 2 - 1) * jitterAmount;
|
||||
|
||||
// Return delay with jitter, ensuring it's not negative
|
||||
return Math.max(0, capped + randomJitter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration for reconnection scheduler
|
||||
*/
|
||||
export interface ReconnectionSchedulerConfig {
|
||||
/** Maximum number of reconnection attempts */
|
||||
maxAttempts: number;
|
||||
|
||||
/** Base delay for exponential backoff */
|
||||
backoffBase: number;
|
||||
|
||||
/** Maximum delay between attempts */
|
||||
backoffMax: number;
|
||||
|
||||
/** Jitter factor for randomizing delays */
|
||||
jitter: number;
|
||||
|
||||
/** Callback invoked for each reconnection attempt */
|
||||
onReconnect: () => Promise<void>;
|
||||
|
||||
/** Callback invoked when max attempts exceeded */
|
||||
onMaxAttemptsExceeded: (error: Error) => void;
|
||||
|
||||
/** Optional callback invoked before each attempt */
|
||||
onBeforeAttempt?: (attempt: number, maxAttempts: number, delay: number) => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconnection scheduler state
|
||||
*/
|
||||
export interface ReconnectionScheduler {
|
||||
/** Current attempt number */
|
||||
attempt: number;
|
||||
|
||||
/** Whether scheduler is active */
|
||||
active: boolean;
|
||||
|
||||
/** Schedule next reconnection attempt */
|
||||
schedule: () => void;
|
||||
|
||||
/** Cancel scheduled reconnection */
|
||||
cancel: () => void;
|
||||
|
||||
/** Reset attempt counter */
|
||||
reset: () => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a reconnection scheduler
|
||||
*
|
||||
* @param config - Scheduler configuration
|
||||
* @returns Reconnection scheduler instance
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* const scheduler = createReconnectionScheduler({
|
||||
* maxAttempts: 10,
|
||||
* backoffBase: 1000,
|
||||
* backoffMax: 30000,
|
||||
* jitter: 0.2,
|
||||
* onReconnect: async () => {
|
||||
* await connect();
|
||||
* },
|
||||
* onMaxAttemptsExceeded: (error) => {
|
||||
* console.error('Failed to reconnect:', error);
|
||||
* },
|
||||
* onBeforeAttempt: (attempt, max, delay) => {
|
||||
* console.log(`Reconnecting in ${delay}ms (${attempt}/${max})...`);
|
||||
* }
|
||||
* });
|
||||
*
|
||||
* // Start reconnection
|
||||
* scheduler.schedule();
|
||||
*
|
||||
* // Cancel reconnection
|
||||
* scheduler.cancel();
|
||||
* ```
|
||||
*/
|
||||
export function createReconnectionScheduler(
|
||||
config: ReconnectionSchedulerConfig
|
||||
): ReconnectionScheduler {
|
||||
let attempt = 0;
|
||||
let active = false;
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
|
||||
const schedule = () => {
|
||||
// Cancel any existing timer
|
||||
if (timer) {
|
||||
clearTimeout(timer);
|
||||
timer = undefined;
|
||||
}
|
||||
|
||||
// Check if max attempts exceeded
|
||||
if (attempt >= config.maxAttempts) {
|
||||
active = false;
|
||||
config.onMaxAttemptsExceeded(
|
||||
new Error(`Max reconnection attempts exceeded (${config.maxAttempts})`)
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate delay
|
||||
const delay = calculateBackoff(
|
||||
attempt,
|
||||
config.backoffBase,
|
||||
config.backoffMax,
|
||||
config.jitter
|
||||
);
|
||||
|
||||
// Notify before attempt
|
||||
if (config.onBeforeAttempt) {
|
||||
config.onBeforeAttempt(attempt + 1, config.maxAttempts, delay);
|
||||
}
|
||||
|
||||
// Mark as active
|
||||
active = true;
|
||||
|
||||
// Schedule reconnection
|
||||
timer = setTimeout(async () => {
|
||||
attempt++;
|
||||
try {
|
||||
await config.onReconnect();
|
||||
// Success - reset scheduler
|
||||
attempt = 0;
|
||||
active = false;
|
||||
} catch (error) {
|
||||
// Failure - schedule next attempt
|
||||
schedule();
|
||||
}
|
||||
}, delay);
|
||||
};
|
||||
|
||||
const cancel = () => {
|
||||
if (timer) {
|
||||
clearTimeout(timer);
|
||||
timer = undefined;
|
||||
}
|
||||
active = false;
|
||||
};
|
||||
|
||||
const reset = () => {
|
||||
cancel();
|
||||
attempt = 0;
|
||||
};
|
||||
|
||||
return {
|
||||
get attempt() {
|
||||
return attempt;
|
||||
},
|
||||
get active() {
|
||||
return active;
|
||||
},
|
||||
schedule,
|
||||
cancel,
|
||||
reset
|
||||
};
|
||||
}
|
||||
329
src/durable/service.ts
Normal file
329
src/durable/service.ts
Normal file
@@ -0,0 +1,329 @@
|
||||
/**
|
||||
* DurableService - Service with automatic TTL refresh
|
||||
*
|
||||
* Manages service publishing with automatic reconnection for incoming
|
||||
* connections and TTL auto-refresh to prevent expiration.
|
||||
*/
|
||||
|
||||
import { EventEmitter } from '../event-emitter.js';
|
||||
import { ServicePool, type PoolStatus } from '../service-pool.js';
|
||||
import type { RondevuOffers } from '../offers.js';
|
||||
import { DurableChannel } from './channel.js';
|
||||
import type {
|
||||
DurableServiceConfig,
|
||||
DurableServiceEvents,
|
||||
ServiceInfo
|
||||
} from './types.js';
|
||||
|
||||
/**
|
||||
* Connection handler callback
|
||||
*/
|
||||
export type ConnectionHandler = (
|
||||
channel: DurableChannel,
|
||||
connectionId: string
|
||||
) => void | Promise<void>;
|
||||
|
||||
/**
|
||||
* Default configuration for durable services
|
||||
*/
|
||||
const DEFAULT_CONFIG = {
|
||||
isPublic: false,
|
||||
ttlRefreshMargin: 0.2,
|
||||
poolSize: 1,
|
||||
pollingInterval: 2000,
|
||||
maxReconnectAttempts: 10,
|
||||
reconnectBackoffBase: 1000,
|
||||
reconnectBackoffMax: 30000,
|
||||
reconnectJitter: 0.2,
|
||||
connectionTimeout: 30000,
|
||||
maxQueueSize: 1000,
|
||||
maxMessageAge: 60000,
|
||||
rtcConfig: {
|
||||
iceServers: [
|
||||
{ urls: 'stun:stun.l.google.com:19302' },
|
||||
{ urls: 'stun:stun1.l.google.com:19302' }
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Durable service that automatically refreshes TTL and handles reconnections
|
||||
*
|
||||
* The DurableService manages service publishing and provides:
|
||||
* - Automatic TTL refresh before expiration
|
||||
* - Durable connections for incoming peers
|
||||
* - Connection pooling for multiple simultaneous connections
|
||||
* - High-level connection lifecycle events
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* const service = new DurableService(
|
||||
* offersApi,
|
||||
* (channel, connectionId) => {
|
||||
* channel.on('message', (data) => {
|
||||
* console.log(`Message from ${connectionId}:`, data);
|
||||
* channel.send(`Echo: ${data}`);
|
||||
* });
|
||||
* },
|
||||
* {
|
||||
* username: 'alice',
|
||||
* privateKey: keypair.privateKey,
|
||||
* serviceFqn: 'chat@1.0.0',
|
||||
* poolSize: 10
|
||||
* }
|
||||
* );
|
||||
*
|
||||
* service.on('published', (serviceId, uuid) => {
|
||||
* console.log(`Service published: ${uuid}`);
|
||||
* });
|
||||
*
|
||||
* service.on('connection', (connectionId) => {
|
||||
* console.log(`New connection: ${connectionId}`);
|
||||
* });
|
||||
*
|
||||
* await service.start();
|
||||
* ```
|
||||
*/
|
||||
export class DurableService extends EventEmitter<DurableServiceEvents> {
|
||||
readonly config: Required<DurableServiceConfig>;
|
||||
|
||||
private serviceId?: string;
|
||||
private uuid?: string;
|
||||
private expiresAt?: number;
|
||||
private ttlRefreshTimer?: ReturnType<typeof setTimeout>;
|
||||
private servicePool?: ServicePool;
|
||||
private activeChannels: Map<string, DurableChannel> = new Map();
|
||||
|
||||
constructor(
|
||||
private offersApi: RondevuOffers,
|
||||
private baseUrl: string,
|
||||
private credentials: { peerId: string; secret: string },
|
||||
private handler: ConnectionHandler,
|
||||
config: DurableServiceConfig
|
||||
) {
|
||||
super();
|
||||
this.config = { ...DEFAULT_CONFIG, ...config } as Required<DurableServiceConfig>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start the service
|
||||
*
|
||||
* Publishes the service and begins accepting connections.
|
||||
*
|
||||
* @returns Service information
|
||||
*/
|
||||
async start(): Promise<ServiceInfo> {
|
||||
if (this.servicePool) {
|
||||
throw new Error('Service already started');
|
||||
}
|
||||
|
||||
// Create and start service pool
|
||||
this.servicePool = new ServicePool(
|
||||
this.baseUrl,
|
||||
this.credentials,
|
||||
{
|
||||
username: this.config.username,
|
||||
privateKey: this.config.privateKey,
|
||||
serviceFqn: this.config.serviceFqn,
|
||||
rtcConfig: this.config.rtcConfig,
|
||||
isPublic: this.config.isPublic,
|
||||
metadata: this.config.metadata,
|
||||
ttl: this.config.ttl,
|
||||
poolSize: this.config.poolSize,
|
||||
pollingInterval: this.config.pollingInterval,
|
||||
handler: (channel, peer, connectionId) => {
|
||||
this.handleNewConnection(channel, connectionId);
|
||||
},
|
||||
onPoolStatus: (status) => {
|
||||
// Could emit pool status event if needed
|
||||
},
|
||||
onError: (error, context) => {
|
||||
this.emit('error', error, context);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
const handle = await this.servicePool.start();
|
||||
|
||||
// Store service info
|
||||
this.serviceId = handle.serviceId;
|
||||
this.uuid = handle.uuid;
|
||||
this.expiresAt = Date.now() + (this.config.ttl || 300000); // Default 5 minutes
|
||||
|
||||
this.emit('published', this.serviceId, this.uuid);
|
||||
|
||||
// Schedule TTL refresh
|
||||
this.scheduleRefresh();
|
||||
|
||||
return {
|
||||
serviceId: this.serviceId,
|
||||
uuid: this.uuid,
|
||||
expiresAt: this.expiresAt
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop the service
|
||||
*
|
||||
* Unpublishes the service and closes all active connections.
|
||||
*/
|
||||
async stop(): Promise<void> {
|
||||
// Cancel TTL refresh
|
||||
if (this.ttlRefreshTimer) {
|
||||
clearTimeout(this.ttlRefreshTimer);
|
||||
this.ttlRefreshTimer = undefined;
|
||||
}
|
||||
|
||||
// Close all active channels
|
||||
for (const channel of this.activeChannels.values()) {
|
||||
channel.close();
|
||||
}
|
||||
this.activeChannels.clear();
|
||||
|
||||
// Stop service pool
|
||||
if (this.servicePool) {
|
||||
await this.servicePool.stop();
|
||||
this.servicePool = undefined;
|
||||
}
|
||||
|
||||
this.emit('closed');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get list of active connection IDs
|
||||
*/
|
||||
getActiveConnections(): string[] {
|
||||
return Array.from(this.activeChannels.keys());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get service information
|
||||
*/
|
||||
getServiceInfo(): ServiceInfo | null {
|
||||
if (!this.serviceId || !this.uuid || !this.expiresAt) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
serviceId: this.serviceId,
|
||||
uuid: this.uuid,
|
||||
expiresAt: this.expiresAt
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule TTL refresh
|
||||
*/
|
||||
private scheduleRefresh(): void {
|
||||
if (!this.expiresAt || !this.config.ttl) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Cancel existing timer
|
||||
if (this.ttlRefreshTimer) {
|
||||
clearTimeout(this.ttlRefreshTimer);
|
||||
}
|
||||
|
||||
// Calculate refresh time (default: refresh at 80% of TTL)
|
||||
const timeUntilExpiry = this.expiresAt - Date.now();
|
||||
const refreshMargin = timeUntilExpiry * this.config.ttlRefreshMargin;
|
||||
const refreshTime = Math.max(0, timeUntilExpiry - refreshMargin);
|
||||
|
||||
// Schedule refresh
|
||||
this.ttlRefreshTimer = setTimeout(() => {
|
||||
this.refreshServiceTTL().catch(error => {
|
||||
this.emit('error', error, 'ttl-refresh');
|
||||
// Retry after short delay
|
||||
setTimeout(() => this.scheduleRefresh(), 5000);
|
||||
});
|
||||
}, refreshTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* Refresh service TTL
|
||||
*/
|
||||
private async refreshServiceTTL(): Promise<void> {
|
||||
if (!this.serviceId || !this.uuid) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Delete old service
|
||||
await this.servicePool?.stop();
|
||||
|
||||
// Recreate service pool (this republishes the service)
|
||||
this.servicePool = new ServicePool(
|
||||
this.baseUrl,
|
||||
this.credentials,
|
||||
{
|
||||
username: this.config.username,
|
||||
privateKey: this.config.privateKey,
|
||||
serviceFqn: this.config.serviceFqn,
|
||||
rtcConfig: this.config.rtcConfig,
|
||||
isPublic: this.config.isPublic,
|
||||
metadata: this.config.metadata,
|
||||
ttl: this.config.ttl,
|
||||
poolSize: this.config.poolSize,
|
||||
pollingInterval: this.config.pollingInterval,
|
||||
handler: (channel, peer, connectionId) => {
|
||||
this.handleNewConnection(channel, connectionId);
|
||||
},
|
||||
onPoolStatus: (status) => {
|
||||
// Could emit pool status event if needed
|
||||
},
|
||||
onError: (error, context) => {
|
||||
this.emit('error', error, context);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
const handle = await this.servicePool.start();
|
||||
|
||||
// Update service info
|
||||
this.serviceId = handle.serviceId;
|
||||
this.uuid = handle.uuid;
|
||||
this.expiresAt = Date.now() + (this.config.ttl || 300000);
|
||||
|
||||
this.emit('ttl-refreshed', this.expiresAt);
|
||||
|
||||
// Schedule next refresh
|
||||
this.scheduleRefresh();
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle new incoming connection
|
||||
*/
|
||||
private handleNewConnection(channel: RTCDataChannel, connectionId: string): void {
|
||||
// Create durable channel
|
||||
const durableChannel = new DurableChannel(channel.label, {
|
||||
maxQueueSize: this.config.maxQueueSize,
|
||||
maxMessageAge: this.config.maxMessageAge
|
||||
});
|
||||
|
||||
// Attach to underlying channel
|
||||
durableChannel.attachToChannel(channel);
|
||||
|
||||
// Track channel
|
||||
this.activeChannels.set(connectionId, durableChannel);
|
||||
|
||||
// Setup cleanup on close
|
||||
durableChannel.on('close', () => {
|
||||
this.activeChannels.delete(connectionId);
|
||||
this.emit('disconnection', connectionId);
|
||||
});
|
||||
|
||||
// Emit connection event
|
||||
this.emit('connection', connectionId);
|
||||
|
||||
// Invoke user handler
|
||||
try {
|
||||
const result = this.handler(durableChannel, connectionId);
|
||||
if (result && typeof result.then === 'function') {
|
||||
result.catch(error => {
|
||||
this.emit('error', error, 'handler');
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
this.emit('error', error as Error, 'handler');
|
||||
}
|
||||
}
|
||||
}
|
||||
184
src/durable/types.ts
Normal file
184
src/durable/types.ts
Normal file
@@ -0,0 +1,184 @@
|
||||
/**
|
||||
* Type definitions for durable WebRTC connections
|
||||
*
|
||||
* This module defines all interfaces, enums, and types used by the durable
|
||||
* connection system for automatic reconnection and message queuing.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Connection state enum
|
||||
*/
|
||||
export enum DurableConnectionState {
|
||||
CONNECTING = 'connecting',
|
||||
CONNECTED = 'connected',
|
||||
RECONNECTING = 'reconnecting',
|
||||
DISCONNECTED = 'disconnected',
|
||||
FAILED = 'failed',
|
||||
CLOSED = 'closed'
|
||||
}
|
||||
|
||||
/**
|
||||
* Channel state enum
|
||||
*/
|
||||
export enum DurableChannelState {
|
||||
CONNECTING = 'connecting',
|
||||
OPEN = 'open',
|
||||
CLOSING = 'closing',
|
||||
CLOSED = 'closed'
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration for durable connections
|
||||
*/
|
||||
export interface DurableConnectionConfig {
|
||||
/** Maximum number of reconnection attempts (default: 10) */
|
||||
maxReconnectAttempts?: number;
|
||||
|
||||
/** Base delay for exponential backoff in milliseconds (default: 1000) */
|
||||
reconnectBackoffBase?: number;
|
||||
|
||||
/** Maximum delay between reconnection attempts in milliseconds (default: 30000) */
|
||||
reconnectBackoffMax?: number;
|
||||
|
||||
/** Jitter factor for randomizing reconnection delays (default: 0.2 = ±20%) */
|
||||
reconnectJitter?: number;
|
||||
|
||||
/** Timeout for initial connection attempt in milliseconds (default: 30000) */
|
||||
connectionTimeout?: number;
|
||||
|
||||
/** Maximum number of messages to queue during disconnection (default: 1000) */
|
||||
maxQueueSize?: number;
|
||||
|
||||
/** Maximum age of queued messages in milliseconds (default: 60000) */
|
||||
maxMessageAge?: number;
|
||||
|
||||
/** WebRTC configuration */
|
||||
rtcConfig?: RTCConfiguration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration for durable channels
|
||||
*/
|
||||
export interface DurableChannelConfig {
|
||||
/** Maximum number of messages to queue (default: 1000) */
|
||||
maxQueueSize?: number;
|
||||
|
||||
/** Maximum age of queued messages in milliseconds (default: 60000) */
|
||||
maxMessageAge?: number;
|
||||
|
||||
/** Whether messages should be delivered in order (default: true) */
|
||||
ordered?: boolean;
|
||||
|
||||
/** Maximum retransmits for unordered channels (default: undefined) */
|
||||
maxRetransmits?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration for durable services
|
||||
*/
|
||||
export interface DurableServiceConfig extends DurableConnectionConfig {
|
||||
/** Username that owns the service */
|
||||
username: string;
|
||||
|
||||
/** Private key for signing service operations */
|
||||
privateKey: string;
|
||||
|
||||
/** Fully qualified service name (e.g., com.example.chat@1.0.0) */
|
||||
serviceFqn: string;
|
||||
|
||||
/** Whether the service is publicly discoverable (default: false) */
|
||||
isPublic?: boolean;
|
||||
|
||||
/** Optional metadata for the service */
|
||||
metadata?: Record<string, any>;
|
||||
|
||||
/** Time-to-live for service in milliseconds (default: server default) */
|
||||
ttl?: number;
|
||||
|
||||
/** Margin before TTL expiry to trigger refresh (default: 0.2 = refresh at 80%) */
|
||||
ttlRefreshMargin?: number;
|
||||
|
||||
/** Number of simultaneous open offers to maintain (default: 1) */
|
||||
poolSize?: number;
|
||||
|
||||
/** Polling interval for checking answers in milliseconds (default: 2000) */
|
||||
pollingInterval?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Queued message structure
|
||||
*/
|
||||
export interface QueuedMessage {
|
||||
/** Message data */
|
||||
data: string | Blob | ArrayBuffer | ArrayBufferView;
|
||||
|
||||
/** Timestamp when message was enqueued */
|
||||
enqueuedAt: number;
|
||||
|
||||
/** Unique message ID */
|
||||
id: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Event type map for DurableConnection
|
||||
*/
|
||||
export interface DurableConnectionEvents extends Record<string, (...args: any[]) => void> {
|
||||
'state': (state: DurableConnectionState, previousState: DurableConnectionState) => void;
|
||||
'connected': () => void;
|
||||
'reconnecting': (attempt: number, maxAttempts: number, nextRetryIn: number) => void;
|
||||
'disconnected': () => void;
|
||||
'failed': (error: Error, permanent: boolean) => void;
|
||||
'closed': () => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Event type map for DurableChannel
|
||||
*/
|
||||
export interface DurableChannelEvents extends Record<string, (...args: any[]) => void> {
|
||||
'open': () => void;
|
||||
'message': (data: any) => void;
|
||||
'error': (error: Error) => void;
|
||||
'close': () => void;
|
||||
'bufferedAmountLow': () => void;
|
||||
'queueOverflow': (droppedCount: number) => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Event type map for DurableService
|
||||
*/
|
||||
export interface DurableServiceEvents extends Record<string, (...args: any[]) => void> {
|
||||
'published': (serviceId: string, uuid: string) => void;
|
||||
'connection': (connectionId: string) => void;
|
||||
'disconnection': (connectionId: string) => void;
|
||||
'ttl-refreshed': (expiresAt: number) => void;
|
||||
'error': (error: Error, context: string) => void;
|
||||
'closed': () => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Information about a durable connection
|
||||
*/
|
||||
export interface ConnectionInfo {
|
||||
/** Username (for username-based connections) */
|
||||
username?: string;
|
||||
|
||||
/** Service FQN (for service-based connections) */
|
||||
serviceFqn?: string;
|
||||
|
||||
/** UUID (for UUID-based connections) */
|
||||
uuid?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Service information returned when service is published
|
||||
*/
|
||||
export interface ServiceInfo {
|
||||
/** Service ID */
|
||||
serviceId: string;
|
||||
|
||||
/** Service UUID for discovery */
|
||||
uuid: string;
|
||||
|
||||
/** Expiration timestamp */
|
||||
expiresAt: number;
|
||||
}
|
||||
Reference in New Issue
Block a user