def test_patch(self):
"""Test combining 3 iters of metadata rorps"""
self.make_temp()
xcopytree(os.path.join(old_test_dir, b"various_file_types"),
tempdir.path,
content=True)
rp1 = tempdir.append('regular_file')
rp2 = tempdir.append('subdir')
rp3 = rp2.append('subdir_file')
rp4 = tempdir.append('test')
rp1new = tempdir.append('regular_file')
rp1new.chmod(0)
zero = rpath.RORPath(('test', ))
current = [rp1, rp2, rp3]
diff1 = [rp1, rp4]
diff2 = [rp1new, rp2, zero]
Globals.rbdir = tempdir
output = meta_mgr.PatchDiffMan()._iterate_patched_attr(
[iter(current), iter(diff1),
iter(diff2)])
out1 = next(output)
self.assertIs(out1, rp1new)
out2 = next(output)
self.assertIs(out2, rp2)
out3 = next(output)
self.assertIs(out3, rp3)
self.assertRaises(StopIteration, output.__next__)
def attach_files(cls, src_iter, mirror_rp, inc_rp, compare_time):
"""Attach data to all the files that need checking
Return an iterator of repo rorps that includes all the files
that may have changed, and has the fileobj set on all rorps
that need it.
"""
repo_iter = cls.init_and_get_iter(mirror_rp, inc_rp, compare_time)
base_index = cls.mirror_base.index
for src_rorp, mir_rorp in rorpiter.Collate2Iters(src_iter, repo_iter):
index = src_rorp and src_rorp.index or mir_rorp.index
if src_rorp and mir_rorp:
if not src_rorp.isreg() and src_rorp == mir_rorp:
_log_success(src_rorp, mir_rorp)
continue # They must be equal, nothing else to check
if (src_rorp.isreg() and mir_rorp.isreg()
and src_rorp.getsize() == mir_rorp.getsize()):
fp = cls.rf_cache.get_fp(base_index + index, mir_rorp)
mir_rorp.setfile(fp)
mir_rorp.set_attached_filetype('snapshot')
if mir_rorp:
yield mir_rorp
else:
yield rpath.RORPath(index) # indicate deleted mir_rorp
def test_patch(self):
"""Test combining 3 iters of metadata rorps"""
self.make_temp()
os.system('cp -a testfiles/various_file_types/* ' + tempdir.path)
rp1 = tempdir.append('regular_file')
rp2 = tempdir.append('subdir')
rp3 = rp2.append('subdir_file')
rp4 = tempdir.append('test')
rp1new = tempdir.append('regular_file')
rp1new.chmod(0)
zero = rpath.RORPath(('test',))
current = [rp1, rp2, rp3]
diff1 = [rp1, rp4]
diff2 = [rp1new, rp2, zero]
Globals.rbdir = tempdir
output = PatchDiffMan().iterate_patched_meta(
[iter(current), iter(diff1), iter(diff2)])
out1 = output.next()
assert out1 is rp1new, out1
out2 = output.next()
assert out2 is rp2, out2
out3 = output.next()
assert out3 is rp3, out3
self.assertRaises(StopIteration, output.next)
def test_patch(self):
"""Test combining 3 iters of metadata rorps"""
self.make_temp()
# shutil.copytree fails on the fifo file in the directory
os.system(
'cp -a %s/* %s' %
(os.path.join(old_test_dir, "various_file_types"), tempdir.path))
rp1 = tempdir.append('regular_file')
rp2 = tempdir.append('subdir')
rp3 = rp2.append('subdir_file')
rp4 = tempdir.append('test')
rp1new = tempdir.append('regular_file')
rp1new.chmod(0)
zero = rpath.RORPath(('test', ))
current = [rp1, rp2, rp3]
diff1 = [rp1, rp4]
diff2 = [rp1new, rp2, zero]
Globals.rbdir = tempdir
output = PatchDiffMan().iterate_patched_meta(
[iter(current), iter(diff1),
iter(diff2)])
out1 = next(output)
assert out1 is rp1new, out1
out2 = next(output)
assert out2 is rp2, out2
out3 = next(output)
assert out3 is rp3, out3
self.assertRaises(StopIteration, output.__next__)
def _get_one_sig(cls, dest_base_rpath, index, src_rorp, dest_rorp):
"""Return a signature given source and destination rorps"""
if (Globals.preserve_hardlinks and src_rorp
and Hardlink.is_linked(src_rorp)):
dest_sig = rpath.RORPath(index)
dest_sig.flaglinked(Hardlink.get_link_index(src_rorp))
elif dest_rorp:
dest_sig = dest_rorp.getRORPath()
if dest_rorp.isreg():
dest_rp = longname.get_mirror_rp(dest_base_rpath, dest_rorp)
sig_fp = cls._get_one_sig_fp(dest_rp)
if sig_fp is None:
return None
dest_sig.setfile(sig_fp)
else:
dest_sig = rpath.RORPath(index)
return dest_sig
def get_diffs(cls, dest_sigiter):
"""
Return diffs of any files with signature in dest_sigiter
"""
source_rps = cls._select
error_handler = robust.get_error_handler("ListError")
def attach_snapshot(diff_rorp, src_rp):
"""Attach file of snapshot to diff_rorp, w/ error checking"""
fileobj = robust.check_common_error(error_handler,
rpath.RPath.open,
(src_rp, "rb"))
if fileobj:
diff_rorp.setfile(hash.FileWrapper(fileobj))
else:
diff_rorp.zero()
diff_rorp.set_attached_filetype('snapshot')
def attach_diff(diff_rorp, src_rp, dest_sig):
"""Attach file of diff to diff_rorp, w/ error checking"""
fileobj = robust.check_common_error(error_handler,
Rdiff.get_delta_sigrp_hash,
(dest_sig, src_rp))
if fileobj:
diff_rorp.setfile(fileobj)
diff_rorp.set_attached_filetype('diff')
else:
diff_rorp.zero()
diff_rorp.set_attached_filetype('snapshot')
for dest_sig in dest_sigiter:
if dest_sig is iterfile.MiscIterFlushRepeat:
yield iterfile.MiscIterFlush # Flush buffer when get_sigs does
continue
src_rp = (source_rps.get(dest_sig.index)
or rpath.RORPath(dest_sig.index))
diff_rorp = src_rp.getRORPath()
if dest_sig.isflaglinked():
diff_rorp.flaglinked(dest_sig.get_link_flag())
elif src_rp.isreg():
reset_perms = False
if (Globals.process_uid != 0 and not src_rp.readable()
and src_rp.isowner()):
reset_perms = True
src_rp.chmod(0o400 | src_rp.getperms())
if dest_sig.isreg():
attach_diff(diff_rorp, src_rp, dest_sig)
else:
attach_snapshot(diff_rorp, src_rp)
if reset_perms:
src_rp.chmod(src_rp.getperms() & ~0o400)
else:
dest_sig.close_if_necessary()
diff_rorp.set_attached_filetype('snapshot')
yield diff_rorp
def _get_diffiter(self, new_iter, old_iter):
"""
Iterate meta diffs of new_iter -> old_iter
"""
for new_rorp, old_rorp in rorpiter.Collate2Iters(new_iter, old_iter):
if not old_rorp:
yield rpath.RORPath(new_rorp.index)
elif not new_rorp or new_rorp.data != old_rorp.data:
# exact compare here, can't use == on rorps
yield old_rorp
def _record_to_object(cls, record_string):
"""
Given record_string, return RORPath
For speed reasons, write the RORPath data dictionary directly
instead of calling rorpath functions. Profiling has shown this to
be a time critical function.
"""
data_dict = {}
for field, data in cls.line_parsing_regexp.findall(record_string):
field = field.decode('ascii')
if field in cls._integer_mapping:
data_dict[cls._integer_mapping[field]] = int(data)
elif field in cls._decode_mapping:
if data == b":" or data == b"None":
data_dict[cls._decode_mapping[field]] = None
else:
data_dict[cls._decode_mapping[field]] = data.decode(
'ascii')
elif field == "File":
index = cls._filename_to_index(data)
elif field == "ResourceFork":
if data == b"None":
data_dict['resourcefork'] = b""
else:
data_dict['resourcefork'] = binascii.unhexlify(data)
elif field == "CarbonFile":
if data == b"None":
data_dict['carbonfile'] = None
else:
data_dict['carbonfile'] = _string2carbonfile(data)
elif field == "SymData":
data_dict['linkname'] = quoting.unquote_path(data)
elif field == "DeviceNum":
devchar, major_str, minor_str = data.split(b" ")
data_dict['devnums'] = (devchar.decode('ascii'),
int(major_str), int(minor_str))
elif field == "AlternateMirrorName":
data_dict['mirrorname'] = data
elif field == "AlternateIncrementName":
data_dict['incname'] = data
else:
log.Log(
"Unknown field in line field/data '{uf}/{ud}'".format(
uf=field, ud=data), log.WARNING)
return rpath.RORPath(index, data_dict)
def set_metadata_rorp(self, metadata_rorp):
"""Set self.metadata_rorp, creating empty if given None"""
if metadata_rorp:
self.metadata_rorp = metadata_rorp
else:
self.metadata_rorp = rpath.RORPath(self.index)
