@testim/testim-cli/services/gridService.js

"use strict";

const _ = require('lodash');
const Promise = require('bluebird');
const {GridError, ArgError} = require('../errors');
const {gridMessages} = require('../commons/constants');
const logger = require('../commons/logger').getLogger("grid-service");
const servicesApi = require('../commons/testimServicesApi');

const gridCache = {};
const urlExtractRegex = /(^(https?):\/{2})?(.*)/;
let keepAliveTimer = null;

function extractProtocol(hostUrl) {
    const urlExtract = urlExtractRegex.exec(hostUrl);

    return urlExtract[2] || 'https';
}

function extractHost(hostUrl) {
    const urlExtract = urlExtractRegex.exec(hostUrl);

    return urlExtract[3];
}

function getSerializableObject(grid) {
    const host = grid && extractHost(grid.host);
    const port = grid && grid.port;
    const protocol = grid && grid.type === 'testimEnterprise' ? extractProtocol(grid.host) : undefined;
    const accessToken = grid && grid.token;
    const slotId = grid && grid.slotId;
    const user = grid && grid.external && grid.external.user;
    const key = grid && grid.external && grid.external.key;
    const arn = grid && grid.external && grid.external.arn;
    const type = grid && grid.type;
    const name = grid && grid.name;
    const gridId = grid && grid._id;

    return { host, port, protocol, accessToken, slotId, gridId, user, key, type, name, arn };
}

function handleGetGridResponse(projectId, workerId, browser, getFun) {
    return getFun()
        .catch(err => {
            logger.error("failed to get grid", {projectId, err});
            throw new Error(gridMessages.UNKNOWN);
        })
        .then(res => {
            logger.info("get grid info", Object.assign({}, res, {projectId}));
            const isSuccess = () => res.status === "success";
            const isError = () => res.status === "error" && res.code;
            if (!res || (!isError() && !isSuccess())) {
                logger.error("invalid response - get grid", {res});
                throw new Error(gridMessages.UNKNOWN);
            }

            if (isSuccess()) {
                const serGrid = getSerializableObject(res.grid);
                addItemToGridCache(workerId, serGrid.gridId, serGrid.slotId, browser);
                return serGrid;
            }

            if (isError() && res.code === "not-found") {
                throw new GridError(gridMessages.NOT_FOUND);
            }

            if (isError() && res.code === "no-available-slot") {
                throw new GridError(`Failed to run test on ${browser} - concurrency limit reached`);
            }

            logger.error("invalid code error response - get grid", {res});
            throw new GridError(gridMessages.UNKNOWN);
        });
}

function addItemToGridCache(workerId, gridId, slotId, browser) {
    gridCache[workerId] = {gridId, slotId, browser};
}

function getHostAndPortById(workerId, projectId, gridId, browser, executionId) {
    return handleGetGridResponse(projectId, workerId, browser, () => servicesApi.getGridById(projectId, gridId, browser, executionId));
}

function getHostAndPortByName(workerId, projectId, gridName, browser, executionId) {
    return handleGetGridResponse(projectId, workerId, browser, () => servicesApi.getGridByProject(projectId, gridName, browser, executionId));
}

function getAllGrids(companyId) {
    return servicesApi.getAllGrids(companyId);
}

function getGridDataByGridId(companyId, gridId, allGrids) {
    return Promise.resolve(allGrids || getAllGrids(companyId))
        .then(grids => {
            const grid = grids.find(grid => grid._id === gridId);
            if (!grid) {
                throw new ArgError(`Failed to find grid id: ${gridId}`);
            }
            return getSerializableObject(grid);
        });
}

function getGridDataByGridName(companyId, gridName, allGrids) {
    return Promise.resolve(allGrids || getAllGrids(companyId))
        .then(grids => {
            const grid = grids.find(grid => (grid.name || "").toLowerCase() === gridName.toLowerCase());
            if (!grid) {
                throw new ArgError(`Failed to find grid name: ${gridName}`);
            }
            return getSerializableObject(grid);
        });
}

