sl-cia/lib/scm/git.js

var Promise = require('promise'),
    childProcess = require('child_process'),
    spawn = require('child_process').spawn,
    diffParse = require('parse-diff'),
    logParse = require('./parse-log.js').logParse,
    util = require('util'),
    formatBuilder = require('../git-format-builder'),
    globalErrorHandler = require('../global-error-handler'),
    consoleFileLogger = require("../sl-logger.js").consoleFileLogger;

var GIT_ROOT_DIR_COMMAND = " rev-parse --show-toplevel";
var GIT_LS_FILES_COMMAND = " ls-tree --full-tree -r --name-only HEAD";
var MAX_BUFFER_VALUE = 1024 * 1024 * 200; //200 Mb, instead of 200Kb

function Git(cfg) {
    this.getCfg = function getCfg() { return cfg; }
}

Git.prototype.getGitPath = function getGitPath() {
    return (this.getCfg() || {}).gitPath || 'git';
    // /tools/arch/Linux_2.6.32-x86_64/gcc-4.9.1-buildrel/bin/git
}

Git.prototype.detectCommitVersion = function detectCommitVersion(handlerParams, logger) {
    var gitPath = this.getGitPath();
    var cfg = this.getCfg();
    var log = logger? logger.child({methodName: "detectCommitVersion"}) : consoleFileLogger("detectCommitVersion");
    var p = new Promise(function (resolve, reject) {
        try {
            log.info('GIT: invoking git log -n 1.');
            log.info('GIT PATH: '+gitPath);
            var cmd = gitPath + " log -n 1 --pretty=format:%H";
            var gitLogOutput = childProcess.exec(cmd, {
                cwd: handlerParams.buildArguments.workspacepath,
                //maxBuffer: 1024 * 1024 * 200 //200 Mb, instead of 200Kb
            }, function (error, stdout, stderr) {
                //debuglog('stdout: ' + stdout);
                if (error !== null) {
                    handleChildProcessError(error, stderr, log);
                    reject(error);
                    return;
                }
                var commit = stdout.toString().trim();
                resolve(commit);
            });
        } catch (e) {
            globalErrorHandler.setLastError(e, 'GIT log error in detectCommitVersion: ');
            reject(e);
        }
    });
    return p;
}

Git.prototype.getBranchHistory = function getBranchHistory(handlerParams, logger) {
    var gitPath = this.getGitPath();
    var cfg = this.getCfg();
    var log = logger? logger.child({methodName: "getBranchHistory"}) : consoleFileLogger("getBranchHistory");
    var p = new Promise(function (resolve, reject) {
        var historyLength = getHistoryLength(cfg, log);
        log.info('GIT: invoking git log to get branch history');
        log.info('GIT PATH: ' + gitPath);
        var format = new formatBuilder().withCommit().withAuthorName().withAuthorEmail().withCommitterName().withCommitTerEmail()
            .withAuthorDate().withCommitterDate().withTitle().build();;
        var gitLogOutput = childProcess.exec(gitPath + ' log -n ' + historyLength + ' --format='+format, {
            cwd: handlerParams.buildArguments.workspacepath,
            maxBuffer: MAX_BUFFER_VALUE
        }, function (error, stdout, stderr) {
            if (error !== null) {
                handleChildProcessError(error, stderr, log)
                reject(error);
                return;
            }
            gitLog = handleBranchHistoryOutput(stdout, handlerParams, log);
            resolve(gitLog);
        });
    });
    return p;
}

Git.prototype.getContributors = function getContributors(handlerParams, logger){
    var gitPath = this.getGitPath();
    var cfg = this.getCfg();
    var log = logger? logger.child({methodName: "getContributors"}) : consoleFileLogger("getContributors");
    var p = new Promise(function (resolve, reject) {
        var historyLength = getHistoryLength(cfg, log);
        var format = new formatBuilder().withAuthorName("contributorName").withAuthorEmail("contributorEmail").build();
        var gitLogOutput = childProcess.exec(gitPath + ' log -n ' + historyLength +' --all --format=' + format, {
            cwd: handlerParams.buildArguments.workspacepath,
            maxBuffer: MAX_BUFFER_VALUE
        }, function (error, stdout, stderr) {
            if (error !== null) {
                handleChildProcessError(error, stderr, log);
                reject(error);
                return
            }
            contributorsLog = handleContributorsOutput(stdout, log);
            resolve(contributorsLog);
        });
    })
    return p;
}

