@push.rocks/smartnetwork 4.9.0 → 4.10.1

package/ts/smartnetwork.classes.smartnetwork.ts

@@ -5,7 +5,10 @@ import { IpIntelligence, type IIpIntelligenceResult } from './smartnetwork.class
 import { DomainIntelligence, type IDomainIntelligenceResult } from './smartnetwork.classes.domainintelligence.js';
 import { getLogger } from './logging.js';
 import { NetworkError } from './errors.js';
-import { RustNetworkBridge } from './smartnetwork.classes.rustbridge.js';
+import {
+  RustNetworkBridge,
+  RustNetworkBridgeActivationCleanupError,
+} from './smartnetwork.classes.rustbridge.js';
 
 /** Type alias for the shared Smartdns client instance */
 type TSmartdnsClient = InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>;
@@ -39,6 +42,8 @@ export interface IFindFreePortOptions {
   exclude?: number[];
 }
 
+type TBridgeLifecycleState = 'idle' | 'active' | 'release-failed';
+
 /**
  * SmartNetwork simplifies actions within the network.
  * Uses a Rust binary for system-dependent operations (ping, traceroute, port scanning, gateway detection).
@@ -58,7 +63,11 @@ export class SmartNetwork {
   private options: SmartNetworkOptions;
   private cache: Map<string, { value: any; expiry: number }>;
   private rustBridge: RustNetworkBridge;
-  private bridgeStarted = false;
+  private bridgeLifecycleState: TBridgeLifecycleState = 'idle';
+  private bridgeLifecycleQueue: Promise<void> = Promise.resolve();
+  private activeDnsOperations = 0;
+  private dnsDrainPromise: Promise<void> | null = null;
+  private resolveDnsDrain: (() => void) | null = null;
   private ipIntelligence: IpIntelligence | null = null;
   private domainIntelligence: DomainIntelligence | null = null;
   private dnsClient: TSmartdnsClient | null = null;
@@ -73,11 +82,21 @@ export class SmartNetwork {
    * Start the Rust binary bridge. Must be called before using ping, traceroute,
    * port scanning, or gateway operations. Safe to call multiple times.
    */