function releaseGridSlot(workerId, projectId) {
    const gridData = gridCache[workerId];
    if (!gridData) {
        return Promise.resolve();
    }

    const {slotId, gridId, browser} = gridData;
    delete gridCache[workerId];
    if (!slotId) {
        logger.warn("failed to find grid slot id", {projectId});
        return Promise.resolve();
    }

    logger.info("release slot id", {projectId, slotId, gridId, browser});
    return servicesApi.releaseGridSlot(projectId, slotId, gridId, browser)
        .catch(err => logger.error("failed to release slot", {projectId, err}));
}

function keepAlive(projectId) {
    const slots = Object.keys(gridCache).reduce((slots, workerId) => {
        slots.push(gridCache[workerId]);
        return slots;
    }, []).filter(Boolean);

    if (_.isEmpty(slots)) {
        return Promise.resolve();
    }

    logger.info("keep alive worker slots", {projectId, slots});
    return servicesApi.keepAliveGrid(projectId, slots)
        .catch(err => logger.error("failed to update grid keep alive", {err, slots, projectId}));
}

function startKeepAlive(projectId) {
    const KEEP_ALIVE_INTERVAL = 10 * 1000;
    keepAliveTimer = setInterval(keepAlive, KEEP_ALIVE_INTERVAL, projectId);
}

function releaseAllSlots(projectId) {
    const workerIds = Object.keys(gridCache);

    if (_.isEmpty(workerIds)) {
        return Promise.resolve();
    }

    logger.warn("not all slots released before end runner flow", {projectId});
    return Promise.map(workerIds, workerId => releaseGridSlot(workerId, projectId))
        .catch(err => logger.error("failed to release all slots", {err, projectId}));
}

function endKeepAlive(projectId) {
    return releaseAllSlots(projectId)
        .then(() => clearInterval(keepAliveTimer));
}

function getVendorKeyFromOptions(type, options) {
    const {testobjectSauce, saucelabs} = options;
    if (type === "testobject") {
        return testobjectSauce.testobjectApiKey;
    }
    if (type === "saucelabs") {
        return saucelabs.accessKey;
    }
}

function getVendorUserFromOptions(type, options) {
    const {saucelabs} = options;
    if (type === "saucelabs") {
        return saucelabs.username;
    }
}

function getOptionGrid(options) {
    const getGridType = () => {
        if (!_.isEmpty(options.testobjectSauce)) {
            return "testobject";
        }

        if (!_.isEmpty(options.saucelabs)) {
            return "saucelabs";
        }

        if (!_.isEmpty(options.perfecto)) {
            return "perfecto";
        }

        return "hostAndPort";
    };
    const type = getGridType();
    const {host, port, path, protocol} = options;
    const key = getVendorKeyFromOptions(type, options);
    const user = getVendorUserFromOptions(type, options);
    return Promise.resolve({host, port, path, protocol, type, user, key});
}

function getGridData(options, allGrids = undefined) {
    const {host, grid, gridId, company, useLocalChromeDriver} = options;
    const companyId = company.companyId;

    if (host) {
        return Promise.resolve(getOptionGrid(options));
    }
    if (useLocalChromeDriver === true) {
        return Promise.resolve({ mode: 'local' });
    }
    if (gridId) {
        return getGridDataByGridId(companyId, gridId, allGrids);
    }
    if (grid) {
        return getGridDataByGridName(companyId, grid, allGrids);
    }
    
    return Promise.reject(new GridError("Missing host or grid configuration"));
}

const getGridSlot = Promise.method(_getGridSlot);

async function _getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
    const getGridDataFromServer = () => {
        const {host, project, grid, gridId, useLocalChromeDriver} = options;
        if (host) {
            return Promise.resolve(getOptionGrid(options));
        }
        if (gridId) {
            return getHostAndPortById(workerId, project, gridId, browser, executionId);
        }
        if (grid) {
            return getHostAndPortByName(workerId, project, grid, browser, executionId);
        }
        if (useLocalChromeDriver) {
            return { mode: 'local' };
        }
        throw new GridError("Missing host or grid configuration");
    };

    const gridInfo = await getGridDataFromServer();

    await onGridSlot(executionId, testResultId, gridInfo);

    return gridInfo;
}

module.exports = {
    getGridSlot: getGridSlot,
    releaseGridSlot: releaseGridSlot,
    getGridData: getGridData,
    addItemToGridCache: addItemToGridCache,
    getSerializableObject: getSerializableObject,
    keepAlive: {
        start: startKeepAlive,
        end: endKeepAlive
    }
};