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

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

@@ -16,11 +16,11 @@
  */
 
 import { ChannelOptions, channelOptionsEqual } from './channel-options';
+import { Subchannel } from './subchannel';
 import {
-  Subchannel,
   SubchannelAddress,
   subchannelAddressEqual,
-} from './subchannel';
+} from './subchannel-address';
 import { ChannelCredentials } from './channel-credentials';
 import { GrpcUri, uriToString } from './uri-parser';
 

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

@@ -18,32 +18,30 @@
 import * as http2 from 'http2';
 import { ChannelCredentials } from './channel-credentials';
 import { Metadata } from './metadata';
-import { Http2CallStream } from './call-stream';
+import { Call, Http2CallStream, WriteObject } from './call-stream';
 import { ChannelOptions } from './channel-options';
-import { PeerCertificate, checkServerIdentity } from 'tls';
-import { ConnectivityState } from './channel';
+import { PeerCertificate, checkServerIdentity, TLSSocket, CipherNameAndProtocol } from 'tls';
+import { ConnectivityState } from './connectivity-state';
 import { BackoffTimeout, BackoffOptions } from './backoff-timeout';
 import { getDefaultAuthority } from './resolver';
 import * as logging from './logging';
-import { LogVerbosity } from './constants';
+import { LogVerbosity, Status } from './constants';
 import { getProxiedConnection, ProxyConnectionResult } from './http_proxy';
 import * as net from 'net';
 import { GrpcUri, parseUri, splitHostPort, uriToString } from './uri-parser';
 import { ConnectionOptions } from 'tls';
-import { FilterFactory, Filter } from './filter';
+import { FilterFactory, Filter, BaseFilter } from './filter';
+import {
+  stringToSubchannelAddress,
+  SubchannelAddress,
+  subchannelAddressToString,
+} from './subchannel-address';
+import { SubchannelRef, ChannelzTrace, ChannelzChildrenTracker, SubchannelInfo, registerChannelzSubchannel, ChannelzCallTracker, SocketInfo, SocketRef, unregisterChannelzRef, registerChannelzSocket, TlsInfo } from './channelz';
 
 const clientVersion = require('../../package.json').version;
 
 const TRACER_NAME = 'subchannel';
 
-function trace(text: string): void {
-  logging.trace(LogVerbosity.DEBUG, TRACER_NAME, text);
-}
-
-function refTrace(text: string): void {
-  logging.trace(LogVerbosity.DEBUG, 'subchannel_refcount', text);
-}
-
 const MIN_CONNECT_TIMEOUT_MS = 20000;
 const INITIAL_BACKOFF_MS = 1000;
 const BACKOFF_MULTIPLIER = 1.6;
@@ -62,6 +60,11 @@ export type ConnectivityStateListener = (
   newState: ConnectivityState
 ) => void;
 
