sl-cia/lib/sl-config-cia-cli.js

var nopt = require("nopt"),    
    noptUsage = require("nopt-usage"),
    fs = require("fs"),
    readJsonSync = require('read-json-sync'),
    utils = require('./utils.js'),
    globalErrorHandler = require('./global-error-handler'),
    version = require("../package.json").version,
    SlJsInfra = require('sl-js-infra').SlJsInfra,
    bunyan = require('bunyan');

var SEALIGHTS_JSON_FILENAME = "./sealights.json";
var knownOpts = {
    "token": String
    , "customerid" : String
    , "server": String
    , "proxy" : String
    , "appname" : String
    , "branch" : String
    , "nodejsexcludedpaths" : String
    , "usebranchcoverage": Boolean
    , "help": Boolean
},
    shortHands = {
        "h": ["--help"]
    },

    description = {
        "token": "Sealights Token Received Upon Registration",
        "customerid": " Customer ID (mandatory, unless already exists in sealights.json)",
        "server": " SeaLights Server URL",
        "proxy": " Proxy server (optional, must be a valid URL)",
        "help": " Show this help page", 
        "nodejsexcludedpaths": "NodeJS Only. Comma-separated list of excluded paths glob strings, in the form of 'public/**/*.js,files/**/*.js'. The default value is test/**/*.js. The node_modules folder is always excluded.",
        "usebranchcoverage": "Optional. Include branches in scan"
    },

    defaults = {
        "help": "",
    };

var parsedArgs = parseCommandLineArguments();
if (parsedArgs.help) {
    printUsage();
    process.exit(1);
} else {
    getConfigFromServer(parsedArgs, function (err, serverConfig) {
        if (err)
        {
            console.error("Failed to get configuration from the server. Continue with current config. Error: ", err);
        }
        updateOrCreateCfg(err, serverConfig);
    })
}




function updateOrCreateCfg(err, serverConfig) {
    
    var cfg = {
        "interval": 10000,
        "enabled": true
    };
    var forceRewrite = false;
    var readExistingCfgFileResult = readExistingCfgFile(SEALIGHTS_JSON_FILENAME) || {};
    if (readExistingCfgFileResult.error) {
        console.error("ERROR: " + readExistingCfgFileResult.error);
        process.exit(1);
    }
    else if (readExistingCfgFileResult.cfg) {
        cfg = readExistingCfgFileResult.cfg;
    } else {
        forceRewrite = true;
    }
    
    if (updateCfgFromAgruments(cfg, parsedArgs, serverConfig) > 0) {
        forceRewrite = true;
    }
    
    validateCfg(cfg);
    
    if (forceRewrite) {
        writeFile(cfg);
    } else {
        console.warn('No changes made to ' + SEALIGHTS_JSON_FILENAME);
    }
}

function parseCommandLineArguments() {
    var parsedArgs = nopt(knownOpts, shortHands, process.argv, 2);
    if (parsedArgs.token) {
        utils.parseToken(parsedArgs.token, parsedArgs)
    }
    return parsedArgs;
}

function printUsage() {
    try {
        var usage = noptUsage(knownOpts, shortHands, description, defaults);
        console.info('Usage: sl-config-cia -customerid [customerid] -server [server] -proxy [proxy]');
        console.info(usage);
    } catch (e) {
        globalErrorHandler.setLastError(e);
    }
}

function readExistingCfgFile(filename) {
    if (fs.existsSync(filename)) {
        try {
            var loadedCfg = readJsonSync(filename);
            if (Object.prototype.toString.call(loadedCfg) !== "[object Object]")
                throw "File content is not a valid JSON object";
            return { cfg: loadedCfg };
        } catch (e) {
            globalErrorHandler.setLastError(e, "Cannot read cfg file");
            return { error: filename + " cannot be read and is probably corrupted. Please delete it and re-run.", cfg: null };
        }
    }
}

function updateCfgFromAgruments(cfg, parsedArgs, serverConfig) {
    function updateField(name, cfgProperty, argName) {
        if (serverConfig[argName]) {
            console.info("Updating " + name + " = " + serverConfig[argName] + " From Server");
            cfg[cfgProperty] = serverConfig[argName];
            return true;
        }
        else if (parsedArgs[argName]) {
            console.info("Updating " + name + " = " + parsedArgs[argName]);
            cfg[cfgProperty] = parsedArgs[argName];
            return true;
        }
        return false;
    }
    var changedFields = 0;
    if (updateField("Token", "token", "token")) changedFields++;
    if (updateField("Valid Token", "isValidToken", "isValidToken")) changedFields++;
    if (updateField("Customer Id", "customerId", "customerid")) changedFields++;
    if (updateField("Server", "server", "server")) changedFields++;
    if (updateField("App Name", "appName", "appname")) changedFields++;
    if (updateField("Branch", "branch", "branch")) changedFields++;
    if (updateField("Proxy", "proxy", "proxy")) changedFields++;    
    if (updateField("Node.js excluded paths", "nodeJsExcludedPaths", "nodejsexcludedpaths")) changedFields++;
    if (updateField("Branch Coverage", "useBranchCoverage", "usebranchcoverage")) changedFields++;
    if (updateField("Send Logs", "sendLogs", "sendLogs")) changedFields++;
    if (updateField("Logs Buffer Length", "bufferLength", "bufferLength")) changedFields++;
    if (updateField("Logs Buffer Timeout", "bufferTimeout", "bufferTimeout")) changedFields++;
    
    return changedFields;
    
}

function validateCfg(cfg) {
    if (!cfg.customerId)
        console.warn("WARNING: Configuration file is missing the required 'customerId' field");
    if (!cfg.server)
        console.warn("WARNING: Configuration file is missing the required 'server' field");
}

function writeFile(cfg) {
    try {
        console.info('Writing file ' + SEALIGHTS_JSON_FILENAME);
        var json = JSON.stringify(cfg, null, '\t');
        fs.writeFileSync(SEALIGHTS_JSON_FILENAME, json);
        console.info('Done.');
    } catch (e) {
        globalErrorHandler.setLastError(e, 'Error writing to file ' + SEALIGHTS_JSON_FILENAME + ": ");
    }
}

function getConfigFromServer(cfg, callback) {
    if (!cfg.customerid || !cfg.server) {
        console.warn(
            "[CONFIG FROM SERVER] customerid and server are required for server configuration. " +
            "Config: " + JSON.stringify(cfg)
        );
        return callback(null, {});
    }

    var request = {
        appName:cfg.appname,
        branch:cfg.branch,
        customerId:cfg.customerid,
        testStage:"null",
        component:"nodejs-build",
        version:version
    };

    var backendProxy = new SlJsInfra.BackendProxy(cfg, createLogger());
    backendProxy.getRemoteConfig (request,function (err, resp) {
        if (!err) {
            console.info("[CONFIG FROM SERVER] Got Configuration From Server Successfully. Config: " + JSON.stringify(resp));
        }
        
        return callback(err, resp);
    });
}

function createLogger(){
    var log = bunyan.createLogger({
        name: "CIA-Config",
    });

    return log;
}