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

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

@@ -33,22 +33,23 @@ import { FilterStackFactory } from './filter-stack';
 import { CallCredentialsFilterFactory } from './call-credentials-filter';
 import { DeadlineFilterFactory } from './deadline-filter';
 import { CompressionFilterFactory } from './compression-filter';
-import { CallConfig, ConfigSelector, getDefaultAuthority, mapUriDefaultScheme } from './resolver';
+import {
+  CallConfig,
+  ConfigSelector,
+  getDefaultAuthority,
+  mapUriDefaultScheme,
+} from './resolver';
 import { trace, log } from './logging';
-import { SubchannelAddress } from './subchannel';
+import { SubchannelAddress } from './subchannel-address';
 import { MaxMessageSizeFilterFactory } from './max-message-size-filter';
 import { mapProxyName } from './http_proxy';
 import { GrpcUri, parseUri, uriToString } from './uri-parser';
 import { ServerSurfaceCall } from './server-call';
 import { SurfaceCall } from './call';
+import { Filter } from './filter';
 
-export enum ConnectivityState {
-  IDLE,
-  CONNECTING,
-  READY,
-  TRANSIENT_FAILURE,
-  SHUTDOWN,
-}
+import { ConnectivityState } from './connectivity-state';
+import { ChannelInfo, ChannelRef, ChannelzCallTracker, ChannelzChildrenTracker, ChannelzTrace, registerChannelzChannel, SubchannelRef, unregisterChannelzRef } from './channelz';
 
 /**
  * See https://nodejs.org/api/timers.html#timers_setinterval_callback_delay_args
@@ -104,6 +105,12 @@ export interface Channel {
     deadline: Date | number,
     callback: (error?: Error) => void
   ): void;
+  /**
+   * Get the channelz reference object for this channel. A request to the
+   * channelz service for the id in this object will provide information
+   * about this channel.
+   */
+  getChannelzRef(): ChannelRef;
   /**
    * Create a call object. Call is an opaque type that is used by the Client
    * class. This function is called by the gRPC library when starting a
@@ -148,6 +155,7 @@ export class ChannelImplementation implements Channel {
     callStream: Http2CallStream;
     callMetadata: Metadata;
     callConfig: CallConfig;
+    dynamicFilters: Filter[];
   }> = [];
   private connectivityStateWatchers: ConnectivityStateWatcher[] = [];
   private defaultAuthority: string;
@@ -162,6 +170,14 @@ export class ChannelImplementation implements Channel {
    */
   private callRefTimer: NodeJS.Timer;
   private configSelector: ConfigSelector | null = null;
