syntax: improved variable names and docs

[ci skip]

Author: tegefaulkes

src/PolykeyAgent.ts

@@ -57,9 +57,9 @@ type NetworkConfig = {
   clientHost?: Host;
   clientPort?: Port;
   maxReadBufferBytes?: number;
-  idleTimeout?: number;
-  pingInterval?: number;
-  pingTimeout?: number;
+  idleTimeoutTime?: number;
+  pingIntervalTime?: number;
+  pingTimeoutTime?: number;
 };
 
 interface PolykeyAgent extends CreateDestroyStartStop {}
@@ -193,7 +193,7 @@ class PolykeyAgent {
       ...config.defaults.nodeConnectionManagerConfig,
       ...utils.filterEmptyObject(nodeConnectionManagerConfig),
     };
-    const _networkConfig = {
+    const networkConfig_ = {
       ...config.defaults.networkConfig,
       ...utils.filterEmptyObject(networkConfig),
     };
@@ -454,13 +454,13 @@ class PolykeyAgent {
           connectionCallback: (streamPair) =>
             rpcServerClient!.handleStream(streamPair, {}),
           fs,
-          host: _networkConfig.clientHost,
-          port: _networkConfig.clientPort,
+          host: networkConfig_.clientHost,
+          port: networkConfig_.clientPort,
           tlsConfig,
-          maxReadBufferBytes: _networkConfig.maxReadBufferBytes,
-          idleTimeout: _networkConfig.idleTimeout,
-          pingInterval: _networkConfig.pingInterval,
-          pingTimeout: _networkConfig.pingTimeout,
+          maxReadableStreamBytes: networkConfig_.maxReadBufferBytes,
+          connectionIdleTimeoutTime: networkConfig_.idleTimeout,
+          pingIntervalTime: networkConfig_.pingIntervalTime,
+          pingTimeoutTime: networkConfig_.pingTimeoutTime,
           logger: logger.getChild('WebSocketServer'),
         }));
       grpcServerAgent =

src/config.ts