-  public async start(): Promise<void> {
-    if (!this.bridgeStarted) {
-      await this.rustBridge.start();
-      this.bridgeStarted = true;
-    }
+  public start(): Promise<void> {
+    return this.enqueueBridgeLifecycle(async () => {
+      if (this.bridgeLifecycleState === 'release-failed') {
+        throw new Error('SmartNetwork cleanup must succeed before it can start again');
+      }
+      try {
+        await this.rustBridge.start(this);
+        this.bridgeLifecycleState = 'active';
+      } catch (error) {
+        if (error instanceof RustNetworkBridgeActivationCleanupError) {
+          this.bridgeLifecycleState = 'release-failed';
+        }
+        throw error;
+      }
+    });
   }
 
   /**
@@ -86,35 +105,100 @@ export class SmartNetwork {
    * Rust-backed features, otherwise the smartdns Rust backend may keep
    * the event loop alive.
    */
-  public async stop(): Promise<void> {
-    if (this.bridgeStarted) {
-      await this.rustBridge.stop();
-      this.bridgeStarted = false;
+  public stop(): Promise<void> {
+    return this.enqueueBridgeLifecycle(async () => {
+      await this.waitForDnsOperations();
+
+      let bridgeError: unknown;
+      if (this.bridgeLifecycleState !== 'idle') {
+        try {
+          await this.rustBridge.stop(this);
+        } catch (error) {
+          bridgeError = error;
+        }
+      }
+
+      let dnsError: unknown;
+      if (this.dnsClient) {
+        try {
+          await this.dnsClient.terminate();
+          this.dnsClient = null;
+          // Intelligence instances hold a stale reference to the terminated
+          // client; drop them so the next call rebuilds with a fresh one.
+          this.ipIntelligence = null;
+          this.domainIntelligence = null;
+        } catch (error) {
+          dnsError = error;
+        }
+      }
+
+      if (bridgeError || dnsError) {
+        this.bridgeLifecycleState = 'release-failed';
+      } else {
+        this.bridgeLifecycleState = 'idle';
+      }
+
+      if (bridgeError && dnsError) {
+        throw new AggregateError([bridgeError, dnsError], 'SmartNetwork cleanup failed');
+      }
+      if (bridgeError) throw bridgeError;
+      if (dnsError) throw dnsError;
+    });
+  }
+
+  private enqueueBridgeLifecycle(operationArg: () => Promise<void>): Promise<void> {
+    const result = this.bridgeLifecycleQueue.then(operationArg);
+    this.bridgeLifecycleQueue = result.catch(() => {});
+    return result;
+  }
+
+  private async withDnsClient<T>(
+    operationArg: (dnsClientArg: TSmartdnsClient) => Promise<T>,
+  ): Promise<T> {
+    let dnsClient: TSmartdnsClient;
+    await this.enqueueBridgeLifecycle(async () => {
+      if (this.bridgeLifecycleState === 'release-failed') {
+        throw new Error('SmartNetwork cleanup must succeed before DNS can be used again');
+      }
+      dnsClient = this.ensureDnsClient();
+      this.activeDnsOperations++;
+    });
+
+    try {
+      return await operationArg(dnsClient!);
+    } finally {
+      this.activeDnsOperations--;
+      if (this.activeDnsOperations === 0 && this.resolveDnsDrain) {
+        const resolve = this.resolveDnsDrain;
+        this.resolveDnsDrain = null;
+        this.dnsDrainPromise = null;
+        resolve();
+      }
     }
-    if (this.dnsClient) {
-      this.dnsClient.destroy();
-      this.dnsClient = null;
-      // Intelligence instances hold a stale reference to the destroyed
-      // client; drop them so the next call rebuilds with a fresh one.
-      this.ipIntelligence = null;
-      this.domainIntelligence = null;
+  }
+
+  private waitForDnsOperations(): Promise<void> {
+    if (this.activeDnsOperations === 0) return Promise.resolve();
+    if (!this.dnsDrainPromise) {
+      this.dnsDrainPromise = new Promise<void>((resolve) => {
+        this.resolveDnsDrain = resolve;
+      });
     }
+    return this.dnsDrainPromise;
   }
 
   /**
    * Ensure the Rust bridge is running before sending commands.
    */
   private async ensureBridge(): Promise<void> {
-    if (!this.bridgeStarted) {
-      await this.start();
-    }
+    await this.start();
   }
 
   /**
    * Lazily create the shared Smartdns client. The Rust backend inside
    * Smartdns is only spawned on first query that requires it (NS/MX/SOA
    * with prefer-system strategy, or any query with doh/udp strategy).
-   * The client is destroyed by stop().
+   * The client is terminated by stop().
    */
   private ensureDnsClient(): TSmartdnsClient {
     if (!this.dnsClient) {
@@ -348,31 +432,31 @@ export class SmartNetwork {
   /**
    * Resolve DNS records (A, AAAA, MX) via the shared smartdns client.
    * The client is lifecycle-managed by start()/stop() — MX queries spawn
-   * the smartdns Rust bridge, which is torn down by stop().
+   * the smartdns Rust bridge, whose termination is confirmed by stop().
    */
   public async resolveDns(
     host: string,
   ): Promise<{ A: string[]; AAAA: string[]; MX: { exchange: string; priority: number }[] }> {
     try {
-      const dnsClient = this.ensureDnsClient();
-
-      const [aRecords, aaaaRecords, mxRecords] = await Promise.all([
-        dnsClient.getRecordsA(host).catch((): any[] => []),
-        dnsClient.getRecordsAAAA(host).catch((): any[] => []),
-        dnsClient.getRecords(host, 'MX').catch((): any[] => []),
-      ]);
-
-      const A = aRecords.map((record: any) => record.value);
-      const AAAA = aaaaRecords.map((record: any) => record.value);
-      const MX = mxRecords.map((record: any) => {
-        const parts = record.value.split(' ');
-        return {
-          priority: parseInt(parts[0], 10),
-          exchange: parts[1] || '',
-        };
+      return await this.withDnsClient(async (dnsClient) => {
+        const [aRecords, aaaaRecords, mxRecords] = await Promise.all([
+          dnsClient.getRecordsA(host).catch((): any[] => []),
+          dnsClient.getRecordsAAAA(host).catch((): any[] => []),
+          dnsClient.getRecords(host, 'MX').catch((): any[] => []),
+        ]);
+
+        const A = aRecords.map((record: any) => record.value);
+        const AAAA = aaaaRecords.map((record: any) => record.value);
+        const MX = mxRecords.map((record: any) => {
+          const parts = record.value.split(' ');
+          return {
+            priority: parseInt(parts[0], 10),
+            exchange: parts[1] || '',
+          };
+        });
+
+        return { A, AAAA, MX };
       });
-
-      return { A, AAAA, MX };
     } catch (err: any) {
       throw new NetworkError(err.message, err.code);
     }
@@ -438,13 +522,15 @@ export class SmartNetwork {
    * Pure TS, no Rust needed.
    */
   public async getIpIntelligence(ip: string): Promise<IIpIntelligenceResult> {
-    if (!this.ipIntelligence) {
-      this.ipIntelligence = new IpIntelligence({
-        dnsClient: this.ensureDnsClient(),
-        timeout: this.options.ipIntelligenceTimeout,
-      });
-    }
-    const fetcher = () => this.ipIntelligence!.getIntelligence(ip);
+    const fetcher = () => this.withDnsClient(async (dnsClient) => {
+      if (!this.ipIntelligence) {
+        this.ipIntelligence = new IpIntelligence({
+          dnsClient,
+          timeout: this.options.ipIntelligenceTimeout,
+        });
+      }
+      return this.ipIntelligence.getIntelligence(ip);
+    });
     if (this.options.cacheTtl && this.options.cacheTtl > 0) {
       return this.getCached(`ipIntelligence:${ip}`, fetcher);
     }
@@ -457,10 +543,12 @@ export class SmartNetwork {
    * Rust needed.
    */
   public async getDomainIntelligence(domain: string): Promise<IDomainIntelligenceResult> {
-    if (!this.domainIntelligence) {
-      this.domainIntelligence = new DomainIntelligence({ dnsClient: this.ensureDnsClient() });
-    }
-    const fetcher = () => this.domainIntelligence!.getIntelligence(domain);
+    const fetcher = () => this.withDnsClient(async (dnsClient) => {
+      if (!this.domainIntelligence) {
+        this.domainIntelligence = new DomainIntelligence({ dnsClient });
+      }
+      return this.domainIntelligence.getIntelligence(domain);
+    });
     if (this.options.cacheTtl && this.options.cacheTtl > 0) {
       return this.getCached(`domainIntelligence:${domain}`, fetcher);
     }

package/ts/smartnetwork.plugins.ts

@@ -8,8 +8,9 @@ export { os, https, perfHooks };
 // @pushrocks scope
 import * as smartdns from '@push.rocks/smartdns';
 import * as smartrust from '@push.rocks/smartrust';
+import * as smartwhois from '@push.rocks/smartwhois';
 
-export { smartdns, smartrust };
+export { smartdns, smartrust, smartwhois };
 
 // third party
 import * as maxmind from 'maxmind';