codefresh 0.78.2

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

@@ -0,0 +1,122 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const DEFAULTS = require('../../defaults');
+const { prepareKeyValueFromCLIEnvOption } = require('../../helpers/general');
+const { extractImages } = require('../../helpers/image');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+
+const IMAGE_FIELDS_TO_SELECT = 'internalName tags internalImageId created size imageDisplayName metadata sha';
+
+const command = new Command({
+    command: 'images [id..]',
+    aliases: ['img', 'image'],
+    parent: getRoot,
+    description: 'Get a specific image or an array of images',
+    usage: 'Passing [id] argument will cause a retrieval of a specific image.\n In case of not passing [id] argument, a list will be returned',
+    webDocs: {
+        category: 'Images',
+        title: 'Get Image',
+    },
+    builder: (yargs) => {
+        return yargs
+            .parserConfiguration({
+                'parse-numbers': false,
+            })
+            .positional('id', {
+                describe: 'Docker Image id',
+                coerce: (value) => value,
+            })
+            .option('limit', {
+                describe: 'Limit amount of returned results',
+                default: DEFAULTS.GET_LIMIT_RESULTS,
+            })
+            .option('all', {
+                alias: 'a',
+                describe: 'Return images from all possible registries (by default only r.cfcr.io images will be returned)',
+                default: false,
+                type: 'boolean',
+            })
+            .option('label', {
+                describe: 'Filter by a list of annotated labels',
+                alias: 'l',
+                default: [],
+            })
+            .option('tag', {
+                describe: 'Filter by a list of tags',
+                alias: 't',
+                type: Array,
+                default: [],
+            })
+            .option('sha', {
+                describe: 'Filter by specific commit sha',
+                alias: 's',
+            })
+            .option('image-name', {
+                describe: 'Filter by specific image name',
+                type: 'array',
+            })
+            .option('branch', {
+                describe: 'Filter by specific branch',
+                type: 'array',
+            })
+            .option('page', {
+                describe: 'Paginated page',
+                default: DEFAULTS.GET_PAGINATED_PAGE,
+            })
+            .example('codefresh get image ID', 'Get image ID')
+            .example('codefresh get images', 'Get all images')
+            .example('codefresh get images --image-name node', "Get all images that their name contains the word 'node'")
+            .example('codefresh get images -l key1=value1', "Get all images that are annotated with 'value1' for 'key1'");
+    },
+    handler: async (argv) => {
+        const imageIds = _.uniq(argv.id);
+        const labels = prepareKeyValueFromCLIEnvOption(argv.label);
+        const tags = argv.tag;
+        const sha = argv.sha;
+        const limit = argv.limit;
+        const type = argv.type;
+        const branch = argv.branch;
+        const allRegistries = argv.all;
+        const offset = (argv.page - 1) * limit;
+        const imageName = argv['image-name'];
+
+        let imageRepo;
+        if (!allRegistries) {
+            imageRepo = DEFAULTS.INTERNAL_REGISTRY_PREFIX;
+        }
+
+        let images = [];
+        // TODO:need to decide for one way for error handeling
+        if (!_.isEmpty(imageIds)) {
+            images = await Promise.map(imageIds, id => sdk.images.list({
+                filter: { internalImageId: id },
+                limit: 100,
+                select: IMAGE_FIELDS_TO_SELECT,
+            }));
+            images = _.chain(images)
+                .map('docs')
+                .flatten()
+                .value();
+        } else {
+            images = await sdk.images.list({
+                metadata: labels,
+                tag: tags,
+                sha,
+                limit,
+                type,
+                branch,
+                imageDisplayNameRegex: imageName,
+                offset,
+                select: IMAGE_FIELDS_TO_SELECT,
+                ...(imageRepo && { imageRepo }),
+            });
+            images = images.docs;
+        }
+        Output.print(extractImages(images));
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,134 @@
+const getCmd = require('./get.cmd').toCommand();
+const yargs = require('yargs');
+
+let annotateCmd = require('./annotate.cmd');
+let tagCmd = require('./tag.cmd');
+let untagCmd = require('./untag.cmd');
+
+annotateCmd.requiresAuthentication = false;
+annotateCmd = annotateCmd.toCommand();
+
+tagCmd.requiresAuthentication = false;
+tagCmd = tagCmd.toCommand();
+
+untagCmd.requiresAuthentication = false;
+untagCmd = untagCmd.toCommand();
+
+jest.mock('../../../../logic/entities/Image');
+
+jest.mock('../../helpers/image', () => ({
+    extractImages: images => images,
+}));
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('image commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('stop parse number', () => {
+        it('should be string', async () => {
+            const { numberArg } = yargs(['--numberArg', '21'])
+                .parserConfiguration({
+                    'parse-numbers': false,
+                })
+                .option('numberArg', {})
+                .argv;
+
+            expect(typeof numberArg).toBe('string');
+        });
+
+        it('should be number', async () => {
+            const { numberArg } = yargs(['--numberArg', '21'])
+                .option('numberArg', {})
+                .argv;
+
+            expect(typeof numberArg).toBe('number');
+        });
+    });
+
+    describe('get', () => {
+        it('should handle getting given id', async () => {
+            const argv = { id: ['some id'], label: [], tag: [] };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting all', async () => {
+            const argv = { label: [], tag: [] };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('tag', () => {
+        it('should handle tagging', async () => {
+            const argv = { id: 'some id', tags: ['tag'] };
+            const responses = [
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await tagCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('untag', () => {
+        it('should handle removing tags', async () => {
+            const argv = { id: 'some id', tags: ['tag'] };
+            const responses = [
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await untagCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    describe('annotate', () => {
+        it('should handle annotating given docker image id', async () => {
+            const argv = { id: 'some id', label: ['test=test'] };
+            await annotateCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle annotating given full image name', async () => {
+            const argv = { id: 'repo/name:tag', label: ['test=test'] };
+            const responses = [
+                { statusCode: 200, body: [{ internalImageId: 'some id' }] },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await annotateCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should throw on no images found given image full name', async () => {
+            const argv = { id: 'repo/name:tag', label: ['test=test'] };
+            const response = { statusCode: 200, body: [] };
+            request.__setResponse(response);
+
+            await expect(annotateCmd.handler(argv)).rejects.toThrow();
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should throw on multiple images found given image full name', async () => {
+            const argv = { id: 'repo/name:tag', label: ['test=test'] };
+            const response = {
+                statusCode: 200,
+                body: [{ internalImageId: 'some id' }, { internalImageId: 'another id' }],
+            };
+            request.__setResponse(response);
+
+            await expect(annotateCmd.handler(argv)).rejects.toThrow();
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/image/tag.cmd.js

@@ -0,0 +1,50 @@
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const Promise = require('bluebird');
+
+
+const tag = new Command({
+    root: true,
+    command: 'tag <id> [tags..]',
+    category: 'Images',
+    description: 'Add an image tag',
+    usage: 'Tagging an image will result in the creation of a new Docker Image tag. If registry not specified - default is used',
+    webDocs: {
+        category: 'Images',
+        title: 'Tag Image',
+        weight: 60,
+    },
+    builder: (yargs) => {
+        yargs
+            .parserConfiguration({
+                'parse-numbers': false,
+            })
+            .positional('id', {
+                description: 'Docker image id',
+            })
+            .positional('names', {
+                description: 'Tag names',
+            })
+            .option('registry', {
+                alias: 'r',
+                description: 'Registry integration name',
+            })
+            .example('codefresh tag 2dfacdaad466 1.0.0', "Tag image '2dfacdaad466' with a new tag: '1.0.0' on default registry")
+            .example('codefresh tag 2dfacdaad466 1.0.0 --registry dockerhub', "Tag image '2dfacdaad466' with a new tag: '1.0.0' on dockerhub")
+            .example('codefresh tag 2dfacdaad466 1.0.0 my-tag', "Tag image '2dfacdaad466' with multiple tags: '1.0.0' and 'my-tag'");
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const id = argv.id;
+        const tags = argv.tags;
+        const registry = argv.registry;
+
+        await Promise.each(tags, async (tag) => {
+            await sdk.images.tag({ id, tag, registry });
+            console.log(`Tag "${tag}" was added successfully to image "${id}" on "${registry || 'default'}" registry`);
+        });
+    },
+});
+
+module.exports = tag;

package/lib/interface/cli/commands/image/untag.cmd.js

@@ -0,0 +1,47 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+const Promise = require('bluebird');
+
+const untag = new Command({
+    root: true,
+    command: 'untag <id> [tags..]',
+    category: 'Images',
+    description: 'Untag an image',
+    usage: 'Untagging an image will result in the removal of tag. If registry not specified - default is used',
+    webDocs: {
+        category: 'Images',
+        title: 'Untag Image',
+        weight: 70,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('id', {
+                description: 'Docker image id',
+            })
+            .positional('names', {
+                description: 'Tag names',
+            })
+            .option('registry', {
+                alias: 'r',
+                description: 'Registry integration name',
+            })
+            .example('codefresh untag 2dfacdaad466 1.0.0', "Remove tag '1.0.0' from image '2dfacdaad466' on default registry")
+            .example('codefresh untag 2dfacdaad466 1.0.0 --registry dockerhub', "Remove tag '2dfacdaad466' with a new tag: '1.0.0' on dockerhub")
+            .example('codefresh untag 2dfacdaad466 1.0.0 my-tag', "Remove tags '1.0.0' and 'my-tag' from image'2dfacdaad466'");
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const id = argv.id;
+        const tags = argv.tags;
+        const registry = argv.registry;
+
+        await Promise.each(tags, async (tag) => {
+            await sdk.images.untag({ id, tag, registry });
+            console.log(`Tag "${tag}" was successfully removed from image "${id}" on "${registry || 'default'}" registry'`);
+        });
+    },
+});
+
+module.exports = untag;

package/lib/interface/cli/commands/imagePullSecret/generate.cmd.js

@@ -0,0 +1,49 @@
+const debug = require('debug')('codefresh:cli:generate:imagePullSecret');
+const Command = require('../../Command');
+const genCmd = require('../root/generate.cmd');
+const { sdk } = require('./../../../../logic');
+
+const command = new Command({
+    command: 'image-pull-secret',
+    parent: genCmd,
+    description: 'Generate image pull secret on Kubernetes cluster from integrated Docker registry',
+    usage: `
+    For Kuberentes cluster to pull an image from your private registry it needs special secret typed as \`kubernetes.io/dockercfg\`.
+    After this secret been created you can use them in pod template that lives in the same namespace.
+    You can generate this secret from any integrated Docker registry on your account.
+    More information about image pull secret can be found here: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/`,
+    webDocs: {
+        category: 'More',
+        title: 'Image Pull Secret',
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('cluster', {
+                describe: 'cluster name',
+                required: true,
+            })
+            .option('namespace', {
+                describe: 'namespace name',
+                default: 'default',
+            })
+            .option('registry', {
+                describe: 'name of Docker registry to generate pull secret from',
+                required: true,
+            })
+            .example('codefresh generate image-pull-secret --cluster cluster --registry cfcr', 'Generate image pull secret');
+    },
+    handler: async (argv) => {
+        const res = await sdk.kubernetes.generateImagePullSecret({
+            selector: argv.cluster,
+            namespace: argv.namespace,
+        }, {
+            registry: argv.registry,
+        });
+        console.log(`Image Pull Secret created with name: ${res.name}`);
+        console.log('Avaliable via kubectl:');
+        console.log(`kubectl get secret --context ${argv.cluster} --namespace ${argv.namespace} ${res.name}`);
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,21 @@
+const generateCmd = require('./generate.cmd').toCommand();
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('image pull secret commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('generate', () => {
+        it('should handle generation', async () => {
+            const argv = { cluster: 'cluster', namespace: 'default', registry: 'reg' };
+            await generateCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

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

@@ -0,0 +1,160 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const installRoot = require('../root/install.cmd');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+const { downloadVeonona } = require('../hybrid/helper');
+const { Runner, components } = require('../../../../binary');
+const sdk = require('../../../../logic/sdk');
+const _ = require('lodash');
+
+const installMonitorCmd = new Command({
+    root: false,
+    parent: installRoot,
+    command: 'monitor',
+    description: 'Install and create an cluster resources monitor on kubernetes cluster',
+    webDocs: {
+        category: 'Monitor',
+        title: 'Install',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('cluster-id', {
+            describe: 'Cluster id - freestyle name',
+        })
+        .option('token', {
+            describe: 'Codefresh user token',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+            type: 'string',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which monitor should be installed [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('url', {
+            describe: 'Codefresh url, by default https://g.codefresh.io',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which monitor should be installed [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('docker-registry', {
+            describe: 'The prefix for the container registry that will be used for pulling the required components images. Example: --docker-registry="docker.io"',
+            type: 'string',
+        })
+        .option('values', {
+            describe: 'specify values in a YAML file',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        })
+        .option('dry-run', {
+            describe: 'dry run',
+            default: false,
+            type: 'boolean',
+        })
+        .option('bypass-download', {
+            describe: 'If the flag is set, then the first attempt (to get the required component) would be by searching for it locally. If the search fails, there will be a download attempt',
+            default: false,
+            type: 'boolean',
+        }),
+    handler: async (argv) => {
+        const {
+            url,
+            //     'kube-config-path': kubeConfigPath,
+            'cluster-id': clusterId,
+            token,
+            'kube-config-path': kubeConfigPath,
+            'kube-context-name': kubeContextName,
+            'kube-namespace': kubeNamespace,
+            'docker-registry': dockerRegistry,
+            verbose,
+            values: valuesFile,
+            'env-vars': envVars,
+            'set-value': setValue,
+            'set-file': setFile,
+            'dry-run': dryRun,
+            'bypass-download': bypassDownload,
+            //        noExit,
+        } = argv;
+        const binLocation = await downloadVeonona(undefined, bypassDownload);
+        const componentRunner = new Runner(binLocation);
+
+        const commands = [
+            'install',
+            'monitor',
+        ];
+
+        if (clusterId) {
+            commands.push('--clusterId');
+            commands.push(clusterId);
+        }
+
+        commands.push('--codefreshToken');
+        if (token) {
+            commands.push(token);
+        } else {
+            commands.push(_.get(sdk, 'config.context.token'));
+        }
+
+        if (kubeConfigPath) {
+            commands.push('--kube-config-path');
+            commands.push(kubeConfigPath);
+        }
+
+        if (kubeContextName) {
+            commands.push('--kube-context-name');
+            commands.push(kubeContextName);
+        }
+
+        // if (helm3) {
+        //     commands.push('--helm3');
+        // }
+
+        if (kubeNamespace) {
+            commands.push('--kube-namespace');
+            commands.push(kubeNamespace);
+        }
+
+        if (url) {
+            commands.push('--codefreshHost');
+            commands.push(url);
+        }
+        if (verbose) {
+            commands.push('--verbose');
+        }
+        if (DefaultLogFormatter) {
+            commands.push(`--log-formtter=${DefaultLogFormatter}`);
+        }
+
+        if (dockerRegistry) {
+            commands.push(`--docker-registry=${dockerRegistry}`);
+        }
+        if (valuesFile) {
+            commands.push(`--values=${valuesFile}`);
+        }
+        if (setFile) {
+            commands.push(`--set-file=${setFile}`);
+        }
+        if (setValue) {
+            if (_.isArray(setValue)) {
+                setValue.forEach(sv => commands.push(`--set-value=${sv}`));
+            } else {
+                commands.push(`--set-value=${setValue}`);
+            }
+        }
+        if (envVars) {
+            envVars.forEach((item) => {
+                const parts = item.split('=');
+                commands.push(`--set-value=EnvVars.${parts[0]}=${parts[1].replace(/,/g, '\\,')}`);
+            });
+        }
+        if (dryRun) {
+            commands.push('--dry-run');
+        }
+
+        await componentRunner.run(components.venona, commands);
+    },
+});
+
+module.exports = installMonitorCmd;

package/lib/interface/cli/commands/monitor/uninstall.cmd.js

@@ -0,0 +1,78 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const unInstallRoot = require('../root/uninstall.cmd');
+const { sdk } = require('../../../../logic');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+
+
+const unInstallAgentCmd = new Command({
+    root: false,
+    parent: unInstallRoot,
+    command: 'monitor',
+    description: 'Uninstall an monitor on kubernetes cluster',
+    webDocs: {
+        category: 'Monitor',
+        title: 'Uninstall',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which monitor should be uninstalled [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which monitor should be uninstalled [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            'kube-namespace': kubeNamespace,
+            'kube-config-path': kubeConfigPath,
+            'kube-context-name': kubeContextName,
+            noExit,
+        } = argv;
+
+        const events = new ProgressEvents();
+        const format = 'downloading [{bar}] {percentage}% | {value}/{total}';
+        const progressBar = new cliProgress.SingleBar({ stopOnComplete: true, format }, cliProgress.Presets.shades_classic);
+        let totalSize;
+        events.onStart((size) => {
+            progressBar.start(size, 0);
+            totalSize = size;
+        });
+        events.onProgress((progress) => {
+            progressBar.update(progress);
+            if (progress >= totalSize) {
+                console.log('\n');
+            }
+        });
+
+
+        const exitCode = await sdk.monitor.unInstall({
+            kubeContextName,
+            kubeNamespace,
+            kubeConfigPath,
+            terminateProcess: false,
+            events,
+            logFormatting: DefaultLogFormatter,
+        });
+        if (exitCode === 0) {
+            console.log('Monitor uninstalled successfully');
+            if (!noExit) {
+                process.exit(0);
+            }
+        }
+        if (!noExit) {
+            process.exit(1);
+        }
+    },
+});
+
+module.exports = unInstallAgentCmd;