sl-cia/lib/cli.js

var nopt = require("nopt"),
    noptTypes = require("./nopt-types.js"),
    noptUsage = require("./nopt-usage-2.js"),
    path = require("path"),
    parseDependencies = require('./dependency-parser.js').parseDependencies,
    BuildDiffProcess = require("./build-diff-process.js").BuildDiffProcess,
    cfgLoader = require('./configuration-loader.js'),
    readJsonSync = require('read-json-sync'),
    loggerFactory = require("./sl-logger.js").logger,
    expandCommaSeparatedValues = require('./utils').expandCommaSeparatedValues,
    globalErrorHandler = require('./global-error-handler'),
    SlJsInfra = require('sl-js-infra').SlJsInfra,
    DefaultValuesResolver = require('./default-values-resolver'),
    Technology = SlJsInfra.Entities.Technology,
    AgentType = SlJsInfra.Entities.AgentType;


//TODO: [SLDEV-4709] Verify if we can remove this completely. Should check how SlNodeJS invokes it.
function sendLastLogs(cfg, logger, callback) {
    if (cfg.sendLogs) {
        logger.remoteStream.checkBuffer(true, function (err) {
            callback();
        })
    } else {
        callback();
    }
}

function CIA(sourceConrolProviders) {
    this._hasMissingArguments = false;
    this._hadInvalidArguments = false;
    this.knownOpts = this._createKnownOptions();
    this.shortHands = this._createShortHands();
    this.description = this._createDescription();
    this.defaults = this._createDefaults();
    this.getSourceConrolProviders = function () {
        return sourceConrolProviders;
    };
}

CIA.prototype.run = function run(callback) {
    console.log('SeaLights Build agent ' + require("../package.json").version);
    var context = this;
    var buildArguments = this.getBuildArguments();
    this._validateArguments(buildArguments);
    if (this._hasInvalidOrMissingArguments(buildArguments)) {
        return this.handleInvalidArgs(callback);
    }
    var parsedDependencies = this._tryParseDependenciesForIntegrationBuild(buildArguments);
    this.loadConfiguration(buildArguments, function (err, cfg) {
      if(err){
          console.error(err.stack);
          callback(buildArguments.failBuild ? 1 : 0);
      } else {
          var logger = loggerFactory(cfg);
          printConfiguration(cfg, logger);
          var buildMappingProxy = new SlJsInfra.BackendProxy(cfg, logger);
          var packageJsonFile = getPackageJsonFile(buildArguments.workspacepath, logger)
          var agentEventsController = createAgentEventsController(buildArguments.workspacepath, logger);
          agentEventsController.submitAgentStartedEvent(packageJsonFile).then(function () {
              context.runBuildDiffProcess(cfg, buildMappingProxy, parsedDependencies, buildArguments, logger, agentEventsController, callback);
          })
      }
    })
}

CIA.prototype._hasInvalidOrMissingArguments = function(buildArguments){
    return this._hasMissingArguments || this._hadInvalidArguments || buildArguments.help;
}

CIA.prototype._tryParseDependenciesForIntegrationBuild = function(buildArguments){
    var parsedDependencies = [];
    if (buildArguments.dependency && !this._hadInvalidArguments) {
        try {
            parsedDependencies = parseDependencies(buildArguments.dependency);
        } catch (e) {
            globalErrorHandler.setLastError(e)
            this._hadInvalidArguments = true;
        }
    }

    if (buildArguments.dependenciesFile && !this._hadInvalidArguments) {
        try {
            var parsedJson = readJsonSync(buildArguments.dependenciesFile);
            if (!parsedJson || !Array.isArray(parsedJson)) {
                throw 'Invalid file structure';
            }

            parsedJson.forEach(function (depItem) {
                if (depItem.appName && depItem.build && depItem.branch) {
                    parsedDependencies.push({
                        appName: depItem.appName.toString(),
                        branch: depItem.branch.toString(),
                        build: depItem.build.toString()
                    });
                } else {
                    throw 'Invalid dependency item: ' + JSON.stringify(depItem);
                }
            });

        } catch (e) {
            globalErrorHandler.setLastError(e, 'Error reading/parsing ' + buildArguments.dependenciesFile);
            this._hadInvalidArguments = true;
        }
    }

    return parsedDependencies;
}

