screwdriver-api 7.0.24 → 7.0.26

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
@@ -225,6 +229,16 @@ const buildClusterFactory = Models.BuildClusterFactory.getInstance({
     datastoreRO,
     scm
 });
+const pipelineTemplateFactory = Models.PipelineTemplateFactory.getInstance({
+    datastore,
+    datastoreRO,
+    scm
+});
+const pipelineTemplateVersionFactory = Models.PipelineTemplateVersionFactory.getInstance({
+    datastore,
+    datastoreRO,
+    scm
+});
 
 // @TODO run setup for SCM and Executor
 // datastoreConfig.ddlSync => sync datastore schema (ddl) via api (default: true)
@@ -246,6 +260,8 @@ datastore.setup(datastoreConfig.ddlSyncEnabled).then(() =>
         userFactory,
         buildFactory,
         buildClusterFactory,
+        pipelineTemplateFactory,
+        pipelineTemplateVersionFactory,
         stepFactory,
         bannerFactory,
         secretFactory,
@@ -253,6 +269,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
@@ -125,7 +126,13 @@ module.exports = async config => {
             commandTagFactory: config.commandTagFactory,
             templateFactory: config.templateFactory,
             templateTagFactory: config.templateTagFactory,
+            pipelineTemplateFactory: config.pipelineTemplateFactory,
+            pipelineTemplateVersionFactory: config.pipelineTemplateVersionFactory,
+            templateMetaFactory: config.templateMetaFactory,
+            jobTemplateTagFactory: config.jobTemplateTagFactory,
+            pipelineTemplateTagFactory: config.pipelineTemplateTagFactory,
             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.24",
+  "version": "7.0.26",
   "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",
@@ -123,7 +123,7 @@
     "screwdriver-scm-github": "^12.1.1",
     "screwdriver-scm-gitlab": "^3.1.0",
     "screwdriver-scm-router": "^7.0.0",
-    "screwdriver-template-validator": "^6.0.0",
+    "screwdriver-template-validator": "^7.0.0",
     "screwdriver-workflow-parser": "^4.1.1",
     "sqlite3": "^5.1.4",
     "stream": "0.0.2",

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/index.js

@@ -29,6 +29,8 @@ const latestCommitEvent = require('./latestCommitEvent');
 const getAdmin = require('./admins/get');
 const deleteCache = require('./caches/delete');
 const openPrRoute = require('./openPr');
+const createTemplate = require('./templates/create');
+const validateTemplate = require('./templates/validate');
 
 /**
  * Pipeline API Plugin
@@ -195,7 +197,9 @@ const pipelinesPlugin = {
             latestCommitEvent(),
             getAdmin(),
             deleteCache(),
-            openPrRoute()
+            openPrRoute(),
+            createTemplate(),
+            validateTemplate()
         ]);
     }
 };

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/pipelines/templates/create.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const schema = require('screwdriver-data-schema');
+const validator = require('screwdriver-template-validator').parsePipelineTemplate;
+const templateSchema = schema.api.templateValidator;
+
+module.exports = () => ({
+    method: 'POST',
+    path: '/pipeline/template',
+    options: {
+        description: 'Create a new pipeline template',
+        notes: 'Create a specific pipeline template',
+        tags: ['api', 'pipelineTemplate'],
+        auth: {
+            strategies: ['token'],
+            scope: ['build']
+        },
+
+        handler: async (request, h) => {
+            const { pipelineTemplateVersionFactory, pipelineTemplateFactory } = request.server.app;
+
+            const config = await validator(request.payload.yaml);
+
+            if (config.errors.length > 0) {
+                throw boom.badRequest(`Template has invalid format: ${config.errors.length} error(s).`, config.errors);
+            }
+
+            const pipelineTemplate = await pipelineTemplateFactory.get({
+                name: config.template.name,
+                namespace: config.template.namespace
+            });
+
+            const { isPR, pipelineId } = request.auth.credentials;
+
+            // If template name exists, but this build's pipelineId is not the same as template's pipelineId
+            // Then this build does not have permission to publish
+            if (isPR || (pipelineTemplate && pipelineId !== pipelineTemplate.pipelineId)) {
+                throw boom.forbidden('Not allowed to publish this template');
+            }
+
+            const template = await pipelineTemplateVersionFactory.create(
+                {
+                    ...config.template,
+                    pipelineId
+                },
+                pipelineTemplateFactory
+            );
+
+            const location = new URL(
+                `${request.path}/${template.id}`,
+                `${request.server.info.protocol}://${request.headers.host}`
+            ).toString();
+
+            return h.response(template.toJson()).header('Location', location).code(201);
+        },
+        validate: {
+            payload: templateSchema.input
+        }
+    }
+});

package/plugins/pipelines/templates/validate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const schema = require('screwdriver-data-schema');
+const templateSchema = schema.api.templateValidator;
+const pipelineValidator = require('screwdriver-template-validator').parsePipelineTemplate;
+
+module.exports = () => ({
+    method: 'POST',
+    path: '/pipeline/template/validate',
+    options: {
+        description: 'Validate a given sd-template.yaml',
+        notes: 'returns the parsed config, validation errors, or both',
+        tags: ['api', 'validation', 'yaml'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'pipeline']
+        },
+
+        handler: async (request, h) => {
+            try {
+                const { yaml: templateString } = request.payload;
+
+                const result = await pipelineValidator(templateString);
+
+                return h.response(result);
+            } catch (err) {
+                throw boom.badRequest(err.toString());
+            }
+        },
+        validate: {
+            payload: templateSchema.input
+        },
+        response: {
+            schema: templateSchema.output
+        }
+    }
+});

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
+                })
+            )
+        }
+    }
+});

package/plugins/template-validator.js

@@ -3,7 +3,7 @@
 const boom = require('@hapi/boom');
 const schema = require('screwdriver-data-schema');
 const templateSchema = schema.api.templateValidator;
-const validator = require('screwdriver-template-validator');
+const validator = require('screwdriver-template-validator').parseJobTemplate;
 
 /**
  * Hapi Template Validator Plugin

package/plugins/templates/create.js

@@ -3,7 +3,7 @@
 const urlLib = require('url');
 const boom = require('@hapi/boom');
 const schema = require('screwdriver-data-schema');
-const validator = require('screwdriver-template-validator');
+const validator = require('screwdriver-template-validator').parseJobTemplate;
 const templateSchema = schema.api.templateValidator;
 const hoek = require('@hapi/hoek');