Move workflow runs to separate store

cschleiden · cschleiden · commit b189a3f4df3c · 2022-12-19T17:27:59.000+01:00
diff --git a/src/extension.ts b/src/extension.ts
@@ -15,12 +15,14 @@ import {registerUpdateSecret} from "./commands/secrets/updateSecret";
 import {registerTriggerWorkflowRun} from "./commands/triggerWorkflowRun";
 import {registerUnPinWorkflow} from "./commands/unpinWorkflow";
 import {initConfiguration} from "./configuration/configuration";
-import {getGitHubContext} from "./git/repository";
+import {getGitHubContext, GitHubRepoContext} from "./git/repository";
 import {LogScheme} from "./logs/constants";
 import {WorkflowStepLogProvider} from "./logs/fileProvider";
 import {WorkflowStepLogFoldingProvider} from "./logs/foldingProvider";
 import {WorkflowStepLogSymbolProvider} from "./logs/symbolProvider";
+import {WorkflowRun} from "./model";
 import {initPinnedWorkflows} from "./pinnedWorkflows/pinnedWorkflows";
+import {RunStore} from "./store/store";
 import {initWorkflowDocumentTracking} from "./tracker/workflowDocumentTracker";
 import {CurrentBranchTreeProvider} from "./treeViews/currentBranch";
 import {initResources} from "./treeViews/icons";
@@ -44,14 +46,15 @@ export async function activate(context: vscode.ExtensionContext) {
   await initWorkflowDocumentTracking(context);
 
   // Tree views
+  const store = new RunStore();
 
-  const workflowTreeProvider = new WorkflowsTreeProvider();
+  const workflowTreeProvider = new WorkflowsTreeProvider(store);
   context.subscriptions.push(vscode.window.registerTreeDataProvider("github-actions.workflows", workflowTreeProvider));
 
   const settingsTreeProvider = new SettingsTreeProvider();
   context.subscriptions.push(vscode.window.registerTreeDataProvider("github-actions.settings", settingsTreeProvider));
 
-  const currentBranchTreeProvider = new CurrentBranchTreeProvider();
+  const currentBranchTreeProvider = new CurrentBranchTreeProvider(store);
   context.subscriptions.push(
     vscode.window.registerTreeDataProvider("github-actions.current-branch", currentBranchTreeProvider)
   );
@@ -63,6 +66,14 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   );
 