Git.prototype.getCommitsPerFile = function getCommitsPerFile(handlerParams, logger){
    var gitPath = this.getGitPath();
    var cfg = this.getCfg();
    var log = logger? logger.child({methodName: "getCommitsPerFile"}) : consoleFileLogger("getCommitsPerFile");
    var historyLength = getHistoryLength(cfg, log);
    var p = new Promise(function (resolve, reject) {
        var commitToIndexMap = handlerParams.commitToIndexMap;
        if(!commitToIndexMap){
            logger.error("Cannot get commits for file, Commits log map is null or undefined");
            resolve('');
        }
        var gitLogOutput = childProcess.exec(gitPath + ' log -' + historyLength + ' --name-only --pretty=format:hash:%H', {
            cwd: handlerParams.buildArguments.workspacepath,
            maxBuffer: MAX_BUFFER_VALUE
        }, function (error, stdout, stderr) {
            if (error !== null) {
                handleChildProcessError(error, stderr, log);
                reject(error);
                return
            }
            var fileToCommitMap = handleCommitsPerFileOutput(stdout, commitToIndexMap, log);
            resolve(fileToCommitMap);
        });
    })
    return p;
}

Git.prototype.getRepositoryUrl = function getRepositoryUrl(handlerParams, logger) {
    var gitPath = this.getGitPath();
    var log = logger? logger.child({methodName: "getRepositoryUrl"}) : consoleFileLogger("getRepositoryUrl");
    var p = new Promise(function (resolve, reject) {
        var gitLogOutput = childProcess.exec(gitPath + ' remote -v', {
            cwd: handlerParams.buildArguments.workspacepath,
            maxBuffer: MAX_BUFFER_VALUE
        }, function (error, stdout, stderr) {
            if (error !== null) {
                handleChildProcessError(error, stderr, log);
                reject(error);
                return;
            }
            try {
                var repositoryUrl = '';
                if (stdout.toString()) {
                    repositoryUrl = logParse(stdout.toString());
                    repositoryUrl = repositoryUrl[0].split('\t').map(function (l) {return l.trim()})[1].replace(' (fetch)', '');
                }
                resolve(repositoryUrl);
            }
            catch (e) {
                globalErrorHandler.setLastError(e, 'Cannot get repository url due to an error: ');
                resolve('');
            }
        });
    })
    return p;
}

Git.prototype.getRootDirectory = function getRootDirectory(handlerParams) {
    var gitPath = this.getGitPath();
    return new Promise(function (resolve, reject) {
        childProcess.exec(gitPath + GIT_ROOT_DIR_COMMAND,{cwd: handlerParams.buildArguments.workspacepath} , function (error, stdout, stderr) {
            if (error) {
                handleChildProcessError(error, stderr, log);
                reject(error);
            }
            if(stderr){
                reject(stderr);
            }
            var rootDirPath = stdout.toString().trim();
            resolve(rootDirPath);
        })
    });
}

Git.prototype.getFiles = function getGitFiles(handlerParams) {
    var gitPath = this.getGitPath();
    return new Promise(function (resolve, reject) {
        childProcess.exec(gitPath + GIT_LS_FILES_COMMAND,{
            cwd: handlerParams.buildArguments.workspacepath,
            maxBuffer: MAX_BUFFER_VALUE
    } , function (error, stdout, stderr) {
            if (error) {
                handleChildProcessError(error, stderr, log);
                reject(error);
            }
            if(stderr){
                reject(stderr);
            }
            var result = stdout.toString() || "";
            var gitFilesList = result.trim().split("\n");
            resolve(gitFilesList);
        })
    });
}

function createCommitLogEntry(line, handlerParams){
    var lineObject = JSON.parse(line);
    var authorEmail = lineObject.authorEmail;
    var authorIndex = handlerParams.emailToIndexMap[authorEmail];
    var commitLogEntry={
        contributorIndex : authorIndex,
        commit: lineObject.commit,
        committerDate: parseInt(lineObject.committerDate),
        authorDate: parseInt(lineObject.authorDate),
        title: lineObject.title
    }
    return commitLogEntry;
}

