Exemple #1
0
Fichier : tvfs.py Projet : bup/bup
def test_duplicate_save_dates():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            environ['TZ'] = 'UTC'
            git.repodir = bup_dir
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            with open(data_path + '/file', 'w+') as tmpfile:
                tmpfile.write(b'canary\n')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            for i in range(11):
                ex((bup_path, 'save', '-d', '100000', '-n', 'test', data_path))
            repo = LocalRepo()
            res = vfs.resolve(repo, '/test')
            wvpasseq(2, len(res))
            name, revlist = res[-1]
            wvpasseq('test', name)
            wvpasseq(('.',
                      '1970-01-02-034640-00',
                      '1970-01-02-034640-01',
                      '1970-01-02-034640-02',
                      '1970-01-02-034640-03',
                      '1970-01-02-034640-04',
                      '1970-01-02-034640-05',
                      '1970-01-02-034640-06',
                      '1970-01-02-034640-07',
                      '1970-01-02-034640-08',
                      '1970-01-02-034640-09',
                      '1970-01-02-034640-10',
                      'latest'),
                     tuple(sorted(x[0] for x in vfs.contents(repo, revlist))))
Exemple #2
0
def test_long_index():
    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = bup_exe
        os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
        git.init_repo(bupdir)
        w = git.PackWriter()
        obj_bin = struct.pack('!IIIII',
                0x00112233, 0x44556677, 0x88990011, 0x22334455, 0x66778899)
        obj2_bin = struct.pack('!IIIII',
                0x11223344, 0x55667788, 0x99001122, 0x33445566, 0x77889900)
        obj3_bin = struct.pack('!IIIII',
                0x22334455, 0x66778899, 0x00112233, 0x44556677, 0x88990011)
        pack_bin = struct.pack('!IIIII',
                0x99887766, 0x55443322, 0x11009988, 0x77665544, 0x33221100)
        idx = list(list() for i in xrange(256))
        idx[0].append((obj_bin, 1, 0xfffffffff))
        idx[0x11].append((obj2_bin, 2, 0xffffffffff))
        idx[0x22].append((obj3_bin, 3, 0xff))
        w.count = 3
        name = tmpdir + '/tmp.idx'
        r = w._write_pack_idx_v2(name, idx, pack_bin)
        i = git.PackIdxV2(name, open(name, 'rb'))
        WVPASSEQ(i.find_offset(obj_bin), 0xfffffffff)
        WVPASSEQ(i.find_offset(obj2_bin), 0xffffffffff)
        WVPASSEQ(i.find_offset(obj3_bin), 0xff)
Exemple #3
0
def test_check_repo_or_die():
    with no_lingering_errors():
        with test_tempdir(b'bup-tgit-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir + b'/bup'
            orig_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                git.init_repo(bupdir)
                git.check_repo_or_die()
                # if we reach this point the call above passed
                WVPASS('check_repo_or_die')

                os.rename(bupdir + b'/objects/pack',
                          bupdir + b'/objects/pack.tmp')
                open(bupdir + b'/objects/pack', 'w').close()
                try:
                    git.check_repo_or_die()
                except SystemExit as e:
                    WVPASSEQ(e.code, 14)
                else:
                    WVFAIL()
                os.unlink(bupdir + b'/objects/pack')
                os.rename(bupdir + b'/objects/pack.tmp',
                          bupdir + b'/objects/pack')

                try:
                    git.check_repo_or_die(b'nonexistantbup.tmp')
                except SystemExit as e:
                    WVPASSEQ(e.code, 15)
                else:
                    WVFAIL()
            finally:
                os.chdir(orig_cwd)
Exemple #4
0
def test_apply_to_path_restricted_access():
    if is_superuser() or detect_fakeroot():
        return
    if sys.platform.startswith('cygwin'):
        return # chmod 000 isn't effective.
    with no_lingering_errors():
        with test_tempdir(b'bup-tmetadata-') as tmpdir:
            parent = tmpdir + b'/foo'
            path = parent + b'/bar'
            os.mkdir(parent)
            os.mkdir(path)
            clear_errors()
            if metadata.xattr:
                try:
                    metadata.xattr.set(path, b'user.buptest', b'bup')
                except:
                    print("failed to set test xattr")
                    # ignore any failures here - maybe FS cannot do it
                    pass
            m = metadata.from_path(path, archive_path=path, save_symlinks=True)
            WVPASSEQ(m.path, path)
            os.chmod(parent, 0o000)
            m.apply_to_path(path)
            print('saved_errors:', helpers.saved_errors, file=sys.stderr)
            expected_errors = ['utime: ']
            if m.linux_attr and _linux_attr_supported(tmpdir):
                expected_errors.append('Linux chattr: ')
            if metadata.xattr and m.linux_xattr:
                expected_errors.append("xattr.set ")
            WVPASS(len(helpers.saved_errors) == len(expected_errors))
            for i in range(len(expected_errors)):
                WVPASS(str(helpers.saved_errors[i]).startswith(expected_errors[i]))
            clear_errors()
Exemple #5
0
def test_check_repo_or_die():
    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
        orig_cwd = os.getcwd()
        try:
            os.chdir(tmpdir)
            git.init_repo(bupdir)
            git.check_repo_or_die()
            WVPASS('check_repo_or_die')  # if we reach this point the call above passed

            os.rename(bupdir + '/objects/pack', bupdir + '/objects/pack.tmp')
            open(bupdir + '/objects/pack', 'w').close()
            try:
                git.check_repo_or_die()
            except SystemExit as e:
                WVPASSEQ(e.code, 14)
            else:
                WVFAIL()
            os.unlink(bupdir + '/objects/pack')
            os.rename(bupdir + '/objects/pack.tmp', bupdir + '/objects/pack')

            try:
                git.check_repo_or_die('nonexistantbup.tmp')
            except SystemExit as e:
                WVPASSEQ(e.code, 15)
            else:
                WVFAIL()
        finally:
            os.chdir(orig_cwd)
Exemple #6
0
def test_duplicate_save_dates():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            environ['TZ'] = 'UTC'
            git.repodir = bup_dir
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            with open(data_path + '/file', 'w+') as tmpfile:
                tmpfile.write(b'canary\n')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            for i in range(11):
                ex((bup_path, 'save', '-d', '100000', '-n', 'test', data_path))
            repo = LocalRepo()
            res = vfs.resolve(repo, '/test')
            wvpasseq(2, len(res))
            name, revlist = res[-1]
            wvpasseq('test', name)
            wvpasseq(('.', '1970-01-02-034640-00', '1970-01-02-034640-01',
                      '1970-01-02-034640-02', '1970-01-02-034640-03',
                      '1970-01-02-034640-04', '1970-01-02-034640-05',
                      '1970-01-02-034640-06', '1970-01-02-034640-07',
                      '1970-01-02-034640-08', '1970-01-02-034640-09',
                      '1970-01-02-034640-10', 'latest'),
                     tuple(sorted(x[0] for x in vfs.contents(repo, revlist))))
Exemple #7
0
def test_metadata_method():
    with no_lingering_errors(), test_tempdir('bup-tmetadata-') as tmpdir:
        bup_dir = tmpdir + '/bup'
        data_path = tmpdir + '/foo'
        os.mkdir(data_path)
        ex('touch', data_path + '/file')
        ex('ln', '-s', 'file', data_path + '/symlink')
        test_time1 = 13 * 1000000000
        test_time2 = 42 * 1000000000
        utime(data_path + '/file', (0, test_time1))
        lutime(data_path + '/symlink', (0, 0))
        utime(data_path, (0, test_time2))
        ex(bup_path, '-d', bup_dir, 'init')
        ex(bup_path, '-d', bup_dir, 'index', '-v', data_path)
        ex(bup_path, '-d', bup_dir, 'save', '-tvvn', 'test', data_path)
        git.check_repo_or_die(bup_dir)
        top = vfs.RefList(None)
        n = top.lresolve('/test/latest' + resolve_parent(data_path))
        m = n.metadata()
        WVPASS(m.mtime == test_time2)
        WVPASS(len(n.subs()) == 2)
        WVPASS(n.name == 'foo')
        WVPASS(set([x.name for x in n.subs()]) == set(['file', 'symlink']))
        for sub in n:
            if sub.name == 'file':
                m = sub.metadata()
                WVPASS(m.mtime == test_time1)
            elif sub.name == 'symlink':
                m = sub.metadata()
                WVPASS(m.mtime == 0)
Exemple #8
0
def test_contents_with_mismatched_bupm_git_ordering():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            os.mkdir(data_path + '/foo')
            with open(data_path + '/foo.', 'w+') as tmpfile:
                tmpfile.write(b'canary\n')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            ex((bup_path, 'save', '-tvvn', 'test', '--strip', data_path))
            repo = LocalRepo()
            tip_sref = exo(('git', 'show-ref', 'refs/heads/test'))[0]
            tip_oidx = tip_sref.strip().split()[0]
            tip_tree_oidx = exo(
                ('git', 'log', '--pretty=%T', '-n1', tip_oidx))[0].strip()
            tip_tree_oid = tip_tree_oidx.decode('hex')
            tip_tree = tree_dict(repo, tip_tree_oid)

            name, item = vfs.resolve(repo, '/test/latest')[2]
            wvpasseq('latest', name)
            expected = frozenset(
                (x.name, vfs.Item(oid=x.oid, meta=x.meta))
                for x in (tip_tree[name] for name in ('.', 'foo', 'foo.')))
            contents = tuple(vfs.contents(repo, item))
            wvpasseq(expected, frozenset(contents))
            # Spot check, in case tree_dict shares too much code with the vfs
            name, item = next(((n, i) for n, i in contents if n == 'foo'))
            wvpass(S_ISDIR(item.meta))
            name, item = next(((n, i) for n, i in contents if n == 'foo.'))
            wvpass(S_ISREG(item.meta.mode))
Exemple #9
0
def test_new_commit():
    with no_lingering_errors():
        with test_tempdir(b'bup-tgit-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir + b'/bup'
            git.init_repo(bupdir)
            git.verbose = 1

            w = git.PackWriter()
            tree = os.urandom(20)
            parent = os.urandom(20)
            author_name = b'Author'
            author_mail = b'author@somewhere'
            adate_sec = 1439657836
            cdate_sec = adate_sec + 1
            committer_name = b'Committer'
            committer_mail = b'committer@somewhere'
            adate_tz_sec = cdate_tz_sec = None
            commit = w.new_commit(tree, parent,
                                  b'%s <%s>' % (author_name, author_mail),
                                  adate_sec, adate_tz_sec,
                                  b'%s <%s>' % (committer_name, committer_mail),
                                  cdate_sec, cdate_tz_sec,
                                  b'There is a small mailbox here')
            adate_tz_sec = -60 * 60
            cdate_tz_sec = 120 * 60
            commit_off = w.new_commit(tree, parent,
                                      b'%s <%s>' % (author_name, author_mail),
                                      adate_sec, adate_tz_sec,
                                      b'%s <%s>' % (committer_name, committer_mail),
                                      cdate_sec, cdate_tz_sec,
                                      b'There is a small mailbox here')
            w.close()

            commit_items = git.get_commit_items(hexlify(commit), git.cp())
            local_author_offset = localtime(adate_sec).tm_gmtoff
            local_committer_offset = localtime(cdate_sec).tm_gmtoff
            WVPASSEQ(tree, unhexlify(commit_items.tree))
            WVPASSEQ(1, len(commit_items.parents))
            WVPASSEQ(parent, unhexlify(commit_items.parents[0]))
            WVPASSEQ(author_name, commit_items.author_name)
            WVPASSEQ(author_mail, commit_items.author_mail)
            WVPASSEQ(adate_sec, commit_items.author_sec)
            WVPASSEQ(local_author_offset, commit_items.author_offset)
            WVPASSEQ(committer_name, commit_items.committer_name)
            WVPASSEQ(committer_mail, commit_items.committer_mail)
            WVPASSEQ(cdate_sec, commit_items.committer_sec)
            WVPASSEQ(local_committer_offset, commit_items.committer_offset)

            commit_items = git.get_commit_items(hexlify(commit_off), git.cp())
            WVPASSEQ(tree, unhexlify(commit_items.tree))
            WVPASSEQ(1, len(commit_items.parents))
            WVPASSEQ(parent, unhexlify(commit_items.parents[0]))
            WVPASSEQ(author_name, commit_items.author_name)
            WVPASSEQ(author_mail, commit_items.author_mail)
            WVPASSEQ(adate_sec, commit_items.author_sec)
            WVPASSEQ(adate_tz_sec, commit_items.author_offset)
            WVPASSEQ(committer_name, commit_items.committer_name)
            WVPASSEQ(committer_mail, commit_items.committer_mail)
            WVPASSEQ(cdate_sec, commit_items.committer_sec)
            WVPASSEQ(cdate_tz_sec, commit_items.committer_offset)
Exemple #10
0
def test_multiple_suggestions():
    with no_lingering_errors():
        with test_tempdir(b'bup-tclient-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir
            git.init_repo(bupdir)

            lw = git.PackWriter()
            lw.new_blob(s1)
            lw.close()
            lw = git.PackWriter()
            lw.new_blob(s2)
            lw.close()
            WVPASSEQ(len(glob.glob(git.repo(b'objects/pack' + IDX_PAT))), 2)

            c = client.Client(bupdir, create=True)
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 0)
            rw = c.new_packwriter()
            s1sha = rw.new_blob(s1)
            WVPASS(rw.exists(s1sha))
            s2sha = rw.new_blob(s2)
            # This is a little hacky, but ensures that we test the
            # code under test
            while (len(glob.glob(c.cachedir + IDX_PAT)) < 2
                   and not c.conn.has_input()):
                pass
            rw.new_blob(s2)
            WVPASS(rw.objcache.exists(s1sha))
            WVPASS(rw.objcache.exists(s2sha))
            rw.new_blob(s3)
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 2)
            rw.close()
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 3)
Exemple #11
0
def test_restore_over_existing_target():
    with no_lingering_errors(), test_tempdir('bup-tmetadata-') as tmpdir:
        path = tmpdir + '/foo'
        os.mkdir(path)
        dir_m = metadata.from_path(path, archive_path=path, save_symlinks=True)
        os.rmdir(path)
        open(path, 'w').close()
        file_m = metadata.from_path(path, archive_path=path, save_symlinks=True)
        # Restore dir over file.
        WVPASSEQ(dir_m.create_path(path, create_symlinks=True), None)
        WVPASS(stat.S_ISDIR(os.stat(path).st_mode))
        # Restore dir over dir.
        WVPASSEQ(dir_m.create_path(path, create_symlinks=True), None)
        WVPASS(stat.S_ISDIR(os.stat(path).st_mode))
        # Restore file over dir.
        WVPASSEQ(file_m.create_path(path, create_symlinks=True), None)
        WVPASS(stat.S_ISREG(os.stat(path).st_mode))
        # Restore file over file.
        WVPASSEQ(file_m.create_path(path, create_symlinks=True), None)
        WVPASS(stat.S_ISREG(os.stat(path).st_mode))
        # Restore file over non-empty dir.
        os.remove(path)
        os.mkdir(path)
        open(path + '/bar', 'w').close()
        WVEXCEPT(Exception, file_m.create_path, path, create_symlinks=True)
        # Restore dir over non-empty dir.
        os.remove(path + '/bar')
        os.mkdir(path + '/bar')
        WVEXCEPT(Exception, dir_m.create_path, path, create_symlinks=True)
