screwdriver-api 7.0.130 → 7.0.132

package/plugins/builds/triggers/joinBase.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const logger = require('screwdriver-logger');
+const { createInternalBuild, updateParentBuilds, getParentBuildStatus, handleNewBuild } = require('./helpers');
+
+/**
+ * @typedef {import('screwdriver-models').EventFactory} EventFactory
+ * @typedef {import('screwdriver-models').BuildFactory} BuildFactory
+ * @typedef {import('screwdriver-models').JobFactory} JobFactory
+ * @typedef {import('screwdriver-models/lib/event')} Event
+ * @typedef {import('screwdriver-models/lib/build')} Build
+ * @typedef {import('screwdriver-models/lib/stage')} Stage
+ */
+
+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} config Configuration object
+     * @param {Build} config.build
+     * @param {Stage} config.stage
+     * @param {String} config.username
+     * @param {String} config.scmContext
+     */
+    constructor(app, config) {
+        this.eventFactory = app.eventFactory;
+        this.buildFactory = app.buildFactory;
+        this.jobFactory = app.jobFactory;
+
+        this.currentBuild = config.build;
+        this.stage = config.stage;
+        this.username = config.username;
+        this.scmContext = config.scmContext;
+    }
+
+    /**
+     * Create a build if the next build does not exist.
+     * If the next build exists, trigger it if the conditions for triggering are met.
+     * @param {Number} pipelineId
+     * @param {Event} event
+     * @param {Build} nextBuild
+     * @param {String} nextJobName
+     * @param {String} nextJobId
+     * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @param {String} parentBuildId
+     * @param {String[]} joinListNames
+     * @returns {Promise<Build[]|null>}
+     */
+    async processNextBuild({
+        pipelineId,
+        event,
+        nextBuild,
+        nextJobName,
+        nextJobId,
+        parentBuilds,
+        parentBuildId,
+        joinListNames
+    }) {
+        let newBuild;
+
+        // Create next build
+        if (!nextBuild) {
+            newBuild = await createInternalBuild({
+                jobFactory: this.jobFactory,
+                buildFactory: this.buildFactory,
+                pipelineId,
+                jobName: nextJobName,
+                jobId: nextJobId,
+                username: this.username,
+                scmContext: this.scmContext,
+                event, // this is the parentBuild for the next build
+                baseBranch: event.baseBranch || null,
+                parentBuilds,
+                parentBuildId,
+                start: false
+            });
+        } else {
+            newBuild = await updateParentBuilds({
+                joinParentBuilds: parentBuilds,
+                nextBuild,
+                build: this.currentBuild
+            });
+        }
+
+        if (!newBuild) {
+            logger.error(`No build found for ${pipelineId}:${nextJobName}`);
+
+            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,
+            newBuild,
+            nextJobName,
+            pipelineId,
+            stage: this.stage
+        });
+    }
+}
+
+module.exports = {
+    JoinBase
+};

package/plugins/builds/triggers/or.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { OrBase } = require('./orBase');
+
+/**
+ * @typedef {import('screwdriver-models/lib/build')} Build
+ * @typedef {import('screwdriver-models/lib/event')} Event
+ */
+
+class OrTrigger extends OrBase {
+    /**
+     * Trigger the next jobs of the current job
+     * @param {Event} event
+     * @param {Number} pipelineId
+     * @param {String} nextJobName
+     * @param {Number} nextJobId
+     * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @return {Promise<Build|null>}
+     */
+    async execute(event, pipelineId, nextJobName, nextJobId, parentBuilds) {
+        return this.trigger(event, pipelineId, nextJobName, nextJobId, parentBuilds);
+    }
+}
+
+module.exports = {
+    OrTrigger
+};

