screwdriver-api 7.0.23 → 7.0.25

package/bin/server

@@ -216,6 +216,10 @@ const stageFactory = Models.StageFactory.getInstance({
     datastore,
     datastoreRO
 });
+const stageBuildFactory = Models.StageBuildFactory.getInstance({
+    datastore,
+    datastoreRO
+});
 const triggerFactory = Models.TriggerFactory.getInstance({
     datastore,
     datastoreRO
@@ -253,6 +257,7 @@ datastore.setup(datastoreConfig.ddlSyncEnabled).then(() =>
         eventFactory,
         collectionFactory,
         stageFactory,
+        stageBuildFactory,
         triggerFactory,
         banners: authConfig,
         builds: {

package/config/default.yaml

@@ -315,6 +315,7 @@ bookends:
       - screwdriver-cache-bookend
     teardown:
       - screwdriver-artifact-bookend
+      - screwdriver-coverage-bookend
       - screwdriver-cache-bookend
 
 notifications:

package/lib/server.js

@@ -75,6 +75,7 @@ function prettyPrintErrors(request, h) {
  * @param  {Factory}     config.eventFactory        Event Factory instance
  * @param  {Factory}     config.collectionFactory   Collection Factory instance
  * @param  {Factory}     config.stageFactory        Stage Factory instance
+ * @param  {Factory}     config.stageBuildFactory   Stage Build Factory instance
  * @param  {Factory}     config.triggerFactory      Trigger Factory instance
  * @param  {Object}      config.builds              Config to include for builds plugin
  * @param  {Object}      config.builds.ecosystem    List of hosts in the ecosystem
@@ -126,6 +127,7 @@ module.exports = async config => {
             templateFactory: config.templateFactory,
             templateTagFactory: config.templateTagFactory,
             stageFactory: config.stageFactory,
+            stageBuildFactory: config.stageBuildFactory,
             triggerFactory: config.triggerFactory,
             pipelineFactory: config.pipelineFactory,
             jobFactory: config.jobFactory,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "7.0.23",
+  "version": "7.0.25",
   "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.7.0",
+    "screwdriver-models": "^29.11.0",
     "screwdriver-notifications-email": "^3.0.0",
     "screwdriver-notifications-slack": "^5.0.0",
     "screwdriver-request": "^2.0.1",

package/plugins/coverage/token.js

@@ -64,6 +64,8 @@ module.exports = config => ({
                     throw boom.notFound(`Pipeline ${pipelineId} does not exist`);
                 }
 
+                logger.info(`looking up pipeline from:${pipelineId}, and found pipeline:${pipeline}`);
+
                 tokenConfig.pipelineName = pipeline.name;
             }
 
@@ -82,50 +84,57 @@ module.exports = config => ({
 
                 const selfSonar = new CoveragePlugin(selfSonarConfig);
                 const data = await selfSonar.coveragePlugin.getAccessToken(tokenConfig);
-                const projectUrl = selfSonar.coveragePlugin.getProjectData(tokenConfig);
-
-                if (pipeline && projectUrl) {
-                    try {
-                        const pipelineSonarBadge = {
-                            defaultName: pipelineId,
-                            defaultUri: projectUrl
-                        };
-                        let shouldPipelineUpdate = true;
-
-                        if (
-                            pipeline.badges &&
-                            pipeline.badges.sonar &&
-                            pipeline.badges.sonar.defaultName === pipelineId &&
-                            pipeline.badges.sonar.defaultUri === projectUrl
-                        ) {
-                            shouldPipelineUpdate = false;
-                        }
 
-                        if (shouldPipelineUpdate) {
-                            if (pipeline.badges) {
-                                pipeline.badges.sonar = pipelineSonarBadge;
-                            } else {
-                                pipeline.badges = {
-                                    sonar: pipelineSonarBadge
-                                };
-                            }
-
-                            await pipeline.update();
-                            logger.info(
-                                `update pipeline:${pipeline.id}'s sonar badge with defaultName:${pipelineId}, defaultUri: ${projectUrl}`
-                            );
+                return h.response(data);
+            }
+
+            const data = await config.coveragePlugin.getAccessToken(tokenConfig);
+            const { projectUrl } = config.coveragePlugin.getProjectData(tokenConfig);
+
+            if (!pipeline && pipelineId) {
+                pipeline = await pipelineFactory.get(pipelineId);
+
+                logger.info(`looking up again, pipeline:${pipelineId}, and found pipeline: ${pipeline}`);
+            }
+
+            if (pipeline && projectUrl) {
+                try {
+                    const pipelineSonarBadge = {
+                        defaultName: `${pipelineId}`, // ensure pipelineId is stored as String instead of Integer
+                        defaultUri: projectUrl
+                    };
+                    let shouldPipelineUpdate = true;
+
+                    if (
+                        pipeline.badges &&
+                        pipeline.badges.sonar &&
+                        pipeline.badges.sonar.defaultName === pipelineId &&
+                        pipeline.badges.sonar.defaultUri === projectUrl
+                    ) {
+                        shouldPipelineUpdate = false;
+                    }
+
+                    if (shouldPipelineUpdate) {
+                        if (pipeline.badges) {
+                            pipeline.badges.sonar = pipelineSonarBadge;
+                        } else {
+                            pipeline.badges = {
+                                sonar: pipelineSonarBadge
+                            };
                         }
-                    } catch (err) {
-                        logger.error(`Failed to update pipeline:${pipelineId}`, err);
 
-                        throw err;
+                        await pipeline.update();
                     }
-                }
 
-                return h.response(data);
-            }
+                    logger.info(
+                        `update pipeline:${pipeline.id}'s sonar badge with pipeline.badges, ${pipeline.badges}`
+                    );
+                } catch (err) {
+                    logger.error(`Failed to update pipeline:${pipelineId}`, err);
 
-            const data = await config.coveragePlugin.getAccessToken(tokenConfig);
+                    throw err;
+                }
+            }
 
             return h.response(data);
         }

package/plugins/events/index.js

@@ -4,6 +4,7 @@ const boom = require('@hapi/boom');
 const createRoute = require('./create');
 const getRoute = require('./get');
 const listBuildsRoute = require('./listBuilds');
+const listStageBuildsRoute = require('./listStageBuilds');
 const stopBuildsRoute = require('./stopBuilds');
 const metricsRoute = require('./metrics');
 
@@ -51,7 +52,14 @@ const eventsPlugin = {
             return Promise.resolve();
         });
 
-        server.route([createRoute(), getRoute(), listBuildsRoute(), stopBuildsRoute(), metricsRoute()]);
+        server.route([
+            createRoute(),
+            getRoute(),
+            listBuildsRoute(),
+            listStageBuildsRoute(),
+            stopBuildsRoute(),
+            metricsRoute()
+        ]);
     }
 };
 

package/plugins/events/listStageBuilds.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const stageBuildListSchema = joi.array().items(schema.models.stageBuild.get).label('List of stage builds');
+const eventIdSchema = schema.models.event.base.extract('id');
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/events/{id}/stageBuilds',
+    options: {
+        description: 'Get stage builds for a given event',
+        notes: 'Returns stage builds for a given event',
+        tags: ['api', 'events', 'stageBuilds'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'pipeline']
+        },
+
+        handler: async (request, h) => {
+            const { eventFactory } = request.server.app;
+            const event = await eventFactory.get(request.params.id);
+
+            if (!event) {
+                throw boom.notFound('Event does not exist');
+            }
+
+            return event
+                .getStageBuilds()
+                .then(stageBuilds => h.response(stageBuilds.map(c => c.toJson())))
+                .catch(err => {
+                    throw err;
+                });
+        },
+        response: {
+            schema: stageBuildListSchema
+        },
+        validate: {
+            params: joi.object({
+                id: eventIdSchema
+            })
+        }
+    }
+});

package/plugins/pipelines/README.md

@@ -121,9 +121,6 @@ Only PR events of specified PR number will be searched when `prNum` is set
 #### Get all stages for a single pipeline
 
 `GET /pipelines/{id}/stages`
-Will get latest commit event's stages if no event ID or group event ID is provided
-
-`GET /pipelines/{id}/stages?groupEventId={groupEventId}`
 
 `GET /pipelines/{id}/stages?eventId={eventId}`
 

package/plugins/pipelines/listStages.js

@@ -49,8 +49,6 @@ module.exports = () => ({
                         throw boom.notFound(`Latest event does not exist for pipeline ${pipelineId}`);
                     }
 
-                    config.params.eventId = latestCommitEvents[0].id;
-
                     return stageFactory.list(config);
                 })
                 .then(stages => h.response(stages.map(s => s.toJson())))

