Support finally tasks

preview-src/index.ts

@@ -192,6 +192,12 @@ function getStyle(style: CyTheme): cytoscape.Stylesheet[] {
         'color': style.labelColor,
       },
     },
+    {
+      selector: 'node[?final]',
+      style: {
+        'shape': 'diamond',
+      },
+    },
     {
       selector: 'node[state = "Started"]',
       style: {

preview-src/model.ts

@@ -13,6 +13,7 @@ export interface NodeData extends BaseData {
   id: string;
   state?: 'Cancelled'| 'Finished' | 'Started' | 'Failed' | 'Unknown';
   yamlPosition?: number;
+  final?: boolean;
 }
 
 export interface EdgeData extends BaseData {

src/model/pipeline/pipeline-model.ts

@@ -49,6 +49,7 @@ export class PipelineSpec extends NodeTknElement {
   private _description: TknStringElement;
   private _params: TknArray<ParamSpec>;
   private _workspaces: TknArray<WorkspacePipelineDeclaration>;
+  private _finally: TknArray<PipelineTask>;
 
   constructor(parent: Pipeline, node: YamlMap) {
     super(parent, node);
@@ -99,8 +100,18 @@ export class PipelineSpec extends NodeTknElement {
     return this._workspaces;
   }
 
+  get finally(): TknArray<PipelineTask> {
+    if (!this._finally) {
+      const finallyNode = findNodeByKey<YamlSequence>('finally', this.node as YamlMap);
+      if (finallyNode) {
+        this._finally = new TknArray(TknElementType.PIPELINE_TASKS, PipelineTask, this, finallyNode);
+      }
+    }
+    return this._finally;
+  }
+
   collectChildren(): TknElement[] {
-    return [this.tasks, this.description, this.resources, this.params, this.workspaces];
+    return [this.tasks, this.description, this.resources, this.params, this.workspaces, this.finally];
   }
 }
 

src/pipeline/pipeline-graph.ts

@@ -107,8 +107,8 @@ function convertTasksToNode(tasks: PipelineRunTask[], includePositions = true):
   tasks.forEach((task: DeclaredTask) => tasksMap.set(task.name, task));
 
   for (const task of tasks) {
-    result.push({ data: { id: task.name, label: getLabel(task), type: task.kind, taskRef: task.taskRef, state: task.state, yamlPosition: includePositions ? task.position : undefined } as NodeData });
-    for (const after of task.runAfter) {
+    result.push({ data: { id: task.name, label: getLabel(task), type: task.kind, taskRef: task.taskRef, state: task.state, yamlPosition: includePositions ? task.position : undefined, final: task.final } as NodeData });
+    for (const after of task.runAfter ?? []) {
       if (tasksMap.has(after)) {
         result.push({ data: { source: after, target: task.name, id: `${after}-${task.name}`, state: tasksMap.get(after).state } as EdgeData });
       }

src/yaml-support/tkn-yaml.ts

@@ -36,6 +36,7 @@ export interface DeclaredTask {
   runAfter: string[];
   kind: 'Task' | 'ClusterTask' | 'Condition' | string;
   position?: number;
+  final?: boolean;
 }
 
 export type RunState = 'Cancelled' | 'Finished' | 'Started' | 'Failed' | 'Unknown';
@@ -332,41 +333,63 @@ export const pipelineRunYaml = new PipelineRunYaml();
 
 function collectTasks(specMap: YamlMap): DeclaredTask[] {
   const result: DeclaredTask[] = [];
+  const lastTasks: string[] = [];
   if (specMap) {
     const tasksSeq = getTasksSeq(specMap);
     if (tasksSeq) {
       for (const taskNode of tasksSeq.items) {
         if (taskNode.kind === 'MAPPING') {
-          const decTask = {} as DeclaredTask;
-          const nameValue = findNodeByKey<YamlNode>('name', taskNode as YamlMap);
-          if (nameValue) {
-            decTask.name = nameValue.raw;
-            decTask.position = nameValue.startPosition;
-          }
-
-          const taskRef = pipelineYaml.getTaskRef(taskNode as YamlMap);
-          if (taskRef) {
-            const taskRefName = findNodeByKey<YamlNode>('name', taskRef);
-            decTask.taskRef = taskRefName.raw;
-            const kindName = findNodeByKey<YamlNode>('kind', taskRef);
-            if (kindName) {
-              decTask.kind = kindName.raw;
-            } else {
-              decTask.kind = 'Task';
-            }
-          }
-
+          const decTask = toDeclaredTask(taskNode as YamlMap);
           decTask.runAfter = getRunAfter(taskNode as YamlMap);
+          if (decTask.runAfter.length === 0){
+            lastTasks.push(decTask.name);
+          }
           collectConditions(taskNode as YamlMap, result);
           result.push(decTask);
         }
       }
     }
+
+
+    // collect finally tasks
+    const finallyTasks = findNodeByKey<YamlSequence>('finally', specMap);
+    if (finallyTasks) {
+      for (const finalTask of finallyTasks.items) {
+        if (finalTask.kind === 'MAPPING') {
+          const fTask = toDeclaredTask(finalTask as YamlMap);
+          fTask.runAfter = lastTasks;
+          fTask.final = true;
+          result.push(fTask);
+        }
+      }
+    }
   }
 
   return result;
 }
 
+function toDeclaredTask(taskNode: YamlMap): DeclaredTask {
+  const decTask = {} as DeclaredTask;
+  const nameValue = findNodeByKey<YamlNode>('name', taskNode);
+  if (nameValue) {
+    decTask.name = nameValue.raw;
+    decTask.position = nameValue.startPosition;
+  }
+
+  const taskRef = pipelineYaml.getTaskRef(taskNode);
+  if (taskRef) {
+    const taskRefName = findNodeByKey<YamlNode>('name', taskRef);
+    decTask.taskRef = taskRefName.raw;
+    const kindName = findNodeByKey<YamlNode>('kind', taskRef);
+    if (kindName) {
+      decTask.kind = kindName.raw;
+    } else {
+      decTask.kind = 'Task';
+    }
+  }
+  return decTask;
+}
+
 function collectConditions(taskNode: YamlMap, tasks: DeclaredTask[]): void {
 
   const conditions = findNodeByKey<YamlSequence>('conditions', taskNode);

test/model/pipeline/pipeline-model.test.ts

@@ -10,7 +10,7 @@ import * as vscode from 'vscode';
 import { yamlLocator } from '../../../src/yaml-support/yaml-locator';
 import { TknElementType } from '../../../src/model/common';
 import { TektonYamlType } from '../../../src/yaml-support/tkn-yaml';
-import { Pipeline, PipelineTaskRef } from '../../../src/model/pipeline/pipeline-model';
+import { Pipeline, PipelineTask, PipelineTaskRef } from '../../../src/model/pipeline/pipeline-model';
 
 const expect = chai.expect;
 chai.use(sinonChai);
@@ -97,6 +97,16 @@ suite('Pipeline Model', () => {
       expect(tknEl.type).eq(TknElementType.PIPELINE_TASK_REF);
       expect((tknEl as PipelineTaskRef).name.value).eq('build-docker-image-from-git-source');
     });
+
+    test('findElementAt should return finally task', async () => {
+      const yaml = await fs.readFile(path.join(__dirname, '..', '..', '..', '..', 'test', 'model', 'pipeline', 'pipeline-with-finally.yaml'));
+      const docs = yamlLocator.getTknDocuments({ getText: () => yaml.toString(), version: 1, uri: vscode.Uri.parse('file:///model/pipeline/pipeline-with-finally.yaml') } as vscode.TextDocument);
+      const tknDoc = docs[0];
+      const tknEl = tknDoc.findElementAt(new vscode.Position(26, 12));
+      expect(tknEl).not.undefined;
+      expect(tknEl.type).eq(TknElementType.PIPELINE_TASK);
+      expect((tknEl as PipelineTask).name.value).eq('cleanup');
+    });
   });
 
 

test/model/pipeline/pipeline-with-finally.yaml

@@ -0,0 +1,29 @@
+apiVersion: tekton.dev/v1beta1
+kind: Pipeline
+metadata:
+  name: clone-cleanup-workspace
+spec:
+  workspaces:
+    # common workspace where git repo is cloned and needs to be cleanup after done
+    - name: git-source
+  tasks:
+    # Clone app repo to workspace
+    - name: clone-app-repo
+      taskRef:
+        name: git-clone-from-catalog
+      params:
+        - name: url
+          value: https://github.com/tektoncd/community.git
+        - name: subdirectory
+          value: application
+      workspaces:
+        - name: output
+          workspace: git-source
+  finally:
+    # Cleanup workspace
+    - name: cleanup
+      taskRef:
+        name: cleanup-workspace
+      workspaces:
+        - name: source
+          workspace: git-source

test/yaml-support/tkn-yaml.test.ts

@@ -282,7 +282,6 @@ suite('Tekton yaml', () => {
 
   suite('PipelineRun', () => {
 
-
     test('should return pipelinerun name', async () => {
       const yaml = await fs.readFile(path.join(__dirname, '..', '..', '..', 'test', '/yaml-support/pipelinerun.yaml'));
       const docs = tektonYaml.getTektonDocuments({ getText: () => yaml.toString(), version: 1, uri: vscode.Uri.parse('file:///pipelinerun/pipelinerun.yaml') } as vscode.TextDocument, TektonYamlType.PipelineRun);
@@ -299,4 +298,29 @@ suite('Tekton yaml', () => {
       expect(result).eql('Failed');
     });
   });
+
+  suite('Finally tasks', () => {
+    test('Should return finally tasks', () => {
+      const yaml = `
+      apiVersion: tekton.dev/v1alpha1
+      kind: Pipeline
+      metadata:
+        name: pipeline-with-parameters
+      spec:
+        tasks:
+          - name: build-skaffold-web
+            taskRef:
+              name: build-push
+        finally: 
+          - name: final-ask
+            taskRef:
+              name: build-push
+      `
+      const docs = tektonYaml.getTektonDocuments({ getText: () => yaml, version: 1, uri: vscode.Uri.parse('file:///foo/pipeline/finally/tasks.yaml') } as vscode.TextDocument, TektonYamlType.Pipeline);
+      const pipelineTasks = pipelineYaml.getPipelineTasks(docs[0]);
+      expect(pipelineTasks).is.not.empty;
+      expect(pipelineTasks[1].name).equal('final-ask');
+      expect(pipelineTasks[1].runAfter).eql(['build-skaffold-web']);
+    })
+  });
 });