screwdriver-api 7.0.130 → 7.0.132

package/plugins/builds/index.js

@@ -2,8 +2,6 @@
 
 const logger = require('screwdriver-logger');
 const workflowParser = require('screwdriver-workflow-parser');
-const merge = require('lodash.mergewith');
-const schema = require('screwdriver-data-schema');
 const hoek = require('@hapi/hoek');
 const getRoute = require('./get');
 const getBuildStatusesRoute = require('./getBuildStatuses');
@@ -18,59 +16,29 @@ const stepLogsRoute = require('./steps/logs');
 const listSecretsRoute = require('./listSecrets');
 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
- * @param  {String}  jobName Job name
- * @return {Boolean}         If job name is external trigger or not
- */
-function isExternalTrigger(jobName) {
-    return EXTERNAL_TRIGGER_ALL.test(jobName);
-}
-
-/**
- * Get pipelineId and job name from the `name`
- * If internal, pipelineId will be the current pipelineId
- * @param  {String} name        Job name
- * @param  {String} pipelineId  Pipeline ID
- * @return {Object}             With pipeline id, job name and isExternal flag
- */
-function getPipelineAndJob(name, pipelineId) {
-    let externalJobName = name;
-    let externalPipelineId = pipelineId;
-    let isExternal = false;
-
-    if (isExternalTrigger(name)) {
-        isExternal = true;
-        [, externalPipelineId, externalJobName] = EXTERNAL_TRIGGER_ALL.exec(name);
-    }
-
-    return { externalPipelineId, externalJobName, isExternal };
-}
-
-/**
- * Helper function to fetch external event from parentBuilds
- * @param  {Object} currentBuild     Build for current completed job
- * @param  {String} pipelineId       Pipeline ID for next job to be triggered.
- * @param  {Object} eventFactory     Factory for querying event data store.
- * @return {Object} External Event   Event where the next job to be triggered belongs to.
- */
-function getExternalEvent(currentBuild, pipelineId, eventFactory) {
-    if (!currentBuild.parentBuilds || !currentBuild.parentBuilds[pipelineId]) {
-        return null;
-    }
-
-    const { eventId } = currentBuild.parentBuilds[pipelineId];
-
-    return eventFactory.get(eventId);
-}
+const { OrTrigger } = require('./triggers/or');
+const { AndTrigger } = require('./triggers/and');
+const { RemoteTrigger } = require('./triggers/remoteTrigger');
+const { RemoteJoin } = require('./triggers/remoteJoin');
+const {
+    strToInt,
+    createJoinObject,
+    createEvent,
+    parseJobInfo,
+    handleStageFailure,
+    getJobId,
+    isOrTrigger,
+    extractExternalJoinData,
+    extractCurrentPipelineJoinData,
+    createExternalEvent,
+    getBuildsForGroupEvent,
+    buildsToRestartFilter,
+    trimJobName
+} = require('./triggers/helpers');
 
 /**
  * Delete a build
- * @method delBuild
  * @param  {Object}  buildConfig  build object to delete
  * @param  {Object}  buildFactory build factory
  * @return {Promise}
@@ -86,722 +54,188 @@ async function deleteBuild(buildConfig, buildFactory) {
 }
 
 /**
- * Create event for downstream pipeline that need to be rebuilt
- * @method createEvent
- * @param {Object}  config                  Configuration object
- * @param {Factory} config.pipelineFactory  Pipeline Factory
- * @param {Factory} config.eventFactory     Event Factory
- * @param {Number}  config.pipelineId       Pipeline to be rebuilt
- * @param {String}  config.startFrom        Job to be rebuilt
- * @param {String}  config.causeMessage     Caused message, e.g. triggered by 1234(buildId)
- * @param {String}  config.parentBuildId    ID of the build that triggers this event
- * @param {Object}  [config.parentBuilds]   Builds that triggered this build
- * @param {Number}  [config.parentEventId]  Parent event ID
- * @param {Number}  [config.groupEventId]   Group parent event ID
- * @return {Promise}                        Resolves to the newly created event
- */
-async function createEvent(config) {
-    const {
-        pipelineFactory,
-        eventFactory,
-        pipelineId,
-        startFrom,
-        causeMessage,
-        parentBuildId,
-        parentBuilds,
-        parentEventId,
-        groupEventId
-    } = config;
-    const { scm } = eventFactory;
-    const payload = {
-        pipelineId,
-        startFrom,
-        type: 'pipeline',
-        causeMessage,
-        parentBuildId
-    };
-
-    if (parentEventId) {
-        payload.parentEventId = parentEventId;
-    }
-
-    // for backward compatibility, this field is optional
-    if (parentBuilds) {
-        payload.parentBuilds = parentBuilds;
-    }
-
-    if (groupEventId) {
-        payload.groupEventId = groupEventId;
-    }
-
-    const pipeline = await pipelineFactory.get(pipelineId);
-    const realAdmin = await pipeline.admin;
-    const { scmContext, scmUri } = pipeline;
-
-    payload.scmContext = scmContext;
-    payload.username = realAdmin.username;
-
-    // get pipeline admin's token
-    const token = await realAdmin.unsealToken();
-    const scmConfig = {
-        scmContext,
-        scmUri,
-        token
-    };
-
-    // Get commit sha
-    const sha = await scm.getCommitSha(scmConfig);
-
-    payload.sha = sha;
-
-    // Set configPipelineSha for child pipeline
-    if (pipeline.configPipelineId) {
-        const configPipeline = await pipelineFactory.get(pipeline.configPipelineId);
-        const configAdmin = await configPipeline.admin;
-        const configToken = await configAdmin.unsealToken();
-        const configScmConfig = {
-            scmContext: configPipeline.scmContext,
-            scmUri: configPipeline.scmUri,
-            token: configToken
-        };
-
-        payload.configPipelineSha = await scm.getCommitSha(configScmConfig);
-    }
-
-    return eventFactory.create(payload);
-}
-
-/**
- * Create external build (returns event with `builds` field)
- * @method createExternalBuild
- * @param  {Object}   config                    Configuration object
- * @param  {Factory}  config.pipelineFactory    Pipeline Factory
- * @param  {Factory}  config.eventFactory       Event Factory
- * @param  {Number}   config.externalPipelineId External pipeline ID
- * @param  {String}   config.startFrom          External trigger to start from
- * @param  {Number}   config.parentBuildId      Parent Build ID
- * @param  {Object}   config.parentBuilds       Builds that triggered this build
- * @param  {String}   config.causeMessage       Cause message of this event
- * @param  {Number}   [config.parentEventId]    Parent event ID
- * @param  {Number}   [config.groupEventId]     Group parent event ID
- * @return {Promise}
- */
-async function createExternalBuild(config) {
-    const {
-        pipelineFactory,
-        eventFactory,
-        externalPipelineId,
-        startFrom,
-        parentBuildId,
-        parentBuilds,
-        causeMessage,
-        parentEventId,
-        groupEventId
-    } = config;
-
-    const createEventConfig = {
-        pipelineFactory,
-        eventFactory,
-        pipelineId: externalPipelineId,
-        startFrom,
-        parentBuildId, // current build
-        causeMessage,
-        parentBuilds
-    };
-
-    if (parentEventId) {
-        createEventConfig.parentEventId = parentEventId;
-    }
-
-    if (groupEventId) {
-        createEventConfig.groupEventId = groupEventId;
-    }
-
-    return createEvent(createEventConfig);
-}
-
-/**
- * Create internal build. If config.start is false or not passed in then do not start the job
- * Need to pass in (jobName and pipelineId) or (jobId) to get job data
- * @method createInternalBuild
- * @param  {Object}   config                    Configuration object
- * @param  {Factory}  config.jobFactory         Job Factory
- * @param  {Factory}  config.buildFactory       Build Factory
- * @param  {Number}   [config.pipelineId]       Pipeline Id
- * @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  {String}   config.baseBranch         Branch name
- * @param  {Number}   [config.parentBuildId]    Parent build ID
- * @param  {Boolean}  [config.start]            Whether to start the build or not
- * @param  {Number}   [config.jobId]            Job ID
- * @param  {Object}   [config.event]            Event build belongs to
- * @return {Promise}
- */
-async function createInternalBuild(config) {
-    const {
-        jobFactory,
-        buildFactory,
-        pipelineId,
-        jobName,
-        username,
-        scmContext,
-        event,
-        parentBuilds,
-        start,
-        baseBranch,
-        parentBuildId,
-        jobId
-    } = config;
-    const prRef = event.pr.ref ? event.pr.ref : '';
-    const prSource = event.pr.prSource || '';
-    const prInfo = event.pr.prBranchName
-        ? {
-              url: event.pr.url || '',
-              prBranchName: event.pr.prBranchName || ''
-          }
-        : '';
-
-    let job = {};
-
-    if (!jobId) {
-        job = await jobFactory.get({
-            name: jobName,
-            pipelineId
-        });
-    } else {
-        job = await jobFactory.get(jobId);
-    }
-
-    const internalBuildConfig = {
-        jobId: job.id,
-        sha: event.sha,
-        parentBuildId,
-        parentBuilds: parentBuilds || {},
-        eventId: event.id,
-        username,
-        configPipelineSha: event.configPipelineSha,
-        scmContext,
-        prRef,
-        prSource,
-        prInfo,
-        start: start !== false,
-        baseBranch
-    };
-
-    let jobState = job.state;
-
-    if (prRef) {
-        // Whether a job is enabled is determined by the state of the original job.
-        // If the original job does not exist, it will be enabled.
-        const originalJobName = job.parsePRJobName('job');
-        const originalJob = await jobFactory.get({
-            name: originalJobName,
-            pipelineId
-        });
-
-        jobState = originalJob ? originalJob.state : 'ENABLED';
-    }
-
-    if (jobState === 'ENABLED') {
-        return buildFactory.create(internalBuildConfig);
-    }
-
-    return null;
-}
-
-/**
- * Return PR job or not
- * PR job name certainly has ":". e.g. "PR-1:jobName"
- * @method isPR
- * @param  {String}  destJobName
- * @return {Boolean}
- */
-function isPR(jobName) {
-    return jobName.startsWith('PR-');
-}
-
-/**
- * Trim Job name to follow data-schema
- * @method trimJobName
- * @param  {String} jobName
- * @return {String} trimmed jobName
- */
-function trimJobName(jobName) {
-    if (isPR(jobName)) {
-        return jobName.split(':')[1];
-    }
-
-    return jobName;
-}
-
-/**
- * Generates a parent builds object
- * @param  {Number} config.buildId          Build ID
- * @param  {Number} config.eventId          Event ID
- * @param  {Number} config.pipelineId       Pipeline ID
- * @param  {String} config.jobName          Job name
- * @param  {Array}  [config.joinListNames]  Job names in join list
- * @return {Object}                         Returns parent builds object
+ * 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
+ * @return {Promise<null>}                                  Resolves to the newly created build or null
  */
