codefresh 0.78.2

package/lib/interface/cli/helpers/helpers.sdk.spec.js

@@ -0,0 +1,201 @@
+const _ = require('lodash');
+const columnify = require('columnify');
+const kefir = require('kefir');
+const chalk = require('chalk');
+const { Config } = require('codefresh-sdk');
+
+const { normalizeValues } = require('./helm');
+const { validatePipelineSpec, validatePipelineYaml } = require('./validation');
+const { followLogs } = require('./logs');
+const { printTableForAuthContexts } = require('./auth');
+const { sdk } = require('../../../logic');
+
+jest.mock('../../../logic/entities/Context', () => ({
+    fromResponse: () => ({
+        getType: () => 'yaml',
+    }),
+}));
+jest.mock('./../../../../check-version');
+const versionChecker = require('./../../../../check-version');
+
+jest.mock('../../../logic/entities/Workflow', () => ({
+    fromResponse: () => ({
+        getStatus: () => 0,
+    }),
+}));
+
+jest.mock('columnify', () => jest.fn(data => data));
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('helpers using sdk', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('helm', () => {
+        it('should handle getting contexts on normalizeValues', async () => {
+            await normalizeValues(['context-name']);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('validation', () => {
+        it('should handle validation on validatePipelineSpec', async () => {
+            await validatePipelineSpec({
+                version: 'v1',
+                spec: {},
+            });
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+        it('should handle validation on validatePipelineYaml', async () => {
+            await validatePipelineYaml(null, 'content');
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('logs', () => {
+        it('should handle showing logs', async () => {
+            const workflowId = 'id';
+            jest.spyOn(process, 'exit').mockImplementation();
+            jest.spyOn(sdk.logs, 'showWorkflowLogs').mockImplementation();
+            await followLogs(workflowId);
+            expect(sdk.logs.showWorkflowLogs).toBeCalled();
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+        it('should not show logs if check version throw an exception', async () => {
+            const workflowId = 'id';
+            jest.spyOn(sdk.logs, 'showWorkflowLogs').mockImplementation();
+            versionChecker.checkVersion.mockImplementationOnce(() => {
+                throw new Error();
+            });
+            await followLogs(workflowId);
+            expect(sdk.logs.showWorkflowLogs).not.toBeCalled();
+        });
+    });
+
+    describe('auth', () => {
+        describe('printTableForAuthContexts', () => {
+            beforeEach(() => {
+                jest.spyOn(console, 'log');
+                jest.spyOn(kefir, 'sequentially');
+                columnify.mockClear();
+                const addAccountInfo = jest.fn(() => Promise.resolve());
+                const defaultColumns = ['current', 'name'];
+                const contexts = {
+                    current: {
+                        addAccountInfo,
+                        defaultColumns,
+                        current: true,
+                        name: 'current',
+                    },
+                    nonCurrent: {
+                        addAccountInfo,
+                        defaultColumns,
+                        name: 'nonCurrent',
+                    },
+                };
+                const managerMock = {
+                    getCurrentContext: jest.fn(() => contexts.current),
+                    getAllContexts: jest.fn(() => contexts),
+                };
+                Config.manager = () => managerMock;
+                Config.MOCK_CONTEXTS = contexts;
+                Config.ADD_ACCOUNT_INFO_MOCK = addAccountInfo;
+            });
+
+            it('should log fallback message when no current context and no sdk context', async () => {
+                Config.manager().getCurrentContext = jest.fn(() => undefined);
+                sdk.config.context = undefined;
+
+                await printTableForAuthContexts();
+
+                expect(console.log).toBeCalledWith('No authentication contexts. Please create an authentication context (see codefresh auth create-context --help)'); // eslint-disable-line
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(kefir.sequentially).not.toBeCalled();
+            });
+
+            it('should log fallback message when no current context and when sdk context isNoAuth', async () => {
+                Config.manager().getCurrentContext = jest.fn(() => undefined);
+                sdk.config.context = { isNoAuth: true };
+
+                await printTableForAuthContexts();
+
+                expect(console.log).toBeCalledWith('No authentication contexts. Please create an authentication context (see codefresh auth create-context --help)'); // eslint-disable-line
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(kefir.sequentially).not.toBeCalled();
+            });
+
+            it('should log environment context when no current context but sdk context exists', async () => {
+                const mockContext = Config.manager().getCurrentContext();
+                const verifyContext = _.merge(_.pick(mockContext, mockContext.defaultColumns), { current: chalk.green('*') });
+                sdk.config.context = mockContext;
+                Config.manager().getCurrentContext = jest.fn(() => undefined);
+
+                await printTableForAuthContexts();
+
+                expect(console.log).toBeCalledWith('Using authentication context created from CF_API_KEY env variable:');
+                expect(console.log).lastCalledWith([verifyContext]);
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(Config.manager().getAllContexts).not.toBeCalled();
+                expect(kefir.sequentially).toBeCalled();
+            });
+
+            it('should log environment context when there is current context but sdk context differs', async () => {
+                const mockContext = _.clone(Config.manager().getCurrentContext());
+                mockContext.name = 'sdk context';
+                const verifyContext = _.merge(_.pick(mockContext, mockContext.defaultColumns), { current: chalk.green('*') });
+                sdk.config.context = mockContext;
+
+                await printTableForAuthContexts();
+
+                expect(console.log).toBeCalledWith('Using authentication context created from CF_API_KEY env variable:');
+                expect(console.log).lastCalledWith([verifyContext]);
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(Config.manager().getAllContexts).not.toBeCalled();
+                expect(kefir.sequentially).toBeCalled();
+            });
+
+            it('should log all contexts when filter is "all"', async () => {
+                sdk.config.context = Config.manager().getCurrentContext();
+                const verifyContexts = _.map(_.values(Config.MOCK_CONTEXTS), context => _.mapValues(_.pick(context, context.defaultColumns), (val, key) => {
+                    if (key === 'current') return chalk.green('*');
+                    return val;
+                }));
+
+                await printTableForAuthContexts();
+
+                expect(console.log).toBeCalledWith(verifyContexts);
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(Config.manager().getAllContexts).toBeCalled();
+                expect(kefir.sequentially).toBeCalled();
+            });
+
+            it('should log current context when filter is "current"', async () => {
+                const mockContext = Config.manager().getCurrentContext();
+                const verifyContext = _.merge(_.pick(mockContext, mockContext.defaultColumns), { current: chalk.green('*') });
+                sdk.config.context = mockContext;
+
+                await printTableForAuthContexts({ filter: 'current' });
+
+                expect(console.log).lastCalledWith([verifyContext]);
+                expect(Config.manager().getCurrentContext).toBeCalled();
+                expect(Config.manager().getAllContexts).not.toBeCalled();
+                expect(kefir.sequentially).toBeCalled();
+            });
+
+            it('should add account info for each context', async () => {
+                sdk.config.context = Config.manager().getCurrentContext();
+
+                await printTableForAuthContexts();
+
+                expect(kefir.sequentially).toBeCalled();
+                expect(Config.ADD_ACCOUNT_INFO_MOCK).toBeCalledTimes(_.keys(Config.MOCK_CONTEXTS).length);
+            });
+        });
+    });
+});

package/lib/interface/cli/helpers/helpers.unit.spec.js

@@ -0,0 +1,105 @@
+const _ = require('lodash');
+const helper = require('./image');
+const { createEntity, entityList } = require('./entitiesManifests');
+
+const { extractImages } = helper;
+
+jest.mock('../../../logic/entities/Image', () => class {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+});
+
+jest.mock('../commands/annotation/annotation.logic', () => class {
+    static createAnnotations() {
+        return Promise.resolve();
+    }
+});
+
+describe('helpers unit tests', () => {
+    describe('creating entites', () => {
+        const request = require('requestretry');
+        beforeEach(async () => {
+            request.__reset();
+            request.mockClear();
+            await configureSdk(); // eslint-disable-line
+        });
+
+        it('should have some length', () => expect(entityList.length).not.toBe(0));
+        for (const entity of entityList) {
+            const args = { entity, name: 'default', data: {} };
+            it(`${entity} should be promise`, () => expect(createEntity(args).catch(() => null) instanceof Promise).toBe(true));
+        }
+    });
+
+    describe('images', () => {
+        describe('#extractImages', () => {
+            beforeAll(() => {
+                helper.extractFieldsForImageEntity = jest.fn((image, tag) => ({ tag: tag.tag || tag }));
+            });
+
+            it('should wrap data into array if only one image passed', () => {
+                const image = {
+                    tags: [{ tag: 'test', registry: 'r.cfcr.io' }],
+                };
+                expect(extractImages(image)).toEqual([{ tag: 'test' }]);
+            });
+
+            it('should extract image tags as separate images', () => {
+                expect(extractImages([
+                    {
+                        tags: [{ tag: 'banana' }, { tag: 'beer', registry: 'r.cfcr.io' }],
+                    },
+                    {
+                        tags: [{ tag: 'banana' }, { tag: 'beer', registry: 'r.cfcr.io' }],
+                    },
+                ])).toEqual([
+                    { tag: 'banana' },
+                    { tag: 'beer' },
+                    { tag: 'banana' },
+                    { tag: 'beer' },
+                ]);
+            });
+
+            it('should filter images tagged as "volume"', () => {
+                expect(extractImages([
+                    {
+                        tags: [
+                            { tag: 'volume' },
+                        ],
+                    },
+                ])).toEqual([]);
+            });
+
+            it('should add <none> literal to image if it has no tags', () => {
+                expect(extractImages([
+                    {
+                        tags: [],
+                    },
+                ])).toEqual([{ tag: '<none>' }]);
+            });
+
+            it('should sort images by date created DESC', () => {
+                helper.extractFieldsForImageEntity = jest.fn(({ created }) => ({ info: { created } }));
+                const images = [
+                    {
+                        created: new Date('2019-04-22T14:30:18.742Z'),
+                    },
+                    {
+                        created: new Date('2019-04-22T14:40:18.741Z'),
+                    },
+                    {
+                        created: new Date('2019-04-22T14:45:18.742Z'),
+                    },
+                ];
+                const extracted = extractImages(images);
+                const extractedDates = _.map(extracted, i => i.info.created);
+                const initialSortedDates = _.chain(images)
+                    .orderBy(['created'], ['desc'])
+                    .map(i => i.created)
+                    .value();
+                expect(extractedDates).toEqual(initialSortedDates);
+            });
+        });
+    });
+});

package/lib/interface/cli/helpers/image.js

@@ -0,0 +1,66 @@
+const _ = require('lodash');
+const filesize = require('filesize');
+const Image = require('../../../logic/entities/Image');
+const DEFAULTS = require('../../cli/defaults');
+
+const NONE_TAG = '<none>';
+
+class ImagesHelper {
+    constructor() {
+        this.extractFieldsForImageEntity = this.extractFieldsForImageEntity.bind(this);
+        this.extractImages = this.extractImages.bind(this);
+    }
+
+
+    extractFieldsForImageEntity(image, tag){
+        const newImage = {
+            name: image.imageDisplayName || image.imageName,
+            size: image.size && filesize(image.size),
+            sha: image.sha,
+            annotations: _.get(image, 'metadata', {}),
+            tagId: tag._id,
+            created: image.created ? new Date(image.created) : undefined,
+            hash: image.hash || image._id,
+        };
+        newImage.id = image.internalImageId ? image.internalImageId.substring(0, 12) : '\b';
+        if (_.isEqual(tag, NONE_TAG)) {
+            newImage.tag = tag;
+            newImage.pull = image.repoDigest || '';
+        } else {
+            newImage.tag = tag.tag;
+            newImage.pull = `${tag.registry}/${tag.repository}:${tag.tag}`;
+        }
+        return newImage;
+    }
+
+
+    extractImages(images) {
+        if (!_.isArray(images)) {
+            images = [images]; // eslint-disable-line no-param-reassign
+        }
+        return _.chain(images)
+            .map((image) => {
+                const res = [];
+                let volumeImage = false;
+                _.forEach(image.tags, (tag) => {
+                    if (_.isEqual(tag.tag, 'volume')) {
+                        volumeImage = true;
+                        return;
+                    }
+
+                    const data = this.extractFieldsForImageEntity(image, tag);
+                    res.push(new Image(data));
+                });
+                if (_.isEmpty(image.tags) && !volumeImage) {
+                    const data = this.extractFieldsForImageEntity(image, NONE_TAG);
+                    res.push(new Image(data));
+                }
+                return res;
+            })
+            .flatten()
+            .orderBy(['info.created'], ['desc'])
+            .value();
+    }
+}
+
+module.exports = new ImagesHelper();

package/lib/interface/cli/helpers/kubernetes.js

@@ -0,0 +1,61 @@
+const path = require('path');
+const fs = require('fs');
+const { KubeConfig, Client } = require('kubernetes-client');
+const Request = require('kubernetes-client/backends/request');
+const _ = require('lodash');
+const { homedir } = require('os');
+
+const isInCluster = () => fs.existsSync('/var/run/secrets/kubernetes.io/serviceaccount');
+
+const _getKubeConfig = (kubeconfigPath) => {
+    const kc = new KubeConfig();
+    if (isInCluster()) {
+        kc.loadFromCluster();
+        return kc;
+    }
+
+    const kubePath = kubeconfigPath || process.env.KUBECONFIG || path.join(homedir(), '.kube', 'config');
+    if (!fs.existsSync(kubePath)) {
+        throw new Error(`kubeconfig not found at: ${kubePath}, make sure the $KUBECONFIG environment variable is set correctly`);
+    }
+
+    kc.loadFromFile(kubePath);
+
+    return kc;
+};
+
+
+const getKubeContext = (kubeconfigPath) => {
+    const kubeconfig = _getKubeConfig(kubeconfigPath);
+    return kubeconfig.currentContext;
+};
+const getAllKubeContexts = (kubeconfigPath) => {
+    const kubeconfig = _getKubeConfig(kubeconfigPath);
+    const { contexts } = kubeconfig;
+    if (contexts) {
+        return contexts.reduce((acc, curr) => {
+            acc.push(curr.name);
+            return acc;
+        }, []);
+    }
+    return [];
+};
+const getAllNamespaces = async (kubeconfigPath, kubeContextName) => {
+    const kubeconfig = _getKubeConfig(kubeconfigPath);
+    kubeconfig.setCurrentContext(kubeContextName);
+    const backend = new Request({ kubeconfig });
+    const client = new Client({ backend, version: 1.13 });
+    const resp = await client.api.v1.namespaces.get();
+    if (resp.statusCode !== 200) {
+        throw new Error(`could not get namespaces from cluster ${kubeContextName}, failed with status: ${resp.statusCode}`);
+    }
+    const nsObjs = _.get(resp, 'body.items');
+    return _.map(nsObjs, ns => _.get(ns, 'metadata.name'));
+};
+
+module.exports = {
+    getKubeContext,
+    getAllKubeContexts,
+    getAllNamespaces,
+    isInCluster,
+};

package/lib/interface/cli/helpers/logs.js

@@ -0,0 +1,99 @@
+const Promise = require('bluebird');
+const _ = require('lodash');
+const request = require('requestretry');
+const CFError = require('cf-errors');
+
+const { sdk } = require('../../../logic');
+const Workflow = require('../../../logic/entities/Workflow');
+const Output = require('../../../output/Output');
+const { checkVersion } = require('./../../../../check-version');
+
+const nodeVersionToValidate = '<=10.x >=8.x';
+
+const END_STATUSES = ['error', 'success', 'terminated'];
+
+const config = require('../../../logic/cli-config/Manager').config();
+
+async function _fallbackLogs(workflowId, interval, retriesLeft) {
+    try {
+        console.log('Retrying to retrieve logs...');
+        await sdk.logs.showWorkflowLogs(workflowId, true);
+        return;
+    } catch (e) {
+        Output.printError(new CFError({
+            message: `Could not retrieve logs for workflow: ${workflowId}`,
+            cause: e,
+        }));
+    }
+
+    let failedToGetStatus = false;
+
+    try {
+        console.log('Checking build status...');
+        const workflow = await sdk.workflows.getBuild({ buildId: workflowId, noAccount: false });
+        const currentStatus = workflow.status;
+        if (END_STATUSES.includes(currentStatus)) {
+            console.log(`Build finished with status: '${_.upperCase(currentStatus)}'`);
+            return;
+        }
+        console.log(`Current build status is: '${_.upperCase(currentStatus)}'`);
+    } catch (e) {
+        if (!request.RetryStrategies.HTTPOrNetworkError(e, _.pick('statusCode'))) {
+            throw e;
+        }
+
+        failedToGetStatus = true;
+
+        if (retriesLeft === 0) {
+            throw e;
+        }
+        console.log(`Could not get build status: ${e.message}.`);
+        console.log('Retrying...');
+    }
+
+    await Promise.delay(interval);
+    await _fallbackLogs(workflowId, interval, failedToGetStatus ? retriesLeft - 1 : retriesLeft);
+}
+
+const followLogs = async (workflowId) => {
+    try {
+        checkVersion(nodeVersionToValidate);
+    } catch (error) {
+        const url = _.get(sdk, 'config.context.url', 'https://g.codefresh.io');
+        const buildLink = `${url}/build/${workflowId}`;
+        // eslint-disable-next-line max-len
+        console.log(`Your node version (${process.version}) is not compatible with supported node version (${nodeVersionToValidate}) for this command, click the link to see it in codefresh UI : ${buildLink}`);
+        return;
+    }
+    try {
+        await sdk.logs.showWorkflowLogs(workflowId, true);
+    } catch (e) {
+        const error = new CFError({
+            message: `Could not retrieve logs for workflow: ${workflowId}`,
+            cause: e,
+        });
+        if (!process.env.CF_CLI_RUN_WAIT_FALLBACK) {
+            throw error;
+        } else {
+            Output.printError(error);
+        }
+        await _fallbackLogs(workflowId, config.logs.fallback.interval, config.logs.fallback.maxAttempts);
+    }
+    const json = await sdk.workflows.getBuild({ buildId: workflowId, noAccount: false });
+    const workflowInstance = Workflow.fromResponse(json);
+    switch (workflowInstance.getStatus()) {
+        case 'success':
+            return 0;
+        case 'error':
+            return 1;
+        case 'terminated':
+            return 2;
+        default:
+            return 100;
+    }
+};
+
+module.exports = {
+    followLogs,
+    _fallbackLogs,
+};

package/lib/interface/cli/helpers/progressEvents.js

@@ -0,0 +1,25 @@
+const EventEmitter = require('events');
+
+class ProgressEvents {
+    constructor() {
+        this.emitter = new EventEmitter();
+    }
+    onStart(handler) {
+        this.emitter.addListener('start', (args) => {
+            handler(args);
+        });
+    }
+    onProgress(handler) {
+        this.emitter.addListener('progress', (args) => {
+            handler(args);
+        });
+    }
+    reportStart(args) {
+        this.emitter.emit('start', args);
+    }
+    reportProgress(args) {
+        this.emitter.emit('progress', args);
+    }
+}
+
+module.exports = ProgressEvents;

package/lib/interface/cli/helpers/sys-re.js

@@ -0,0 +1,76 @@
+const _ = require('lodash');
+const { sdk } = require('../../../../lib/logic');
+
+const TYPES = {
+    plan: 'PlanRuntimeEnvironment',
+    system: 'SystemRuntimeEnvironment',
+    account: 'AccountRuntimeEnvironment',
+};
+
+function resolveType(name) {
+    if (!name) {
+        return null;
+    }
+    if (name.startsWith('system/plan')) {
+        return TYPES.plan;
+    }
+    if (name.startsWith('system/')) {
+        return TYPES.system;
+    }
+    return TYPES.account;
+}
+
+function get(options) {
+    const type = resolveType(options.name);
+
+    if (type === TYPES.system) {
+        return sdk.onPrem.runtimeEnvs.system.get(options);
+    }
+    return sdk.onPrem.runtimeEnvs.plan.get(options);
+}
+
+function list(options) {
+    if (options.account) {
+        return sdk.onPrem.runtimeEnvs.account.list(options);
+    }
+    return sdk.onPrem.runtimeEnvs.list(options);
+}
+
+function update(options, body) {
+    const type = resolveType(options.name);
+
+    if (type === TYPES.system) {
+        return sdk.onPrem.runtimeEnvs.system.update(options, body);
+    }
+    return sdk.onPrem.runtimeEnvs.plan.update(options, body);
+}
+
+function deleteRe(options) {
+    const type = resolveType(options.name);
+
+    if (type === TYPES.system) {
+        return sdk.onPrem.runtimeEnvs.system.delete(options);
+    }
+    return sdk.onPrem.runtimeEnvs.plan.delete(options);
+}
+
+function setDefault(options) {
+    if (options.account) {
+        return sdk.onPrem.runtimeEnvs.account.setDefault(options);
+    }
+    return sdk.onPrem.runtimeEnvs.plan.setDefault(options);
+}
+
+function types() {
+    return _.cloneDeep(TYPES);
+}
+
+module.exports = {
+    get,
+    list,
+    update,
+    delete: deleteRe,
+    setDefault,
+    resolveType,
+    types,
+};