screwdriver-api 7.0.210 → 7.0.212

package/package.json

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

package/plugins/builds/README.md

@@ -43,6 +43,10 @@ Arguments:
 #### List the build step by status
 `GET /builds/{id}/steps`
 
+Arguments:
+
+* `status` - Status to filter by
+
 `GET /builds/{id}/steps?status=active`
 
 `GET /builds/{id}/steps?status=failure`
@@ -62,6 +66,18 @@ Example payload:
 }
 ```
 
+#### Gets all build artifacts as ZIP file
+`GET /builds/{id}/artifacts`
+
+#### Gets a build artifact or directory as ZIP file
+`GET /builds/{id}/artifacts/{name*}`
+
+Arguments:
+
+* `type` - Return type for build artifact, `download` or `preview`
+
+`GET /builds/{id}/artifacts/{name*}?type=preview`
+
 #### Get build statuses
 `GET /builds/statuses`
 

package/plugins/builds/artifacts/get.js

@@ -3,8 +3,11 @@
 const boom = require('@hapi/boom');
 const joi = require('joi');
 const jwt = require('jsonwebtoken');
-const request = require('screwdriver-request');
+const request = require('got');
 const schema = require('screwdriver-data-schema');
+const archiver = require('archiver');
+const { PassThrough } = require('stream');
+const logger = require('screwdriver-logger');
 const { v4: uuidv4 } = require('uuid');
 const idSchema = schema.models.build.base.extract('id');
 const artifactSchema = joi.string().label('Artifact Name');
@@ -45,41 +48,113 @@ module.exports = config => ({
                     return canAccessPipeline(credentials, event.pipelineId, 'pull', req.server.app);
                 })
                 .then(async () => {
-                    const encodedArtifact = encodeURIComponent(artifact);
+                    // Directory should fetch manifest and
+                    // gather all files that belong to that directory
+                    if (artifact.endsWith('/')) {
+                        try {
+                            const token = jwt.sign({
+                                buildId, artifact, scope: ['user']
+                            }, config.authConfig.jwtPrivateKey, {
+                                algorithm: 'RS256',
+                                expiresIn: '10m',
+                                jwtid: uuidv4()
+                            });
+                            const baseUrl = `${config.ecosystem.store}/v1/builds/${buildId}/ARTIFACTS`;
+                            // Fetch the manifest
+                            const manifest = await request({
+                                url: `${baseUrl}/manifest.txt?token=${token}`,
+                                method: 'GET'
+                            }).text();
+                            const manifestArray = manifest.trim().split('\n');
+                            const directoryArray = manifestArray.filter(f => f.startsWith(`./${artifact}`));
 
-                    const token = jwt.sign({
-                        buildId, artifact, scope: ['user']
-                    }, config.authConfig.jwtPrivateKey, {
-                        algorithm: 'RS256',
-                        expiresIn: '5s',
-                        jwtid: uuidv4()
-                    });
+                            // Create a stream and set up archiver
+                            const archive = archiver('zip', { zlib: { level: 9 } });
+                            const passThrough = new PassThrough();
 
-                    let baseUrl = `${config.ecosystem.store}/v1/builds/`
-                        + `${buildId}/ARTIFACTS/${encodedArtifact}?token=${token}&type=${req.query.type}`;
+                            // Handle archiver errors
+                            archive.on('error', (err) => {
+                                logger.error('Archiver error:', err);
+                                passThrough.emit('error', err); // Propagate the error to the PassThrough stream
+                            });
 
-                    const requestStream = request.stream(baseUrl);
+                            // Handle passThrough errors
+                            passThrough.on('error', (err) => {
+                                logger.error('PassThrough stream error:', err);
+                            });
 
-                    let response = h.response(requestStream);
+                            // Pipe the archive to PassThrough
+                            archive.pipe(passThrough);
 
-                    return new Promise((resolve, reject) => {
-                        requestStream.on('response', response => {
-                            resolve(response.headers);
-                        });
-                        requestStream.on('error', err => {
-                            if (err.response && err.response.statusCode === 404) {
-                                reject(boom.notFound('File not found'));
-                            } else {
-                                reject(err);
+                            // Fetch and append the directory files
+                            for (const file of directoryArray) {
+                                if (file) {
+                                    const fileStream = request.stream(`${baseUrl}/${file}?token=${token}&type=download`);
+
+                                    // Handle errors from file streaming
+                                    fileStream.on('error', (err) => {
+                                        logger.error(`Error downloading file: ${file}`, err);
+                                        archive.emit('error', err); // Emit error to stop the archive process
+                                    });
+
+                                    // Append the file stream to the archive
+                                    archive.append(fileStream, { name: file });
+                                }
                             }
+
+                            // Finalize the archive once all files are appended
+                            archive.finalize();
+
+                            // Create a zip name from the directory structure
+                            const zipName = artifact.split('/').slice(-2)[0];
+
+                            // Respond with the PassThrough stream (which is readable by Hapi)
+                            return h.response(passThrough)
+                                .type('application/zip')
+                                .header('Content-Disposition', `attachment; filename="${zipName}_dir.zip"`);
+                        } catch (err) {
+                            // Catch errors related to the manifest request or other async issues
+                            logger.error('Error while streaming artifact files:', err);
+
+                            return h.response({ error: 'Failed to generate ZIP file' }).code(500);
+                        }
+                    } else {
+                        const token = jwt.sign({
+                            buildId, artifact, scope: ['user']
+                        }, config.authConfig.jwtPrivateKey, {
+                            algorithm: 'RS256',
+                            expiresIn: '5s',
+                            jwtid: uuidv4()
                         });
-                    }).then(headers => {
-                        response.headers['content-type'] = headers['content-type'];
-                        response.headers['content-disposition'] = headers['content-disposition'];
-                        response.headers['content-length'] = headers['content-length'];
+                        const encodedArtifact = encodeURIComponent(artifact);
 
-                        return response;
-                    });
+                        // Fetch single file
+                        let baseUrl = `${config.ecosystem.store}/v1/builds/`
+                            + `${buildId}/ARTIFACTS/${encodedArtifact}?token=${token}&type=${req.query.type}`;
+
+                        const requestStream = request.stream(baseUrl);
+
+                        let response = h.response(requestStream);
+
+                        return new Promise((resolve, reject) => {
+                            requestStream.on('response', response => {
+                                resolve(response.headers);
+                            });
+                            requestStream.on('error', err => {
+                                if (err.response && err.response.statusCode === 404) {
+                                    reject(boom.notFound('File not found'));
+                                } else {
+                                    reject(err);
+                                }
+                            });
+                        }).then(headers => {
+                            response.headers['content-type'] = headers['content-type'];
+                            response.headers['content-disposition'] = headers['content-disposition'];
+                            response.headers['content-length'] = headers['content-length'];
+
+                            return response;
+                        });
+                    }
                 })
                 .catch(err => {
                     throw err;