screwdriver-api 7.0.35 → 7.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screwdriver-api",
-  "version": "7.0.35",
+  "version": "7.0.36",
   "description": "API server for the Screwdriver.cd service",
   "main": "index.js",
   "scripts": {

package/plugins/pipelines/README.md

@@ -288,4 +288,37 @@ Example payload:
         }]
     }
 }
-```
+```
+
+#### Get a pipeline template by namespace and name
+
+`GET /pipeline/template/{namespace}/{name}`
+
+##### Get a specific pipeline template by id
+
+`GET /pipeline/template/{id}`
+
+##### Get version of a pipeline template by name, namespace, version or tag
+
+`GET /pipeline/template/{namespace}/{name}/{versionOrTag}`
+
+
+#### Template Tag
+Template tag allows fetching on template version by tag. For example, tag `mytemplate@1.1.0` as `stable`.
+
+##### Get all tags for a pipeline template by name, namespace
+
+`GET /pipeline/templates/{namespace}/{name}/tags`
+
+Can use additional options for sorting, pagination and count:
+`GET /pipeline/templates/{namespace}/{name}/tags?sort=ascending&sortBy=name&page=1&count=50`
+
+##### Create/Update a tag
+
+If the template tag already exists, it will update the tag with the new version. If the template tag doesn't exist yet, this endpoint will create the tag.
+
+*Note: This endpoint is only accessible in `build` scope and the permission is tied to the pipeline that creates the template.*
+
+`PUT /templates/{templateName}/tags/{tagName}` with the following payload
+
+* `version` - Exact version of the template (ex: `1.1.0`)

package/plugins/pipelines/index.js