+
+  // Channelz info
+  private originalTarget: string;
+  private channelzRef: ChannelRef;
+  private channelzTrace: ChannelzTrace;
+  private callTracker = new ChannelzCallTracker();
+  private childrenTracker = new ChannelzChildrenTracker();
+
   constructor(
     target: string,
     private readonly credentials: ChannelCredentials,
@@ -176,20 +192,11 @@ export class ChannelImplementation implements Channel {
       );
     }
     if (options) {
-      if (
-        typeof options !== 'object' ||
-        !Object.values(options).every(
-          (value) =>
-            typeof value === 'string' ||
-            typeof value === 'number' ||
-            typeof value === 'undefined'
-        )
-      ) {
-        throw new TypeError(
-          'Channel options must be an object with string or number values'
-        );
+      if (typeof options !== 'object') {
+        throw new TypeError('Channel options must be an object');
       }
     }
+    this.originalTarget = target;
     const originalTargetUri = parseUri(target);
     if (originalTargetUri === null) {
       throw new Error(`Could not parse target name "${target}"`);
@@ -206,6 +213,10 @@ export class ChannelImplementation implements Channel {
     this.callRefTimer = setInterval(() => {}, MAX_TIMEOUT_TIME);
     this.callRefTimer.unref?.();
 
+    this.channelzRef = registerChannelzChannel(target, () => this.getChannelzInfo());
+    this.channelzTrace = new ChannelzTrace();
+    this.channelzTrace.addTrace('CT_INFO', 'Channel created');
+
     if (this.options['grpc.default_authority']) {
       this.defaultAuthority = this.options['grpc.default_authority'] as string;
     } else {
@@ -225,20 +236,22 @@ export class ChannelImplementation implements Channel {
         subchannelAddress: SubchannelAddress,
         subchannelArgs: ChannelOptions
       ) => {
-        return this.subchannelPool.getOrCreateSubchannel(
+        const subchannel = this.subchannelPool.getOrCreateSubchannel(
           this.target,
           subchannelAddress,
           Object.assign({}, this.options, subchannelArgs),
           this.credentials
         );
+        this.channelzTrace.addTrace('CT_INFO', 'Created subchannel or used existing subchannel', subchannel.getChannelzRef());
+        return subchannel;
       },
       updateState: (connectivityState: ConnectivityState, picker: Picker) => {
         this.currentPicker = picker;
         const queueCopy = this.pickQueue.slice();
         this.pickQueue = [];
         this.callRefTimerUnref();
-        for (const { callStream, callMetadata, callConfig } of queueCopy) {
-          this.tryPick(callStream, callMetadata, callConfig);
+        for (const { callStream, callMetadata, callConfig, dynamicFilters } of queueCopy) {
+          this.tryPick(callStream, callMetadata, callConfig, dynamicFilters);
         }
         this.updateState(connectivityState);
       },
@@ -248,36 +261,44 @@ export class ChannelImplementation implements Channel {
           'Resolving load balancer should never call requestReresolution'
         );
       },
+      addChannelzChild: (child: ChannelRef | SubchannelRef) => {
+        this.childrenTracker.refChild(child);
+      },
+      removeChannelzChild: (child: ChannelRef | SubchannelRef) => {
+        this.childrenTracker.unrefChild(child);
+      }
     };
     this.resolvingLoadBalancer = new ResolvingLoadBalancer(
       this.target,
       channelControlHelper,
       options,
       (configSelector) => {
+        this.channelzTrace.addTrace('CT_INFO', 'Address resolution succeeded');
         this.configSelector = configSelector;
         /* We process the queue asynchronously to ensure that the corresponding
          * load balancer update has completed. */
         process.nextTick(() => {
           const localQueue = this.configSelectionQueue;
           this.configSelectionQueue = [];
-          this.callRefTimerUnref()
-          for (const {callStream, callMetadata} of localQueue) {
+          this.callRefTimerUnref();
+          for (const { callStream, callMetadata } of localQueue) {
             this.tryGetConfig(callStream, callMetadata);
           }
           this.configSelectionQueue = [];
         });
       },
       (status) => {
+        this.channelzTrace.addTrace('CT_WARNING', 'Address resolution failed with code ' + status.code + ' and details "' + status.details + '"');
         if (this.configSelectionQueue.length > 0) {
-          trace(LogVerbosity.DEBUG, 'channel', 'Name resolution failed for target ' + uriToString(this.target) + ' with calls queued for config selection');
+          this.trace('Name resolution failed with calls queued for config selection');
         }
         const localQueue = this.configSelectionQueue;
         this.configSelectionQueue = [];
         this.callRefTimerUnref();
-        for (const {callStream, callMetadata} of localQueue) {
+        for (const { callStream, callMetadata } of localQueue) {
           if (callMetadata.getOptions().waitForReady) {
             this.callRefTimerRef();
-            this.configSelectionQueue.push({callStream, callMetadata});
+            this.configSelectionQueue.push({ callStream, callMetadata });
           } else {
             callStream.cancelWithStatus(status.code, status.details);
           }
@@ -290,26 +311,56 @@ export class ChannelImplementation implements Channel {
       new MaxMessageSizeFilterFactory(this.options),
       new CompressionFilterFactory(this),
     ]);
+    this.trace('Channel constructed with options ' + JSON.stringify(options, undefined, 2));
+  }
+
+  private getChannelzInfo(): ChannelInfo {
+    return {
+      target: this.originalTarget,
+      state: this.connectivityState,
+      trace: this.channelzTrace,
+      callTracker: this.callTracker,
+      children: this.childrenTracker.getChildLists()
+    };
+  }
+
+  private trace(text: string, verbosityOverride?: LogVerbosity) {
+    trace(verbosityOverride ?? LogVerbosity.DEBUG, 'channel', '(' + this.channelzRef.id + ') ' + uriToString(this.target) + ' ' + text);
   }
 
   private callRefTimerRef() {
     // If the hasRef function does not exist, always run the code
     if (!this.callRefTimer.hasRef?.()) {
-      trace(LogVerbosity.DEBUG, 'channel', 'callRefTimer.ref | configSelectionQueue.length=' + this.configSelectionQueue.length + ' pickQueue.length=' + this.pickQueue.length);
+      this.trace(
+        'callRefTimer.ref | configSelectionQueue.length=' +
+          this.configSelectionQueue.length +
+          ' pickQueue.length=' +
+          this.pickQueue.length
+      );
       this.callRefTimer.ref?.();
     }
   }
 
   private callRefTimerUnref() {
     // If the hasRef function does not exist, always run the code
-    if ((!this.callRefTimer.hasRef) || (this.callRefTimer.hasRef())) {
-      trace(LogVerbosity.DEBUG, 'channel', 'callRefTimer.unref | configSelectionQueue.length=' + this.configSelectionQueue.length + ' pickQueue.length=' + this.pickQueue.length);
+    if (!this.callRefTimer.hasRef || this.callRefTimer.hasRef()) {
+      this.trace(
+        'callRefTimer.unref | configSelectionQueue.length=' +
+          this.configSelectionQueue.length +
+          ' pickQueue.length=' +
+          this.pickQueue.length
+      );
       this.callRefTimer.unref?.();
     }
   }
 
-  private pushPick(callStream: Http2CallStream, callMetadata: Metadata, callConfig: CallConfig) {
-    this.pickQueue.push({ callStream, callMetadata, callConfig });
+  private pushPick(
+    callStream: Http2CallStream,
+    callMetadata: Metadata,
+    callConfig: CallConfig,
+    dynamicFilters: Filter[]
+  ) {
+    this.pickQueue.push({ callStream, callMetadata, callConfig, dynamicFilters });
     this.callRefTimerRef();
   }
 
@@ -320,11 +371,17 @@ export class ChannelImplementation implements Channel {
    * @param callStream
    * @param callMetadata
    */
-  private tryPick(callStream: Http2CallStream, callMetadata: Metadata, callConfig: CallConfig) {
-    const pickResult = this.currentPicker.pick({ metadata: callMetadata, extraPickInfo: callConfig.pickInformation });
-    trace(
-      LogVerbosity.DEBUG,
-      'channel',
+  private tryPick(
+    callStream: Http2CallStream,
+    callMetadata: Metadata,
+    callConfig: CallConfig,
+    dynamicFilters: Filter[]
+  ) {
+    const pickResult = this.currentPicker.pick({
+      metadata: callMetadata,
+      extraPickInfo: callConfig.pickInformation,
+    });
+    this.trace(
       'Pick result: ' +
         PickResultType[pickResult.pickResultType] +
         ' subchannel: ' +
@@ -357,7 +414,7 @@ export class ChannelImplementation implements Channel {
                 ' has state ' +
                 ConnectivityState[pickResult.subchannel!.getConnectivityState()]
             );
-            this.pushPick(callStream, callMetadata, callConfig);
+            this.pushPick(callStream, callMetadata, callConfig, dynamicFilters);
             break;
           }
           /* We need to clone the callMetadata here because the transparent
@@ -370,10 +427,11 @@ export class ChannelImplementation implements Channel {
                 const subchannelState: ConnectivityState = pickResult.subchannel!.getConnectivityState();
                 if (subchannelState === ConnectivityState.READY) {
                   try {
+                    const pickExtraFilters = pickResult.extraFilterFactories.map(factory => factory.createFilter(callStream));
                     pickResult.subchannel!.startCallStream(
                       finalMetadata,
                       callStream,
-                      pickResult.extraFilterFactory ?? undefined
+                      [...dynamicFilters, ...pickExtraFilters]
                     );
                     /* If we reach this point, the call stream has started
                      * successfully */
@@ -397,51 +455,50 @@ export class ChannelImplementation implements Channel {
                        * the stream because the correct behavior may be
                        * re-queueing instead, based on the logic in the rest of
                        * tryPick */
-                      trace(
-                        LogVerbosity.INFO,
-                        'channel',
+                      this.trace(
                         'Failed to start call on picked subchannel ' +
                           pickResult.subchannel!.getAddress() +
                           ' with error ' +
                           (error as Error).message +
-                          '. Retrying pick'
+                          '. Retrying pick',
+                          LogVerbosity.INFO
                       );
-                      this.tryPick(callStream, callMetadata, callConfig);
+                      this.tryPick(callStream, callMetadata, callConfig, dynamicFilters);
                     } else {
-                      trace(
-                        LogVerbosity.INFO,
-                        'channel',
+                      this.trace(
                         'Failed to start call on picked subchanel ' +
                           pickResult.subchannel!.getAddress() +
                           ' with error ' +
                           (error as Error).message +
-                          '. Ending call'
+                          '. Ending call',
+                          LogVerbosity.INFO
                       );
                       callStream.cancelWithStatus(
                         Status.INTERNAL,
-                        `Failed to start HTTP/2 stream with error: ${(error as Error).message}`
+                        `Failed to start HTTP/2 stream with error: ${
+                          (error as Error).message
+                        }`
                       );
                     }
                   }
                 } else {
                   /* The logic for doing this here is the same as in the catch
                    * block above */
-                  trace(
-                    LogVerbosity.INFO,
-                    'channel',
+                  this.trace(
                     'Picked subchannel ' +
                       pickResult.subchannel!.getAddress() +
                       ' has state ' +
                       ConnectivityState[subchannelState] +
-                      ' after metadata filters. Retrying pick'
+                      ' after metadata filters. Retrying pick',
+                      LogVerbosity.INFO
                   );
-                  this.tryPick(callStream, callMetadata, callConfig);
+                  this.tryPick(callStream, callMetadata, callConfig, dynamicFilters);
                 }
               },
               (error: Error & { code: number }) => {
                 // We assume the error code isn't 0 (Status.OK)
                 callStream.cancelWithStatus(
-                  (typeof error.code === 'number') ? error.code : Status.UNKNOWN,
+                  typeof error.code === 'number' ? error.code : Status.UNKNOWN,
                   `Getting metadata from plugin failed with error: ${error.message}`
                 );
               }
@@ -449,11 +506,11 @@ export class ChannelImplementation implements Channel {
         }
         break;
       case PickResultType.QUEUE:
-        this.pushPick(callStream, callMetadata, callConfig);
+        this.pushPick(callStream, callMetadata, callConfig, dynamicFilters);
         break;
       case PickResultType.TRANSIENT_FAILURE:
         if (callMetadata.getOptions().waitForReady) {
-          this.pushPick(callStream, callMetadata, callConfig);
+          this.pushPick(callStream, callMetadata, callConfig, dynamicFilters);
         } else {
           callStream.cancelWithStatus(
             pickResult.status!.code,
@@ -489,17 +546,19 @@ export class ChannelImplementation implements Channel {
     trace(
       LogVerbosity.DEBUG,
       'connectivity_state',
-      uriToString(this.target) +
+      '(' + this.channelzRef.id + ') ' + 
+        uriToString(this.target) +
         ' ' +
         ConnectivityState[this.connectivityState] +
         ' -> ' +
         ConnectivityState[newState]
     );
+    this.channelzTrace.addTrace('CT_INFO', ConnectivityState[this.connectivityState] + ' -> ' + ConnectivityState[newState]);
     this.connectivityState = newState;
     const watchersCopy = this.connectivityStateWatchers.slice();
     for (const watcherObject of watchersCopy) {
       if (newState !== watcherObject.currentState) {
-        if(watcherObject.timer) {
+        if (watcherObject.timer) {
           clearTimeout(watcherObject.timer);
         }
         this.removeConnectivityStateWatcher(watcherObject);
@@ -509,23 +568,64 @@ export class ChannelImplementation implements Channel {
   }
 
   private tryGetConfig(stream: Http2CallStream, metadata: Metadata) {
+    if (stream.getStatus() !== null) {
+      /* If the stream has a status, it has already finished and we don't need
+       * to take any more actions on it. */
+      return;
+    }
     if (this.configSelector === null) {
       /* This branch will only be taken at the beginning of the channel's life,
        * before the resolver ever returns a result. So, the
        * ResolvingLoadBalancer may be idle and if so it needs to be kicked
        * because it now has a pending request. */
       this.resolvingLoadBalancer.exitIdle();
-      this.configSelectionQueue.push({ 
+      this.configSelectionQueue.push({
         callStream: stream,
-        callMetadata: metadata
+        callMetadata: metadata,
       });
       this.callRefTimerRef();
     } else {
       const callConfig = this.configSelector(stream.getMethod(), metadata);
       if (callConfig.status === Status.OK) {
-        this.tryPick(stream, metadata, callConfig);
+        if (callConfig.methodConfig.timeout) {
+          const deadline = new Date();
+          deadline.setSeconds(
+            deadline.getSeconds() + callConfig.methodConfig.timeout.seconds
+          );
+          deadline.setMilliseconds(
+            deadline.getMilliseconds() +
+              callConfig.methodConfig.timeout.nanos / 1_000_000
+          );
+          stream.setConfigDeadline(deadline);
+          // Refreshing the filters makes the deadline filter pick up the new deadline
+          stream.filterStack.refresh();
+        }
+        if (callConfig.dynamicFilterFactories.length > 0) {
+          /* These dynamicFilters are the mechanism for implementing gRFC A39:
+           * https://github.com/grpc/proposal/blob/master/A39-xds-http-filters.md
+           * We run them here instead of with the rest of the filters because
+           * that spec says "the xDS HTTP filters will run in between name 
+           * resolution and load balancing".
+           * 
+           * We use the filter stack here to simplify the multi-filter async
+           * waterfall logic, but we pass along the underlying list of filters
+           * to avoid having nested filter stacks when combining it with the
+           * original filter stack. We do not pass along the original filter
+           * factory list because these filters may need to persist data
+           * between sending headers and other operations. */
+          const dynamicFilterStackFactory = new FilterStackFactory(callConfig.dynamicFilterFactories);
+          const dynamicFilterStack = dynamicFilterStackFactory.createFilter(stream);
+          dynamicFilterStack.sendMetadata(Promise.resolve(metadata)).then(filteredMetadata => {
+            this.tryPick(stream, filteredMetadata, callConfig, dynamicFilterStack.getFilters());
+          });
+        } else {
+          this.tryPick(stream, metadata, callConfig, []);
+        }
       } else {
-        stream.cancelWithStatus(callConfig.status, "Failed to route call to method " + stream.getMethod());
+        stream.cancelWithStatus(
+          callConfig.status,
+          'Failed to route call to method ' + stream.getMethod()
+        );
       }
     }
   }
@@ -538,6 +638,7 @@ export class ChannelImplementation implements Channel {
     this.resolvingLoadBalancer.destroy();
     this.updateState(ConnectivityState.SHUTDOWN);
     clearInterval(this.callRefTimer);
+    unregisterChannelzRef(this.channelzRef);
 
     this.subchannelPool.unrefUnusedSubchannels();
   }
@@ -563,7 +664,7 @@ export class ChannelImplementation implements Channel {
       throw new Error('Channel has been shut down');
     }
     let timer = null;
-    if(deadline !== Infinity) {
+    if (deadline !== Infinity) {
       const deadlineDate: Date =
         deadline instanceof Date ? deadline : new Date(deadline);
       const now = new Date();
@@ -579,16 +680,20 @@ export class ChannelImplementation implements Channel {
         callback(
           new Error('Deadline passed without connectivity state change')
         );
-      }, deadlineDate.getTime() - now.getTime())
+      }, deadlineDate.getTime() - now.getTime());
     }
     const watcherObject = {
       currentState,
       callback,
-      timer
+      timer,
     };
     this.connectivityStateWatchers.push(watcherObject);
   }
 
+  getChannelzRef() {
+    return this.channelzRef;
+  }
+
   createCall(
     method: string,
     deadline: Deadline,
@@ -608,11 +713,8 @@ export class ChannelImplementation implements Channel {
       throw new Error('Channel has been shut down');
     }
     const callNumber = getNewCallNumber();
-    trace(
-      LogVerbosity.DEBUG,
-      'channel',
-      uriToString(this.target) +
-        ' createCall [' +
+    this.trace(
+      'createCall [' +
         callNumber +
         '] method="' +
         method +
@@ -633,6 +735,14 @@ export class ChannelImplementation implements Channel {
       this.credentials._getCallCredentials(),
       callNumber
     );
+    this.callTracker.addCallStarted();
+    stream.addStatusWatcher(status => {
+      if (status.code === Status.OK) {
+        this.callTracker.addCallSucceeded();
+      } else {
+        this.callTracker.addCallFailed();
+      }
+    });
     return stream;
   }
 }