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

package/node_modules/@grpc/grpc-js/src/call-stream.ts

@@ -25,7 +25,7 @@ import { FilterStackFactory, FilterStack } from './filter-stack';
 import { Metadata } from './metadata';
 import { StreamDecoder } from './stream-decoder';
 import { ChannelImplementation } from './channel';
-import { Subchannel } from './subchannel';
+import { SubchannelCallStatsTracker, Subchannel } from './subchannel';
 import * as logging from './logging';
 import { LogVerbosity } from './constants';
 import { ServerSurfaceCall } from './server-call';
@@ -57,7 +57,7 @@ interface SystemError extends Error {
  * Should do approximately the same thing as util.getSystemErrorName but the
  * TypeScript types don't have that function for some reason so I just made my
  * own.
- * @param errno 
+ * @param errno
  */
 function getSystemErrorName(errno: number): string {
   for (const [name, num] of Object.entries(os.constants.errno)) {
@@ -70,6 +70,18 @@ function getSystemErrorName(errno: number): string {
 
 export type Deadline = Date | number;
 
+function getMinDeadline(deadlineList: Deadline[]): Deadline {
+  let minValue = Infinity;
+  for (const deadline of deadlineList) {
+    const deadlineMsecs =
+      deadline instanceof Date ? deadline.getTime() : deadline;
+    if (deadlineMsecs < minValue) {
+      minValue = deadlineMsecs;
+    }
+  }
+  return minValue;
+}
+
 export interface CallStreamOptions {
   deadline: Deadline;
   flags: number;
@@ -199,7 +211,7 @@ export interface Call {
 
 export class Http2CallStream implements Call {
   credentials: CallCredentials;
-  filterStack: Filter;
+  filterStack: FilterStack;
   private http2Stream: http2.ClientHttp2Stream | null = null;
   private pendingRead = false;
   private isWriteFilterPending = false;
@@ -235,6 +247,13 @@ export class Http2CallStream implements Call {
 
   private internalError: SystemError | null = null;
 
+  private configDeadline: Deadline = Infinity;
+
+  private statusWatchers: ((status: StatusObject) => void)[] = [];
+  private streamEndWatchers: ((success: boolean) => void)[] = [];
+
+  private callStatsTracker: SubchannelCallStatsTracker | null = null;
+
   constructor(
     private readonly methodName: string,
     private readonly channel: ChannelImplementation,
@@ -252,7 +271,10 @@ export class Http2CallStream implements Call {
         metadata: new Metadata(),
       });
     };
-    if (this.options.parentCall && this.options.flags & Propagate.CANCELLATION) {
+    if (
+      this.options.parentCall &&
+      this.options.flags & Propagate.CANCELLATION
+    ) {
       this.options.parentCall.on('cancelled', () => {
         this.cancelWithStatus(Status.CANCELLED, 'Cancelled by parent call');
       });
@@ -266,6 +288,7 @@ export class Http2CallStream implements Call {
       const filteredStatus = this.filterStack.receiveTrailers(
         this.finalStatus!
       );
+      this.statusWatchers.forEach(watcher => watcher(filteredStatus));
       /* We delay the actual action of bubbling up the status to insulate the
        * cleanup code in this class from any errors that may be thrown in the
        * upper layers as a result of bubbling up the status. In particular,
@@ -409,6 +432,7 @@ export class Http2CallStream implements Call {
   }
 
   private handleTrailers(headers: http2.IncomingHttpHeaders) {
+    this.streamEndWatchers.forEach(watcher => watcher(true));
     let headersString = '';
     for (const header of Object.keys(headers)) {
       headersString += '\t\t' + header + ': ' + headers[header] + '\n';
@@ -446,17 +470,18 @@ export class Http2CallStream implements Call {
     this.endCall(status);
   }
 
+  private writeMessageToStream(message: Buffer, callback: WriteCallback) {
+    this.callStatsTracker?.addMessageSent();
+    this.http2Stream!.write(message, callback);
+  }
+
   attachHttp2Stream(
     stream: http2.ClientHttp2Stream,
     subchannel: Subchannel,
-    extraFilterFactory?: FilterFactory<Filter>
+    extraFilters: Filter[],
+    callStatsTracker: SubchannelCallStatsTracker
   ): void {
-    if (extraFilterFactory !== undefined) {
-      this.filterStack = new FilterStack([
-        this.filterStack,
-        extraFilterFactory.createFilter(this),
-      ]);
-    }
+    this.filterStack.push(extraFilters);
     if (this.finalStatus !== null) {
       stream.close(NGHTTP2_CANCEL);
     } else {
@@ -465,6 +490,7 @@ export class Http2CallStream implements Call {
       );
       this.http2Stream = stream;
       this.subchannel = subchannel;
+      this.callStatsTracker = callStatsTracker;
       subchannel.addDisconnectListener(this.disconnectListener);
       subchannel.callRef();
       stream.on('response', (headers, flags) => {
@@ -530,6 +556,7 @@ export class Http2CallStream implements Call {
 
         for (const message of messages) {
           this.trace('parsed message of length ' + message.length);
+          this.callStatsTracker!.addMessageReceived();
           this.tryPush(message);
         }
       });
@@ -540,7 +567,7 @@ export class Http2CallStream implements Call {
       stream.on('close', () => {
         /* Use process.next tick to ensure that this code happens after any
          * "error" event that may be emitted at about the same time, so that
-         * we can bubble up the error message from that event. */ 
+         * we can bubble up the error message from that event. */
         process.nextTick(() => {
           this.trace('HTTP/2 stream closed with code ' + stream.rstCode);
           /* If we have a final status with an OK status code, that means that
@@ -589,7 +616,7 @@ export class Http2CallStream implements Call {
                  * "Internal server error" message. */
                 details = `Received RST_STREAM with code ${stream.rstCode} (Internal server error)`;
               } else {
-                if (this.internalError.code === 'ECONNRESET') {
+                if (this.internalError.code === 'ECONNRESET' || this.internalError.code === 'ETIMEDOUT') {
                   code = Status.UNAVAILABLE;
                   details = this.internalError.message;
                 } else {
@@ -621,9 +648,19 @@ export class Http2CallStream implements Call {
          * https://github.com/nodejs/node/blob/8b8620d580314050175983402dfddf2674e8e22a/lib/internal/http2/core.js#L2267
          */
         if (err.code !== 'ERR_HTTP2_STREAM_ERROR') {
-          this.trace('Node error event: message=' + err.message + ' code=' + err.code + ' errno=' + getSystemErrorName(err.errno) + ' syscall=' + err.syscall);
+          this.trace(
+            'Node error event: message=' +
+              err.message +
+              ' code=' +
+              err.code +
+              ' errno=' +
+              getSystemErrorName(err.errno) +
+              ' syscall=' +
+              err.syscall
+          );
           this.internalError = err;
         }
+        this.streamEndWatchers.forEach(watcher => watcher(false));
       });
       if (!this.pendingRead) {
         stream.pause();
@@ -638,7 +675,7 @@ export class Http2CallStream implements Call {
             ' (deferred)'
         );
         try {
-          stream.write(this.pendingWrite, this.pendingWriteCallback);
+          this.writeMessageToStream(this.pendingWrite, this.pendingWriteCallback);
         } catch (error) {
           this.endCall({
             code: Status.UNAVAILABLE,
@@ -683,15 +720,14 @@ export class Http2CallStream implements Call {
   }
 
   getDeadline(): Deadline {
+    const deadlineList = [this.options.deadline];
     if (this.options.parentCall && this.options.flags & Propagate.DEADLINE) {
-      const parentDeadline = this.options.parentCall.getDeadline();
-      const selfDeadline = this.options.deadline;
-      const parentDeadlineMsecs = parentDeadline instanceof Date ? parentDeadline.getTime() : parentDeadline;
-      const selfDeadlineMsecs = selfDeadline instanceof Date ? selfDeadline.getTime() : selfDeadline;
-      return Math.min(parentDeadlineMsecs, selfDeadlineMsecs);
-    } else {
-      return this.options.deadline;
+      deadlineList.push(this.options.parentCall.getDeadline());
+    }
+    if (this.configDeadline) {
+      deadlineList.push(this.configDeadline);
     }
+    return getMinDeadline(deadlineList);
   }
 
   getCredentials(): CallCredentials {
@@ -718,6 +754,22 @@ export class Http2CallStream implements Call {
     return this.options.host;
   }
 
+  setConfigDeadline(configDeadline: Deadline) {
+    this.configDeadline = configDeadline;
+  }
+
+  addStatusWatcher(watcher: (status: StatusObject) => void) {
+    this.statusWatchers.push(watcher);
+  }
+
+  addStreamEndWatcher(watcher: (success: boolean) => void) {
+    this.streamEndWatchers.push(watcher);
+  }
+
+  addFilters(extraFilters: Filter[]) {
+    this.filterStack.push(extraFilters);
+  }
+
   startRead() {
     /* If the stream has ended with an error, we should not emit any more
      * messages and we should communicate that the stream has ended */
@@ -771,7 +823,7 @@ export class Http2CallStream implements Call {
       } else {
         this.trace('sending data chunk of length ' + message.message.length);
         try {
-          this.http2Stream.write(message.message, cb);
+        this.writeMessageToStream(message.message, cb);
         }  catch (error) {
           this.endCall({
             code: Status.UNAVAILABLE,

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

@@ -81,7 +81,8 @@ export function callErrorFromStatus(status: StatusObject): ServiceError {
   return Object.assign(new Error(message), status);
 }
 
-export class ClientUnaryCallImpl extends EventEmitter
+export class ClientUnaryCallImpl
+  extends EventEmitter
   implements ClientUnaryCall {
   public call?: InterceptingCallInterface;
   constructor() {
@@ -97,7 +98,8 @@ export class ClientUnaryCallImpl extends EventEmitter
   }
 }
 
-export class ClientReadableStreamImpl<ResponseType> extends Readable
+export class ClientReadableStreamImpl<ResponseType>
+  extends Readable
   implements ClientReadableStream<ResponseType> {
   public call?: InterceptingCallInterface;
   constructor(readonly deserialize: (chunk: Buffer) => ResponseType) {
@@ -117,7 +119,8 @@ export class ClientReadableStreamImpl<ResponseType> extends Readable
   }
 }
 
-export class ClientWritableStreamImpl<RequestType> extends Writable
+export class ClientWritableStreamImpl<RequestType>
+  extends Writable
   implements ClientWritableStream<RequestType> {
   public call?: InterceptingCallInterface;
   constructor(readonly serialize: (value: RequestType) => Buffer) {
@@ -149,7 +152,8 @@ export class ClientWritableStreamImpl<RequestType> extends Writable
   }
 }
 
-export class ClientDuplexStreamImpl<RequestType, ResponseType> extends Duplex
+export class ClientDuplexStreamImpl<RequestType, ResponseType>
+  extends Duplex
   implements ClientDuplexStream<RequestType, ResponseType> {
   public call?: InterceptingCallInterface;
   constructor(

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

@@ -37,6 +37,7 @@ export interface ChannelOptions {
   'grpc.http_connect_target'?: string;
   'grpc.http_connect_creds'?: string;
   'grpc-node.max_session_memory'?: number;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [key: string]: any;
 }