codefresh 0.78.2

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

@@ -0,0 +1,62 @@
+const _ = require('lodash');
+const columnify = require('columnify');
+const chalk = require('chalk');
+const kefir = require('kefir');
+const debug = require('debug')('codefresh:cli:helpers:auth');
+const { Config } = require('codefresh-sdk');
+const { sdk } = require('../../../logic');
+
+const printTableForAuthContexts = ({ filter = 'all' } = {}) => {
+    const configManager = Config.manager();
+    const currentContext = configManager.getCurrentContext();
+    const sdkContext = sdk.config && sdk.config.context;
+    if (!currentContext && (!sdkContext || sdkContext.isNoAuth)) {
+        console.log('No authentication contexts. Please create an authentication context (see codefresh auth create-context --help)');
+        return Promise.resolve();
+    }
+
+    let contexts;
+    if (!currentContext || currentContext.name !== sdkContext.name) {
+        console.log('Using authentication context created from CF_API_KEY env variable:');
+        sdkContext.current = true;
+        contexts = [sdkContext];
+    } else if (filter === 'all') {
+        contexts = _.values(configManager.getAllContexts());
+    } else if (filter === 'current') {
+        contexts = currentContext ? [currentContext] : [];
+    }
+
+
+    let mergedKeys = [];
+    return kefir.sequentially(0, contexts)
+        .flatMap((context) => {
+            debug(`context to check ${context.name}`);
+            return kefir.fromPromise(context.addAccountInfo()
+                .then(() => {
+                    mergedKeys = _.union(mergedKeys, context.defaultColumns);
+                    return _.chain(context)
+                        .pick(context.defaultColumns)
+                        .mapValues((value, key) => {
+                            if (key === 'current') return chalk.green('*');
+                            return _.isString(value) ? value : JSON.stringify(value);
+                        })
+                        .value();
+                }));
+        })
+        .scan((prev, context) => {
+            prev.push(context);
+            return prev;
+        }, [])
+        .flatMap((info) => {
+            info = _.sortBy(info, ['name']); // eslint-disable-line
+            const output = columnify(info, { columns: mergedKeys });
+            return kefir.constant(output);
+        })
+        .ignoreErrors()
+        .toPromise()
+        .then((output) => {
+            console.log(output);
+        });
+};
+
+module.exports = { printTableForAuthContexts };

package/lib/interface/cli/helpers/cli-config.js

@@ -0,0 +1,110 @@
+const _ = require('lodash');
+const flatten = require('flat');
+const columnify = require('columnify');
+const yaml = require('js-yaml');
+const Style = require('../../../output/Style');
+const { NoPropertyError, MultiplePropertiesError, NotFullPropertyError, SchemaValidationError } = require('../../../logic/cli-config/errors');
+
+const _jsonFormatter = data => JSON.stringify(data, null, 4);
+const COLUMNIFY_OPTS = { columnSplitter: '   ', headingTransform: Style.bold.uppercase };
+
+const NO_PROPERTIES_MESSAGE = 'no properties';
+const PAGINATION_SESSION_HEADER = 'X-Pagination-Session-Id';
+
+function _valueFormatter(value) {
+    if (value === null) {
+        return Style.gray('<null>');
+    }
+    if (typeof value === 'string') {
+        return Style.green(`'${value}'`);
+    }
+    if (typeof value === 'boolean') {
+        return Style.yellow(value);
+    }
+    return value;
+}
+
+function _defaultOutput(data) {
+    const flat = flatten(data);
+    const columns = _.keys(flat)
+        .sort()
+        .map((key) => {
+            const value = _valueFormatter(_.get(data, key));
+            return { key, value };
+        });
+    return columnify(columns, COLUMNIFY_OPTS);
+}
+
+function _formatter(format) {
+    switch (format) {
+        case 'yaml':
+            return yaml.safeDump;
+        case 'json':
+            return _jsonFormatter;
+        default:
+            return _defaultOutput;
+    }
+}
+
+function outputCliConfig(format, data) {
+    const formatter = _formatter(format);
+    console.log(formatter(data));
+}
+
+function outputCliMeta(props) {
+    const columns = props.map(meta => {
+        meta.default = _valueFormatter(meta.default);
+        return meta;
+    });
+    if (columns.length) {
+        console.log(columnify(columns, COLUMNIFY_OPTS));
+    } else {
+        console.log(NO_PROPERTIES_MESSAGE);
+    }
+}
+
+function printProperties(properties) {
+    properties.sort().forEach(prop => console.log(prop));
+}
+
+function propertyErrorHandler(e) {
+    if (e instanceof NoPropertyError) {
+        console.log(`Property "${e.property}" is not supported`);
+        return;
+    }
+    if (e instanceof MultiplePropertiesError) {
+        console.log('Choose one of the following properties:\n');
+        printProperties(e.properties);
+        return;
+    }
+    if (e instanceof NotFullPropertyError) {
+        console.log(`Did you mean property: ${e.property}?`);
+        return;
+    }
+    if (e instanceof SchemaValidationError) {
+        e.printErrors();
+        return;
+    }
+    throw e;
+}
+
+function getSdkConfigForPagination() {
+    const conf = {};
+    const { HOSTNAME, CF_BUILD_ID } = process.env;
+
+    //  if cli runs inside of the codefresh pipeline need to create pagination sessionId according to the build id and container id
+    if (HOSTNAME && CF_BUILD_ID) {
+        //  HOSTNAME – container id inside docker container
+        const sessionId = `${HOSTNAME}:${CF_BUILD_ID}`;
+        _.set(conf, `request.headers.${PAGINATION_SESSION_HEADER}`, sessionId);
+    }
+    return conf;
+}
+
+module.exports = {
+    outputCliConfig,
+    printProperties,
+    propertyErrorHandler,
+    outputCliMeta,
+    getSdkConfigForPagination,
+};

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

