codefresh 0.78.2

package/lib/interface/cli/commands/workflow/logs.cmd.js

@@ -0,0 +1,38 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+
+
+const run = new Command({
+    root: true,
+    command: 'logs <id>',
+    description: 'Show logs of a build',
+    webDocs: {
+        category: 'Builds',
+        title: 'Show Build Logs',
+        weight: 20,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id', {
+                describe: 'Build id',
+            })
+            .option('f', {
+                describe: 'Continue showing build logs until it will finish',
+                type: 'boolean',
+            })
+            .example('codefresh logs ID', 'Get logs of build ID')
+            .example('codefresh logs -f ID', 'Get all previous logs of build ID and attach to future logs');
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const workflowId = argv.id;
+        const follow = argv.f;
+
+        await sdk.logs.showWorkflowLogs(workflowId, follow);
+        // TODO fix this. its a workaround since something related to firebase in not properly closed
+        process.exit(0);
+    },
+});
+
+module.exports = run;

package/lib/interface/cli/commands/workflow/restart.cmd.js

@@ -0,0 +1,37 @@
+const Command = require('../../Command');
+const { followLogs } = require('../../helpers/logs');
+const { sdk } = require('../../../../logic');
+
+const restart = new Command({
+    root: true,
+    command: 'restart <id>',
+    description: 'Restart a build by its id',
+    webDocs: {
+        category: 'Builds',
+        title: 'Restart Build',
+        weight: 30,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Build id',
+            })
+            .option('detach', {
+                alias: 'd',
+                describe: 'Run build and print workflow ID',
+            })
+            .example('codefresh restart ID', 'Restart build ID and attach the created new build')
+            .example('codefresh restart ID -d', 'Restart build ID and return the new build id');
+    },
+    handler: async (argv) => {
+        const workflowId = await sdk.workflows.restart({ id: argv.id });
+        if (argv.detach) {
+            console.log(workflowId);
+            return;
+        }
+        const exitCode = await followLogs(workflowId);
+        process.exit(exitCode);
+    },
+});
+
+module.exports = restart;

package/lib/interface/cli/commands/workflow/terminate.cmd.js

@@ -0,0 +1,31 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const Workflow = require('../../../../logic/entities/Workflow');
+
+const terminate = new Command({
+    root: true,
+    command: 'terminate <id>',
+    description: 'Terminate a build by its id',
+    usage: 'This command will return once the request has been received from the server.\n The termination process can take time according to the pipeline definition',
+    webDocs: {
+        category: 'Builds',
+        title: 'Terminate Build',
+        weight: 40,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Build id',
+            })
+            .example('codefresh terminate ID', 'Terminate build ID');
+    },
+    handler: async (argv) => {
+        const workflowId = argv.id;
+        const buildResponse = await sdk.workflows.getBuild({ buildId: workflowId, noAccount: false });
+        const workflow = Workflow.fromResponse(buildResponse);
+        await sdk.progress.terminate({ id: workflow.info.progress });
+        console.log(`Build: ${workflowId} terminated`);
+    },
+});
+
+module.exports = terminate;

package/lib/interface/cli/commands/workflow/wait.cmd.js