package/plugins/builds/triggers/orBase.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const { createInternalBuild, Status } = require('./helpers');
+
+/**
+ * @typedef {import('screwdriver-models').BuildFactory} BuildFactory
+ * @typedef {import('screwdriver-models').JobFactory} JobFactory
+ * @typedef {import('screwdriver-models').PipelineFactory} PipelineFactory
+ * @typedef {import('screwdriver-models/lib/build')} Build
+ * @typedef {import('screwdriver-models/lib/event')} Event
+ */
+
+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} 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;
+
+        this.currentBuild = config.build;
+        this.username = config.username;
+        this.scmContext = config.scmContext;
+    }
+
+    /**
+     * Trigger the next jobs of the current job
+     * @param {Event} event
+     * @param {Number} pipelineId
+     * @param {String} nextJobName
+     * @param {Number} nextJobId
+     * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @return {Promise<Build|null>}
+     */
+    async trigger(event, pipelineId, nextJobName, nextJobId, parentBuilds) {
+        const nextBuild = await this.buildFactory.get({
+            eventId: event.id,
+            jobId: nextJobId
+        });
+
+        if (nextBuild !== null) {
+            if (Status.isStarted(nextBuild.status)) {
+                return nextBuild;
+            }
+
+            nextBuild.status = Status.QUEUED;
+            await nextBuild.update();
+
+            return nextBuild.start();
+        }
+
+        return createInternalBuild({
+            jobFactory: this.jobFactory,
+            buildFactory: this.buildFactory,
+            pipelineId,
+            jobName: nextJobName,
+            jobId: nextJobId,
+            username: this.username,
+            scmContext: this.scmContext,
+            event,
+            baseBranch: event.baseBranch || null,
+            parentBuilds,
+            parentBuildId: this.currentBuild.id,
+            start: true
+        });
+    }
+}
+
+module.exports = {
+    OrBase
+};

package/plugins/builds/triggers/remoteJoin.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { getParallelBuilds, mergeParentBuilds, getParentBuildIds } = require('./helpers');
+const { JoinBase } = require('./joinBase');
+
+/**
+ * @typedef {import('screwdriver-models/lib/event')} Event
+ * @typedef {import('screwdriver-models/lib/build')} Build
+ */
+
+class RemoteJoin extends JoinBase {
+    /**
+     * @param {Object} app Application object
+     * @param {Object} config Config object
+     * @param {Event} currentEvent Current event
+     */
+    constructor(app, config, currentEvent) {
+        super(app, config);
+
+        this.currentEvent = currentEvent;
+    }
+
+    /**
+     * Trigger the next external jobs of the current job
+     * @param {Event} externalEvent Downstream pipeline's event
+     * @param {String} nextJobName
+     * @param {Number} nextJobId
+     * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @param {Build[]} groupEventBuilds Builds of the downstream pipeline, where only the latest ones for each job are included that have the same groupEventId as the externalEvent
+     * @param {String[]} joinListNames
+     * @returns {Promise<Build|null>}
+     */
+    async execute(externalEvent, nextJobName, nextJobId, parentBuilds, groupEventBuilds, joinListNames) {
+        // fetch builds created due to trigger
+        const parallelBuilds = await getParallelBuilds({
+            eventFactory: this.eventFactory,
+            parentEventId: externalEvent.id,
+            pipelineId: externalEvent.pipelineId
+        });
+
+        groupEventBuilds.push(...parallelBuilds);
+
+        // When restart case, should we create a new build ?
+        const nextBuild = groupEventBuilds.find(b => b.jobId === nextJobId && b.eventId === externalEvent.id);
+
+        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,
+            nextJobName,
+            nextJobId,
+            parentBuilds: newParentBuilds,
+            parentBuildId,
+            joinListNames
+        });
+    }
+}
+
+module.exports = {
+    RemoteJoin
+};

package/plugins/builds/triggers/remoteTrigger.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { OrBase } = require('./orBase');
+
+/**
+ * @typedef {import('screwdriver-models/lib/build')} Build
+ * @typedef {import('screwdriver-models/lib/event')} Event
+ */
+
+class RemoteTrigger extends OrBase {
+    /**
+     * Trigger the next jobs of the current job
+     * @param {Event} event
+     * @param {Number} pipelineId
+     * @param {String} nextJobName
+     * @param {String} nextJobId
+     * @param {import('./helpers').ParentBuilds} parentBuilds
+     * @returns {Promise<Build|null>}
+     */
+    async execute(event, pipelineId, nextJobName, nextJobId, parentBuilds) {
+        return this.trigger(event, pipelineId, nextJobName, nextJobId, parentBuilds);
+    }
+}
+
+module.exports = {
+    RemoteTrigger
+};