testing delaying of the autodiscovery as a way to avoid the odd race condition happening

Author: KIvanow

redisinsight/api/src/modules/database-discovery/auto.database-discovery.service.ts

@@ -15,21 +15,30 @@ import { ConstantsProvider } from 'src/modules/constants/providers/constants.pro
 @Injectable()
 export class AutoDatabaseDiscoveryService {
   private logger = new Logger('AutoDatabaseDiscoveryService');
+  private isDiscoveryRunning = false;
 
   constructor(
     private redisClientFactory: RedisClientFactory,
     private databaseService: DatabaseService,
   ) {}
 
   /**
-   * Try to add standalone databases without auth from processes running on the host machine listening on TCP4
+   * Start discovery process in background without blocking the main thread
    * Database alias will be "host:port"
    */
   async discover(sessionMetadata: SessionMetadata) {
+    // Return immediately to not block the main thread
+    if (this.isDiscoveryRunning) {
+      return;
+    }
+
+    // Perform the actual discovery in background
+    this.isDiscoveryRunning = true;
     try {
       // additional check for existing databases
       // We should not start auto discover if any database already exists
       if ((await this.databaseService.list(sessionMetadata)).length) {
+        this.isDiscoveryRunning = false;
         return;
       }
 
@@ -46,6 +55,8 @@ export class AutoDatabaseDiscoveryService {
       ]);
     } catch (e) {
       this.logger.warn('Unable to discover redis database', e);
+    } finally {
+      this.isDiscoveryRunning = false;
     }
   }
 

redisinsight/api/src/modules/database-discovery/local.database-discovery.service.ts

@@ -11,6 +11,7 @@ const SERVER_CONFIG = config.get('server') as Config['server'];
 @Injectable()
 export class LocalDatabaseDiscoveryService extends DatabaseDiscoveryService {
   private logger = new Logger('LocalDatabaseDiscoveryService');
+  private isDiscoveryRunning = false;
 
   constructor(
     @Inject(forwardRef(() => SettingsService))
@@ -21,33 +22,49 @@ export class LocalDatabaseDiscoveryService extends DatabaseDiscoveryService {
     super();
   }
 
+  /**
+   * Non-blocking implementation of database discovery
+   * This returns quickly and performs the actual discovery work in the background
+   */
   async discover(
     sessionMetadata: SessionMetadata,
     firstRun?: boolean,
   ): Promise<void> {
-    try {
-      // no need to auto discover for Redis Stack
-      if (SERVER_CONFIG.buildType === 'REDIS_STACK') {
-        return;
-      }
+    // Return immediately if discovery is already in progress
+    if (this.isDiscoveryRunning) {
+      return;
+    }
+
+    // No need to auto discover for Redis Stack - quick check
+    if (SERVER_CONFIG.buildType === 'REDIS_STACK') {
+      return;
+    }
 
-      // check agreements to understand if it is first launch
-      const settings =
-        await this.settingsService.getAppSettings(sessionMetadata);
+    // Mark as running and perform discovery in background
+    this.isDiscoveryRunning = true;
+    setImmediate(async () => {
+      try {
+        // check agreements to understand if it is first launch
+        const settings =
+          await this.settingsService.getAppSettings(sessionMetadata);
 
-      if (!settings?.agreements?.eula) {
-        return;
-      }
+        if (!settings?.agreements?.eula) {
+          this.isDiscoveryRunning = false;
+          return;
+        }
 
-      const { discovered } =
-        await this.preSetupDatabaseDiscoveryService.discover(sessionMetadata);
+        const { discovered } =
+          await this.preSetupDatabaseDiscoveryService.discover(sessionMetadata);
 
-      if (!discovered && firstRun) {
-        await this.autoDatabaseDiscoveryService.discover(sessionMetadata);
+        if (!discovered && firstRun) {
+          await this.autoDatabaseDiscoveryService.discover(sessionMetadata);
+        }
+      } catch (e) {
+        // ignore error
+        this.logger.error('Unable to discover databases', e);
+      } finally {
+        this.isDiscoveryRunning = false;
       }
-    } catch (e) {
-      // ignore error
-      this.logger.error('Unable to discover databases', e);
-    }
+    });
   }
 }

redisinsight/api/src/modules/database-discovery/utils/autodiscovery.util.ts

@@ -29,15 +29,23 @@ export const getRunningProcesses = async (): Promise<string[]> =>
       let stdoutData = '';
       const proc = spawn(...getSpawnArgs());
 
+      // Add timeout to ensure we don't wait forever
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve([]); // Return empty array on timeout
+      }, 1000);
+
       proc.stdout.on('data', (data) => {
         stdoutData += data.toString();
       });
 
       proc.on('error', (e) => {
+        clearTimeout(timeout);
         reject(e);
       });
 
       proc.stdout.on('end', () => {
+        clearTimeout(timeout);
         resolve(stdoutData.split('\n'));
       });
     } catch (e) {

redisinsight/api/src/modules/init/local.init.service.ts

@@ -32,9 +32,7 @@ export class LocalInitService extends InitService {
     await this.initAnalytics(firstStart);
     await this.featureService.recalculateFeatureFlags(sessionMetadata);
     await this.redisClientFactory.init();
-    process.nextTick(async () => {
-      await this.databaseDiscoveryService.discover(sessionMetadata, firstStart);
-    });
+    await this.databaseDiscoveryService.discover(sessionMetadata, firstStart);
   }
 
   async initAnalytics(firstStart: boolean) {