QueryServer: Add support for new query-server

Author: alexet

extensions/ql-vscode/src/cli.ts

@@ -1405,4 +1405,9 @@ export class CliVersionConstraint {
   async supportsSourceMap() {
     return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_SOURCEMAP);
   }
+
+  async supportsNewQueryServer() {
+    //  return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_NEW_QUERY_SERVER);
+    return true;
+  }
 }

extensions/ql-vscode/src/extension.ts

@@ -73,7 +73,8 @@ import { WebviewReveal } from './interface-utils';
 import { ideServerLogger, logger, ProgressReporter, queryServerLogger } from './logging';
 import { QueryHistoryManager } from './query-history';
 import { CompletedLocalQueryInfo, LocalQueryInfo } from './query-results';
-import * as qsClient from './legacy-query-server/queryserver-client';
+import * as legacyQueryServer from './legacy-query-server/queryserver-client';
+import * as newQueryServer from './query-server/queryserver-client';
 import { displayQuickQuery } from './quick-query';
 import { QLTestAdapterFactory } from './test-adapter';
 import { TestUIService } from './test-ui';
@@ -104,6 +105,7 @@ import { LogScannerService } from './log-insights/log-scanner-service';
 import { createInitialQueryInfo } from './run-queries-shared';
 import { LegacyQueryRunner } from './legacy-query-server/legacyRunner';
 import { QueryRunner } from './queryRunner';