Exemple #12
0
def test_apply_to_path_restricted_access():
    if is_superuser() or detect_fakeroot():
        return
    if sys.platform.startswith('cygwin'):
        return # chmod 000 isn't effective.
    with no_lingering_errors(), test_tempdir('bup-tmetadata-') as tmpdir:
        parent = tmpdir + '/foo'
        path = parent + '/bar'
        os.mkdir(parent)
        os.mkdir(path)
        clear_errors()
        m = metadata.from_path(path, archive_path=path, save_symlinks=True)
        WVPASSEQ(m.path, path)
        os.chmod(parent, 000)
        m.apply_to_path(path)
        print >> sys.stderr, 'saved_errors:', helpers.saved_errors
        expected_errors = ['utime: ']
        if m.linux_attr and _linux_attr_supported(tmpdir):
            expected_errors.append('Linux chattr: ')
        if metadata.xattr and m.linux_xattr:
            expected_errors.append("xattr.set '")
        WVPASS(len(helpers.saved_errors) == len(expected_errors))
        for i in xrange(len(expected_errors)):
            WVPASS(str(helpers.saved_errors[i]).startswith(expected_errors[i]))
        clear_errors()
Exemple #13
0
def test_resolve_loop():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-resloop-') as tmpdir:
            resolve = vfs.resolve
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            repo = LocalRepo()
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            symlink('loop', data_path + '/loop')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            save_utc = 100000
            ex((bup_path, 'save', '-d', str(save_utc), '-tvvn', 'test',
                '--strip', data_path))
            save_name = strftime('%Y-%m-%d-%H%M%S', localtime(save_utc))
            try:
                wvpasseq('this call should never return',
                         resolve(repo, '/test/%s/loop' % save_name))
            except vfs.IOError as res_ex:
                wvpasseq(ELOOP, res_ex.errno)
                wvpasseq(['', 'test', save_name, 'loop'],
                         [name for name, item in res_ex.terminus])
Exemple #14
0
def test_multiple_suggestions():
    with no_lingering_errors():
        with test_tempdir('bup-tclient-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = '../../../bup'
            os.environ['BUP_DIR'] = bupdir = tmpdir
            git.init_repo(bupdir)

            lw = git.PackWriter()
            lw.new_blob(s1)
            lw.close()
            lw = git.PackWriter()
            lw.new_blob(s2)
            lw.close()
            WVPASSEQ(len(glob.glob(git.repo('objects/pack'+IDX_PAT))), 2)

            c = client.Client(bupdir, create=True)
            WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 0)
            rw = c.new_packwriter()
            s1sha = rw.new_blob(s1)
            WVPASS(rw.exists(s1sha))
            s2sha = rw.new_blob(s2)
            # This is a little hacky, but ensures that we test the
            # code under test
            while (len(glob.glob(c.cachedir+IDX_PAT)) < 2 and
                   not c.conn.has_input()):
                pass
            rw.new_blob(s2)
            WVPASS(rw.objcache.exists(s1sha))
            WVPASS(rw.objcache.exists(s2sha))
            rw.new_blob(s3)
            WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 2)
            rw.close()
            WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 3)