@@ -102,8 +102,8 @@ const config = {
       clientHost: '127.0.0.1' as Host,
       clientPort: 0 as Port,
       maxReadBufferBytes: 1_000_000_000, // About 1 GB
-      pingInterval: 1_000, // 1 second
-      pingTimeout: 10_000, // 10 seconds
+      pingIntervalTime: 1_000, // 1 second
+      pingTimeoutTime: 10_000, // 10 seconds
     },
     proxyConfig: {
       connConnectTime: 2000,

src/rpc/RPCClient.ts

@@ -42,15 +42,16 @@ class RPCClient<M extends ClientManifest> {
    * The middlewareFactory needs to be a function that creates a pair of
    * transform streams that convert `JSONRPCRequest` to `Uint8Array` on the forward
    * path and `Uint8Array` to `JSONRPCResponse` on the reverse path.
-   * @param obj.defaultTimeout - default timeout to be used if none is provided
+   * @param obj.streamKeepAliveTimeoutTime - Timeout time used if no timeout timer was provided when making a call.
+   * Defaults to 60,000 milliseconds.
    * for a client call.
    * @param obj.logger
    */
   static async createRPCClient<M extends ClientManifest>({
     manifest,
     streamFactory,
     middlewareFactory = middlewareUtils.defaultClientMiddlewareWrapper(),
-    defaultTimeout = 60_000, // 1 minuet
+    streamKeepAliveTimeoutTime = 60_000, // 1 minute
     logger = new Logger(this.name),
   }: {
     manifest: M;
@@ -61,15 +62,15 @@ class RPCClient<M extends ClientManifest> {
       JSONRPCResponse,
       Uint8Array
     >;
-    defaultTimeout?: number;
+    streamKeepAliveTimeoutTime?: number;
     logger?: Logger;
   }) {
     logger.info(`Creating ${this.name}`);
     const rpcClient = new this({
       manifest,
       streamFactory,
       middlewareFactory,
-      defaultTimeout,
+      streamKeepAliveTimeoutTime: streamKeepAliveTimeoutTime,
       logger,
     });
     logger.info(`Created ${this.name}`);
@@ -86,7 +87,7 @@ class RPCClient<M extends ClientManifest> {
   >;
   protected callerTypes: Record<string, HandlerType>;
   // Method proxies
-  public readonly defaultTimeout: number;
+  public readonly streamKeepAliveTimeoutTime: number;
   public readonly methodsProxy = new Proxy(
     {},
     {
@@ -115,7 +116,7 @@ class RPCClient<M extends ClientManifest> {
     manifest,
     streamFactory,
     middlewareFactory,
-    defaultTimeout,
+    streamKeepAliveTimeoutTime,
     logger,
   }: {
     manifest: M;
@@ -126,13 +127,13 @@ class RPCClient<M extends ClientManifest> {
       JSONRPCResponse,
       Uint8Array
     >;
-    defaultTimeout: number;
+    streamKeepAliveTimeoutTime: number;
     logger: Logger;
   }) {
     this.callerTypes = rpcUtils.getHandlerTypes(manifest);
     this.streamFactory = streamFactory;
     this.middlewareFactory = middlewareFactory;
-    this.defaultTimeout = defaultTimeout;
+    this.streamKeepAliveTimeoutTime = streamKeepAliveTimeoutTime;
     this.logger = logger;
   }
 
@@ -275,7 +276,7 @@ class RPCClient<M extends ClientManifest> {
     const timer =
       ctx.timer ??
       new Timer({
-        delay: this.defaultTimeout,
+        delay: this.streamKeepAliveTimeoutTime,
       });
     const cleanUp = () => {
       // Clean up the timer and signal
@@ -377,7 +378,7 @@ class RPCClient<M extends ClientManifest> {
     const timer =
       ctx.timer ??
       new Timer({
-        delay: this.defaultTimeout,
+        delay: this.streamKeepAliveTimeoutTime,
       });
     // Ignore unhandled rejections
     const cleanUp = () => {

src/rpc/RPCServer.ts

@@ -58,14 +58,21 @@ class RPCServer extends EventTarget {
    * path and `JSONRPCResponse` to `Uint8Array` on the reverse path.
    * @param obj.sensitive - If true, sanitises any rpc error messages of any
    * sensitive information.
+   * @param obj.streamKeepAliveTimeoutTime - Time before a connection is cleaned up due to no activity. This is the
+   * value used if the handler doesn't specify its own timeout time. This timeout is advisory and only results in a
+   * signal sent to the handler. Stream is forced to end after the timeoutForceCloseTime. Defaults to 60,000
+   * milliseconds.
+   * @param obj.timeoutForceCloseTime - Time before the stream is forced to end after the initial timeout time.
+   * The stream will be forced to close after this amount of time after the initial timeout. This is a grace period for
+   * the handler to handle timeout before it is forced to end. Defaults to 2,000 milliseconds.
    * @param obj.logger
    */
   public static async createRPCServer({
     manifest,
     middlewareFactory = middlewareUtils.defaultServerMiddlewareWrapper(),
     sensitive = false,
-    defaultTimeout = 60_000, // 1 minuet
-    forceEndDelay = 2_000, // 2 seconds
+    streamKeepAliveTimeoutTime = 60_000, // 1 minute
+    timeoutForceCloseTime = 2_000, // 2 seconds
     logger = new Logger(this.name),
   }: {
     manifest: ServerManifest;
@@ -76,17 +83,17 @@ class RPCServer extends EventTarget {
       JSONRPCResponse
     >;
     sensitive?: boolean;
-    defaultTimeout?: number;
-    forceEndDelay?: number;
+    streamKeepAliveTimeoutTime?: number;
+    timeoutForceCloseTime?: number;
     logger?: Logger;
   }): Promise<RPCServer> {
     logger.info(`Creating ${this.name}`);
     const rpcServer = new this({
       manifest,
       middlewareFactory,
       sensitive,
-      defaultTimeout,
-      forceEndDelay,
+      streamKeepAliveTimeoutTime: streamKeepAliveTimeoutTime,
+      timeoutForceCloseTime: timeoutForceCloseTime,
       logger,
     });
     logger.info(`Created ${this.name}`);
@@ -96,8 +103,8 @@ class RPCServer extends EventTarget {
   protected logger: Logger;
   protected handlerMap: Map<string, RawHandlerImplementation> = new Map();
   protected defaultTimeoutMap: Map<string, number | undefined> = new Map();
-  protected defaultTimeout: number;
-  protected forceEndDelay: number;
+  protected streamKeepAliveTimeoutTime: number;
+  protected timeoutForceCloseTime: number;
   protected activeStreams: Set<PromiseCancellable<void>> = new Set();
   protected sensitive: boolean;
   protected middlewareFactory: MiddlewareFactory<
@@ -111,8 +118,8 @@ class RPCServer extends EventTarget {
     manifest,
     middlewareFactory,
     sensitive,
-    defaultTimeout = 60_000, // 1 minuet
-    forceEndDelay = 2_000, // 2 seconds
+    streamKeepAliveTimeoutTime = 60_000, // 1 minuet
+    timeoutForceCloseTime = 2_000, // 2 seconds
     logger,
   }: {
     manifest: ServerManifest;
@@ -122,8 +129,8 @@ class RPCServer extends EventTarget {
       Uint8Array,
       JSONRPCResponseResult
     >;
-    defaultTimeout?: number;
-    forceEndDelay?: number;
+    streamKeepAliveTimeoutTime?: number;
+    timeoutForceCloseTime?: number;
     sensitive: boolean;
     logger: Logger;
   }) {
@@ -181,8 +188,8 @@ class RPCServer extends EventTarget {
     }
     this.middlewareFactory = middlewareFactory;
     this.sensitive = sensitive;
-    this.defaultTimeout = defaultTimeout;
-    this.forceEndDelay = forceEndDelay;
+    this.streamKeepAliveTimeoutTime = streamKeepAliveTimeoutTime;
+    this.timeoutForceCloseTime = timeoutForceCloseTime;
     this.logger = logger;
   }
 
@@ -406,13 +413,13 @@ class RPCServer extends EventTarget {
     const forceStreamEndController = new AbortController();
     // Setting up timeout timer logic
     const timer = new Timer({
-      delay: this.defaultTimeout,
+      delay: this.streamKeepAliveTimeoutTime,
       handler: (signal) => {
         abortController.abort(new rpcErrors.ErrorRpcTimedOut());
         if (signal.aborted) return;
         // Grace timer for force ending stream
         const graceTimer = new Timer({
-          delay: this.forceEndDelay,
+          delay: this.timeoutForceCloseTime,
           handler: () => {
             forceStreamEndController.abort();
           },
@@ -489,7 +496,7 @@ class RPCServer extends EventTarget {
       }
       // Setting up Timeout logic
       const timeout = this.defaultTimeoutMap.get(method);
-      if (timeout != null && timeout < this.defaultTimeout) {
+      if (timeout != null && timeout < this.streamKeepAliveTimeoutTime) {
         // Reset timeout with new delay if it is less than the default
         timer.reset(timeout);
       } else {

src/websockets/WebSocketClient.ts

@@ -19,22 +19,37 @@ import { promise } from '../utils';
 interface WebSocketClient extends createDestroy.CreateDestroy {}
 @createDestroy.CreateDestroy()
 class WebSocketClient {
+  /**
+   * @param obj
+   * @param obj.host - Target host address to connect to
+   * @param obj.port - Target port to connect to
+   * @param obj.expectedNodeIds - Expected NodeIds you are trying to connect to. Will validate the cert chain of the
+   * sever. If none of these NodeIDs are found the connection will be rejected.
+   * @param obj.connectionTimeoutTime - Timeout time used when attempting the connection.
+   * Default is Infinity milliseconds.
+   * @param obj.pingIntervalTime - Time between pings for checking connection health and keep alive.
+   * Default is 1,000 milliseconds.
+   * @param obj.pingTimeoutTime - Time before connection is cleaned up after no ping responses.
+   * Default is 10,000 milliseconds.
+   * @param obj.maxReadableStreamBytes - The number of bytes the readable stream will buffer until pausing.
+   * @param obj.logger
+   */
   static async createWebSocketClient({
     host,
     port,
     expectedNodeIds,
-    connectionTimeout,
-    pingInterval = 1000,
-    pingTimeout = 10000,
-    maxReadableStreamBytes = 1000, // About 1kB
+    connectionTimeoutTime = Infinity,
+    pingIntervalTime = 1_000,
+    pingTimeoutTime = 10_000,
+    maxReadableStreamBytes = 1_000, // About 1kB
     logger = new Logger(this.name),
   }: {
     host: string;
     port: number;
     expectedNodeIds: Array<NodeId>;
-    connectionTimeout?: number;
-    pingInterval?: number;
-    pingTimeout?: number;
+    connectionTimeoutTime?: number;
+    pingIntervalTime?: number;
+    pingTimeoutTime?: number;
     maxReadableStreamBytes?: number;
     logger?: Logger;
   }): Promise<WebSocketClient> {
@@ -45,9 +60,9 @@ class WebSocketClient {
       port,
       maxReadableStreamBytes,
       expectedNodeIds,
-      connectionTimeout ?? Infinity,
-      pingInterval,
-      pingTimeout,
+      connectionTimeoutTime,
+      pingIntervalTime,
+      pingTimeoutTime,
     );
     logger.info(`Created ${this.name}`);
     return clientClient;
@@ -62,9 +77,9 @@ class WebSocketClient {
     protected port: number,
     protected maxReadableStreamBytes: number,
     protected expectedNodeIds: Array<NodeId>,
-    protected connectionTimeout: number,
-    protected pingInterval: number,
-    protected pingTimeout: number,
+    protected connectionTimeoutTime: number,
+    protected pingIntervalTime: number,
+    protected pingTimeoutTime: number,
   ) {
     if (Validator.isValidIPv4String(host)[0]) {
       this.host = host;
@@ -113,7 +128,7 @@ class WebSocketClient {
     const timer =
       ctx.timer ??
       new Timer({
-        delay: this.connectionTimeout,
+        delay: this.connectionTimeoutTime,
       });
     void timer.catch(() => {});
     void timer
@@ -204,8 +219,8 @@ class WebSocketClient {
     const webSocketStreamClient = new WebSocketStreamClientInternal(
       ws,
       this.maxReadableStreamBytes,
-      this.pingInterval,
-      this.pingTimeout,
+      this.pingIntervalTime,
+      this.pingTimeoutTime,
       this.logger,
     );
     const abortStream = () => {