+export interface SubchannelCallStatsTracker {
+  addMessageSent(): void;
+  addMessageReceived(): void;
+}
+
 const {
   HTTP2_HEADER_AUTHORITY,
   HTTP2_HEADER_CONTENT_TYPE,
@@ -82,52 +85,6 @@ function uniformRandom(min: number, max: number) {
 
 const tooManyPingsData: Buffer = Buffer.from('too_many_pings', 'ascii');
 
-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;
-  }
-}
-
 export class Subchannel {
   /**
    * The subchannel's current connectivity state. Invariant: `session` === `null`
@@ -183,7 +140,7 @@ export class Subchannel {
   /**
    * Indicates whether keepalive pings should be sent without any active calls
    */
-  private keepaliveWithoutCalls: boolean = false;
+  private keepaliveWithoutCalls = false;
 
   /**
    * Tracks calls with references to this subchannel
@@ -199,6 +156,26 @@ export class Subchannel {
    */
   private subchannelAddressString: string;
 
+  // Channelz info
+  private channelzRef: SubchannelRef;
+  private channelzTrace: ChannelzTrace;
+  private callTracker = new ChannelzCallTracker();
+  private childrenTracker = new ChannelzChildrenTracker();
+
+  // Channelz socket info
+  private channelzSocketRef: SocketRef | null = null;
+  /**
+   * Name of the remote server, if it is not the same as the subchannel
+   * address, i.e. if connecting through an HTTP CONNECT proxy.
+   */
+  private remoteName: string | null = null;
+  private streamTracker = new ChannelzCallTracker();
+  private keepalivesSent = 0;
+  private messagesSent = 0;
+  private messagesReceived = 0;
+  private lastMessageSentTimestamp: Date | null = null;
+  private lastMessageReceivedTimestamp: Date | null = null;
+
   /**
    * A class representing a connection to a single backend.
    * @param channelTarget The target string for the channel as a whole
@@ -231,7 +208,8 @@ export class Subchannel {
       this.keepaliveTimeoutMs = options['grpc.keepalive_timeout_ms']!;
     }
     if ('grpc.keepalive_permit_without_calls' in options) {
-      this.keepaliveWithoutCalls = options['grpc.keepalive_permit_without_calls'] === 1;
+      this.keepaliveWithoutCalls =
+        options['grpc.keepalive_permit_without_calls'] === 1;
     } else {
       this.keepaliveWithoutCalls = false;
     }
@@ -247,6 +225,87 @@ export class Subchannel {
       this.handleBackoffTimer();
     }, backoffOptions);
     this.subchannelAddressString = subchannelAddressToString(subchannelAddress);
+
+    this.channelzRef = registerChannelzSubchannel(this.subchannelAddressString, () => this.getChannelzInfo());
+    this.channelzTrace = new ChannelzTrace();
+    this.channelzTrace.addTrace('CT_INFO', 'Subchannel created');
+    this.trace('Subchannel constructed with options ' + JSON.stringify(options, undefined, 2));
+  }
+
+  private getChannelzInfo(): SubchannelInfo {
+    return {
+      state: this.connectivityState,
+      trace: this.channelzTrace,
+      callTracker: this.callTracker,
+      children: this.childrenTracker.getChildLists(),
+      target: this.subchannelAddressString
+    };
+  }
+
+  private getChannelzSocketInfo(): SocketInfo | null {
+    if (this.session === null) {
+      return null;
+    }
+    const sessionSocket = this.session.socket;
+    const remoteAddress = sessionSocket.remoteAddress ? stringToSubchannelAddress(sessionSocket.remoteAddress, sessionSocket.remotePort) : null;
+    const localAddress = stringToSubchannelAddress(sessionSocket.localAddress, sessionSocket.localPort);
+    let tlsInfo: TlsInfo | null;
+    if (this.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: this.remoteName,
+      streamsStarted: this.streamTracker.callsStarted,
+      streamsSucceeded: this.streamTracker.callsSucceeded,
+      streamsFailed: this.streamTracker.callsFailed,
+      messagesSent: this.messagesSent,
+      messagesReceived: this.messagesReceived,
+      keepAlivesSent: this.keepalivesSent,
+      lastLocalStreamCreatedTimestamp: this.streamTracker.lastCallStartedTimestamp,
+      lastRemoteStreamCreatedTimestamp: null,
+      lastMessageSentTimestamp: this.lastMessageSentTimestamp,
+      lastMessageReceivedTimestamp: this.lastMessageReceivedTimestamp,
+      localFlowControlWindow: this.session.state.localWindowSize ?? null,
+      remoteFlowControlWindow: this.session.state.remoteWindowSize ?? null
+    };
+    return socketInfo;
+  }
+
+  private resetChannelzSocketInfo() {
+    if (this.channelzSocketRef) {
+      unregisterChannelzRef(this.channelzSocketRef);
+      this.childrenTracker.unrefChild(this.channelzSocketRef);
+      this.channelzSocketRef = null;
+    }
+    this.remoteName = null;
+    this.streamTracker = new ChannelzCallTracker();
+    this.keepalivesSent = 0;
+    this.messagesSent = 0;
+    this.messagesReceived = 0;
+    this.lastMessageSentTimestamp = null;
+    this.lastMessageReceivedTimestamp = null;
+  }
+
+  private trace(text: string): void {
+    logging.trace(LogVerbosity.DEBUG, TRACER_NAME, '(' + this.channelzRef.id + ') ' + this.subchannelAddressString + ' ' + text);
+  }
+
+  private refTrace(text: string): void {
+    logging.trace(LogVerbosity.DEBUG, 'subchannel_refcount', '(' + this.channelzRef.id + ') ' + this.subchannelAddressString + ' ' + text);
   }
 
   private handleBackoffTimer() {
@@ -276,7 +335,13 @@ export class Subchannel {
   }
 
   private sendPing() {
-    logging.trace(LogVerbosity.DEBUG, 'keepalive', 'Sending ping to ' + this.subchannelAddressString);
+    this.keepalivesSent += 1;
+    logging.trace(
+      LogVerbosity.DEBUG,
+      'keepalive',
+      '(' + this.channelzRef.id + ') ' + this.subchannelAddressString + ' ' +
+      'Sending ping'
+    );
     this.keepaliveTimeoutId = setTimeout(() => {
       this.transitionToState([ConnectivityState.READY], ConnectivityState.IDLE);
     }, this.keepaliveTimeoutMs);
@@ -292,7 +357,7 @@ export class Subchannel {
     this.keepaliveIntervalId = setInterval(() => {
       this.sendPing();
     }, this.keepaliveTimeMs);
-    this.keepaliveIntervalId.unref?.()
+    this.keepaliveIntervalId.unref?.();
     /* Don't send a ping immediately because whatever caused us to start
      * sending pings should also involve some network activity. */
   }