CIA.prototype._validateArguments = function(buildArguments){
    var context = this;
    ["branch", "build", "appname"].forEach(function (key) {
        if (!buildArguments[key]) {
            console.error("Required argument '" + key + "' not specified");
            context._hasMissingArguments = true;
        }
    });

    //workspacepath, scm must all come together or not at all
    var count = 0;
    ["workspacepath", "scm"].forEach(function (key) {
        if (buildArguments[key]) {
            count++;
        }
    });

    if (count != 0 && count != 2) {
        console.error("The 'workspacepath' and 'scm' command-line arguments must be specified together or not at all");
        this._hadInvalidArguments = true;
    }
}

CIA.prototype._createKnownOptions = function(){
    return {
        "workspacepath": path,
        "outputpath": String,
        "instrumentForBrowsers": Boolean,
        "downloadAgent": Boolean,
        "instrumentationOnly": Boolean,
        "branch": String,
        "build": String,
        "commit": String,
        "appname": String,
        "config": String,
        "scm": "scm",
        "help": Boolean,
        "dependency": [String, Array],
        "dependenciesFile": path,
        "recursive": Boolean,
        "author": [String, Array],
        "logsUrl": String,
        "jobName": String,
        "usebranchcoverage": Boolean,
        "usebuildmappingv3": Boolean,
        "token": String,
        "buildsessionid": String,
        "includedFiles": [String, Array],
        "excludedFiles": [String, Array],
        "babylonPlugins": [String, Array],
        "es6Modules": Boolean,
        "failBuild": Boolean,
        "uniqueModuleId": String,
        "scmBaseUrl": String,
        "scmVersion": String,
        "scmProvider": String,
        "useBabylon":Boolean,
        "sendContributors": Boolean,
        "delayShutdownInSeconds": Number,
        "projectRoot": String,
        "labid": String
    };
}

CIA.prototype._createShortHands = function(){
    return {
        "h": ["--help"],
        "d": ["--dependency"],
        "r": ["--recursive"]
    };
}

CIA.prototype._createDescription = function(){
    return  {
        "workspacepath": " Path to the workspace where the source code exists",
        "outputpath": " Path where the compiled output exists",
        "instrumentForBrowsers": " Instrument javascript files for browser coverage",
        "instrumentationOnly": " Skip sending mapping to the server. Used when instrumenting files on multiple steps",
        "downloadAgent": " Set this value to 'false' in order to prevent the instrumented javascript to try and download the browser test listener (for example, when using 'Karma').",
        "copyAllFilesToOutput": " Copy all files from the workspacepath to the outputpath. On by default.",
        "branch": " Branch name",
        "build": " Build version",
        "commit": " commit ID, as provided by the SCM (e.g. SHA1 for git, revision for SVN, changeset for TFS). May be automatically detected by the SCM.",
        "appname": " Application Name",
        "scm": " The Source Control Management used (currently only 'git' is supported)",
        "help": " Show this help page",
        "dependency": " Project dependencies. Pattern should be a semicolon-separated AppName@Branch@Build list. May be specified more than once.",
        "dependenciesFile": " A path to a json file that is in the following format: [{\"appName\":\"\",\"branch\":\"\",\"build\":\"\"},{...}]",
        "recursive": " Starts a recursive search for in a folder specified by the 'workspacepath' option",
        "author": " Optional. The name or email of the user that should be associated with this build. May be specified more than once.",
        "logsUrl": " Optional. The logs url of the build.",
        "jobName": " Optional. The jenkins job name that triggered the build.",
        "usebranchcoverage": " Optional. Include branches in scan",
        "usebuildmappingv3": " Optional. Use V3 of build mapping",
        "token": " Agent token used to authenticate requests by the server",
        "buildsessionid": " Build Session ID to associate with this build",
        "includedFiles": " Files glob pattern to include, relative to the workspacepath. Defaults to **/*.js. Comma-separated values are accepted.",
        "excludedFiles": " Files glob pattern to exclude, relative to the workspacepath. Defaults to node_modules/**/*.js, test/**.js. Comma-separated values are accepted.",
        "failBuild": " Makes the build scanner exit with non-zero code on success. Off by default",
        "es6Modules": " Use ES6 'module' mode when scanning files.",
        "useBabylon":"Use babylon for scanning files",
        "babylonPlugins": "List of non default babylon parser plugins, separated by comma",
        "sendContributors": "Send contributor details for advanced committer reports and features",
        "delayShutdownInSeconds":"Shutdown time in seconds for the browser agent. Default is 30 seconds.",
        "scmProvider": "The provider name of your Source Control Management (SCM) tool. Supported values are 'Github', 'Bitbucket' and 'Gitlab'. If not used, 'Github' is assumed.",
        "scmVersion": "The version of your Source Control Management (SCM) tool. If left blank, cloud version is assumed. Otherwise, specify the version of your on-premise server.",
        "scmBaseUrl": "The URL to the repository which contains the code. If left blank, the url of the remote GIT origin is being used.",
        "uniqueModuleId":"Unique module id, case-sensitive. This value should remain consistent between runs."
    };
}

