micro-build-server/BuildServer/lib/git/copy.js

"use strict";

const EventEmitter = require('events').EventEmitter;
const path = require('path');
const fs = require('fs');
const async = require('async');
const Copier = require('recursive-tree-copy').Copier;

const gitToFsCopier = new Copier({
    concurrency: 4,
    walkSourceTree: (tree) => {
        const emitter = new EventEmitter();
        process.nextTick(() => {
            let entries;
            try {
                entries = tree.gitTree.entries();
            } catch(err) {
                return emitter.emit('error', err);
            }

            async.parallel(entries.map((entry) => (callback) => {
                if (entry.isTree()) {
                    entry.getTree((err, subTree) => {
                        if (err) {
                            return callback(err);
                        }

                        emitter.emit('tree', { gitTree: subTree, name: entry.name() });
                        callback();
                    });
                } else if (entry.isFile()) {
                    emitter.emit('leaf', entry);
                    callback();
                } else {
                    callback();
                }
            }), (err) => {
                if (err) {
                    return emitter.emit('error', err);
                }

                return emitter.emit('done');
            });
        });
        return emitter;
    },
    createTargetTree: (tree, targetDir, callback) => {
        const targetSubdir = path.join(targetDir, tree.name);
        fs.mkdir(targetSubdir, (err) => {
            if (err && err.code !== 'EEXIST' /* workaround for broken trees */) {
                return callback(err);
            }

            callback(undefined, targetSubdir);
        });
    },
    finalizeTargetTree: (targetSubdir, callback) => callback(),
    copyLeaf: (entry, targetDir, callback) => {
        const targetPath = path.join(targetDir, entry.name());
        entry.getBlob((err, blob) => {
            if (err) {
                return callback(err);
            }

            fs.writeFile(targetPath, blob.content(), callback);
        });
    }
});

exports.gitToFs = (commit, exportDir, callback) => commit.getTree((err, tree) => {
    if (err) {
        return callback(err);
    }

    gitToFsCopier.copy({ gitTree: tree, name: "." }, exportDir, callback);
});