refactor: Add CloudSqlInstance.close() to stop the refresh cycle.

Author: hessjcg

src/cloud-sql-instance.ts

@@ -69,6 +69,7 @@ export class CloudSQLInstance {
   private scheduledRefreshID?: ReturnType<typeof setTimeout> | null = undefined;
   /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   private throttle?: any;
+  private closed = false;
   public readonly instanceInfo: InstanceConnectionInfo;
   public ephemeralCert?: SslCert;
   public host?: string;
@@ -106,7 +107,7 @@ export class CloudSQLInstance {
     }) as ReturnType<typeof pThrottle>;
   }
 
-  forceRefresh(){
+  forceRefresh() {
     // if a refresh is already ongoing, just await for its promise to fulfill
     // so that a new instance info is available before reconnecting
     if (this.next) {
@@ -120,23 +121,29 @@ export class CloudSQLInstance {
   // cycle has completed, either with success or failure. If no refresh is
   // in progress, the promise will resolve immediately.
   refreshComplete(): Promise<void> {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       // setTimeout() to yield execution to allow other refresh background
       // tasks to start.
-      setTimeout(()=> {
-        if(this.next){
+      setTimeout(() => {
+        if (this.next) {
           // If there is a refresh promise in progress, resolve this promise
           // when the refresh is complete.
-          this.next.finally(resolve)
+          this.next.finally(resolve);
         } else {
           // Else resolve immediately.
-          resolve()
+          resolve();
         }
       }, 0);
     });
   }
 
   refresh(): Promise<RefreshResult> {
+    if (this.closed) {
+      this.scheduledRefreshID = undefined;
+      this.next = undefined;
+      return Promise.reject('closed');
+    }
+
     const currentRefreshId = this.scheduledRefreshID;
 
     // Since forceRefresh might be invoked during an ongoing refresh
@@ -203,6 +210,10 @@ export class CloudSQLInstance {
   // used to create new connections to a Cloud SQL instance. It throws in
   // case any of the internal steps fails.
   private async performRefresh(): Promise<RefreshResult> {
+    if (this.closed) {
+      return Promise.reject('closed');
+    }
+
     const rsaKeys: RSAKeys = await generateKeys();
     const metadata: InstanceMetadata =
       await this.sqlAdminFetcher.getInstanceMetadata(this.instanceInfo);
@@ -264,6 +275,9 @@ export class CloudSQLInstance {
   }
 
   private scheduleRefresh(delay: number): void {
+    if (this.closed) {
+      return;
+    }
     this.scheduledRefreshID = setTimeout(() => this.refresh(), delay);
   }
 
@@ -280,4 +294,11 @@ export class CloudSQLInstance {
   setEstablishedConnection(): void {
     this.establishedConnection = true;
   }
+
+  // close stops any refresh process in progress and prevents future refresh
+  // connections.
+  close(): void {
+    this.closed = true;
+    this.cancelRefresh();
+  }
 }

src/connector.ts

@@ -154,6 +154,7 @@ interface ConnectorOptions {
 // The Connector class is the main public API to interact
 // with the Cloud SQL Node.js Connector.
 export class Connector {
+  private closed = false;
   private readonly instances: CloudSQLInstanceMap;
   private readonly sqlAdminFetcher: SQLAdminFetcher;
   private readonly localProxies: Set<Server>;
@@ -332,8 +333,9 @@ export class Connector {
   //
   // Also clear up any local proxy servers and socket connections.
   close(): void {
+    this.closed = true;
     for (const instance of this.instances.values()) {
-      instance.cancelRefresh();
+      instance.close();
     }
     for (const server of this.localProxies) {
       server.close();

test/cloud-sql-instance.ts

@@ -293,7 +293,7 @@ t.test('CloudSQLInstance', async t => {
     let cancelRefreshCalled = false;
     let refreshCalled = false;
 
-    const refreshPromise = instance.refresh();
+    instance.refresh();
 
     instance.cancelRefresh = () => {
       cancelRefreshCalled = true;
@@ -306,7 +306,7 @@ t.test('CloudSQLInstance', async t => {
     };
 
     instance.forceRefresh();
-    await instance.refreshComplete()
+    await instance.refreshComplete();
 
     t.ok(
       !cancelRefreshCalled,
@@ -479,6 +479,44 @@ t.test('CloudSQLInstance', async t => {
     }
   );
 
+  t.test(
+    'close on established connection and ongoing failed cycle',
+    async t => {
+      let metadataCount = 0;
+      const failAndSlowFetcher = {
+        ...fetcher,
+        async getInstanceMetadata() {
+          await (() => new Promise(res => setTimeout(res, 50)))();
+          metadataCount++;
+          return fetcher.getInstanceMetadata();
+        },
+      };
+
+      const instance = new CloudSQLInstance({
+        ipType: IpAddressTypes.PUBLIC,
+        authType: AuthTypes.PASSWORD,
+        instanceConnectionName: 'my-project:us-east1:my-instance',
+        sqlAdminFetcher: failAndSlowFetcher,
+        limitRateInterval: 50,
+      });
+
+      await instance.refresh();
+      instance.setEstablishedConnection();
+
+      // starts a new refresh cycle but do not await on it
+      instance.close();
+      instance.forceRefresh();
+      await instance.refreshComplete();
+      t.equal(metadataCount, 1, 'No refresh after close');
+
+      await t.rejects(
+        instance.refresh(),
+        'closed',
+        'Refresh after close rejected.'
+      );
+    }
+  );
+
   t.test(
     'get invalid certificate data while having a current valid',
     async t => {