-function createParentBuildsObj(config) {
-    const { buildId, eventId, pipelineId, jobName, joinListNames } = config;
-
-    // For getting multiple parent builds
-    if (joinListNames) {
-        const joinParentBuilds = {};
-
-        joinListNames.forEach(name => {
-            const joinInfo = getPipelineAndJob(name, pipelineId);
-
-            if (!joinParentBuilds[joinInfo.externalPipelineId]) {
-                joinParentBuilds[joinInfo.externalPipelineId] = {
-                    eventId: null,
-                    jobs: {}
-                };
-            }
-
-            joinParentBuilds[joinInfo.externalPipelineId].jobs[joinInfo.externalJobName] = null;
-        });
-
-        return joinParentBuilds;
-    }
-
-    return {
-        [pipelineId]: {
-            eventId,
-            jobs: { [jobName]: buildId }
-        }
+async function triggerNextJobs(config, app) {
+    const currentPipeline = config.pipeline;
+    const currentJob = config.job;
+    const currentBuild = config.build;
+    const { jobFactory, buildFactory, eventFactory, pipelineFactory } = app;
+
+    /** @type {EventModel} */
+    const currentEvent = await eventFactory.get({ id: currentBuild.eventId });
+    const current = {
+        pipeline: currentPipeline,
+        build: currentBuild,
+        event: currentEvent
     };
-}
-
-/**
- * Parse job info into important variables
- * - parentBuilds: parent build information
- * - joinListNames: array of join jobs
- * - joinParentBuilds: parent build information for join jobs
- * @param  {Object} joinObj        Join object
- * @param  {Object} current        Object holding current event, job & pipeline
- * @param  {String} nextJobName    Next job's name
- * @param  {Number} nextPipelineId Next job's Pipeline Id
- * @return {Object}                With above information
- */
-function parseJobInfo({ joinObj = {}, current, nextJobName, nextPipelineId }) {
-    const joinList = joinObj[nextJobName] ? joinObj[nextJobName].join : [];
-    const joinListNames = joinList.map(j => j.name);
-
-    /* CONSTRUCT AN OBJ LIKE {111: {eventId: 2, D:987}}
-     * FOR EASY LOOKUP OF BUILD STATUS */
-    // current job's parentBuilds
-    const currentJobParentBuilds = current.build.parentBuilds || {};
-    // join jobs, with eventId and buildId empty
-    const joinParentBuilds = createParentBuildsObj({
-        pipelineId: nextPipelineId || current.pipeline.id,
-        joinListNames
-    });
-    // override currentBuild in the joinParentBuilds
-    const currentBuildInfo = createParentBuildsObj({
-        buildId: current.build.id,
-        eventId: current.build.eventId,
-        pipelineId: current.pipeline.id,
-        jobName: current.job.name
+    /** @type Array<string> */
+    const nextJobsTrigger = workflowParser.getNextJobs(currentEvent.workflowGraph, {
+        trigger: currentJob.name,
+        chainPR: currentPipeline.chainPR
     });
+    const pipelineJoinData = await createJoinObject(nextJobsTrigger, current, eventFactory);
+    const originalCurrentJobName = trimJobName(currentJob.name);
 
-    // need to merge because it's possible same event has multiple builds
-    const parentBuilds = merge({}, joinParentBuilds, currentJobParentBuilds, currentBuildInfo);
+    // 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 currentPipelineNextJobs = extractCurrentPipelineJoinData(pipelineJoinData, currentPipeline.id);
 
-    return {
-        parentBuilds,
-        joinListNames,
-        joinParentBuilds
-    };
-}
-
-/**
- * Get finished builds in all parent events
- * @param  {Event}      event                   Current event
- * @param  {Number}     [event.parentEventId]   Parent event ID
- * @param  {Number}     [event.groupEventId]    Group parent event ID
- * @param  {Factory}    buildFactory            Build factory
- * @return {Promise}                            All finished builds
- */
-async function getFinishedBuilds(event, buildFactory) {
-    // FIXME: buildFactory.getLatestBuilds doesn't return build model
-    const builds = await buildFactory.getLatestBuilds({ groupEventId: event.groupEventId, readOnly: false });
+    for (const [nextJobName, nextJob] of Object.entries(currentPipelineNextJobs)) {
+        const nextJobId = nextJob.id || (await getJobId(nextJobName, currentPipeline.id, jobFactory));
+        const resource = `pipeline:${currentPipeline.id}:event:${currentEvent.id}`;
+        let lock;
 
-    builds.forEach(b => {
         try {
-            b.parentBuilds = JSON.parse(b.parentBuilds);
-        } catch (err) {
-            logger.error(`Failed to parse parentBuilds for ${b.id}`);
-        }
-    });
-
-    return builds;
-}
-
-/**
- * Update parent builds info when next build already exists
- * @param  {Object} joinParentBuilds       Parent builds object for join job
- * @param  {Build}  nextBuild              Next build
- * @param  {Build}  build                  Build for current completed job
- * @return {Promise}                       Updated next build
- */
-async function updateParentBuilds({ joinParentBuilds, nextBuild, build }) {
-    // Override old parentBuilds info
-    const newParentBuilds = merge({}, joinParentBuilds, nextBuild.parentBuilds, (objVal, srcVal) =>
-        // passthrough objects, else mergeWith mutates source
-        srcVal && typeof srcVal === 'object' ? undefined : objVal || srcVal
-    );
-
-    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()));
-
-    // FIXME: Is this needed ? Why not update once in handleNewBuild()
-    return nextBuild.update();
-}
-
-/**
- * Check if all parent builds of the new build are done
- * @param  {Build}      newBuild      Updated build
- * @param  {Array}      joinListNames Join list names
- * @param  {Number}     pipelineId    Pipeline ID
- * @param  {Factory}    buildFactory  Build factory
- * @return {Promise}                  Object with done and hasFailure statuses
- */
-async function getParentBuildStatus({ newBuild, joinListNames, pipelineId, buildFactory }) {
-    const upstream = newBuild.parentBuilds || {};
-    let done = true;
-    let hasFailure = false;
-    const promisesToAwait = [];
-
-    // Get buildId
-    for (let i = 0; i < joinListNames.length; i += 1) {
-        const name = joinListNames[i];
-        const joinInfo = getPipelineAndJob(name, pipelineId);
-
-        let bId;
-
-        if (
-            upstream[joinInfo.externalPipelineId] &&
-            upstream[joinInfo.externalPipelineId].jobs[joinInfo.externalJobName]
-        ) {
-            bId = upstream[joinInfo.externalPipelineId].jobs[joinInfo.externalJobName];
-        }
-
-        // If buildId is empty, the job hasn't executed yet and the join is not done
-        if (!bId) {
-            done = false;
-            // Otherwise, get the build to check the status
-        } else {
-            promisesToAwait.push(buildFactory.get(bId));
-        }
-    }
-
-    // Get the status of the builds
-    const joinedBuilds = await Promise.all(promisesToAwait);
+            lock = await locker.lock(resource);
+            const { parentBuilds, joinListNames } = parseJobInfo({
+                joinObj: currentPipelineNextJobs,
+                currentBuild,
+                currentPipeline,
+                currentJob,
+                nextJobName
+            });
 
-    joinedBuilds.forEach(b => {
-        // Do not need to run the next build; terminal status
-        if (['FAILURE', 'ABORTED', 'COLLAPSED', 'UNSTABLE'].includes(b.status)) {
-            hasFailure = true;
-        }
-        // Some builds are still going on
-        if (!['FAILURE', 'SUCCESS', 'ABORTED', 'UNSTABLE', 'COLLAPSED'].includes(b.status)) {
-            done = false;
+            // Handle no-join case. Sequential Workflow
+            // Note: current job can be "external" in nextJob's perspective
+            /* CREATE AND START NEXT BUILD IF ALL 2 SCENARIOS ARE TRUE
+             * 1. No join
+             * 2. ([~D,B,C]->A) currentJob=D, nextJob=A, joinList(A)=[B,C]
+             *    joinList doesn't include D, so start A
+             */
+            if (isOrTrigger(currentEvent.workflowGraph, originalCurrentJobName, trimJobName(nextJobName))) {
+                await orTrigger.execute(currentEvent, currentPipeline.id, nextJobName, nextJobId, parentBuilds);
+            } else {
+                await andTrigger.execute(nextJobName, nextJobId, parentBuilds, joinListNames);
+            }
+        } catch (err) {
+            logger.error(
+                `Error in triggerNextJobInSamePipeline:${nextJobName} from pipeline:${currentPipeline.id}-${currentJob.name}-event:${currentEvent.id} `,
+                err
+            );
         }
-    });
-
-    return { hasFailure, done };
-}
-
-/**
- * Handle new build logic: update, start, or remove
- * If the build is done, check if it has a failure:
- *          if failure, delete new build
- *          if no failure, start new build
- * Otherwise, do nothing
- * @param  {Boolean} done           If the build is done or not
- * @param  {Boolean} hasFailure     If the build has a failure or not
- * @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, stage }) {
-    if (!done) {
-        return null;
+        await locker.unlock(lock, resource);
     }
-    if (!['CREATED', null, undefined].includes(newBuild.status)) {
-        return null;
-    }
-
-    // Delete new build since previous build failed
-    if (hasFailure) {
-        let stageTeardownName = '';
 
-        if (stage) {
-            stageTeardownName = getFullStageJobName({ stageName: stage.name, jobName: 'teardown' });
+    // 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 externalPipelineJoinData = extractExternalJoinData(pipelineJoinData, currentPipeline.id);
+
+    for (const [joinedPipelineId, joinedPipeline] of Object.entries(externalPipelineJoinData)) {
+        const isCurrentPipeline = strToInt(joinedPipelineId) === currentPipeline.id;
+        const remoteJoinName = `sd@${currentPipeline.id}:${originalCurrentJobName}`;
+        const remoteTriggerName = `~${remoteJoinName}`;
+        let lock;
+        let resource;
+
+        let externalEvent = joinedPipeline.event;
+
+        // This includes CREATED builds too
+        const groupEventBuilds =
+            externalEvent !== undefined ? await getBuildsForGroupEvent(externalEvent.groupEventId, buildFactory) : [];
+        const buildsToRestart = buildsToRestartFilter(joinedPipeline, groupEventBuilds, currentEvent, currentBuild);
+        const isRestart = buildsToRestart.length > 0;
+
+        // If user used external trigger syntax, the jobs are triggered as external
+        if (isCurrentPipeline || isRestart) {
+            externalEvent = null;
         }
 
-        // 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();
+        // no need to lock if there is no external event
+        if (externalEvent) {
+            resource = `pipeline:${joinedPipelineId}:event:${externalEvent.id}`;
         }
 
-        return null;
-    }
+        // Create a new external event
+        // First downstream trigger, restart case, same pipeline trigger as external
+        if (!externalEvent) {
+            const { parentBuilds } = parseJobInfo({
+                currentBuild,
+                currentPipeline,
+                currentJob
+            });
 
-    // All join builds finished successfully and it's clear that a new build has not been started before.
-    // Start new build.
-    newBuild.status = 'QUEUED';
-    await newBuild.update();
+            const externalEventConfig = {
+                pipelineFactory,
+                eventFactory,
+                externalPipelineId: joinedPipelineId,
+                parentBuildId: currentBuild.id,
+                parentBuilds,
+                causeMessage: `Triggered by ${remoteJoinName}`,
+                parentEventId: currentEvent.id,
+                startFrom: remoteTriggerName,
+                skipMessage: 'Skip bulk external builds creation', // Don't start builds in eventFactory.
+                groupEventId: null
+            };
 
-    return newBuild.start();
-}
+            // Restart case
+            if (isRestart) {
+                externalEventConfig.groupEventId = joinedPipeline.event.id;
+                externalEventConfig.parentBuilds = buildsToRestart[0].parentBuilds;
+            }
 
-/**
- * Get all builds with same parent event id
- * @param  {Factory}    eventFactory    Event factory
- * @param  {Number}     parentEventId   Parent event ID
- * @param  {Number}     pipelineId      Pipeline ID
- * @return {Promise}                    Array of builds with same parent event ID
- */
-async function getParallelBuilds({ eventFactory, parentEventId, pipelineId }) {
-    let parallelEvents = await eventFactory.list({
-        params: {
-            parentEventId
+            externalEvent = await createExternalEvent(externalEventConfig);
         }
-    });
-
-    // Remove previous events from same pipeline
-    parallelEvents = parallelEvents.filter(pe => pe.pipelineId !== pipelineId);
-
-    let parallelBuilds = [];
-
-    await Promise.all(
-        parallelEvents.map(async pe => {
-            const parallelBuild = await pe.getBuilds();
-
-            parallelBuilds = parallelBuilds.concat(parallelBuild);
-        })
-    );
-
-    return parallelBuilds;
-}
 
-/**
- * Fills parentBuilds object with missing job information
- * @param {Array}  parentBuilds
- * @param {Object} current       Holds current build/event data
- * @param {Array}  builds        Completed builds which is used to fill parentBuilds data
- * @param {Object} [nextEvent]     External event
- */
-function fillParentBuilds(parentBuilds, current, builds, nextEvent) {
-    Object.keys(parentBuilds).forEach(pid => {
-        Object.keys(parentBuilds[pid].jobs).forEach(jName => {
-            let joinJob;
-
-            if (parentBuilds[pid].jobs[jName] === null) {
-                let workflowGraph;
-                let searchJob = trimJobName(jName);
+        for (const [nextJobName, nextJob] of Object.entries(joinedPipeline.jobs)) {
+            const nextJobId = nextJob.id || (await getJobId(nextJobName, currentPipeline.id, jobFactory));
 
-                // parentBuild is in current event
-                if (+pid === current.pipeline.id) {
-                    workflowGraph = current.event.workflowGraph;
-                } else if (nextEvent) {
-                    if (+pid !== nextEvent.pipelineId) {
-                        // parentBuild is remote triggered from external event
-                        // FIXME:: Will else condition ever be true ?
-                        searchJob = `sd@${pid}:${searchJob}`;
-                    }
-                    workflowGraph = nextEvent.workflowGraph;
-                } else {
-                    // parentBuild is remote triggered from current Event
-                    searchJob = `sd@${pid}:${searchJob}`;
-                    workflowGraph = current.event.workflowGraph;
-                }
-                joinJob = workflowGraph.nodes.find(node => node.name === searchJob);
+            const { parentBuilds } = parseJobInfo({
+                joinObj: joinedPipeline.jobs,
+                currentBuild,
+                currentPipeline,
+                currentJob,
+                nextJobName,
+                nextPipelineId: joinedPipelineId
+            });
 
-                if (!joinJob) {
-                    logger.warn(`Job ${jName}:${pid} not found in workflowGraph for event ${current.event.id}`);
+            try {
+                if (resource) lock = await locker.lock(resource);
+
+                if (isOrTrigger(externalEvent.workflowGraph, remoteTriggerName, nextJobName)) {
+                    await remoteTrigger.execute(
+                        externalEvent,
+                        externalEvent.pipelineId,
+                        nextJobName,
+                        nextJobId,
+                        parentBuilds
+                    );
                 } else {
-                    const targetBuild = builds.find(b => b.jobId === joinJob.id);
-
-                    if (targetBuild) {
-                        parentBuilds[pid].jobs[jName] = targetBuild.id;
-                        parentBuilds[pid].eventId = targetBuild.eventId;
-                    } else {
-                        logger.warn(`Job ${jName}:${pid} not found in builds`);
-                    }
+                    // Re get join list when first time remote trigger since external event was empty and cannot get workflow graph then
+                    const joinList =
+                        nextJob.join.length > 0
+                            ? nextJob.join
+                            : workflowParser.getSrcForJoin(externalEvent.workflowGraph, { jobName: nextJobName });
+                    const joinListNames = joinList.map(j => j.name);
+
+                    await remoteJoin.execute(
+                        externalEvent,
+                        nextJobName,
+                        nextJobId,
+                        parentBuilds,
+                        groupEventBuilds,
+                        joinListNames
+                    );
                 }
+            } catch (err) {
+                logger.error(
+                    `Error in triggerJobsInExternalPipeline:${joinedPipelineId} from pipeline:${currentPipeline.id}-${currentJob.name}-event:${currentEvent.id} `,
+                    err
+                );
             }
-        });
-    });
-}
-
-/**
- * Create joinObject for nextJobs to trigger
- *   For A & D in nextJobs for currentJobName B, create
- *          {A:[B,C], D:[B,F], X: []} where [B,C] join on A,
- *              [B,F] join on D and X has no join
- *   This can include external jobs
- * @param {Array}   nextJobs       List of jobs to run next from workflow parser.
- * @param {Object}  current        Object holding current job's build, event data
- * @param {Object}  eventFactory   Object for querying DB for event data
- * @return {Object} Object representing join data for next jobs grouped by pipeline id
- *                  {"pipeineId" : {event: "externalEventId",
- *                                  jobs: {"nextJobName": {"id": "jobId", join: ["a", "b"]
- *                                 }
- *                  }
- */
-async function createJoinObject(nextJobs, current, eventFactory) {
-    const { build, event } = current;
-
-    const joinObj = {};
-
-    for (const jobName of nextJobs) {
-        const jobInfo = getPipelineAndJob(jobName, current.pipeline.id);
-        const { externalPipelineId: pid, externalJobName: jName, isExternal } = jobInfo;
-
-        const jId = event.workflowGraph.nodes.find(n => n.name === trimJobName(jobName)).id;
-
-        if (!joinObj[pid]) joinObj[pid] = {};
-        const pipelineObj = joinObj[pid];
-        let jobs;
-
-        if (pid !== current.pipeline.id) {
-            jobs = [];
 
-            const externalEvent = pipelineObj.event || (await getExternalEvent(build, pid, eventFactory));
-
-            if (externalEvent) {
-                pipelineObj.event = externalEvent;
-                jobs = workflowParser.getSrcForJoin(externalEvent.workflowGraph, { jobName: jName });
-            }
-        } else {
-            jobs = workflowParser.getSrcForJoin(event.workflowGraph, { jobName });
+            await locker.unlock(lock, resource);
         }
-
-        if (!pipelineObj.jobs) pipelineObj.jobs = {};
-        pipelineObj.jobs[jName] = { id: jId, join: jobs, isExternal };
     }
 
-    return joinObj;
-}
-
-/**
- * Get parentBuildId from parentBuilds object
- * @param {Object}  parentBuilds    Builds that triggered this build
- * @param {Array}   joinListNames   Array of join job name
- * @param {Number}  pipelineId      Pipeline ID
- * @return {Array}                  Array of parentBuildId
- */
-function getParentBuildIds({ currentBuildId, parentBuilds, joinListNames, pipelineId }) {
-    const parentBuildIds = [];
-
-    for (let i = 0; i < joinListNames.length; i += 1) {
-        const name = joinListNames[i];
-        const joinInfo = getPipelineAndJob(name, pipelineId);
-
-        if (
-            parentBuilds[joinInfo.externalPipelineId] &&
-            parentBuilds[joinInfo.externalPipelineId].jobs[joinInfo.externalJobName]
-        ) {
-            parentBuildIds.push(parentBuilds[joinInfo.externalPipelineId].jobs[joinInfo.externalJobName]);
-        }
-    }
-
-    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;
+    return null;
 }
 
 /**
@@ -860,7 +294,7 @@ const buildsPlugin = {
 
                         //   if nextBuild is stage teardown, just return nextBuild
                         if (current.stage) {
-                            const buildDeletePromises = await handleStageFailure({
+                            const buildDeletePromises = handleStageFailure({
                                 nextJobName,
                                 current,
                                 buildConfig,
@@ -906,405 +340,8 @@ const buildsPlugin = {
 
         /**
          * Trigger the next jobs of the current job
-         * @method triggerNextJobs
-         * @param {Object}      config              Configuration object
-         * @param {Pipeline}    config.pipeline     Current pipeline
-         * @param {Job}         config.job          Current job
-         * @param {Build}       config.build        Current build
-         * @param {String}      config.username     Username
-         * @param {String}      config.scmContext   Scm context
-         * @param {String}  app                      Server app object
-         * @return {Promise}                        Resolves to the newly created build or null
          */
-        server.expose('triggerNextJobs', async (config, app) => {
-            const { pipeline, job, build, event, stage } = config;
-            const { eventFactory, pipelineFactory, buildFactory, jobFactory } = app;
-            const current = {
-                pipeline,
-                job,
-                build,
-                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
-            const triggerNextJobInSamePipeline = async (nextJobName, joinObj) => {
-                const { username, scmContext } = config;
-                const { parentBuilds, joinListNames } = parseJobInfo({
-                    joinObj,
-                    current,
-                    nextJobName
-                });
-
-                // Handle no-join case. Sequential Workflow
-                // Note: current job can be "external" in nextJob's perspective
-                /* CREATE AND START NEXT BUILD IF ALL 2 SCENARIOS ARE TRUE
-                 * 1. No join
-                 * 2. ([~D,B,C]->A) currentJob=D, nextJob=A, joinList(A)=[B,C]
-                 *    joinList doesn't include D, so start A
-                 */
-                const isORTrigger = !joinListNames.includes(current.job.name);
-
-                if (isORTrigger) {
-                    const internalBuildConfig = {
-                        jobFactory,
-                        buildFactory,
-                        pipelineId: current.pipeline.id,
-                        jobName: nextJobName,
-                        username,
-                        scmContext,
-                        event: current.event, // this is the parentBuild for the next build
-                        baseBranch: current.event.baseBranch || null,
-                        parentBuilds,
-                        parentBuildId: current.build.id
-                    };
-
-                    const nextJob = await jobFactory.get({
-                        name: nextJobName,
-                        pipelineId: current.pipeline.id
-                    });
-
-                    const existNextBuild = await buildFactory.get({
-                        eventId: current.event.id,
-                        jobId: nextJob.id
-                    });
-
-                    if (existNextBuild === null) {
-                        return createInternalBuild(internalBuildConfig);
-                    }
-
-                    if (!['CREATED', null, undefined].includes(existNextBuild.status)) {
-                        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);
-
-                if (current.event.parentEventId) {
-                    // FIXME: On restart cases parentEventId should be fetched
-                    // from first event in the group
-                    const parallelBuilds = await getParallelBuilds({
-                        eventFactory,
-                        parentEventId: current.event.parentEventId,
-                        pipelineId: current.pipeline.id
-                    });
-
-                    finishedInternalBuilds = finishedInternalBuilds.concat(parallelBuilds);
-                }
-
-                const nextJobId = joinObj[nextJobName].id;
-
-                let nextBuild;
-
-                // If next build is internal, look at the finished builds for this event
-                nextBuild = finishedInternalBuilds.find(b => b.jobId === nextJobId && b.eventId === current.event.id);
-
-                if (!nextBuild) {
-                    // If the build to join fails and it succeeds on restart, depending on the timing, the latest build will be that of a child event.
-                    // In that case, `nextBuild` will be null and will not be triggered even though there is a build that should be triggered.
-                    // Now we need to check for the existence of a build that should be triggered in its own event.
-                    nextBuild = await buildFactory.get({
-                        eventId: current.event.id,
-                        jobId: nextJobId
-                    });
-
-                    if (nextBuild) {
-                        finishedInternalBuilds = finishedInternalBuilds.concat(nextBuild);
-                    }
-                }
-
-                fillParentBuilds(parentBuilds, current, finishedInternalBuilds);
-
-                let newBuild;
-
-                // Create next build
-                if (!nextBuild) {
-                    const internalBuildConfig = {
-                        jobFactory,
-                        buildFactory,
-                        pipelineId: current.pipeline.id,
-                        jobName: nextJobName,
-                        start: false,
-                        username,
-                        scmContext,
-                        event: current.event, // this is the parentBuild for the next build
-                        baseBranch: current.event.baseBranch || null,
-                        parentBuilds,
-                        parentBuildId: current.build.id
-                    };
-
-                    newBuild = await createInternalBuild(internalBuildConfig);
-                } else {
-                    // nextBuild is not build model, so fetch proper build
-                    newBuild = await updateParentBuilds({
-                        joinParentBuilds: parentBuilds,
-                        nextBuild: await buildFactory.get(nextBuild.id),
-                        build: current.build
-                    });
-                }
-
-                if (!newBuild) {
-                    logger.error(`No build found for ${current.pipeline.id}:${nextJobName}`);
-
-                    return null;
-                }
-                /* CHECK IF ALL PARENT BUILDS OF NEW BUILD ARE DONE */
-                const { hasFailure, done } = await getParentBuildStatus({
-                    newBuild,
-                    joinListNames,
-                    pipelineId: current.pipeline.id,
-                    buildFactory
-                });
-
-                return handleNewBuild({
-                    done,
-                    hasFailure,
-                    newBuild,
-                    jobName: nextJobName,
-                    pipelineId: current.pipeline.id,
-                    stage: current.stage
-                });
-            };
-
-            // Helper function to handle triggering jobs in external pipeline
-            const triggerJobsInExternalPipeline = async (externalPipelineId, joinObj) => {
-                let externalEvent = joinObj.event;
-                const nextJobs = joinObj.jobs;
-                let nextJobNames = Object.keys(nextJobs);
-                const triggerName = `sd@${current.pipeline.id}:${current.job.name}`;
-
-                if (externalEvent) {
-                    // Remote join case
-                    // fetch builds created due to restart
-                    const externalGroupBuilds = await getFinishedBuilds(externalEvent, buildFactory);
-
-                    const buildsToRestart = nextJobNames
-                        .map(j => {
-                            const existingBuild = externalGroupBuilds.find(b => b.jobId === nextJobs[j].id);
-
-                            return existingBuild &&
-                                existingBuild.status !== 'CREATED' &&
-                                !existingBuild.parentBuildId.includes(current.build.id) &&
-                                existingBuild.eventId !== current.event.parentEventId
-                                ? existingBuild
-                                : null;
-                        })
-                        .filter(b => b !== null);
-
-                    // fetch builds created due to trigger
-                    const parallelBuilds = await getParallelBuilds({
-                        eventFactory,
-                        parentEventId: externalEvent.id,
-                        pipelineId: externalEvent.pipelineId
-                    });
-
-                    externalGroupBuilds.push(...parallelBuilds);
-
-                    if (buildsToRestart.length) {
-                        const { parentBuilds } = buildsToRestart[0];
-
-                        // If restart handle like a fresh trigger
-                        // and start all jobs which are not join jobs
-                        const externalBuildConfig = {
-                            pipelineFactory,
-                            eventFactory,
-                            externalPipelineId,
-                            startFrom: `~${triggerName}`,
-                            parentBuildId: current.build.id,
-                            parentBuilds,
-                            causeMessage: `Triggered by ${triggerName}`,
-                            parentEventId: current.event.id,
-                            groupEventId: externalEvent.id
-                        };
-
-                        // proceed with join jobs using new external event
-                        nextJobNames = nextJobNames.filter(j => nextJobs[j].join.length);
-
-                        externalEvent = await createExternalBuild(externalBuildConfig);
-                    }
-
-                    // create/start build for each of nextJobs
-                    for (const nextJobName of nextJobNames) {
-                        const { username, scmContext } = config;
-                        const nextJob = nextJobs[nextJobName];
-                        // create new build if restart case.
-                        // externalGroupBuilds will contain previous externalEvent's builds
-                        const nextBuild = buildsToRestart.length
-                            ? null
-                            : externalGroupBuilds.find(b => b.jobId === nextJob.id);
-                        let newBuild;
-
-                        const { parentBuilds } = parseJobInfo({
-                            joinObj: nextJobs,
-                            current,
-                            nextJobName,
-                            nextPipelineId: externalPipelineId
-                        });
-
-                        fillParentBuilds(parentBuilds, current, externalGroupBuilds, externalEvent);
-
-                        const joinList = nextJobs[nextJobName].join;
-                        const joinListNames = joinList.map(j => j.name);
-                        const isORTrigger = !joinListNames.includes(triggerName);
-
-                        if (nextBuild) {
-                            // update current build info in parentBuilds
-                            // nextBuild is not build model, so fetch proper build
-                            newBuild = await updateParentBuilds({
-                                joinParentBuilds: parentBuilds,
-                                nextBuild: await buildFactory.get(nextBuild.id),
-                                build: current.build
-                            });
-                        } else {
-                            // no existing build, so first time processing this job
-                            // in the external pipeline's event
-                            const parentBuildId = getParentBuildIds({
-                                currentBuildId: current.build.id,
-                                parentBuilds,
-                                joinListNames,
-                                pipelineId: externalPipelineId
-                            });
-
-                            newBuild = await createInternalBuild({
-                                jobFactory,
-                                buildFactory,
-                                pipelineId: externalEvent.pipelineId,
-                                jobName: nextJob.name,
-                                jobId: nextJob.id,
-                                username,
-                                scmContext,
-                                event: externalEvent, // this is the parentBuild for the next build
-                                baseBranch: externalEvent.baseBranch || null,
-                                parentBuilds,
-                                parentBuildId,
-                                start: false
-                            });
-                        }
-
-                        if (isORTrigger) {
-                            if (['CREATED', null, undefined].includes(newBuild.status)) {
-                                newBuild.status = 'QUEUED';
-                                await newBuild.update();
-                                await newBuild.start();
-                            }
-                        } else {
-                            const { hasFailure, done } = await getParentBuildStatus({
-                                newBuild,
-                                joinListNames,
-                                pipelineId: externalPipelineId,
-                                buildFactory
-                            });
-
-                            // Check if external pipeline has Join
-                            // and join conditions are met
-                            await handleNewBuild({
-                                done,
-                                hasFailure,
-                                newBuild,
-                                jobName: nextJobName,
-                                pipelineId: externalPipelineId,
-                                stage: current.stage
-                            });
-                        }
-                    }
-
-                    return null;
-                }
-
-                const { parentBuilds } = parseJobInfo({ current });
-
-                // Simply create an external event if external job is not join job.
-                // Straight external trigger flow.
-                const externalBuildConfig = {
-                    pipelineFactory,
-                    eventFactory,
-                    externalPipelineId,
-                    startFrom: `~${triggerName}`,
-                    parentBuildId: current.build.id,
-                    parentBuilds,
-                    causeMessage: `Triggered by ${triggerName}`,
-                    parentEventId: current.event.id,
-                    groupEventId: null
-                };
-
-                return createExternalBuild(externalBuildConfig);
-            };
-
-            for (const pid of Object.keys(pipelineJoinData)) {
-                // typecast pid to number
-                let triggerCurrentPipelineAsExternal = false;
-                const isCurrentPipeline = +pid === current.pipeline.id;
-
-                if (isCurrentPipeline) {
-                    for (const nextJobName of Object.keys(pipelineJoinData[pid].jobs)) {
-                        const resource = `pipeline:${current.pipeline.id}:event:${current.event.id}`;
-                        let lock;
-
-                        try {
-                            const { isExternal } = pipelineJoinData[pid].jobs[nextJobName];
-
-                            triggerCurrentPipelineAsExternal = triggerCurrentPipelineAsExternal || isExternal;
-                            if (!isExternal) {
-                                lock = await locker.lock(resource);
-
-                                await triggerNextJobInSamePipeline(nextJobName, pipelineJoinData[pid].jobs);
-                            }
-                        } catch (err) {
-                            logger.error(
-                                `Error in triggerNextJobInSamePipeline:${nextJobName} from pipeline:${current.pipeline.id}-${current.job.name}-event:${current.event.id} `,
-                                err
-                            );
-                        }
-
-                        await locker.unlock(lock, resource);
-                    }
-                }
-
-                if (triggerCurrentPipelineAsExternal || !isCurrentPipeline) {
-                    let resource;
-                    let lock;
-
-                    try {
-                        if (isCurrentPipeline) {
-                            // force external trigger for jobs in same pipeline if user used external trigger syntax
-                            delete pipelineJoinData[pid].event;
-                        }
-                        const extEvent = pipelineJoinData[pid].event;
-
-                        // no need to lock if there is no external event
-                        if (extEvent) {
-                            resource = `pipeline:${pid}:event:${extEvent.id}`;
-                            lock = await locker.lock(resource);
-                        }
-
-                        await triggerJobsInExternalPipeline(pid, pipelineJoinData[pid]);
-                    } catch (err) {
-                        logger.error(
-                            `Error in triggerJobsInExternalPipeline:${pid} from pipeline:${current.pipeline.id}-${current.job.name}-event:${current.event.id} `,
-                            err
-                        );
-                    }
-
-                    await locker.unlock(lock, resource);
-                }
-            }
-
-            return null;
-        });
+        server.expose('triggerNextJobs', triggerNextJobs);
 
         server.route([
             getRoute(),