lib/bup/t/tvfs.py

   1
   2 from __future__ import print_function
   3 from collections import namedtuple
   4 from io import BytesIO
   5 from os import environ, symlink
   6 from stat import S_IFDIR, S_IFREG, S_ISDIR, S_ISREG
   7 from sys import stderr
   8 from time import localtime, strftime
   9
  10 from wvtest import *
  11
  12 from bup import git, metadata, vfs2 as vfs
  13 from bup.git import BUP_CHUNKED
  14 from bup.helpers import exc, exo, shstr
  15 from bup.metadata import Metadata
  16 from bup.repo import LocalRepo
  17 from buptest import no_lingering_errors, test_tempdir
  18
  19 top_dir = '../../..'
  20 bup_tmp = os.path.realpath('../../../t/tmp')
  21 bup_path = top_dir + '/bup'
  22 start_dir = os.getcwd()
  23
  24 def ex(cmd, **kwargs):
  25     print(shstr(cmd), file=stderr)
  26     return exc(cmd, **kwargs)
  27
  28 TreeDictValue = namedtuple('TreeDictValue', ('name', 'oid', 'meta'))
  29
  30 def tree_items(repo, oid):
  31     """Yield (name, entry_oid, meta) for each entry in oid.  meta will be
  32     a Metadata object for any non-directories and for '.', otherwise
  33     None.
  34
  35     """
  36     # This is a simpler approach than the one in the vfs, used to
  37     # cross-check its behavior.
  38     tree_data, bupm_oid = vfs._tree_data_and_bupm(repo, oid)
  39     bupm = vfs._FileReader(repo, bupm_oid) if bupm_oid else None
  40     try:
  41         maybe_meta = lambda : Metadata.read(bupm) if bupm else None
  42         m = maybe_meta()
  43         if m:
  44             m.size = 0
  45         yield TreeDictValue(name='.', oid=oid, meta=m)
  46         tree_ents = vfs.ordered_tree_entries(tree_data, bupm=True)
  47         for name, mangled_name, kind, gitmode, sub_oid in tree_ents:
  48             if mangled_name == '.bupm':
  49                 continue
  50             assert name != '.'
  51             if S_ISDIR(gitmode):
  52                 if kind == BUP_CHUNKED:
  53                     yield TreeDictValue(name=name, oid=sub_oid,
  54                                         meta=maybe_meta())
  55                 else:
  56                     yield TreeDictValue(name=name, oid=sub_oid,
  57                                         meta=vfs.default_dir_mode)
  58             else:
  59                 yield TreeDictValue(name=name, oid=sub_oid, meta=maybe_meta())
  60     finally:
  61         if bupm:
  62             bupm.close()
  63
  64 def tree_dict(repo, oid):
  65     return dict((x.name, x) for x in tree_items(repo, oid))
  66
  67 def run_augment_item_meta_tests(repo,
  68                                 file_path, file_size,
  69                                 link_path, link_target):
  70     _, file_item = vfs.resolve(repo, file_path)[-1]
  71     _, link_item = vfs.lresolve(repo, link_path)[-1]
  72     wvpass(isinstance(file_item.meta, Metadata))
  73     wvpass(isinstance(link_item.meta, Metadata))
  74     # Note: normally, modifying item.meta values is forbidden
  75     file_item.meta.size = file_item.meta.size or vfs.item_size(repo, file_item)
  76     link_item.meta.size = link_item.meta.size or vfs.item_size(repo, link_item)
  77
  78     ## Ensure a fully populated item is left alone
  79     augmented = vfs.augment_item_meta(repo, file_item)
  80     wvpass(augmented is file_item)
  81     wvpass(augmented.meta is file_item.meta)
  82     augmented = vfs.augment_item_meta(repo, file_item, include_size=True)
  83     wvpass(augmented is file_item)
  84     wvpass(augmented.meta is file_item.meta)
  85
  86     ## Ensure a missing size is handled poperly
  87     file_item.meta.size = None
  88     augmented = vfs.augment_item_meta(repo, file_item)
  89     wvpass(augmented is file_item)
  90     wvpass(augmented.meta is file_item.meta)
  91     augmented = vfs.augment_item_meta(repo, file_item, include_size=True)
  92     wvpass(augmented is not file_item)
  93     wvpasseq(file_size, augmented.meta.size)
  94
  95     ## Ensure a meta mode is handled properly
  96     mode_item = file_item._replace(meta=vfs.default_file_mode)
  97     augmented = vfs.augment_item_meta(repo, mode_item)
  98     augmented_w_size = vfs.augment_item_meta(repo, mode_item, include_size=True)
  99     for item in (augmented, augmented_w_size):
 100         meta = item.meta
 101         wvpass(item is not file_item)
 102         wvpass(isinstance(meta, Metadata))
 103         wvpasseq(vfs.default_file_mode, meta.mode)
 104         wvpasseq((0, 0, 0, 0, 0),
 105                  (meta.uid, meta.gid, meta.atime, meta.mtime, meta.ctime))
 106     wvpass(augmented.meta.size is None)
 107     wvpasseq(file_size, augmented_w_size.meta.size)
 108
 109     ## Ensure symlinks are handled properly
 110     mode_item = link_item._replace(meta=vfs.default_symlink_mode)
 111     augmented = vfs.augment_item_meta(repo, mode_item)
 112     wvpass(augmented is not mode_item)
 113     wvpass(isinstance(augmented.meta, Metadata))
 114     wvpasseq(link_target, augmented.meta.symlink_target)
 115     wvpasseq(len(link_target), augmented.meta.size)
 116     augmented = vfs.augment_item_meta(repo, mode_item, include_size=True)
 117     wvpass(augmented is not mode_item)
 118     wvpass(isinstance(augmented.meta, Metadata))
 119     wvpasseq(link_target, augmented.meta.symlink_target)
 120     wvpasseq(len(link_target), augmented.meta.size)
 121
 122
 123 @wvtest
 124 def test_item_mode():
 125     with no_lingering_errors():
 126         mode = S_IFDIR | 0o755
 127         meta = metadata.from_path('.')
 128         oid = '\0' * 20
 129         wvpasseq(mode, vfs.item_mode(vfs.Item(oid=oid, meta=mode)))
 130         wvpasseq(meta.mode, vfs.item_mode(vfs.Item(oid=oid, meta=meta)))
 131
 132 @wvtest
 133 def test_reverse_suffix_duplicates():
 134     suffix = lambda x: tuple(vfs._reverse_suffix_duplicates(x))
 135     wvpasseq(('x',), suffix(('x',)))
 136     wvpasseq(('x', 'y'), suffix(('x', 'y')))
 137     wvpasseq(('x-1', 'x-0'), suffix(('x',) * 2))
 138     wvpasseq(['x-%02d' % n for n in reversed(range(11))],
 139              list(suffix(('x',) * 11)))
 140     wvpasseq(('x-1', 'x-0', 'y'), suffix(('x', 'x', 'y')))
 141     wvpasseq(('x', 'y-1', 'y-0'), suffix(('x', 'y', 'y')))
 142     wvpasseq(('x', 'y-1', 'y-0', 'z'), suffix(('x', 'y', 'y', 'z')))
 143
 144 @wvtest
 145 def test_misc():
 146     with no_lingering_errors():
 147         with test_tempdir('bup-tvfs-') as tmpdir:
 148             bup_dir = tmpdir + '/bup'
 149             environ['GIT_DIR'] = bup_dir
 150             environ['BUP_DIR'] = bup_dir
 151             git.repodir = bup_dir
 152             data_path = tmpdir + '/src'
 153             os.mkdir(data_path)
 154             with open(data_path + '/file', 'w+') as tmpfile:
 155                 tmpfile.write(b'canary\n')
 156             symlink('file', data_path + '/symlink')
 157             ex((bup_path, 'init'))
 158             ex((bup_path, 'index', '-v', data_path))
 159             ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
 160                 data_path))
 161             repo = LocalRepo()
 162
 163             wvstart('readlink')
 164             ls_tree = exo(('git', 'ls-tree', 'test', 'symlink'))
 165             mode, typ, oidx, name = ls_tree[0].strip().split(None, 3)
 166             assert name == 'symlink'
 167             link_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
 168             wvpasseq('file', vfs.readlink(repo, link_item))
 169
 170             ls_tree = exo(('git', 'ls-tree', 'test', 'file'))
 171             mode, typ, oidx, name = ls_tree[0].strip().split(None, 3)
 172             assert name == 'file'
 173             file_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
 174             wvexcept(Exception, vfs.readlink, repo, file_item)
 175
 176             wvstart('item_size')
 177             wvpasseq(4, vfs.item_size(repo, link_item))
 178             wvpasseq(7, vfs.item_size(repo, file_item))
 179             meta = metadata.from_path(__file__)
 180             meta.size = 42
 181             fake_item = file_item._replace(meta=meta)
 182             wvpasseq(42, vfs.item_size(repo, fake_item))
 183
 184             wvstart('augment_item_meta')
 185             run_augment_item_meta_tests(repo,
 186                                         '/test/latest/file', 7,
 187                                         '/test/latest/symlink', 'file')
 188
 189             wvstart('copy_item')
 190             # FIXME: this caused StopIteration
 191             #_, file_item = vfs.resolve(repo, '/file')[-1]
 192             _, file_item = vfs.resolve(repo, '/test/latest/file')[-1]
 193             file_copy = vfs.copy_item(file_item)
 194             wvpass(file_copy is not file_item)
 195             wvpass(file_copy.meta is not file_item.meta)
 196             wvpass(isinstance(file_copy, tuple))
 197             wvpass(file_item.meta.user)
 198             wvpass(file_copy.meta.user)
 199             file_copy.meta.user = None
 200             wvpass(file_item.meta.user)
 201
 202 @wvtest
 203 def test_resolve():
 204     with no_lingering_errors():
 205         with test_tempdir('bup-tvfs-') as tmpdir:
 206             resolve = vfs.resolve
 207             lresolve = vfs.lresolve
 208             bup_dir = tmpdir + '/bup'
 209             environ['GIT_DIR'] = bup_dir
 210             environ['BUP_DIR'] = bup_dir
 211             git.repodir = bup_dir
 212             data_path = tmpdir + '/src'
 213             save_time = 100000
 214             save_time_str = strftime('%Y-%m-%d-%H%M%S', localtime(save_time))
 215             os.mkdir(data_path)
 216             with open(data_path + '/file', 'w+') as tmpfile:
 217                 print('canary', file=tmpfile)
 218             symlink('file', data_path + '/symlink')
 219             ex((bup_path, 'init'))
 220             ex((bup_path, 'index', '-v', data_path))
 221             ex((bup_path, 'save', '-d', str(save_time), '-tvvn', 'test',
 222                 '--strip', data_path))
 223             ex((bup_path, 'tag', 'test-tag', 'test'))
 224             repo = LocalRepo()
 225
 226             tip_hash = exo(('git', 'show-ref', 'refs/heads/test'))[0]
 227             tip_oidx = tip_hash.strip().split()[0]
 228             tip_oid = tip_oidx.decode('hex')
 229             tip_meta = Metadata()
 230             tip_meta.mode = S_IFDIR | 0o755
 231             tip_meta.uid = tip_meta.gid = tip_meta.size = 0
 232             tip_meta.atime = tip_meta.mtime = tip_meta.ctime = save_time * 10**9
 233             test_revlist = vfs.RevList(meta=tip_meta, oid=tip_oid)
 234             tip_tree_oidx = exo(('git', 'log', '--pretty=%T', '-n1',
 235                                  tip_oidx))[0].strip()
 236             tip_tree_oid = tip_tree_oidx.decode('hex')
 237             tip_tree = tree_dict(repo, tip_tree_oid)
 238
 239             wvstart('resolve: /')
 240             res = resolve(repo, '/')
 241             wvpasseq(1, len(res))
 242             wvpasseq((('', vfs._root),), res)
 243             ignore, root_item = res[0]
 244             root_content = frozenset(vfs.contents(repo, root_item))
 245             wvpasseq(frozenset([('.', root_item),
 246                                 ('.tag', vfs._tags),
 247                                 ('test', test_revlist)]),
 248                      root_content)
 249
 250             wvstart('resolve: /.tag')
 251             res = resolve(repo, '/.tag')
 252             wvpasseq(2, len(res))
 253             wvpasseq((('', vfs._root), ('.tag', vfs._tags)),
 254                      res)
 255             ignore, tag_item = res[1]
 256             tag_content = frozenset(vfs.contents(repo, tag_item))
 257             wvpasseq(frozenset([('.', tag_item),
 258                                 ('test-tag', test_revlist)]),
 259                      tag_content)
 260
 261             wvstart('resolve: /test')
 262             res = resolve(repo, '/test')
 263             wvpasseq(2, len(res))
 264             wvpasseq((('', vfs._root), ('test', test_revlist)), res)
 265             ignore, test_item = res[1]
 266             test_content = frozenset(vfs.contents(repo, test_item))
 267             expected_latest_item = vfs.Item(meta=S_IFDIR | 0o755,
 268                                                     oid=tip_tree_oid)
 269             wvpasseq(frozenset([('.', test_revlist),
 270                                 (save_time_str, expected_latest_item),
 271                                 ('latest', expected_latest_item)]),
 272                      test_content)
 273
 274             wvstart('resolve: /test/latest')
 275             res = resolve(repo, '/test/latest')
 276             wvpasseq(3, len(res))
 277             expected_latest_item_w_meta = vfs.Item(meta=tip_tree['.'].meta,
 278                                                    oid=tip_tree_oid)
 279             expected = (('', vfs._root),
 280                         ('test', test_revlist),
 281                         ('latest', expected_latest_item_w_meta))
 282             wvpasseq(expected, res)
 283             ignore, latest_item = res[2]
 284             latest_content = frozenset(vfs.contents(repo, latest_item))
 285             expected = frozenset((x.name, vfs.Item(oid=x.oid, meta=x.meta))
 286                                  for x in (tip_tree[name]
 287                                            for name in ('.', 'file',
 288                                                         'symlink')))
 289             wvpasseq(expected, latest_content)
 290
 291             wvstart('resolve: /test/latest/foo')
 292             res = resolve(repo, '/test/latest/file')
 293             wvpasseq(4, len(res))
 294             expected_file_item_w_meta = vfs.Item(meta=tip_tree['file'].meta,
 295                                                  oid=tip_tree['file'].oid)
 296             expected = (('', vfs._root),
 297                         ('test', test_revlist),
 298                         ('latest', expected_latest_item_w_meta),
 299                         ('file', expected_file_item_w_meta))
 300             wvpasseq(expected, res)
 301
 302             wvstart('resolve: /test/latest/symlink')
 303             res = resolve(repo, '/test/latest/symlink')
 304             wvpasseq(4, len(res))
 305             expected = (('', vfs._root),
 306                         ('test', test_revlist),
 307                         ('latest', expected_latest_item_w_meta),
 308                         ('file', expected_file_item_w_meta))
 309             wvpasseq(expected, res)
 310
 311             wvstart('lresolve: /test/latest/symlink')
 312             res = lresolve(repo, '/test/latest/symlink')
 313             wvpasseq(4, len(res))
 314             symlink_value = tip_tree['symlink']
 315             expected_symlink_item_w_meta = vfs.Item(meta=symlink_value.meta,
 316                                                     oid=symlink_value.oid)
 317             expected = (('', vfs._root),
 318                         ('test', test_revlist),
 319                         ('latest', expected_latest_item_w_meta),
 320                         ('symlink', expected_symlink_item_w_meta))
 321             wvpasseq(expected, res)
 322
 323             wvstart('resolve: /test/latest/missing')
 324             res = resolve(repo, '/test/latest/missing')
 325             wvpasseq(4, len(res))
 326             name, item = res[-1]
 327             wvpasseq('missing', name)
 328             wvpass(item is None)
 329
 330 @wvtest
 331 def test_resolve_loop():
 332     with no_lingering_errors():
 333         with test_tempdir('bup-tvfs-resloop-') as tmpdir:
 334             resolve = vfs.resolve
 335             lresolve = vfs.lresolve
 336             bup_dir = tmpdir + '/bup'
 337             environ['GIT_DIR'] = bup_dir
 338             environ['BUP_DIR'] = bup_dir
 339             git.repodir = bup_dir
 340             repo = LocalRepo()
 341             data_path = tmpdir + '/src'
 342             os.mkdir(data_path)
 343             symlink('loop', data_path + '/loop')
 344             ex((bup_path, 'init'))
 345             ex((bup_path, 'index', '-v', data_path))
 346             ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
 347                 data_path))
 348             wvexcept(vfs.Loop, resolve, repo, '/test/latest/loop')
 349
 350 @wvtest
 351 def test_contents_with_mismatched_bupm_git_ordering():
 352     with no_lingering_errors():
 353         with test_tempdir('bup-tvfs-') as tmpdir:
 354             bup_dir = tmpdir + '/bup'
 355             environ['GIT_DIR'] = bup_dir
 356             environ['BUP_DIR'] = bup_dir
 357             git.repodir = bup_dir
 358             data_path = tmpdir + '/src'
 359             os.mkdir(data_path)
 360             os.mkdir(data_path + '/foo')
 361             with open(data_path + '/foo.', 'w+') as tmpfile:
 362                 tmpfile.write(b'canary\n')
 363             ex((bup_path, 'init'))
 364             ex((bup_path, 'index', '-v', data_path))
 365             ex((bup_path, 'save', '-tvvn', 'test', '--strip',
 366                 data_path))
 367             repo = LocalRepo()
 368             tip_sref = exo(('git', 'show-ref', 'refs/heads/test'))[0]
 369             tip_oidx = tip_sref.strip().split()[0]
 370             tip_tree_oidx = exo(('git', 'log', '--pretty=%T', '-n1',
 371                                  tip_oidx))[0].strip()
 372             tip_tree_oid = tip_tree_oidx.decode('hex')
 373             tip_tree = tree_dict(repo, tip_tree_oid)
 374
 375             name, item = vfs.resolve(repo, '/test/latest')[2]
 376             wvpasseq('latest', name)
 377             expected = frozenset((x.name, vfs.Item(oid=x.oid, meta=x.meta))
 378                                  for x in (tip_tree[name]
 379                                            for name in ('.', 'foo', 'foo.')))
 380             contents = tuple(vfs.contents(repo, item))
 381             wvpasseq(expected, frozenset(contents))
 382             # Spot check, in case tree_dict shares too much code with the vfs
 383             name, item = next(((n, i) for n, i in contents if n == 'foo'))
 384             wvpass(S_ISDIR(item.meta))
 385             name, item = next(((n, i) for n, i in contents if n == 'foo.'))
 386             wvpass(S_ISREG(item.meta.mode))
 387
 388 @wvtest
 389 def test_duplicate_save_dates():
 390     with no_lingering_errors():
 391         with test_tempdir('bup-tvfs-') as tmpdir:
 392             bup_dir = tmpdir + '/bup'
 393             environ['GIT_DIR'] = bup_dir
 394             environ['BUP_DIR'] = bup_dir
 395             environ['TZ'] = 'UTC'
 396             git.repodir = bup_dir
 397             data_path = tmpdir + '/src'
 398             os.mkdir(data_path)
 399             with open(data_path + '/file', 'w+') as tmpfile:
 400                 tmpfile.write(b'canary\n')
 401             ex((bup_path, 'init'))
 402             ex((bup_path, 'index', '-v', data_path))
 403             for i in range(11):
 404                 ex((bup_path, 'save', '-d', '100000', '-n', 'test', data_path))
 405             repo = LocalRepo()
 406             res = vfs.resolve(repo, '/test')
 407             wvpasseq(2, len(res))
 408             name, revlist = res[-1]
 409             wvpasseq('test', name)
 410             wvpasseq(('.',
 411                       '1970-01-02-034640-10',
 412                       '1970-01-02-034640-09',
 413                       '1970-01-02-034640-08',
 414                       '1970-01-02-034640-07',
 415                       '1970-01-02-034640-06',
 416                       '1970-01-02-034640-05',
 417                       '1970-01-02-034640-04',
 418                       '1970-01-02-034640-03',
 419                       '1970-01-02-034640-02',
 420                       '1970-01-02-034640-01',
 421                       '1970-01-02-034640-00',
 422                       'latest'),
 423                      tuple(x[0] for x in vfs.contents(repo, revlist)))
 424
 425 # FIXME: add tests for the want_meta=False cases.