screwdriver-queue-service 5.0.4 → 5.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-queue-service",
-  "version": "5.0.4",
+  "version": "5.0.5",
   "description": "Screwdriver Queue Service API",
   "main": "app.js",
   "directories": {

package/plugins/queue/scheduler.js

@@ -20,16 +20,6 @@ const TEMPORAL_TOKEN_TIMEOUT = 12 * 60; // 12 hours in minutes
 const TEMPORAL_UNZIP_TOKEN_TIMEOUT = 2 * 60; // 2 hours in minutes
 const BLOCKED_BY_SAME_JOB_WAIT_TIME = 5;
 
-/**
- * Checks whether the job associated with the build is virtual or not
- * @method isVirtualJob
- * @param {Object} annotations           Job Annotations
- * @return {Boolean}
- */
-function isVirtualJob(annotations) {
-    return annotations && annotations['screwdriver.cd/virtualJob'];
-}
-
 /**
  * Posts a new build event to the API
  * @method postBuildEvent
@@ -310,8 +300,7 @@ async function start(executor, config) {
         apiUri,
         pipeline,
         isPR,
-        prParentJobId,
-        annotations
+        prParentJobId
     } = config;
     const forceStart = /\[(force start)\]/.test(causeMessage);
 
@@ -422,87 +411,59 @@ async function start(executor, config) {
             throw value.error;
         }
 
-        if (isVirtualJob(annotations)) {
-            // Bypass execution of the build if the job is virtual
-            const buildUpdatePayload = {
-                status: 'SUCCESS',
-                statusMessage: 'Skipped execution of the virtual job',
-                statusMessageType: 'INFO'
-            };
+        const token = executor.tokenGen(Object.assign(tokenConfig, { scope: ['temporal'] }), TEMPORAL_TOKEN_TIMEOUT);
 
+        if (buildStats) {
             await helper
                 .updateBuild(
                     {
                         buildId,
                         token: buildToken,
                         apiUri,
-                        payload: buildUpdatePayload
+                        payload: { stats: build.stats, status: 'QUEUED' }
                     },
                     helper.requestRetryStrategy
                 )
                 .catch(err => {
-                    logger.error(`Failed to update virtual build status for build ${buildId}: ${err}`);
-
+                    logger.error(`Failed to update build status to QUEUED for build ${buildId}: ${err}`);
                     throw err;
                 });
-        } else {
-            if (buildStats) {
-                await helper
-                    .updateBuild(
-                        {
-                            buildId,
-                            token: buildToken,
-                            apiUri,
-                            payload: { stats: build.stats, status: 'QUEUED' }
-                        },
-                        helper.requestRetryStrategy
-                    )
-                    .catch(err => {
-                        logger.error(`Failed to update build status to QUEUED for build ${buildId}: ${err}`);
-                        throw err;
-                    });
-            }
+        }
 
-            try {
-                const token = executor.tokenGen(
-                    Object.assign(tokenConfig, { scope: ['temporal'] }),
-                    TEMPORAL_TOKEN_TIMEOUT
-                );
+        try {
+            // set the start time in the queue
+            Object.assign(config, { token });
+            // Store the config in redis
+            await executor.redisBreaker.runCommand('hset', executor.buildConfigTable, buildId, JSON.stringify(config));
+
+            const blockedBySameJob = reach(config, 'annotations>screwdriver.cd/blockedBySameJob', {
+                separator: '>',
+                default: true
+            });
+            const blockedBySameJobWaitTime = reach(config, 'annotations>screwdriver.cd/blockedBySameJobWaitTime', {
+                separator: '>',
+                default: BLOCKED_BY_SAME_JOB_WAIT_TIME
+            });
+            const virtualJob = reach(config, 'annotations>screwdriver.cd/virtualJob', {
+                separator: '>',
+                default: false
+            });
 
-                // set the start time in the queue
-                Object.assign(config, { token });
-                // Store the config in redis
-                await executor.redisBreaker.runCommand(
-                    'hset',
-                    executor.buildConfigTable,
+            // Note: arguments to enqueue are [queue name, job name, array of args]
+            enq = await executor.queueBreaker.runCommand('enqueue', executor.buildQueue, 'start', [
+                {
                     buildId,
-                    JSON.stringify(config)
-                );
-
-                const blockedBySameJob = reach(config, 'annotations>screwdriver.cd/blockedBySameJob', {
-                    separator: '>',
-                    default: true
-                });
-                const blockedBySameJobWaitTime = reach(config, 'annotations>screwdriver.cd/blockedBySameJobWaitTime', {
-                    separator: '>',
-                    default: BLOCKED_BY_SAME_JOB_WAIT_TIME
-                });
-
-                // Note: arguments to enqueue are [queue name, job name, array of args]
-                enq = await executor.queueBreaker.runCommand('enqueue', executor.buildQueue, 'start', [
-                    {
-                        buildId,
-                        jobId,
-                        blockedBy: blockedBy.toString(),
-                        blockedBySameJob,
-                        blockedBySameJobWaitTime
-                    }
-                ]);
-            } catch (err) {
-                logger.error(`Redis enqueue failed for build ${buildId}: ${err}`);
+                    jobId,
+                    blockedBy: blockedBy.toString(),
+                    blockedBySameJob,
+                    blockedBySameJobWaitTime,
+                    virtualJob
+                }
+            ]);
+        } catch (err) {
+            logger.error(`Redis enqueue failed for build ${buildId}: ${err}`);
 
-                throw err;
-            }
+            throw err;
         }
     }
 

package/plugins/worker/lib/jobs.js

@@ -244,8 +244,35 @@ async function schedule(job, buildConfig) {
 async function start(buildConfig) {
     try {
         const fullBuildConfig = await redis.hget(`${queuePrefix}buildConfigs`, buildConfig.buildId);
+        const parsedConfig = fullBuildConfig && JSON.parse(fullBuildConfig);
+
+        // Short-circuit virtual jobs: mark success and skip executor start
+        if (buildConfig.virtualJob) {
+            const payload = {
+                status: 'SUCCESS',
+                statusMessage: 'Skipped execution of the virtual job',
+                statusMessageType: 'INFO'
+            };
+
+            // Preserve any queued stats (e.g. queueEnterTime) if present
+            if (parsedConfig && parsedConfig.stats) {
+                payload.stats = parsedConfig.stats;
+            }
+
+            await helper.updateBuild(
+                {
+                    buildId: buildConfig.buildId,
+                    token: parsedConfig && parsedConfig.token,
+                    apiUri: parsedConfig && parsedConfig.apiUri,
+                    payload
+                },
+                helper.requestRetryStrategy
+            );
+
+            return null;
+        }
 
-        await schedule('start', JSON.parse(fullBuildConfig));
+        await schedule('start', parsedConfig);
 
         return null;
     } catch (err) {