@@ -0,0 +1,60 @@
+const _ = require('lodash');
+const CFError = require('cf-errors');
+const { validatePipelineSpec, checkOrProjectExists } = require('./validation');
+const { sdk } = require('../../../logic');
+const { createAnnotations } = require('../commands/annotation/annotation.logic');
+
+function _basicValidation({ name }) {
+    if (!name) {
+        throw new CFError('Name is missing');
+    }
+}
+
+const _entities = {
+
+    context: {
+        validate: _basicValidation,
+        create: ({ data }) => sdk.contexts.create(data),
+    },
+    'step-type': {
+        validate: _basicValidation,
+        create: ({ data }) => sdk.steps.create(data),
+    },
+    project: {
+        validate: _basicValidation,
+        create: ({ name, data }) => checkOrProjectExists(name)
+            .then(() => sdk.projects.create({ projectName: name, ..._.pick(data.metadata, ['tags', 'variables']) })),
+    },
+    pipeline: {
+        validate: _basicValidation,
+        create: ({ data }) => validatePipelineSpec(data)
+            .then((result = {}) => (result.valid ? sdk.pipelines.create(data) : console.warn(result.message))),
+    },
+    annotation: {
+        create: ({ data }) => {
+            const labels = _.get(data.metadata, 'labels', [])
+                .map(({ key, value }) => `${key}=${value}`);
+            return createAnnotations({ labels, ..._.pick(data.metadata, ['entityId', 'entityType']) });
+        },
+    },
+};
+
+const entityList = Object.keys(_entities);
+
+function createEntity(options) {
+    const { entity } = options;
+    if (!_entities[entity]) {
+        throw new CFError(`Entity: ${entity} not supported`);
+    }
+
+    if (_entities[entity].validate instanceof Function) {
+        _entities[entity].validate(options);
+    }
+
+    return _entities[entity].create(options);
+}
+
+module.exports = {
+    createEntity,
+    entityList,
+};

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