+import { NewQueryRunner } from './query-server/query-runner';
 
 /**
  * extension.ts
@@ -390,6 +392,8 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
   });
 }
 
+const PACK_GLOBS = ['**/codeql-pack.yml', '**/qlpack.yml', '**/queries.xml', '**/codeql-pack.lock.yml', '**/qlpack.lock.yml', '.codeqlmanifest.json', 'codeql-workspace.yml'];
+
 async function activateWithInstalledDistribution(
   ctx: ExtensionContext,
   distributionManager: DistributionManager,
@@ -420,6 +424,15 @@ async function activateWithInstalledDistribution(
   void logger.log('Initializing query server client.');
   const qs = await createQueryServer(qlConfigurationListener, cliServer, ctx);
 
+
+  for (const glob of PACK_GLOBS) {
+    const fsWatcher = workspace.createFileSystemWatcher(glob);
+    ctx.subscriptions.push(fsWatcher);
+    fsWatcher.onDidChange(async (_uri) => {
+      await qs.clearPackCache();
+    });
+  }
+
   void logger.log('Initializing database manager.');
   const dbm = new DatabaseManager(ctx, qs, cliServer, logger);
   ctx.subscriptions.push(dbm);
@@ -1135,15 +1148,28 @@ async function createQueryServer(qlConfigurationListener: QueryServerConfigListe
     { title: 'CodeQL query server', location: ProgressLocation.Window },
     task
   );
-  const qs = new qsClient.QueryServerClient(
-    qlConfigurationListener,
-    cliServer,
-    qsOpts,
-    progressCallback
-  );
-  ctx.subscriptions.push(qs);
-  await qs.startQueryServer();
-  return new LegacyQueryRunner(qs);
+  if (await cliServer.cliConstraints.supportsNewQueryServer()) {
+    const qs = new newQueryServer.QueryServerClient(
+      qlConfigurationListener,
+      cliServer,
+      qsOpts,
+      progressCallback
+    );
+    ctx.subscriptions.push(qs);
+    await qs.startQueryServer();
+    return new NewQueryRunner(qs);
+
+  } else {
+    const qs = new legacyQueryServer.QueryServerClient(
+      qlConfigurationListener,
+      cliServer,
+      qsOpts,
+      progressCallback
+    );
+    ctx.subscriptions.push(qs);
+    await qs.startQueryServer();
+    return new LegacyQueryRunner(qs);
+  }
 }
 
 function getContextStoragePath(ctx: ExtensionContext) {

extensions/ql-vscode/src/legacy-query-server/legacyRunner.ts

@@ -56,4 +56,10 @@ export class LegacyQueryRunner extends QueryRunner {
   async upgradeDatabaseExplicit(dbItem: DatabaseItem, progress: ProgressCallback, token: CancellationToken): Promise<void> {
     await upgradeDatabaseExplicit(this.qs, dbItem, progress, token);
   }
+
+  async clearPackCache(): Promise<void> {
+    /**
+     * Nothing needs to be done
+     */
+  }
 }

extensions/ql-vscode/src/legacy-query-server/upgrades.ts

@@ -3,7 +3,7 @@ import { getOnDiskWorkspaceFolders, showAndLogErrorMessage, tmpDir } from '../he
 import { ProgressCallback, UserCancellationException } from '../commandRunner';
 import { logger } from '../logging';
 import * as messages from '../pure/legacy-messages';
-import * as qsClient from '../legacy-query-server/queryserver-client';
+import * as qsClient from './queryserver-client';
 import * as tmp from 'tmp-promise';
 import * as path from 'path';
 import { DatabaseItem } from '../databases';

extensions/ql-vscode/src/pure/new-messages.ts

@@ -0,0 +1,215 @@
+/**
+ * Types for messages exchanged during jsonrpc communication with the
+ * the CodeQL query server.
+ *
+ * This file exists in the queryserver and in the vscode extension, and
+ * should be kept in sync between them.
+ *
+ * A note about the namespaces below, which look like they are
+ * essentially enums, namely Severity, ResultColumnKind, and
+ * QueryResultType. By design, for the sake of extensibility, clients
+ * receiving messages of this protocol are supposed to accept any
+ * number for any of these types. We commit to the given meaning of
+ * the numbers listed in constants in the namespaces, and we commit to
+ * the fact that any unknown QueryResultType value counts as an error.
+ */
+
+import * as rpc from 'vscode-jsonrpc';
+import * as shared from './messages-shared';
+
+
+
+/**
+ * Parameters to clear the cache
+ */
+export interface ClearCacheParams {
+  /**
+   * The dataset for which we want to clear the cache
+   */
+  db: string;
+  /**
+   * Whether the cache should actually be cleared.
+   */
+  dryRun: boolean;
+}
+
+/**
+ * Parameters for trimming the cache of a dataset
+ */
+export interface TrimCacheParams {
+  /**
+   * The dataset that we want to trim the cache of.
+   */
+  db: string;
+}
+
+/**
+ * The result of trimming or clearing the cache.
+ */
+export interface ClearCacheResult {
+  /**
+   * A user friendly message saying what was or would be
+   * deleted.
+   */
+  deletionMessage: string;
+}
+
+
+export type QueryResultType = number;
+/**
+ * The result of running a query. This namespace is intentionally not
+ * an enum, see "for the sake of extensibility" comment above.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace QueryResultType {
+  /**
+   * The query ran successfully
+   */
+  export const SUCCESS = 0;
+  /**
+   * The query failed due to an reason
+   * that isn't listed
+   */
+  export const OTHER_ERROR = 1;
+  /**
+   * The query failed do to compilation erorrs
+   */
+  export const COMPILATION_ERROR = 2;
+  /**
+    * The query failed due to running out of
+    * memory
+    */
+  export const OOM = 3;
+  /**
+   * The query failed because it was cancelled.
+   */
+  export const CANCELLATION = 4;
+  /**
+   * The dbscheme basename was not the same
+   */
+  export const DBSCHEME_MISMATCH_NAME = 5;
+  /**
+   * No upgrade was found
+   */
+  export const DBSCHEME_NO_UPGRADE = 6;
+}
+
+
+export interface RegisterDatabasesParams {
+  databases: string[];
+}
+
+export interface DeregisterDatabasesParams {
+  databases: string[];
+}
+
+export type RegisterDatabasesResult = {
+  registeredDatabases: string[];
+};
+
+export type DeregisterDatabasesResult = {
+  registeredDatabases: string[];
+};
+
+
+export interface RunQueryParams {
+  /**
+   * The path of the query
+   */
+  queryPath: string,
+  /**
+   * The output path
+   */
+  outputPath: string,
+  /**
+   * The database path
+   */
+  db: string,
+  additionalPacks: string[],
+  target: CompilationTarget,
+  externalInputs: Record<string, string>,
+  singletonExternalInputs: Record<string, string>,
+  dilPath?: string,
+  logPath?: string
+}
+
+export interface RunQueryResult {
+  resultType: QueryResultType,
+  message?: string,
+  expectedDbschemeName?: string,
+  evaluationTime: number;
+}
+
+
+
+export interface UpgradeParams {
+  db: string,
+  additionalPacks: string[],
+}
+
+export type UpgradeResult = Record<string, unknown>;
+
+export type ClearPackCacheParams = Record<string, unknown>;
+export type ClearPackCacheResult = Record<string, unknown>;
+
+/**
+ * A position within a QL file.
+ */
+export type Position = shared.Position;
+
+/**
+ * The way of compiling the query, as a normal query
+ * or a subset of it. Note that precisely one of the two options should be set.
+ */
+export type CompilationTarget = shared.CompilationTarget;
+
+export type QuickEvalOptions = shared.QuickEvalOptions;
+
+export type WithProgressId<T> = shared.WithProgressId<T>;
+export type ProgressMessage = shared.ProgressMessage;
+
+/**
+ * Clear the cache of a dataset
+ */
+export const clearCache = new rpc.RequestType<WithProgressId<ClearCacheParams>, ClearCacheResult, void, void>('evaluation/clearCache');
+/**
+ * Trim the cache of a dataset
+ */
+export const trimCache = new rpc.RequestType<WithProgressId<TrimCacheParams>, ClearCacheResult, void, void>('evaluation/trimCache');
+
+/**
+ * Clear the pack cache
+ */
+export const clearPackCache = new rpc.RequestType<WithProgressId<ClearPackCacheParams>, ClearPackCacheResult, void, void>('evaluation/clearPackCache');
+
+/**
+ * Run a query on a database
+ */
+export const runQuery = new rpc.RequestType<WithProgressId<RunQueryParams>, RunQueryResult, void, void>('evaluation/runQuery');
+
+export const registerDatabases = new rpc.RequestType<
+  WithProgressId<RegisterDatabasesParams>,
+  RegisterDatabasesResult,
+  void,
+  void
+>('evaluation/registerDatabases');
+
+export const deregisterDatabases = new rpc.RequestType<
+  WithProgressId<DeregisterDatabasesParams>,
+  DeregisterDatabasesResult,
+  void,
+  void
+>('evaluation/deregisterDatabases');
+
+
+export const upgradeDatabase = new rpc.RequestType<
+  WithProgressId<UpgradeParams>,
+  UpgradeResult,
+  void,
+  void
+>('evaluation/upgrade');
+
+/**
+ * A notification that the progress has been changed.
+ */
+export const progress = shared.progress;