Exemple #15
0
def test_long_index():
    with no_lingering_errors():
        with test_tempdir('bup-tgit-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bup_exe
            os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
            git.init_repo(bupdir)
            w = git.PackWriter()
            obj_bin = struct.pack('!IIIII', 0x00112233, 0x44556677, 0x88990011,
                                  0x22334455, 0x66778899)
            obj2_bin = struct.pack('!IIIII', 0x11223344, 0x55667788,
                                   0x99001122, 0x33445566, 0x77889900)
            obj3_bin = struct.pack('!IIIII', 0x22334455, 0x66778899,
                                   0x00112233, 0x44556677, 0x88990011)
            pack_bin = struct.pack('!IIIII', 0x99887766, 0x55443322,
                                   0x11009988, 0x77665544, 0x33221100)
            idx = list(list() for i in xrange(256))
            idx[0].append((obj_bin, 1, 0xfffffffff))
            idx[0x11].append((obj2_bin, 2, 0xffffffffff))
            idx[0x22].append((obj3_bin, 3, 0xff))
            w.count = 3
            name = tmpdir + '/tmp.idx'
            r = w._write_pack_idx_v2(name, idx, pack_bin)
            i = git.PackIdxV2(name, open(name, 'rb'))
            WVPASSEQ(i.find_offset(obj_bin), 0xfffffffff)
            WVPASSEQ(i.find_offset(obj2_bin), 0xffffffffff)
            WVPASSEQ(i.find_offset(obj3_bin), 0xff)
Exemple #16
0
def test_new_commit():
    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = bup_exe
        os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
        git.init_repo(bupdir)
        git.verbose = 1

        w = git.PackWriter()
        tree = os.urandom(20)
        parent = os.urandom(20)
        author_name = 'Author'
        author_mail = 'author@somewhere'
        adate_sec = 1439657836
        cdate_sec = adate_sec + 1
        committer_name = 'Committer'
        committer_mail = 'committer@somewhere'
        adate_tz_sec = cdate_tz_sec = None
        commit = w.new_commit(tree, parent,
                              '%s <%s>' % (author_name, author_mail),
                              adate_sec, adate_tz_sec,
                              '%s <%s>' % (committer_name, committer_mail),
                              cdate_sec, cdate_tz_sec,
                              'There is a small mailbox here')
        adate_tz_sec = -60 * 60
        cdate_tz_sec = 120 * 60
        commit_off = w.new_commit(tree, parent,
                                  '%s <%s>' % (author_name, author_mail),
                                  adate_sec, adate_tz_sec,
                                  '%s <%s>' % (committer_name, committer_mail),
                                  cdate_sec, cdate_tz_sec,
                                  'There is a small mailbox here')
        w.close()

        commit_items = git.get_commit_items(commit.encode('hex'), git.cp())
        local_author_offset = localtime(adate_sec).tm_gmtoff
        local_committer_offset = localtime(cdate_sec).tm_gmtoff
        WVPASSEQ(tree, commit_items.tree.decode('hex'))
        WVPASSEQ(1, len(commit_items.parents))
        WVPASSEQ(parent, commit_items.parents[0].decode('hex'))
        WVPASSEQ(author_name, commit_items.author_name)
        WVPASSEQ(author_mail, commit_items.author_mail)
        WVPASSEQ(adate_sec, commit_items.author_sec)
        WVPASSEQ(local_author_offset, commit_items.author_offset)
        WVPASSEQ(committer_name, commit_items.committer_name)
        WVPASSEQ(committer_mail, commit_items.committer_mail)
        WVPASSEQ(cdate_sec, commit_items.committer_sec)
        WVPASSEQ(local_committer_offset, commit_items.committer_offset)

        commit_items = git.get_commit_items(commit_off.encode('hex'), git.cp())
        WVPASSEQ(tree, commit_items.tree.decode('hex'))
        WVPASSEQ(1, len(commit_items.parents))
        WVPASSEQ(parent, commit_items.parents[0].decode('hex'))
        WVPASSEQ(author_name, commit_items.author_name)
        WVPASSEQ(author_mail, commit_items.author_mail)
        WVPASSEQ(adate_sec, commit_items.author_sec)
        WVPASSEQ(adate_tz_sec, commit_items.author_offset)
        WVPASSEQ(committer_name, commit_items.committer_name)
        WVPASSEQ(committer_mail, commit_items.committer_mail)
        WVPASSEQ(cdate_sec, commit_items.committer_sec)
        WVPASSEQ(cdate_tz_sec, commit_items.committer_offset)
Exemple #17
0
def test_new_commit():
    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = bup_exe
        os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
        git.init_repo(bupdir)
        git.verbose = 1

        w = git.PackWriter()
        tree = os.urandom(20)
        parent = os.urandom(20)
        author_name = 'Author'
        author_mail = 'author@somewhere'
        adate_sec = 1439657836
        cdate_sec = adate_sec + 1
        committer_name = 'Committer'
        committer_mail = 'committer@somewhere'
        adate_tz_sec = cdate_tz_sec = None
        commit = w.new_commit(tree, parent,
                              '%s <%s>' % (author_name, author_mail),
                              adate_sec, adate_tz_sec,
                              '%s <%s>' % (committer_name, committer_mail),
                              cdate_sec, cdate_tz_sec,
                              'There is a small mailbox here')
        adate_tz_sec = -60 * 60
        cdate_tz_sec = 120 * 60
        commit_off = w.new_commit(tree, parent,
                                  '%s <%s>' % (author_name, author_mail),
                                  adate_sec, adate_tz_sec,
                                  '%s <%s>' % (committer_name, committer_mail),
                                  cdate_sec, cdate_tz_sec,
                                  'There is a small mailbox here')
        w.close()

        commit_items = git.get_commit_items(commit.encode('hex'), git.cp())
        local_author_offset = localtime(adate_sec).tm_gmtoff
        local_committer_offset = localtime(cdate_sec).tm_gmtoff
        WVPASSEQ(tree, commit_items.tree.decode('hex'))
        WVPASSEQ(1, len(commit_items.parents))
        WVPASSEQ(parent, commit_items.parents[0].decode('hex'))
        WVPASSEQ(author_name, commit_items.author_name)
        WVPASSEQ(author_mail, commit_items.author_mail)
        WVPASSEQ(adate_sec, commit_items.author_sec)
        WVPASSEQ(local_author_offset, commit_items.author_offset)
        WVPASSEQ(committer_name, commit_items.committer_name)
        WVPASSEQ(committer_mail, commit_items.committer_mail)
        WVPASSEQ(cdate_sec, commit_items.committer_sec)
        WVPASSEQ(local_committer_offset, commit_items.committer_offset)

        commit_items = git.get_commit_items(commit_off.encode('hex'), git.cp())
        WVPASSEQ(tree, commit_items.tree.decode('hex'))
        WVPASSEQ(1, len(commit_items.parents))
        WVPASSEQ(parent, commit_items.parents[0].decode('hex'))
        WVPASSEQ(author_name, commit_items.author_name)
        WVPASSEQ(author_mail, commit_items.author_mail)
        WVPASSEQ(adate_sec, commit_items.author_sec)
        WVPASSEQ(adate_tz_sec, commit_items.author_offset)
        WVPASSEQ(committer_name, commit_items.committer_name)
        WVPASSEQ(committer_mail, commit_items.committer_mail)
        WVPASSEQ(cdate_sec, commit_items.committer_sec)
        WVPASSEQ(cdate_tz_sec, commit_items.committer_offset)
Exemple #18
0
def test_misc():
    with no_lingering_errors():
        with test_tempdir(b'bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + b'/bup'
            environ[b'GIT_DIR'] = bup_dir
            environ[b'BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            data_path = tmpdir + b'/src'
            os.mkdir(data_path)
            with open(data_path + b'/file', 'wb+') as tmpfile:
                tmpfile.write(b'canary\n')
            symlink(b'file', data_path + b'/symlink')
            ex((bup_path, b'init'))
            ex((bup_path, b'index', b'-v', data_path))
            ex((bup_path, b'save', b'-d', b'100000', b'-tvvn', b'test',
                b'--strip', data_path))
            repo = LocalRepo()

            wvstart('readlink')
            ls_tree = exo((b'git', b'ls-tree', b'test', b'symlink')).out
            mode, typ, oidx, name = ls_tree.strip().split(None, 3)
            assert name == b'symlink'
            link_item = vfs.Item(oid=unhexlify(oidx), meta=int(mode, 8))
            wvpasseq(b'file', vfs.readlink(repo, link_item))

            ls_tree = exo((b'git', b'ls-tree', b'test', b'file')).out
            mode, typ, oidx, name = ls_tree.strip().split(None, 3)
            assert name == b'file'
            file_item = vfs.Item(oid=unhexlify(oidx), meta=int(mode, 8))
            wvexcept(Exception, vfs.readlink, repo, file_item)

            wvstart('item_size')
            wvpasseq(4, vfs.item_size(repo, link_item))
            wvpasseq(7, vfs.item_size(repo, file_item))
            meta = metadata.from_path(fsencode(__file__))
            meta.size = 42
            fake_item = file_item._replace(meta=meta)
            wvpasseq(42, vfs.item_size(repo, fake_item))

            _, fakelink_item = vfs.resolve(repo, b'/test/latest',
                                           follow=False)[-1]
            wvpasseq(17, vfs.item_size(repo, fakelink_item))

            wvstart('augment_item_meta')
            run_augment_item_meta_tests(repo, b'/test/latest/file', 7,
                                        b'/test/latest/symlink', b'file')

            wvstart('copy_item')
            # FIXME: this caused StopIteration
            #_, file_item = vfs.resolve(repo, '/file')[-1]
            _, file_item = vfs.resolve(repo, b'/test/latest/file')[-1]
            file_copy = vfs.copy_item(file_item)
            wvpass(file_copy is not file_item)
            wvpass(file_copy.meta is not file_item.meta)
            wvpass(isinstance(file_copy, tuple))
            wvpass(file_item.meta.user)
            wvpass(file_copy.meta.user)
            file_copy.meta.user = None
            wvpass(file_item.meta.user)
Exemple #19
0
def test_bloom():
    with no_lingering_errors():
        with test_tempdir('bup-tbloom-') as tmpdir:
            hashes = [os.urandom(20) for i in range(100)]

            class Idx:
                pass

            ix = Idx()
            ix.name = 'dummy.idx'
            ix.shatable = ''.join(hashes)
            for k in (4, 5):
                b = bloom.create(tmpdir + '/pybuptest.bloom',
                                 expected=100,
                                 k=k)
                b.add_idx(ix)
                WVPASSLT(b.pfalse_positive(), .1)
                b.close()
                b = bloom.ShaBloom(tmpdir + '/pybuptest.bloom')
                all_present = True
                for h in hashes:
                    all_present &= b.exists(h)
                WVPASS(all_present)
                false_positives = 0
                for h in [os.urandom(20) for i in range(1000)]:
                    if b.exists(h):
                        false_positives += 1
                WVPASSLT(false_positives, 5)
                os.unlink(tmpdir + '/pybuptest.bloom')

            tf = tempfile.TemporaryFile(dir=tmpdir)
            b = bloom.create('bup.bloom', f=tf, expected=100)
            WVPASSEQ(b.rwfile, tf)
            WVPASSEQ(b.k, 5)

            # Test large (~1GiB) filter.  This may fail on s390 (31-bit
            # architecture), and anywhere else where the address space is
            # sufficiently limited.
            tf = tempfile.TemporaryFile(dir=tmpdir)
            skip_test = False
            try:
                b = bloom.create('bup.bloom',
                                 f=tf,
                                 expected=2**28,
                                 delaywrite=False)
            except EnvironmentError as ex:
                (ptr_width, linkage) = platform.architecture()
                if ptr_width == '32bit' and ex.errno == errno.ENOMEM:
                    WVMSG(
                        'skipping large bloom filter test (mmap probably failed) '
                        + str(ex))
                    skip_test = True
                else:
                    raise
            if not skip_test:
                WVPASSEQ(b.k, 4)
Exemple #20
0
Fichier : tvfs.py Projet : bup/bup
def test_misc():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            with open(data_path + '/file', 'w+') as tmpfile:
                tmpfile.write(b'canary\n')
            symlink('file', data_path + '/symlink')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
                data_path))
            repo = LocalRepo()

            wvstart('readlink')
            ls_tree = exo(('git', 'ls-tree', 'test', 'symlink')).out
            mode, typ, oidx, name = ls_tree.strip().split(None, 3)
            assert name == 'symlink'
            link_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
            wvpasseq('file', vfs.readlink(repo, link_item))

            ls_tree = exo(('git', 'ls-tree', 'test', 'file')).out
            mode, typ, oidx, name = ls_tree.strip().split(None, 3)
            assert name == 'file'
            file_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
            wvexcept(Exception, vfs.readlink, repo, file_item)

            wvstart('item_size')
            wvpasseq(4, vfs.item_size(repo, link_item))
            wvpasseq(7, vfs.item_size(repo, file_item))
            meta = metadata.from_path(__file__)
            meta.size = 42
            fake_item = file_item._replace(meta=meta)
            wvpasseq(42, vfs.item_size(repo, fake_item))

            wvstart('augment_item_meta')
            run_augment_item_meta_tests(repo,
                                        '/test/latest/file', 7,
                                        '/test/latest/symlink', 'file')

            wvstart('copy_item')
            # FIXME: this caused StopIteration
            #_, file_item = vfs.resolve(repo, '/file')[-1]
            _, file_item = vfs.resolve(repo, '/test/latest/file')[-1]
            file_copy = vfs.copy_item(file_item)
            wvpass(file_copy is not file_item)
            wvpass(file_copy.meta is not file_item.meta)
            wvpass(isinstance(file_copy, tuple))
            wvpass(file_item.meta.user)
            wvpass(file_copy.meta.user)
            file_copy.meta.user = None
            wvpass(file_item.meta.user)
Exemple #21
0
def test_midx_close():
    fddir = b'/proc/self/fd'
    try:
        os.listdir(fddir)
    except Exception:
        # not supported, not Linux, I guess
        return

    def openfiles():
        for fd in os.listdir(fddir):
            try:
                yield os.readlink(os.path.join(fddir, fd))
            except OSError:
                pass

    def force_midx(objdir):
        args = [path.exe(), b'midx', b'--auto', b'--dir', objdir]
        check_call(args)

    with no_lingering_errors(), \
         test_tempdir(b'bup-tgit-') as tmpdir:
        environ[b'BUP_DIR'] = bupdir = tmpdir + b'/bup'
        git.init_repo(bupdir)
        # create a few dummy idxes
        for i in range(10):
            _create_idx(tmpdir, i)
        git.auto_midx(tmpdir)
        l = git.PackIdxList(tmpdir)
        # this doesn't exist (yet)
        WVPASSEQ(None, l.exists(struct.pack('18xBB', 10, 0)))
        for i in range(10, 15):
            _create_idx(tmpdir, i)
        # delete the midx ...
        # TODO: why do we need to? git.auto_midx() below doesn't?!
        for fn in os.listdir(tmpdir):
            if fn.endswith(b'.midx'):
                os.unlink(os.path.join(tmpdir, fn))
        # and make a new one
        git.auto_midx(tmpdir)
        # check it still doesn't exist - we haven't refreshed
        WVPASSEQ(None, l.exists(struct.pack('18xBB', 10, 0)))
        # check that we still have the midx open, this really
        # just checks more for the kernel API ('deleted' string)
        for fn in openfiles():
            if not b'midx-' in fn:
                continue
            WVPASSEQ(True, b'deleted' in fn)
        # refresh the PackIdxList
        l.refresh()
        # and check that an object in pack 10 exists now
        WVPASSEQ(True, l.exists(struct.pack('18xBB', 10, 0)))
        for fn in openfiles():
            if not b'midx-' in fn:
                continue
            # check that we don't have it open anymore
            WVPASSEQ(False, b'deleted' in fn)
Exemple #22
0
def prep_and_test_repo(name, create_repo, test_repo):
    with no_lingering_errors():
        with test_tempdir(b'bup-t' + name) as tmpdir:
            bup_dir = tmpdir + b'/bup'
            environ[b'GIT_DIR'] = bup_dir
            environ[b'BUP_DIR'] = bup_dir
            ex((bup_path, b'init'))
            git.repodir = bup_dir
            with create_repo(bup_dir) as repo:
                test_repo(repo, tmpdir)
Exemple #23
0
def prep_and_test_repo(name, create_repo, test_repo):
    with no_lingering_errors():
        with test_tempdir('bup-t' + name) as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            environ['BUP_MAIN_EXE'] = bup_path
            ex((bup_path, 'init'))
            git.repodir = bup_dir
            with create_repo(bup_dir) as repo:
                test_repo(repo, tmpdir)
Exemple #24
0
def test_list_refs():
    with no_lingering_errors():
        with test_tempdir(b'bup-tgit-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir + b'/bup'
            src = tmpdir + b'/src'
            mkdirp(src)
            with open(src + b'/1', 'wb+') as f:
                f.write(b'something\n')
            with open(src + b'/2', 'wb+') as f:
                f.write(b'something else\n')
            git.init_repo(bupdir)
            emptyset = frozenset()
            WVPASSEQ(frozenset(git.list_refs()), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)), emptyset)
            exc(bup_exe, b'index', src)
            exc(bup_exe, b'save', b'-n', b'src', b'--strip', src)
            src_hash = exo(b'git', b'--git-dir', bupdir, b'rev-parse',
                           b'src').strip().split(b'\n')
            assert (len(src_hash) == 1)
            src_hash = unhexlify(src_hash[0])
            tree_hash = unhexlify(
                exo(b'git', b'--git-dir', bupdir, b'rev-parse',
                    b'src:').strip().split(b'\n')[0])
            blob_hash = unhexlify(
                exo(b'git', b'--git-dir', bupdir, b'rev-parse',
                    b'src:1').strip().split(b'\n')[0])
            WVPASSEQ(frozenset(git.list_refs()),
                     frozenset([(b'refs/heads/src', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([(b'refs/heads/src', src_hash)]))
            exc(b'git', b'--git-dir', bupdir, b'tag', b'commit-tag', b'src')
            WVPASSEQ(
                frozenset(git.list_refs()),
                frozenset([(b'refs/heads/src', src_hash),
                           (b'refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)),
                     frozenset([(b'refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([(b'refs/heads/src', src_hash)]))
            exc(b'git', b'--git-dir', bupdir, b'tag', b'tree-tag', b'src:')
            exc(b'git', b'--git-dir', bupdir, b'tag', b'blob-tag', b'src:1')
            os.unlink(bupdir + b'/refs/heads/src')
            expected_tags = frozenset([(b'refs/tags/commit-tag', src_hash),
                                       (b'refs/tags/tree-tag', tree_hash),
                                       (b'refs/tags/blob-tag', blob_hash)])
            WVPASSEQ(frozenset(git.list_refs()), expected_tags)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)),
                     expected_tags)
Exemple #25
0
def test_list_refs():
    with no_lingering_errors():
        with test_tempdir('bup-tgit-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bup_exe
            os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
            src = tmpdir + '/src'
            mkdirp(src)
            with open(src + '/1', 'w+') as f:
                print f, 'something'
            with open(src + '/2', 'w+') as f:
                print f, 'something else'
            git.init_repo(bupdir)
            emptyset = frozenset()
            WVPASSEQ(frozenset(git.list_refs()), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)), emptyset)
            exc(bup_exe, 'index', src)
            exc(bup_exe, 'save', '-n', 'src', '--strip', src)
            src_hash = exo('git', '--git-dir', bupdir, 'rev-parse',
                           'src').strip().split('\n')
            assert (len(src_hash) == 1)
            src_hash = src_hash[0].decode('hex')
            tree_hash = exo('git', '--git-dir', bupdir, 'rev-parse',
                            'src:').strip().split('\n')[0].decode('hex')
            blob_hash = exo('git', '--git-dir', bupdir, 'rev-parse',
                            'src:1').strip().split('\n')[0].decode('hex')
            WVPASSEQ(frozenset(git.list_refs()),
                     frozenset([('refs/heads/src', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([('refs/heads/src', src_hash)]))
            exc('git', '--git-dir', bupdir, 'tag', 'commit-tag', 'src')
            WVPASSEQ(
                frozenset(git.list_refs()),
                frozenset([('refs/heads/src', src_hash),
                           ('refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)),
                     frozenset([('refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([('refs/heads/src', src_hash)]))
            exc('git', '--git-dir', bupdir, 'tag', 'tree-tag', 'src:')
            exc('git', '--git-dir', bupdir, 'tag', 'blob-tag', 'src:1')
            os.unlink(bupdir + '/refs/heads/src')
            expected_tags = frozenset([('refs/tags/commit-tag', src_hash),
                                       ('refs/tags/tree-tag', tree_hash),
                                       ('refs/tags/blob-tag', blob_hash)])
            WVPASSEQ(frozenset(git.list_refs()), expected_tags)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)),
                     expected_tags)
Exemple #26
0
def test_bloom():
    with no_lingering_errors():
        with test_tempdir('bup-tbloom-') as tmpdir:
            hashes = [os.urandom(20) for i in range(100)]
            class Idx:
                pass
            ix = Idx()
            ix.name='dummy.idx'
            ix.shatable = ''.join(hashes)
            for k in (4, 5):
                b = bloom.create(tmpdir + '/pybuptest.bloom', expected=100, k=k)
                b.add_idx(ix)
                WVPASSLT(b.pfalse_positive(), .1)
                b.close()
                b = bloom.ShaBloom(tmpdir + '/pybuptest.bloom')
                all_present = True
                for h in hashes:
                    all_present &= b.exists(h)
                WVPASS(all_present)
                false_positives = 0
                for h in [os.urandom(20) for i in range(1000)]:
                    if b.exists(h):
                        false_positives += 1
                WVPASSLT(false_positives, 5)
                os.unlink(tmpdir + '/pybuptest.bloom')

            tf = tempfile.TemporaryFile(dir=tmpdir)
            b = bloom.create('bup.bloom', f=tf, expected=100)
            WVPASSEQ(b.rwfile, tf)
            WVPASSEQ(b.k, 5)

            # Test large (~1GiB) filter.  This may fail on s390 (31-bit
            # architecture), and anywhere else where the address space is
            # sufficiently limited.
            tf = tempfile.TemporaryFile(dir=tmpdir)
            skip_test = False
            try:
                b = bloom.create('bup.bloom', f=tf, expected=2**28,
                                 delaywrite=False)
            except EnvironmentError as ex:
                (ptr_width, linkage) = platform.architecture()
                if ptr_width == '32bit' and ex.errno == errno.ENOMEM:
                    WVMSG('skipping large bloom filter test (mmap probably failed) '
                          + str(ex))
                    skip_test = True
                else:
                    raise
            if not skip_test:
                WVPASSEQ(b.k, 4)
Exemple #27
0
def test_bup_lutimes():
    if not xstat._bup_lutimes:
        return
    with no_lingering_errors(), test_tempdir('bup-txstat-') as tmpdir:
        path = tmpdir + '/foo'
        open(path, 'w').close()
        frac_ts = (0, 10**6 / 2)
        xstat._bup_lutimes(path, (frac_ts, frac_ts))
        st = _helpers.stat(path)
        atime_ts = st[8]
        mtime_ts = st[9]
        WVPASSEQ(atime_ts[0], 0)
        WVPASS(atime_ts[1] == 0 or atime_ts[1] == frac_ts[1] * 1000)
        WVPASSEQ(mtime_ts[0], 0)
        WVPASS(mtime_ts[1] == 0 or mtime_ts[1] == frac_ts[1] * 1000)
Exemple #28
0
def test_list_refs():
    with no_lingering_errors():
        with test_tempdir('bup-tgit-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bup_exe
            os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
            src = tmpdir + '/src'
            mkdirp(src)
            with open(src + '/1', 'w+') as f:
                print f, 'something'
            with open(src + '/2', 'w+') as f:
                print f, 'something else'
            git.init_repo(bupdir)
            emptyset = frozenset()
            WVPASSEQ(frozenset(git.list_refs()), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)), emptyset)
            exc(bup_exe, 'index', src)
            exc(bup_exe, 'save', '-n', 'src', '--strip', src)
            src_hash = exo('git', '--git-dir', bupdir,
                           'rev-parse', 'src').strip().split('\n')
            assert(len(src_hash) == 1)
            src_hash = src_hash[0].decode('hex')
            tree_hash = exo('git', '--git-dir', bupdir,
                           'rev-parse', 'src:').strip().split('\n')[0].decode('hex')
            blob_hash = exo('git', '--git-dir', bupdir,
                           'rev-parse', 'src:1').strip().split('\n')[0].decode('hex')
            WVPASSEQ(frozenset(git.list_refs()),
                     frozenset([('refs/heads/src', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), emptyset)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([('refs/heads/src', src_hash)]))
            exc('git', '--git-dir', bupdir, 'tag', 'commit-tag', 'src')
            WVPASSEQ(frozenset(git.list_refs()),
                     frozenset([('refs/heads/src', src_hash),
                                ('refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)),
                     frozenset([('refs/tags/commit-tag', src_hash)]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)),
                     frozenset([('refs/heads/src', src_hash)]))
            exc('git', '--git-dir', bupdir, 'tag', 'tree-tag', 'src:')
            exc('git', '--git-dir', bupdir, 'tag', 'blob-tag', 'src:1')
            os.unlink(bupdir + '/refs/heads/src')
            expected_tags = frozenset([('refs/tags/commit-tag', src_hash),
                                       ('refs/tags/tree-tag', tree_hash),
                                       ('refs/tags/blob-tag', blob_hash)])
            WVPASSEQ(frozenset(git.list_refs()), expected_tags)
            WVPASSEQ(frozenset(git.list_refs(limit_to_heads=True)), frozenset([]))
            WVPASSEQ(frozenset(git.list_refs(limit_to_tags=True)), expected_tags)
Exemple #29
0
def test_bup_utimes():
    if not xstat._bup_utimes:
        return
    with no_lingering_errors():
        with test_tempdir('bup-txstat-') as tmpdir:
            path = tmpdir + '/foo'
            open(path, 'w').close()
            frac_ts = (0, 10**6 / 2)
            xstat._bup_utimes(path, (frac_ts, frac_ts))
            st = _helpers.stat(path)
            atime_ts = st[8]
            mtime_ts = st[9]
            WVPASSEQ(atime_ts[0], 0)
            WVPASS(atime_ts[1] == 0 or atime_ts[1] == frac_ts[1] * 1000)
            WVPASSEQ(mtime_ts[0], 0)
            WVPASS(mtime_ts[1] == 0 or mtime_ts[1] == frac_ts[1] * 1000)
Exemple #30
0
def test_server_split_with_indexes():
    with no_lingering_errors():
        with test_tempdir(b'bup-tclient-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir
            git.init_repo(bupdir)
            lw = git.PackWriter()
            c = client.Client(bupdir, create=True)
            rw = c.new_packwriter()

            lw.new_blob(s1)
            lw.close()

            rw.new_blob(s2)
            rw.breakpoint()
            rw.new_blob(s1)
            rw.close()
Exemple #31
0
def create_test_config():
    with test_tempdir(b'enc') as tmpdir:
        cfgfile = os.path.join(tmpdir, b'repo.conf')
        cfg = open(cfgfile, 'wb')
        cfg.write(b'[bup]\n')
        cfg.write(b'  storage = File\n')
        cfg.write(b'  path = %s\n' % os.path.join(tmpdir, b'repo'))
        cfg.write(b'  cachedir = %s\n' % os.path.join(tmpdir, b'cache'))
        cfg.close()

        class DummyRepo(ConfigRepo):
            def finish_writing(self):
                pass

        yield tmpdir, storage.get_storage(DummyRepo(cfg_file=cfgfile),
                                          create=True)
Exemple #32
0
def test_from_path_error():
    if is_superuser() or detect_fakeroot():
        return
    with no_lingering_errors(), test_tempdir('bup-tmetadata-') as tmpdir:
        path = tmpdir + '/foo'
        os.mkdir(path)
        m = metadata.from_path(path, archive_path=path, save_symlinks=True)
        WVPASSEQ(m.path, path)
        os.chmod(path, 000)
        metadata.from_path(path, archive_path=path, save_symlinks=True)
        if metadata.get_linux_file_attr:
            print >> sys.stderr, 'saved_errors:', helpers.saved_errors
            WVPASS(len(helpers.saved_errors) == 1)
            errmsg = _first_err()
            WVPASS(errmsg.startswith('read Linux attr'))
            clear_errors()
Exemple #33
0
def test_server_split_with_indexes():
    with no_lingering_errors(), test_tempdir('bup-tclient-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = '../../../bup'
        os.environ['BUP_DIR'] = bupdir = tmpdir
        git.init_repo(bupdir)
        lw = git.PackWriter()
        c = client.Client(bupdir, create=True)
        rw = c.new_packwriter()

        lw.new_blob(s1)
        lw.close()

        rw.new_blob(s2)
        rw.breakpoint()
        rw.new_blob(s1)
        rw.close()
Exemple #34
0
def test_bup_utimensat():
    if not xstat._bup_utimensat:
        return
    with no_lingering_errors():
        with test_tempdir('bup-txstat-') as tmpdir:
            path = tmpdir + '/foo'
            open(path, 'w').close()
            frac_ts = (0, 10**9 / 2)
            xstat._bup_utimensat(_helpers.AT_FDCWD, path, (frac_ts, frac_ts), 0)
            st = _helpers.stat(path)
            atime_ts = st[8]
            mtime_ts = st[9]
            WVPASSEQ(atime_ts[0], 0)
            WVPASS(atime_ts[1] == 0 or atime_ts[1] == frac_ts[1])
            WVPASSEQ(mtime_ts[0], 0)
            WVPASS(mtime_ts[1] == 0 or mtime_ts[1] == frac_ts[1])
Exemple #35
0
def test_read_and_seek():
    # Write a set of randomly sized files containing random data whose
    # names are their sizes, and then verify that what we get back
    # from the vfs when seeking and reading with various block sizes
    # matches the original content.
    with no_lingering_errors():
        with test_tempdir(b'bup-tvfs-read-') as tmpdir:
            resolve = vfs.resolve
            bup_dir = tmpdir + b'/bup'
            environ[b'GIT_DIR'] = bup_dir
            environ[b'BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            repo = LocalRepo()
            data_path = tmpdir + b'/src'
            os.mkdir(data_path)
            seed = randint(-(1 << 31), (1 << 31) - 1)
            rand = Random()
            rand.seed(seed)
            print('test_read seed:', seed, file=sys.stderr)
            max_size = 2 * 1024 * 1024
            sizes = set((rand.randint(1, max_size) for _ in range(5)))
            sizes.add(1)
            sizes.add(max_size)
            for size in sizes:
                write_sized_random_content(data_path, size, seed)
            ex((bup_path, b'init'))
            ex((bup_path, b'index', b'-v', data_path))
            ex((bup_path, b'save', b'-d', b'100000', b'-tvvn', b'test',
                b'--strip', data_path))
            read_sizes = set((rand.randint(1, max_size) for _ in range(10)))
            sizes.add(1)
            sizes.add(max_size)
            print('test_read src sizes:', sizes, file=sys.stderr)
            print('test_read read sizes:', read_sizes, file=sys.stderr)
            for size in sizes:
                res = resolve(repo,
                              b'/test/latest/' + str(size).encode('ascii'))
                _, item = res[-1]
                wvpasseq(size, vfs.item_size(repo, res[-1][1]))
                validate_vfs_streaming_read(repo, item,
                                            b'%s/%d' % (data_path, size),
                                            read_sizes)
                validate_vfs_seeking_read(repo, item,
                                          b'%s/%d' % (data_path, size),
                                          read_sizes)
Exemple #36
0
def index_writer():
    with no_lingering_errors(), test_tempdir('bup-tindex-') as tmpdir:
        orig_cwd = os.getcwd()
        try:
            os.chdir(tmpdir)
            ds = xstat.stat('.')
            fs = xstat.stat(lib_t_dir + '/tindex.py')
            ms = index.MetaStoreWriter('index.meta.tmp');
            tmax = (time.time() - 1) * 10**9
            w = index.Writer('index.tmp', ms, tmax)
            w.add('/var/tmp/sporky', fs, 0)
            w.add('/etc/passwd', fs, 0)
            w.add('/etc/', ds, 0)
            w.add('/', ds, 0)
            ms.close()
            w.close()
        finally:
            os.chdir(orig_cwd)
Exemple #37
0
def index_writer():
    with no_lingering_errors(), test_tempdir('bup-tindex-') as tmpdir:
        orig_cwd = os.getcwd()
        try:
            os.chdir(tmpdir)
            ds = xstat.stat('.')
            fs = xstat.stat(lib_t_dir + '/tindex.py')
            ms = index.MetaStoreWriter('index.meta.tmp')
            tmax = (time.time() - 1) * 10**9
            w = index.Writer('index.tmp', ms, tmax)
            w.add('/var/tmp/sporky', fs, 0)
            w.add('/etc/passwd', fs, 0)
            w.add('/etc/', ds, 0)
            w.add('/', ds, 0)
            ms.close()
            w.close()
        finally:
            os.chdir(orig_cwd)
Exemple #38
0
def test_resolve_loop():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-resloop-') as tmpdir:
            resolve = vfs.resolve
            lresolve = vfs.lresolve
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            repo = LocalRepo()
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            symlink('loop', data_path + '/loop')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
                data_path))
            wvexcept(vfs.Loop, resolve, repo, '/test/latest/loop')
Exemple #39
0
Fichier : tvfs.py Projet : bup/bup
def test_read_and_seek():
    # Write a set of randomly sized files containing random data whose
    # names are their sizes, and then verify that what we get back
    # from the vfs when seeking and reading with various block sizes
    # matches the original content.
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-read-') as tmpdir:
            resolve = vfs.resolve
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            repo = LocalRepo()
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            seed = randint(-(1 << 31), (1 << 31) - 1)
            rand = Random()
            rand.seed(seed)
            print('test_read seed:', seed, file=sys.stderr)
            max_size = 2 * 1024 * 1024
            sizes = set((rand.randint(1, max_size) for _ in xrange(5)))
            sizes.add(1)
            sizes.add(max_size)
            for size in sizes:
                write_sized_random_content(data_path, size, seed)
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
                data_path))
            read_sizes = set((rand.randint(1, max_size) for _ in xrange(10)))
            sizes.add(1)
            sizes.add(max_size)
            print('test_read src sizes:', sizes, file=sys.stderr)
            print('test_read read sizes:', read_sizes, file=sys.stderr)
            for size in sizes:
                res = resolve(repo, '/test/latest/' + str(size))
                _, item = res[-1]
                wvpasseq(size, vfs.item_size(repo, res[-1][1]))
                validate_vfs_streaming_read(repo, item,
                                            '%s/%d' % (data_path, size),
                                            read_sizes)
                validate_vfs_seeking_read(repo, item,
                                          '%s/%d' % (data_path, size),
                                          read_sizes)
Exemple #40
0
def test_dumb_client_server():
    with no_lingering_errors():
        with test_tempdir(b'bup-tclient-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir
            git.init_repo(bupdir)
            open(git.repo(b'bup-dumb-server'), 'w').close()

            lw = git.PackWriter()
            lw.new_blob(s1)
            lw.close()

            c = client.Client(bupdir, create=True)
            rw = c.new_packwriter()
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 1)
            rw.new_blob(s1)
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 1)
            rw.new_blob(s2)
            rw.close()
            WVPASSEQ(len(glob.glob(c.cachedir + IDX_PAT)), 2)
Exemple #41
0
def test_dumb_client_server():
    with no_lingering_errors(), test_tempdir('bup-tclient-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = '../../../bup'
        os.environ['BUP_DIR'] = bupdir = tmpdir
        git.init_repo(bupdir)
        open(git.repo('bup-dumb-server'), 'w').close()

        lw = git.PackWriter()
        lw.new_blob(s1)
        lw.close()

        c = client.Client(bupdir, create=True)
        rw = c.new_packwriter()
        WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 1)
        rw.new_blob(s1)
        WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 1)
        rw.new_blob(s2)
        rw.close()
        WVPASSEQ(len(glob.glob(c.cachedir+IDX_PAT)), 2)
Exemple #42
0
def create_test_config():
    with test_tempdir(b'enc') as tmpdir:
        if repo_conf is None:
            cfgfile = os.path.join(tmpdir, b'repo.conf')
            cfg = open(cfgfile, 'wb')
            cfg.write(b'[bup]\n')
            cfg.write(b'  storage = File\n')
            cfg.write(b'  path = %s\n' % os.path.join(tmpdir, b'repo'))
            cfg.write(b'  cachedir = %s\n' % os.path.join(tmpdir, b'cache'))
            cfg.close()
            create = True
        else:
            wvstart("storage config from %s" % repo_conf)
            cfgfile = repo_conf
            create = False
        repo = DummyRepo(cfg_file=cfgfile)
        store = get_storage(repo, create=create)
        yield tmpdir, store
        del store
Exemple #43
0
def testpacks():
    with no_lingering_errors():
        with test_tempdir('bup-tgit-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bup_exe
            os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
            git.init_repo(bupdir)
            git.verbose = 1

            w = git.PackWriter()
            w.new_blob(os.urandom(100))
            w.new_blob(os.urandom(100))
            w.abort()

            w = git.PackWriter()
            hashes = []
            nobj = 1000
            for i in range(nobj):
                hashes.append(w.new_blob(str(i)))
            log('\n')
            nameprefix = w.close()
            print repr(nameprefix)
            WVPASS(os.path.exists(nameprefix + '.pack'))
            WVPASS(os.path.exists(nameprefix + '.idx'))

            r = git.open_idx(nameprefix + '.idx')
            print repr(r.fanout)

            for i in range(nobj):
                WVPASS(r.find_offset(hashes[i]) > 0)
            WVPASS(r.exists(hashes[99]))
            WVFAIL(r.exists('\0' * 20))

            pi = iter(r)
            for h in sorted(hashes):
                WVPASSEQ(str(pi.next()).encode('hex'), h.encode('hex'))

            WVFAIL(r.find_offset('\0' * 20))

            r = git.PackIdxList(bupdir + '/objects/pack')
            WVPASS(r.exists(hashes[5]))
            WVPASS(r.exists(hashes[6]))
            WVFAIL(r.exists('\0' * 20))
Exemple #44
0
def testpacks():
    with no_lingering_errors():
        with test_tempdir('bup-tgit-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bup_exe
            os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
            git.init_repo(bupdir)
            git.verbose = 1

            w = git.PackWriter()
            w.new_blob(os.urandom(100))
            w.new_blob(os.urandom(100))
            w.abort()

            w = git.PackWriter()
            hashes = []
            nobj = 1000
            for i in range(nobj):
                hashes.append(w.new_blob(str(i)))
            log('\n')
            nameprefix = w.close()
            print repr(nameprefix)
            WVPASS(os.path.exists(nameprefix + '.pack'))
            WVPASS(os.path.exists(nameprefix + '.idx'))

            r = git.open_idx(nameprefix + '.idx')
            print repr(r.fanout)

            for i in range(nobj):
                WVPASS(r.find_offset(hashes[i]) > 0)
            WVPASS(r.exists(hashes[99]))
            WVFAIL(r.exists('\0'*20))

            pi = iter(r)
            for h in sorted(hashes):
                WVPASSEQ(str(pi.next()).encode('hex'), h.encode('hex'))

            WVFAIL(r.find_offset('\0'*20))

            r = git.PackIdxList(bupdir + '/objects/pack')
            WVPASS(r.exists(hashes[5]))
            WVPASS(r.exists(hashes[6]))
            WVFAIL(r.exists('\0'*20))
Exemple #45
0
def testpacks():
    with no_lingering_errors():
        with test_tempdir(b'bup-tgit-') as tmpdir:
            environ[b'BUP_DIR'] = bupdir = tmpdir + b'/bup'
            git.init_repo(bupdir)
            git.verbose = 1

            w = git.PackWriter()
            w.new_blob(os.urandom(100))
            w.new_blob(os.urandom(100))
            w.abort()

            w = git.PackWriter()
            hashes = []
            nobj = 1000
            for i in range(nobj):
                hashes.append(w.new_blob(b'%d' % i))
            log('\n')
            nameprefix = w.close()
            print(repr(nameprefix))
            WVPASS(os.path.exists(nameprefix + b'.pack'))
            WVPASS(os.path.exists(nameprefix + b'.idx'))

            r = git.open_idx(nameprefix + b'.idx')
            print(repr(r.fanout))

            for i in range(nobj):
                WVPASS(r.find_offset(hashes[i]) > 0)
            WVPASS(r.exists(hashes[99]))
            WVFAIL(r.exists(b'\0'*20))

            pi = iter(r)
            for h in sorted(hashes):
                WVPASSEQ(hexlify(next(pi)), hexlify(h))

            WVFAIL(r.find_offset(b'\0'*20))

            r = git.PackIdxList(bupdir + b'/objects/pack')
            WVPASS(r.exists(hashes[5]))
            WVPASS(r.exists(hashes[6]))
            WVFAIL(r.exists(b'\0'*20))
Exemple #46
0
def index_negative_timestamps():
    with no_lingering_errors():
        with test_tempdir('bup-tindex-') as tmpdir:
            # Makes 'foo' exist
            foopath = tmpdir + '/foo'
            f = file(foopath, 'wb')
            f.close()

            # Dec 31, 1969
            os.utime(foopath, (-86400, -86400))
            ns_per_sec = 10**9
            tmax = (time.time() - 1) * ns_per_sec
            e = index.BlankNewEntry(foopath, 0, tmax)
            e.update_from_stat(xstat.stat(foopath), 0)
            WVPASS(e.packed())

            # Jun 10, 1893
            os.utime(foopath, (-0x80000000, -0x80000000))
            e = index.BlankNewEntry(foopath, 0, tmax)
            e.update_from_stat(xstat.stat(foopath), 0)
            WVPASS(e.packed())
Exemple #47
0
def test_atomically_replaced_file():
    with no_lingering_errors(), test_tempdir('bup-thelper-') as tmpdir:
        target_file = os.path.join(tmpdir, 'test-atomic-write')

        with atomically_replaced_file(target_file, mode='w') as f:
            f.write('asdf')
            WVPASSEQ(f.mode, 'w')
        f = open(target_file, 'r')
        WVPASSEQ(f.read(), 'asdf')

        try:
            with atomically_replaced_file(target_file, mode='w') as f:
                f.write('wxyz')
                raise Exception()
        except:
            pass
        with open(target_file) as f:
            WVPASSEQ(f.read(), 'asdf')

        with atomically_replaced_file(target_file, mode='wb') as f:
            f.write(os.urandom(20))
            WVPASSEQ(f.mode, 'wb')
Exemple #48
0
Fichier : tvfs.py Projet : bup/bup
def test_contents_with_mismatched_bupm_git_ordering():
    with no_lingering_errors():
        with test_tempdir('bup-tvfs-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            environ['GIT_DIR'] = bup_dir
            environ['BUP_DIR'] = bup_dir
            git.repodir = bup_dir
            data_path = tmpdir + '/src'
            os.mkdir(data_path)
            os.mkdir(data_path + '/foo')
            with open(data_path + '/foo.', 'w+') as tmpfile:
                tmpfile.write(b'canary\n')
            ex((bup_path, 'init'))
            ex((bup_path, 'index', '-v', data_path))
            save_utc = 100000
            save_name = strftime('%Y-%m-%d-%H%M%S', localtime(save_utc))
            ex((bup_path, 'save', '-tvvn', 'test', '-d', str(save_utc),
                '--strip', data_path))
            repo = LocalRepo()
            tip_sref = exo(('git', 'show-ref', 'refs/heads/test')).out
            tip_oidx = tip_sref.strip().split()[0]
            tip_tree_oidx = exo(('git', 'log', '--pretty=%T', '-n1',
                                 tip_oidx)).out.strip()
            tip_tree_oid = tip_tree_oidx.decode('hex')
            tip_tree = tree_dict(repo, tip_tree_oid)

            name, item = vfs.resolve(repo, '/test/latest')[2]
            wvpasseq(save_name, name)
            expected = frozenset((x.name, vfs.Item(oid=x.oid, meta=x.meta))
                                 for x in (tip_tree[name]
                                           for name in ('.', 'foo', 'foo.')))
            contents = tuple(vfs.contents(repo, item))
            wvpasseq(expected, frozenset(contents))
            # Spot check, in case tree_dict shares too much code with the vfs
            name, item = next(((n, i) for n, i in contents if n == 'foo'))
            wvpass(S_ISDIR(item.meta))
            name, item = next(((n, i) for n, i in contents if n == 'foo.'))
            wvpass(S_ISREG(item.meta.mode))
Exemple #49
0
def test_metadata_method():
    with no_lingering_errors():
        with test_tempdir('bup-tmetadata-') as tmpdir:
            bup_dir = tmpdir + '/bup'
            data_path = tmpdir + '/foo'
            os.mkdir(data_path)
            ex('touch', data_path + '/file')
            ex('ln', '-s', 'file', data_path + '/symlink')
            test_time1 = 13 * 1000000000
            test_time2 = 42 * 1000000000
            utime(data_path + '/file', (0, test_time1))
            lutime(data_path + '/symlink', (0, 0))
            utime(data_path, (0, test_time2))
            ex(bup_path, '-d', bup_dir, 'init')
            ex(bup_path, '-d', bup_dir, 'index', '-v', data_path)
            ex(bup_path, '-d', bup_dir, 'save', '-tvvn', 'test', data_path)
            git.check_repo_or_die(bup_dir)
            repo = LocalRepo()
            resolved = vfs.resolve(repo,
                                   '/test/latest' + resolve_parent(data_path),
                                   follow=False)
            leaf_name, leaf_item = resolved[-1]
            m = leaf_item.meta
            WVPASS(m.mtime == test_time2)
            WVPASS(leaf_name == 'foo')
            contents = tuple(vfs.contents(repo, leaf_item))
            WVPASS(len(contents) == 3)
            WVPASSEQ(frozenset(name for name, item in contents),
                     frozenset(('.', 'file', 'symlink')))
            for name, item in contents:
                if name == 'file':
                    m = item.meta
                    WVPASS(m.mtime == test_time1)
                elif name == 'symlink':
                    m = item.meta
                    WVPASSEQ(m.symlink_target, 'file')
                    WVPASSEQ(m.size, 4)
                    WVPASSEQ(m.mtime, 0)
Exemple #50
0
def test_pack_name_lookup():
    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        os.environ['BUP_MAIN_EXE'] = bup_exe
        os.environ['BUP_DIR'] = bupdir = tmpdir + "/bup"
        git.init_repo(bupdir)
        git.verbose = 1
        packdir = git.repo('objects/pack')

        idxnames = []
        hashes = []

        for start in range(0,28,2):
            w = git.PackWriter()
            for i in range(start, start+2):
                hashes.append(w.new_blob(str(i)))
            log('\n')
            idxnames.append(os.path.basename(w.close() + '.idx'))

        r = git.PackIdxList(packdir)
        WVPASSEQ(len(r.packs), 2)
        for e,idxname in enumerate(idxnames):
            for i in range(e*2, (e+1)*2):
                WVPASSEQ(r.exists(hashes[i], want_source=True), idxname)
Exemple #51
0
def test_midx_refreshing():
    with no_lingering_errors():
        with test_tempdir('bup-tclient-') as tmpdir:
            os.environ['BUP_MAIN_EXE'] = bupmain = '../../../bup'
            os.environ['BUP_DIR'] = bupdir = tmpdir
            git.init_repo(bupdir)
            c = client.Client(bupdir, create=True)
            rw = c.new_packwriter()
            rw.new_blob(s1)
            p1base = rw.breakpoint()
            p1name = os.path.join(c.cachedir, p1base)
            s1sha = rw.new_blob(s1)  # should not be written; it's already in p1
            s2sha = rw.new_blob(s2)
            p2base = rw.close()
            p2name = os.path.join(c.cachedir, p2base)
            del rw

            pi = git.PackIdxList(bupdir + '/objects/pack')
            WVPASSEQ(len(pi.packs), 2)
            pi.refresh()
            WVPASSEQ(len(pi.packs), 2)
            WVPASSEQ(sorted([os.path.basename(i.name) for i in pi.packs]),
                     sorted([p1base, p2base]))

            p1 = git.open_idx(p1name)
            WVPASS(p1.exists(s1sha))
            p2 = git.open_idx(p2name)
            WVFAIL(p2.exists(s1sha))
            WVPASS(p2.exists(s2sha))

            subprocess.call([bupmain, 'midx', '-f'])
            pi.refresh()
            WVPASSEQ(len(pi.packs), 1)
            pi.refresh(skip_midx=True)
            WVPASSEQ(len(pi.packs), 2)
            pi.refresh(skip_midx=False)
            WVPASSEQ(len(pi.packs), 1)
Exemple #52
0
def test_commit_parsing():

    def restore_env_var(name, val):
        if val is None:
            del os.environ[name]
        else:
            os.environ[name] = val

    def showval(commit, val):
        return readpipe(['git', 'show', '-s',
                         '--pretty=format:%s' % val, commit]).strip()

    with no_lingering_errors(), test_tempdir('bup-tgit-') as tmpdir:
        orig_cwd = os.getcwd()
        workdir = tmpdir + "/work"
        repodir = workdir + '/.git'
        orig_author_name = os.environ.get('GIT_AUTHOR_NAME')
        orig_author_email = os.environ.get('GIT_AUTHOR_EMAIL')
        orig_committer_name = os.environ.get('GIT_COMMITTER_NAME')
        orig_committer_email = os.environ.get('GIT_COMMITTER_EMAIL')
        os.environ['GIT_AUTHOR_NAME'] = 'bup test'
        os.environ['GIT_COMMITTER_NAME'] = os.environ['GIT_AUTHOR_NAME']
        os.environ['GIT_AUTHOR_EMAIL'] = 'bup@a425bc70a02811e49bdf73ee56450e6f'
        os.environ['GIT_COMMITTER_EMAIL'] = os.environ['GIT_AUTHOR_EMAIL']
        try:
            readpipe(['git', 'init', workdir])
            os.environ['GIT_DIR'] = os.environ['BUP_DIR'] = repodir
            git.check_repo_or_die(repodir)
            os.chdir(workdir)
            with open('foo', 'w') as f:
                print >> f, 'bar'
            readpipe(['git', 'add', '.'])
            readpipe(['git', 'commit', '-am', 'Do something',
                      '--author', 'Someone <someone@somewhere>',
                      '--date', 'Sat Oct 3 19:48:49 2009 -0400'])
            commit = readpipe(['git', 'show-ref', '-s', 'master']).strip()
            parents = showval(commit, '%P')
            tree = showval(commit, '%T')
            cname = showval(commit, '%cn')
            cmail = showval(commit, '%ce')
            cdate = showval(commit, '%ct')
            coffs = showval(commit, '%ci')
            coffs = coffs[-5:]
            coff = (int(coffs[-4:-2]) * 60 * 60) + (int(coffs[-2:]) * 60)
            if coffs[-5] == '-':
                coff = - coff
            commit_items = git.get_commit_items(commit, git.cp())
            WVPASSEQ(commit_items.parents, [])
            WVPASSEQ(commit_items.tree, tree)
            WVPASSEQ(commit_items.author_name, 'Someone')
            WVPASSEQ(commit_items.author_mail, 'someone@somewhere')
            WVPASSEQ(commit_items.author_sec, 1254613729)
            WVPASSEQ(commit_items.author_offset, -(4 * 60 * 60))
            WVPASSEQ(commit_items.committer_name, cname)
            WVPASSEQ(commit_items.committer_mail, cmail)
            WVPASSEQ(commit_items.committer_sec, int(cdate))
            WVPASSEQ(commit_items.committer_offset, coff)
            WVPASSEQ(commit_items.message, 'Do something\n')
            with open('bar', 'w') as f:
                print >> f, 'baz'
            readpipe(['git', 'add', '.'])
            readpipe(['git', 'commit', '-am', 'Do something else'])
            child = readpipe(['git', 'show-ref', '-s', 'master']).strip()
            parents = showval(child, '%P')
            commit_items = git.get_commit_items(child, git.cp())
            WVPASSEQ(commit_items.parents, [commit])
        finally:
            os.chdir(orig_cwd)
            restore_env_var('GIT_AUTHOR_NAME', orig_author_name)
            restore_env_var('GIT_AUTHOR_EMAIL', orig_author_email)
            restore_env_var('GIT_COMMITTER_NAME', orig_committer_name)
            restore_env_var('GIT_COMMITTER_EMAIL', orig_committer_email)
Exemple #53
0
def index_dirty():
    with no_lingering_errors():
        with test_tempdir('bup-tindex-') as tmpdir:
            orig_cwd = os.getcwd()
            try:
                os.chdir(tmpdir)
                default_meta = metadata.Metadata()
                ms1 = index.MetaStoreWriter('index.meta.tmp')
                ms2 = index.MetaStoreWriter('index2.meta.tmp')
                ms3 = index.MetaStoreWriter('index3.meta.tmp')
                meta_ofs1 = ms1.store(default_meta)
                meta_ofs2 = ms2.store(default_meta)
                meta_ofs3 = ms3.store(default_meta)

                ds = xstat.stat(lib_t_dir)
                fs = xstat.stat(lib_t_dir + '/tindex.py')
                tmax = (time.time() - 1) * 10**9

                w1 = index.Writer('index.tmp', ms1, tmax)
                w1.add('/a/b/x', fs, meta_ofs1)
                w1.add('/a/b/c', fs, meta_ofs1)
                w1.add('/a/b/', ds, meta_ofs1)
                w1.add('/a/', ds, meta_ofs1)
                #w1.close()
                WVPASS()

                w2 = index.Writer('index2.tmp', ms2, tmax)
                w2.add('/a/b/n/2', fs, meta_ofs2)
                #w2.close()
                WVPASS()

                w3 = index.Writer('index3.tmp', ms3, tmax)
                w3.add('/a/c/n/3', fs, meta_ofs3)
                #w3.close()
                WVPASS()

                r1 = w1.new_reader()
                r2 = w2.new_reader()
                r3 = w3.new_reader()
                WVPASS()

                r1all = [e.name for e in r1]
                WVPASSEQ(r1all,
                         ['/a/b/x', '/a/b/c', '/a/b/', '/a/', '/'])
                r2all = [e.name for e in r2]
                WVPASSEQ(r2all,
                         ['/a/b/n/2', '/a/b/n/', '/a/b/', '/a/', '/'])
                r3all = [e.name for e in r3]
                WVPASSEQ(r3all,
                         ['/a/c/n/3', '/a/c/n/', '/a/c/', '/a/', '/'])
                all = [e.name for e in index.merge(r2, r1, r3)]
                WVPASSEQ(all,
                         ['/a/c/n/3', '/a/c/n/', '/a/c/',
                          '/a/b/x', '/a/b/n/2', '/a/b/n/', '/a/b/c',
                          '/a/b/', '/a/', '/'])
                fake_validate(r1)
                dump(r1)

                print [hex(e.flags) for e in r1]
                WVPASSEQ([e.name for e in r1 if e.is_valid()], r1all)
                WVPASSEQ([e.name for e in r1 if not e.is_valid()], [])
                WVPASSEQ([e.name for e in index.merge(r2, r1, r3) if not e.is_valid()],
                         ['/a/c/n/3', '/a/c/n/', '/a/c/',
                          '/a/b/n/2', '/a/b/n/', '/a/b/', '/a/', '/'])

                expect_invalid = ['/'] + r2all + r3all
                expect_real = (set(r1all) - set(r2all) - set(r3all)) \
                                | set(['/a/b/n/2', '/a/c/n/3'])
                dump(index.merge(r2, r1, r3))
                for e in index.merge(r2, r1, r3):
                    print e.name, hex(e.flags), e.ctime
                    eiv = e.name in expect_invalid
                    er  = e.name in expect_real
                    WVPASSEQ(eiv, not e.is_valid())
                    WVPASSEQ(er, e.is_real())
                fake_validate(r2, r3)
                dump(index.merge(r2, r1, r3))
                WVPASSEQ([e.name for e in index.merge(r2, r1, r3) if not e.is_valid()], [])

                e = eget(index.merge(r2, r1, r3), '/a/b/c')
                e.invalidate()
                e.repack()
                dump(index.merge(r2, r1, r3))
                WVPASSEQ([e.name for e in index.merge(r2, r1, r3) if not e.is_valid()],
                         ['/a/b/c', '/a/b/', '/a/', '/'])
                w1.close()
                w2.close()
                w3.close()
            finally: