Example #1
0
var execute_global = function(options) {
    var action = options.action;
    var config = cfg.system(cfg.global);

    switch (action) {
    case 'register':
        if (!options.data)
            error.raise({ action : action, msg : "Needs data" });

        var data = parse_kv_pairs(options.data)
        if (options.unit !== undefined)
            data.name = options.unit;
        config.set(data);
        break;
    case 'unregister':
        if (!options.unit)
            error.raise({ action : action, msg : "Needs unit name" });

        config.rm(options.unit);
        break;
    default:
        error.raise({ msg : "Unknown action", action : action});
        break;
    }
};
Example #2
0
        var exec_script = function(action) {
            debug.info('SCRIPT>>>', config.script, 'action', action);
            if (!os.path.isexec(config.script))
                error.raise({msg : "Should be executable"
                            , script : config.script});
            var args = ['--action', action,
                        '--dir', data_dir.absolute,
                        '--bin-dir', blobs_dir.absolute,
                        '--home-dir', home ];
            var ps = subprocess.system(config.script, args);
            var trace_res = debug.info;
            if (ps.rc())
                trace_res = debug.error;

            trace_res("RC", ps.rc());
            trace_res("STDOUT", ps.stdout().toString());
            trace_res("<<STDOUT");
            trace_res("STDERR", ps.stderr().toString());
            trace_res("<<STDERR");
            trace_res('<<<SCRIPT', config.script, 'action', action, "is done");
            if (ps.rc()) {
                var msg = "Backup script " + config.script
                    + " exited with rc=" + ps.rc();
                error.raise({msg: msg, stdout: ps.stdout().toString()
                             , stderr: ps.stderr().toString()});
            }
        };
Example #3
0
        var backup_unit = function() {
            var status, i;

            // cleanup directories for data and blobs in
            // the repository
            os.rmtree(data_dir.absolute);
            os.rmtree(blobs_dir.absolute);
            mkdir(root_dir.absolute);
            mkdir(data_dir.absolute);
            mkdir(blobs_dir.absolute);

            exec_script('export');

            // save blobs
            util.forEach(vcs.status(blobs_dir.relative), function(status) {
                var git_path = status.src;
                if (status.index === ' ' && status.tree === 'D')
                    return vcs.rm(git_path);

                // service files are not blobs
                var fname = os.path.fileName(git_path);
                var service_prefix = cfg.prefix, len = service_prefix.length;
                if (fname.length >= len && fname.substr(0, len) == service_prefix)
                    return vcs.add(git_path);

                return blob(git_path).add();
            });

            // commit data
            status = vcs.status(root_dir.relative);
            if (!status.length) {
                debug.info("Nothing to backup for " + name);
                return;
            }

            // add all only in data dir to avoid blobs to get into git
            // objects storage
            vcs.add(data_dir.relative, ['-A']);
            status = vcs.status(root_dir.relative);
            if (stat.is_tree_dirty(status))
                error.raise({msg : "Dirty tree",
                             dir : root_dir,
                             status : status_dump(status) });

            vcs.commit(">" + name);

            status = vcs.status(root_dir.relative);
            if (stat.is_dirty(status))
                error.raise({msg : "Not fully commited",
                             dir : root_dir,
                             status : status_dump(status)});

        };
Example #4
0
        var create_repo = function() {
            if (vcs.init())
                error.raise({
                    msg : "Can't init git",
                    path : path,
                    stderr : vcs.stderr()});

            if (!os.path.exists(storage))
                error.raise({
                    msg : "Can't find .git",
                    path : path,
                    stderr : vcs.stderr()});
        };
Example #5
0
var execute = function(options) {
    if (options.global)
        return execute_global(options);

    if(!options.vault)
        error.raise({msg : "Missing option", name : "vault"});

    var vault = mk_vault(options.vault);
    var action = options.action;
    var res, units = options.unit ? [options.unit] : undefined;

    switch (action) {
    case 'init':
        res = vault.init(parse_kv_pairs(options.git_config));
        break;
    case 'export':
    case 'backup':
        res = vault.backup(options.home,
                           {units : units,
                            message : options.message},
                           results);
        break;
    case 'import':
    case 'restore':
        if (!options.tag)
            error.raise({msg : "tag should be provided to restore"});
        vault.snapshots.activate(options.tag);
        res = vault.restore(options.home,
                            {units : units},
                            results);
        break;
    case 'list-snapshots':
        res = vault.snapshots.list();
        print(res.join('\n'));
        break;
    case 'register':
        if (!options.data)
            error.raise({ action : action, msg : "Needs data" });
        vault.register(parse_kv_pairs(options.data));
        break;
    case 'unregister':
        if (!options.unit)
            error.raise({ action : action, msg : "Needs unit name" });
        res = vault.unregister(options.unit);
        break;
    default:
        error.raise({ msg : "Unknown action", action : action});
        break;
    }
    return res;
};
Example #6
0
var parse_next_status = function(stream) {
    var s = stream.next();
    if (s.length < 4 && s[2] != " ")
        error.raise({
            msg : "Unexpected status format, need 'XX ...'",
            got : s });
    var item = Object.create(status_item);
    item.init(s);
    if (item.isRename()) {
        if (stream.end())
            error.raise({ msg : "No dst after rename op", format : s });
        item.dst = item.src;
        item.src = stream.next();
    }
    return item;
};
Example #7
0
    var backup = function(home, options, on_progress) {
        if (options)
            debug.debug(util.dump("Backup", options));

        if (!os.path.isDir(home))
            error.raise({msg: "Home is not a dir", path: home });

        if (typeof(on_progress) !== 'function')
            on_progress = function(status) {
                debug.debug(util.dump("Progress", status));
            };

        options = options || {};

        var res = { succeeded :[], failed : [] };
        var config = vault_config();
        var start_time_tag = sys.date().toGitTag();
        var name, message;

        var backup_unit = function(name) {
            var head_before = vcs.rev_parse('HEAD');
            var unit = mk_unit(config.units()[name], home);

            try {
                on_progress({ unit: name, status: "begin" });
                unit.backup();
                on_progress({ unit: name, status: "ok" });
                res.succeeded.push(name);
            } catch (err) {
                err.unit = name;
                debug.error("Can't backup " + name + util.dump("Reason:", err));
                on_progress({ unit: name, status: err.reason || "fail" });
                res.failed.push(name);
                unit.reset(head_before);
            }
        };

        reset();
        vcs.checkout('master', ['-f']);

        if (options.units) {
            options.units.each(backup_unit);
        } else {
            config.units().each(function(name, value) {
                return backup_unit(name);
            });
        }

        message = (options.message
                   ? [start_time_tag, options.message].join('\n')
                   : start_time_tag);
        os.write_file(files.message, message);
        vcs.add(".message");
        vcs.commit([start_time_tag, message].join('\n'));

        snapshots.tag(start_time_tag);
        vcs.notes.add(options.message || "");
        return res;
    };
