socket-function 1.1.15 → 1.1.17

package/index.d.ts

@@ -467,12 +467,14 @@ declare module "socket-function/src/CallFactory" {
     import * as tls from "tls";
     export interface CallFactory {
         nodeId: string;
+        realNodeId?: string;
         lastClosed: number;
         closedForever?: boolean;
         isConnected?: boolean;
         receivedInitializeState?: InitializeState;
         performCall(call: CallType): Promise<unknown>;
         onNextDisconnect(callback: () => void): void;
+        disconnect(): void;
         connectionId: {
             nodeId: string;
         };
@@ -481,6 +483,7 @@ declare module "socket-function/src/CallFactory" {
         nodeId?: string;
         _socket?: tls.TLSSocket;
         send(data: string | Buffer): void;
+        close(): void;
         addEventListener(event: "open", listener: () => void): void;
         addEventListener(event: "close", listener: () => void): void;
         addEventListener(event: "error", listener: (err: {
@@ -1072,7 +1075,7 @@ declare module "socket-function/src/nodeCache" {
         originalNodeId: string;
         newNodeId: string;
         callFactory: CallFactory;
-    }): void;
+    }): boolean;
     export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
     export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
     export declare function debugGetAllCallFactories(): CallFactory[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.15",
+	"version": "1.1.17",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.d.ts

@@ -6,12 +6,14 @@ import * as ws from "ws";
 import * as tls from "tls";
 export interface CallFactory {
     nodeId: string;
+    realNodeId?: string;
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;
     receivedInitializeState?: InitializeState;
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
+    disconnect(): void;
     connectionId: {
         nodeId: string;
     };
@@ -20,6 +22,7 @@ export interface SenderInterface {
     nodeId?: string;
     _socket?: tls.TLSSocket;
     send(data: string | Buffer): void;
+    close(): void;
     addEventListener(event: "open", listener: () => void): void;
     addEventListener(event: "close", listener: () => void): void;
     addEventListener(event: "error", listener: (err: {

package/src/CallFactory.ts

@@ -44,6 +44,7 @@ type InternalReturnType = {
 
 export interface CallFactory {
     nodeId: string;
+    realNodeId?: string;
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;
@@ -52,6 +53,8 @@ export interface CallFactory {
     //  Trigger performLocalCall on the other side of the connection
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
+    disconnect(): void;
+    // If we change the node ID we need to recreate this object, essentially this object should be immutable. I forget why we wanted this. I think it's because we didn't know for sure if node ID would be unique, but it will be. 
     connectionId: { nodeId: string };
 }
 
@@ -61,6 +64,7 @@ export interface SenderInterface {
     _socket?: tls.TLSSocket;
 
     send(data: string | Buffer): void;
+    close(): void;
 
     addEventListener(event: "open", listener: () => void): void;
     addEventListener(event: "close", listener: () => void): void;
@@ -108,7 +112,8 @@ export async function createCallFactory(
     // The node id we are connecting to (or that connected to us)
     nodeId: string,
     // The node id that we were contacted on
-    localNodeId = "",
+    // NOTE: This used to default to empty string, which would be the case if we made the connection. But this caused problems when we want it to stop making two connections per server and reuse the connection if both the servers want it to talk to each other. I guess we can default it to our reconnection URL. I mean, how else are people going to connect to us other than that?
+    localNodeId = ownReconnectionUrl || "",
 ): Promise<CallFactory> {
     let niceConnectionName = nodeId;
 
@@ -157,6 +162,13 @@ export async function createCallFactory(
         connectionId: { nodeId },
         receivedInitializeState: undefined,
         onNextDisconnect,
+        disconnect() {
+            canReconnect = false;
+            callFactory.closedForever = true;
+            if (webSocketPromise) {
+                webSocketPromise.then(ws => ws.close()).catch(() => { });
+            }
+        },
         async performCall(call: CallType) {
             let seqNum = nextSeqNum++;
             let fullCall: InternalCallType = {
@@ -549,18 +561,23 @@ export async function createCallFactory(
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
                 let otherReconnectionUrl = callFactory.receivedInitializeState.ownReconnectionUrl;
-                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl)) {
-                    changeNodeId({
+                callFactory.realNodeId = otherReconnectionUrl;
+                if (SocketFunction.logMessages) {
+                    console.log(green(`Received initialize state from ${callFactory.realNodeId} at ${Date.now()}`));
+                }
+                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl) && otherReconnectionUrl !== ownReconnectionUrl) {
+                    if (changeNodeId({
                         originalNodeId: nodeId,
                         newNodeId: otherReconnectionUrl,
                         callFactory,
-                    });
-                    nodeId = otherReconnectionUrl;
-                    niceConnectionName = otherReconnectionUrl;
-                    callerContext.nodeId = nodeId;
-                    canReconnect = !!getNodeIdLocation(nodeId);
-                    callFactory.nodeId = nodeId;
-                    callFactory.connectionId.nodeId = nodeId;
+                    })) {
+                        nodeId = otherReconnectionUrl;
+                        niceConnectionName = otherReconnectionUrl;
+                        callerContext.nodeId = nodeId;
+                        canReconnect = !!getNodeIdLocation(nodeId);
+                        callFactory.nodeId = nodeId;
+                        callFactory.connectionId = { nodeId };
+                    }
                 }
                 return;
             }
@@ -781,8 +798,14 @@ export async function createCallFactory(
             result: initState,
             seqNum: INITIALIZE_STATE_SEQ_NUM,
         };
+        if (SocketFunction.logMessages) {
+            console.log(`Sending initialize state to ${nodeId}`);
+        }
         let data = await SocketFunction.WIRE_SERIALIZER.serialize(initReturn);
         await send(data);
+        if (SocketFunction.logMessages) {
+            console.log(`Sent initialize state to ${nodeId}`);
+        }
     }
 
     return callFactory;

package/src/nodeCache.d.ts

@@ -22,7 +22,7 @@ export declare function changeNodeId(config: {
     originalNodeId: string;
     newNodeId: string;
     callFactory: CallFactory;
-}): void;
+}): boolean;
 export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
 export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
 export declare function debugGetAllCallFactories(): CallFactory[];

package/src/nodeCache.ts

@@ -82,9 +82,13 @@ export function changeNodeId(config: {
     newNodeId: string;
     callFactory: CallFactory;
 }) {
-    if (nodeCache.has(config.newNodeId)) return;
+    if (nodeCache.has(config.newNodeId)) {
+        console.warn(`Received connection we already have. Likely we and them tried to connect at the same time. Other nodeId: ${config.newNodeId}`);
+        return false;
+    }
     nodeCache.delete(config.originalNodeId);
     nodeCache.set(config.newNodeId, config.callFactory);
+    return true;
 }
 
 export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {