Пример #1
0
    def test_non_root(self):
        """Main non-root -> root test"""
        input_rp1, input_rp2 = self.make_root_dirs()
        Globals.change_ownership = 1
        output_rp = rpath.RPath(Globals.local_connection, abs_output_dir)
        re_init_rpath_dir(output_rp, userid)
        restore_rp = rpath.RPath(Globals.local_connection, abs_restore_dir)
        empty_rp = rpath.RPath(Globals.local_connection,
                               os.path.join(old_test_dir, b"empty"))

        self.backup(input_rp1, output_rp, 1000000)
        self.restore(output_rp, restore_rp)
        assert CompareRecursive(input_rp1, restore_rp, compare_ownership=1)

        self.backup(input_rp2, output_rp, 2000000)
        self.restore(output_rp, restore_rp)
        assert CompareRecursive(input_rp2, restore_rp, compare_ownership=1)

        self.backup(empty_rp, output_rp, 3000000)
        self.restore(output_rp, restore_rp)
        assert CompareRecursive(empty_rp, restore_rp, compare_ownership=1)

        self.restore(output_rp, restore_rp, 1000000)
        assert CompareRecursive(input_rp1, restore_rp, compare_ownership=1)

        self.restore(output_rp, restore_rp, 2000000)
        assert CompareRecursive(input_rp2, restore_rp, compare_ownership=1)
Пример #2
0
    def test_final_local(self):
        """Test backing up and restoring using 'rdiff-backup' script"""
        self.make_backup_dirs()
        self.make_temp_out_dirs()
        rdiff_backup(1,
                     1,
                     self.ea_test1_rpath.path,
                     tempdir.path,
                     current_time=10000)
        assert CompareRecursive(self.ea_test1_rpath, tempdir, compare_eas=1)

        rdiff_backup(1,
                     1,
                     self.ea_test2_rpath.path,
                     tempdir.path,
                     current_time=20000)
        assert CompareRecursive(self.ea_test2_rpath, tempdir, compare_eas=1)

        rdiff_backup(1,
                     1,
                     tempdir.path,
                     restore_dir.path,
                     extra_options=b'-r 10000')
        assert CompareRecursive(self.ea_test1_rpath,
                                restore_dir,
                                compare_eas=1)
Пример #3
0
    def restore_dir_test(self, mirror_local, dest_local):
        """Run whole dir tests

        If any of the above tests don't work, try rerunning
        makerestoretest3.

        """
        Myrm(abs_output_dir)
        restore3_dir = os.path.join(old_test_dir, b"restoretest3")
        target_rp = rpath.RPath(Globals.local_connection, abs_output_dir)
        inc1_rp = rpath.RPath(Globals.local_connection,
                              os.path.join(old_test_dir, b"increment1"))
        inc2_rp = rpath.RPath(Globals.local_connection,
                              os.path.join(old_test_dir, b"increment2"))
        inc3_rp = rpath.RPath(Globals.local_connection,
                              os.path.join(old_test_dir, b"increment3"))
        inc4_rp = rpath.RPath(Globals.local_connection,
                              os.path.join(old_test_dir, b"increment4"))

        InternalRestore(mirror_local, dest_local, restore3_dir, abs_output_dir,
                        45000)
        assert CompareRecursive(inc4_rp, target_rp)
        InternalRestore(mirror_local, dest_local, restore3_dir, abs_output_dir,
                        35000)
        assert CompareRecursive(inc3_rp, target_rp, compare_hardlinks=0)
        InternalRestore(mirror_local, dest_local, restore3_dir, abs_output_dir,
                        25000)
        assert CompareRecursive(inc2_rp, target_rp, compare_hardlinks=0)
        InternalRestore(mirror_local, dest_local, restore3_dir, abs_output_dir,
                        5000)
        assert CompareRecursive(inc1_rp, target_rp, compare_hardlinks=0)
Пример #4
0
 def testEquality(self):
     """Test rorp_eq function in conjunction with CompareRecursive"""
     assert CompareRecursive(self.hlinks_rp1, self.hlinks_rp1copy)
     assert CompareRecursive(self.hlinks_rp1,
                             self.hlinks_rp2,
                             compare_hardlinks=None)
     assert not CompareRecursive(
         self.hlinks_rp1, self.hlinks_rp2, compare_hardlinks=1)
