Merge remote-tracking branch 'origin/main' into koesie10/restore-mrva-on-restart

Author: koesie10

extensions/ql-vscode/package-lock.json

@@ -1208,7 +1208,7 @@
   "dependencies": {
     "@octokit/plugin-retry": "^3.0.9",
     "@octokit/rest": "^19.0.4",
-    "@primer/octicons-react": "^16.3.0",
+    "@primer/octicons-react": "^17.6.0",
     "@primer/react": "^35.0.0",
     "@vscode/codicons": "^0.0.31",
     "@vscode/webview-ui-toolkit": "^1.0.1",

extensions/ql-vscode/package.json

@@ -178,6 +178,7 @@ export interface CodeQLExtensionInterface {
   readonly distributionManager: DistributionManager;
   readonly databaseManager: DatabaseManager;
   readonly databaseUI: DatabaseUI;
+  readonly variantAnalysisManager: VariantAnalysisManager;
   readonly dispose: () => void;
 }
 
@@ -400,7 +401,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
     allowAutoUpdating: !!ctx.globalState.get(shouldUpdateOnNextActivationKey)
   });
 
-  variantAnalysisViewSerializer.onExtensionLoaded();
+  variantAnalysisViewSerializer.onExtensionLoaded(codeQlExtension.variantAnalysisManager);
 
   return codeQlExtension;
 }
@@ -946,16 +947,14 @@ async function activateWithInstalledDistribution(
       // Generate a random variant analysis ID for testing
       const variantAnalysisId: number = Math.floor(Math.random() * 1000000);
 
-      const variantAnalysisView = new VariantAnalysisView(ctx, variantAnalysisId);
-      void variantAnalysisView.openView();
+      await variantAnalysisManager.showView(variantAnalysisId);
     })
   );
 
   // The "openVariantAnalysisView" command is internal-only.
   ctx.subscriptions.push(
     commandRunner('codeQL.openVariantAnalysisView', async (variantAnalysisId: number) => {
-      const variantAnalysisView = new VariantAnalysisView(ctx, variantAnalysisId);
-      void variantAnalysisView.openView();
+      await variantAnalysisManager.showView(variantAnalysisId);
     })
   );
 
