Ejemplo n.º 1
0
    def test_populate_tokenmap(self):
        node_backups = list()
        node_backups.append(Mock())
        with open("tests/resources/restore_cluster_tokenmap.json", 'r') as f:
            with open("tests/resources/restore_cluster_tokenmap.target.json",
                      'r') as f_target:
                tokenmap = json.loads(f.read())
                cluster_backup = MagicMock()
                restoreJob = RestoreJob(cluster_backup,
                                        self.medusa_config,
                                        self.tmp_dir,
                                        None,
                                        "node1.mydomain.net",
                                        False,
                                        False,
                                        None,
                                        bypass_checks=True)

                target_tokenmap = json.loads(f_target.read())
                restoreJob._populate_ringmap(tokenmap, target_tokenmap)
                assert restoreJob.use_sstableloader is False

        assert restoreJob.host_map["node4.mydomain.net"]['source'] == [
            "node1.mydomain.net"
        ]
        assert restoreJob.host_map["node5.mydomain.net"]['source'] == [
            "node2.mydomain.net"
        ]
        assert restoreJob.host_map["node6.mydomain.net"]['source'] == [
            "node3.mydomain.net"
        ]
Ejemplo n.º 2
0
 def test_populate_ringmap_catches_mismatching_tokens_when_using_vnodes(self):
     node_backups = list()
     node_backups.append(Mock())
     with open("tests/resources/restore_cluster_tokenmap_vnodes.json", 'r') as f:
         with open("tests/resources/restore_cluster_tokenmap_vnodes_target_fail.json", 'r') as f_target:
             tokenmap = json.loads(f.read())
             cluster_backup = MagicMock()
             restore_job = RestoreJob(
                 cluster_backup, self.medusa_config, self.tmp_dir, None, "node1.mydomain.net", False, False, None,
                 version_target="4.0.0")
             target_tokenmap = json.loads(f_target.read())
             restore_job._populate_ringmap(tokenmap, target_tokenmap)
             # topologies are different, which forces the use of the sstableloader
             assert restore_job.use_sstableloader is True
    def test_populate_tokenmap_fail(self):
        node_backups = list()
        node_backups.append(Mock())
        with open("tests/resources/restore_cluster_tokenmap.json", 'r') as f:
            with open("tests/resources/restore_cluster_tokenmap.fail.json", 'r') as f_target:
                tokenmap = json.loads(f.read())
                cluster_backup = MagicMock()
                restoreJob = RestoreJob(
                    cluster_backup, self.config, Path('/tmp'), None, "node1.mydomain.net", False, False, None
                )

                target_tokenmap = json.loads(f_target.read())
                restoreJob._populate_ringmap(tokenmap, target_tokenmap)
                # topologies are different, which forces the use of the sstableloader
                assert restoreJob.use_sstableloader is True
    def test_populate_tokenmap(self):
        node_backups = list()
        node_backups.append(Mock())
        with open("tests/resources/restore_cluster_tokenmap.json", 'r') as f:
            with open("tests/resources/restore_cluster_tokenmap.target.json", 'r') as f_target:
                tokenmap = json.loads(f.read())
                cluster_backup = MagicMock()
                restoreJob = RestoreJob(
                    cluster_backup, self.config, Path('/tmp'), None, "node1.mydomain.net", False, False, None
                )

                target_tokenmap = json.loads(f_target.read())
                restoreJob._populate_ringmap(tokenmap, target_tokenmap)
                assert restoreJob.use_sstableloader is False

        self.assertEqual(restoreJob.host_map["node4.mydomain.net"]['source'], ["node1.mydomain.net"])
        self.assertEqual(restoreJob.host_map["node5.mydomain.net"]['source'], ["node2.mydomain.net"])
        self.assertEqual(restoreJob.host_map["node6.mydomain.net"]['source'], ["node3.mydomain.net"])
Ejemplo n.º 5
0
    def test_populate_ringmap(self, resolver_mock):

        # resolver checks for seed target w/ resolve as well.
        seed_target = "node1.mydomain.net"
        resolver_mock.side_effect = [
            'node4.mydomain.net', seed_target, 'node1.mydomain.net',
            'node5.mydomain.net', seed_target, 'node2.mydomain.net',
            'node6.mydomain.net', seed_target, 'node3.mydomain.net'
        ]

        node_backups = list()
        node_backups.append(Mock())
        with open("tests/resources/restore_cluster_tokenmap.json", 'r') as f:
            with open("tests/resources/restore_cluster_tokenmap.target.json",
                      'r') as f_target:
                tokenmap = json.loads(f.read())
                cluster_backup = MagicMock()
                restore_job = RestoreJob(cluster_backup,
                                         self.medusa_config,
                                         self.tmp_dir,
                                         None,
                                         seed_target,
                                         False,
                                         False,
                                         None,
                                         bypass_checks=True,
                                         version_target="4.0.0")

                target_tokenmap = json.loads(f_target.read())
                restore_job._populate_ringmap(tokenmap, target_tokenmap)
                assert restore_job.use_sstableloader is False

        assert restore_job.host_map["node4.mydomain.net"]['source'] == [
            "node1.mydomain.net"
        ]
        assert restore_job.host_map["node5.mydomain.net"]['source'] == [
            "node2.mydomain.net"
        ]
        assert restore_job.host_map["node6.mydomain.net"]['source'] == [
            "node3.mydomain.net"
        ]