Пример #5
0
    def testWindowsMode(self):
        """Test backup with quoting enabled

        We need to delete from the increment? directories long file
        names, because quoting adds too many extra letters.

        """

        def delete_long(base_rp, length=100):
            """Delete filenames longer than length given"""
            for rp in selection.Select(base_rp).set_iter():
                if len(rp.dirsplit()[1]) > length:
                    rp.delete()

        if not Local.wininc2.lstat() or not Local.wininc3.lstat():
            os.system(b"cp -a testfiles/increment2 testfiles/win-increment2")
            os.system(b"cp -a testfiles/increment3 testfiles/win-increment3")
            delete_long(Local.wininc2)
            delete_long(Local.wininc3)

        old_schema = self.rb_schema
        self.rb_schema = old_schema + b" --override-chars-to-quote '^a-z0-9_ -.' "
        self.set_connections(None, None, None, None)

        self.delete_tmpdirs()
        # Back up increment2, this contains a file with colons
        self.exec_rb(20000, b'testfiles/win-increment2', b'testfiles/output')
        self.rb_schema = old_schema  # Quoting setting should now be saved
        time.sleep(1)

        # Back up increment3
        self.exec_rb(30000, b'testfiles/win-increment3', b'testfiles/output')

        # Now check to make sure no ":" in output directory
        popen_fp = os.popen(b"find testfiles/output -name '*:*' | wc")
        wc_output = popen_fp.read()
        popen_fp.close()
        assert wc_output.split() == [b"0", b"0", b"0"], wc_output

        # Start restore of increment 2
        Globals.chars_to_quote = b'^a-z0-9_ -.'
        inc_paths = self.getinc_paths(b"increments.",
                                      b"testfiles/output/rdiff-backup-data", 1)
        Globals.chars_to_quote = None
        assert len(inc_paths) == 1, inc_paths
        self.exec_rb(None, inc_paths[0], b'testfiles/restoretarget2')
        assert CompareRecursive(Local.wininc2,
                                Local.rpout2,
                                compare_hardlinks=0)

        # Restore increment 3 again, using different syntax
        self.rb_schema = old_schema + b'-r 30000 '
        self.exec_rb(None, b'testfiles/output', b'testfiles/restoretarget3')
        assert CompareRecursive(Local.wininc3,
                                Local.rpout3,
                                compare_hardlinks=0)
        self.rb_schema = old_schema
Пример #6
0
 def testLegacy(self):
     """Test restoring directory with no mirror_metadata file"""
     self.delete_tmpdirs()
     rdiff_backup(True,
                  True,
                  Local.vftrp.path,
                  Local.rpout.path,
                  current_time=10000)
     rdiff_backup(True,
                  True,
                  Local.emptyrp.path,
                  Local.rpout.path,
                  current_time=20000)
     # remove mirror_metadata files to simulate old style backups
     # pathlib.Path doesn't work with bytes hence need to work with str path
     for mirror_file in pathlib.Path(
             os.fsdecode(Local.rpout.append(
                 b'rdiff-backup-data').path)).glob('mirror_metadata*'):
         mirror_file.unlink()
     rdiff_backup(True,
                  True,
                  Local.rpout.path,
                  Local.rpout1.path,
                  extra_options=b'-r0')
     assert CompareRecursive(Local.vftrp, Local.rpout1, compare_hardlinks=0)
Пример #7
0
    def make_root_dirs(self):
        """Make directory createable only by root"""
        rp = rpath.RPath(Globals.local_connection,
                         os.path.join(abs_test_dir, b"root_out1"))
        re_init_rpath_dir(rp)
        rp1 = rp.append("1")
        rp1.touch()
        rp2 = rp.append("2")
        rp2.touch()
        rp2.chown(1, 1)
        rp3 = rp.append("3")
        rp3.touch()
        rp3.chown(2, 2)
        rp4 = rp.append("dev")
        rp4.makedev('c', 4, 28)

        sp = rpath.RPath(Globals.local_connection,
                         os.path.join(abs_test_dir, b"root_out2"))
        if sp.lstat():
            Myrm(sp.path)
        Run(b"cp -a %s %s" % (rp.path, sp.path))
        rp2 = sp.append("2")
        rp2.chown(2, 2)
        rp3 = sp.append("3")
        rp3.chown(1, 1)
        assert not CompareRecursive(rp, sp, compare_ownership=1)

        return rp, sp