@@ -1173,6 +1172,7 @@ async function activateWithInstalledDistribution(
     distributionManager,
     databaseManager: dbm,
     databaseUI,
+    variantAnalysisManager,
     dispose: () => {
       ctx.subscriptions.forEach(d => d.dispose());
     }

extensions/ql-vscode/src/extension.ts

@@ -2,7 +2,11 @@ import * as sarif from 'sarif';
 import { AnalysisResults } from '../remote-queries/shared/analysis-result';
 import { AnalysisSummary, RemoteQueryResult } from '../remote-queries/shared/remote-query-result';
 import { RawResultSet, ResultRow, ResultSetSchema, Column, ResolvableLocationValue } from './bqrs-cli-types';
-import { VariantAnalysis } from '../remote-queries/shared/variant-analysis';
+import {
+  VariantAnalysis,
+  VariantAnalysisScannedRepositoryResult,
+  VariantAnalysisScannedRepositoryState,
+} from '../remote-queries/shared/variant-analysis';
 
 /**
  * This module contains types and code that are shared between
@@ -436,18 +440,30 @@ export interface SetVariantAnalysisMessage {
   variantAnalysis: VariantAnalysis;
 }
 
-export type ToVariantAnalysisMessage =
-  | SetVariantAnalysisMessage;
-
 export type StopVariantAnalysisMessage = {
   t: 'stopVariantAnalysis';
   variantAnalysisId: number;
 }
 
-export type FromVariantAnalysisMessage =
-  | ViewLoadedMsg
-  | StopVariantAnalysisMessage;
-
 export type VariantAnalysisState = {
   variantAnalysisId: number;
 }
+
+export interface SetRepoResultsMessage {
+  t: 'setRepoResults';
+  repoResults: VariantAnalysisScannedRepositoryResult[];
+}
+
+export interface SetRepoStatesMessage {
+  t: 'setRepoStates';
+  repoStates: VariantAnalysisScannedRepositoryState[];
+}
+
+export type ToVariantAnalysisMessage =
+  | SetVariantAnalysisMessage
+  | SetRepoResultsMessage
+  | SetRepoStatesMessage;
+
+export type FromVariantAnalysisMessage =
+  | ViewLoadedMsg
+  | StopVariantAnalysisMessage;

extensions/ql-vscode/src/pure/interface-types.ts

@@ -76,8 +76,8 @@ export interface VariantAnalysisRepoTask {
 }
 
 export interface VariantAnalysisSkippedRepositories {
-  access_mismatch_repos: VariantAnalysisSkippedRepositoryGroup,
-  not_found_repo_nwos: VariantAnalysisNotFoundRepositoryGroup,
-  no_codeql_db_repos: VariantAnalysisSkippedRepositoryGroup,
-  over_limit_repos: VariantAnalysisSkippedRepositoryGroup
+  access_mismatch_repos?: VariantAnalysisSkippedRepositoryGroup,
+  not_found_repo_nwos?: VariantAnalysisNotFoundRepositoryGroup,
+  no_codeql_db_repos?: VariantAnalysisSkippedRepositoryGroup,
+  over_limit_repos?: VariantAnalysisSkippedRepositoryGroup
 }

extensions/ql-vscode/src/remote-queries/gh-api/variant-analysis.ts

@@ -82,6 +82,18 @@ export interface VariantAnalysisSkippedRepository {
   private?: boolean,
 }
 
+export enum VariantAnalysisScannedRepositoryDownloadStatus {
+  Pending = 'pending',
+  InProgress = 'inProgress',
+  Succeeded = 'succeeded',
+  Failed = 'failed',
+}
+
+export interface VariantAnalysisScannedRepositoryState {
+  repositoryId: number;
+  downloadStatus: VariantAnalysisScannedRepositoryDownloadStatus;
+}
+
 export interface VariantAnalysisScannedRepositoryResult {
   repositoryId: number;
   interpretedResults?: AnalysisAlert[];

extensions/ql-vscode/src/remote-queries/shared/variant-analysis.ts

@@ -11,18 +11,65 @@ import {
   VariantAnalysisRepoTask,
   VariantAnalysisScannedRepository as ApiVariantAnalysisScannedRepository
 } from './gh-api/variant-analysis';
-import { VariantAnalysis } from './shared/variant-analysis';
+import {
+  VariantAnalysis,
+  VariantAnalysisScannedRepositoryDownloadStatus,
+  VariantAnalysisScannedRepositoryState
+} from './shared/variant-analysis';
 import { getErrorMessage } from '../pure/helpers-pure';
+import { VariantAnalysisView } from './variant-analysis-view';
+import { VariantAnalysisViewManager } from './variant-analysis-view-manager';
 
-export class VariantAnalysisManager extends DisposableObject {
+export class VariantAnalysisManager extends DisposableObject implements VariantAnalysisViewManager<VariantAnalysisView> {
   private readonly variantAnalysisMonitor: VariantAnalysisMonitor;
+  private readonly views = new Map<number, VariantAnalysisView>();
 
   constructor(
     private readonly ctx: ExtensionContext,
     logger: Logger,
   ) {
     super();
-    this.variantAnalysisMonitor = new VariantAnalysisMonitor(ctx, logger);
+    this.variantAnalysisMonitor = this.push(new VariantAnalysisMonitor(ctx, logger));
+    this.variantAnalysisMonitor.onVariantAnalysisChange(this.onVariantAnalysisUpdated.bind(this));
+  }
+
+  public async showView(variantAnalysisId: number): Promise<void> {
+    if (!this.views.has(variantAnalysisId)) {
+      // The view will register itself with the manager, so we don't need to do anything here.
+      this.push(new VariantAnalysisView(this.ctx, variantAnalysisId, this));
+    }
+
+    const variantAnalysisView = this.views.get(variantAnalysisId)!;
+    await variantAnalysisView.openView();
+    return;
+  }
+
+  public registerView(view: VariantAnalysisView): void {
+    if (this.views.has(view.variantAnalysisId)) {
+      throw new Error(`View for variant analysis with id: ${view.variantAnalysisId} already exists`);
+    }
+
+    this.views.set(view.variantAnalysisId, view);
+  }
+
+  public unregisterView(view: VariantAnalysisView): void {
+    this.views.delete(view.variantAnalysisId);
+  }
+
+  public getView(variantAnalysisId: number): VariantAnalysisView | undefined {
+    return this.views.get(variantAnalysisId);
+  }
+
+  private async onVariantAnalysisUpdated(variantAnalysis: VariantAnalysis | undefined): Promise<void> {
+    if (!variantAnalysis) {
+      return;
+    }
+
+    await this.getView(variantAnalysis.id)?.updateView(variantAnalysis);
+  }
+
+  private async onRepoStateUpdated(variantAnalysisId: number, repoState: VariantAnalysisScannedRepositoryState): Promise<void> {
+    await this.getView(variantAnalysisId)?.updateRepoState(repoState);
   }
 
   public async monitorVariantAnalysis(
@@ -37,11 +84,19 @@ export class VariantAnalysisManager extends DisposableObject {
     variantAnalysisSummary: VariantAnalysisApiResponse,
     cancellationToken: CancellationToken
   ): Promise<void> {
+    const repoState = {
+      repositoryId: scannedRepo.repository.id,
+      downloadStatus: VariantAnalysisScannedRepositoryDownloadStatus.Pending,
+    };
+
+    await this.onRepoStateUpdated(variantAnalysisSummary.id, repoState);
 
     const credentials = await Credentials.initialize(this.ctx);
     if (!credentials) { throw Error('Error authenticating with GitHub'); }
 
     if (cancellationToken && cancellationToken.isCancellationRequested) {
+      repoState.downloadStatus = VariantAnalysisScannedRepositoryDownloadStatus.Failed;
+      await this.onRepoStateUpdated(variantAnalysisSummary.id, repoState);
       return;
     }
 
@@ -53,10 +108,16 @@ export class VariantAnalysisManager extends DisposableObject {
         variantAnalysisSummary.id,
         scannedRepo.repository.id
       );
+    } catch (e) {
+      repoState.downloadStatus = VariantAnalysisScannedRepositoryDownloadStatus.Failed;
+      await this.onRepoStateUpdated(variantAnalysisSummary.id, repoState);
+      throw new Error(`Could not download the results for variant analysis with id: ${variantAnalysisSummary.id}. Error: ${getErrorMessage(e)}`);
     }
-    catch (e) { throw new Error(`Could not download the results for variant analysis with id: ${variantAnalysisSummary.id}. Error: ${getErrorMessage(e)}`); }
 
     if (repoTask.artifact_url) {
+      repoState.downloadStatus = VariantAnalysisScannedRepositoryDownloadStatus.InProgress;
+      await this.onRepoStateUpdated(variantAnalysisSummary.id, repoState);
+
       const resultDirectory = path.join(
         this.ctx.globalStorageUri.fsPath,
         'variant-analyses',
@@ -77,5 +138,8 @@ export class VariantAnalysisManager extends DisposableObject {
       fs.mkdirSync(resultDirectory, { recursive: true });
       await fs.writeFile(storagePath, JSON.stringify(result, null, 2), 'utf8');
     }
+
+    repoState.downloadStatus = VariantAnalysisScannedRepositoryDownloadStatus.Succeeded;
+    await this.onRepoStateUpdated(variantAnalysisSummary.id, repoState);
   }
 }

extensions/ql-vscode/src/remote-queries/variant-analysis-manager.ts

@@ -1,4 +1,4 @@
-import { ExtensionContext, CancellationToken, commands } from 'vscode';
+import { ExtensionContext, CancellationToken, commands, EventEmitter } from 'vscode';
 import { Credentials } from '../authentication';
 import { Logger } from '../logging';
 import * as ghApiClient from './gh-api/gh-api-client';
@@ -8,18 +8,23 @@ import {
   VariantAnalysis as VariantAnalysisApiResponse
 } from './gh-api/variant-analysis';
 import { VariantAnalysisMonitorResult } from './shared/variant-analysis-monitor-result';
-import { processFailureReason } from './variant-analysis-processor';
+import { processFailureReason, processUpdatedVariantAnalysis } from './variant-analysis-processor';
+import { DisposableObject } from '../pure/disposable-object';
 
-export class VariantAnalysisMonitor {
+export class VariantAnalysisMonitor extends DisposableObject {
   // With a sleep of 5 seconds, the maximum number of attempts takes
   // us to just over 2 days worth of monitoring.
   public static maxAttemptCount = 17280;
   public static sleepTime = 5000;
 
+  private readonly _onVariantAnalysisChange = this.push(new EventEmitter<VariantAnalysis | undefined>());
+  readonly onVariantAnalysisChange = this._onVariantAnalysisChange.event;
+
   constructor(
     private readonly extensionContext: ExtensionContext,
     private readonly logger: Logger
   ) {
+    super();
   }
 
   public async monitorVariantAnalysis(
@@ -59,6 +64,10 @@ export class VariantAnalysisMonitor {
         };
       }
 
+      variantAnalysis = processUpdatedVariantAnalysis(variantAnalysis, variantAnalysisSummary);
+
+      this._onVariantAnalysisChange.fire(variantAnalysis);
+
       void this.logger.log('****** Retrieved variant analysis' + JSON.stringify(variantAnalysisSummary));
 
       if (variantAnalysisSummary.scanned_repositories) {

extensions/ql-vscode/src/remote-queries/variant-analysis-monitor.ts

@@ -23,7 +23,20 @@ export function processVariantAnalysis(
   submission: VariantAnalysisSubmission,
   response: ApiVariantAnalysis
 ): VariantAnalysis {
+  return processUpdatedVariantAnalysis({
+    query: {
+      name: submission.query.name,
+      filePath: submission.query.filePath,
+      language: submission.query.language
+    },
+    databases: submission.databases,
+  }, response);
+}
 
+export function processUpdatedVariantAnalysis(
+  previousVariantAnalysis: Pick<VariantAnalysis, 'query' | 'databases'>,
+  response: ApiVariantAnalysis
+): VariantAnalysis {
   let scannedRepos: VariantAnalysisScannedRepository[] = [];
   let skippedRepos: VariantAnalysisSkippedRepositories = {};
 
@@ -39,11 +52,11 @@ export function processVariantAnalysis(
     id: response.id,
     controllerRepoId: response.controller_repo.id,
     query: {
-      name: submission.query.name,
-      filePath: submission.query.filePath,
-      language: submission.query.language
+      name: previousVariantAnalysis.query.name,
+      filePath: previousVariantAnalysis.query.filePath,
+      language: previousVariantAnalysis.query.language
     },
-    databases: submission.databases,
+    databases: previousVariantAnalysis.databases,
     status: processApiStatus(response.status),
     actionsWorkflowRunId: response.actions_workflow_run_id,
     scannedRepos: scannedRepos,
@@ -87,7 +100,11 @@ function processSkippedRepositories(
   };
 }
 
-function processRepoGroup(repoGroup: ApiVariantAnalysisSkippedRepositoryGroup): VariantAnalysisSkippedRepositoryGroup {
+function processRepoGroup(repoGroup: ApiVariantAnalysisSkippedRepositoryGroup | undefined): VariantAnalysisSkippedRepositoryGroup | undefined {
+  if (!repoGroup) {
+    return undefined;
+  }
+
   const repos = repoGroup.repositories.map(repo => {
     return {
       id: repo.id,
@@ -101,7 +118,11 @@ function processRepoGroup(repoGroup: ApiVariantAnalysisSkippedRepositoryGroup):
   };
 }
 
-function processNotFoundRepoGroup(repoGroup: ApiVariantAnalysisNotFoundRepositoryGroup): VariantAnalysisSkippedRepositoryGroup {
+function processNotFoundRepoGroup(repoGroup: ApiVariantAnalysisNotFoundRepositoryGroup | undefined): VariantAnalysisSkippedRepositoryGroup | undefined {
+  if (!repoGroup) {
+    return undefined;
+  }
+
   const repo_full_names = repoGroup.repository_full_names.map(nwo => {
     return {
       fullName: nwo