@reptilestyle/grpc-js 1.9.14-compression.1

package/src/subchannel-pool.ts

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2019 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 { ChannelOptions, channelOptionsEqual } from './channel-options';
+import { Subchannel } from './subchannel';
+import {
+  SubchannelAddress,
+  subchannelAddressEqual,
+} from './subchannel-address';
+import { ChannelCredentials } from './channel-credentials';
+import { GrpcUri, uriToString } from './uri-parser';
+import { Http2SubchannelConnector } from './transport';
+
+// 10 seconds in milliseconds. This value is arbitrary.
+/**
+ * The amount of time in between checks for dropping subchannels that have no
+ * other references
+ */
+const REF_CHECK_INTERVAL = 10_000;
+
+export class SubchannelPool {
+  private pool: {
+    [channelTarget: string]: Array<{
+      subchannelAddress: SubchannelAddress;
+      channelArguments: ChannelOptions;
+      channelCredentials: ChannelCredentials;
+      subchannel: Subchannel;
+    }>;
+  } = Object.create(null);
+
+  /**
+   * A timer of a task performing a periodic subchannel cleanup.
+   */
+  private cleanupTimer: NodeJS.Timeout | null = null;
+
+  /**
+   * A pool of subchannels use for making connections. Subchannels with the
+   * exact same parameters will be reused.
+   */
+  constructor() {}
+
+  /**
+   * Unrefs all unused subchannels and cancels the cleanup task if all
+   * subchannels have been unrefed.
+   */
+  unrefUnusedSubchannels(): void {
+    let allSubchannelsUnrefed = true;
+
+    /* These objects are created with Object.create(null), so they do not
+     * have a prototype, which means that for (... in ...) loops over them
+     * do not need to be filtered */
+    // eslint-disable-disable-next-line:forin
+    for (const channelTarget in this.pool) {
+      const subchannelObjArray = this.pool[channelTarget];
+
+      const refedSubchannels = subchannelObjArray.filter(
+        value => !value.subchannel.unrefIfOneRef()
+      );
+
+      if (refedSubchannels.length > 0) {
+        allSubchannelsUnrefed = false;
+      }
+
+      /* For each subchannel in the pool, try to unref it if it has
+       * exactly one ref (which is the ref from the pool itself). If that
+       * does happen, remove the subchannel from the pool */
+      this.pool[channelTarget] = refedSubchannels;
+    }
+    /* Currently we do not delete keys with empty values. If that results
+     * in significant memory usage we should change it. */
+
+    // Cancel the cleanup task if all subchannels have been unrefed.
+    if (allSubchannelsUnrefed && this.cleanupTimer !== null) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /**
+   * Ensures that the cleanup task is spawned.
+   */
+  ensureCleanupTask(): void {
+    if (this.cleanupTimer === null) {
+      this.cleanupTimer = setInterval(() => {
+        this.unrefUnusedSubchannels();
+      }, REF_CHECK_INTERVAL);
+
+      // Unref because this timer should not keep the event loop running.
+      // Call unref only if it exists to address electron/electron#21162
+      this.cleanupTimer.unref?.();
+    }
+  }
+
+  /**
+   * Get a subchannel if one already exists with exactly matching parameters.
+   * Otherwise, create and save a subchannel with those parameters.
+   * @param channelTarget
+   * @param subchannelTarget
+   * @param channelArguments
+   * @param channelCredentials
+   */
+  getOrCreateSubchannel(
+    channelTargetUri: GrpcUri,
+    subchannelTarget: SubchannelAddress,
+    channelArguments: ChannelOptions,
+    channelCredentials: ChannelCredentials
+  ): Subchannel {
+    this.ensureCleanupTask();
+    const channelTarget = uriToString(channelTargetUri);
+    if (channelTarget in this.pool) {
+      const subchannelObjArray = this.pool[channelTarget];
+      for (const subchannelObj of subchannelObjArray) {
+        if (
+          subchannelAddressEqual(
+            subchannelTarget,
+            subchannelObj.subchannelAddress
+          ) &&
+          channelOptionsEqual(
+            channelArguments,
+            subchannelObj.channelArguments
+          ) &&
+          channelCredentials._equals(subchannelObj.channelCredentials)
+        ) {
+          return subchannelObj.subchannel;
+        }
+      }
+    }
+    // If we get here, no matching subchannel was found
+    const subchannel = new Subchannel(
+      channelTargetUri,
+      subchannelTarget,
+      channelArguments,
+      channelCredentials,
+      new Http2SubchannelConnector(channelTargetUri)
+    );
+    if (!(channelTarget in this.pool)) {
+      this.pool[channelTarget] = [];
+    }
+    this.pool[channelTarget].push({
+      subchannelAddress: subchannelTarget,
+      channelArguments,
+      channelCredentials,
+      subchannel,
+    });
+    subchannel.ref();
+    return subchannel;
+  }
+}
+
+const globalSubchannelPool = new SubchannelPool();
+
+/**
+ * Get either the global subchannel pool, or a new subchannel pool.
+ * @param global
+ */
+export function getSubchannelPool(global: boolean): SubchannelPool {
+  if (global) {
+    return globalSubchannelPool;
+  } else {
+    return new SubchannelPool();
+  }
+}

package/src/subchannel.ts

@@ -0,0 +1,482 @@
+/*
+ * Copyright 2019 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 { ChannelCredentials } from './channel-credentials';
+import { Metadata } from './metadata';
+import { ChannelOptions } from './channel-options';
+import { ConnectivityState } from './connectivity-state';
+import { BackoffTimeout, BackoffOptions } from './backoff-timeout';
+import * as logging from './logging';
+import { LogVerbosity, Status } from './constants';
+import { GrpcUri, uriToString } from './uri-parser';
+import {
+  SubchannelAddress,
+  subchannelAddressToString,
+} from './subchannel-address';
+import {
+  SubchannelRef,
+  ChannelzTrace,
+  ChannelzChildrenTracker,
+  SubchannelInfo,
+  registerChannelzSubchannel,
+  ChannelzCallTracker,
+  unregisterChannelzRef,
+} from './channelz';
+import {
+  ConnectivityStateListener,
+  SubchannelInterface,
+} from './subchannel-interface';
+import { SubchannelCallInterceptingListener } from './subchannel-call';
+import { SubchannelCall } from './subchannel-call';
+import { CallEventTracker, SubchannelConnector, Transport } from './transport';
+
+const TRACER_NAME = 'subchannel';
+
+/* setInterval and setTimeout only accept signed 32 bit integers. JS doesn't
+ * have a constant for the max signed 32 bit integer, so this is a simple way
+ * to calculate it */
+const KEEPALIVE_MAX_TIME_MS = ~(1 << 31);
+
+export class Subchannel {
+  /**
+   * The subchannel's current connectivity state. Invariant: `session` === `null`
+   * if and only if `connectivityState` is IDLE or TRANSIENT_FAILURE.
+   */
+  private connectivityState: ConnectivityState = ConnectivityState.IDLE;
+  /**
+   * The underlying http2 session used to make requests.
+   */
+  private transport: Transport | null = null;
+  /**
+   * Indicates that the subchannel should transition from TRANSIENT_FAILURE to
+   * CONNECTING instead of IDLE when the backoff timeout ends.
+   */
+  private continueConnecting = false;
+  /**
+   * A list of listener functions that will be called whenever the connectivity
+   * state changes. Will be modified by `addConnectivityStateListener` and
+   * `removeConnectivityStateListener`
+   */
+  private stateListeners: Set<ConnectivityStateListener> = new Set();
+
+  private backoffTimeout: BackoffTimeout;
+
+  private keepaliveTime: number;
+  /**
+   * Tracks channels and subchannel pools with references to this subchannel
+   */
+  private refcount = 0;
+
+  /**
+   * A string representation of the subchannel address, for logging/tracing
+   */
+  private subchannelAddressString: string;
+
+  // Channelz info
+  private readonly channelzEnabled: boolean = true;
+  private channelzRef: SubchannelRef;
+  private channelzTrace: ChannelzTrace;
+  private callTracker = new ChannelzCallTracker();
+  private childrenTracker = new ChannelzChildrenTracker();
+
+  // Channelz socket info
+  private streamTracker = new ChannelzCallTracker();
+
+  /**
+   * A class representing a connection to a single backend.
+   * @param channelTarget The target string for the channel as a whole
+   * @param subchannelAddress The address for the backend that this subchannel
+   *     will connect to
+   * @param options The channel options, plus any specific subchannel options
+   *     for this subchannel
+   * @param credentials The channel credentials used to establish this
+   *     connection
+   */
+  constructor(
+    private channelTarget: GrpcUri,
+    private subchannelAddress: SubchannelAddress,
+    private options: ChannelOptions,
+    private credentials: ChannelCredentials,
+    private connector: SubchannelConnector
+  ) {
+    const backoffOptions: BackoffOptions = {
+      initialDelay: options['grpc.initial_reconnect_backoff_ms'],
+      maxDelay: options['grpc.max_reconnect_backoff_ms'],
+    };
+    this.backoffTimeout = new BackoffTimeout(() => {
+      this.handleBackoffTimer();
+    }, backoffOptions);
+    this.backoffTimeout.unref();
+    this.subchannelAddressString = subchannelAddressToString(subchannelAddress);
+
+    this.keepaliveTime = options['grpc.keepalive_time_ms'] ?? -1;
+
+    if (options['grpc.enable_channelz'] === 0) {
+      this.channelzEnabled = false;
+    }
+    this.channelzTrace = new ChannelzTrace();
+    this.channelzRef = registerChannelzSubchannel(
+      this.subchannelAddressString,
+      () => this.getChannelzInfo(),
+      this.channelzEnabled
+    );
+    if (this.channelzEnabled) {
+      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 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() {
+    if (this.continueConnecting) {
+      this.transitionToState(
+        [ConnectivityState.TRANSIENT_FAILURE],
+        ConnectivityState.CONNECTING
+      );
+    } else {
+      this.transitionToState(
+        [ConnectivityState.TRANSIENT_FAILURE],
+        ConnectivityState.IDLE
+      );
+    }
+  }
+
+  /**
+   * Start a backoff timer with the current nextBackoff timeout
+   */
+  private startBackoff() {
+    this.backoffTimeout.runOnce();
+  }
+
+  private stopBackoff() {
+    this.backoffTimeout.stop();
+    this.backoffTimeout.reset();
+  }
+
+  private startConnectingInternal() {
+    let options = this.options;
+    if (options['grpc.keepalive_time_ms']) {
+      const adjustedKeepaliveTime = Math.min(
+        this.keepaliveTime,
+        KEEPALIVE_MAX_TIME_MS
+      );
+      options = { ...options, 'grpc.keepalive_time_ms': adjustedKeepaliveTime };
+    }
+    this.connector
+      .connect(this.subchannelAddress, this.credentials, options)
+      .then(
+        transport => {
+          if (
+            this.transitionToState(
+              [ConnectivityState.CONNECTING],
+              ConnectivityState.READY
+            )
+          ) {
+            this.transport = transport;
+            if (this.channelzEnabled) {
+              this.childrenTracker.refChild(transport.getChannelzRef());
+            }
+            transport.addDisconnectListener(tooManyPings => {
+              this.transitionToState(
+                [ConnectivityState.READY],
+                ConnectivityState.IDLE
+              );
+              if (tooManyPings && this.keepaliveTime > 0) {
+                this.keepaliveTime *= 2;
+                logging.log(
+                  LogVerbosity.ERROR,
+                  `Connection to ${uriToString(this.channelTarget)} at ${
+                    this.subchannelAddressString
+                  } rejected by server because of excess pings. Increasing ping interval to ${
+                    this.keepaliveTime
+                  } ms`
+                );
+              }
+            });
+          } else {
+            /* If we can't transition from CONNECTING to READY here, we will
+             * not be using this transport, so release its resources. */
+            transport.shutdown();
+          }
+        },
+        error => {
+          this.transitionToState(
+            [ConnectivityState.CONNECTING],
+            ConnectivityState.TRANSIENT_FAILURE,
+            `${error}`
+          );
+        }
+      );
+  }
+
+  /**
+   * Initiate a state transition from any element of oldStates to the new
+   * state. If the current connectivityState is not in oldStates, do nothing.
+   * @param oldStates The set of states to transition from
+   * @param newState The state to transition to
+   * @returns True if the state changed, false otherwise
+   */
+  private transitionToState(
+    oldStates: ConnectivityState[],
+    newState: ConnectivityState,
+    errorMessage?: string
+  ): boolean {
+    if (oldStates.indexOf(this.connectivityState) === -1) {
+      return false;
+    }
+    this.trace(
+      ConnectivityState[this.connectivityState] +
+        ' -> ' +
+        ConnectivityState[newState]
+    );
+    if (this.channelzEnabled) {
+      this.channelzTrace.addTrace(
+        'CT_INFO',
+        'Connectivity state change to ' + ConnectivityState[newState]
+      );
+    }
+    const previousState = this.connectivityState;
+    this.connectivityState = newState;
+    switch (newState) {
+      case ConnectivityState.READY:
+        this.stopBackoff();
+        break;
+      case ConnectivityState.CONNECTING:
+        this.startBackoff();
+        this.startConnectingInternal();
+        this.continueConnecting = false;
+        break;
+      case ConnectivityState.TRANSIENT_FAILURE:
+        if (this.channelzEnabled && this.transport) {
+          this.childrenTracker.unrefChild(this.transport.getChannelzRef());
+        }
+        this.transport?.shutdown();
+        this.transport = null;
+        /* If the backoff timer has already ended by the time we get to the
+         * TRANSIENT_FAILURE state, we want to immediately transition out of
+         * TRANSIENT_FAILURE as though the backoff timer is ending right now */
+        if (!this.backoffTimeout.isRunning()) {
+          process.nextTick(() => {
+            this.handleBackoffTimer();
+          });
+        }
+        break;
+      case ConnectivityState.IDLE:
+        if (this.channelzEnabled && this.transport) {
+          this.childrenTracker.unrefChild(this.transport.getChannelzRef());
+        }
+        this.transport?.shutdown();
+        this.transport = null;
+        break;
+      default:
+        throw new Error(`Invalid state: unknown ConnectivityState ${newState}`);
+    }
+    for (const listener of this.stateListeners) {
+      listener(this, previousState, newState, this.keepaliveTime, errorMessage);
+    }
+    return true;
+  }
+
+  ref() {
+    this.refTrace('refcount ' + this.refcount + ' -> ' + (this.refcount + 1));
+    this.refcount += 1;
+  }
+
+  unref() {
+    this.refTrace('refcount ' + this.refcount + ' -> ' + (this.refcount - 1));
+    this.refcount -= 1;
+    if (this.refcount === 0) {
+      if (this.channelzEnabled) {
+        this.channelzTrace.addTrace('CT_INFO', 'Shutting down');
+      }
+      if (this.channelzEnabled) {
+        unregisterChannelzRef(this.channelzRef);
+      }
+      process.nextTick(() => {
+        this.transitionToState(
+          [ConnectivityState.CONNECTING, ConnectivityState.READY],
+          ConnectivityState.IDLE
+        );
+      });
+    }
+  }
+
+  unrefIfOneRef(): boolean {
+    if (this.refcount === 1) {
+      this.unref();
+      return true;
+    }
+    return false;
+  }
+
+  createCall(
+    metadata: Metadata,
+    host: string,
+    method: string,
+    listener: SubchannelCallInterceptingListener
+  ): SubchannelCall {
+    if (!this.transport) {
+      throw new Error('Cannot create call, subchannel not READY');
+    }
+    let statsTracker: Partial<CallEventTracker>;
+    if (this.channelzEnabled) {
+      this.callTracker.addCallStarted();
+      this.streamTracker.addCallStarted();
+      statsTracker = {
+        onCallEnd: status => {
+          if (status.code === Status.OK) {
+            this.callTracker.addCallSucceeded();
+          } else {
+            this.callTracker.addCallFailed();
+          }
+        },
+      };
+    } else {
+      statsTracker = {};
+    }
+    return this.transport.createCall(
+      metadata,
+      host,
+      method,
+      listener,
+      statsTracker
+    );
+  }
+
+  /**
+   * If the subchannel is currently IDLE, start connecting and switch to the
+   * CONNECTING state. If the subchannel is current in TRANSIENT_FAILURE,
+   * the next time it would transition to IDLE, start connecting again instead.
+   * Otherwise, do nothing.
+   */
+  startConnecting() {
+    process.nextTick(() => {
+      /* First, try to transition from IDLE to connecting. If that doesn't happen
+       * because the state is not currently IDLE, check if it is
+       * TRANSIENT_FAILURE, and if so indicate that it should go back to
+       * connecting after the backoff timer ends. Otherwise do nothing */
+      if (
+        !this.transitionToState(
+          [ConnectivityState.IDLE],
+          ConnectivityState.CONNECTING
+        )
+      ) {
+        if (this.connectivityState === ConnectivityState.TRANSIENT_FAILURE) {
+          this.continueConnecting = true;
+        }
+      }
+    });
+  }
+
+  /**
+   * Get the subchannel's current connectivity state.
+   */
+  getConnectivityState() {
+    return this.connectivityState;
+  }
+
+  /**
+   * Add a listener function to be called whenever the subchannel's
+   * connectivity state changes.
+   * @param listener
+   */
+  addConnectivityStateListener(listener: ConnectivityStateListener) {
+    this.stateListeners.add(listener);
+  }
+
+  /**
+   * Remove a listener previously added with `addConnectivityStateListener`
+   * @param listener A reference to a function previously passed to
+   *     `addConnectivityStateListener`
+   */
+  removeConnectivityStateListener(listener: ConnectivityStateListener) {
+    this.stateListeners.delete(listener);
+  }
+
+  /**
+   * Reset the backoff timeout, and immediately start connecting if in backoff.
+   */
+  resetBackoff() {
+    process.nextTick(() => {
+      this.backoffTimeout.reset();
+      this.transitionToState(
+        [ConnectivityState.TRANSIENT_FAILURE],
+        ConnectivityState.CONNECTING
+      );
+    });
+  }
+
+  getAddress(): string {
+    return this.subchannelAddressString;
+  }
+
+  getChannelzRef(): SubchannelRef {
+    return this.channelzRef;
+  }
+
+  getRealSubchannel(): this {
+    return this;
+  }
+
+  realSubchannelEquals(other: SubchannelInterface): boolean {
+    return other.getRealSubchannel() === this;
+  }
+
+  throttleKeepalive(newKeepaliveTime: number) {
+    if (newKeepaliveTime > this.keepaliveTime) {
+      this.keepaliveTime = newKeepaliveTime;
+    }
+  }
+}

package/src/tls-helpers.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2019 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 * as fs from 'fs';
+
+export const CIPHER_SUITES: string | undefined =
+  process.env.GRPC_SSL_CIPHER_SUITES;
+
+const DEFAULT_ROOTS_FILE_PATH = process.env.GRPC_DEFAULT_SSL_ROOTS_FILE_PATH;
+
+let defaultRootsData: Buffer | null = null;
+
+export function getDefaultRootsData(): Buffer | null {
+  if (DEFAULT_ROOTS_FILE_PATH) {
+    if (defaultRootsData === null) {
+      defaultRootsData = fs.readFileSync(DEFAULT_ROOTS_FILE_PATH);
+    }
+    return defaultRootsData;
+  }
+  return null;
+}