Пример #8
0
    def compare_no_times(self, src_rp, dest_rp):
        """Compare but disregard directories attributes"""
        def equal(src_rorp, dest_rorp):
            return ((src_rorp.isdir() and dest_rorp.isdir())
                    or src_rorp == dest_rorp)

        return CompareRecursive(src_rp, dest_rp, None, equal)
Пример #9
0
    def test_backup(self):
        """Test back up, simple restores"""
        in_rp1, in_rp2 = self.make_dirs()
        outrp = rpath.RPath(Globals.local_connection, abs_output_dir)
        re_init_rpath_dir(outrp, userid)
        remote_schema = b'su -c "rdiff-backup --server" %s' % (user.encode(), )
        cmd_schema = (b"rdiff-backup -v%i" % verbosity +
                      b" --current-time %i --remote-schema '%%s' %b '%b'::%b")

        cmd1 = cmd_schema % (10000, in_rp1.path, remote_schema, outrp.path)
        Run(cmd1)
        in_rp1.setdata()
        outrp.setdata()

        cmd2 = cmd_schema % (20000, in_rp2.path, remote_schema, outrp.path)
        Run(cmd2)
        in_rp2.setdata()
        outrp.setdata()

        rout_rp = rpath.RPath(Globals.local_connection, abs_restore_dir)
        restore_schema = (b"rdiff-backup -v%i" % verbosity +
                          b" -r %b --remote-schema '%%s' '%b'::%b %b")
        Myrm(rout_rp.path)
        cmd3 = restore_schema % (b'10000', remote_schema, outrp.path,
                                 rout_rp.path)
        Run(cmd3)
        assert CompareRecursive(in_rp1, rout_rp)
        rout_perms = rout_rp.append('unreadable_dir').getperms()
        outrp_perms = outrp.append('unreadable_dir').getperms()
        assert rout_perms == 0, rout_perms
        assert outrp_perms == 0, outrp_perms

        Myrm(rout_rp.path)
        cmd4 = restore_schema % (b"now", remote_schema, outrp.path,
                                 rout_rp.path)
        Run(cmd4)
        assert CompareRecursive(in_rp2, rout_rp)
        rout_perms = rout_rp.append('unreadable_dir').getperms()
        outrp_perms = outrp.append('unreadable_dir').getperms()
        assert rout_perms == 0, rout_perms
        assert outrp_perms == 0, outrp_perms

        self.cause_regress(outrp)
        cmd5 = (b'su -c "rdiff-backup --check-destination-dir %s" %s' %
                (outrp.path, user.encode()))
        Run(cmd5)
Пример #10
0
 def cycle_once(min_max_time_pair, curtime, input_rp, old_rp):
     """Backup input_rp, kill, regress, and then compare"""
     time.sleep(1)
     self.exec_and_kill(min_max_time_pair, curtime, input_rp.path,
                        Local.rpout.path)
     result = self.mark_incomplete(curtime, Local.rpout)
     assert not self.exec_rb(None, 1, '--check-destination-dir',
                             Local.rpout.path)
     assert CompareRecursive(old_rp, Local.rpout, compare_hardlinks=0)
     return result
Пример #11
0
    def runtest(self, regress_function):
        """Test regressing a full directory to older state

        Make two directories, one with one more backup in it.  Then
        regress the bigger one, and then make sure they compare the
        same.

        Regress_function takes a time and should regress
        self.output_rp back to that time.

        """
        self.output_rp.setdata()
        if self.output_rp.lstat():
            Myrm(self.output_rp.path)

        rdiff_backup(1,
                     1,
                     self.incrp[0].path,
                     self.output_rp.path,
                     current_time=10000)
        assert CompareRecursive(self.incrp[0], self.output_rp)

        rdiff_backup(1,
                     1,
                     self.incrp[1].path,
                     self.output_rp.path,
                     current_time=20000)
        assert CompareRecursive(self.incrp[1], self.output_rp)

        rdiff_backup(1,
                     1,
                     self.incrp[2].path,
                     self.output_rp.path,
                     current_time=30000)
        assert CompareRecursive(self.incrp[2], self.output_rp)

        rdiff_backup(1,
                     1,
                     self.incrp[3].path,
                     self.output_rp.path,
                     current_time=40000)
        assert CompareRecursive(self.incrp[3], self.output_rp)

        Globals.rbdir = self.output_rbdir_rp

        regress_function(30000)
        assert CompareRecursive(self.incrp[2],
                                self.output_rp,
                                compare_hardlinks=0)
        regress_function(20000)
        assert CompareRecursive(self.incrp[1],
                                self.output_rp,
                                compare_hardlinks=0)
        regress_function(10000)
        assert CompareRecursive(self.incrp[0],
                                self.output_rp,
                                compare_hardlinks=0)