@@ -0,0 +1,77 @@
+const _ = require('lodash');
+const CFError = require('cf-errors');
+const Command = require('../../Command');
+const { ObjectID } = require('mongodb');
+const moment = require('moment');
+const { sdk } = require('../../../../logic');
+const Promise = require('bluebird');
+
+
+const wait = new Command({
+    root: true,
+    command: 'wait <id..>',
+    description: 'Wait until a condition will be met on a build',
+    usage: 'Wait command is useful in case there is a need to wait for a desired status on a specific set of builds',
+    webDocs: {
+        category: 'Builds',
+        title: 'Wait For Build Condition',
+        weight: 50,
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('status', {
+                describe: 'Build status',
+                alias: 's',
+                choices: ['pending', 'elected', 'running', 'error', 'success', 'terminating', 'terminated', 'pending-approval', 'delayed'],
+                default: 'success',
+                required: true,
+            })
+            .option('verbose', {
+                alias: 'v',
+                describe: 'Show debug output until the condition will be met.',
+                default: false,
+                type: 'boolean',
+            })
+            .option('debug', {
+                alias: 'd',
+                describe: 'Show debug output until the condition will be met.',
+                omitFromDocs: true,
+            })
+            .option('timeout', {
+                alias: 't',
+                describe: 'Define a timeout for the wait operation in minutes',
+                default: 30,
+            })
+            .positional('id', {
+                describe: 'Build id',
+            })
+            .example('codefresh wait ID', 'Wait until build "ID" will reach "success" status')
+            .example('codefresh wait ID --status=terminated', 'Wait until build "ID" will reach "terminated" status')
+            .example('codefresh wait ID1 ID2', 'Wait until build "ID1" and build "ID2" will reach "success" status');
+    },
+    handler: async (argv) => {
+        const workflowIds = argv.id;
+        const desiredStatus = argv.status;
+        const descriptive = argv.d || argv.v;
+
+        _.forEach(workflowIds, (workflowId) => {
+            if (!ObjectID.isValid(workflowId)) {
+                throw new CFError({
+                    message: `Passed build id: ${workflowId} is not valid`,
+                });
+            }
+        });
+
+        const timeoutDate = moment()
+            .add(argv.timeout, 'minutes');
+
+        await Promise.map(workflowIds, (workflowId) => {
+            return sdk.workflows.waitForStatus(workflowId, desiredStatus, timeoutDate, descriptive)
+                .then(() => {
+                    console.log(`Build: ${workflowId} status: ${desiredStatus} reached`);
+                });
+        });
+    },
+});
+
+module.exports = wait;

package/lib/interface/cli/commands/workflow/workflow-data-item/create.cmd.js

@@ -0,0 +1,44 @@
+const _ = require('lodash');
+const Promise = require('bluebird');
+const Command = require('../../../Command');
+const createRoot = require('../../root/create.cmd');
+const { sdk } = require('../../../../../logic');
+const { crudFilenameOption } = require('../../../helpers/general');
+
+function builder(y) {
+    crudFilenameOption(y);
+    return y
+        .option('workflow', {
+            describe: 'Workflow ID that the Workflow-Data-Item belongs to',
+            required: true,
+            alias: 'wf',
+        })
+        .example('codefresh create workflow-data-item --workflow [WORKFLOW_ID] --file ./file.json', 'Create new Workflow-Data-Iten that belongs to WORKFLOW_ID with content from "./file.json"');
+}
+
+async function handler({ workflow, filename }) {
+    let payload;
+    if (filename) { // file content
+        payload = filename;
+    }
+    const res = await sdk.workflows.pushWorkflowData({
+        workflowId: workflow,
+    }, payload);
+    console.log(`Workflow-Data-Item ${_.get(res, '_id')} created`);
+    return Promise.resolve();
+}
+
+const command = new Command({
+    command: 'workflow-data-item',
+    aliases: ['wdi'],
+    parent: createRoot,
+    description: 'Create New Workflow Data Item',
+    webDocs: {
+        category: 'Workflow-Data',
+        title: 'Create',
+    },
+    builder,
+    handler,
+});
+
+module.exports = command;

package/lib/interface/cli/commands/workflow/workflow-data-item/get.cmd.js