CIA.prototype._createDefaults = function(){
    var defaultValuesResolver = new DefaultValuesResolver();
    return {
        "help": "",
        "includedFiles": defaultValuesResolver.getIncludedFiles(),
        "excludedFiles": defaultValuesResolver.getExcludedFiles(),
        "prefixesOfExcludedFiles": process.env["SL_prefixesOfExcludedFiles"] ? process.env["SL_prefixesOfExcludedFiles"] : "~, :, webpack, node_modules",
        "delayShutdownInSeconds":30
    };
}

CIA.prototype.handleInvalidArgs = function(callback) {
    try {
        var usage = noptUsage(this.knownOpts, this.shortHands, this.description, this.defaults);
        console.error(usage);
    } catch (e) {
        globalErrorHandler.setLastError(e);
    }
    return callback(1);
}


CIA.prototype.loadConfiguration = function(buildArguments, callback) {
    cfgLoader(buildArguments.config).then(function (cfg) {
        cfg.appName = buildArguments.appname;
        if (buildArguments.token) {
            cfg.token = buildArguments.token;
        }
        callback(null, cfg);
    }).catch(function (err) {
        callback(err)
    });
}

function shutdownAgent(logger, cfg, statusCode, agentEventsController, callback) {
    sendLastLogs(cfg, logger, function () {
        agentEventsController.submitAgentShutdownEvent().then(function () {
            callback(statusCode);
        })
    });}


CIA.prototype.runBuildDiffProcess = function(cfg, buildMappingProxy, parsedDependencies, buildArguments, logger, agentEventsController, callback) {
    var scmProviders = this.getSourceConrolProviders();
    var buildDiffProcess = new BuildDiffProcess(cfg, buildMappingProxy, scmProviders, parsedDependencies, agentEventsController, logger);
    buildDiffProcess.run(buildArguments).then(function () {
        shutdownAgent(logger, cfg, 0, agentEventsController, callback);
    }).catch(function (err) {
        logger.error(err);
        var statusCode = buildArguments.failBuild ? 1 : 0;
        shutdownAgent(logger, cfg, statusCode, agentEventsController, callback);
    });
}

CIA.prototype.getBuildArguments = function() {
    nopt.typeDefs.git = noptTypes.git;
    nopt.invalidHandler = function (key, val, types) {
        context._hasMissingArguments = true;
        console.error('Invalid value specified for ' + key + ': ' + val);
    };
    var buildArguments = nopt(this.knownOpts, this.shortHands, process.argv, 2);
    for (var i in this.defaults) { //Add default values
        if (!buildArguments[i]) {
            buildArguments[i] = this.defaults[i];
        }
    }
    buildArguments.includedFiles = expandCommaSeparatedValues(buildArguments.includedFiles);
    buildArguments.excludedFiles = expandCommaSeparatedValues(buildArguments.excludedFiles);
    buildArguments.babylonPlugins = expandCommaSeparatedValues(buildArguments.babylonPlugins);
    return buildArguments;
}




function printConfiguration(cfg, logger)
{
    logger.info("***************************************************************");
    logger.info("Current Configuration: ");
    logger.info("***************************************************************");

    for(p in cfg)
    {
        if (typeof cfg[p] != "function"){
            logger.info(p + ":", cfg[p]);
        }
    }

    logger.info("***************************************************************");

}

function createAgentEventsController(workspace, logger){
    var loader = new SlJsInfra.ConfigLoader();
    var agentConfig = loader.loadAgentConfiguration({});
    return new SlJsInfra.AgentEventsController(agentConfig, AgentType.BUILD_SCANNER, Technology.NODEJS, false, logger);
}

function getPackageJsonFile(path, logger) {
    try {
        var packageFilePath = SlJsInfra.Utils.FileUtils.findFileUp("package.json", path);
        return require(packageFilePath);
    } catch (e) {
        logger.info("Could not find package.json file in path '%s'");
        return null
    }
}

module.exports.CIA = CIA;