Merge pull request #1620 from github/mob/consume-update-event

QueryHistory: Consume event when variant analysis status is updated

extensions/ql-vscode/src/query-history.ts

@@ -34,7 +34,7 @@ import { CompletedLocalQueryInfo, LocalQueryInfo } from './query-results';
 import { getQueryHistoryItemId, getQueryText, QueryHistoryInfo } from './query-history-info';
 import { DatabaseManager } from './databases';
 import { registerQueryHistoryScrubber } from './query-history-scrubber';
-import { QueryStatus } from './query-status';
+import { QueryStatus, variantAnalysisStatusToQueryStatus } from './query-status';
 import { slurpQueryHistory, splatQueryHistory } from './query-serialization';
 import * as fs from 'fs-extra';
 import { CliVersionConstraint } from './cli';
@@ -52,6 +52,8 @@ import { QueryWithResults } from './run-queries-shared';
 import { QueryRunner } from './queryRunner';
 import { VariantAnalysisManager } from './remote-queries/variant-analysis-manager';
 import { nanoid } from 'nanoid';
+import { VariantAnalysisHistoryItem } from './remote-queries/variant-analysis-history-item';
+import { getTotalResultCount } from './remote-queries/shared/variant-analysis';
 
 /**
  * query-history.ts
@@ -611,6 +613,27 @@ export class QueryHistoryManager extends DisposableObject {
       await this.refreshTreeView();
     });
 
+    const variantAnalysisStatusUpdateSubscription = this.variantAnalysisManager.onVariantAnalysisStatusUpdated(async (variantAnalysis) => {
+      const items = this.treeDataProvider.allHistory.filter(i => i.t === 'variant-analysis' && i.variantAnalysis.id === variantAnalysis.id);
+      const status = variantAnalysisStatusToQueryStatus(variantAnalysis.status);
+
+      if (items.length > 0) {
+        items.forEach(async (item) => {
+          const variantAnalysisHistoryItem = item as VariantAnalysisHistoryItem;
+          variantAnalysisHistoryItem.status = status;
+          variantAnalysisHistoryItem.failureReason = variantAnalysis.failureReason;
+          variantAnalysisHistoryItem.resultCount = getTotalResultCount(variantAnalysis.scannedRepos);
+          variantAnalysisHistoryItem.variantAnalysis = variantAnalysis;
+          if (status === QueryStatus.Completed) {
+            variantAnalysisHistoryItem.completed = true;
+          }
+        });
+        await this.refreshTreeView();
+      } else {
+        void logger.log('Variant analysis status update event received for unknown variant analysis');
+      }
+    });
+
     const variantAnalysisRemovedSubscription = this.variantAnalysisManager.onVariantAnalysisRemoved(async (variantAnalysis) => {
       const item = this.treeDataProvider.allHistory.find(i => i.t === 'variant-analysis' && i.variantAnalysis.id === variantAnalysis.id);
       if (item) {
@@ -619,6 +642,7 @@ export class QueryHistoryManager extends DisposableObject {
     });
 
     this.push(variantAnalysisAddedSubscription);
+    this.push(variantAnalysisStatusUpdateSubscription);
     this.push(variantAnalysisRemovedSubscription);
   }
 

extensions/ql-vscode/src/query-status.ts

@@ -1,5 +1,23 @@
+import { assertNever } from './pure/helpers-pure';
+import { VariantAnalysisStatus } from './remote-queries/shared/variant-analysis';
+
 export enum QueryStatus {
   InProgress = 'InProgress',
   Completed = 'Completed',
   Failed = 'Failed',
 }
+
+export function variantAnalysisStatusToQueryStatus(status: VariantAnalysisStatus): QueryStatus {
+  switch (status) {
+    case VariantAnalysisStatus.Succeeded:
+      return QueryStatus.Completed;
+    case VariantAnalysisStatus.Failed:
+      return QueryStatus.Failed;
+    case VariantAnalysisStatus.InProgress:
+      return QueryStatus.InProgress;
+    case VariantAnalysisStatus.Canceled:
+      return QueryStatus.Completed;
+    default:
+      assertNever(status);
+  }
+}

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

@@ -33,6 +33,8 @@ import * as fs from 'fs-extra';
 export class VariantAnalysisManager extends DisposableObject implements VariantAnalysisViewManager<VariantAnalysisView> {
   private readonly _onVariantAnalysisAdded = this.push(new EventEmitter<VariantAnalysis>());
   public readonly onVariantAnalysisAdded = this._onVariantAnalysisAdded.event;
+  private readonly _onVariantAnalysisStatusUpdated = this.push(new EventEmitter<VariantAnalysis>());
+  public readonly onVariantAnalysisStatusUpdated = this._onVariantAnalysisStatusUpdated.event;
 
   private readonly _onVariantAnalysisRemoved = this.push(new EventEmitter<VariantAnalysis>());
   public readonly onVariantAnalysisRemoved = this._onVariantAnalysisRemoved.event;
@@ -123,6 +125,7 @@ export class VariantAnalysisManager extends DisposableObject implements VariantA
     this.variantAnalyses.set(variantAnalysis.id, variantAnalysis);
 
     await this.getView(variantAnalysis.id)?.updateView(variantAnalysis);
+    this._onVariantAnalysisStatusUpdated.fire(variantAnalysis);
   }
 
   public async onVariantAnalysisSubmitted(variantAnalysis: VariantAnalysis): Promise<void> {

extensions/ql-vscode/src/vscode-tests/no-workspace/query-history.test.ts

@@ -68,6 +68,7 @@ describe('query-history', () => {
 
     variantAnalysisManagerStub = {
       onVariantAnalysisAdded: sandbox.stub(),
+      onVariantAnalysisStatusUpdated: sandbox.stub(),
       onVariantAnalysisRemoved: sandbox.stub()
     } as any as VariantAnalysisManager;
   });

extensions/ql-vscode/src/vscode-tests/no-workspace/remote-queries/remote-query-history.test.ts

@@ -78,6 +78,7 @@ describe('Remote queries and query history manager', function() {
 
     variantAnalysisManagerStub = {
       onVariantAnalysisAdded: sandbox.stub(),
+      onVariantAnalysisStatusUpdated: sandbox.stub(),
       onVariantAnalysisRemoved: sandbox.stub()
     } as any as VariantAnalysisManager;
   });