@finsemble/finsemble-electron-adapter 6.2.1 → 6.3.1-beta-1

package/node_modules/@grpc/grpc-js/src/server.ts

@@ -56,15 +56,14 @@ import {
   TcpSubchannelAddress,
   isTcpSubchannelAddress,
   subchannelAddressToString,
-} from './subchannel';
+  stringToSubchannelAddress,
+} from './subchannel-address';
 import { parseUri } from './uri-parser';
+import { ChannelzCallTracker, ChannelzChildrenTracker, ChannelzTrace, registerChannelzServer, registerChannelzSocket, ServerInfo, ServerRef, SocketInfo, SocketRef, TlsInfo, unregisterChannelzRef } from './channelz';
+import { CipherNameAndProtocol, TLSSocket } from 'tls';
 
 const TRACER_NAME = 'server';
 
-function trace(text: string): void {
-  logging.trace(LogVerbosity.DEBUG, TRACER_NAME, text);
-}
-
 interface BindResult {
   port: number;
   count: number;
@@ -125,21 +124,101 @@ function getDefaultHandler(handlerType: HandlerType, methodName: string) {
   }
 }
 
+interface ChannelzSessionInfo {
+  ref: SocketRef;
+  streamTracker: ChannelzCallTracker;
+  messagesSent: number;
+  messagesReceived: number;
+  lastMessageSentTimestamp: Date | null;
+  lastMessageReceivedTimestamp: Date | null;
+}
+
+interface ChannelzListenerInfo {
+  ref: SocketRef;
+}
+
 export class Server {
-  private http2ServerList: (http2.Http2Server | http2.Http2SecureServer)[] = [];
+  private http2ServerList: { server: (http2.Http2Server | http2.Http2SecureServer), channelzRef: SocketRef }[] = [];
 
   private handlers: Map<string, UntypedHandler> = new Map<
     string,
     UntypedHandler
   >();
-  private sessions = new Set<http2.ServerHttp2Session>();
+  private sessions = new Map<http2.ServerHttp2Session, ChannelzSessionInfo>();
   private started = false;
   private options: ChannelOptions;
 
+  // Channelz Info
+  private channelzRef: ServerRef;
+  private channelzTrace = new ChannelzTrace();
+  private callTracker = new ChannelzCallTracker();
+  private listenerChildrenTracker = new ChannelzChildrenTracker();
+  private sessionChildrenTracker = new ChannelzChildrenTracker();
+
   constructor(options?: ChannelOptions) {
     this.options = options ?? {};
+    this.channelzRef = registerChannelzServer(() => this.getChannelzInfo());
+    this.channelzTrace.addTrace('CT_INFO', 'Server created');
+    this.trace('Server constructed');
+  }
+
+  private getChannelzInfo(): ServerInfo {
+    return {
+      trace: this.channelzTrace,
+      callTracker: this.callTracker,
+      listenerChildren: this.listenerChildrenTracker.getChildLists(),
+      sessionChildren: this.sessionChildrenTracker.getChildLists()
+    };
   }
 
+  private getChannelzSessionInfoGetter(session: http2.ServerHttp2Session): () => SocketInfo {
+    return () => {
+      const sessionInfo = this.sessions.get(session)!;
+      const sessionSocket = session.socket;
+      const remoteAddress = sessionSocket.remoteAddress ? stringToSubchannelAddress(sessionSocket.remoteAddress, sessionSocket.remotePort) : null;
+      const localAddress = stringToSubchannelAddress(sessionSocket.localAddress, sessionSocket.localPort);
+      let tlsInfo: TlsInfo | null;
+      if (session.encrypted) {
+        const tlsSocket: TLSSocket = sessionSocket as TLSSocket;
+        const cipherInfo: CipherNameAndProtocol & {standardName?: string} = tlsSocket.getCipher();
+        const certificate = tlsSocket.getCertificate();
+        const peerCertificate = tlsSocket.getPeerCertificate();
+        tlsInfo = {
+          cipherSuiteStandardName: cipherInfo.standardName ?? null,
+          cipherSuiteOtherName: cipherInfo.standardName ? null : cipherInfo.name,
+          localCertificate: (certificate && 'raw' in certificate) ? certificate.raw : null,
+          remoteCertificate: (peerCertificate && 'raw' in peerCertificate) ? peerCertificate.raw : null
+        };
+      } else {
+        tlsInfo = null;
+      }
+      const socketInfo: SocketInfo = {
+        remoteAddress: remoteAddress,
+        localAddress: localAddress,
+        security: tlsInfo,
+        remoteName: null,
+        streamsStarted: sessionInfo.streamTracker.callsStarted,
+        streamsSucceeded: sessionInfo.streamTracker.callsSucceeded,
+        streamsFailed: sessionInfo.streamTracker.callsFailed,
+        messagesSent: sessionInfo.messagesSent,
+        messagesReceived: sessionInfo.messagesReceived,
+        keepAlivesSent: 0,
+        lastLocalStreamCreatedTimestamp: null,
+        lastRemoteStreamCreatedTimestamp: sessionInfo.streamTracker.lastCallStartedTimestamp,
+        lastMessageSentTimestamp: sessionInfo.lastMessageSentTimestamp,
+        lastMessageReceivedTimestamp: sessionInfo.lastMessageReceivedTimestamp,
+        localFlowControlWindow: session.state.localWindowSize ?? null,
+        remoteFlowControlWindow: session.state.remoteWindowSize ?? null
+      };
+      return socketInfo;
+    };
+  }
+
+  private trace(text: string): void {
+    logging.trace(LogVerbosity.DEBUG, TRACER_NAME, '(' + this.channelzRef.id + ') ' + text);
+  }
+  
+
   addProtoService(): void {
     throw new Error('Not implemented. Use addService() instead');
   }
@@ -209,10 +288,7 @@ export class Server {
   }
 
   removeService(service: ServiceDefinition): void {
-    if (
-      service === null ||
-      typeof service !== 'object'
-    ) {
+    if (service === null || typeof service !== 'object') {
       throw new Error('removeService() requires object as argument');
     }
 
@@ -240,8 +316,8 @@ export class Server {
       throw new TypeError('port must be a string');
     }
 
-    if (creds === null || typeof creds !== 'object') {
-      throw new TypeError('creds must be an object');
+    if (creds === null || !(creds instanceof ServerCredentials)) {
+      throw new TypeError('creds must be a ServerCredentials object');
     }
 
     if (typeof callback !== 'function') {
@@ -258,10 +334,12 @@ export class Server {
     }
 
     const serverOptions: http2.ServerOptions = {
-      maxSendHeaderBlockLength: Number.MAX_SAFE_INTEGER
+      maxSendHeaderBlockLength: Number.MAX_SAFE_INTEGER,
     };
     if ('grpc-node.max_session_memory' in this.options) {
-      serverOptions.maxSessionMemory = this.options['grpc-node.max_session_memory'];
+      serverOptions.maxSessionMemory = this.options[
+        'grpc-node.max_session_memory'
+      ];
     }
     if ('grpc.max_concurrent_streams' in this.options) {
       serverOptions.settings = {
@@ -269,6 +347,10 @@ export class Server {
       };
     }
 
+    const deferredCallback = (error: Error | null, port: number) => {
+      process.nextTick(() => callback(error, port));
+    }
+
     const setupServer = (): http2.Http2Server | http2.Http2SecureServer => {
       let http2Server: http2.Http2Server | http2.Http2SecureServer;
       if (creds._isSecure()) {
@@ -296,7 +378,7 @@ export class Server {
       }
       return Promise.all(
         addressList.map((address) => {
-          trace('Attempting to bind ' + subchannelAddressToString(address));
+          this.trace('Attempting to bind ' + subchannelAddressToString(address));
           let addr: SubchannelAddress;
           if (isTcpSubchannelAddress(address)) {
             addr = {
@@ -309,21 +391,50 @@ export class Server {
 
           const http2Server = setupServer();
           return new Promise<number | Error>((resolve, reject) => {
-            function onError(err: Error): void {
+            const onError = (err: Error) => {
+              this.trace('Failed to bind ' + subchannelAddressToString(address) + ' with error ' + err.message);
               resolve(err);
             }
 
             http2Server.once('error', onError);
 
             http2Server.listen(addr, () => {
-              trace('Successfully bound ' + subchannelAddressToString(address));
-              this.http2ServerList.push(http2Server);
               const boundAddress = http2Server.address()!;
+              let boundSubchannelAddress: SubchannelAddress;
               if (typeof boundAddress === 'string') {
-                resolve(portNum);
+                boundSubchannelAddress = {
+                  path: boundAddress
+                };
               } else {
-                resolve(boundAddress.port);
+                boundSubchannelAddress = {
+                  host: boundAddress.address,
+                  port: boundAddress.port
+                }
               }
+              const channelzRef = registerChannelzSocket(subchannelAddressToString(boundSubchannelAddress), () => {
+                return {
+                  localAddress: boundSubchannelAddress,
+                  remoteAddress: null,
+                  security: null,
+                  remoteName: null,
+                  streamsStarted: 0,
+                  streamsSucceeded: 0,
+                  streamsFailed: 0,
+                  messagesSent: 0,
+                  messagesReceived: 0,
+                  keepAlivesSent: 0,
+                  lastLocalStreamCreatedTimestamp: null,
+                  lastRemoteStreamCreatedTimestamp: null,
+                  lastMessageSentTimestamp: null,
+                  lastMessageReceivedTimestamp: null,
+                  localFlowControlWindow: null,
+                  remoteFlowControlWindow: null
+                };
+              });
+              this.listenerChildrenTracker.refChild(channelzRef);
+              this.http2ServerList.push({server: http2Server, channelzRef: channelzRef});
+              this.trace('Successfully bound ' + subchannelAddressToString(boundSubchannelAddress));
+              resolve('port' in boundSubchannelAddress ? boundSubchannelAddress.port : portNum);
               http2Server.removeListener('error', onError);
             });
           });
@@ -356,18 +467,46 @@ export class Server {
       const address = addressList[0];
       const http2Server = setupServer();
       return new Promise<BindResult>((resolve, reject) => {
-        function onError(err: Error): void {
+        const onError = (err: Error) => {
+          this.trace('Failed to bind ' + subchannelAddressToString(address) + ' with error ' + err.message);
           resolve(bindWildcardPort(addressList.slice(1)));
         }
 
         http2Server.once('error', onError);
 
         http2Server.listen(address, () => {
-          this.http2ServerList.push(http2Server);
+          const boundAddress = http2Server.address() as AddressInfo;
+          const boundSubchannelAddress: SubchannelAddress = {
+            host: boundAddress.address,
+            port: boundAddress.port
+          };
+          const channelzRef = registerChannelzSocket(subchannelAddressToString(boundSubchannelAddress), () => {
+            return {
+              localAddress: boundSubchannelAddress,
+              remoteAddress: null,
+              security: null,
+              remoteName: null,
+              streamsStarted: 0,
+              streamsSucceeded: 0,
+              streamsFailed: 0,
+              messagesSent: 0,
+              messagesReceived: 0,
+              keepAlivesSent: 0,
+              lastLocalStreamCreatedTimestamp: null,
+              lastRemoteStreamCreatedTimestamp: null,
+              lastMessageSentTimestamp: null,
+              lastMessageReceivedTimestamp: null,
+              localFlowControlWindow: null,
+              remoteFlowControlWindow: null
+            };
+          });
+          this.listenerChildrenTracker.refChild(channelzRef);
+          this.http2ServerList.push({server: http2Server, channelzRef: channelzRef});
+          this.trace('Successfully bound ' + subchannelAddressToString(boundSubchannelAddress));
           resolve(
             bindSpecificPort(
               addressList.slice(1),
-              (http2Server.address() as AddressInfo).port,
+              boundAddress.port,
               1
             )
           );
@@ -385,7 +524,7 @@ export class Server {
         // We only want one resolution result. Discard all future results
         resolverListener.onSuccessfulResolution = () => {};
         if (addressList.length === 0) {
-          callback(new Error(`No addresses resolved for port ${port}`), 0);
+          deferredCallback(new Error(`No addresses resolved for port ${port}`), 0);
           return;
         }
         let bindResultPromise: Promise<BindResult>;
@@ -408,7 +547,7 @@ export class Server {
             if (bindResult.count === 0) {
               const errorString = `No address added out of total ${addressList.length} resolved`;
               logging.log(LogVerbosity.ERROR, errorString);
-              callback(new Error(errorString), 0);
+              deferredCallback(new Error(errorString), 0);
             } else {
               if (bindResult.count < addressList.length) {
                 logging.log(
@@ -416,18 +555,18 @@ export class Server {
                   `WARNING Only ${bindResult.count} addresses added out of total ${addressList.length} resolved`
                 );
               }
-              callback(null, bindResult.port);
+              deferredCallback(null, bindResult.port);
             }
           },
           (error) => {
             const errorString = `No address added out of total ${addressList.length} resolved`;
             logging.log(LogVerbosity.ERROR, errorString);
-            callback(new Error(errorString), 0);
+            deferredCallback(new Error(errorString), 0);
           }
         );
       },
       onError: (error) => {
-        callback(new Error(error.details), 0);
+        deferredCallback(new Error(error.details), 0);
       },
     };
 
@@ -438,9 +577,12 @@ export class Server {
   forceShutdown(): void {
     // Close the server if it is still running.
 
-    for (const http2Server of this.http2ServerList) {
+    for (const {server: http2Server, channelzRef: ref} of this.http2ServerList) {
       if (http2Server.listening) {
-        http2Server.close();
+        http2Server.close(() => {
+          this.listenerChildrenTracker.unrefChild(ref);
+          unregisterChannelzRef(ref);
+        });
       }
     }
 
@@ -448,13 +590,14 @@ export class Server {
 
     // Always destroy any available sessions. It's possible that one or more
     // tryShutdown() calls are in progress. Don't wait on them to finish.
-    this.sessions.forEach((session) => {
+    this.sessions.forEach((channelzInfo, session) => {
       // Cast NGHTTP2_CANCEL to any because TypeScript doesn't seem to
       // recognize destroy(code) as a valid signature.
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       session.destroy(http2.constants.NGHTTP2_CANCEL as any);
     });
     this.sessions.clear();
+    unregisterChannelzRef(this.channelzRef);
   }
 
   register<RequestType, ResponseType>(
@@ -486,7 +629,7 @@ export class Server {
     if (
       this.http2ServerList.length === 0 ||
       this.http2ServerList.every(
-        (http2Server) => http2Server.listening !== true
+        ({server: http2Server}) => http2Server.listening !== true
       )
     ) {
       throw new Error('server must be bound in order to start');
@@ -495,39 +638,47 @@ export class Server {
     if (this.started === true) {
       throw new Error('server is already started');
     }
-
+    this.channelzTrace.addTrace('CT_INFO', 'Starting');
     this.started = true;
   }
 
   tryShutdown(callback: (error?: Error) => void): void {
+    const wrappedCallback = (error?: Error) => {
+      unregisterChannelzRef(this.channelzRef);
+      callback(error);
+    };
     let pendingChecks = 0;
 
     function maybeCallback(): void {
       pendingChecks--;
 
       if (pendingChecks === 0) {
-        callback();
+        wrappedCallback();
       }
     }
 
     // Close the server if necessary.
     this.started = false;
 
-    for (const http2Server of this.http2ServerList) {
+    for (const {server: http2Server, channelzRef: ref} of this.http2ServerList) {
       if (http2Server.listening) {
         pendingChecks++;
-        http2Server.close(maybeCallback);
+        http2Server.close(() => {
+          this.listenerChildrenTracker.unrefChild(ref);
+          unregisterChannelzRef(ref);
+          maybeCallback();
+        });
       }
     }
 
-    this.sessions.forEach((session) => {
+    this.sessions.forEach((channelzInfo, session) => {
       if (!session.closed) {
         pendingChecks += 1;
         session.close(maybeCallback);
       }
     });
     if (pendingChecks === 0) {
-      callback();
+      wrappedCallback();
     }
   }
 
@@ -535,6 +686,10 @@ export class Server {
     throw new Error('Not yet implemented');
   }
 
+  getChannelzRef() {
+    return this.channelzRef;
+  }
+
   private _setupHandlers(
     http2Server: http2.Http2Server | http2.Http2SecureServer
   ): void {
@@ -545,6 +700,9 @@ export class Server {
     http2Server.on(
       'stream',
       (stream: http2.ServerHttp2Stream, headers: http2.IncomingHttpHeaders) => {
+        const channelzSessionInfo = this.sessions.get(stream.session as http2.ServerHttp2Session);
+        this.callTracker.addCallStarted();
+        channelzSessionInfo?.streamTracker.addCallStarted();
         const contentType = headers[http2.constants.HTTP2_HEADER_CONTENT_TYPE];
 
         if (
@@ -558,9 +716,13 @@ export class Server {
             },
             { endStream: true }
           );
+          this.callTracker.addCallFailed();
+          channelzSessionInfo?.streamTracker.addCallFailed();
           return;
         }
 
+        let call: Http2ServerCallStream<any, any> | null = null;
+
         try {
           const path = headers[http2.constants.HTTP2_HEADER_PATH] as string;
           const serverAddress = http2Server.address();
@@ -573,7 +735,7 @@ export class Server {
                 serverAddress.address + ':' + serverAddress.port;
             }
           }
-          trace(
+          this.trace(
             'Received call to method ' +
               path +
               ' at address ' +
@@ -582,7 +744,7 @@ export class Server {
           const handler = this.handlers.get(path);
 
           if (handler === undefined) {
-            trace(
+            this.trace(
               'No handler registered for method ' +
                 path +
                 '. Sending UNIMPLEMENTED status.'
@@ -590,7 +752,31 @@ export class Server {
             throw getUnimplementedStatusResponse(path);
           }
 
-          const call = new Http2ServerCallStream(stream, handler, this.options);
+          call = new Http2ServerCallStream(stream, handler, this.options);
+          call.once('callEnd', (code: Status) => {
+            if (code === Status.OK) {
+              this.callTracker.addCallSucceeded();
+            } else {
+              this.callTracker.addCallFailed();
+            }
+          });
+          if (channelzSessionInfo) {
+            call.once('streamEnd', (success: boolean) => {
+              if (success) {
+                channelzSessionInfo.streamTracker.addCallSucceeded();
+              } else {
+                channelzSessionInfo.streamTracker.addCallFailed();
+              }
+            });
+            call.on('sendMessage', () => {
+              channelzSessionInfo.messagesSent += 1;
+              channelzSessionInfo.lastMessageSentTimestamp = new Date();
+            });
+            call.on('receiveMessage', () => {
+              channelzSessionInfo.messagesReceived += 1;
+              channelzSessionInfo.lastMessageReceivedTimestamp = new Date();
+            });
+          }
           const metadata: Metadata = call.receiveMetadata(headers) as Metadata;
           switch (handler.type) {
             case 'unary':
@@ -621,7 +807,11 @@ export class Server {
               throw new Error(`Unknown handler type: ${handler.type}`);
           }
         } catch (err) {
-          const call = new Http2ServerCallStream(stream, null!, this.options);
+          if (!call) {
+            call = new Http2ServerCallStream(stream, null!, this.options);
+            this.callTracker.addCallFailed();
+            channelzSessionInfo?.streamTracker.addCallFailed()
+          }
 
           if (err.code === undefined) {
             err.code = Status.INTERNAL;
@@ -638,9 +828,25 @@ export class Server {
         return;
       }
 
-      this.sessions.add(session);
+      const channelzRef = registerChannelzSocket(session.socket.remoteAddress ?? 'unknown', this.getChannelzSessionInfoGetter(session));
+
+      const channelzSessionInfo: ChannelzSessionInfo = {
+        ref: channelzRef,
+        streamTracker: new ChannelzCallTracker(),
+        messagesSent: 0,
+        messagesReceived: 0,
+        lastMessageSentTimestamp: null,
+        lastMessageReceivedTimestamp: null
+      };
 
+      this.sessions.set(session, channelzSessionInfo);
+      const clientAddress = session.socket.remoteAddress;
+      this.channelzTrace.addTrace('CT_INFO', 'Connection established by client ' + clientAddress);
+      this.sessionChildrenTracker.refChild(channelzRef);
       session.on('close', () => {
+        this.channelzTrace.addTrace('CT_INFO', 'Connection dropped by client ' + clientAddress);
+        this.sessionChildrenTracker.unrefChild(channelzRef);
+        unregisterChannelzRef(channelzRef);
         this.sessions.delete(session);
       });
     });

package/node_modules/@grpc/grpc-js/src/service-config.ts

@@ -27,17 +27,25 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import * as os from 'os';
-import { LoadBalancingConfig, validateLoadBalancingConfig } from './load-balancer';
+import {
+  LoadBalancingConfig,
+  validateLoadBalancingConfig,
+} from './load-balancer';
 
 export interface MethodConfigName {
   service: string;
   method?: string;
 }
 
+export interface Duration {
+  seconds: number;
+  nanos: number;
+}
+
 export interface MethodConfig {
   name: MethodConfigName[];
   waitForReady?: boolean;
-  timeout?: string;
+  timeout?: Duration;
   maxRequestBytes?: number;
   maxResponseBytes?: number;
 }
@@ -101,13 +109,34 @@ function validateMethodConfig(obj: any): MethodConfig {
     result.waitForReady = obj.waitForReady;
   }
   if ('timeout' in obj) {
-    if (
-      !(typeof obj.timeout === 'string') ||
-      !TIMEOUT_REGEX.test(obj.timeout)
+    if (typeof obj.timeout === 'object') {
+      if (
+        !('seconds' in obj.timeout) ||
+        !(typeof obj.timeout.seconds === 'number')
+      ) {
+        throw new Error('Invalid method config: invalid timeout.seconds');
+      }
+      if (
+        !('nanos' in obj.timeout) ||
+        !(typeof obj.timeout.nanos === 'number')
+      ) {
+        throw new Error('Invalid method config: invalid timeout.nanos');
+      }
+      result.timeout = obj.timeout;
+    } else if (
+      typeof obj.timeout === 'string' &&
+      TIMEOUT_REGEX.test(obj.timeout)
     ) {
+      const timeoutParts = obj.timeout
+        .substring(0, obj.timeout.length - 1)
+        .split('.');
+      result.timeout = {
+        seconds: timeoutParts[0] | 0,
+        nanos: (timeoutParts[1] ?? 0) | 0,
+      };
+    } else {
       throw new Error('Invalid method config: invalid timeout');
     }
-    result.timeout = obj.timeout;
   }
   if ('maxRequestBytes' in obj) {
     if (typeof obj.maxRequestBytes !== 'number') {

package/node_modules/@grpc/grpc-js/src/subchannel-address.ts

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { isIP } from "net";
+
+export interface TcpSubchannelAddress {
+  port: number;
+  host: string;
+}
+
+export interface IpcSubchannelAddress {
+  path: string;
+}
+/**
+ * This represents a single backend address to connect to. This interface is a
+ * subset of net.SocketConnectOpts, i.e. the options described at
+ * https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener.
+ * Those are in turn a subset of the options that can be passed to http2.connect.
+ */
+
+export type SubchannelAddress = TcpSubchannelAddress | IpcSubchannelAddress;
+
+export function isTcpSubchannelAddress(
+  address: SubchannelAddress
+): address is TcpSubchannelAddress {
+  return 'port' in address;
+}
+
+export function subchannelAddressEqual(
+  address1: SubchannelAddress,
+  address2: SubchannelAddress
+): boolean {
+  if (isTcpSubchannelAddress(address1)) {
+    return (
+      isTcpSubchannelAddress(address2) &&
+      address1.host === address2.host &&
+      address1.port === address2.port
+    );
+  } else {
+    return !isTcpSubchannelAddress(address2) && address1.path === address2.path;
+  }
+}
+
+export function subchannelAddressToString(address: SubchannelAddress): string {
+  if (isTcpSubchannelAddress(address)) {
+    return address.host + ':' + address.port;
+  } else {
+    return address.path;
+  }
+}
+
+const DEFAULT_PORT = 443;
+
+export function stringToSubchannelAddress(addressString: string, port?: number): SubchannelAddress {
+  if (isIP(addressString)) {
+    return {
+      host: addressString,
+      port: port ?? DEFAULT_PORT
+    };
+  } else {
+    return {
+      path: addressString
+    };
+  }
+}