Пример #12
0
 def testProcLocalToRemote(self):
     """Test mirroring proc remote"""
     procout_dir = os.path.join(abs_test_dir, b"procoutput")
     Myrm(procout_dir)
     procout = rpath.RPath(Globals.local_connection, procout_dir)
     rdiff_backup(True, False, '/proc', procout.path, current_time=10000)
     time.sleep(1)
     rdiff_backup(True, False, '/proc', procout.path, current_time=20000)
     time.sleep(1)
     rdiff_backup(True,
                  False,
                  Local.inc1rp.path,
                  procout.path,
                  current_time=30000)
     assert CompareRecursive(Local.inc1rp, procout)
     time.sleep(1)
     rdiff_backup(True, False, '/proc', procout.path, current_time=40000)
Пример #13
0
 def test_long_socket_name(self):
     """Test when socket name is saved to a backup directory with a long name
     It addresses an issue where socket wasn't created with mknod but
     with socket.socket and bind, which has a limit at 107 characters."""
     input_dir = os.path.join(old_test_dir, b"select", b"filetypes")
     # create a target directory with a long name next to 107
     output_dir = os.path.join(abs_test_dir, b"tenletters" * 10)
     Myrm(output_dir)
     restore_dir = os.path.join(abs_test_dir, b"restoresme" * 10)
     Myrm(restore_dir)
     # backup and restore the input directory with socket, then compare
     rdiff_backup(True, True, input_dir, output_dir)
     rdiff_backup(True,
                  True,
                  output_dir,
                  restore_dir,
                  extra_options=b'-r 0')
     CompareRecursive(rpath.RPath(Globals.local_connection, input_dir),
                      rpath.RPath(Globals.local_connection, restore_dir))
Пример #14
0
    def testTerm(self):
        """Run rdiff-backup, termining and regressing each time

        Because rdiff-backup must be killed, the timing should be
        updated

        """
        count, killed_too_soon, killed_too_late = 5, [0] * 4, [0] * 4
        self.delete_tmpdirs()
        # Back up killtest3 first because it is big and the first case
        # is kind of special (there's no incrementing, so different
        # code)
        self.exec_rb(10000, 1, Local.ktrp[2].path, Local.rpout.path)
        assert CompareRecursive(Local.ktrp[2], Local.rpout)

        def cycle_once(min_max_time_pair, curtime, input_rp, old_rp):
            """Backup input_rp, kill, regress, and then compare"""
            time.sleep(1)
            self.exec_and_kill(min_max_time_pair, curtime, input_rp.path,
                               Local.rpout.path)
            result = self.mark_incomplete(curtime, Local.rpout)
            assert not self.exec_rb(None, 1, '--check-destination-dir',
                                    Local.rpout.path)
            assert CompareRecursive(old_rp, Local.rpout, compare_hardlinks=0)
            return result

        # Keep backing ktrp[0], and then regressing to ktrp[2].  Then go to ktrp[0]
        for i in range(count):
            result = cycle_once(self.time_pairs[1], 20000, Local.ktrp[0],
                                Local.ktrp[2])
            if result == 0:
                killed_too_late[0] += 1
            elif result == -1:
                killed_too_soon[0] += 1
        self.exec_rb(20000, 1, Local.ktrp[0].path, Local.rpout.path)

        # Now keep regressing from ktrp[1], only staying there at the end
        for i in range(count):
            result = cycle_once(self.time_pairs[2], 30000, Local.ktrp[1],
                                Local.ktrp[0])
            if result == 0:
                killed_too_late[1] += 1
            elif result == -1:
                killed_too_soon[1] += 1
        self.exec_rb(30000, 1, Local.ktrp[1].path, Local.rpout.path)

        # Now keep regressing from ktrp[2], only staying there at the end
        for i in range(count):
            result = cycle_once(self.time_pairs[3], 40000, Local.ktrp[2],
                                Local.ktrp[1])
            if result == 0:
                killed_too_late[2] += 1
            elif result == -1:
                killed_too_soon[2] += 1
        self.exec_rb(40000, 1, Local.ktrp[2].path, Local.rpout.path)

        # Now keep regressing from ktrp[3], only staying there at the end
        for i in range(count):
            result = cycle_once(self.time_pairs[4], 50000, Local.ktrp[3],
                                Local.ktrp[2])
            if result == 0:
                killed_too_late[3] += 1
            elif result == -1:
                killed_too_soon[3] += 1

        print("Killed too soon out of %s: %s" % (count, killed_too_soon))
        print("Killed too late out of %s: %s" % (count, killed_too_late))