@@ -304,9 +369,11 @@ export class Subchannel {
 
   private createSession(proxyConnectionResult: ProxyConnectionResult) {
     if (proxyConnectionResult.realTarget) {
-      trace(this.subchannelAddressString + ' creating HTTP/2 session through proxy to ' + proxyConnectionResult.realTarget);
+      this.remoteName = uriToString(proxyConnectionResult.realTarget);
+      this.trace('creating HTTP/2 session through proxy to ' + proxyConnectionResult.realTarget);
     } else {
-      trace(this.subchannelAddressString + ' creating HTTP/2 session');
+      this.remoteName = null;
+      this.trace('creating HTTP/2 session');
     }
     const targetAuthority = getDefaultAuthority(
       proxyConnectionResult.realTarget ?? this.channelTarget
@@ -315,7 +382,9 @@ export class Subchannel {
       this.credentials._getConnectionOptions() || {};
     connectionOptions.maxSendHeaderBlockLength = Number.MAX_SAFE_INTEGER;
     if ('grpc-node.max_session_memory' in this.options) {
-      connectionOptions.maxSessionMemory = this.options['grpc-node.max_session_memory'];
+      connectionOptions.maxSessionMemory = this.options[
+        'grpc-node.max_session_memory'
+      ];
     }
     let addressScheme = 'http://';
     if ('secureContext' in connectionOptions) {
@@ -393,6 +462,8 @@ export class Subchannel {
       connectionOptions
     );
     this.session = session;
+    this.channelzSocketRef = registerChannelzSocket(this.subchannelAddressString, () => this.getChannelzSocketInfo()!);
+    this.childrenTracker.refChild(this.channelzSocketRef);
     session.unref();
     /* For all of these events, check if the session at the time of the event
      * is the same one currently attached to this subchannel, to ensure that
@@ -408,7 +479,7 @@ export class Subchannel {
     });
     session.once('close', () => {
       if (this.session === session) {
-        trace(this.subchannelAddressString + ' connection closed');
+        this.trace('connection closed');
         this.transitionToState(
           [ConnectivityState.CONNECTING],
           ConnectivityState.TRANSIENT_FAILURE
@@ -438,12 +509,15 @@ export class Subchannel {
             );
             logging.log(
               LogVerbosity.ERROR,
-              `Connection to ${uriToString(this.channelTarget)} at ${this.subchannelAddressString} rejected by server because of excess pings. Increasing ping interval to ${this.keepaliveTimeMs} ms`
+              `Connection to ${uriToString(this.channelTarget)} at ${
+                this.subchannelAddressString
+              } rejected by server because of excess pings. Increasing ping interval to ${
+                this.keepaliveTimeMs
+              } ms`
             );
           }
-          trace(
-            this.subchannelAddressString +
-              ' connection closed by GOAWAY with code ' +
+          this.trace(
+            'connection closed by GOAWAY with code ' +
               errorCode
           );
           this.transitionToState(
@@ -456,12 +530,12 @@ export class Subchannel {
     session.once('error', (error) => {
       /* Do nothing here. Any error should also trigger a close event, which is
        * where we want to handle that.  */
-      trace(
-        this.subchannelAddressString +
-          ' connection closed with error ' +
+      this.trace(
+        'connection closed with error ' +
           (error as Error).message
       );
     });
+    registerChannelzSocket(this.subchannelAddressString, () => this.getChannelzSocketInfo()!);
   }
 
   private startConnectingInternal() {
@@ -536,13 +610,12 @@ export class Subchannel {
     if (oldStates.indexOf(this.connectivityState) === -1) {
       return false;
     }
-    trace(
-      this.subchannelAddressString +
-        ' ' +
-        ConnectivityState[this.connectivityState] +
+    this.trace(
+      ConnectivityState[this.connectivityState] +
         ' -> ' +
         ConnectivityState[newState]
     );
+    this.channelzTrace.addTrace('CT_INFO', ConnectivityState[this.connectivityState] + ' -> ' + ConnectivityState[newState]);
     const previousState = this.connectivityState;
     this.connectivityState = newState;
     switch (newState) {
@@ -567,6 +640,7 @@ export class Subchannel {
           this.session.close();
         }
         this.session = null;
+        this.resetChannelzSocketInfo();
         this.stopKeepalivePings();
         /* If the backoff timer has already ended by the time we get to the
          * TRANSIENT_FAILURE state, we want to immediately transition out of
@@ -582,6 +656,7 @@ export class Subchannel {
           this.session.close();
         }
         this.session = null;
+        this.resetChannelzSocketInfo();
         this.stopKeepalivePings();
         break;
       default:
@@ -603,20 +678,18 @@ export class Subchannel {
     /* If no calls, channels, or subchannel pools have any more references to
      * this subchannel, we can be sure it will never be used again. */
     if (this.callRefcount === 0 && this.refcount === 0) {
+      this.channelzTrace.addTrace('CT_INFO', 'Shutting down');
       this.transitionToState(
-        [
-          ConnectivityState.CONNECTING,
-          ConnectivityState.READY,
-        ],
+        [ConnectivityState.CONNECTING, ConnectivityState.READY],
         ConnectivityState.TRANSIENT_FAILURE
       );
+      unregisterChannelzRef(this.channelzRef);
     }
   }
 
   callRef() {
-    refTrace(
-      this.subchannelAddressString +
-        ' callRefcount ' +
+    this.refTrace(
+      'callRefcount ' +
         this.callRefcount +
         ' -> ' +
         (this.callRefcount + 1)
@@ -634,9 +707,8 @@ export class Subchannel {
   }
 
   callUnref() {
-    refTrace(
-      this.subchannelAddressString +
-        ' callRefcount ' +
+    this.refTrace(
+      'callRefcount ' +
         this.callRefcount +
         ' -> ' +
         (this.callRefcount - 1)
@@ -655,9 +727,8 @@ export class Subchannel {
   }
 
   ref() {
-    refTrace(
-      this.subchannelAddressString +
-        ' refcount ' +
+    this.refTrace(
+      'refcount ' +
         this.refcount +
         ' -> ' +
         (this.refcount + 1)
@@ -666,9 +737,8 @@ export class Subchannel {
   }
 
   unref() {
-    refTrace(
-      this.subchannelAddressString +
-        ' refcount ' +
+    this.refTrace(
+      'refcount ' +
         this.refcount +
         ' -> ' +
         (this.refcount - 1)
@@ -695,7 +765,7 @@ export class Subchannel {
   startCallStream(
     metadata: Metadata,
     callStream: Http2CallStream,
-    extraFilterFactory?: FilterFactory<Filter>
+    extraFilters: Filter[]
   ) {
     const headers = metadata.toHttp2Headers();
     headers[HTTP2_HEADER_AUTHORITY] = callStream.getHost();
@@ -726,8 +796,43 @@ export class Subchannel {
     for (const header of Object.keys(headers)) {
       headersString += '\t\t' + header + ': ' + headers[header] + '\n';
     }
-    logging.trace(LogVerbosity.DEBUG, 'call_stream', 'Starting stream on subchannel ' + this.subchannelAddressString + ' with headers\n' + headersString);
-    callStream.attachHttp2Stream(http2Stream, this, extraFilterFactory);
+    logging.trace(
+      LogVerbosity.DEBUG,
+      'call_stream',
+      'Starting stream on subchannel ' +
+        '(' + this.channelzRef.id + ') ' +
+        this.subchannelAddressString +
+        ' with headers\n' +
+        headersString
+    );
+    this.callTracker.addCallStarted();
+    callStream.addStatusWatcher(status => {
+      if (status.code === Status.OK) {
+        this.callTracker.addCallSucceeded();
+      } else {
+        this.callTracker.addCallFailed();
+      }
+    });
+    const streamSession = this.session;
+    this.streamTracker.addCallStarted();
+    callStream.addStreamEndWatcher(success => {
+      if (streamSession === this.session) {
+        if (success) {
+          this.streamTracker.addCallSucceeded();
+        } else {
+          this.streamTracker.addCallFailed();
+        }
+      }
+    });
+    callStream.attachHttp2Stream(http2Stream, this, extraFilters, {
+      addMessageSent: () => {
+        this.messagesSent += 1;
+        this.lastMessageSentTimestamp = new Date();
+      },
+      addMessageReceived: () => {
+        this.messagesReceived += 1;
+      }
+    });
   }
 
   /**
@@ -806,4 +911,8 @@ export class Subchannel {
   getAddress(): string {
     return this.subchannelAddressString;
   }
+
+  getChannelzRef(): SubchannelRef {
+    return this.channelzRef;
+  }
 }

package/node_modules/@grpc/proto-loader/build/bin/proto-loader-gen-types.js

@@ -444,6 +444,37 @@ function generateEnumInterface(formatter, enumType, options, nameOverride) {
     formatter.unindent();
     formatter.writeLine('}');
 }
+/**
+ * This is a list of methods that are exist in the generic Client class in the
+ * gRPC libraries. TypeScript has a problem with methods in subclasses with the
+ * same names as methods in the superclass, but with mismatched APIs. So, we
+ * avoid generating methods with these names in the service client interfaces.
+ * We always generate two service client methods per service method: one camel
+ * cased, and one with the original casing. So we will still generate one
+ * service client method for any conflicting name.
+ *
+ * Technically, at runtime conflicting name in the service client method
+ * actually shadows the original method, but TypeScript does not have a good
+ * way to represent that. So this change is not 100% accurate, but it gets the
+ * generated code to compile.
+ *
+ * This is just a list of the methods in the Client class definitions in
+ * grpc@1.24.11 and @grpc/grpc-js@1.4.0.
+ */
+const CLIENT_RESERVED_METHOD_NAMES = new Set([
+    'close',
+    'getChannel',
+    'waitForReady',
+    'makeUnaryRequest',
+    'makeClientStreamRequest',
+    'makeServerStreamRequest',
+    'makeBidiStreamRequest',
+    'resolveCallInterceptors',
+    /* These methods are private, but TypeScript is not happy with overriding even
+     * private methods with mismatched APIs. */
+    'checkOptionalUnaryResponseArguments',
+    'checkMetadataAndOptions'
+]);
 function generateServiceClientInterface(formatter, serviceType, options) {
     if (options.includeComments) {
         formatComment(formatter, serviceType.comment);
@@ -453,6 +484,9 @@ function generateServiceClientInterface(formatter, serviceType, options) {
     for (const methodName of Object.keys(serviceType.methods).sort()) {
         const method = serviceType.methods[methodName];
         for (const name of [methodName, camelCase(methodName)]) {
+            if (CLIENT_RESERVED_METHOD_NAMES.has(name)) {
+                continue;
+            }
             if (options.includeComments) {
                 formatComment(formatter, method.comment);
             }

package/node_modules/@grpc/proto-loader/build/src/index.js

@@ -72,6 +72,9 @@ function createDeserializer(cls, options) {
 }
 function createSerializer(cls) {
     return function serialize(arg) {
+        if (Array.isArray(arg)) {
+            throw new Error(`Failed to serialize message: expected object with ${cls.name} structure, got array instead`);
+        }
         const message = cls.fromObject(arg);
         return cls.encode(message).finish();
     };

package/node_modules/@grpc/proto-loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grpc/proto-loader",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "author": "Google Inc.",
   "contributors": [
     {