示例#1
0
 def setUp(self):
     super(TestHeketiServerStateExamineGluster, self).setUp()
     self.node = self.ocp_master_node[0]
     version = heketi_version.get_heketi_version(self.heketi_client_node)
     if version < '8.0.0-7':
         self.skipTest("heketi-client package %s does not support server "
                       "state examine gluster" % version.v_str)
示例#2
0
 def setUp(self):
     super(TestHeketiMetrics, self).setUp()
     self.node = self.ocp_master_node[0]
     version = heketi_version.get_heketi_version(self.heketi_client_node)
     if version < '6.0.0-14':
         self.skipTest("heketi-client package %s does not support heketi "
                       "metrics functionality" % version.v_str)
示例#3
0
    def _block_vol_expand_common_offline_vs_online(self, is_online_expand):
        node = self.ocp_master_node[0]
        h_node, h_server = self.heketi_client_node, self.heketi_server_url

        version = heketi_version.get_heketi_version(h_node)
        if version < '9.0.0-14':
            self.skipTest("heketi-client package {} does not support "
                          "blockvolume expand".format(version.v_str))

        pvc_name = self.create_and_wait_for_pvc()
        dc_name = self.create_dc_with_pvc(pvc_name)
        pv_name = get_pv_name_from_pvc(node, pvc_name)

        # get block volume id
        custom = r":.metadata.annotations.'gluster\.org\/volume-id'"
        bvol_id = oc_get_custom_resource(node, 'pv', custom, pv_name)
        self.assertNotEqual(bvol_id[0], "<none>",
                            "volume name not found from pv {}".format(pv_name))
        bvol_info = heketi_blockvolume_info(h_node,
                                            h_server,
                                            bvol_id[0],
                                            json=True)

        # verify required blockhostingvolume free size
        bhv_id = bvol_info["blockhostingvolume"]
        bhv_info = heketi_volume_info(h_node, h_server, bhv_id, json=True)
        if bhv_info["blockinfo"]["freesize"] < 1:
            self.skipTest("blockhostingvolume doesn't have required freespace")

        if not is_online_expand:
            scale_dc_pod_amount_and_wait(node, dc_name[0], pod_amount=0)

        # expand block volume and verify usable size
        bvol_info = heketi_blockvolume_expand(h_node,
                                              h_server,
                                              bvol_id[0],
                                              2,
                                              json=True)
        self.assertEqual(bvol_info["size"], 2,
                         "Block volume expand does not works")
        self.assertEqual(
            bvol_info["size"], bvol_info["usablesize"],
            "block volume size is not equal to the usablesize: {}".format(
                bvol_info))

        return pvc_name, dc_name, bvol_info
示例#4
0
    def setUp(self):
        super(TestHeketiLvmWrapper, self).setUp()

        self.oc_node = self.ocp_master_node[0]
        self.pod_name = openshift_ops.get_ocp_gluster_pod_details(self.oc_node)
        self.h_pod_name = openshift_ops.get_pod_name_from_dc(
            self.oc_node, self.heketi_dc_name)
        self.volume_size = 2

        ocp_version = openshift_version.get_openshift_version()
        if ocp_version < "3.11.170":
            self.skipTest("Heketi LVM Wrapper functionality does not "
                          "support on OCP {}".format(ocp_version.v_str))
        h_version = heketi_version.get_heketi_version(self.heketi_client_node)
        if h_version < '9.0.0-9':
            self.skipTest("heketi-client package {} does not support Heketi "
                          "LVM Wrapper functionality".format(h_version.v_str))
    def test_gluster_block_log_rotation(self):
        "Verify log-rotation for gluster-block logs on independent mode"

        if self.is_containerized_gluster():
            self.skipTest(
                "Skipping this test case as it is not independent mode setup")

        version = heketi_version.get_heketi_version(self.heketi_client_node)
        if (version < '9.0.0-14'):
            self.skipTest(
                "This test case is not supported for < heketi 9.0.0-14 version"
                " due to bug BZ-1790788")

        # Get system current date and time
        get_system_time = "date '+%F %T'"

        # Get current system date & time
        exec_time = command.cmd_run(get_system_time, hostname=self.g_node)
        exec_time = datetime.datetime.strptime(exec_time, self.timeformat)

        # Set log level to debug or higher level
        self._set_log_level(self.g_node, 5, 'DEBUG SCSI CMD', exec_time)

        # Get initial size on file gluster-block log
        cmd = 'ls -lh {} | cut -d " " -f5'.format(TCMU_RUNNER_LOG)
        initial_log_size = command.cmd_run(cmd, hostname=self.g_node)

        # Create PVCs and pod with I/O
        pvc_names = self.create_and_wait_for_pvcs(pvc_amount=5)
        self.create_dcs_with_pvc(pvc_names)

        # Get log size after PVC create
        after_log_size = command.cmd_run(cmd, hostname=self.g_node)
        self.assertGreaterEqual(
            after_log_size, initial_log_size,
            "gluster-block log size has not changed")

        # Rotate logs manually
        log_rotate_cmd = "logrotate -vf {}".format(TCMU_ROTATE_LOG)
        command.cmd_run(log_rotate_cmd, hostname=self.g_node)

        # Get log size after log rotate
        final_log_size = command.cmd_run(cmd, hostname=self.g_node)
        self.assertLess(
            final_log_size, after_log_size,
            "Failed: log rotation is unsuccessful")