package/plugins/stages/README.md

@@ -0,0 +1,32 @@
+# Stages Plugin
+> API stages plugin for the Screwdriver API
+
+## Usage
+
+### Register plugin
+
+```javascript
+const Hapi = require('@hapi/hapi');
+const server = new Hapi.Server();
+const stagesPlugin = require('./');
+
+server.connection({ port: 3000 });
+
+server.register({
+    register: stagesPlugin,
+    options: {}
+}, () => {
+    server.start((err) => {
+        if (err) {
+            throw err;
+        }
+        console.log('Server running at:', server.info.uri);
+    });
+});
+```
+
+### Routes
+
+#### Get a listing of all stage builds for a stage
+
+`GET /stages/{id}/stageBuilds`

package/plugins/stages/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const getStageBuildsRoute = require('./stageBuilds/list');
+
+/**
+ * Stage API Plugin
+ * @method register
+ * @param  {Hapi}     server                Hapi Server
+ * @param  {Object}   options               Configuration
+ * @param  {Function} next                  Function to call when done
+ */
+const stagesPlugin = {
+    name: 'stages',
+    async register(server) {
+        server.route([getStageBuildsRoute()]);
+    }
+};
+
+module.exports = stagesPlugin;

package/plugins/stages/stageBuilds/list.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const listSchema = joi.array().items(schema.models.stageBuild.get).label('List of stage builds for a stage');
+const idSchema = schema.models.stage.base.extract('id');
+const eventIdSchema = schema.models.stageBuild.base.extract('eventId');
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/stages/{id}/stageBuilds',
+    options: {
+        description: 'Get stage builds for a stage',
+        notes: 'Returns all stage builds for a stage',
+        tags: ['api', 'stageBuilds'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', '!guest']
+        },
+
+        handler: async (request, h) => {
+            const { stageFactory, stageBuildFactory } = request.server.app;
+            const { page, count } = request.query;
+            const config = {
+                sort: request.query.sort,
+                params: {
+                    stageId: request.params.id
+                }
+            };
+
+            return stageFactory.get(config.params.stageId).then(async stage => {
+                if (!stage) {
+                    throw boom.notFound(`Stage ${config.params.stageId} does not exist`);
+                }
+
+                if (page || count) {
+                    config.paginate = { page, count };
+                }
+
+                // Set eventId if provided
+                if (request.query.eventId) {
+                    config.params.eventId = request.query.eventId;
+                }
+
+                return stageBuildFactory
+                    .list(config)
+                    .then(stageBuilds => h.response(stageBuilds.map(c => c.toJson())))
+                    .catch(err => {
+                        throw err;
+                    });
+            });
+        },
+        response: {
+            schema: listSchema
+        },
+        validate: {
+            params: joi.object({
+                id: idSchema
+            }),
+            query: schema.api.pagination.concat(
+                joi.object({
+                    eventId: eventIdSchema
+                })
+            )
+        }
+    }
+});