screwdriver-api 8.0.9 → 8.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "8.0.9",
+  "version": "8.0.11",
   "description": "API server for the Screwdriver.cd service",
   "main": "index.js",
   "scripts": {
@@ -111,7 +111,7 @@
     "screwdriver-config-parser": "^12.0.0",
     "screwdriver-coverage-bookend": "^3.0.0",
     "screwdriver-coverage-sonar": "^5.0.0",
-    "screwdriver-data-schema": "^25.1.0",
+    "screwdriver-data-schema": "^25.1.3",
     "screwdriver-datastore-sequelize": "^10.0.0",
     "screwdriver-executor-base": "^11.0.0",
     "screwdriver-executor-docker": "^8.0.1",

package/plugins/builds/helper/updateBuild.js

@@ -135,18 +135,26 @@ async function getStage({ stageFactory, workflowGraph, jobName, pipelineId }) {
 }
 
 /**
- * Checks if all builds in stage are done running
+ * Get all builds in stage
  *
  * @param  {Stage}      stage   Stage
  * @param  {Event}      event   Event
- * @return {Boolean}            Flag if stage is done
+ * @return {Promise<Build[]>}   Builds in stage
  */
-async function isStageDone({ stage, event }) {
+async function getStageJobBuilds({ stage, event }) {
     // Get all jobIds for jobs in the stage
     const stageJobIds = [...stage.jobIds, stage.setup];
 
     // Get all builds in a stage for this event
-    const stageJobBuilds = await event.getBuilds({ params: { jobId: stageJobIds } });
+    return event.getBuilds({ params: { jobId: stageJobIds } });
+}
+
+/**
+ * Checks if all builds in stage are done running
+ * @param {Build[]} stageJobBuilds Builds in stage
+ * @returns {Boolean}              Flag if stage is done
+ */
+function isStageDone(stageJobBuilds) {
     let stageIsDone = false;
 
     if (stageJobBuilds && stageJobBuilds.length !== 0) {
@@ -292,10 +300,13 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
 
         // Start stage teardown build if stage is done
         if (stageTeardownBuild && stageTeardownBuild.status === 'CREATED') {
-            const stageIsDone = await isStageDone({ stage, event: newEvent });
+            const stageJobBuilds = await getStageJobBuilds({ stage, event: newEvent });
+            const stageIsDone = isStageDone(stageJobBuilds);
 
             if (stageIsDone) {
                 stageTeardownBuild.status = 'QUEUED';
+                stageTeardownBuild.parentBuildId = stageJobBuilds.map(b => b.id);
+
                 await stageTeardownBuild.update();
                 await stageTeardownBuild.start();
             }

package/plugins/builds/index.js

@@ -39,8 +39,7 @@ const {
     getParallelBuilds,
     isStartFromMiddleOfCurrentStage,
     Status,
-    getSameParentEvents,
-    isVirtualJob
+    getSameParentEvents
 } = require('./triggers/helpers');
 const { getFullStageJobName } = require('../helper');
 
@@ -96,9 +95,11 @@ async function triggerNextJobs(config, app) {
 
     const downstreamOfNextJobsToBeProcessed = [];
 
-    for (const [nextJobName, nextJobInfo] of Object.entries(currentPipelineNextJobs)) {
+    for (const [nextJobName] of Object.entries(currentPipelineNextJobs)) {
         const nextJob = await getJob(nextJobName, currentPipeline.id, jobFactory);
-        const { stageName: nextJobStageName } = nextJobInfo;
+        const node = currentEvent.workflowGraph.nodes.find(n => n.name === trimJobName(nextJobName));
+        const isNextJobVirtual = node.virtual || false;
+        const nextJobStageName = node.stageName || null;
         const resource = `pipeline:${currentPipeline.id}:groupEvent:${currentEvent.groupEventId}`;
         let lock;
         let nextBuild;
@@ -124,12 +125,24 @@ async function triggerNextJobs(config, app) {
                 isOrTrigger(currentEvent.workflowGraph, originalCurrentJobName, trimJobName(nextJobName)) ||
                 isStartFromMiddleOfCurrentStage(currentJob.name, currentEvent.startFrom, currentEvent.workflowGraph)
             ) {
-                nextBuild = await orTrigger.execute(currentEvent, currentPipeline.id, nextJob, parentBuilds);
+                nextBuild = await orTrigger.execute(
+                    currentEvent,
+                    currentPipeline.id,
+                    nextJob,
+                    parentBuilds,
+                    isNextJobVirtual
+                );
             } else {
-                nextBuild = await andTrigger.execute(nextJob, parentBuilds, joinListNames, nextJobStageName);
+                nextBuild = await andTrigger.execute(
+                    nextJob,
+                    parentBuilds,
+                    joinListNames,
+                    isNextJobVirtual,
+                    nextJobStageName
+                );
             }
 
-            if (isVirtualJob(nextJob) && nextBuild && nextBuild.status === Status.SUCCESS) {
+            if (isNextJobVirtual && nextBuild && nextBuild.status === Status.SUCCESS) {
                 downstreamOfNextJobsToBeProcessed.push({
                     build: nextBuild,
                     event: currentEvent,
@@ -274,7 +287,9 @@ async function triggerNextJobs(config, app) {
         if (externalEvent) {
             for (const [nextJobName, nextJobInfo] of Object.entries(joinedPipeline.jobs)) {
                 const nextJob = await getJob(nextJobName, joinedPipelineId, jobFactory);
-                const { stageName: nextJobStageName } = nextJobInfo;
+                const node = externalEvent.workflowGraph.nodes.find(n => n.name === trimJobName(nextJobName));
+                const isNextJobVirtual = node.virtual || false;
+                const nextJobStageName = node.stageName || null;
 
                 const { parentBuilds } = parseJobInfo({
                     joinObj: joinedPipeline.jobs,
@@ -295,7 +310,8 @@ async function triggerNextJobs(config, app) {
                             externalEvent,
                             externalEvent.pipelineId,
                             nextJob,
-                            parentBuilds
+                            parentBuilds,
+                            isNextJobVirtual
                         );
                     } else {
                         // Re get join list when first time remote trigger since external event was empty and cannot get workflow graph then
@@ -311,11 +327,12 @@ async function triggerNextJobs(config, app) {
                             parentBuilds,
                             groupEventBuilds,
                             joinListNames,
+                            isNextJobVirtual,
                             nextJobStageName
                         );
                     }
 
-                    if (isVirtualJob(nextJob) && nextBuild && nextBuild.status === Status.SUCCESS) {
+                    if (isNextJobVirtual && nextBuild && nextBuild.status === Status.SUCCESS) {
                         downstreamOfNextJobsToBeProcessed.push({
                             build: nextBuild,
                             event: currentEvent,

package/plugins/builds/triggers/and.js

@@ -98,7 +98,6 @@ class AndTrigger extends JoinBase {
             nextBuild,
             nextJob,
             parentBuilds: newParentBuilds,
-            parentBuildId: this.currentBuild.id,
             joinListNames,
             isNextJobVirtual,
             nextJobStageName

package/plugins/builds/triggers/helpers.js

@@ -128,17 +128,6 @@ function isExternalTrigger(jobName) {
     return EXTERNAL_TRIGGER_ALL.test(jobName);
 }
 
-/**
- * Checks if job is virtual
- * @param {Job} job Job object
- * @returns {Boolean}
- */
-function isVirtualJob(job) {
-    const { annotations } = job.permutations[0];
-
-    return annotations ? annotations['screwdriver.cd/virtualJob'] === true : false;
-}
-
 /**
  * Checks if job has freezeWindows
  * @param {Job} job Job object
@@ -545,10 +534,9 @@ async function getBuildsForGroupEvent(groupEventId, buildFactory) {
  * @param {Object} arg
  * @param {ParentBuilds} arg.joinParentBuilds Parent builds object for join job
  * @param {Build} arg.nextBuild Next build
- * @param {Build} arg.build Build for current completed job
  * @returns {Promise<Build>} Updated next build
  */
-async function updateParentBuilds({ joinParentBuilds, nextBuild, build }) {
+async function updateParentBuilds({ joinParentBuilds, nextBuild }) {
     // Override old parentBuilds info
     const newParentBuilds = merge({}, joinParentBuilds, nextBuild.parentBuilds, (objVal, srcVal) =>
         // passthrough objects, else mergeWith mutates source
@@ -556,59 +544,69 @@ async function updateParentBuilds({ joinParentBuilds, nextBuild, build }) {
     );
 
     nextBuild.parentBuilds = newParentBuilds;
-    // nextBuild.parentBuildId may be int or Array, so it needs to be flattened
-    nextBuild.parentBuildId = Array.from(new Set([build.id, nextBuild.parentBuildId || []].flat()));
 
     return nextBuild.update();
 }
 
 /**
- * Check if all parent builds of the new build are done
- * @param {Object} arg
- * @param {Build} arg.newBuild Updated build
+ * Get builds in join list from parent builds
+ * @param {newBuild} arg.newBuild Updated build
  * @param {String[]} arg.joinListNames Join list names
  * @param {Number} arg.pipelineId Pipeline ID
  * @param {BuildFactory} arg.buildFactory Build factory
- * @returns {Promise<{hasFailure: Boolean, done: Boolean}>} Object with done and hasFailure statuses
+ * @returns {Promise<Map<String, Build>>} Join builds
  */
-async function getParentBuildStatus({ newBuild, joinListNames, pipelineId, buildFactory }) {
+async function getJoinBuilds({ newBuild, joinListNames, pipelineId, buildFactory }) {
     const upstream = newBuild.parentBuilds || {};
+    const joinBuilds = {};
 
-    // Get buildId
-    const joinBuildIds = joinListNames.map(name => {
+    for (const jobName of joinListNames) {
         let upstreamPipelineId = pipelineId;
-        let upstreamJobName = name;
+        let upstreamJobName = jobName;
 
-        if (isExternalTrigger(name)) {
-            const { externalPipelineId, externalJobName } = getExternalPipelineAndJob(name);
+        if (isExternalTrigger(upstreamJobName)) {
+            const { externalPipelineId, externalJobName } = getExternalPipelineAndJob(jobName);
 
             upstreamPipelineId = externalPipelineId;
             upstreamJobName = externalJobName;
         }
 
         if (upstream[upstreamPipelineId] && upstream[upstreamPipelineId].jobs[upstreamJobName]) {
-            return upstream[upstreamPipelineId].jobs[upstreamJobName];
+            const buildId = upstream[upstreamPipelineId].jobs[upstreamJobName];
+
+            const build = await buildFactory.get(buildId);
+
+            if (typeof build.endTime === 'string') {
+                build.endTime = new Date(build.endTime);
+            }
+
+            joinBuilds[jobName] = build;
         }
+    }
 
-        return undefined;
-    });
+    return joinBuilds;
+}
 
+/**
+ * Check if all parent builds of the new build are done
+ * @param {Object} arg
+ * @param {String[]} arg.joinListNames Join list names
+ * @param {String[]} arg.joinBuilds Join builds
+ * @returns {Promise<{hasFailure: Boolean, done: Boolean}>} Object with done and hasFailure statuses
+ */
+async function getParentBuildStatus({ joinListNames, joinBuilds }) {
     // If buildId is empty, the job hasn't executed yet and the join is not done
-    const isExecuted = !joinBuildIds.includes(undefined);
+    const isExecuted = joinListNames.every(name => joinBuilds[name] !== undefined);
+    const parentBuilds = Object.values(joinBuilds);
 
-    // Get the status of the builds
-    const buildIds = joinBuildIds.filter(buildId => buildId !== undefined);
-    const promisesToAwait = buildIds.map(buildId => buildFactory.get(buildId));
-    const joinedBuilds = await Promise.all(promisesToAwait);
-
-    const hasFailure = joinedBuilds
+    const hasFailure = parentBuilds
         .map(build => {
             // Do not need to run the next build; terminal status
             return [Status.FAILURE, Status.ABORTED, Status.COLLAPSED, Status.UNSTABLE].includes(build.status);
         })
         .includes(true);
 
-    const isDoneStatus = joinedBuilds.every(build => {
+    const isDoneStatus = parentBuilds.every(build => {
         // All builds are done
         return [Status.FAILURE, Status.SUCCESS, Status.ABORTED, Status.UNSTABLE, Status.COLLAPSED].includes(
             build.status
@@ -627,29 +625,40 @@ async function getParentBuildStatus({ newBuild, joinListNames, pipelineId, build
  *          if no failure, start new build
  * Otherwise, do nothing
  * @param {Object} arg If the build is done or not
- * @param {Boolean} arg.done If the build is done or not
- * @param {Boolean} arg.hasFailure If the build has a failure or not
+ * @param {String[]} arg.joinListNames Join list names
  * @param {Build} arg.newBuild Next build
  * @param {Job} arg.job Next job
  * @param {String|undefined} arg.pipelineId Pipeline ID
  * @param {String|undefined} arg.stageName Stage name
+ * @param {Boolean} arg.isVirtualJob If the job is virtual or not
  * @param {Event} arg.event Event
- * @param {Build} arg.currentBuild Current build
+ * @param {BuildFactory} arg.buildFactory Build factory
  * @returns {Promise<Build|null>} The newly updated/created build
  */
-async function handleNewBuild({ done, hasFailure, newBuild, job, pipelineId, stageName, event, currentBuild }) {
-    if (!done || Status.isStarted(newBuild.status)) {
-        // The virtual job does not inherit metadata because the Launcher is not executed.
-        // Therefore, it is necessary to take over the metadata from the previous build.
-
-        // TODO There is a bug when virtual job requires [a, b] and if "a" and "b" are completed simultaneously.
-        // https://github.com/screwdriver-cd/screwdriver/issues/3287
-        if (isVirtualJob(job) && !hasFreezeWindows(job)) {
-            newBuild.meta = merge({}, newBuild.meta, currentBuild.meta);
+async function handleNewBuild({
+    joinListNames,
+    newBuild,
+    job,
+    pipelineId,
+    stageName,
+    isVirtualJob,
+    event,
+    buildFactory
+}) {
+    const joinBuilds = await getJoinBuilds({
+        newBuild,
+        joinListNames,
+        pipelineId,
+        buildFactory
+    });
 
-            await newBuild.update();
-        }
+    /* CHECK IF ALL PARENT BUILDS OF NEW BUILD ARE DONE */
+    const { hasFailure, done } = await getParentBuildStatus({
+        joinBuilds,
+        joinListNames
+    });
 
+    if (!done || Status.isStarted(newBuild.status)) {
         return null;
     }
 
@@ -668,14 +677,28 @@ async function handleNewBuild({ done, hasFailure, newBuild, job, pipelineId, sta
         return null;
     }
 
+    /* Prepare to execute the build */
+    const parentBuilds = Object.values(joinBuilds);
+
+    parentBuilds.sort((l, r) => {
+        if (l.endTime && r.endTime) {
+            return l.endTime.getTime() - r.endTime.getTime();
+        }
+
+        // Move to tail if endTime is not set
+        return (l.endTime ? 0 : 1) - (r.endTime ? 0 : 1);
+    });
+    newBuild.parentBuildId = parentBuilds.map(build => build.id);
+
     // Bypass execution of the build if the job is virtual
-    if (isVirtualJob(job) && !hasFreezeWindows(job)) {
+    if (isVirtualJob && !hasFreezeWindows(job)) {
         newBuild.status = Status.SUCCESS;
         newBuild.statusMessage = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessage;
         newBuild.statusMessageType = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessageType;
+
         // The virtual job does not inherit metadata because the Launcher is not executed.
         // Therefore, it is necessary to take over the metadata from the previous build.
-        newBuild.meta = merge({}, newBuild.meta, currentBuild.meta);
+        newBuild.meta = parentBuilds.reduce((acc, build) => merge(acc, build.meta), {});
 
         return newBuild.update();
     }
@@ -934,9 +957,7 @@ async function createJoinObject(nextJobNames, current, eventFactory) {
             isExternal = true;
         }
 
-        const node = event.workflowGraph.nodes.find(n => n.name === trimJobName(jobName));
-        const jId = node.id;
-        const stageName = node.stageName || null;
+        const jId = event.workflowGraph.nodes.find(n => n.name === trimJobName(jobName)).id;
 
         if (!joinObj[nextJobPipelineId]) joinObj[nextJobPipelineId] = {};
         const pipelineObj = joinObj[nextJobPipelineId];
@@ -956,7 +977,7 @@ async function createJoinObject(nextJobNames, current, eventFactory) {
         }
 
         if (!pipelineObj.jobs) pipelineObj.jobs = {};
-        pipelineObj.jobs[nextJobName] = { id: jId, join: jobs, isExternal, stageName };
+        pipelineObj.jobs[nextJobName] = { id: jId, join: jobs, isExternal };
     }
 
     return joinObj;
@@ -1017,38 +1038,6 @@ async function ensureStageTeardownBuildExists({
     }
 }
 
-/**
- * Get parentBuildId from parentBuilds object
- * @param {Object} arg
- * @param {ParentBuilds} arg.parentBuilds Builds that triggered this build
- * @param {String[]} arg.joinListNames Array of join job name
- * @param {Number} arg.pipelineId Pipeline ID
- * @returns {String[]} Array of parentBuildId
- */
-function getParentBuildIds({ currentBuildId, parentBuilds, joinListNames, pipelineId }) {
-    const parentBuildIds = joinListNames
-        .map(name => {
-            let parentBuildPipelineId = pipelineId;
-            let parentBuildJobName = name;
-
-            if (isExternalTrigger(name)) {
-                const { externalPipelineId, externalJobName } = getExternalPipelineAndJob(name);
-
-                parentBuildPipelineId = externalPipelineId;
-                parentBuildJobName = externalJobName;
-            }
-
-            if (parentBuilds[parentBuildPipelineId] && parentBuilds[parentBuildPipelineId].jobs[parentBuildJobName]) {
-                return parentBuilds[parentBuildPipelineId].jobs[parentBuildJobName];
-            }
-
-            return null;
-        })
-        .filter(Boolean); // Remove undefined or null values
-
-    return Array.from(new Set([currentBuildId, ...parentBuildIds]));
-}
-
 /**
  * Extract a current pipeline's next jobs from pipeline join data
  * (Next jobs triggered as external are not included)
@@ -1208,13 +1197,13 @@ module.exports = {
     getSameParentEvents,
     mergeParentBuilds,
     updateParentBuilds,
+    getJoinBuilds,
     getParentBuildStatus,
     handleNewBuild,
     ensureStageTeardownBuildExists,
     getBuildsForGroupEvent,
     createJoinObject,
     createExternalEvent,
-    getParentBuildIds,
     strToInt,
     createEvent,
     deleteBuild,
@@ -1225,7 +1214,6 @@ module.exports = {
     buildsToRestartFilter,
     trimJobName,
     isStartFromMiddleOfCurrentStage,
-    isVirtualJob,
     hasFreezeWindows,
     BUILD_STATUS_MESSAGES
 };

package/plugins/builds/triggers/joinBase.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const logger = require('screwdriver-logger');
-const { createInternalBuild, updateParentBuilds, getParentBuildStatus, handleNewBuild } = require('./helpers');
+const { createInternalBuild, updateParentBuilds, handleNewBuild } = require('./helpers');
 
 /**
  * @typedef {import('screwdriver-models').EventFactory} EventFactory
@@ -41,8 +41,8 @@ class JoinBase {
      * @param {Build} nextBuild
      * @param {Job} nextJob
      * @param {import('./helpers').ParentBuilds} parentBuilds
-     * @param {String} parentBuildId
      * @param {String[]} joinListNames
+     * @param {Boolean} isNextJobVirtual
      * @param {String} nextJobStageName
      * @returns {Promise<Build[]|null>}
      */
@@ -52,8 +52,8 @@ class JoinBase {
         nextBuild,
         nextJob,
         parentBuilds,
-        parentBuildId,
         joinListNames,
+        isNextJobVirtual,
         nextJobStageName
     }) {
         let newBuild;
@@ -71,7 +71,7 @@ class JoinBase {
                 event, // this is the parentBuild for the next build
                 baseBranch: event.baseBranch || null,
                 parentBuilds,
-                parentBuildId,
+                parentBuildId: this.currentBuild.id,
                 start: false
             });
         } else {
@@ -88,23 +88,15 @@ class JoinBase {
             return null;
         }
 
-        /* CHECK IF ALL PARENT BUILDS OF NEW BUILD ARE DONE */
-        const { hasFailure, done } = await getParentBuildStatus({
-            newBuild,
-            joinListNames,
-            pipelineId,
-            buildFactory: this.buildFactory
-        });
-
         return handleNewBuild({
-            done,
-            hasFailure,
+            joinListNames,
             newBuild,
             job: nextJob,
             pipelineId,
+            isVirtualJob: isNextJobVirtual,
             stageName: nextJobStageName,
             event,
-            currentBuild: this.currentBuild
+            buildFactory: this.buildFactory
         });
     }
 }

package/plugins/builds/triggers/orBase.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const merge = require('lodash.mergewith');
-const { createInternalBuild, Status, BUILD_STATUS_MESSAGES, isVirtualJob, hasFreezeWindows } = require('./helpers');
+const { createInternalBuild, Status, BUILD_STATUS_MESSAGES, hasFreezeWindows } = require('./helpers');
 
 /**
  * @typedef {import('screwdriver-models').BuildFactory} BuildFactory
@@ -39,15 +39,15 @@ class OrBase {
      * @param {Number} pipelineId
      * @param {Job} nextJob
      * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @param {Boolean} isNextJobVirtual
      * @return {Promise<Build|null>}
      */
-    async trigger(event, pipelineId, nextJob, parentBuilds) {
+    async trigger(event, pipelineId, nextJob, parentBuilds, isNextJobVirtual) {
         let nextBuild = await this.buildFactory.get({
             eventId: event.id,
             jobId: nextJob.id
         });
 
-        const isNextJobVirtual = isVirtualJob(nextJob);
         const hasWindows = hasFreezeWindows(nextJob);
         const causeMessage = nextJob.name === event.startFrom ? event.causeMessage : '';
 
@@ -56,12 +56,16 @@ class OrBase {
                 return nextBuild;
             }
 
+            nextBuild.parentBuildId = [this.currentBuild.id];
+
             // Bypass execution of the build if the job is virtual
             if (isNextJobVirtual && !hasWindows) {
                 nextBuild.status = Status.SUCCESS;
                 nextBuild.statusMessage = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessage;
                 nextBuild.statusMessageType = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessageType;
-                nextBuild.meta = merge({}, nextBuild.meta, this.currentBuild.meta);
+
+                // Overwrite metadata by current build's
+                nextBuild.meta = merge({}, this.currentBuild.meta);
 
                 return nextBuild.update();
             }
@@ -93,7 +97,9 @@ class OrBase {
             nextBuild.status = Status.SUCCESS;
             nextBuild.statusMessage = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessage;
             nextBuild.statusMessageType = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessageType;
-            nextBuild.meta = merge({}, nextBuild.meta, this.currentBuild.meta);
+
+            // Overwrite metadata by current build's
+            nextBuild.meta = merge({}, this.currentBuild.meta);
 
             await nextBuild.update();
         }

package/plugins/builds/triggers/remoteJoin.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { mergeParentBuilds, getParentBuildIds } = require('./helpers');
+const { mergeParentBuilds } = require('./helpers');
 const { JoinBase } = require('./joinBase');
 
 /**
@@ -45,20 +45,12 @@ class RemoteJoin extends JoinBase {
 
         const newParentBuilds = mergeParentBuilds(parentBuilds, groupEventBuilds, this.currentEvent, externalEvent);
 
-        const parentBuildId = getParentBuildIds({
-            currentBuildId: this.currentBuild.id,
-            parentBuilds: newParentBuilds,
-            joinListNames,
-            pipelineId: externalEvent.pipelineId
-        });
-
         return this.processNextBuild({
             pipelineId: externalEvent.pipelineId,
             event: externalEvent,
             nextBuild,
             nextJob,
             parentBuilds: newParentBuilds,
-            parentBuildId,
             joinListNames,
             isNextJobVirtual,
             nextJobStageName

package/plugins/jobs/buildCluster/update.js

@@ -74,7 +74,7 @@ module.exports = () => ({
 
             permutation.annotations = permutation.annotations || {};
 
-            const annotations = permutation.annotations;
+            const { annotations } = permutation;
 
             if (annotations[adminAnnotation]) {
                 logger.info(