@codenotch/codenotch.react 1.0.82 → 2.0.1

package/src/core/SignalR.ts

@@ -1,375 +0,0 @@
-import { HttpTransportType, HubConnectionBuilder, HubConnectionState, LogLevel } from "@microsoft/signalr";
-import { v4 } from "uuid";
-import { IProcessCallbacks, ICodenotchSignal } from "../models/Misc";
-import { IProcessResult } from "../models/Codenotch";
-
-
-
-export class SignalR {
-
-    private _connection: signalR.HubConnection | null;
-    private _hubUrl: string;
-    private _accessToken: string | undefined;
-
-    // The callbacks coming from components when a signal is received
-    // Also used on the root component to keep track of which signals we listen to
-    private _signalCallbacks: {[signalId: string]: {[subscriptionId: string]: (signal: ICodenotchSignal) => void} };
-
-    // Store callbacks of ongoing processes
-    private _processCallbacks: {[processInstanceId: string]: IProcessCallbacks};
-
-    private _inactivityTimer: NodeJS.Timeout | null;
-    private _unsubscribeTimers: {[signalId: string]: NodeJS.Timeout} = {};
-
-    private _isConnecting: boolean = false;
-    private _pendingConnectionPromises: Array<{ resolve: () => void; reject: (error: Error) => void }> = [];
-
-    // Determines if connection should be kept alive even if there are no subscriptions
-    private _keepAlive: boolean;
-
-    public constructor(clusterUrl: string, serviceName: string, keepAlive: boolean, accessToken?: string)
-    {
-        this._hubUrl = `${clusterUrl}/${serviceName}/exec`;
-        this._accessToken = accessToken;
-        this._connection = null;
-        this._signalCallbacks = {};
-        this._processCallbacks = {};
-
-        this._inactivityTimer = null;
-        this._keepAlive = keepAlive;
-    }
-
-    async connect() {
-
-        console.log(`SignalR establishing connection...`)
-
-        this._isConnecting = true;
-
-        // Here we inject the access token if defined
-        let options: signalR.IHttpConnectionOptions = this._accessToken ? { accessTokenFactory: () => this._accessToken! } : {};
-
-        // Skip negotiation and only use websockets
-        // This allows us to have multiple SignalR server without sticky sessions
-        // But it won't work in the rare cases where websockets are not supported
-        options.skipNegotiation = true;
-        options.transport = HttpTransportType.WebSockets;
-        //TODO if the server has multi instances, and the one we are connected fails, do sticky sessions prevent us from connecting to a healthy instance ?
-
-        this._connection = new HubConnectionBuilder()
-            .withUrl(this._hubUrl, options)
-            .withAutomaticReconnect([0, 1000, 3000, 5000, 10000, 30000, 60000, 90000]) // If the server is a single instance and decide to change node, it might take a little while
-            .configureLogging(LogLevel.Error)
-            .build();
-
-        this._connection.off("ReceiveSignal");
-        this._connection.off("ReceiveLog");
-        this._connection.off("ReceiveCallback");
-        this._connection.off("ReceiveProcessOver");
-
-        // On Signal
-        this._connection.on("ReceiveSignal", (signal: ICodenotchSignal) => this.onSignalReceived(signal));
-
-        // On log
-        this._connection.on("ReceiveLog", (log: string) => {
-            console.log(log);
-        });
-
-        // On callback received from process
-        //TODO only used to set wec content and redirect, do we still need those ?
-        this._connection.on("ReceiveCallback", (callback) => this.onProcessCallbackReceived(callback));
-
-        // On process completed
-        this._connection.on("ReceiveProcessOver", (processResult: IProcessResult) => this.onProcessOverReceived(processResult));
-
-        this._connection.onclose(
-            (error) => console.log(`disconnected: ${error ? error.message : "no error"}`)
-        );
-
-        this._connection.onreconnected(
-            () => this.resolvePendingRequests()
-        );
-
-        try
-        {
-            await this._connection.start();
-            console.log(`SignalR connection established`)
-
-            this.resolvePendingRequests();
-            this._isConnecting = false;
-        }
-        catch(err: any)
-        {
-            console.log(`SignalR connection error: ${err}`)
-
-            this.rejectPendingRequests(err);
-            this._isConnecting = false;
-        }
-    }
-
-    private resolvePendingRequests()
-    {
-        if(this._pendingConnectionPromises.length > 0)
-        {
-            console.log(`Resolving ${this._pendingConnectionPromises.length} pending connection promises`);
-        }
-
-        for(let p of this._pendingConnectionPromises)
-        {
-            p?.resolve();
-        }
-    }
-
-    private rejectPendingRequests(error: Error): void {
-
-        if(this._pendingConnectionPromises.length > 0)
-        {
-            console.log(`Rejecting ${this._pendingConnectionPromises.length} pending connection promises`);
-        }
-
-        for(let p of this._pendingConnectionPromises)
-        {
-            p?.reject(error);
-        }
-    }
-
-    private async ensureConnected() {
-    
-        if(this._inactivityTimer)
-        {
-            // cancel disconnection
-            clearTimeout(this._inactivityTimer);
-            this._inactivityTimer = null;
-        }
-
-        if(this._connection && this._connection.state === HubConnectionState.Connected)
-        {
-            return Promise.resolve();
-        }
-
-        console.log(`SignalR not currently connected, waiting on connection...`)
-
-        const connectionPromise = new Promise<void>((resolve, reject) => {
-            this._pendingConnectionPromises.push({ resolve, reject });
-        });
-
-        if (!this._isConnecting) {
-            this.connect();
-        }
-
-        // Return a promise that will resolve when the connection is established
-        return connectionPromise;
-    }
-
-
-    private onSignalReceived(signal: ICodenotchSignal) {
-        try {
-            console.log(`Received signal '${signal.signalId}'`)
-            console.log(signal);
-
-            // parse the eventual data in the signal
-            if(signal.data)
-            {
-                try
-                {
-                    signal.data = JSON.parse(signal.data);
-                }
-                catch {
-                    // Data is not json but might still be valid
-                }
-            }
-    
-            // If signal id contains multiple paths, trigger each one
-            var signalPaths = this.getSignalPaths(signal.signalId);
-    
-            for(let p of signalPaths)
-            {
-                if(this._signalCallbacks[p])
-                {
-                    for(let callback of Object.values(this._signalCallbacks[p]))
-                    {
-                        callback(signal);
-                    }
-                }
-            }
-        }
-        catch (ex) {
-            console.log(`An exception occured during 'ReceiveSignal' callback:`);
-            console.log(ex);
-        }
-    }
-
-    private getSignalPaths(signalId: string): string[]
-    {
-        // Signals can be segmented using '.', each segment corresponds to a more specific subject 
-        // Subscribers can subscribe to a very specific signal or to a more general topic
-        // eg. Signal ref : invoice.update.0000-1111-2222-3333, will be received by subscribers on:
-        //  -> 'invoice'
-        //  -> 'invoice.update'
-        //  -> 'invoice.update.0000-1111-2222-3333'
-        var signalPaths:string[] = [];   
-
-        if(!signalId || signalId === '')
-            return signalPaths;
-
-        var segments = signalId.split('.');
-        for (let i = 0; i < segments.length; i++)
-        {
-            signalPaths.push(segments.slice(0, i + 1).join('.')); // "path" from index 0 to i
-        }
-
-        return signalPaths;
-    }
-
-    private onProcessCallbackReceived(callback: {processInstanceId: string }) {
-
-        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
-        if(this._processCallbacks[callback.processInstanceId])
-        {
-            this._processCallbacks[callback.processInstanceId].onCallback(callback)
-        }
-    }
-
-    private onProcessOverReceived(processResult: IProcessResult) {
-
-        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
-        if(this._processCallbacks[processResult.processInstanceId])
-        {
-            this._processCallbacks[processResult.processInstanceId].onOver(processResult)
-
-            // Clean it, now that the process is over we should not receive anymore callbacks
-            delete this._processCallbacks[processResult.processInstanceId];
-
-            this.disconnectIfInactive();
-        }
-    }
-
-    async subscribeToProcessInstance(processInstanceId: string, callbacks: IProcessCallbacks) {
-
-        if(this._processCallbacks[processInstanceId])
-        {
-            // Already subscribed
-            return;
-        }
-
-        await this.ensureConnected();
-
-        try
-        {
-            await this._connection!.invoke("SubscribeToInstanceEvents", processInstanceId);
-            
-            // Setup callbacks
-            this._processCallbacks[processInstanceId] = callbacks;
-        }
-        catch(err)
-        {
-            console.error(`Couldn't subscribe to process '${processInstanceId}', : ${err}`)
-        }
-    }
-
-    async subscribeToSignal(signalId: string, callback: (signal: ICodenotchSignal) => void): Promise<() => Promise<void>> {
-
-        console.log(`subscribeToSignal: signalId:${signalId}`);
-
-        if (!signalId || signalId === "")
-            return () => Promise.resolve();
-
-        await this.ensureConnected();
-
-        if(this._unsubscribeTimers[signalId])
-        {
-            // cancel eventual unsubscription
-            clearTimeout(this._unsubscribeTimers[signalId]);
-            delete this._unsubscribeTimers[signalId];
-        }
-
-        if(!this._signalCallbacks[signalId])
-        {
-            // Create the subscription
-            try
-            {
-                await this._connection!.invoke("SubscribeToSignal", signalId);
-
-                // Remember which signals we are subscribed so we don't subscribe twice
-                if(!this._signalCallbacks[signalId])
-                {
-                    this._signalCallbacks[signalId] = {};
-                }
-
-            }
-            catch(err)
-            {
-                throw `Couldn't subscribe to signal '${signalId}', : ${err}`;
-            }
-        }
-
-        // Generate a new id to keep track of each subscription
-        let subscriptionId = v4();
-        this._signalCallbacks[signalId][subscriptionId] = callback;
-
-        // Return the unsubscribe function
-        return async () => await this.unsubscribeFromSignal(signalId, subscriptionId);
-    }
-
-    async unsubscribeFromSignal(signalId: string, subscriptionId: string)
-    {
-        console.log(`unsubscribeFromSignal: signalId:${signalId}, subscriptionId:${subscriptionId}`);
-
-        if(!this._signalCallbacks[signalId])
-        {
-            return;
-        }
-
-        delete this._signalCallbacks[signalId][subscriptionId];
-
-        // From this point we won't send events to the component who just unsubscribed, but we are still subscribed to the signal on the server so we'll recieve new signals
-        this.unsubscribeFromServerIfNoMoreSubscriptions(signalId);
-
-        // If no more subscriptions, we can disconnect from the server
-        this.disconnectIfInactive();
-    }
-
-    private unsubscribeFromServerIfNoMoreSubscriptions(signalId: string)
-    {
-        if(Object.keys(this._signalCallbacks[signalId]).length === 0)
-        {
-            delete this._signalCallbacks[signalId];
-
-            // No more subscriptions for this signal, we can unsubscribe from the server
-            // but in order to not send too many requests, we will wait a little bit before actually unsubscribing, the client might come back to the tab that need this signal in a few seconds
-            this._unsubscribeTimers[signalId] = setTimeout(() => this.unsubscribeSignalServer(signalId), 1 * 60 * 1000);
-        }
-    }
-
-    private async unsubscribeSignalServer(signalId: string)
-    {
-        console.log(`unsubscribeSignalServer: signalId:${signalId}`);
-
-        await this._connection!.invoke("UnsubscribeFromSignal", signalId);
-    }
-
-    private disconnectIfInactive()
-    {
-        if(this._keepAlive)
-            return;
-
-        if(Object.keys(this._signalCallbacks).length === 0 && Object.keys(this._processCallbacks).length === 0)
-        {
-            // No more subscriptions, disconnect from the server after a little while (5 minutes) to save resources
-            this._inactivityTimer = setTimeout(() => this.disconnect(), 5 * 60 * 1000);
-            console.log("SignalR has no more active subscriptions, will disconnect in 5 minutes...");
-        }
-    }
-
-    public disconnect(): void {
-
-        if (this._connection) {
-            this._connection.off("ReceiveCallback");
-            this._connection.off("ReceiveProcessOver");
-            this._connection.off("ReceiveSignal");
-            this._connection.off("ReceiveLog");
-
-            this._connection.stop();
-            this._connection = null;
-        }
-    }
-}