revert refactor run pipeline command (#265)

Author: itai-codefresh

lib/interface/cli/commands/pipeline/run.base.js

@@ -1,16 +1,24 @@
 const debug = require('debug')('codefresh:cli:run:pipeline');
 const Command = require('../../Command');
-const { crudFilenameOption } = require('../../helpers/general');
-const RunLocalCommand = require('./run.local');
-const RunExternalCommand = require('./run.cf');
+const _ = require('lodash');
+const CFError = require('cf-errors');
+const { prepareKeyValueFromCLIEnvOption, crudFilenameOption } = require('../../helpers/general');
+const { workflow, pipeline, log } = require('../../../../logic').api;
+const authManager = require('../../../../logic').auth.manager;
+const Docker = require('dockerode');
+const { validatePipelineYaml } = require('../../helpers/validation');
+const { printResult } = require('../root/validate.cmd');
+const DEFAULTS = require('../../defaults');
+const path = require('path');
+const regex = /##[0-9a-f]{24}##/i;
+const imageName = 'codefresh/engine:master';
 
-function getCommandFlavor(argv) {
-    if (argv.local) {
-        return new RunLocalCommand(argv);
+
+function _customizer(objValue, srcValue) {
+    if (Array.isArray(objValue)) {
+        return _.compact(objValue.concat(srcValue));
     }
-    return new RunExternalCommand(argv);
 }
-
 const run = new Command({
     root: true,
     command: 'run <name>',
@@ -72,11 +80,6 @@ const run = new Command({
                 describe: 'Use your file system as volume in local run',
                 alias: 'lv',
             })
-            .option('no-cf-cache', {
-                describe: 'Ignore Codefresh cache optimizations',
-                alias: 'ncfc',
-                default: false,
-            })
             .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master', 'Defining the source control context using a branch')
             .example('codefresh run PIPELINE_ID | PIPELINE_NAME -s=52b992e783d2f84dd0123c70ac8623b4f0f938d1', 'Defining the source control context using a commit')
             .example('codefresh run PIPELINE_ID | PIPELINE_NAME -b=master -v key1=value1 -v key2=value2', 'Setting variables through the command')
@@ -99,11 +102,158 @@ const run = new Command({
         return yargs;
     },
     handler: async (argv) => {
-        const flavor = getCommandFlavor(argv);
-        await flavor.preRunAll();
-        const exitCode = await flavor.run();
-        await flavor.postRunAll();
-        process.exit(exitCode);
+        const pipelineName = argv.name;
+        const branch = argv.branch;
+        const sha = argv.sha;
+        const noCache = argv['no-cache'];
+        const enableNotifications = argv['enable-notifications'];
+        const resetVolume = argv['reset-volume'];
+        const variablesFromFile = argv['var-file'];
+        const contexts = argv.context;
+        const userYamlDescriptor = argv.yaml;
+        const local = argv.local;
+        const localVolume = argv['local-volume'] === true ? path.join(DEFAULTS.CODEFRESH_PATH, pipelineName) : argv['local-volume'];
+
+        try {
+            await pipeline.getPipelineByName(pipelineName);
+        } catch (err) {
+            throw new CFError({
+                message: `Passed pipeline id: ${pipelineName} does not exist`,
+            });
+        }
+
+        if (userYamlDescriptor) {
+            const result = await validatePipelineYaml(undefined, userYamlDescriptor);
+            printResult(result);
+        }
+
+        if (local) {
+            const docker = new Docker();
+            const cleanupActions = [];
+            const injectedOpts = {};
+            // TODO : Move to per command's handler so each command will be handled in a seperate handler
+            if (userYamlDescriptor) {
+                injectedOpts.Env = [`OVERRIDE_WORKFLOW_YAML=${userYamlDescriptor}`];
+            }
+
+            console.log(`Updating Codefresh engine ==>`);
+            docker.pull(imageName, (err, stream) => {
+                docker.modem.followProgress(stream, onFinished, onProgress);
+                function onFinished(err) {
+                    if (!err) {
+                        console.log('Finished Update.\n');
+
+                        if (localVolume) {
+                            injectedOpts.Env = [`EXTERNAL_WORKSPACE=${localVolume}`];
+                            console.log(`\nUsing ${localVolume} as a local volume.\n`);
+                        }
+
+                        const currentContext = authManager.getCurrentContext();
+                        console.log(`Running pipeline: ${pipelineName}`);
+
+                        docker.run(imageName, [], [], _.mergeWith({
+                            Env: [
+                                `ACCESS_TOKEN=${currentContext.token}`,
+                                `PIPELINE_ID=${pipelineName}`, `BRANCH=${branch}`,
+                                `CF_HOST=${currentContext.url}`,
+                                'DOCKER_SOCKET_PATH=/var/run/docker.sock',
+                                'NO_EXT_MONITOR=true',
+                            ],
+                            Hostconfig: {
+                                Binds: [
+                                    '/var/run/docker.sock:/var/run/docker.sock',
+                                ],
+                            },
+                        }, injectedOpts, _customizer), (err, data) => {
+                            cleanupActions.forEach((action) => {
+                                try {
+                                    action();
+                                } catch (error) {
+                                    console.error(err);
+                                }
+                            });
+                            if (err) {
+                                return console.error(err);
+                            }
+                            process.exit(data.StatusCode);
+                        }).on('stream', (stream) => {
+                            stream.on('data', (chunk) => {
+                                const line = chunk.toString();
+                                const include = line.match(regex);
+                                if (include) {
+                                    const workflowId = include[0].substring(2, include[0].length - 2);
+                                    log.showWorkflowLogs(workflowId, true)
+                                        .then(() => Promise.resolve());
+                                }
+                            });
+                        });
+                    } else {
+                        console.log(err);
+                        process.exit(1);
+                    }
+                }
+                function onProgress() {
+                    stream.pipe(process.stdout);
+                }
+            });
+        } else {
+            const executionRequests = [];
+            const executionRequestTemplate = {
+                pipelineName,
+                options: {
+                    noCache,
+                    resetVolume,
+                    branch,
+                    sha,
+                    enableNotifications,
+                    userYamlDescriptor,
+                },
+            };
+
+            if (variablesFromFile) {
+                _.forEach(variablesFromFile, (variables) => {
+                    const request = _.cloneDeep(executionRequestTemplate);
+                    request.options.variables = variables;
+                    executionRequests.push(request);
+                });
+            } else {
+                const variables = prepareKeyValueFromCLIEnvOption(argv.variable);
+                const request = _.cloneDeep(executionRequestTemplate);
+                request.options.variables = variables;
+                request.options.contexts = contexts;
+                executionRequests.push(request);
+            }
+
+            _.forEach(executionRequests, async ({ pipelineName, options }) => {
+                let workflowId;
+                workflowId = await pipeline.runPipelineByName(pipelineName, options);
+
+                if (executionRequests.length === 1) {
+                    if (argv.detach) {
+                        console.log(workflowId);
+                    } else {
+                        await log.showWorkflowLogs(workflowId, true);
+                        const workflowInstance = await workflow.getWorkflowById(workflowId);
+                        switch (workflowInstance.getStatus()) {
+                            case 'success':
+                                process.exit(0);
+                                break;
+                            case 'error':
+                                process.exit(1);
+                                break;
+                            case 'terminated':
+                                process.exit(2);
+                                break;
+                            default:
+                                process.exit(100);
+                                break;
+                        }
+                    }
+                } else {
+                    console.log(workflowId);
+                }
+            });
+        }
     },
 });