Пример #15
0
    def runtest(self, from_local, to_local):
        self.delete_tmpdirs()

        # Backing up increment1
        rdiff_backup(from_local,
                     to_local,
                     Local.inc1rp.path,
                     Local.rpout.path,
                     current_time=10000)
        assert CompareRecursive(Local.inc1rp, Local.rpout)
        time.sleep(1)

        # Backing up increment2
        rdiff_backup(from_local,
                     to_local,
                     Local.inc2rp.path,
                     Local.rpout.path,
                     current_time=20000)
        assert CompareRecursive(Local.inc2rp, Local.rpout)
        time.sleep(1)

        # Backing up increment3
        rdiff_backup(from_local,
                     to_local,
                     Local.inc3rp.path,
                     Local.rpout.path,
                     current_time=30000)
        assert CompareRecursive(Local.inc3rp, Local.rpout)
        time.sleep(1)

        # Backing up increment4
        rdiff_backup(from_local,
                     to_local,
                     Local.inc4rp.path,
                     Local.rpout.path,
                     current_time=40000)
        assert CompareRecursive(Local.inc4rp, Local.rpout)

        # Getting restore rps
        inc_paths = self.getinc_paths(
            b"increments.", os.path.join(Local.rpout.path,
                                         b"rdiff-backup-data"))
        assert len(inc_paths) == 3

        # Restoring increment1
        rdiff_backup(from_local, to_local, inc_paths[0], Local.rpout1.path)
        assert CompareRecursive(Local.inc1rp, Local.rpout1)

        # Restoring increment2
        rdiff_backup(from_local, to_local, inc_paths[1], Local.rpout2.path)
        assert CompareRecursive(Local.inc2rp, Local.rpout2)

        # Restoring increment3
        rdiff_backup(from_local, to_local, inc_paths[2], Local.rpout3.path)
        assert CompareRecursive(Local.inc3rp, Local.rpout3)

        # Test restoration of a few random files
        vft_paths = self.getinc_paths(
            b"various_file_types.",
            os.path.join(Local.rpout.path, b"rdiff-backup-data",
                         b"increments"))
        rdiff_backup(from_local, to_local, vft_paths[1], Local.vft_out.path)
        self.refresh(Local.vft_in, Local.vft_out)
        assert CompareRecursive(Local.vft_in, Local.vft_out)

        timbar_paths = self.getinc_paths(
            b"timbar.pyc.",
            os.path.join(Local.rpout.path, b"rdiff-backup-data",
                         b"increments"))
        rdiff_backup(from_local, to_local, timbar_paths[0],
                     Local.timbar_out.path)
        self.refresh(Local.timbar_in, Local.timbar_out)
        assert Local.timbar_in.equal_loose(Local.timbar_out)

        rdiff_backup(from_local,
                     to_local,
                     Local.rpout.append('various_file_types').path,
                     Local.vft_recover.path,
                     extra_options=b"--restore-as-of 25000")
        self.refresh(Local.vft_recover, Local.vft_in)
        assert CompareRecursive(Local.vft_recover, Local.vft_in)

        # Make sure too many increment files not created
        assert len(
            self.getinc_paths(
                b"nochange.",
                os.path.join(Local.rpout.path, b"rdiff-backup-data",
                             b"increments"))) == 0
        nochange_incs = len(
            self.getinc_paths(
                b"",
                os.path.join(Local.rpout.path, b"rdiff-backup-data",
                             b"increments", b"nochange")))
        assert nochange_incs == 1 or nochange_incs == 0, nochange_incs