construct qsForWarmingOverlayBaseCache lazily

Author: ginsbach

extensions/ql-vscode/src/common/logging/vscode/loggers.ts

@@ -11,8 +11,18 @@ export const extLogger = new OutputChannelLogger("CodeQL Extension Log");
 export const queryServerLogger = new OutputChannelLogger("CodeQL Query Server");
 
 // Logger for messages from the query server for warming overlay-base cache.
-export const queryServerForWarmingOverlayBaseCacheLogger =
-  new OutputChannelLogger("CodeQL Query Server for warming overlay-base cache");
+let queryServerForWarmingOverlayBaseCacheLogger:
+  | OutputChannelLogger
+  | undefined;
+
+// construct queryServerForWarmingOverlayBaseCacheLogger lazily, as most users don't need it
+export function getQueryServerForWarmingOverlayBaseCacheLogger(): OutputChannelLogger {
+  if (!queryServerForWarmingOverlayBaseCacheLogger)
+    queryServerForWarmingOverlayBaseCacheLogger = new OutputChannelLogger(
+      "CodeQL Query Server for warming overlay-base cache",
+    );
+  return queryServerForWarmingOverlayBaseCacheLogger;
+}
 
 // Logger for messages from the language server.
 export const languageServerLogger = new OutputChannelLogger(

extensions/ql-vscode/src/databases/local-databases/database-manager.ts

@@ -118,7 +118,6 @@ export class DatabaseManager extends DisposableObject {
     private readonly ctx: ExtensionContext,
     private readonly app: App,
     private readonly qs: QueryRunner,
-    private readonly qsForWarmingOverlayBaseCache: QueryRunner,
     private readonly cli: CodeQLCliServer,
     private readonly languageContext: LanguageContextStore,
     public logger: Logger,
@@ -740,19 +739,20 @@ export class DatabaseManager extends DisposableObject {
     }
   }
 
-  public async withDatabaseInQsForWarmingOverlayBaseCache(
+  public async runWithDatabaseInSeparateQueryRunner(
+    queryRunner: QueryRunner,
     whatToDo: () => Promise<void>,
   ) {
     try {
       if (this._currentDatabaseItem) {
         const dbItem = this._currentDatabaseItem;
         await this.qs.deregisterDatabase(dbItem);
-        await this.qsForWarmingOverlayBaseCache.registerDatabase(dbItem);
+        await queryRunner.registerDatabase(dbItem);
       }
       await whatToDo();
       if (this._currentDatabaseItem) {
         const dbItem = this._currentDatabaseItem;
-        await this.qsForWarmingOverlayBaseCache.deregisterDatabase(dbItem);
+        await queryRunner.deregisterDatabase(dbItem);
         await this.qs.registerDatabase(dbItem);
       }
     } catch (e) {

extensions/ql-vscode/src/extension.ts

@@ -86,7 +86,7 @@ import {
   extLogger,
   languageServerLogger,
   queryServerLogger,
-  queryServerForWarmingOverlayBaseCacheLogger,
+  getQueryServerForWarmingOverlayBaseCacheLogger,
 } from "./common/logging/vscode";
 import { QueryHistoryManager } from "./query-history/query-history-manager";
 import type { CompletedLocalQueryInfo } from "./query-results";
@@ -173,7 +173,7 @@ function getCommands(
   app: App,
   cliServer: CodeQLCliServer,
   queryRunner: QueryRunner,
-  queryRunnerForWarmingOverlayBaseCache: QueryRunner,
+  queryRunnerForWarmingOverlayBaseCache: QueryRunner | undefined,
   languageClient: LanguageClient,
 ): BaseCommands {
   const getCliVersion = async () => {
@@ -191,7 +191,9 @@ function getCommands(
         cliServer.restartCliServer();
         await Promise.all([
           queryRunner.restartQueryServer(progress),
-          queryRunnerForWarmingOverlayBaseCache.restartQueryServer(progress),
+          queryRunnerForWarmingOverlayBaseCache
+            ? queryRunnerForWarmingOverlayBaseCache.restartQueryServer(progress)
+            : {},
           async () => {
             if (languageClient.isRunning()) {
               await languageClient.restart();
@@ -204,10 +206,12 @@ function getCommands(
           queryServerLogger,
           "CodeQL Query Server restarted.",
         );
-        void showAndLogErrorMessage(
-          queryServerForWarmingOverlayBaseCacheLogger,
-          "CodeQL Query Server for warming overlay-base cache restarted.",
-        );
+        if (queryRunnerForWarmingOverlayBaseCache) {
+          void showAndLogErrorMessage(
+            getQueryServerForWarmingOverlayBaseCacheLogger(),
+            "CodeQL Query Server for warming overlay-base cache restarted.",
+          );
+        }
       },
       {
         title: "Restarting Query Server",
@@ -288,7 +292,7 @@ export interface CodeQLExtensionInterface {
   readonly ctx: ExtensionContext;
   readonly cliServer: CodeQLCliServer;
   readonly qs: QueryRunner;
-  readonly qsForWarmingOverlayBaseCache: QueryRunner;
+  readonly qsForWarmingOverlayBaseCache: QueryRunner | undefined;
   readonly distributionManager: DistributionManager;
   readonly databaseManager: DatabaseManager;
   readonly databaseUI: DatabaseUI;
@@ -806,14 +810,24 @@ async function activateWithInstalledDistribution(
     false,
   );
 
-  void extLogger.log("Initializing base cache warming query server client.");
-  const qsForWarmingOverlayBaseCache = await createQueryServer(
-    app,
-    qlConfigurationListener,
-    cliServer,
-    ctx,
-    true,
-  );
+  let qsForWarmingOverlayBaseCache: QueryRunner | undefined;
+
+  // construct qsForWarmingOverlayBaseCache lazily, as most users don't need it
+  async function getQsForWarmingOverlayBaseCache(): Promise<QueryRunner> {
+    if (!qsForWarmingOverlayBaseCache) {
+      void extLogger.log(
+        "Initializing base cache warming query server client.",
+      );
+      qsForWarmingOverlayBaseCache = await createQueryServer(
+        app,
+        qlConfigurationListener,
+        cliServer,
+        ctx,
+        true,
+      );
+    }
+    return qsForWarmingOverlayBaseCache;
+  }
 
   for (const glob of CLEAR_PACK_CACHE_ON_EDIT_GLOBS) {
     const fsWatcher = workspace.createFileSystemWatcher(glob);
@@ -840,7 +854,6 @@ async function activateWithInstalledDistribution(
     ctx,
     app,
     qs,
-    qsForWarmingOverlayBaseCache,
     cliServer,
     languageContext,
     extLogger,
@@ -1017,7 +1030,7 @@ async function activateWithInstalledDistribution(
   const localQueries = new LocalQueries(
     app,
     qs,
-    qsForWarmingOverlayBaseCache,
+    getQsForWarmingOverlayBaseCache,
     qhm,
     dbm,
     databaseFetcher,
@@ -1309,7 +1322,7 @@ async function createQueryServer(
 ): Promise<QueryRunner> {
   const qsOpts = {
     logger: warmOverlayBaseCache
-      ? queryServerForWarmingOverlayBaseCacheLogger
+      ? getQueryServerForWarmingOverlayBaseCacheLogger()
       : queryServerLogger,
     contextStoragePath: getContextStoragePath(ctx),
   };

extensions/ql-vscode/src/local-queries/local-queries.ts

@@ -74,7 +74,7 @@ export class LocalQueries extends DisposableObject {
   public constructor(
     private readonly app: ExtensionApp,
     private readonly queryRunner: QueryRunner,
-    private readonly queryRunnerForWarmingOverlayBaseCache: QueryRunner,
+    private readonly getQueryRunnerForWarmingOverlayBaseCache: () => Promise<QueryRunner>,
     private readonly queryHistoryManager: QueryHistoryManager,
     private readonly databaseManager: DatabaseManager,
     private readonly databaseFetcher: DatabaseFetcher,
@@ -167,8 +167,10 @@ export class LocalQueries extends DisposableObject {
   private async runWarmOverlayBaseCacheForQuery(
     uri: Uri | undefined,
   ): Promise<void> {
-    await this.databaseManager.withDatabaseInQsForWarmingOverlayBaseCache(() =>
-      this.runQueryInternal(uri, true),
+    const queryRunner = await this.getQueryRunnerForWarmingOverlayBaseCache();
+    await this.databaseManager.runWithDatabaseInSeparateQueryRunner(
+      queryRunner,
+      () => this.runQueryInternal(uri, true),
     );
   }
 
@@ -216,8 +218,10 @@ export class LocalQueries extends DisposableObject {
   private async runWarmOverlayBaseCacheForQueries(
     fileURIs: Uri[],
   ): Promise<void> {
-    await this.databaseManager.withDatabaseInQsForWarmingOverlayBaseCache(() =>
-      this.runQueriesInternal(fileURIs, true),
+    const queryRunner = await this.getQueryRunnerForWarmingOverlayBaseCache();
+    await this.databaseManager.runWithDatabaseInSeparateQueryRunner(
+      queryRunner,
+      () => this.runQueriesInternal(fileURIs, true),
     );
   }
 
@@ -298,8 +302,10 @@ export class LocalQueries extends DisposableObject {
   private async runWarmOverlayBaseCacheForQuerySuite(
     fileUri: Uri,
   ): Promise<void> {
-    await this.databaseManager.withDatabaseInQsForWarmingOverlayBaseCache(() =>
-      this.runQuerySuiteInternal(fileUri, true),
+    const queryRunner = await this.getQueryRunnerForWarmingOverlayBaseCache();
+    await this.databaseManager.runWithDatabaseInSeparateQueryRunner(
+      queryRunner,
+      () => this.runQuerySuiteInternal(fileUri, true),
     );
   }
 
@@ -341,7 +347,7 @@ export class LocalQueries extends DisposableObject {
           });
         });
         const queryRunner = warmOverlayBaseCache
-          ? this.queryRunnerForWarmingOverlayBaseCache
+          ? await this.getQueryRunnerForWarmingOverlayBaseCache()
           : this.queryRunner;
         const coreQueryRun = queryRunner.createQueryRun(
           databaseItem.databaseUri.fsPath,
@@ -523,7 +529,7 @@ export class LocalQueries extends DisposableObject {
     await createTimestampFile(outputDir.querySaveDir);
 
     const queryRunner = warmOverlayBaseCache
-      ? this.queryRunnerForWarmingOverlayBaseCache
+      ? await this.getQueryRunnerForWarmingOverlayBaseCache()
       : this.queryRunner;
 
     if (queryRunner.customLogDirectory) {
@@ -625,7 +631,7 @@ export class LocalQueries extends DisposableObject {
     const extensionPacks = await this.getDefaultExtensionPacks(additionalPacks);
 
     const queryRunner = warmOverlayBaseCache
-      ? this.queryRunnerForWarmingOverlayBaseCache
+      ? await this.getQueryRunnerForWarmingOverlayBaseCache()
       : this.queryRunner;
     const coreQueryRun = queryRunner.createQueryRun(
       databaseItem.databaseUri.fsPath,