function logJsonParsError(logger, line, field, err) {
    logger.warn("Unsupported string format \"" + line + "\" .'" + field + "'  may not be shown in dashboard")
    logger.debug("Error:", err)
}

function handleBranchHistoryOutput(stdout, handlerParams, logger){
    var commitHistory = [];
    var commitLog = [];
    var commitToIndexMap ={};
    var sendContributors = handlerParams.buildArguments.sendContributors;
    var lines = stdout.toString().split('\n');
    lines.forEach(function (line,index) {
        if(!line || line.trim().length == 0){
            return
        }
        line = line.trim();
        line = fixUnSupportedJsonCharacters(line);
        try {
            var gitLogEntry;
            if(sendContributors) {
                gitLogEntry = createCommitLogEntry(line, handlerParams)
            }else{
                gitLogEntry = JSON.parse(line);
            }
            commitHistory.push(gitLogEntry.commit);
            commitLog.push(gitLogEntry);
            commitToIndexMap[gitLogEntry.commit] = index;
        }
        catch (err) {
            logJsonParsError(logger, line, "commit-log", err);
        }
    });
    var gitLog = {
        commitHistory: commitHistory,
        commitLog: commitLog
        };
    if(sendContributors){
        gitLog.commitToIndexMap = commitToIndexMap;
    }
    return gitLog;
}

function handleContributorsOutput(stdout, logger){
    var contributors=[]
    var emailToIndexMap= {}
    var lines = stdout.toString().split('\n');
    var contributorIndex = 0;
    lines.forEach(function (line, lineIndex) {
        if(!line || line.trim().length == 0){
            return
        }
        line = line.trim();
        try {
            line = fixUnSupportedJsonCharacters(line);
            var contributorData = JSON.parse(line);
            if(!emailToIndexMap.hasOwnProperty(contributorData.contributorEmail)) {
                contributors.push(contributorData);
                emailToIndexMap[contributorData.contributorEmail] = contributorIndex++;
            }
        }
        catch (err) {
            logJsonParsError(logger, line, "contributor", err);
        }
    })
    var contributorsLog ={
        contributors : contributors,
        emailToIndexMap : emailToIndexMap
    }
    return contributorsLog;
}

function handleCommitsPerFileOutput(stdout, commitToIndexMap, log) {
    var fileToCommitMap = {}
    var commits = stdout.toString().split('hash:');
    try {
        commits.forEach(function (currCommit) {
            currCommit = currCommit.trim();
            var commitData = currCommit.split('\n');
            if(commitData.length < 2){
                return
            }
            var commitHash = commitData[0];
            for(var i=1;i<commitData.length;i++){
                if(fileToCommitMap[commitData[i]]){
                    fileToCommitMap[commitData[i]].push(commitToIndexMap[commitHash])
                }else{
                    fileToCommitMap[commitData[i]] =[commitToIndexMap[commitHash]]
                }
            }
        })
    }
    catch (e) {
        log.error("File to commit map error: " + e);
    }
    return fileToCommitMap;
}

function handleChildProcessError(error, stderr, log){
    globalErrorHandler.setLastError(error, 'GIT log error: ');
    log.error('GIT log error: ' + error);
    log.error('stderr: ' + stderr);
}

function getHistoryLength(cfg, log) {
    var historyLength = 100;
    if (cfg.branchHistoryLength) {
        var v = parseInt(cfg.branchHistoryLength);
        if (v < 1 || Number.isNaN(v)) {
            log.error("An invalid value was specified for branchHistoryLength in sealights.json: " + cfg.branchHistoryLength + ". Valid values are positive integers. Defaulting to " + historyLength);

        }
        else {
            historyLength = v;
        }

    }
    return historyLength;

}

function fixUnSupportedJsonCharacters(entry){
    // Backslashes ar not supported by json format so we replace it to double slashes.
    // For more info please see 'http://json.org/' (the string schema).
    return entry.replace(/\\/g, "\\\\");
}

module.exports = Git;