screwdriver-api 8.0.83 → 8.0.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "8.0.83",
+  "version": "8.0.84",
   "description": "API server for the Screwdriver.cd service",
   "main": "index.js",
   "scripts": {

package/plugins/builds/helper/updateBuild.js

@@ -5,7 +5,7 @@ const hoek = require('@hapi/hoek');
 const merge = require('lodash.mergewith');
 const { PR_JOB_NAME, PR_STAGE_NAME, STAGE_TEARDOWN_PATTERN } = require('screwdriver-data-schema').config.regex;
 const { getFullStageJobName } = require('../../helper');
-const { updateVirtualBuildSuccess } = require('../triggers/helpers');
+const { updateVirtualBuildSuccess, emitBuildStatusEvent } = require('../triggers/helpers');
 const TERMINAL_STATUSES = ['FAILURE', 'ABORTED', 'UNSTABLE', 'COLLAPSED'];
 const FINISHED_STATUSES = ['SUCCESS', ...TERMINAL_STATUSES];
 const NON_TERMINATED_STATUSES = ['CREATED', 'RUNNING', 'QUEUED', 'BLOCKED', 'FROZEN'];
@@ -60,25 +60,6 @@ function stopBuilds(builds, statusMessage) {
     return { unchangedBuilds, changedBuilds };
 }
 
-/**
- * Identify whether this build resulted in a previously failed job to become successful.
- *
- * @method isFixedBuild
- * @param  {Build}          build       Build Object
- * @param  {JobFactory}     jobFactory  Job Factory instance
- */
-async function isFixedBuild(build, jobFactory) {
-    if (build.status !== 'SUCCESS') {
-        return false;
-    }
-
-    const job = await jobFactory.get(build.jobId);
-    const failureBuild = await job.getLatestBuild({ status: 'FAILURE' });
-    const successBuild = await job.getLatestBuild({ status: 'SUCCESS' });
-
-    return !!((failureBuild && !successBuild) || failureBuild.id > successBuild.id);
-}
-
 /**
  * Stops a frozen build from executing
  *
@@ -405,7 +386,6 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
         throw boom.badRequest(`Cannot update builds to ${desiredStatus}`);
     }
 
-    let isFixed = Promise.resolve(false);
     let stopFrozen = null;
 
     // If the event is Aborted, check if there are any builds within the same event
@@ -429,7 +409,6 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
         await updateInitStep(build, server.app);
     } else {
         stopFrozen = stopFrozenBuild(build, currentStatus);
-        isFixed = isFixedBuild(build, jobFactory);
     }
 
     const [newBuild, newEvent] = await Promise.all([build.update(), event.update(), stopFrozen]);
@@ -437,16 +416,7 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
     const pipeline = await job.pipeline;
 
     if (desiredStatus) {
-        await server.events.emit('build_status', {
-            settings: job.permutations[0].settings,
-            status: newBuild.status,
-            event: newEvent.toJson(),
-            pipeline: pipeline.toJson(),
-            jobName: job.name,
-            build: newBuild.toJson(),
-            buildLink: `${buildFactory.uiUri}/pipelines/${pipeline.id}/builds/${build.id}`,
-            isFixed: await isFixed
-        });
+        await emitBuildStatusEvent({ server, build: newBuild, pipeline, event: newEvent, job });
     }
 
     const skipFurther = /\[(skip further)\]/.test(newEvent.causeMessage);
@@ -485,7 +455,7 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
     } else if (newBuild.status === 'SUCCESS' && isStageTeardown && stageBuildHasFailure) {
         await removeJoinBuilds({ pipeline, job, build: newBuild, event: newEvent, stage }, server.app);
     } else {
-        await triggerNextJobs({ pipeline, job, build: newBuild, username, scmContext, event: newEvent }, server.app);
+        await triggerNextJobs({ pipeline, job, build: newBuild, username, scmContext, event: newEvent }, server);
     }
 
     // Determine if stage teardown build should start
@@ -520,7 +490,13 @@ async function updateBuildAndTriggerDownstreamJobs(config, build, server, userna
                 stageTeardownBuild.parentBuildId = stageJobBuilds.map(b => b.id);
 
                 if (teardownNode && teardownNode.virtual) {
-                    await updateVirtualBuildSuccess(stageTeardownBuild);
+                    await updateVirtualBuildSuccess({
+                        server,
+                        build: stageTeardownBuild,
+                        pipeline,
+                        event: newEvent,
+                        job: stageTeardownJob
+                    });
                     await updateStageBuildStatus({ stageBuild, newStatus: 'SUCCESS', job: stageTeardownJob });
                 } else {
                     stageTeardownBuild.status = 'QUEUED';

package/plugins/builds/index.js

@@ -65,14 +65,15 @@ async function deleteBuild(buildConfig, buildFactory) {
 /**
  * Trigger the next jobs of the current job
  * @param { import('./types/index').ServerConfig }  config  Configuration object
- * @param { import('./types/index').ServerApp }     app     Server app object
+ * @param { Object }                                server     Server object
+ * @param { import('./types/index').ServerApp }     server.app     Server app object
  * @return {Promise<null>}                                  Resolves to the newly created build or null
  */
-async function triggerNextJobs(config, app) {
+async function triggerNextJobs(config, server) {
     const currentPipeline = config.pipeline;
     const currentJob = config.job;
     const currentBuild = config.build;
-    const { jobFactory, buildFactory, eventFactory, pipelineFactory, stageFactory, stageBuildFactory } = app;
+    const { jobFactory, buildFactory, eventFactory, pipelineFactory, stageFactory, stageBuildFactory } = server.app;
 
     /** @type {EventModel} */
     const currentEvent = await eventFactory.get({ id: currentBuild.eventId });
@@ -92,8 +93,8 @@ async function triggerNextJobs(config, app) {
 
     // Trigger OrTrigger and AndTrigger for current pipeline jobs.
     // Helper function to handle triggering jobs in same pipeline
-    const orTrigger = new OrTrigger(app, config);
-    const andTrigger = new AndTrigger(app, config, currentEvent);
+    const orTrigger = new OrTrigger(server, config);
+    const andTrigger = new AndTrigger(server, config, currentEvent);
     const currentPipelineNextJobs = extractCurrentPipelineJoinData(pipelineJoinData, currentPipeline.id);
 
     const downstreamOfNextJobsToBeProcessed = [];
@@ -155,7 +156,8 @@ async function triggerNextJobs(config, app) {
                     eventId: currentEvent.id
                 });
 
-                if (stageBuild) {
+                // The next build is only created (not started) when nextBuild is null
+                if (stageBuild && nextBuild) {
                     await updateStageBuildStatus({ stageBuild, newStatus: nextBuild.status, job: nextJob });
                 }
 
@@ -182,8 +184,8 @@ async function triggerNextJobs(config, app) {
 
     // Trigger RemoteJoin and RemoteTrigger for current and external pipeline jobs.
     // Helper function to handle triggering jobs in external pipeline
-    const remoteTrigger = new RemoteTrigger(app, config);
-    const remoteJoin = new RemoteJoin(app, config, currentEvent);
+    const remoteTrigger = new RemoteTrigger(server, config);
+    const remoteJoin = new RemoteJoin(server, config, currentEvent);
     const externalPipelineJoinData = extractExternalJoinData(pipelineJoinData, currentPipeline.id);
 
     for (const [joinedPipelineId, joinedPipeline] of Object.entries(externalPipelineJoinData)) {
@@ -389,7 +391,7 @@ async function triggerNextJobs(config, app) {
     }
 
     for (const nextConfig of downstreamOfNextJobsToBeProcessed) {
-        await triggerNextJobs(nextConfig, app);
+        await triggerNextJobs(nextConfig, server);
     }
 
     return null;

package/plugins/builds/triggers/helpers.js

@@ -606,19 +606,67 @@ async function getParentBuildStatus({ joinListNames, joinBuilds }) {
     return { hasFailure, done };
 }
 
+/**
+ * Emit 'build_status' event to notify
+ * @param {Object} arg
+ * @param {Object} arg.server Server object
+ * @param {Build} arg.build Build
+ * @param {Pipeline} [arg.pipeline] Pipeline
+ * @param {Event} [arg.event] Event
+ * @param {Job} [arg.job] Job
+ * @returns {Promise}
+ */
+async function emitBuildStatusEvent({ server, build, pipeline, event, job }) {
+    const { buildFactory } = server.app;
+
+    event = event || (await build.event); // eslint-disable-line no-param-reassign
+    job = job || (await build.job); // eslint-disable-line no-param-reassign
+    pipeline = pipeline || (await job.pipeline); // eslint-disable-line no-param-reassign
+
+    let isFixed = false;
+
+    if (build.status === Status.SUCCESS) {
+        const failureBuild = await job.getLatestBuild({ status: Status.FAILURE });
+        const successBuild = await job.getLatestBuild({ status: Status.SUCCESS });
+
+        // Identify whether this build resulted in a previously failed job to become successful.
+        isFixed = !!((failureBuild && !successBuild) || failureBuild.id > successBuild.id);
+    }
+
+    return server.events.emit('build_status', {
+        settings: job.permutations[0].settings,
+        status: build.status,
+        event: event.toJson(),
+        pipeline: pipeline.toJson(),
+        jobName: job.name,
+        build: build.toJson(),
+        buildLink: `${buildFactory.uiUri}/pipelines/${pipeline.id}/builds/${build.id}`,
+        isFixed
+    });
+}
+
 /**
  * Update virtual build status to SUCCESS and init metadata
- * @param {Build} build
+ * @param {Object} arg
+ * @param {Object} arg.server Server object
+ * @param {Build} arg.build Build
+ * @param {Pipeline} [arg.pipeline] Pipeline
+ * @param {Event} [arg.event] Event
+ * @param {Job} [arg.job] Job
  * @returns {Promise<Build>}
  */
-async function updateVirtualBuildSuccess(build) {
+async function updateVirtualBuildSuccess({ server, build, pipeline, event, job }) {
     build.status = Status.SUCCESS;
     build.statusMessage = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessage;
     build.statusMessageType = BUILD_STATUS_MESSAGES.SKIP_VIRTUAL_JOB.statusMessageType;
 
     await build.initMeta();
 
-    return build.update();
+    const newBuild = await build.update();
+
+    await emitBuildStatusEvent({ server, build: newBuild, pipeline, event, job });
+
+    return newBuild;
 }
 
 /**
@@ -628,6 +676,7 @@ async function updateVirtualBuildSuccess(build) {
  *          if no failure, start new build
  * Otherwise, do nothing
  * @param {Object} arg If the build is done or not
+ * @param {Object} arg.server Server object
  * @param {String[]} arg.joinListNames Join list names
  * @param {Build} arg.newBuild Next build
  * @param {Job} arg.job Next job
@@ -639,6 +688,7 @@ async function updateVirtualBuildSuccess(build) {
  * @returns {Promise<Build|null>} The newly updated/created build
  */
 async function handleNewBuild({
+    server,
     joinListNames,
     newBuild,
     job,
@@ -687,7 +737,7 @@ async function handleNewBuild({
 
     // Bypass execution of the build if the job is virtual
     if (isVirtualJob && !hasFreezeWindows(job)) {
-        return updateVirtualBuildSuccess(newBuild);
+        return updateVirtualBuildSuccess({ server, build: newBuild, event, job });
     }
 
     // All join builds finished successfully, and it's clear that a new build has not been started before.
@@ -1203,6 +1253,7 @@ module.exports = {
     getJoinBuilds,
     getParentBuildStatus,
     handleNewBuild,
+    emitBuildStatusEvent,
     ensureStageTeardownBuildExists,
     getBuildsForGroupEvent,
     createJoinObject,

package/plugins/builds/triggers/joinBase.js

@@ -14,19 +14,20 @@ const { createInternalBuild, updateParentBuilds, handleNewBuild } = require('./h
 class JoinBase {
     /**
      * Base class for AND trigger and RemoteJoin
-     * @param {Object} app Server app object
-     * @param {EventFactory} app.eventFactory Server app object
-     * @param {BuildFactory} app.buildFactory Server app object
-     * @param {JobFactory} app.jobFactory Server app object
+     * @param {Object} server Server object
+     * @param {EventFactory} server.app.eventFactory Server app object
+     * @param {BuildFactory} server.app.buildFactory Server app object
+     * @param {JobFactory} server.app.jobFactory Server app object
      * @param {Object} config Configuration object
      * @param {Build} config.build
      * @param {String} config.username
      * @param {String} config.scmContext
      */
-    constructor(app, config) {
-        this.eventFactory = app.eventFactory;
-        this.buildFactory = app.buildFactory;
-        this.jobFactory = app.jobFactory;
+    constructor(server, config) {
+        this.server = server;
+        this.eventFactory = server.app.eventFactory;
+        this.buildFactory = server.app.buildFactory;
+        this.jobFactory = server.app.jobFactory;
 
         this.currentBuild = config.build;
         this.username = config.username;
@@ -89,6 +90,7 @@ class JoinBase {
         }
 
         return handleNewBuild({
+            server: this.server,
             joinListNames,
             newBuild,
             job: nextJob,

package/plugins/builds/triggers/orBase.js

@@ -13,19 +13,20 @@ const { createInternalBuild, Status, updateVirtualBuildSuccess, hasFreezeWindows
 class OrBase {
     /**
      * Trigger the next jobs of the current job
-     * @param {Object} app Server app object
-     * @param {BuildFactory} app.buildFactory
-     * @param {JobFactory} app.jobFactory
-     * @param {PipelineFactory} app.pipelineFactory
+     * @param {Object} server Server object
+     * @param {BuildFactory} server.app.buildFactory
+     * @param {JobFactory} server.app.jobFactory
+     * @param {PipelineFactory} server.app.pipelineFactory
      * @param {Object} config Configuration object
      * @param {Build} config.currentBuild
      * @param {String} config.username
      * @param {String} config.scmContext
      */
-    constructor(app, config) {
-        this.buildFactory = app.buildFactory;
-        this.jobFactory = app.jobFactory;
-        this.pipelineFactory = app.pipelineFactory;
+    constructor(server, config) {
+        this.server = server;
+        this.buildFactory = server.app.buildFactory;
+        this.jobFactory = server.app.jobFactory;
+        this.pipelineFactory = server.app.pipelineFactory;
 
         this.currentBuild = config.build;
         this.username = config.username;
@@ -59,7 +60,7 @@ class OrBase {
 
             // Bypass execution of the build if the job is virtual
             if (isNextJobVirtual && !hasWindows) {
-                return updateVirtualBuildSuccess(nextBuild);
+                return updateVirtualBuildSuccess({ server: this.server, build: nextBuild, event, job: nextJob });
             }
 
             nextBuild.status = Status.QUEUED;
@@ -86,7 +87,7 @@ class OrBase {
 
         // Bypass execution of the build if the job is virtual
         if (isNextJobVirtual && !hasWindows) {
-            await updateVirtualBuildSuccess(nextBuild);
+            await updateVirtualBuildSuccess({ server: this.server, build: nextBuild, event, job: nextJob });
         }
 
         return nextBuild;