Juergen Kunz
1d62c9c695
- Updated test files to use new testing library and reduced test cycles for efficiency. - Removed dependency on smartexpress and integrated direct WebSocket handling. - Enhanced Smartsocket and SmartsocketClient classes to support new message types and authentication flow. - Implemented a new message interface for structured communication between client and server. - Added external server support for smartserve with appropriate WebSocket hooks. - Improved connection management and error handling in SocketConnection and SocketRequest classes. - Cleaned up code and removed deprecated socket.io references in favor of native WebSocket.
370 lines
12 KiB
TypeScript
370 lines
12 KiB
TypeScript
import * as plugins from './smartsocket.plugins.js';
|
|
import * as pluginsTyped from './smartsocket.pluginstyped.js';
|
|
import * as interfaces from './interfaces/index.js';
|
|
|
|
import { SocketConnection } from './smartsocket.classes.socketconnection.js';
|
|
import {
|
|
type ISocketFunctionCallDataRequest,
|
|
SocketFunction,
|
|
} from './smartsocket.classes.socketfunction.js';
|
|
import { type ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
|
|
import { logger } from './smartsocket.logging.js';
|
|
|
|
/**
|
|
* interface for class SmartsocketClient
|
|
*/
|
|
export interface ISmartsocketClientOptions {
|
|
port: number;
|
|
url: string;
|
|
alias: string; // an alias makes it easier to identify this client in a multi client environment
|
|
autoReconnect?: boolean;
|
|
maxRetries?: number; // maximum number of reconnection attempts
|
|
initialBackoffDelay?: number; // initial backoff delay in ms
|
|
maxBackoffDelay?: number; // maximum backoff delay in ms
|
|
}
|
|
|
|
export class SmartsocketClient {
|
|
// a unique id
|
|
public shortId = plugins.isounique.uni();
|
|
|
|
// the shortId of the remote we connect to
|
|
public remoteShortId: string = null;
|
|
|
|
public alias: string;
|
|
public socketConnection: SocketConnection;
|
|
public serverUrl: string;
|
|
public serverPort: number;
|
|
public autoReconnect: boolean;
|
|
public maxRetries: number;
|
|
public initialBackoffDelay: number;
|
|
public maxBackoffDelay: number;
|
|
public currentRetryCount = 0;
|
|
public currentBackoffDelay: number;
|
|
|
|
// status handling
|
|
public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
|
|
public eventStatus: interfaces.TConnectionStatus = 'new';
|
|
|
|
public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
|
|
public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
|
|
|
|
// tagStore
|
|
private tagStore: { [key: string]: interfaces.ITag } = {};
|
|
private tagStoreSubscription: plugins.smartrx.rxjs.Subscription;
|
|
|
|
/**
|
|
* adds a tag to a connection
|
|
*/
|
|
public async addTag(tagArg: interfaces.ITag) {
|
|
if (this.socketConnection) {
|
|
await this.socketConnection.addTag(tagArg);
|
|
} else {
|
|
this.tagStore[tagArg.id] = tagArg;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gets a tag by id
|
|
* @param tagIdArg
|
|
*/
|
|
public async getTagById(tagIdArg: interfaces.ITag['id']) {
|
|
return this.tagStore[tagIdArg];
|
|
}
|
|
|
|
/**
|
|
* removes a tag from a connection
|
|
*/
|
|
public async removeTagById(tagIdArg: interfaces.ITag['id']) {
|
|
if (this.socketConnection) {
|
|
this.socketConnection.removeTagById(tagIdArg);
|
|
} else {
|
|
delete this.tagStore[tagIdArg];
|
|
}
|
|
}
|
|
|
|
constructor(optionsArg: ISmartsocketClientOptions) {
|
|
this.alias = optionsArg.alias;
|
|
this.serverUrl = optionsArg.url;
|
|
this.serverPort = optionsArg.port;
|
|
this.autoReconnect = optionsArg.autoReconnect;
|
|
this.maxRetries = optionsArg.maxRetries ?? 100; // Default to 100 retries
|
|
this.initialBackoffDelay = optionsArg.initialBackoffDelay ?? 1000; // Default to 1 second
|
|
this.maxBackoffDelay = optionsArg.maxBackoffDelay ?? 60000; // Default to 1 minute
|
|
this.currentBackoffDelay = this.initialBackoffDelay;
|
|
}
|
|
|
|
public addSocketFunction(socketFunction: SocketFunction<any>) {
|
|
this.socketFunctions.add(socketFunction);
|
|
}
|
|
|
|
private isReconnecting = false;
|
|
|
|
/**
|
|
* connect the client to the server
|
|
*/
|
|
public async connect() {
|
|
// Only reset retry counters on fresh connection (not during auto-reconnect)
|
|
if (!this.isReconnecting) {
|
|
this.currentRetryCount = 0;
|
|
this.currentBackoffDelay = this.initialBackoffDelay;
|
|
}
|
|
this.isReconnecting = false;
|
|
|
|
const done = plugins.smartpromise.defer();
|
|
const smartenvInstance = new plugins.smartenv.Smartenv();
|
|
|
|
logger.log('info', 'trying to connect...');
|
|
|
|
// Construct WebSocket URL
|
|
const protocol = this.serverUrl.startsWith('https') ? 'wss' : 'ws';
|
|
const host = this.serverUrl.replace(/^https?:\/\//, '');
|
|
const socketUrl = `${protocol}://${host}:${this.serverPort}`;
|
|
|
|
// Get WebSocket implementation (native in browser, ws in Node)
|
|
let WebSocketClass: typeof WebSocket;
|
|
if (typeof WebSocket !== 'undefined') {
|
|
// Browser environment
|
|
WebSocketClass = WebSocket;
|
|
} else {
|
|
// Node.js environment
|
|
const wsModule = await smartenvInstance.getSafeNodeModule('ws');
|
|
WebSocketClass = wsModule.default || wsModule;
|
|
}
|
|
|
|
const socket = new WebSocketClass(socketUrl);
|
|
this.currentSocket = socket;
|
|
|
|
this.socketConnection = new SocketConnection({
|
|
alias: this.alias,
|
|
authenticated: false,
|
|
side: 'client',
|
|
smartsocketHost: this,
|
|
socket: socket as any,
|
|
});
|
|
|
|
// Increment attempt ID to invalidate any pending timers from previous attempts
|
|
this.connectionAttemptId++;
|
|
const currentAttemptId = this.connectionAttemptId;
|
|
|
|
const timer = new plugins.smarttime.Timer(5000);
|
|
timer.start();
|
|
timer.completed.then(() => {
|
|
// Only fire timeout if this is still the current connection attempt
|
|
if (currentAttemptId === this.connectionAttemptId && this.eventStatus !== 'connected') {
|
|
this.updateStatus('timedOut');
|
|
logger.log('warn', 'connection to server timed out.');
|
|
this.disconnect(true);
|
|
}
|
|
});
|
|
|
|
// Handle connection open
|
|
socket.addEventListener('open', () => {
|
|
timer.reset();
|
|
});
|
|
|
|
// Handle messages
|
|
socket.addEventListener('message', async (event: MessageEvent | { data: string }) => {
|
|
try {
|
|
const data = typeof event.data === 'string' ? event.data : event.data.toString();
|
|
const message: interfaces.ISocketMessage = JSON.parse(data);
|
|
|
|
switch (message.type) {
|
|
case 'authRequest':
|
|
timer.reset();
|
|
const authRequestPayload = message.payload as interfaces.IAuthRequestPayload;
|
|
logger.log('info', `server ${authRequestPayload.serverAlias} requested authentication`);
|
|
this.remoteShortId = authRequestPayload.serverAlias;
|
|
|
|
// Send authentication data
|
|
this.socketConnection.sendMessage({
|
|
type: 'auth',
|
|
payload: { alias: this.alias },
|
|
});
|
|
break;
|
|
|
|
case 'authResponse':
|
|
const authResponse = message.payload as interfaces.IAuthResponsePayload;
|
|
if (authResponse.success) {
|
|
logger.log('info', 'client is authenticated');
|
|
this.socketConnection.authenticated = true;
|
|
} else {
|
|
logger.log('warn', `authentication failed: ${authResponse.error}`);
|
|
await this.disconnect();
|
|
}
|
|
break;
|
|
|
|
case 'serverReady':
|
|
// Set up function request listening
|
|
await this.socketConnection.listenToFunctionRequests();
|
|
|
|
// Handle retagging
|
|
const oldTagStore = this.tagStore;
|
|
this.tagStoreSubscription?.unsubscribe();
|
|
for (const keyArg of Object.keys(this.tagStore)) {
|
|
this.socketConnection.addTag(this.tagStore[keyArg]);
|
|
}
|
|
this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
|
|
(tagStoreArg) => {
|
|
this.tagStore = tagStoreArg;
|
|
}
|
|
);
|
|
|
|
for (const tag of Object.keys(oldTagStore)) {
|
|
await this.addTag(oldTagStore[tag]);
|
|
}
|
|
this.updateStatus('connected');
|
|
done.resolve();
|
|
break;
|
|
|
|
default:
|
|
// Other messages are handled by SocketConnection
|
|
this.socketConnection.handleMessage(message);
|
|
break;
|
|
}
|
|
} catch (err) {
|
|
// Not a valid JSON message, ignore
|
|
}
|
|
});
|
|
|
|
// Handle disconnection and errors
|
|
const closeHandler = async () => {
|
|
// Only handle close if this is still the current socket and we're not already disconnecting
|
|
if (this.currentSocket === socket && !this.disconnectRunning) {
|
|
logger.log(
|
|
'info',
|
|
`SocketConnection with >alias ${this.alias} on >side client disconnected`
|
|
);
|
|
await this.disconnect(true);
|
|
}
|
|
};
|
|
|
|
const errorHandler = async () => {
|
|
if (this.currentSocket === socket && !this.disconnectRunning) {
|
|
await this.disconnect(true);
|
|
}
|
|
};
|
|
|
|
socket.addEventListener('close', closeHandler);
|
|
socket.addEventListener('error', errorHandler);
|
|
|
|
return done.promise;
|
|
}
|
|
|
|
private disconnectRunning = false;
|
|
private currentSocket: WebSocket | null = null;
|
|
private connectionAttemptId = 0; // Increment on each connect attempt to invalidate old timers
|
|
|
|
/**
|
|
* disconnect from the server
|
|
*/
|
|
public async disconnect(useAutoReconnectSetting = false) {
|
|
if (this.disconnectRunning) {
|
|
return;
|
|
}
|
|
this.disconnectRunning = true;
|
|
this.updateStatus('disconnecting');
|
|
this.tagStoreSubscription?.unsubscribe();
|
|
|
|
// Store reference to current socket before cleanup
|
|
const socketToClose = this.currentSocket;
|
|
this.currentSocket = null;
|
|
|
|
if (this.socketConnection) {
|
|
await this.socketConnection.disconnect();
|
|
this.socketConnection = undefined;
|
|
logger.log('ok', 'disconnected socket!');
|
|
} else if (!socketToClose) {
|
|
this.disconnectRunning = false;
|
|
logger.log('warn', 'tried to disconnect, without a SocketConnection');
|
|
return;
|
|
}
|
|
|
|
logger.log('warn', `disconnected from server ${this.remoteShortId}`);
|
|
this.remoteShortId = null;
|
|
|
|
if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
|
|
this.updateStatus('connecting');
|
|
|
|
// Check if we've exceeded the maximum number of retries
|
|
if (this.currentRetryCount >= this.maxRetries) {
|
|
logger.log('warn', `Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
|
|
this.disconnectRunning = false;
|
|
return;
|
|
}
|
|
|
|
// Increment retry counter
|
|
this.currentRetryCount++;
|
|
|
|
// Calculate backoff with jitter (±20% randomness)
|
|
const jitter = this.currentBackoffDelay * 0.2 * (Math.random() * 2 - 1);
|
|
const delay = Math.min(this.currentBackoffDelay + jitter, this.maxBackoffDelay);
|
|
|
|
logger.log('info', `Reconnect attempt ${this.currentRetryCount}/${this.maxRetries} in ${Math.round(delay)}ms`);
|
|
|
|
// Apply exponential backoff for next time (doubling with each attempt)
|
|
this.currentBackoffDelay = Math.min(this.currentBackoffDelay * 2, this.maxBackoffDelay);
|
|
|
|
await plugins.smartdelay.delayFor(delay);
|
|
this.disconnectRunning = false;
|
|
this.isReconnecting = true;
|
|
await this.connect();
|
|
} else {
|
|
this.disconnectRunning = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* stops the client completely
|
|
*/
|
|
public async stop() {
|
|
this.autoReconnect = false;
|
|
this.currentRetryCount = 0;
|
|
this.currentBackoffDelay = this.initialBackoffDelay;
|
|
await this.disconnect();
|
|
}
|
|
|
|
/**
|
|
* dispatches a server call
|
|
* @param functionNameArg
|
|
* @param dataArg
|
|
*/
|
|
public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
|
|
functionNameArg: T['method'],
|
|
dataArg: T['request']
|
|
): Promise<T['response']> {
|
|
const socketRequest = new SocketRequest<T>(this, {
|
|
side: 'requesting',
|
|
originSocketConnection: this.socketConnection,
|
|
shortId: plugins.isounique.uni(),
|
|
funcCallData: {
|
|
funcName: functionNameArg,
|
|
funcDataArg: dataArg,
|
|
},
|
|
});
|
|
const response = await socketRequest.dispatch();
|
|
const result = response.funcDataArg;
|
|
return result;
|
|
}
|
|
|
|
private updateStatus(statusArg: interfaces.TConnectionStatus) {
|
|
if (this.eventStatus !== statusArg) {
|
|
this.eventSubject.next(statusArg);
|
|
}
|
|
this.eventStatus = statusArg;
|
|
|
|
// Reset reconnection state when connection is successful
|
|
if (statusArg === 'connected') {
|
|
this.currentRetryCount = 0;
|
|
this.currentBackoffDelay = this.initialBackoffDelay;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resets the reconnection state
|
|
*/
|
|
public resetReconnectionState() {
|
|
this.currentRetryCount = 0;
|
|
this.currentBackoffDelay = this.initialBackoffDelay;
|
|
}
|
|
}
|