screwdriver-api 7.0.69 → 7.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "7.0.69",
+  "version": "7.0.71",
   "description": "API server for the Screwdriver.cd service",
   "main": "index.js",
   "scripts": {
@@ -114,7 +114,7 @@
     "screwdriver-executor-queue": "^4.0.0",
     "screwdriver-executor-router": "^3.0.0",
     "screwdriver-logger": "^2.0.0",
-    "screwdriver-models": "^29.14.1",
+    "screwdriver-models": "^29.17.2",
     "screwdriver-notifications-email": "^3.0.0",
     "screwdriver-notifications-slack": "^5.0.0",
     "screwdriver-request": "^2.0.1",

package/plugins/builds/index.js

@@ -20,6 +20,7 @@ const tokenRoute = require('./token');
 const metricsRoute = require('./metrics');
 const { EXTERNAL_TRIGGER_ALL } = schema.config.regex;
 const locker = require('../lock');
+const { getFullStageJobName } = require('../helper');
 
 /**
  * Checks if job is external trigger
@@ -230,7 +231,7 @@ async function createExternalBuild(config) {
  * @param  {String}   [config.jobName]          Job name
  * @param  {String}   config.username           Username of build
  * @param  {String}   config.scmContext         SCM context
- * @param  {Object}   config.parentBuilds       Builds that triggered this build
+ * @param  {Object}   [config.parentBuilds]     Builds that triggered this build
  * @param  {String}   config.baseBranch         Branch name
  * @param  {Number}   [config.parentBuildId]    Parent build ID
  * @param  {Boolean}  [config.start]            Whether to start the build or not
@@ -272,6 +273,7 @@ async function createInternalBuild(config) {
     } else {
         job = await jobFactory.get(jobId);
     }
+
     const internalBuildConfig = {
         jobId: job.id,
         sha: event.sha,
@@ -526,9 +528,10 @@ async function getParentBuildStatus({ newBuild, joinListNames, pipelineId, build
  * @param  {Build}   newBuild       Next build
  * @param  {String}  [jobName]      Job name
  * @param  {String}  [pipelineId]   Pipeline ID
+ * @param  {Object}  [stage]        Stage
  * @return {Promise}                The newly updated/created build
  */
-async function handleNewBuild({ done, hasFailure, newBuild, jobName, pipelineId }) {
+async function handleNewBuild({ done, hasFailure, newBuild, jobName, pipelineId, stage }) {
     if (!done) {
         return null;
     }
@@ -538,10 +541,19 @@ async function handleNewBuild({ done, hasFailure, newBuild, jobName, pipelineId
 
     // Delete new build since previous build failed
     if (hasFailure) {
-        logger.info(
-            `Failure occurred in upstream job, removing new build - build:${newBuild.id} pipeline:${pipelineId}-${jobName} event:${newBuild.eventId} `
-        );
-        await newBuild.remove();
+        let stageTeardownName = '';
+
+        if (stage) {
+            stageTeardownName = getFullStageJobName({ stageName: stage.name, jobName: 'teardown' });
+        }
+
+        // New build is not stage teardown job
+        if (jobName !== stageTeardownName) {
+            logger.info(
+                `Failure occurred in upstream job, removing new build - build:${newBuild.id} pipeline:${pipelineId}-${jobName} event:${newBuild.eventId} `
+            );
+            await newBuild.remove();
+        }
 
         return null;
     }
@@ -709,6 +721,89 @@ function getParentBuildIds({ currentBuildId, parentBuilds, joinListNames, pipeli
     return Array.from(new Set([currentBuildId, ...parentBuildIds]));
 }
 
+/**
+ * Create stage teardown build if it doesn't already exist
+ * @param  {Factory}    jobFactory                      Job factory
+ * @param  {Factory}    buildFactory                    Build factory
+ * @param  {Object}     current                         Current object
+ * @param  {String}     stageTeardownName               Stage teardown name
+ * @param  {String}     username                        Username
+ * @param  {String}     scmContext                      SCM context
+ */
+async function ensureStageTeardownBuildExists({
+    jobFactory,
+    buildFactory,
+    current,
+    stageTeardownName,
+    username,
+    scmContext
+}) {
+    // Check if stage teardown build already exists
+    const stageTeardownJob = await jobFactory.get({
+        pipelineId: current.pipeline.id,
+        name: stageTeardownName
+    });
+    const existingStageTeardownBuild = await buildFactory.get({
+        eventId: current.event.id,
+        jobId: stageTeardownJob.id
+    });
+
+    // Doesn't exist, create stage teardown job
+    if (!existingStageTeardownBuild) {
+        await createInternalBuild({
+            jobFactory,
+            buildFactory,
+            pipelineId: current.pipeline.id,
+            jobName: stageTeardownName,
+            username,
+            scmContext,
+            event: current.event, // this is the parentBuild for the next build
+            baseBranch: current.event.baseBranch || null,
+            start: false
+        });
+    }
+}
+
+/**
+ * Delete nextBuild, create teardown build if it doesn't exist, and return teardown build or return null
+ * @param  {String}  nextJobName                  Next job name
+ * @param  {Object}  current                      Object with stage, event, pipeline info
+ * @param  {Object}  buildConfig                  Build config
+ * @param  {Factory} jobFactory                   Job factory
+ * @param  {Factory} buildFactory                 Build factory
+ * @param  {String}  username                     Username
+ * @param  {String}  scmContext                   Scm context
+ * @return {Array}                                Array of promises
+ */
+async function handleStageFailure({
+    nextJobName,
+    current,
+    buildConfig,
+    jobFactory,
+    buildFactory,
+    username,
+    scmContext
+}) {
+    const buildDeletePromises = [];
+    const stageTeardownName = getFullStageJobName({ stageName: current.stage.name, jobName: 'teardown' });
+
+    // Remove next build
+    if (buildConfig.eventId && nextJobName !== stageTeardownName) {
+        buildDeletePromises.push(deleteBuild(buildConfig, buildFactory));
+    }
+
+    await ensureStageTeardownBuildExists({
+        jobFactory,
+        buildFactory,
+        current,
+        stageTeardownName,
+        username,
+        scmContext
+    });
+
+    return buildDeletePromises;
+}
+
 /**
  * Build API Plugin
  * @method register
@@ -732,21 +827,19 @@ const buildsPlugin = {
          * @return {Promise}                        Resolves to the removed build or null
          */
         server.expose('removeJoinBuilds', async (config, app) => {
-            const { pipeline, job, build } = config;
-            const { eventFactory, buildFactory } = app;
-            const event = await eventFactory.get({ id: build.eventId });
+            const { pipeline, job, build, username, scmContext, event, stage } = config;
+            const { eventFactory, buildFactory, jobFactory } = app;
             const current = {
                 pipeline,
                 job,
                 build,
-                event
+                event,
+                stage
             };
-
             const nextJobsTrigger = workflowParser.getNextJobs(current.event.workflowGraph, {
                 trigger: current.job.name,
                 chainPR: pipeline.chainPR
             });
-
             const pipelineJoinData = await createJoinObject(nextJobsTrigger, current, eventFactory);
             const buildConfig = {};
             const deletePromises = [];
@@ -765,7 +858,20 @@ const buildsPlugin = {
                             buildConfig.eventId = hoek.reach(pipelineJoinData[pid], 'event.id');
                         }
 
-                        if (buildConfig.eventId) {
+                        //   if nextBuild is stage teardown, just return nextBuild
+                        if (current.stage) {
+                            const buildDeletePromises = await handleStageFailure({
+                                nextJobName,
+                                current,
+                                buildConfig,
+                                jobFactory,
+                                buildFactory,
+                                username,
+                                scmContext
+                            });
+
+                            deletePromises.concat(buildDeletePromises);
+                        } else if (buildConfig.eventId) {
                             deletePromises.push(deleteBuild(buildConfig, buildFactory));
                         }
                     } catch (err) {
@@ -776,6 +882,7 @@ const buildsPlugin = {
                     }
                 }
             }
+
             await Promise.all(deletePromises);
         });
 
@@ -810,21 +917,20 @@ const buildsPlugin = {
          * @return {Promise}                        Resolves to the newly created build or null
          */
         server.expose('triggerNextJobs', async (config, app) => {
-            const { pipeline, job, build } = config;
+            const { pipeline, job, build, event, stage } = config;
             const { eventFactory, pipelineFactory, buildFactory, jobFactory } = app;
-            const event = await eventFactory.get({ id: build.eventId });
             const current = {
                 pipeline,
                 job,
                 build,
-                event
+                event,
+                stage
             };
 
             const nextJobsTrigger = workflowParser.getNextJobs(current.event.workflowGraph, {
                 trigger: current.job.name,
                 chainPR: pipeline.chainPR
             });
-
             const pipelineJoinData = await createJoinObject(nextJobsTrigger, current, eventFactory);
 
             // Helper function to handle triggering jobs in same pipeline
@@ -877,12 +983,14 @@ const buildsPlugin = {
                         return existNextBuild;
                     }
 
+                    // Current build is not part of stage
                     existNextBuild.status = 'QUEUED';
                     await existNextBuild.update();
 
                     return existNextBuild.start();
                 }
 
+                // Handle join case. Fan-out/fan-in Workflow
                 logger.info(`Fetching finished builds for event ${event.id}`);
                 let finishedInternalBuilds = await getFinishedBuilds(current.event, buildFactory);
 
@@ -967,7 +1075,8 @@ const buildsPlugin = {
                     hasFailure,
                     newBuild,
                     jobName: nextJobName,
-                    pipelineId: current.pipeline.id
+                    pipelineId: current.pipeline.id,
+                    stage: current.stage
                 });
             };
 
@@ -1107,7 +1216,8 @@ const buildsPlugin = {
                                 hasFailure,
                                 newBuild,
                                 jobName: nextJobName,
-                                pipelineId: externalPipelineId
+                                pipelineId: externalPipelineId,
+                                stage: current.stage
                             });
                         }
                     }
@@ -1163,6 +1273,7 @@ const buildsPlugin = {
                         await locker.unlock(lock, resource);
                     }
                 }
+
                 if (triggerCurrentPipelineAsExternal || !isCurrentPipeline) {
                     let resource;
                     let lock;

package/plugins/builds/update.js

@@ -5,7 +5,10 @@ const hoek = require('@hapi/hoek');
 const schema = require('screwdriver-data-schema');
 const joi = require('joi');
 const idSchema = schema.models.build.base.extract('id');
-const { getScmUri, getUserPermissions } = require('../helper');
+const { getScmUri, getUserPermissions, getFullStageJobName } = require('../helper');
+const STAGE_TEARDOWN_PATTERN = /^stage@([\w-]+)(?::teardown)$/;
+const TERMINAL_STATUSES = ['FAILURE', 'ABORTED', 'UNSTABLE', 'COLLAPSED'];
+const FINISHED_STATUSES = ['FAILURE', 'SUCCESS', 'ABORTED', 'UNSTABLE', 'COLLAPSED'];
 
 /**
  * Identify whether this build resulted in a previously failed job to become successful.
@@ -124,7 +127,7 @@ async function validateUserPermission(build, request) {
 }
 
 /**
- *
+ * Set build status to desired status, set build statusMessage
  * @param {Object} build         Build Model
  * @param {String} desiredStatus New Status
  * @param {String} statusMessage User passed status message
@@ -155,6 +158,51 @@ function updateBuildStatus(build, desiredStatus, statusMessage, username) {
     }
 }
 
+/**
+ * Get stage for current node
+ * @param  {StageFactory}   stageFactory                Stage factory
+ * @param  {Object}         workflowGraph               Workflow graph
+ * @param  {String}         jobName                     Job name
+ * @param  {Number}         pipelineId                  Pipeline ID
+ * @return {Stage}                                      Stage for node
+ */
+async function getStage({ stageFactory, workflowGraph, jobName, pipelineId }) {
+    const currentNode = workflowGraph.nodes.find(node => node.name === jobName);
+    let stage = null;
+
+    if (currentNode && currentNode.stageName) {
+        stage = await stageFactory.get({
+            pipelineId,
+            name: currentNode.stageName
+        });
+    }
+
+    return Promise.resolve(stage);
+}
+
+/**
+ * Checks if all builds in stage are done running
+ * @param  {Object}     stage                     Stage
+ * @param  {Object}     event                     Event
+ * @return {Boolean}              Flag if stage is done
+ */
+async function isStageDone({ stage, event }) {
+    // Get all jobIds for jobs in the stage
+    const stageJobIds = stage.jobIds;
+
+    stageJobIds.push(stage.setup);
+
+    // Get all builds in a stage for this event
+    const stageJobBuilds = await event.getBuilds({ params: { jobId: stageJobIds } });
+    let stageIsDone = false;
+
+    if (stageJobBuilds && stageJobBuilds.length !== 0) {
+        stageIsDone = !stageJobBuilds.some(b => !FINISHED_STATUSES.includes(b.status));
+    }
+
+    return stageIsDone;
+}
+
 module.exports = () => ({
     method: 'PUT',
     path: '/builds/{id}',
@@ -168,13 +216,14 @@ module.exports = () => ({
         },
 
         handler: async (request, h) => {
-            const { buildFactory, eventFactory, jobFactory } = request.server.app;
+            const { buildFactory, eventFactory, jobFactory, stageFactory, stageBuildFactory } = request.server.app;
             const { id } = request.params;
             const { statusMessage, stats, status: desiredStatus } = request.payload;
             const { username, scmContext, scope } = request.auth.credentials;
             const isBuild = scope.includes('build') || scope.includes('temporal');
             const { triggerNextJobs, removeJoinBuilds } = request.server.plugins.builds;
 
+            // Check token permissions
             if (isBuild && username !== id) {
                 return boom.forbidden(`Credential only valid for ${username}`);
             }
@@ -226,7 +275,6 @@ module.exports = () => ({
             }
 
             const [newBuild, newEvent] = await Promise.all([build.update(), event.update(), stopFrozen]);
-
             const job = await newBuild.job;
             const pipeline = await job.pipeline;
 
@@ -245,16 +293,74 @@ module.exports = () => ({
 
             const skipFurther = /\[(skip further)\]/.test(newEvent.causeMessage);
 
-            // Guard against triggering non-successful or unstable builds
-            // Don't further trigger pipeline if intented to skip further jobs
+            // Update stageBuild status if it has changed;
+            // if stageBuild status is currently terminal, do not update
+            const stage = await getStage({
+                stageFactory,
+                workflowGraph: newEvent.workflowGraph,
+                jobName: job.name,
+                pipelineId: pipeline.id
+            });
+            const isStageTeardown = STAGE_TEARDOWN_PATTERN.test(job.name);
+            let stageBuildHasFailure = false;
+
+            if (stage) {
+                const stageBuild = await stageBuildFactory.get({
+                    stageId: stage.id,
+                    eventId: newEvent.id
+                });
+
+                if (stageBuild.status !== newBuild.status) {
+                    if (!TERMINAL_STATUSES.includes(stageBuild.status)) {
+                        stageBuild.status = newBuild.status;
+                        await stageBuild.update();
+                    }
+                }
 
+                stageBuildHasFailure = TERMINAL_STATUSES.includes(stageBuild.status);
+            }
+
+            // Guard against triggering non-successful or unstable builds
+            // Don't further trigger pipeline if intend to skip further jobs
             if (newBuild.status !== 'SUCCESS' || skipFurther) {
                 // Check for failed jobs and remove any child jobs in created state
                 if (newBuild.status === 'FAILURE') {
-                    await removeJoinBuilds({ pipeline, job, build: newBuild }, request.server.app);
+                    await removeJoinBuilds(
+                        { pipeline, job, build: newBuild, username, scmContext, event: newEvent, stage },
+                        request.server.app
+                    );
                 }
+                // Do not continue downstream is current job is stage teardown and statusBuild has failure
+            } else if (newBuild.status === 'SUCCESS' && isStageTeardown && stageBuildHasFailure) {
+                await removeJoinBuilds(
+                    { pipeline, job, build: newBuild, username, scmContext, event: newEvent, stage },
+                    request.server.app
+                );
             } else {
-                await triggerNextJobs({ pipeline, job, build: newBuild, username, scmContext }, request.server.app);
+                await triggerNextJobs(
+                    { pipeline, job, build: newBuild, username, scmContext, event: newEvent, stage },
+                    request.server.app
+                );
+            }
+
+            // Determine if stage teardown build should start
+            // (if stage teardown build exists, and stageBuild.status is negative,
+            // and there are no active stage builds, and teardown build is not started)
+            if (stage && FINISHED_STATUSES.includes(newBuild.status)) {
+                const stageTeardownName = getFullStageJobName({ stageName: stage.name, jobName: 'teardown' });
+                const stageTeardownJob = await jobFactory.get({ pipelineId: pipeline.id, name: stageTeardownName });
+                const stageTeardownBuild = await buildFactory.get({ eventId: newEvent.id, jobId: stageTeardownJob.id });
+
+                // Start stage teardown build if stage is done
+                if (stageTeardownBuild && stageTeardownBuild.status === 'CREATED') {
+                    const stageIsDone = await isStageDone({ stage, event: newEvent });
+
+                    if (stageIsDone) {
+                        stageTeardownBuild.status = 'QUEUED';
+                        await stageTeardownBuild.update();
+                        await stageTeardownBuild.start();
+                    }
+                }
             }
 
             return h.response(await newBuild.toJsonWithSteps()).code(200);

package/plugins/helper.js

@@ -2,6 +2,7 @@
 
 const boom = require('@hapi/boom');
 const dayjs = require('dayjs');
+const STAGE_PREFIX = 'stage@';
 
 /**
  * Set default start time and end time
@@ -102,10 +103,21 @@ async function getScmUri({ pipeline, pipelineFactory }) {
     return scmUri;
 }
 
+/**
+ * Returns full stage name with correct formatting and setup or teardown suffix (e.g. stage@deploy:setup)
+ * @param  {String} stageName               Stage name
+ * @param  {String} type                    Type of stage job, either 'setup' or 'teardown'
+ * @return {String}                         Full stage name
+ */
+function getFullStageJobName({ stageName, jobName }) {
+    return `${STAGE_PREFIX}${stageName}:${jobName}`;
+}
+
 module.exports = {
     getReadOnlyInfo,
     getScmUri,
     getUserPermissions,
     setDefaultTimeRange,
-    validTimeRange
+    validTimeRange,
+    getFullStageJobName
 };

package/plugins/pipelines/README.md

@@ -122,8 +122,6 @@ Only PR events of specified PR number will be searched when `prNum` is set
 
 `GET /pipelines/{id}/stages`
 
-`GET /pipelines/{id}/stages?eventId={eventId}`
-
 #### Get all pipeline secrets
 
 `GET /pipelines/{id}/secrets`

package/plugins/pipelines/templates/get.js

@@ -18,8 +18,6 @@ module.exports = () => ({
             scope: ['user', 'build']
         },
         handler: async (request, h) => {
-            console.log('request.params', request.params);
-
             const { namespace, name } = request.params;
             const { pipelineTemplateFactory } = request.server.app;