@@ -0,0 +1,235 @@
+const Promise = require('bluebird');
+const _ = require('lodash');
+const fs = require('fs');
+const yaml = require('js-yaml');
+const defaults = require('../defaults');
+const CFError = require('cf-errors');
+const path = require('path');
+const Output = require('../../../output/Output');
+const { sdk } = require('../../../logic');
+
+const isDebug = () => (process.env.DEBUG || '').includes(defaults.DEBUG_PATTERN);
+
+
+const wrapHandler = (handler, requiresAuthentication) => {
+    return async (argv) => {
+        try {
+            Output.init(argv);
+
+            let requiresAuthenticationValue = requiresAuthentication;
+            if (typeof requiresAuthentication === 'function') {
+                requiresAuthenticationValue = requiresAuthentication(argv);
+            }
+
+            if (requiresAuthenticationValue && (!sdk.config || !sdk.config.context || sdk.config.context.isNoAuth)) {
+                Output.printError(new CFError('Authentication error: Please create an authentication context (see codefresh auth create-context --help)'));// eslint-disable-line
+                process.exit(1);
+            }
+
+            if (!argv.watch) {
+                await handler(argv);
+                return;
+            }
+
+            let consecutiveErrors = 0;
+            let initial = true;
+            while (true) {
+                try {
+                    await handler(argv, initial);
+                    consecutiveErrors = 0;
+                    initial = false;
+                }
+                catch (err) {
+                    consecutiveErrors++;
+                    if (initial || consecutiveErrors > defaults.MAX_CONSECUTIVE_ERRORS_LIMIT) {
+                        throw err;
+                    }
+                }
+                await Promise.delay(argv['watch-interval']);
+            }
+
+        } catch (err) {
+            Output.printError(err);
+            process.exit(1);
+        }
+    };
+};
+
+/**
+ * will return an object with key/value from parsing an array of key=value
+ * @param environmentVariables
+ * @returns {{}}
+ */
+const prepareKeyValueFromCLIEnvOption = (environmentVariables) => {
+    const variables = {};
+    if (!environmentVariables) {
+        return variables;
+    }
+
+    const envArray = _.isArray(environmentVariables) ? environmentVariables : [environmentVariables];
+
+    envArray.forEach((vars) => {
+        const separator = '=';
+        const key = _.chain(vars).split(separator, 1).first().value();
+        const val = _.split(vars, separator).slice(1).join(separator);
+        if (_.isUndefined(key) || _.isUndefined(val)) {
+            throw new CFError('Invalid environment variable format. please enter [key]=[value]');
+        }
+        variables[key] = val;
+    });
+    return variables;
+};
+
+/**
+ * will return an array of objects { key, value } from parsing an array of key=value
+ * @param environmentVariables
+ * @returns Array of { key, value }
+ */
+const prepareKeyValueObjectsFromCLIEnvOption = (environmentVariables) => {
+    const variables = [];
+    if (!environmentVariables) {
+        return variables;
+    }
+
+    const envArray = _.isArray(environmentVariables) ? environmentVariables : [environmentVariables];
+
+    envArray.forEach((vars) => {
+        const fields = vars.split('=');
+        const key = fields[0];
+        const value = fields[1];
+        if (_.isUndefined(key) || _.isUndefined(value)) {
+            throw new CFError('Invalid environment variable format. please enter [key]=[value]');
+        }
+        const obj = { key, value };
+        variables.push(obj);
+    });
+    return variables;
+};
+
+const crudFilenameOption = (yargs, options = {}) => {
+    const filenameOption = {
+        alias: options.alias || 'f',
+        describe: options.describe || 'Filename or directory of spec files use to create the resource',
+        global: options.global || false,
+        required: options.required || false,
+    };
+    if (options.group) {
+        filenameOption.group = options.group;
+    }
+
+    yargs
+        .option(options.name || 'filename', filenameOption)
+        .coerce(options.name || 'filename', (arg) => {
+            try {
+                const rawFile = fs.readFileSync(path.resolve(process.cwd(), arg), 'utf8');
+                if (arg.endsWith('.json')) {
+                    return options.raw ? rawFile : JSON.parse(rawFile);
+                }
+                if (arg.endsWith('.yml') || arg.endsWith('yaml')) {
+                    return options.raw ? rawFile : yaml.safeLoad(rawFile);
+                }
+                throw new CFError('File extension is not recognized');
+            } catch (err) {
+                const error = new CFError({
+                    message: 'Failed to read file',
+                    cause: err,
+                });
+                Output.printError(error);
+                process.exit(1);
+            }
+        });
+};
+
+const selectColumnsOption = (yargs, options = {}) => {
+    const selectColumnsConfig = {
+        alias: options.alias || 'sc',
+        describe: options.describe || 'Columns to select for table output',
+        group: 'Output Options',
+    };
+    if (options.group) {
+        selectColumnsConfig.group = options.group;
+    }
+
+    yargs
+        .option(options.name || 'select-columns', selectColumnsConfig)
+        .coerce(options.name || 'select-columns', (arg) => {
+            if (_.isEmpty(arg)) {
+                return [];
+            }
+            return arg.split(',');
+        });
+};
+
+function pathExists(p) {
+    return new Promise(resolve => fs.access(p, resolve))
+        .then(err => !err);
+}
+
+const readFile = Promise.promisify(fs.readFile);
+
+function watchFile(filename, listener) {
+    fs.watchFile(filename, { interval: 500 }, listener);
+    const unwatcher = f => () => fs.unwatchFile(f);
+    ['exit', 'SIGINT', 'SIGUSR1', 'SIGUSR2', 'uncaughtException', 'SIGTERM'].forEach((eventType) => {
+        process.on(eventType, unwatcher(filename));
+    });
+}
+
+function ignoreHttpError(e) {
+    if (!e.statusCode) {
+        throw e
+    }
+    return undefined;
+}
+
+function detectProxy() {
+    const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY;
+    const httpsProxy = process.env.https_proxy || process.env.HTTPS_PROXY;
+    const noProxy = process.env.no_proxy || process.env.NO_PROXY;
+    return {
+        httpProxy,
+        httpsProxy,
+        noProxy,
+    };
+}
+
+function keyValueArrayToObject(arr) {
+    return arr.reduce((acc, cur) => {
+        const parts = cur.split('=');
+        // eslint-disable-next-line prefer-destructuring
+        acc[parts[0]] = parts[1];
+        return acc;
+    }, {});
+}
+
+function addProxyVariables(envVars, { httpProxy, httpsProxy, noProxy }) {
+    const envVarsObj = keyValueArrayToObject(envVars);
+    if (httpsProxy && !envVarsObj.HTTPS_PROXY && !envVarsObj.https_proxy) {
+        envVars.push(`HTTPS_PROXY=${httpsProxy}`);
+        envVars.push(`https_proxy=${httpsProxy}`);
+    }
+    if (httpProxy && !envVarsObj.HTTP_PROXY && !envVarsObj.http_proxy) {
+        envVars.push(`HTTP_PROXY=${httpProxy}`);
+        envVars.push(`http_proxy=${httpProxy}`);
+    }
+    if (noProxy && !envVarsObj.NO_PROXY && !envVarsObj.no_proxy) {
+        envVars.push(`NO_PROXY=${noProxy}`);
+        envVars.push(`no_proxy=${noProxy}`);
+    }
+}
+
+module.exports = {
+    wrapHandler,
+    prepareKeyValueFromCLIEnvOption,
+    crudFilenameOption,
+    selectColumnsOption,
+    prepareKeyValueObjectsFromCLIEnvOption,
+    pathExists,
+    readFile,
+    watchFile,
+    isDebug,
+    ignoreHttpError,
+    detectProxy,
+    keyValueArrayToObject,
+    addProxyVariables,
+};

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