@@ -0,0 +1,72 @@
+const _ = require('lodash');
+const Promise = require('bluebird');
+const Command = require('../../../Command');
+const getRoot = require('../../root/get.cmd');
+const { sdk } = require('../../../../../logic');
+const Output = require('../../../../../output/Output');
+const WorkflowDataItem = require('../../../../../logic/entities/WorkflowDataItem');
+
+async function _get(workflowId, workflowDataItemIds, decrypt) {
+    const result = [];
+    await Promise.map((workflowDataItemIds), async (id) => {
+        const res = await sdk.workflows.getWorkflowDataItem({
+            workflowId,
+            id,
+            decrypt,
+        });
+        result.push(WorkflowDataItem.fromResponse(res));
+        return Promise.resolve();
+    });
+    return result;
+}
+
+async function _list(workflowId) {
+    const res = await sdk.workflows.getWorkflowData({
+        workflowId,
+    });
+    return _.map(res.docs, WorkflowDataItem.fromResponse);
+}
+
+function builder(y) {
+    return y
+        .positional('id', {
+            describe: 'Workflow-Data-Item ID',
+        })
+        .option('workflow', {
+            describe: 'Workflow ID that the Workflow-Data-Item belongs to',
+            required: true,
+            alias: 'wf',
+        })
+        .option('decrypt', {
+            describe: 'When requesting spesific Workflow-Data-Item, decrypt the stored data',
+            typoe: 'boolean',
+        })
+        .example('codefresh get workflow-data-item --workflow [WORKFLOW_ID]', 'Get all Workflow-Data-Items for given WORKFLOW_ID')
+        .example('codefresh get workflow-data-item [WORKFLOW_DATA_ITEM_ID] --decrypt --workflow [WORKFLOW_ID]', 'Get and decrypt WORKFLOW_DATA_ITEM_ID that is was reported to WORKFLOW_ID');
+}
+
+async function handler({ workflow, id, decrypt }) {
+    let res;
+    if (id && id.length > 0) {
+        res = await _get(workflow, id, decrypt);
+    } else {
+        res = await _list(workflow);
+    }
+    Output.print(res);
+}
+
+const command = new Command({
+    command: 'workflow-data-item [id..]',
+    aliases: ['wdi'],
+    parent: getRoot,
+    description: 'Get Workflow Data Item',
+    usage: 'Passing [id] argument will cause a retrieval of a specific Workflow-Data-Item.',
+    webDocs: {
+        category: 'Workflow-Data',
+        title: 'Get',
+    },
+    builder,
+    handler,
+});
+
+module.exports = command;

package/lib/interface/cli/commands/workflow/workflow.sdk.spec.js

@@ -0,0 +1,123 @@
+const getCmd = require('./get.cmd').toCommand();
+const { sdk } = require('../../../../logic');
+
+let restartCmd = require('./restart.cmd');
+let logsCmd = require('./logs.cmd');
+let terminateCmd = require('./terminate.cmd');
+let waitCmd = require('./wait.cmd');
+
+restartCmd.requiresAuthentication = false;
+logsCmd.requiresAuthentication = false;
+terminateCmd.requiresAuthentication = false;
+waitCmd.requiresAuthentication = false;
+
+restartCmd = restartCmd.toCommand();
+logsCmd = logsCmd.toCommand();
+terminateCmd = terminateCmd.toCommand();
+waitCmd = waitCmd.toCommand();
+
+jest.mock('../../../../logic/entities/Workflow', () => {
+    return {
+        fromResponse: res => res,
+    };
+});
+jest.mock('../../helpers/logs');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('workflow commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting by id', async () => {
+            const argv = { id: ['some id'] };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should handle getting by pipeline name', async () => {
+            const argv = { 'pipeline-name': 'pipeline' };
+            const responses = [
+                {
+                    statusCode: 200,
+                    body: { docs: [{ metadata: { id: 'id' } }] },
+                },
+                {
+                    statusCode: 200,
+                    body: { workflows: { docs: [DEFAULT_RESPONSE.body] } },
+                },
+            ];
+            request.__queueResponses(responses);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should handle getting all', async () => {
+            const argv = { 'pipeline-name': [] };
+            const response = {
+                statusCode: 200,
+                body: { workflows: { docs: [DEFAULT_RESPONSE.body] } },
+            };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    // todo: fix firebase logs
+    describe('logs', () => {
+        it('should handle logs', async () => {
+            jest.spyOn(process, 'exit').mockImplementation();
+            jest.spyOn(sdk.logs, 'showWorkflowLogs').mockImplementation();
+            const argv = {};
+            await logsCmd.handler(argv);
+            expect(sdk.logs.showWorkflowLogs).toBeCalled();
+        });
+    });
+
+    describe('wait', () => {
+        it('should handle waiting', async () => {
+            const argv = { status: 'success', id: ['5c586a396d6d78651e7f96f1'], timeout: 1 };
+            const response = {
+                statusCode: 200,
+                body: { status: 'success' },
+            };
+            request.__setResponse(response);
+            await waitCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('terminate', () => {
+        it('should handle termination', async () => {
+            const argv = { id: 'workflow id' };
+            const responses = [
+                {
+                    statusCode: 200,
+                    body: { info: { progress: 'progress id' } },
+                },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await terminateCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('restart', () => {
+        it('should handle restarting', async () => {
+            const argv = { id: 'workflow id' };
+            await restartCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});