def testTreeReducerState(self):
"""Test saving and recreation of an IterTreeReducer"""
itm1a = rorpiter.IterTreeReducer(ITRBadder, [])
for index in self.i1a:
val = itm1a(index)
assert val, index
itm1b = pickle.loads(pickle.dumps(itm1a))
for index in self.i1b:
val = itm1b(index)
assert val, index
itm1b.Finish()
assert itm1b.root_branch.total == 6, itm1b.root_branch.total
itm2a = rorpiter.IterTreeReducer(ITRBadder2, [])
for index in self.i2a:
val = itm2a(index)
if index == (): assert not val
else: assert val
itm2b = pickle.loads(pickle.dumps(itm2a))
for index in self.i2b:
val = itm2b(index)
if index == (): assert not val
else: assert val
itm2c = pickle.loads(pickle.dumps(itm2b))
for index in self.i2c:
val = itm2c(index)
if index == (): assert not val
else: assert val
itm2c.Finish()
assert itm2c.root_branch.total == 12, itm2c.root_branch.total
def Regress(mirror_rp):
"""Bring mirror and inc directory back to regress_to_time
Also affects the rdiff-backup-data directory, so Globals.rbdir
should be set. Regress should only work one step at a time
(i.e. don't "regress" through two separate backup sets. This
function should be run locally to the rdiff-backup-data directory.
"""
inc_rpath = Globals.rbdir.append_path(b"increments")
assert mirror_rp.index == () and inc_rpath.index == (), (
"Mirror and increment paths must have an empty index")
assert mirror_rp.isdir() and inc_rpath.isdir(), (
"Mirror and increments paths must be directories")
assert mirror_rp.conn is inc_rpath.conn is Globals.local_connection, (
"Regress must happen locally.")
meta_manager, former_current_mirror_rp = _set_regress_time()
_set_restore_times()
_regress_rbdir(meta_manager)
ITR = rorpiter.IterTreeReducer(RegressITRB, [])
for rf in _iterate_meta_rfs(mirror_rp, inc_rpath):
ITR(rf.index, rf)
ITR.finish_processing()
if former_current_mirror_rp:
if Globals.do_fsync:
C.sync() # Sync first, since we are marking dest dir as good now
former_current_mirror_rp.delete()
def testTreeReducer(self):
"""testing IterTreeReducer"""
itm = rorpiter.IterTreeReducer(ITRBadder, [])
for index in self.i1:
val = itm(index)
assert val, (val, index)
itm.Finish()
assert itm.root_branch.total == 6, itm.root_branch.total
itm2 = rorpiter.IterTreeReducer(ITRBadder2, [])
for index in self.i2:
val = itm2(index)
if index == (): assert not val
else: assert val
itm2.Finish()
assert itm2.root_branch.total == 12, itm2.root_branch.total
def testTreeReducer(self):
"""testing IterTreeReducer"""
itm = rorpiter.IterTreeReducer(ITRBadder, [])
for index in self.i1:
val = itm(index)
self.assertTrue(val)
itm.finish_processing()
self.assertEqual(itm.root_branch.total, 6)
itm2 = rorpiter.IterTreeReducer(ITRBadder2, [])
for index in self.i2:
val = itm2(index)
if index == ():
self.assertFalse(val)
else:
self.assertTrue(val)
itm2.finish_processing()
self.assertEqual(itm2.root_branch.total, 12)
def patch(cls, dest_rpath, source_diffiter, start_index=()):
"""Patch dest_rpath with an rorpiter of diffs"""
ITR = rorpiter.IterTreeReducer(PatchITRB, [dest_rpath, cls.CCPP])
for diff in rorpiter.FillInIter(source_diffiter, dest_rpath):
log.Log("Processing file {cf}".format(cf=diff), log.INFO)
ITR(diff.index, diff)
ITR.finish_processing()
cls.CCPP.close()
dest_rpath.setdata()
def patch_and_increment(cls, dest_rpath, source_diffiter, inc_rpath):
"""Patch dest_rpath with rorpiter of diffs and write increments"""
ITR = rorpiter.IterTreeReducer(IncrementITRB,
[dest_rpath, inc_rpath, cls.CCPP])
for diff in rorpiter.FillInIter(source_diffiter, dest_rpath):
log.Log("Processing changed file {cf}".format(cf=diff), log.INFO)
ITR(diff.index, diff)
ITR.finish_processing()
cls.CCPP.close()
dest_rpath.setdata()
def testTreeReducerState(self):
"""Test saving and recreation of an IterTreeReducer"""
itm1a = rorpiter.IterTreeReducer(ITRBadder, [])
for index in self.i1a:
val = itm1a(index)
self.assertTrue(val)
itm1b = pickle.loads(pickle.dumps(itm1a))
for index in self.i1b:
val = itm1b(index)
self.assertTrue(val)
itm1b.finish_processing()
self.assertEqual(itm1b.root_branch.total, 6)
itm2a = rorpiter.IterTreeReducer(ITRBadder2, [])
for index in self.i2a:
val = itm2a(index)
if index == ():
self.assertFalse(val)
else:
self.assertTrue(val)
itm2b = pickle.loads(pickle.dumps(itm2a))
for index in self.i2b:
val = itm2b(index)
if index == ():
self.assertFalse(val)
else:
self.assertTrue(val)
itm2c = pickle.loads(pickle.dumps(itm2b))
for index in self.i2c:
val = itm2c(index)
if index == ():
self.assertFalse(val)
else:
self.assertTrue(val)
itm2c.finish_processing()
self.assertEqual(itm2c.root_branch.total, 12)
def patch(cls, target, diff_iter):
"""
Patch target with the diffs from the mirror side
This function and the associated ITRB is similar to the
patching code in backup.py, but they have different error
correction requirements, so it seemed easier to just repeat it
all in this module.
"""
ITR = rorpiter.IterTreeReducer(_DirPatchITRB, [target])
for diff in rorpiter.FillInIter(diff_iter, target):
log.Log("Processing changed file {cf}".format(cf=diff), log.INFO)
ITR(diff.index, diff)
ITR.finish_processing()
target.setdata()
