def test_map_directory_structure(self):
old = contents.contentsSet(
[self.mk_dir("/dir"),
self.mk_link("/sym", "dir")])
new = contents.contentsSet(
[self.mk_file("/sym/a"),
self.mk_dir("/sym")])
# verify the machinery is working as expected.
ret = new.map_directory_structure(old)
self.assertEqual(sorted(ret),
sorted([self.mk_dir("/dir"),
self.mk_file("/dir/a")]))
# test recursion next.
old.add(self.mk_link("/dir/sym", "dir2"))
old.add(self.mk_dir("/dir/dir2"))
new.add(self.mk_file("/dir/sym/b"))
new.add(self.mk_dir("/sym/sym"))
ret = new.map_directory_structure(old)
self.assertEqual(
sorted(ret),
sorted([
self.mk_dir("/dir"),
self.mk_file("/dir/a"),
self.mk_dir("/dir/dir2"),
self.mk_file("/dir/dir2/b")
]))
def check_complex_set_op(self, name, *test_cases):
for required, data1, data2 in test_cases:
cset1 = contents.contentsSet(data1)
cset2 = contents.contentsSet(data2)
f = getattr(cset1, name)
got = f(cset2)
self.assertEqual(got, required,
msg="%s: expected %s, got %s\ncset1=%r\ncset2=%r" %
(name, required, got, cset1, cset2))
def check_complex_set_op(self, name, *test_cases):
for required, data1, data2 in test_cases:
cset1 = contents.contentsSet(data1)
cset2 = contents.contentsSet(data2)
f = getattr(cset1, name)
got = f(cset2)
self.assertEqual(got, required,
msg="%s: expected %s, got %s\ncset1=%r\ncset2=%r" %
(name, required, got, cset1, cset2))
def check_complex_set_op(self, name, *test_cases):
for required, data1, data2 in test_cases:
cset1 = contents.contentsSet(data1)
cset2 = contents.contentsSet(data2)
f = getattr(cset1, name)
got = f(cset2)
self.assertEqual(
got, required,
msg=f"{name}: expected {required}, got {got}\ncset1={cset1!r}\ncset2={cset2!r}")
def test_remove(self):
self.assertRaises(AttributeError,
contents.contentsSet(mutable=False).remove, self.devs[0])
self.assertRaises(AttributeError,
contents.contentsSet(mutable=False).remove, 1)
cs = contents.contentsSet(self.all, mutable=True)
map(cs.remove, self.all)
cs = contents.contentsSet(self.all, mutable=True)
map(cs.remove, (x.location for x in self.all))
self.assertEqual(len(cs), 0)
self.assertRaises(KeyError, cs.remove, self.all[0])
def test_remove(self):
self.assertRaises(AttributeError,
contents.contentsSet(mutable=False).remove, self.devs[0])
self.assertRaises(AttributeError,
contents.contentsSet(mutable=False).remove, 1)
cs = contents.contentsSet(self.all, mutable=True)
map(cs.remove, self.all)
cs = contents.contentsSet(self.all, mutable=True)
map(cs.remove, (x.location for x in self.all))
self.assertEqual(len(cs), 0)
self.assertRaises(KeyError, cs.remove, self.all[0])
def test_intersect(self):
open(pjoin(self.dir, 'reg'), 'w').close()
cset = contentsSet([fs.fsFile('reg', strict=False)])
cset = cset.insert_offset(self.dir)
self.assertEqual(contentsSet(livefs.intersect(cset)), cset)
cset = contentsSet([fs.fsFile('reg/foon', strict=False),
fs.fsFile('reg/dar', strict=False),
fs.fsDir('reg/dir', strict=False)]).insert_offset(self.dir)
self.assertEqual(list(livefs.intersect(cset)), [])
cset = contentsSet([fs.fsDir('reg', strict=False)])
self.assertEqual(list(livefs.intersect(cset)), [])
def test_add(self):
cs = contents.contentsSet(self.files + self.dirs, mutable=True)
for x in self.links:
cs.add(x)
self.assertIn(x, cs)
self.assertEqual(
len(cs),
len(set(x.location for x in self.files + self.dirs + self.links)))
self.assertRaises(AttributeError,
lambda:contents.contentsSet(mutable=False).add(self.devs[0]))
self.assertRaises(TypeError, cs.add, 1)
self.assertRaises(TypeError, cs.add, self.fifos)
def test_intersect(self):
open(pjoin(self.dir, 'reg'), 'w').close()
cset = contentsSet([fs.fsFile('reg', strict=False)])
cset = cset.insert_offset(self.dir)
self.assertEqual(contentsSet(livefs.intersect(cset)), cset)
cset = contentsSet([
fs.fsFile('reg/foon', strict=False),
fs.fsFile('reg/dar', strict=False),
fs.fsDir('reg/dir', strict=False)
]).insert_offset(self.dir)
self.assertEqual(list(livefs.intersect(cset)), [])
cset = contentsSet([fs.fsDir('reg', strict=False)])
self.assertEqual(list(livefs.intersect(cset)), [])
def test_get_replace_cset(self):
files = contentsSet(self.simple_cset.iterfiles(invert=True))
engine = fake_engine(csets={
'install': files,
'old_cset': self.simple_cset
})
self.assertCsetEqual(files, self.run_cset('get_replace_cset', engine))
def trigger(self, engine, cset):
op = self.format_op
op = getattr(op, 'install_op', op)
op.setup_workdir()
merge_contents = get_plugin("fs_ops.merge_contents")
merge_cset = cset
if engine.offset != '/':
merge_cset = cset.change_offset(engine.offset, '/')
merge_contents(merge_cset, offset=op.env["D"])
# ok. they're on disk.
# now to avoid going back to the binpkg, we rewrite
# the data_source for files to the on disk location.
# we can update in place also, since we're not changing the mapping.
# this rewrites the data_source to the ${D} loc.
d = op.env["D"]
fi = (x.change_attributes(
data=local_source(pjoin(d, x.location.lstrip('/'))))
for x in merge_cset.iterfiles())
if engine.offset:
# we're using merge_cset above, which has the final offset loc
# pruned; this is required for the merge, however, we're updating
# the cset so we have to insert the final offset back in.
# wrap the iter, iow.
fi = offset_rewriter(engine.offset, fi)
cset.update(contentsSet(fi))
# we *probably* should change the csets class at some point
# since it no longer needs to be tar, but that's for another day.
engine.replace_cset('new_cset', cset)
def get_merged_cset(self, strip_offset=True):
cset = self.csets["install"]
if self.offset not in (None, '/') and strip_offset:
rewrite = contents.change_offset_rewriter(self.offset, '/',
cset)
cset = contents.contentsSet(rewrite)
return cset
def test_it(self):
orig = contentsSet([
fs.fsFile('/cheddar', strict=False),
fs.fsFile('/sporks-suck', strict=False),
fs.fsDir('/foons-rule', strict=False),
fs.fsDir('/mango', strict=False)
])
engine = fake_engine(mode=const.INSTALL_MODE)
def run(func):
new = contentsSet(orig)
self.kls(func)(engine, {'new_cset':new})
return new
self.assertEqual(orig, run(lambda s:False))
self.assertEqual([], run(post_curry(isinstance, fs.fsDir)).dirs())
self.assertEqual(orig.files(),
run(post_curry(isinstance, fs.fsDir)).dirs(True))
# check noisyness.
info = []
engine = fake_engine(observer=fake_reporter(info=info.append),
mode=const.REPLACE_MODE)
run(lambda s:False)
self.assertFalse(info)
run(post_curry(isinstance, fs.fsDir))
self.assertEqual(len(info), 2)
# ensure only the relevant files show.
self.assertNotIn('/cheddar', ' '.join(info))
self.assertNotIn('/sporks-suck', ' '.join(info))
self.assertIn('/foons-rule', ' '.join(info))
self.assertIn('/mango', ' '.join(info))
def map_new_cset_livefs(engine, csets, cset_name='new_cset'):
"""Find symlinks on disk that redirect new_cset, and return a livefs localized cset."""
initial = csets[cset_name]
ondisk = contents.contentsSet(livefs.intersect(initial.iterdirs(), realpath=False))
livefs.recursively_fill_syms(ondisk)
ret = initial.map_directory_structure(ondisk, add_conflicting_sym=True)
return ret
def scan(*a, **kw):
"""Alias for list(iter_scan(\*a, \*\*kw))
Look at :py:func:`iter_scan` for valid args.
"""
mutable = kw.pop("mutable", True)
return contentsSet(iter_scan(*a, **kw), mutable=mutable)
def map_new_cset_livefs(engine, csets, cset_name='new_cset'):
"""Find symlinks on disk that redirect new_cset, and return a livefs localized cset."""
initial = csets[cset_name]
ondisk = contents.contentsSet(livefs.intersect(initial.iterdirs(), realpath=False))
livefs.recursively_fill_syms(ondisk)
ret = initial.map_directory_structure(ondisk, add_conflicting_sym=True)
return ret
def scan(*a, **kw):
"""Alias for list(iter_scan(*a, **kw))
Look at :py:func:`iter_scan` for valid args.
"""
mutable = kw.pop("mutable", True)
return contentsSet(iter_scan(*a, **kw), mutable=mutable)
def test_it(self):
orig = contentsSet([
fs.fsFile('/cheddar', strict=False),
fs.fsFile('/sporks-suck', strict=False),
fs.fsDir('/foons-rule', strict=False),
fs.fsDir('/mango', strict=False)
])
engine = fake_engine(mode=const.INSTALL_MODE)
def run(func):
new = contentsSet(orig)
self.kls(func)(engine, {'new_cset':new})
return new
self.assertEqual(orig, run(lambda s:False))
self.assertEqual([], run(post_curry(isinstance, fs.fsDir)).dirs())
self.assertEqual(sorted(orig.files()),
sorted(run(post_curry(isinstance, fs.fsDir)).dirs(True)))
# check noisyness.
info = []
engine = fake_engine(observer=make_fake_reporter(info=info.append),
mode=const.REPLACE_MODE)
run(lambda s:False)
self.assertFalse(info)
run(post_curry(isinstance, fs.fsDir))
self.assertEqual(len(info), 2)
# ensure only the relevant files show.
self.assertNotIn('/cheddar', ' '.join(info))
self.assertNotIn('/sporks-suck', ' '.join(info))
self.assertIn('/foons-rule', ' '.join(info))
self.assertIn('/mango', ' '.join(info))
def test_dir_over_file(self):
# according to the spec, dirs can't be merged over files that
# aren't dirs or symlinks to dirs
path = pjoin(self.dir, "file2dir")
open(path, 'w').close()
d = fs.fsDir(path, mode=0o755, mtime=0, uid=os.getuid(), gid=os.getgid())
cset = contents.contentsSet([d])
self.assertRaises(ops.CannotOverwrite, ops.merge_contents, cset)
def test_dir_over_file(self):
# according to the spec, dirs can't be merged over files that
# aren't dirs or symlinks to dirs
path = pjoin(self.dir, "file2dir")
open(path, 'w').close()
d = fs.fsDir(path, mode=0o755, mtime=0, uid=os.getuid(), gid=os.getgid())
cset = contents.contentsSet([d])
self.assertRaises(ops.CannotOverwrite, ops.merge_contents, cset)
def listobj(self, name, obj_class=None):
valid_list = getattr(self, name)
cs = contents.contentsSet(valid_list)
test_list = getattr(cs, name)()
if obj_class is not None:
for x in test_list:
self.assertInstance(x, obj_class)
self.assertEqual(set(test_list), set(valid_list))
def test_child_nodes(self):
self.assertEqual(
sorted(['/usr', '/usr/bin', '/usr/foo']),
sorted(x.location for x in contents.contentsSet([
self.mk_dir("/usr"),
self.mk_dir("/usr/bin"),
self.mk_file("/usr/foo")
])))
def write(tempspace, finalpath, pkg, cset=None, platform='', maintainer='', compressor='gz'):
# The debian-binary file
if cset is None:
cset = pkg.contents
# The data.tar.gz file
data_path = pjoin(tempspace, 'data.tar.gz')
tar.write_set(cset, data_path, compressor='gz', absolute_paths=False)
# Control data file
control = {}
control['Package'] = pkg.package
#control['Section'] = pkg.category
control['Version'] = pkg.fullver
control['Architecture'] = platform
if maintainer:
control['Maintainer'] = maintainer
control['Description'] = pkg.description
pkgdeps = "%s" % (pkg.rdepends,)
if (pkgdeps is not None and pkgdeps != ""):
control.update(parsedeps(pkgdeps))
control_ds = text_data_source("".join("%s: %s\n" % (k, v)
for (k, v) in control.iteritems()))
control_path = pjoin(tempspace, 'control.tar.gz')
tar.write_set(
contents.contentsSet([
fs.fsFile('control',
{'size':len(control_ds.text_fileobj().getvalue())},
data=control_ds,
uid=0, gid=0, mode=0644, mtime=time.time())
]),
control_path, compressor='gz')
dbinary_path = pjoin(tempspace, 'debian-binary')
with open(dbinary_path, 'w') as f:
f.write("2.0\n")
ret = spawn(['ar', '-r', finalpath, dbinary_path, data_path, control_path])
if ret != 0:
unlink_if_exists(finalpath)
raise Exception("failed creating archive: return code %s" % (ret,))
def test_symlink_awareness(self):
src = contentsSet(self.simple_cset)
src.add(fsFile("/usr/lib/blah/donkey"))
trg = src.difference(["/usr/lib/blah/donkey"])
trg.add(fsFile("/blah/donkey"))
trg = trg.insert_offset(self.dir)
pkg = fake_pkg(src)
engine = self.kls.install(self.dir, pkg, offset=self.dir)
result = engine.csets['new_cset']
self.assertEqual(sorted(result.iterfiles()), sorted(trg.iterfiles()))
def test_symlink_awareness(self):
src = contentsSet(self.simple_cset)
src.add(fsFile("/usr/lib/blah/donkey"))
trg = src.difference(["/usr/lib/blah/donkey"])
trg.add(fsFile("/blah/donkey"))
trg = trg.insert_offset(self.dir)
pkg = fake_pkg(src)
engine = self.kls.install(self.dir, pkg, offset=self.dir)
result = engine.csets['new_cset']
self.assertEqual(sorted(result.iterfiles()), sorted(trg.iterfiles()))
def test_add_missing_directories(self):
src = [self.mk_file("/dir1/a"), self.mk_file("/dir2/dir3/b"),
self.mk_dir("/dir1/dir4")]
cs = contents.contentsSet(src)
cs.add_missing_directories()
self.assertEqual(sorted(x.location for x in cs),
['/dir1', '/dir1/a', '/dir1/dir4', '/dir2', '/dir2/dir3',
'/dir2/dir3/b'])
obj = cs['/dir1']
self.assertEqual(obj.mode, 0o775)
def test_contains(self):
cs = contents.contentsSet(mutable=True)
for x in [y[0] for y in [
self.files, self.dirs, self.links, self.devs, self.fifos]]:
self.assertFalse(x in cs)
self.assertFalse(x.location in cs)
cs.add(x)
self.assertTrue(x in cs)
self.assertTrue(x.location in cs)
cs.remove(x)
def test_map_directory_structure(self):
old = contents.contentsSet([self.mk_dir("/dir"),
self.mk_link("/sym", "dir")])
new = contents.contentsSet([self.mk_file("/sym/a"),
self.mk_dir("/sym")])
# verify the machinery is working as expected.
ret = new.map_directory_structure(old)
self.assertEqual(sorted(ret), sorted([self.mk_dir("/dir"),
self.mk_file("/dir/a")]))
# test recursion next.
old.add(self.mk_link("/dir/sym", "dir2"))
old.add(self.mk_dir("/dir/dir2"))
new.add(self.mk_file("/dir/sym/b"))
new.add(self.mk_dir("/sym/sym"))
ret = new.map_directory_structure(old)
self.assertEqual(sorted(ret), sorted([self.mk_dir("/dir"),
self.mk_file("/dir/a"), self.mk_dir("/dir/dir2"),
self.mk_file("/dir/dir2/b")]))
def write(tempspace,
finalpath,
pkg,
cset=None,
platform='',
maintainer='',
compressor='gz'):
# The debian-binary file
if cset is None:
cset = pkg.contents
# The data.tar.gz file
data_path = pjoin(tempspace, 'data.tar.gz')
tar.write_set(cset, data_path, compressor='gz', absolute_paths=False)
# Control data file
control = {}
control['Package'] = pkg.package
#control['Section'] = pkg.category
control['Version'] = pkg.fullver
control['Architecture'] = platform
if maintainer:
control['Maintainer'] = maintainer
control['Description'] = pkg.description
pkgdeps = "%s" % (pkg.rdepend, )
if (pkgdeps is not None and pkgdeps != ""):
control.update(parsedeps(pkgdeps))
control_ds = text_data_source("".join("%s: %s\n" % (k, v)
for (k, v) in control.items()))
control_path = pjoin(tempspace, 'control.tar.gz')
tar.write_set(contents.contentsSet([
fs.fsFile('control',
{'size': len(control_ds.text_fileobj().getvalue())},
data=control_ds,
uid=0,
gid=0,
mode=0o644,
mtime=time.time())
]),
control_path,
compressor='gz')
dbinary_path = pjoin(tempspace, 'debian-binary')
with open(dbinary_path, 'w') as f:
f.write("2.0\n")
ret = spawn(['ar', '-r', finalpath, dbinary_path, data_path, control_path])
if ret != 0:
unlink_if_exists(finalpath)
raise Exception("failed creating archive: return code %s" % (ret, ))
def check_set_op(self, name, ret, source=None):
if source is None:
source = [[fs.fsDir("/tmp", strict=False)],
[fs.fsFile("/tmp", strict=False)]]
c1, c2 = [contents.contentsSet(x) for x in source]
if name.endswith("_update"):
getattr(c1, name)(c2)
c3 = c1
else:
c3 = getattr(c1, name)(c2)
self.assertEqual(set(ret), set(x.location for x in c3))
c1, c2 = [contents.contentsSet(x) for x in source]
if name.endswith("_update"):
getattr(c1, name)(iter(c2))
c3 = c1
else:
c3 = getattr(c1, name)(iter(c2))
self.assertEqual(set(ret), set(x.location for x in c3))
def test_callback(self):
for attr in dir(self):
if not attr.startswith('entries') or 'fail' in attr:
continue
e = getattr(self, attr)
if not isinstance(e, dict):
continue
src, dest, cset = self.generic_merge_bits(e)
new_cset = contents.contentsSet(contents.offset_rewriter(dest, cset))
s = set(new_cset)
ops.merge_contents(cset, offset=dest, callback=s.remove)
self.assertFalse(s)
def test_sym_over_dir(self):
path = pjoin(self.dir, "sym")
fp = pjoin(self.dir, "trg")
os.mkdir(path)
# test sym over a directory.
f = fs.fsSymlink(path, fp, mode=0644, mtime=0, uid=os.getuid(),
gid=os.getgid())
cset = contents.contentsSet([f])
self.assertRaises(ops.FailedCopy, ops.merge_contents, cset)
self.assertTrue(fs.isdir(livefs.gen_obj(path)))
os.mkdir(fp)
ops.merge_contents(cset)
def test_rewrite_awareness(self):
src = contentsSet(self.simple_cset)
src.add(fsFile("/usr/lib/donkey"))
trg = src.difference(["/usr/lib/donkey"])
trg.add(fsFile("/usr/lib64/donkey"))
trg = trg.insert_offset(self.dir)
os.mkdir(pjoin(self.dir, 'usr'))
os.mkdir(pjoin(self.dir, 'usr', 'lib64'))
os.symlink('lib64', pjoin(self.dir, 'usr', 'lib'))
pkg = fake_pkg(src)
engine = self.kls.install(self.dir, pkg, offset=self.dir)
result = engine.csets['resolved_install']
self.assertEqual(sorted(result.iterfiles()), sorted(trg.iterfiles()))
def test_rewrite_awareness(self):
src = contentsSet(self.simple_cset)
src.add(fsFile("/usr/lib/donkey"))
trg = src.difference(["/usr/lib/donkey"])
trg.add(fsFile("/usr/lib64/donkey"))
trg = trg.insert_offset(self.dir)
os.mkdir(pjoin(self.dir, 'usr'))
os.mkdir(pjoin(self.dir, 'usr', 'lib64'))
os.symlink('lib64', pjoin(self.dir, 'usr', 'lib'))
pkg = fake_pkg(src)
engine = self.kls.install(self.dir, pkg, offset=self.dir)
result = engine.csets['resolved_install']
self.assertEqual(sorted(result.iterfiles()), sorted(trg.iterfiles()))
def test_init(self):
self.assertEqual(len(self.all), len(contents.contentsSet(self.all)))
self.assertRaises(TypeError, contents.contentsSet, self.all + [1])
contents.contentsSet(self.all)
contents.contentsSet(self.all, mutable=True)
# test to ensure no one screwed up the optional initials
# making it mandatory
self.assertEqual(len(contents.contentsSet()), 0)
def check_set_op(self, name, ret, source=None):
if source is None:
source = [[fs.fsDir("/tmp", strict=False)],
[fs.fsFile("/tmp", strict=False)]]
c1, c2 = [contents.contentsSet(x) for x in source]
if name.endswith("_update"):
getattr(c1, name)(c2)
c3 = c1
else:
c3 = getattr(c1, name)(c2)
self.assertEqual(
set(ret),
set(x.location for x in c3))
c1, c2 = [contents.contentsSet(x) for x in source]
if name.endswith("_update"):
getattr(c1, name)(iter(c2))
c3 = c1
else:
c3 = getattr(c1, name)(iter(c2))
self.assertEqual(
set(ret),
set(x.location for x in c3))
def _split_setup(self, engine, cset):
skip = frozenset(['strip', 'splitdebug'
]).intersection(getattr(engine.new, 'restrict', ()))
skip = bool(skip)
if not skip:
for fs_obj in cset:
if fs_obj.basename.endswith(".debug"):
skip = True
break
if skip:
engine.observer.info(
f"splitdebug disabled for {engine.new}, skipping splitdebug")
return False
self._initialize_paths(engine.new, ("strip", "objcopy"))
self._modified = contents.contentsSet()
return True
def copy_main(options, out, err):
"""Copy pkgs between repos."""
source_repo = options.source_repo
if source_repo is None:
source_repo = options.domain.all_source_repos
target_repo = options.target_repo
failures = False
for pkg in source_repo.itermatch(options.query):
if options.ignore_existing and pkg.versioned_atom in target_repo:
out.write(f"skipping existing pkg: {pkg.cpvstr}")
continue
# TODO: remove this once we limit src repos to non-virtual (pkg.provided) repos
if not getattr(pkg, 'package_is_real', True):
out.write(f"skipping virtual pkg: {pkg.cpvstr}")
continue
out.write(f"copying {pkg}... ")
if getattr(getattr(pkg, 'repo', None), 'livefs', False):
out.write("forcing regen of contents due to src being livefs..")
new_contents = contents.contentsSet(mutable=True)
for fsobj in pkg.contents:
try:
new_contents.add(livefs.gen_obj(fsobj.location))
except FileNotFoundError:
err.write(
f"warning: dropping fs obj {fsobj!r} since it doesn't exist")
except OSError as oe:
err.write(
f"failed accessing fs obj {fsobj!r}; {oe}\n"
"aborting this copy")
failures = True
new_contents = None
break
if new_contents is None:
continue
pkg = mutated.MutatedPkg(pkg, {'contents': new_contents})
target_repo.operations.install_or_replace(pkg).finish()
out.write("completed\n")
if failures:
return 1
return 0
def assertContents(self, cset=()):
orig = sorted(cset)
new = contentsSet(orig)
self.trigger(fake_engine(mode=const.INSTALL_MODE), {'new_cset': new})
new = sorted(new)
self.assertEqual(len(orig), len(new))
for x, y in izip(orig, new):
self.assertEqual(orig.__class__, new.__class__)
for attr in x.__attrs__:
if self.attr == attr:
val = getattr(x, attr)
if self.bad_val is not None and val == self.bad_val:
self.assertEqual(self.good_val(val), getattr(y, attr))
else:
self.assertEqual(self.good_val(val), getattr(y, attr))
elif attr != 'chksums':
# abuse self as unique singleton.
self.assertEqual(getattr(x, attr, self),
getattr(y, attr, self))
def iterobj(self, name, obj_class=None, forced_name=None):
s = set(getattr(self, name))
cs = contents.contentsSet(s)
if forced_name is None:
forced_name = "iter"+name
s2 = set(getattr(cs, forced_name)())
if obj_class is not None:
map(post_curry(self.assertTrue, obj_class), s2)
self.assertEqual(s, s2)
if forced_name == "__iter__":
return
# inversion tests now.
s3 = set(getattr(cs, forced_name)(invert=True))
if obj_class is not None:
map(post_curry(self.assertFalse, obj_class), s3)
self.assertEqual(s.symmetric_difference(s2), s3)
def assertContents(self, cset=()):
orig = sorted(cset)
new = contentsSet(orig)
self.trigger(fake_engine(mode=const.INSTALL_MODE),
{'new_cset':new})
new = sorted(new)
self.assertEqual(len(orig), len(new))
for x, y in izip(orig, new):
self.assertEqual(orig.__class__, new.__class__)
for attr in x.__attrs__:
if self.attr == attr:
val = getattr(x, attr)
if self.bad_val is not None and val == self.bad_val:
self.assertEqual(self.good_val(val), getattr(y, attr))
else:
self.assertEqual(self.good_val(val), getattr(y, attr))
elif attr != 'chksums':
# abuse self as unique singleton.
self.assertEqual(getattr(x, attr, self),
getattr(y, attr, self))
def iterobj(self, name, obj_class=None, forced_name=None):
s = set(getattr(self, name))
cs = contents.contentsSet(s)
if forced_name is None:
forced_name = "iter" + name
s2 = set(getattr(cs, forced_name)())
if obj_class is not None:
map(post_curry(self.assertTrue, obj_class), s2)
self.assertEqual(s, s2)
if forced_name == "__iter__":
return
# inversion tests now.
s3 = set(getattr(cs, forced_name)(invert=True))
if obj_class is not None:
map(post_curry(self.assertFalse, obj_class), s3)
self.assertEqual(s.symmetric_difference(s2), s3)
def set_state(self, locations, stat_func=os.stat, forced_past=2):
"""
set the initial state; will adjust ondisk mtimes as needed
to avoid race potentials.
:param locations: sequence, file paths to scan
:param stat_func: stat'er to use. defaults to os.stat
"""
self.locations = locations
mtimes = list(self._scan_mtimes(locations, stat_func))
cset = contents.contentsSet(mtimes)
now = time.time()
pause_cutoff = floor(now)
past = float(max(pause_cutoff - forced_past, 0))
resets = [x for x in mtimes if x.mtime > past]
for x in resets:
cset.add(x.change_attributes(mtime=past))
os.utime(x.location, (past, past))
self.saved_mtimes = cset
def test_inode_map(self):
def check_it(target):
d = {k: sorted(v) for k, v in cs.inode_map().iteritems()}
target = {k: sorted(v) for k, v in target.iteritems()}
self.assertEqual(d, target)
cs = contents.contentsSet()
f1 = self.mk_file("/f", dev=1, inode=1)
cs.add(f1)
check_it({(1, 1): [f1]})
f2 = self.mk_file("/x", dev=1, inode=2)
cs.add(f2)
check_it({(1, 1): [f1], (1, 2): [f2]})
f3 = self.mk_file("/y", dev=2, inode=1)
cs.add(f3)
check_it({(1, 1): [f1], (1, 2): [f2], (2, 1): [f3]})
f4 = self.mk_file("/z", dev=1, inode=1)
cs.add(f4)
check_it({(1, 1): [f1, f4], (1, 2): [f2], (2, 1): [f3]})
def test_inode_map(self):
def check_it(target):
d = {k: sorted(v) for k, v in cs.inode_map().items()}
target = {k: sorted(v) for k, v in target.items()}
self.assertEqual(d, target)
cs = contents.contentsSet()
f1 = self.mk_file("/f", dev=1, inode=1)
cs.add(f1)
check_it({(1,1):[f1]})
f2 = self.mk_file("/x", dev=1, inode=2)
cs.add(f2)
check_it({(1,1):[f1], (1,2):[f2]})
f3 = self.mk_file("/y", dev=2, inode=1)
cs.add(f3)
check_it({(1,1):[f1], (1,2):[f2], (2,1):[f3]})
f4 = self.mk_file("/z", dev=1, inode=1)
cs.add(f4)
check_it({(1,1):[f1, f4], (1,2):[f2], (2,1):[f3]})
def test_child_nodes(self):
self.assertEqual(sorted(['/usr', '/usr/bin', '/usr/foo']),
sorted(x.location for x in contents.contentsSet(
[self.mk_dir("/usr"), self.mk_dir("/usr/bin"),
self.mk_file("/usr/foo")])))
def test_len(self):
self.assertEqual(len(contents.contentsSet(self.all)), len(self.all))
def test_clear(self):
cs = contents.contentsSet(self.all, mutable=True)
self.assertTrue(len(cs))
cs.clear()
self.assertEqual(len(cs), 0)
def _get_livefs_intersect_cset(engine, csets, cset_name, realpath=False):
"""generates the livefs intersection against a cset"""
return contents.contentsSet(livefs.intersect(csets[cset_name],
realpath=realpath))
def run(fs_objs, fix_perms=False):
self.kls(fix_perms=fix_perms).trigger(engine,
contentsSet(fs_objs))
def run(func):
new = contentsSet(orig)
self.kls(func)(engine, {'new_cset':new})
return new