示例#6
0
    def setUp(self):
        super(TestArbiterVolumeCreateExpandDelete, self).setUp()
        self.node = self.ocp_master_node[0]
        if openshift_version.get_openshift_version() < "3.9":
            self.skipTest("Arbiter feature cannot be used on OCP older "
                          "than 3.9, because 'volumeoptions' for Heketi "
                          "is not supported there.")
        version = heketi_version.get_heketi_version(self.heketi_client_node)
        if version < '6.0.0-11':
            self.skipTest("heketi-client package %s does not support arbiter "
                          "functionality" % version.v_str)

        # Mark one of the Heketi nodes as arbiter-supported if none of
        # existent nodes or devices already enabled to support it.
        self.heketi_server_url = self.sc.get('resturl')
        arbiter_tags = ('required', 'supported')
        arbiter_already_supported = False

        self.node_id_list = heketi_ops.heketi_node_list(
            self.heketi_client_node, self.heketi_server_url)

        for node_id in self.node_id_list[::-1]:
            node_info = heketi_ops.heketi_node_info(self.heketi_client_node,
                                                    self.heketi_server_url,
                                                    node_id,
                                                    json=True)
            if node_info.get('tags', {}).get('arbiter') in arbiter_tags:
                arbiter_already_supported = True
                break
            for device in node_info['devices'][::-1]:
                if device.get('tags', {}).get('arbiter') in arbiter_tags:
                    arbiter_already_supported = True
                    break
            else:
                continue
            break
        if not arbiter_already_supported:
            self._set_arbiter_tag_with_further_revert(self.heketi_client_node,
                                                      self.heketi_server_url,
                                                      'node',
                                                      self.node_id_list[0],
                                                      'supported')
示例#7
0
    def setUp(self):
        super(TestHeketiBrickEvict, self).setUp()

        version = heketi_version.get_heketi_version(self.heketi_client_node)
        if version < '9.0.0-14':
            self.skipTest(
                "heketi-client package {} does not support brick evict".format(
                    version.v_str))

        node_list = heketi_ops.heketi_node_list(self.heketi_client_node,
                                                self.heketi_server_url)

        if len(node_list) > 3:
            return

        for node_id in node_list:
            node_info = heketi_ops.heketi_node_info(self.heketi_client_node,
                                                    self.heketi_server_url,
                                                    node_id,
                                                    json=True)
            if len(node_info["devices"]) < 2:
                self.skipTest("does not have extra device/node to evict brick")
    def setUp(self):
        super(TestArbiterVolumeCreateExpandDelete, self).setUp()
        self.node = self.ocp_master_node[0]
        if get_openshift_version() < "3.9":
            self.skipTest("Arbiter feature cannot be used on OCP older "
                          "than 3.9, because 'volumeoptions' for Heketi "
                          "is not supported there.")
        version = heketi_version.get_heketi_version(self.heketi_client_node)
        if version < '6.0.0-11':
            self.skipTest("heketi-client package %s does not support arbiter "
                          "functionality" % version.v_str)

        # Mark one of the Heketi nodes as arbiter-supported if none of
        # existent nodes or devices already enabled to support it.
        self.heketi_server_url = self.sc.get('resturl')
        arbiter_tags = ('required', 'supported')
        arbiter_already_supported = False

        self.node_id_list = heketi_ops.heketi_node_list(
            self.heketi_client_node, self.heketi_server_url)

        for node_id in self.node_id_list[::-1]:
            node_info = heketi_ops.heketi_node_info(
                self.heketi_client_node, self.heketi_server_url,
                node_id, json=True)
            if node_info.get('tags', {}).get('arbiter') in arbiter_tags:
                arbiter_already_supported = True
                break
            for device in node_info['devices'][::-1]:
                if device.get('tags', {}).get('arbiter') in arbiter_tags:
                    arbiter_already_supported = True
                    break
            else:
                continue
            break
        if not arbiter_already_supported:
            self._set_arbiter_tag_with_further_revert(
                self.heketi_client_node, self.heketi_server_url,
                'node', self.node_id_list[0], 'supported')
 def setUp(self):
     self.node = self.ocp_master_node[0]
     version = heketi_version.get_heketi_version(self.heketi_client_node)
     if version < '6.0.0-14':
         self.skipTest("heketi-client package %s does not support heketi "
                       "metrics functionality" % version.v_str)
 def setUp(self):
     self.node = self.ocp_master_node[0]
     version = heketi_version.get_heketi_version(self.heketi_client_node)
     if version < '8.0.0-7':
         self.skipTest("heketi-client package %s does not support server "
                       "state examine gluster" % version.v_str)