codefresh 0.78.2

package/lib/interface/cli/commands/context/get.cmd.js

@@ -0,0 +1,68 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+const Context = require('../../../../logic/entities/Context');
+
+const command = new Command({
+    command: 'contexts [name..]',
+    aliases: ['ctx', 'context'],
+    parent: getRoot,
+    description: 'Get a specific context or an array of contexts',
+    usage: 'Passing [name] argument will cause a retrieval of a specific context.\n In case of not passing [name] argument, a list will be returned',
+    webDocs: {
+        category: 'Contexts',
+        title: 'Get Context',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'context name',
+            })
+            .option('type', {
+                describe: 'Context type',
+                choices: [
+                    'config', 'git.bitbucket-server', 'git.bitbucket', 'git.github', 'git.gitlab',
+                    'git.stash', 'helm-repository', 'secret-yaml', 'secret', 'storage.gc', 'storage.s3', 'yaml',
+                    'secret-store.kubernetes', 'secret-store.kubernetes-runtime',
+                ],
+            })
+            .option('decrypt', {
+                describe: 'Either to show decoded credentials or not',
+            })
+            .option('prepare', {
+                describe: 'Activate tokens in case its invalid',
+            })
+            .example('codefresh get context NAME', 'Get context NAME')
+            .example('codefresh get contexts', 'Get all contexts')
+            .example('codefresh get context --decrypt', 'Get all contexts with credentials decrypted')
+            .example('codefresh get context --type secret', 'Get all secret contexts')
+            .example('codefresh get context --type git.github', 'Get all git based contexts for github kind')
+            .example('codefresh get context --type helm-repository', 'Get all helm-repository contexts');
+    },
+    handler: async (argv) => {
+        const data = {};
+        const names = argv.name;
+        if (argv.type) {
+            data.type = argv.type;
+        }
+        data.decrypt = argv.decrypt || undefined;
+        data.prepare = argv.prepare || undefined;
+
+        let contexts = [];
+        if (!_.isEmpty(names)) {
+            if (data.prepare) {
+                contexts = await Promise.map(names, name => sdk.contexts.prepare({ name }));
+            } else {
+                contexts = await Promise.map(names, name => sdk.contexts.get({ name, decrypt: data.decrypt }));
+            }
+        } else {
+            contexts = await sdk.contexts.list(data);
+        }
+        Output.print(_.map(contexts, Context.fromResponse));
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/environment/delete.cmd.js

@@ -0,0 +1,28 @@
+const Command = require('../../Command');
+const deleteRoot = require('../root/delete.cmd');
+const { sdk } = require('../../../../logic');
+
+const command = new Command({
+    command: 'environment <id>',
+    aliases: ['env'],
+    description: 'Delete an environment',
+    parent: deleteRoot,
+    webDocs: {
+        category: 'Environments',
+        title: 'Delete Environment',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Environment id',
+            })
+            .example('codefresh delete environment ID', 'Delete environment ID');
+    },
+    handler: async (argv) => {
+        const id = argv.id;
+        await sdk.envs.terminate({ id });
+        console.log(`Environment: '${id}' deleted`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,40 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+
+const request = require('requestretry');
+
+jest.mock('../../../../logic/entities/Environment');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('environment commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting given id', async () => {
+            const argv = { id: ['some id'] };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting all', async () => {
+            const argv = {};
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given id', async () => {
+            const argv = { id: 'some id' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/environment/get.cmd.js

@@ -0,0 +1,43 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const Environment = require('../../../../logic/entities/Environment');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+
+const command = new Command({
+    command: 'environments [id..]',
+    aliases: ['env', 'environment'],
+    category: 'Environments',
+    parent: getRoot,
+    description: 'Get a specific environment or an array of environments',
+    usage: 'Passing [id] argument will cause a retrieval of a specific environment.\n In case of not passing [id] argument, a list will be returned',
+    webDocs: {
+        category: 'Environments',
+        title: 'Get Environment',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'environment id or name',
+            })
+            .example('codefresh get environment ID', 'Get environment ID')
+            .example('codefresh get environments', 'Get all environments');
+    },
+    handler: async (argv) => {
+        const environmentIds = argv.id;
+
+        let environments = [];
+        // TODO:need to decide for one way for error handeling
+        if (!_.isEmpty(environmentIds)) {
+            environments = await Promise.map(environmentIds, id => sdk.envs.get({ id }));
+        } else {
+            environments = await sdk.envs.list();
+        }
+        Output.print(_.map(environments, Environment.fromResponse));
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/gitops/argocd/install.js

@@ -0,0 +1,9 @@
+const gitopsInstaller = require('../common/install');
+
+class ArgoCDInstall {
+    // eslint-disable-next-line class-methods-use-this
+    async install(argv) {
+        return gitopsInstaller.install(argv);
+    }
+}
+module.exports = new ArgoCDInstall();

package/lib/interface/cli/commands/gitops/argocd/uninstall.js

@@ -0,0 +1,11 @@
+const _ = require('lodash');
+const gitopsUninstaller = require('../common/uninstall');
+
+class ArgoCDInstall {
+    // eslint-disable-next-line class-methods-use-this
+    async uninstall(argv) {
+        const uninstallOptions = _.pick(argv, ['kube-config-path', 'kube-context-name', 'kube-namespace', 'in-cluster']);
+        return gitopsUninstaller.uninstall(argv.provider, uninstallOptions);
+    }
+}
+module.exports = new ArgoCDInstall();

package/lib/interface/cli/commands/gitops/argocd/upgrade.js

@@ -0,0 +1,9 @@
+const gitopsUpgrader = require('../common/upgrade');
+
+class ArgoCDUpgrade {
+    // eslint-disable-next-line class-methods-use-this
+    async upgrade(argv) {
+        return gitopsUpgrader.upgrade(argv);
+    }
+}
+module.exports = new ArgoCDUpgrade();

package/lib/interface/cli/commands/gitops/codefresh/install.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const _ = require('lodash');
+const YAML = require('yaml');
+const gitopsInstaller = require('../common/install');
+
+const valuesMapping = {
+    'kube-config-path': 'ConfigPath',
+    'kube-context-name': 'Context',
+    'kube-namespace': 'Namespace',
+    'install-manifest': 'Manifest',
+    'in-cluster': 'InCluster',
+
+    'codefresh-host': 'CodefreshHost',
+    'codefresh-token': 'Token',
+    'codefresh-clusters': 'ClustersList',
+
+    'argo-password': 'Password',
+
+    'git-integration': 'Git',
+    'git-repo-url': 'Repo',
+};
+
+function mergeValuesFromValuesFile(argv, valuesFile) {
+    const valuesFileStr = fs.readFileSync(valuesFile, 'utf8');
+    const valuesObj = YAML.parse(valuesFileStr);
+
+    Object.keys(valuesMapping)
+        .forEach((argvKey) => {
+            const valuesKey = valuesMapping[argvKey];
+            if (!_.has(argv, argvKey) && _.has(valuesObj, valuesKey)) {
+                Object.assign(argv, {
+                    [argvKey]: _.get(valuesObj, valuesKey),
+                    [_.camelCase(argvKey)]: _.get(valuesObj, valuesKey),
+                });
+            }
+        });
+}
+
+class CodefreshInstall {
+    // eslint-disable-next-line class-methods-use-this
+    async install(argv) {
+        const _argv = _.cloneDeep(argv);
+        if (argv.values) {
+            mergeValuesFromValuesFile(_argv, _argv.values/* , handleError */);
+        }
+        await gitopsInstaller.install(_argv);
+    }
+}
+
+module.exports = new CodefreshInstall();

package/lib/interface/cli/commands/gitops/codefresh/uninstall.js

@@ -0,0 +1,14 @@
+const _ = require('lodash');
+const gitopsUninstaller = require('../common/uninstall');
+
+class CodefreshInstall {
+    // eslint-disable-next-line class-methods-use-this
+    async uninstall(argv) {
+        const uninstallOptions = _.pick(argv, [
+            'kube-config-path', 'kube-context-name', 'kube-namespace', 'install-manifest', 'in-cluster',
+        ]);
+        await gitopsUninstaller.uninstall(argv.provider, uninstallOptions);
+    }
+}
+
+module.exports = new CodefreshInstall();

package/lib/interface/cli/commands/gitops/codefresh/upgrade.js

@@ -0,0 +1,9 @@
+const gitopsUpgrader = require('../common/upgrade');
+
+class CodefreshGitopsUpgrade {
+    // eslint-disable-next-line class-methods-use-this
+    async upgrade(argv) {
+        return gitopsUpgrader.upgrade(argv);
+    }
+}
+module.exports = new CodefreshGitopsUpgrade();

package/lib/interface/cli/commands/gitops/common/install.js

@@ -0,0 +1,62 @@
+const { detectProxy } = require('../../../helpers/general');
+const { downloadProvider } = require('../../hybrid/helper');
+const { Runner, components } = require('../../../../../binary');
+const _ = require('lodash');
+
+class GitopsInstaller {
+    // eslint-disable-next-line class-methods-use-this
+    async install(argv) {
+        let { httpProxy, httpsProxy } = argv;
+        const { kubeConfigPath, provider, argoHost, argoUsername, argoPassword, bypassDownload } = argv;
+
+        const binLocation = await downloadProvider({ provider }, bypassDownload);
+        const componentRunner = new Runner(binLocation);
+
+        const commands = [
+            'install',
+        ];
+
+        if (kubeConfigPath) {
+            commands.push('--kubeconfig');
+            commands.push(kubeConfigPath);
+        }
+
+        const installOptions = _.pick(argv, ['git-integration', 'codefresh-integration', 'argo-token', 'output',
+            'update', 'kube-context-name', 'kube-namespace', 'sync-mode', 'sync-apps', 'codefresh-host',
+            'codefresh-token', 'codefresh-agent-suffix', 'in-cluster']);
+        installOptions['argo-host'] = argoHost;
+        installOptions['argo-username'] = argoUsername;
+        installOptions['argo-password'] = argoPassword;
+
+        _.forEach(_.pickBy(installOptions, _.identity), (value, key) => {
+            if (_.isArray(value)) {
+                value.forEach((item) => {
+                    commands.push(`--${key}`);
+                    commands.push(item);
+                });
+            } else {
+                commands.push(`--${key}`);
+                if (value !== true) commands.push(value);
+            }
+        });
+
+        const detectedProxyVars = detectProxy();
+        httpProxy = httpProxy || detectedProxyVars.httpProxy;
+        httpsProxy = httpsProxy || detectedProxyVars.httpsProxy;
+
+        if (httpProxy) {
+            commands.push('--http-proxy');
+            commands.push(httpProxy);
+        }
+
+        if (httpsProxy) {
+            commands.push('--https-proxy');
+            commands.push(httpsProxy);
+        }
+
+
+        await componentRunner.run(components.gitops[provider], commands);
+    }
+}
+
+module.exports = new GitopsInstaller();

package/lib/interface/cli/commands/gitops/common/uninstall.js

@@ -0,0 +1,39 @@
+const { downloadProvider } = require('../../hybrid/helper');
+const { Runner, components } = require('../../../../../binary');
+const _ = require('lodash');
+
+class GitopsUninstaller {
+    // eslint-disable-next-line class-methods-use-this
+    async uninstall(provider, argv) {
+        const { 'kube-config-path': kubeConfigPath, 'bypass-download': bypassDownload } = argv;
+        const binLocation = await downloadProvider({ provider }, bypassDownload);
+        const componentRunner = new Runner(binLocation);
+
+        const commands = [
+            'uninstall',
+        ];
+
+        if (kubeConfigPath) {
+            commands.push('--kubeconfig');
+            commands.push(kubeConfigPath);
+        }
+
+        const installOptions = _.omit(argv, 'kube-config-path');
+
+        _.forEach(_.pickBy(installOptions, _.identity), (value, key) => {
+            if (_.isArray(value)) {
+                value.forEach((item) => {
+                    commands.push(`--${key}`);
+                    commands.push(item);
+                });
+            } else {
+                commands.push(`--${key}`);
+                if (value !== true) commands.push(value);
+            }
+        });
+
+        await componentRunner.run(components.gitops[provider], commands);
+    }
+}
+
+module.exports = new GitopsUninstaller();

package/lib/interface/cli/commands/gitops/common/upgrade.js

@@ -0,0 +1,45 @@
+const { downloadProvider } = require('../../hybrid/helper');
+const { Runner, components } = require('../../../../../binary');
+const _ = require('lodash');
+
+class GitopsUpgrader {
+    // eslint-disable-next-line class-methods-use-this
+    async upgrade(argv) {
+        const {
+            provider,
+            'kube-config-path': kubeConfigPath,
+            'kube-namespace': kubeNamespace,
+            'kube-context-name': kubeContextName,
+            'in-cluster': inCluster,
+            'bypass-download': bypassDownload,
+        } = argv;
+
+        const binLocation = await downloadProvider({ provider }, bypassDownload);
+        const componentRunner = new Runner(binLocation);
+
+        const commands = [
+            'update',
+        ];
+
+        if (kubeConfigPath) {
+            commands.push('--kubeconfig');
+            commands.push(kubeConfigPath);
+        }
+        if (kubeNamespace) {
+            commands.push('--kube-namespace');
+            commands.push(kubeNamespace);
+        }
+        if (kubeContextName) {
+            commands.push('--kube-context-name');
+            commands.push(kubeContextName);
+        }
+        if (inCluster) {
+            commands.push('--in-cluster');
+            commands.push('true');
+        }
+
+        await componentRunner.run(components.gitops[provider], commands);
+    }
+}
+
+module.exports = new GitopsUpgrader();

package/lib/interface/cli/commands/gitops/install.cmd.js

@@ -0,0 +1,111 @@
+/* eslint-disable max-len */
+const _ = require('lodash');
+const Command = require('../../Command');
+const installRoot = require('../root/install.cmd');
+
+const PROVIDERS = {
+    codefresh: require('./codefresh/install'),
+    'argocd-agent': require('./argocd/install'),
+};
+
+const installArgoCmd = new Command({
+    root: false,
+    parent: installRoot,
+    command: 'gitops <provider>',
+    description: 'Install gitops',
+    webDocs: {
+        category: 'Gitops',
+        title: 'Install',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_')
+        .positional('provider', {
+            describe: 'Gitops provider',
+            choices: ['codefresh', 'argocd-agent'],
+            required: true,
+        })
+        .option('git-integration', {
+            describe: 'Name of git integration in Codefresh',
+        })
+        .option('git-repo-url', {
+            describe: 'Url to manifest repo',
+        })
+        .option('codefresh-integration', {
+            describe: 'Name of gitops integration in Codefresh ( Please create a dedicated context for the agent to  avoid hitting the Github rate limits )',
+        })
+        .option('argo-host', {
+            describe: 'Host of argocd installation',
+        })
+        .option('argo-token', {
+            describe: 'Token of argocd installation. Preferred auth method',
+        })
+        .option('argo-username', {
+            describe: 'Username of existing argocd installation. Should be used with argo-password',
+        })
+        .option('argo-password', {
+            describe: 'Password of existing argocd installation. Should be used with argo-username',
+        })
+        .option('update', {
+            describe: 'Update gitops integration if exists',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of Kubernetes context',
+        })
+        .option('kube-namespace', {
+            describe: 'Namespace in Kubernetes cluster',
+        })
+        .option('in-cluster', {
+            type: 'boolean',
+            default: false,
+            describe: 'Use this option if gitops provider is been updated from inside a cluster',
+        })
+        .option('output', {
+            describe: 'Path to k8s manifest output file, example: -o /home/user/out.yaml',
+            alias: 'o',
+        })
+        .option('sync-mode', {
+            choices: ['NONE', 'SELECT', 'CONTINUE_SYNC', 'ONE_TIME_SYNC'],
+            describe: 'Synchronization mode\nNONE - don\'t synchronize\nSELECT - select applications for synchronization\nCONTINUE_SYNC - continuous synchronization\nONE_TIME_SYNC - synchronize one time',
+        })
+        .option('sync-apps', {
+            array: true,
+            describe: 'Applications to be synchronized',
+        })
+        .option('http-proxy', {
+            describe: 'http proxy to be used in the runner',
+        })
+        .option('https-proxy', {
+            describe: 'https proxy to be used in the runner',
+        })
+        .option('install-manifest', {
+            describe: 'Url of argocd install manifest',
+            default: 'https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml',
+        })
+        .option('set-argo-password', {
+            describe: 'Set password for admin user of new argocd installation',
+        })
+        .option('codefresh-host', {
+            describe: 'Codefresh api host',
+            default: 'https://g.codefresh.io/',
+        })
+        .option('codefresh-agent-suffix', {
+            describe: 'Suffix for agent application\'s resources. Can be used for installing multiple agents in one namespace',
+            default: '',
+        })
+        .option('values', {
+            describe: 'Specify values in a YAML file',
+        }),
+
+    handler: async (argv) => {
+        const { provider } = argv;
+
+        const providerInstaller = PROVIDERS[provider];
+        return providerInstaller.install(argv);
+    },
+});
+
+module.exports = installArgoCmd;

package/lib/interface/cli/commands/gitops/install.spec.js

@@ -0,0 +1,77 @@
+const installCmd = require('./install.cmd').toCommand();
+const { Runner } = require('../../../../binary');
+const yargs = require('yargs');
+
+jest.mock('../hybrid/helper', () => ({
+    downloadProvider: async () => {},
+}));
+
+jest.mock('../../../../binary');
+
+describe('install gitops', () => {
+    beforeEach(async () => {
+        Runner.mockClear();
+    });
+
+    it('install gitops argocd-agent w/o arguments', async () => {
+        const argv = { provider: 'argocd-agent' };
+        await installCmd.handler(argv);
+        const { calls } = Runner.mock.instances[0].run.mock;
+        expect(calls).toHaveLength(1);
+        const [component, commands] = calls[0];
+        expect(component.name).toEqual('gitops');
+        expect(commands).toEqual(['install']);
+    });
+
+    it('install gitops argocd-agent with arguments', async () => {
+        const argv = {
+            provider: 'argocd-agent',
+            'git-integration': 'gitIntegration',
+            'codefresh-integration': 'codefreshIntegration',
+            'kube-context-name': 'kubeContextName',
+            'kube-namespace': 'kubeNamespace',
+            'sync-mode': 'SELECT',
+            'sync-apps': 'syncApps',
+        };
+        await installCmd.handler(argv);
+        const { calls } = Runner.mock.instances[0].run.mock;
+        expect(calls).toHaveLength(1);
+        const [component, commands] = calls[0];
+        expect(component.name).toEqual('gitops');
+        expect(commands).toEqual([
+            'install',
+            '--git-integration',
+            'gitIntegration',
+            '--codefresh-integration',
+            'codefreshIntegration',
+            '--kube-context-name',
+            'kubeContextName',
+            '--kube-namespace',
+            'kubeNamespace',
+            '--sync-mode',
+            'SELECT',
+            '--sync-apps',
+            'syncApps',
+        ]);
+    });
+
+    it('install gitops codefresh with required arguments', async () => {
+        const argv = {
+            provider: 'codefresh',
+            'set-argo-password': 'pass',
+            setArgoPassword: 'pass',
+            'kube-namespace': 'ns',
+            kubeNamespace: 'ns',
+        };
+        await installCmd.handler(argv);
+        const { calls } = Runner.mock.instances[0].run.mock;
+        expect(calls).toHaveLength(1);
+        const [component, commands] = calls[0];
+        expect(component.name).toEqual('cf-gitops-controller');
+        expect(commands).toEqual([
+            'install',
+            '--kube-namespace',
+            'ns',
+        ]);
+    });
+});