fixing unit test where only even lines where being processed

[python-delta-tar] / backup.py

import argparse
import binascii
import json
import logging
import os
import re
import random
import shutil
from datetime import datetime
from functools import partial

from deltatar.deltatar import DeltaTar, NO_MATCH, MATCH, PARENT_MATCH
from deltatar.tarfile import TarFile, GNU_FORMAT

MODE = ''
PASSWORD = ''

consoleLogger = logging.StreamHandler()
consoleLogger.setLevel(logging.DEBUG)

def launch_memory_usage_server(port = 8080):
    import cherrypy
    import dowser

    cherrypy.tree.mount(dowser.Root())
    cherrypy.config.update({
        'environment': 'embedded',
        'server.socket_port': port
    })

    cherrypy.engine.start()


def check_equal_dirs(path1, path2, deltatar):
    '''
    compare the two directories source_dir and target_dir and check
    # they are the same
    '''
    nbars1 = len(path1.split('/'))
    nbars2 = len(path2.split('/'))

    source_it = deltatar._recursive_walk_dir(path1)
    source_it = deltatar.jsonize_path_iterator(source_it, strip=nbars1)
    target_it = deltatar._recursive_walk_dir(path2)
    target_it = deltatar.jsonize_path_iterator(target_it, strip=nbars2)
    while True:
        try:
            sitem = source_it.next()
            titem = target_it.next()
        except StopIteration:
            try:
                titem = target_it.next()
                raise Exception("iterators do not stop at the same time")
            except StopIteration:
                break
        try:
            assert deltatar._equal_stat_dicts(sitem, titem)
        except Exception, e:
            print sitem
            print titem
            print "FAIL"
            raise

if __name__ == "__main__":
    #launch_memory_usage_server()
    parser = argparse.ArgumentParser()

    parser.add_argument("-m", "--mode", default='',
                        help="Mode in which to read/write the backup")
    parser.add_argument("-t", "--targetpath", help="target path directory")
    parser.add_argument("-s", "--sourcepath", help="source path directory")
    parser.add_argument("-p", "--password", default='', help="password")
    parser.add_argument("-v", "--volsize", default=None, help="maximum volume size, in Megabytes")
    parser.add_argument("-r", "--restore", action='store_true', help="Restore a backup")
    parser.add_argument("-f", "--full", action='store_true', help="Create a full backup")
    parser.add_argument("-d", "--diff", action='store_true', help="Create a diff backup")
    parser.add_argument("-i", "--indexes", nargs='+', help="indexes paths")
    parser.add_argument("-l", "--list-files", action='store_true', help="List files in a tarball")
    parser.add_argument("-x", "--excluded", nargs='+', default=[],
                        help="excluded files")
    parser.add_argument("-xp", "--excluded-path", default=None,
                        help="path to the file containing excluded paths")
    parser.add_argument("-e", "--equals", action='store_true', help="Checks two dirs are equal")

    args = parser.parse_args()

    if args.excluded_path:
        f = open(args.excluded_path, 'r')
        excluded_files = f.readlines()
        f.close()
    else:
        excluded_files = args.excluded

    deltatar = DeltaTar(mode=args.mode, password=args.password,
        logger=consoleLogger, excluded_files=excluded_files)

    if args.full:
        deltatar.create_full_backup(args.sourcepath, args.targetpath, args.volsize)
    elif args.diff:
        deltatar.create_diff_backup(args.sourcepath, args.targetpath, args.indexes[0], args.volsize)
    elif args.list_files:
        deltatar.list_backup(args.sourcepath)
    elif args.restore:
        if args.indexes is not None:
            deltatar.restore_backup(args.targetpath, backup_indexes_paths=args.indexes)
        else:
            deltatar.restore_backup(args.targetpath, backup_tar_path=args.sourcepath)
    elif args.equals:
        check_equal_dirs(os.path.abspath(args.sourcepath), os.path.abspath(args.targetpath), deltatar)