@@ -0,0 +1,51 @@
+const Promise = require('bluebird');
+const _ = require('lodash');
+const sdk = require('../../../logic/sdk');
+const Context = require('../../../logic/entities/Context');
+
+const SUPPORTED_TYPES = [
+    'yaml',
+    'secret-yaml',
+];
+
+const normalizeValues = async (values = []) => {
+    return Promise.reduce(values, async (normalized, name) => {
+        let context;
+        try {
+            context = await sdk.contexts.get({ name });
+            context = Context.fromResponse(context);
+        } catch (err) {
+            console.log(`Failed to get context: ${err.message}`);
+            throw err;
+        }
+        const type = context.getType();
+        if (_.includes(SUPPORTED_TYPES, type)) {
+            normalized.push({
+                name,
+            });
+        } else {
+            console.log(`${name} has type ${type} which not supported, skipping`);
+        }
+        return normalized;
+    }, []);
+};
+
+const normalizeSetValues = async (values = []) => {
+    return Promise.reduce(values, async (normalized, givenValue) => {
+        const [key, value] = givenValue.split('=');
+        if (!key || !value) {
+            throw new Error('Passed set value must be in format KEY=VALUE');
+        }
+        const setObject = {
+            key,
+            value,
+        };
+        normalized.push(setObject);
+        return normalized;
+    }, []);
+};
+
+module.exports = {
+    normalizeValues,
+    normalizeSetValues,
+};