agent-skill-manager 1.20.0 → 1.22.0

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

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2022 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 { CallCredentials } from './call-credentials';
+import { Channel } from './channel';
+import type { SubchannelRef } from './channelz';
+import { ConnectivityState } from './connectivity-state';
+import { Subchannel } from './subchannel';
+
+export type ConnectivityStateListener = (
+  subchannel: SubchannelInterface,
+  previousState: ConnectivityState,
+  newState: ConnectivityState,
+  keepaliveTime: number,
+  errorMessage?: string
+) => void;
+
+export type HealthListener = (healthy: boolean) => void;
+
+export interface DataWatcher {
+  setSubchannel(subchannel: Subchannel): void;
+  destroy(): void;
+}
+
+/**
+ * This is an interface for load balancing policies to use to interact with
+ * subchannels. This allows load balancing policies to wrap and unwrap
+ * subchannels.
+ *
+ * Any load balancing policy that wraps subchannels must unwrap the subchannel
+ * in the picker, so that other load balancing policies consistently have
+ * access to their own wrapper objects.
+ */
+export interface SubchannelInterface {
+  getConnectivityState(): ConnectivityState;
+  addConnectivityStateListener(listener: ConnectivityStateListener): void;
+  removeConnectivityStateListener(listener: ConnectivityStateListener): void;
+  startConnecting(): void;
+  getAddress(): string;
+  throttleKeepalive(newKeepaliveTime: number): void;
+  ref(): void;
+  unref(): void;
+  getChannelzRef(): SubchannelRef;
+  isHealthy(): boolean;
+  addHealthStateWatcher(listener: HealthListener): void;
+  removeHealthStateWatcher(listener: HealthListener): void;
+  addDataWatcher(dataWatcher: DataWatcher): void;
+  /**
+   * If this is a wrapper, return the wrapped subchannel, otherwise return this
+   */
+  getRealSubchannel(): Subchannel;
+  /**
+   * Returns true if this and other both proxy the same underlying subchannel.
+   * Can be used instead of directly accessing getRealSubchannel to allow mocks
+   * to avoid implementing getRealSubchannel
+   */
+  realSubchannelEquals(other: SubchannelInterface): boolean;
+  /**
+   * Get the call credentials associated with the channel credentials for this
+   * subchannel.
+   */
+  getCallCredentials(): CallCredentials;
+  /**
+   * Get a channel that can be used to make requests with just this
+   */
+  getChannel(): Channel;
+}
+
+export abstract class BaseSubchannelWrapper implements SubchannelInterface {
+  private healthy = true;
+  private healthListeners: Set<HealthListener> = new Set();
+  private refcount = 0;
+  private dataWatchers: Set<DataWatcher> = new Set();
+  constructor(protected child: SubchannelInterface) {
+    child.addHealthStateWatcher(childHealthy => {
+      /* A change to the child health state only affects this wrapper's overall
+       * health state if this wrapper is reporting healthy. */
+      if (this.healthy) {
+        this.updateHealthListeners();
+      }
+    });
+  }
+
+  private updateHealthListeners(): void {
+    for (const listener of this.healthListeners) {
+      listener(this.isHealthy());
+    }
+  }
+
+  getConnectivityState(): ConnectivityState {
+    return this.child.getConnectivityState();
+  }
+  addConnectivityStateListener(listener: ConnectivityStateListener): void {
+    this.child.addConnectivityStateListener(listener);
+  }
+  removeConnectivityStateListener(listener: ConnectivityStateListener): void {
+    this.child.removeConnectivityStateListener(listener);
+  }
+  startConnecting(): void {
+    this.child.startConnecting();
+  }
+  getAddress(): string {
+    return this.child.getAddress();
+  }
+  throttleKeepalive(newKeepaliveTime: number): void {
+    this.child.throttleKeepalive(newKeepaliveTime);
+  }
+  ref(): void {
+    this.child.ref();
+    this.refcount += 1;
+  }
+  unref(): void {
+    this.child.unref();
+    this.refcount -= 1;
+    if (this.refcount === 0) {
+      this.destroy();
+    }
+  }
+  protected destroy() {
+    for (const watcher of this.dataWatchers) {
+      watcher.destroy();
+    }
+  }
+  getChannelzRef(): SubchannelRef {
+    return this.child.getChannelzRef();
+  }
+  isHealthy(): boolean {
+    return this.healthy && this.child.isHealthy();
+  }
+  addHealthStateWatcher(listener: HealthListener): void {
+    this.healthListeners.add(listener);
+  }
+  removeHealthStateWatcher(listener: HealthListener): void {
+    this.healthListeners.delete(listener);
+  }
+  addDataWatcher(dataWatcher: DataWatcher): void {
+    dataWatcher.setSubchannel(this.getRealSubchannel());
+    this.dataWatchers.add(dataWatcher);
+  }
+  protected setHealthy(healthy: boolean): void {
+    if (healthy !== this.healthy) {
+      this.healthy = healthy;
+      /* A change to this wrapper's health state only affects the overall
+       * reported health state if the child is healthy. */
+      if (this.child.isHealthy()) {
+        this.updateHealthListeners();
+      }
+    }
+  }
+  getRealSubchannel(): Subchannel {
+    return this.child.getRealSubchannel();
+  }
+  realSubchannelEquals(other: SubchannelInterface): boolean {
+    return this.getRealSubchannel() === other.getRealSubchannel();
+  }
+  getCallCredentials(): CallCredentials {
+    return this.child.getCallCredentials();
+  }
+  getChannel(): Channel {
+      return this.child.getChannel();
+  }
+}

package/node_modules/@grpc/grpc-js/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();
+  }
+}