+  // TODO: CS: Remove!
+  vscode.commands.registerCommand(
+    "github-actions.explorer.poll",
+    (args: {gitHubRepoContext: GitHubRepoContext; run: WorkflowRun}) => {
+      store.pollRun(args.run.id, args.gitHubRepoContext, 2000, 10);
+    }
+  );
+
   context.subscriptions.push(
     vscode.commands.registerCommand("github-actions.explorer.current-branch.refresh", () => {
       currentBranchTreeProvider.refresh();
diff --git a/src/log.ts b/src/log.ts
@@ -6,7 +6,7 @@ enum LogLevel {
 }
 
 let logger: vscode.OutputChannel;
-const level: LogLevel = LogLevel.Debug;
+const level: LogLevel = PRODUCTION ? LogLevel.Info : LogLevel.Debug;
 
 export function init() {
   logger = vscode.window.createOutputChannel("GitHub Actions");
diff --git a/src/store/store.ts b/src/store/store.ts
@@ -0,0 +1,71 @@
+import {setInterval} from "timers";
+import {EventEmitter} from "vscode";
+import {GitHubRepoContext} from "../git/repository";
+import {logDebug} from "../log";
+import {WorkflowRun} from "../model";
+
+export interface RunStoreEvent {
+  run: WorkflowRun;
+}
+
+type Updater = {
+  intervalMs: number;
+  remainingAttempts: number;
+  repoContext: GitHubRepoContext;
+  runId: number;
+  handle: NodeJS.Timeout | undefined;
+};
+
+export class RunStore extends EventEmitter<RunStoreEvent> {
+  private runs = new Map<number, WorkflowRun>();
+  private updaters = new Map<number, Updater>();
+
+  /**
+   * Update the given run and inform any listener
+   */
+  updateRun(run: WorkflowRun) {
+    this.runs.set(run.id, run);
+    this.fire({run});
+  }
+
+  /**
+   * Start polling for updates for the given run
+   */
+  pollRun(runId: number, repoContext: GitHubRepoContext, intervalMs: number, attempts = 10) {
+    let updater: Updater | undefined = this.updaters.get(runId);
+    if (updater) {
+      clearInterval(updater.handle);
+    }
+
+    updater = {
+      intervalMs,
+      repoContext,
+      runId,
+      remainingAttempts: attempts,
+      handle: undefined
+    };
+
+    updater.handle = setInterval(async () => this.fetchRun(updater!), intervalMs);
+
+    this.updaters.set(runId, updater);
+  }
+
+  private async fetchRun(updater: Updater) {
+    logDebug("Updating run: " + updater.runId);
+
+    updater.remainingAttempts--;
+    if (updater.remainingAttempts === 0) {
+      clearInterval(updater.handle);
+      this.updaters.delete(updater.runId);
+    }
+
+    const result = await updater.repoContext.client.actions.getWorkflowRun({
+      owner: updater.repoContext.owner,
+      repo: updater.repoContext.name,
+      run_id: updater.runId
+    });
+
+    const run = result.data;
+    this.updateRun(run);
+  }
+}
diff --git a/src/treeViews/current-branch/currentBranchRepoNode.ts b/src/treeViews/current-branch/currentBranchRepoNode.ts
@@ -1,10 +1,10 @@
 import * as vscode from "vscode";
 
-import {GitHubRepoContext, getCurrentBranch} from "../../git/repository";
+import {getCurrentBranch, GitHubRepoContext} from "../../git/repository";
 
-import {NoRunForBranchNode} from "./noRunForBranchNode";
-import {WorkflowRunNode} from "../workflows/workflowRunNode";
 import {logDebug} from "../../log";
+import {WorkflowRunNode} from "../shared/workflowRunNode";
+import {NoRunForBranchNode} from "./noRunForBranchNode";
 
 export class CurrentBranchRepoNode extends vscode.TreeItem {
   constructor(public readonly gitHubRepoContext: GitHubRepoContext, public readonly currentBranchName: string) {
diff --git a/src/treeViews/currentBranch.ts b/src/treeViews/currentBranch.ts
@@ -1,25 +1,40 @@
 import * as vscode from "vscode";
 
-import {CurrentBranchRepoNode, getCurrentBranchWorkflowRunNodes} from "./current-branch/currentBranchRepoNode";
-import {getCurrentBranch, getGitHubContext} from "../git/repository";
+import {getCurrentBranch, getGitHubContext, GitHubRepoContext} from "../git/repository";
+import {CurrentBranchRepoNode} from "./current-branch/currentBranchRepoNode";
 
+import {log, logDebug} from "../log";
+import {RunStore} from "../store/store";
 import {NoRunForBranchNode} from "./current-branch/noRunForBranchNode";
-import {WorkflowJobNode} from "./workflows/workflowJobNode";
-import {WorkflowRunNode} from "./workflows/workflowRunNode";
+import {NoWorkflowJobsNode} from "./shared/noWorkflowJobsNode";
+import {WorkflowJobNode} from "./shared/workflowJobNode";
+import {WorkflowRunNode} from "./shared/workflowRunNode";
+import {WorkflowRunTreeDataProvider} from "./workflowRunTreeDataProvider";
 import {WorkflowStepNode} from "./workflows/workflowStepNode";
-import {logDebug} from "../log";
 
 type CurrentBranchTreeNode =
   | CurrentBranchRepoNode
   | WorkflowRunNode
   | WorkflowJobNode
+  | NoWorkflowJobsNode
   | WorkflowStepNode
   | NoRunForBranchNode;
 
-export class CurrentBranchTreeProvider implements vscode.TreeDataProvider<CurrentBranchTreeNode> {
-  private _onDidChangeTreeData = new vscode.EventEmitter<CurrentBranchTreeNode | null>();
+export class CurrentBranchTreeProvider
+  extends WorkflowRunTreeDataProvider
+  implements vscode.TreeDataProvider<CurrentBranchTreeNode>
+{
+  protected _onDidChangeTreeData = new vscode.EventEmitter<CurrentBranchTreeNode | null>();
   readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
 
+  constructor(store: RunStore) {
+    super(store);
+  }
+
+  protected _updateNode(node: WorkflowRunNode): void {
+    this._onDidChangeTreeData.fire(node);
+  }
+
   refresh(): void {
     this._onDidChangeTreeData.fire(null);
   }
@@ -36,15 +51,22 @@ export class CurrentBranchTreeProvider implements vscode.TreeDataProvider<Curren
       }
 
       if (gitHubContext.repos.length === 1) {
-        return (await getCurrentBranchWorkflowRunNodes(gitHubContext.repos[0])) || [];
+        const repoContext = gitHubContext.repos[0];
+        const currentBranch = getCurrentBranch(repoContext.repositoryState);
+        if (!currentBranch) {
+          log(`Could not find current branch for ${repoContext.name}`);
+          return [];
+        }
+
+        return (await this.getRuns(repoContext, currentBranch)) || [];
       }
 
-      if (gitHubContext.repos.length > 1) {
+      if (gitHubContext.repos.length === 1) {
         return gitHubContext.repos
           .map((repoContext): CurrentBranchRepoNode | undefined => {
             const currentBranch = getCurrentBranch(repoContext.repositoryState);
             if (!currentBranch) {
-              logDebug(`Could not find current branch for ${repoContext.name}`);
+              log(`Could not find current branch for ${repoContext.name}`);
               return undefined;
             }
 
@@ -53,7 +75,7 @@ export class CurrentBranchTreeProvider implements vscode.TreeDataProvider<Curren
           .filter(x => x !== undefined) as CurrentBranchRepoNode[];
       }
     } else if (element instanceof CurrentBranchRepoNode) {
-      return element.getRuns();
+      return this.getRuns(element.gitHubRepoContext, element.currentBranchName);
     } else if (element instanceof WorkflowRunNode) {
       return element.getJobs();
     } else if (element instanceof WorkflowJobNode) {
@@ -62,4 +84,24 @@ export class CurrentBranchTreeProvider implements vscode.TreeDataProvider<Curren
 
     return [];
   }
+
+  private async getRuns(gitHubRepoContext: GitHubRepoContext, currentBranchName: string): Promise<WorkflowRunNode[]> {
+    logDebug("Getting workflow runs");
+
+    const result = await gitHubRepoContext.client.actions.listWorkflowRunsForRepo({
+      owner: gitHubRepoContext.owner,
+      repo: gitHubRepoContext.name,
+      branch: currentBranchName
+    });
+
+    const resp = result.data;
+    const runs = resp.workflow_runs;
+
+    return runs.map(wr => {
+      this.store.updateRun(wr);
+      const node = new WorkflowRunNode(gitHubRepoContext, wr);
+      this._runNodes.set(wr.id, node);
+      return node;
+    });
+  }
 }
diff --git a/src/treeViews/shared/noWorkflowJobsNode.ts b/src/treeViews/shared/noWorkflowJobsNode.ts
@@ -0,0 +1,10 @@
+import * as vscode from "vscode";
+
+/**
+ * When no github.com remote can be found in the current workspace.
+ */
+export class NoWorkflowJobsNode extends vscode.TreeItem {
+  constructor() {
+    super("No workflow jobs");
+  }
+}
diff --git a/src/treeViews/shared/workflowJobNode.ts b/src/treeViews/shared/workflowJobNode.ts
@@ -2,7 +2,7 @@ import * as vscode from "vscode";
 import {GitHubRepoContext} from "../../git/repository";
 import {WorkflowJob} from "../../model";
 import {getIconForWorkflowRun} from "../icons";
-import {WorkflowStepNode} from "./workflowStepNode";
+import {WorkflowStepNode} from "../workflows/workflowStepNode";
 
 export class WorkflowJobNode extends vscode.TreeItem {
   constructor(public readonly gitHubRepoContext: GitHubRepoContext, public readonly job: WorkflowJob) {
diff --git a/src/treeViews/shared/workflowRunNode.ts b/src/treeViews/shared/workflowRunNode.ts
@@ -3,19 +3,26 @@ import * as vscode from "vscode";
 import {WorkflowJob, WorkflowRun} from "../../model";
 
 import {GitHubRepoContext} from "../../git/repository";
-import {WorkflowJobNode} from "./workflowJobNode";
-import {getIconForWorkflowRun} from "../icons";
 import {logDebug} from "../../log";
+import {getIconForWorkflowRun} from "../icons";
+import {NoWorkflowJobsNode} from "./noWorkflowJobsNode";
+import {WorkflowJobNode} from "./workflowJobNode";
 
 export class WorkflowRunNode extends vscode.TreeItem {
   constructor(
     public readonly gitHubRepoContext: GitHubRepoContext,
-    public readonly run: WorkflowRun,
+    public run: WorkflowRun,
     public readonly workflowName?: string
   ) {
-    super(`${workflowName ? workflowName + " " : ""}#${run.id}`, vscode.TreeItemCollapsibleState.Collapsed);
+    super(WorkflowRunNode._getLabel(run, workflowName), vscode.TreeItemCollapsibleState.Collapsed);
+
+    this.updateRun(run);
+  }
+
+  updateRun(run: WorkflowRun) {
+    this.run = run;
 
-    this.description = `${run.event} (${(run.head_sha || "").substr(0, 7)})`;
+    this.label = WorkflowRunNode._getLabel(run, this.workflowName);
 
     this.contextValue = "run";
     if (this.run.status !== "completed") {
@@ -34,7 +41,7 @@ export class WorkflowRunNode extends vscode.TreeItem {
     this.tooltip = `${this.run.status || ""} ${this.run.conclusion || ""}`;
   }
 
-  async getJobs(): Promise<WorkflowJobNode[]> {
+  async getJobs(): Promise<(WorkflowJobNode | NoWorkflowJobsNode)[]> {
     logDebug("Getting workflow jobs");
 
     const result = await this.gitHubRepoContext.client.actions.listJobsForWorkflowRun({
@@ -45,7 +52,14 @@ export class WorkflowRunNode extends vscode.TreeItem {
 
     const resp = result.data;
     const jobs: WorkflowJob[] = resp.jobs;
+    if (jobs.length === 0) {
+      return [new NoWorkflowJobsNode()];
+    }
 
     return jobs.map(job => new WorkflowJobNode(this.gitHubRepoContext, job));
   }
+
+  private static _getLabel(run: WorkflowRun, workflowName?: string): string {
+    return `${workflowName ? workflowName + " " : ""}#${run.id}`;
+  }
 }
diff --git a/src/treeViews/workflowRunTreeDataProvider.ts b/src/treeViews/workflowRunTreeDataProvider.ts
@@ -0,0 +1,19 @@
+import {RunStore} from "../store/store";
+import {WorkflowRunNode} from "./shared/workflowRunNode";
+
+export abstract class WorkflowRunTreeDataProvider {
+  protected _runNodes = new Map<number, WorkflowRunNode>();
+
+  constructor(protected store: RunStore) {
+    this.store.event(({run}) => {
+      // Get tree node
+      const node = this._runNodes.get(run.id);
+      if (node) {
+        node.updateRun(run);
+        this._updateNode(node);
+      }
+    });
+  }
+
+  protected abstract _updateNode(node: WorkflowRunNode): void;
+}
diff --git a/src/treeViews/workflows.ts b/src/treeViews/workflows.ts
diff --git a/src/treeViews/workflows/workflowNode.ts b/src/treeViews/workflows/workflowNode.ts

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ enum LogLevel {`
`6`	`6`	`}`
`7`	`7`
`8`	`8`	`let logger: vscode.OutputChannel;`
`9`		`-const level: LogLevel = LogLevel.Debug;`
	`9`	`+const level: LogLevel = PRODUCTION ? LogLevel.Info : LogLevel.Debug;`
`10`	`10`
`11`	`11`	`export function init() {`
`12`	`12`	`logger = vscode.window.createOutputChannel("GitHub Actions");`