@@ -29,10 +29,15 @@ 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');
-const listTemplates = require('./templates/list');
-const listTemplateVersions = require('./templates/listVersions');
+const createTemplateRoute = require('./templates/create');
+const validateTemplateRoute = require('./templates/validate');
+const listTemplatesRoute = require('./templates/list');
+const listTemplateVersionsRoute = require('./templates/listVersions');
+const listTagsRoute = require('./templates/listTags');
+const getTemplateRoute = require('./templates/get');
+const getTemplateByIdRoute = require('./templates/getTemplateById');
+const createTagRoute = require('./templates/createTag');
+const getVersionRoute = require('./templates/getVersion');
 
 /**
  * Pipeline API Plugin
@@ -200,10 +205,15 @@ const pipelinesPlugin = {
             getAdmin(),
             deleteCache(),
             openPrRoute(),
-            createTemplate(),
-            validateTemplate(),
-            listTemplates(),
-            listTemplateVersions()
+            createTemplateRoute(),
+            validateTemplateRoute(),
+            listTemplatesRoute(),
+            listTemplateVersionsRoute(),
+            listTagsRoute(),
+            getVersionRoute(),
+            getTemplateByIdRoute(),
+            getTemplateRoute(),
+            createTagRoute()
         ]);
     }
 };

package/plugins/pipelines/templates/createTag.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const baseSchema = schema.models.templateTag.base;
+const metaSchema = schema.models.templateMeta.base;
+
+module.exports = () => ({
+    method: 'PUT',
+    path: '/pipeline/template/{namespace}/{name}/tags/{tag}',
+    options: {
+        description: 'Add or update a pipeline template tag',
+        notes: 'Add or update a specific template',
+        tags: ['api', 'templates'],
+        auth: {
+            strategies: ['token'],
+            scope: ['build']
+        },
+        handler: async (request, h) => {
+            const { pipelineFactory, pipelineTemplateVersionFactory, pipelineTemplateTagFactory } = request.server.app;
+
+            const { isPR, pipelineId } = request.auth.credentials;
+
+            const { name, namespace, tag } = request.params;
+
+            const { version } = request.payload;
+
+            const [pipeline, template, templateTag] = await Promise.all([
+                pipelineFactory.get(pipelineId),
+                pipelineTemplateVersionFactory.get({ name, namespace, version }),
+                pipelineTemplateTagFactory.get({ name, namespace, tag })
+            ]);
+
+            // If template doesn't exist, throw error
+            if (!template) {
+                throw boom.notFound(`PipelineTemplate ${name}@${version} not found`);
+            }
+
+            // check if build has permission to publish
+            if (pipeline.id !== template.pipelineId || isPR) {
+                throw boom.forbidden('Not allowed to tag this pipeline template');
+            }
+
+            // If template tag exists, update the version
+            if (templateTag) {
+                templateTag.version = version;
+
+                const newTag = await templateTag.update();
+
+                return h.response(newTag.toJson()).code(200);
+            }
+
+            const newTag = await pipelineTemplateTagFactory.create({ namespace, name, tag, version });
+
+            const location = new URL(
+                `${request.path}/${newTag.id}`,
+                `${request.server.info.protocol}://${request.headers.host}`
+            ).toString();
+
+            return h.response(newTag.toJson()).header('Location', location).code(201);
+        },
+        validate: {
+            params: joi.object({
+                namespace: metaSchema.extract('namespace'),
+                name: metaSchema.extract('name'),
+                tag: baseSchema.extract('tag')
+            }),
+            payload: joi.object({
+                version: baseSchema.extract('version')
+            })
+        }
+    }
+});

package/plugins/pipelines/templates/get.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const getSchema = schema.models.templateMeta.get;
+const metaSchema = schema.models.templateMeta.base;
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/pipeline/template/{namespace}/{name}',
+    options: {
+        description: 'Get a specific template by namespace and name',
+        notes: 'Returns template meta for the specified namespace and name',
+        tags: ['api', 'pipeline', 'template'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'build']
+        },
+        handler: async (request, h) => {
+            console.log('request.params', request.params);
+
+            const { namespace, name } = request.params;
+            const { pipelineTemplateFactory } = request.server.app;
+
+            const pipelineTemplate = await pipelineTemplateFactory.get({
+                name,
+                namespace
+            });
+
+            if (!pipelineTemplate) {
+                throw boom.notFound('Pipeline Template does not exist');
+            }
+
+            return h.response(pipelineTemplate).code(200);
+        },
+        response: {
+            schema: getSchema
+        },
+        validate: {
+            params: joi.object({
+                namespace: metaSchema.extract('namespace'),
+                name: metaSchema.extract('name')
+            })
+        }
+    }
+});

package/plugins/pipelines/templates/getTemplateById.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const getSchema = schema.models.templateMeta.get;
+const idSchema = schema.models.templateMeta.base.extract('id');
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/pipeline/template/{id}',
+    options: {
+        description: 'Get a single template',
+        notes: 'Returns a template record',
+        tags: ['api', 'templates'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'build']
+        },
+        handler: async (request, h) => {
+            const { pipelineTemplateFactory } = request.server.app;
+
+            const pipelineTemplate = await pipelineTemplateFactory.get({ id: request.params.id });
+
+            if (!pipelineTemplate) {
+                throw boom.notFound('Pipeline Template does not exist');
+            }
+
+            return h.response(pipelineTemplate).code(200);
+        },
+        response: {
+            schema: getSchema
+        },
+        validate: {
+            params: joi.object({
+                id: idSchema
+            })
+        }
+    }
+});

package/plugins/pipelines/templates/getVersion.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const boom = require('@hapi/boom');
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const metaSchema = schema.models.templateMeta.base;
+const versionSchema = schema.models.pipelineTemplateVersions.base.extract('version');
+const tagSchema = schema.models.templateTag.base.extract('tag');
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/pipeline/template/{namespace}/{name}/{versionOrTag}',
+    options: {
+        description: 'Get a specific template version details by version number or tag',
+        notes: 'Returns template meta and version for namespace, name and version/tag',
+        tags: ['api', 'pipeline', 'template'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'build']
+        },
+        handler: async (request, h) => {
+            const { namespace, name, versionOrTag } = request.params;
+            const { pipelineTemplateVersionFactory } = request.server.app;
+
+            const pipelineTemplate = await pipelineTemplateVersionFactory.getWithMetadata({
+                name,
+                namespace,
+                versionOrTag
+            });
+
+            if (!pipelineTemplate) {
+                throw boom.notFound('Pipeline Template does not exist');
+            }
+
+            return h.response(pipelineTemplate).code(200);
+        },
+        validate: {
+            params: joi.object({
+                namespace: metaSchema.extract('namespace'),
+                name: metaSchema.extract('name'),
+                versionOrTag: joi.alternatives().try(versionSchema, tagSchema)
+            })
+        }
+    }
+});

package/plugins/pipelines/templates/listTags.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const joi = require('joi');
+const schema = require('screwdriver-data-schema');
+const listSchema = joi.array().items(schema.models.templateTag.base).label('List of templates');
+const metaSchema = schema.models.templateMeta.base;
+
+module.exports = () => ({
+    method: 'GET',
+    path: '/pipeline/templates/{namespace}/{name}/tags',
+    options: {
+        description: 'Get all pipeline template tags for a given template name and namespace',
+        notes: 'Returns all pipeline template tags for a given template name and namespace',
+        tags: ['api', 'templates', 'tags'],
+        auth: {
+            strategies: ['token'],
+            scope: ['user', 'build']
+        },
+
+        handler: async (request, h) => {
+            const { pipelineTemplateTagFactory } = request.server.app;
+            const config = {
+                params: request.params,
+                sort: request.query.sort
+            };
+
+            if (request.query.page || request.query.count) {
+                config.paginate = {
+                    page: request.query.page,
+                    count: request.query.count
+                };
+            }
+
+            const tags = await pipelineTemplateTagFactory.list(config);
+
+            return h.response(tags);
+        },
+        response: {
+            schema: listSchema
+        },
+        validate: {
+            params: joi.object({
+                namespace: metaSchema.extract('namespace'),
+                name: metaSchema.extract('name')
+            }),
+            query: schema.api.pagination.concat(
+                joi.object({
+                    search: joi.forbidden()
+                })
+            )
+        }
+    }
+});