Example #8
0
    var init = function(config) {
        var create_repo = function() {
            if (vcs.init())
                error.raise({
                    msg : "Can't init git",
                    path : path,
                    stderr : vcs.stderr()});

            if (!os.path.exists(storage))
                error.raise({
                    msg : "Can't find .git",
                    path : path,
                    stderr : vcs.stderr()});
        };

        var setup_git_config = function(config) {
            config["status.showUntrackedFiles"] = "all";
            vcs.config.set(config);
        };

        var init_versions = function() {
            init_version("tree");
            vcs.add(files.version.tree);
            vcs.commit('anchor');
            vcs.tag(['anchor']);

            os.path.isdir(blob_storage) || os.mkdir(blob_storage);
            init_version("repository");
        };

        var exclude_service_files = function() {
            var exclude = vcs.get_local().exclude;
            exclude.add(".vault.*");
            exclude.commit();
            set_state("new");
        };

        if (!os.mkdir(path))
            error.raise({
                msg : "Can't init vault",
                path : path,
                reason : "directory already exists" });

        try {
            create_repo();
            setup_git_config(config);
            exclude_service_files();
            init_versions();
        } catch (err) {
            os.rmtree(path);
            throw err;
        }
    };
Example #9
0
    var restore = function(home, options, on_progress) {
        if (options)
            debug.debug(util.dump("Restore", options));
        if (!os.path.isDir(home))
            error.raise({msg: "Home is not a dir", path: home });

        if (typeof(on_progress) !== 'function')
            on_progress = function(status) {
                debug.debug(util.dump("Progress", status));
            };

        options = options || {};

        var config = vault_config();
        var res = { succeeded :[], failed : [] };
        var name;

        var restore_unit = function(name) {
            var unit = mk_unit(config.units()[name], home);
            try {
                on_progress({ unit: name, status: "begin" });
                unit.restore();
                on_progress({ unit: name, status: "ok" });
                res.succeeded.push(name);
            } catch (err) {
                err.unit = name;
                debug.error("Can't restore " + name + util.dump("Reason:", err));
                on_progress({ unit: name, status: err.reason || "fail" });
                res.failed.push(name);
            }
        };

        if (options.units) {
            options.units.each(restore_unit);
        } else {
            config.units().each(function(name, value) {
                restore_unit(name);
            });
        }
    };
Example #10
0
        var add = function() {
            var origTime;
            os.path.isDir(blob_dir) || os.mkdir(blob_dir);

            origTime = os.path.lastModified(link_fname);

            if (os.path.isFile(blob_fname)) {
                os.unlink(link_fname);
            } else {
                os.rename(link_fname, blob_fname);
            }
            os.path.setLastModified(blob_fname, origTime);
            var target = os.path.relative(blob_fname, os.path.dirname(link_fname));
            os.symlink(target, link_fname);
            if (!(os.path.isSymLink(link_fname) && os.path.isFile(blob_fname))) {
                error.raise({
                    msg: "Blob should be symlinked",
                    link: link_fname,
                    target: target
                });
            }
            vcs.add(git_path);
        };
Example #11
0
 var checkout = function(treeish) {
     if (typeof(treeish) !== 'string')
         error.raise({msg: 'expected string as treeish', actual: treeish});
     vcs.checkout(treeish, ['-f']);
     reset(treeish);
 };
Example #12
0
 var restore_unit = function() {
     if (!os.path.isDir(root_dir.absolute))
         error.raise({reason: "absent", name: name});
     exec_script('import');
 };
Example #13
0
 set_state = function(name) {
     if (os.write_file(files.state, name) !== name.length)
         error.raise({message: "State is not written", fname: files.state});
 };