X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/b5a93c7336c09d2c62280e9956f3072ff281aa24..cabc869c4f04c46ec4fd486f531b4db16f54b348:/qa/qa_cluster.py diff --git a/qa/qa_cluster.py b/qa/qa_cluster.py index 1e4ff86..8da65c5 100644 --- a/qa/qa_cluster.py +++ b/qa/qa_cluster.py @@ -27,12 +27,14 @@ import re import tempfile import os.path +from ganeti import _constants from ganeti import constants from ganeti import compat from ganeti import utils from ganeti import pathutils import qa_config +import qa_daemon import qa_utils import qa_error import qa_instance @@ -173,13 +175,19 @@ def TestClusterInit(rapi_user, rapi_secret): fh.close() # Initialize cluster + enabled_disk_templates = qa_config.GetEnabledDiskTemplates() cmd = [ "gnt-cluster", "init", "--primary-ip-version=%d" % qa_config.get("primary_ip_version", 4), "--enabled-hypervisors=%s" % ",".join(qa_config.GetEnabledHypervisors()), "--enabled-disk-templates=%s" % - ",".join(qa_config.GetEnabledDiskTemplates()) + ",".join(enabled_disk_templates), ] + if constants.DT_FILE in enabled_disk_templates: + cmd.append( + "--file-storage-dir=%s" % + qa_config.get("default-file-storage-dir", + pathutils.DEFAULT_FILE_STORAGE_DIR)) for spec_type in ("mem-size", "disk-size", "disk-count", "cpu-count", "nic-count"): @@ -192,9 +200,13 @@ def TestClusterInit(rapi_user, rapi_secret): if master.secondary: cmd.append("--secondary-ip=%s" % master.secondary) - vgname = qa_config.get("vg-name", None) - if vgname: - cmd.append("--vg-name=%s" % vgname) + if utils.IsLvmEnabled(qa_config.GetEnabledDiskTemplates()): + vgname = qa_config.get("vg-name", constants.DEFAULT_VG) + if vgname: + cmd.append("--vg-name=%s" % vgname) + else: + raise qa_error.Error("Please specify a volume group if you enable" + " lvm-based disk templates in the QA.") master_netdev = qa_config.get("master-netdev", None) if master_netdev: @@ -214,7 +226,13 @@ def TestClusterInit(rapi_user, rapi_secret): qa_config.SetExclusiveStorage(e_s) extra_args = qa_config.get("cluster-init-args") + if extra_args: + # This option was removed in 2.10, but in order to not break QA of older + # branches we remove it from the extra_args if it is in there. + opt_drbd_storage = "--no-drbd-storage" + if opt_drbd_storage in extra_args: + extra_args.remove(opt_drbd_storage) cmd.extend(extra_args) cmd.append(qa_config.get("name")) @@ -343,6 +361,44 @@ def TestClusterVerify(): AssertCommand(["gnt-cluster", "verify-disks"]) +def TestClusterVerifyDisksBrokenDRBD(instance, inst_nodes): + """gnt-cluster verify-disks with broken DRBD""" + qa_daemon.TestPauseWatcher() + + try: + info = qa_instance.GetInstanceInfo(instance.name) + snode = inst_nodes[1] + for idx, minor in enumerate(info["drbd-minors"][snode.primary]): + if idx % 2 == 0: + break_drbd_cmd = \ + "(drbdsetup %d down >/dev/null 2>&1;" \ + " drbdsetup down resource%d >/dev/null 2>&1) || /bin/true" % \ + (minor, minor) + else: + break_drbd_cmd = \ + "(drbdsetup %d detach >/dev/null 2>&1;" \ + " drbdsetup detach %d >/dev/null 2>&1) || /bin/true" % \ + (minor, minor) + AssertCommand(break_drbd_cmd, node=snode) + + verify_output = GetCommandOutput(qa_config.GetMasterNode().primary, + "gnt-cluster verify-disks") + activation_msg = "Activating disks for instance '%s'" % instance.name + if activation_msg not in verify_output: + raise qa_error.Error("gnt-cluster verify-disks did not activate broken" + " DRBD disks:\n%s" % verify_output) + + verify_output = GetCommandOutput(qa_config.GetMasterNode().primary, + "gnt-cluster verify-disks") + if activation_msg in verify_output: + raise qa_error.Error("gnt-cluster verify-disks wants to activate broken" + " DRBD disks on second attempt:\n%s" % verify_output) + + AssertCommand(_CLUSTER_VERIFY) + finally: + qa_daemon.TestResumeWatcher() + + def TestJobqueue(): """gnt-debug test-jobqueue""" AssertCommand(["gnt-debug", "test-jobqueue"]) @@ -358,6 +414,9 @@ def TestDelay(node): def TestClusterReservedLvs(): """gnt-cluster reserved lvs""" + # if no lvm-based templates are supported, skip the test + if not qa_config.IsStorageTypeSupported(constants.ST_LVM_VG): + return vgname = qa_config.get("vg-name", constants.DEFAULT_VG) lvname = _QA_LV_PREFIX + "test" lvfullname = "/".join([vgname, lvname]) @@ -391,13 +450,122 @@ def TestClusterModifyDisk(): AssertCommand(["gnt-cluster", "modify", "-D", param], fail=True) +def _GetOtherEnabledDiskTemplate(undesired_disk_templates, + enabled_disk_templates): + """Returns one template that is not in the undesired set. + + @type undesired_disk_templates: list of string + @param undesired_disk_templates: a list of disk templates that we want to + exclude when drawing one disk template from the list of enabled + disk templates + @type enabled_disk_templates: list of string + @param enabled_disk_templates: list of enabled disk templates (in QA) + + """ + desired_templates = list(set(enabled_disk_templates) + - set(undesired_disk_templates)) + if desired_templates: + template = desired_templates[0] + else: + # If no desired disk template is available for QA, choose 'diskless' and + # hope for the best. + template = constants.ST_DISKLESS + + return template + + +def TestClusterModifyFileBasedStorageDir( + file_disk_template, dir_config_key, default_dir, option_name): + """Tests gnt-cluster modify wrt to file-based directory options. + + @type file_disk_template: string + @param file_disk_template: file-based disk template + @type dir_config_key: string + @param dir_config_key: key for the QA config to retrieve the default + directory value + @type default_dir: string + @param default_dir: default directory, if the QA config does not specify + it + @type option_name: string + @param option_name: name of the option of 'gnt-cluster modify' to + change the directory + + """ + enabled_disk_templates = qa_config.GetEnabledDiskTemplates() + assert file_disk_template in [constants.DT_FILE, constants.DT_SHARED_FILE] + if not qa_config.IsTemplateSupported(file_disk_template): + return + + # Get some non-file-based disk template to disable file storage + other_disk_template = _GetOtherEnabledDiskTemplate( + utils.storage.GetDiskTemplatesOfStorageType(constants.ST_FILE), + enabled_disk_templates) + + file_storage_dir = qa_config.get(dir_config_key, default_dir) + invalid_file_storage_dir = "/boot/" + + for fail, cmd in [ + (False, ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % file_disk_template, + "--ipolicy-disk-templates=%s" % file_disk_template]), + (False, ["gnt-cluster", "modify", + "--%s=%s" % (option_name, file_storage_dir)]), + (False, ["gnt-cluster", "modify", + "--%s=%s" % (option_name, invalid_file_storage_dir)]), + # file storage dir is set to an inacceptable path, thus verify + # should fail + (True, ["gnt-cluster", "verify"]), + # unsetting the storage dir while file storage is enabled + # should fail + (True, ["gnt-cluster", "modify", + "--%s=" % option_name]), + (False, ["gnt-cluster", "modify", + "--%s=%s" % (option_name, file_storage_dir)]), + (False, ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % other_disk_template, + "--ipolicy-disk-templates=%s" % other_disk_template]), + (False, ["gnt-cluster", "modify", + "--%s=%s" % (option_name, invalid_file_storage_dir)]), + # file storage is set to an inacceptable path, but file storage + # is disabled, thus verify should not fail + (False, ["gnt-cluster", "verify"]), + # unsetting the file storage dir while file storage is not enabled + # should be fine + (False, ["gnt-cluster", "modify", + "--%s=" % option_name]), + # resetting everything to sane values + (False, ["gnt-cluster", "modify", + "--%s=%s" % (option_name, file_storage_dir), + "--enabled-disk-templates=%s" % ",".join(enabled_disk_templates), + "--ipolicy-disk-templates=%s" % ",".join(enabled_disk_templates)]) + ]: + AssertCommand(cmd, fail=fail) + + +def TestClusterModifyFileStorageDir(): + """gnt-cluster modify --file-storage-dir=...""" + TestClusterModifyFileBasedStorageDir( + constants.DT_FILE, "default-file-storage-dir", + pathutils.DEFAULT_FILE_STORAGE_DIR, + "file-storage-dir") + + +def TestClusterModifySharedFileStorageDir(): + """gnt-cluster modify --shared-file-storage-dir=...""" + TestClusterModifyFileBasedStorageDir( + constants.DT_SHARED_FILE, "default-shared-file-storage-dir", + pathutils.DEFAULT_SHARED_FILE_STORAGE_DIR, + "shared-file-storage-dir") + + def TestClusterModifyDiskTemplates(): """gnt-cluster modify --enabled-disk-templates=...""" enabled_disk_templates = qa_config.GetEnabledDiskTemplates() default_disk_template = qa_config.GetDefaultDiskTemplate() - _TestClusterModifyDiskTemplatesArguments(default_disk_template, - enabled_disk_templates) + _TestClusterModifyDiskTemplatesArguments(default_disk_template) + _TestClusterModifyDiskTemplatesDrbdHelper(enabled_disk_templates) + _TestClusterModifyDiskTemplatesVgName(enabled_disk_templates) _RestoreEnabledDiskTemplates() nodes = qa_config.AcquireManyNodes(2) @@ -405,7 +573,6 @@ def TestClusterModifyDiskTemplates(): instance_template = enabled_disk_templates[0] instance = qa_instance.CreateInstanceByDiskTemplate(nodes, instance_template) - _TestClusterModifyUnusedDiskTemplate(instance_template) _TestClusterModifyUsedDiskTemplate(instance_template, enabled_disk_templates) @@ -420,25 +587,76 @@ def _RestoreEnabledDiskTemplates(): other tests. """ - AssertCommand( - ["gnt-cluster", "modify", - "--enabled-disk-template=%s" % - ",".join(qa_config.GetEnabledDiskTemplates())], - fail=False) + enabled_disk_templates = qa_config.GetEnabledDiskTemplates() + cmd = ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % ",".join(enabled_disk_templates), + "--ipolicy-disk-templates=%s" % ",".join(enabled_disk_templates), + ] + + if utils.IsLvmEnabled(qa_config.GetEnabledDiskTemplates()): + vgname = qa_config.get("vg-name", constants.DEFAULT_VG) + cmd.append("--vg-name=%s" % vgname) + + AssertCommand(cmd, fail=False) + +def _TestClusterModifyDiskTemplatesDrbdHelper(enabled_disk_templates): + """Tests argument handling of 'gnt-cluster modify' with respect to + the parameter '--drbd-usermode-helper'. This test is independent + of instances. + + """ + _RestoreEnabledDiskTemplates() + + if constants.DT_DRBD8 not in enabled_disk_templates: + return + if constants.DT_PLAIN not in enabled_disk_templates: + return -def _TestClusterModifyDiskTemplatesArguments(default_disk_template, - enabled_disk_templates): + drbd_usermode_helper = qa_config.get("drbd-usermode-helper", "/bin/true") + bogus_usermode_helper = "/tmp/pinkbunny" + for command, fail in [ + (["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % constants.DT_DRBD8, + "--ipolicy-disk-templates=%s" % constants.DT_DRBD8], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=%s" % drbd_usermode_helper], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=%s" % bogus_usermode_helper], True), + # unsetting helper when DRBD is enabled should not work + (["gnt-cluster", "modify", + "--drbd-usermode-helper="], True), + (["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % constants.DT_PLAIN, + "--ipolicy-disk-templates=%s" % constants.DT_PLAIN], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper="], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=%s" % drbd_usermode_helper], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=%s" % drbd_usermode_helper, + "--enabled-disk-templates=%s" % constants.DT_DRBD8, + "--ipolicy-disk-templates=%s" % constants.DT_DRBD8], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=", + "--enabled-disk-templates=%s" % constants.DT_PLAIN, + "--ipolicy-disk-templates=%s" % constants.DT_PLAIN], False), + (["gnt-cluster", "modify", + "--drbd-usermode-helper=%s" % drbd_usermode_helper, + "--enabled-disk-templates=%s" % constants.DT_DRBD8, + "--ipolicy-disk-templates=%s" % constants.DT_DRBD8], False), + ]: + AssertCommand(command, fail=fail) + _RestoreEnabledDiskTemplates() + + +def _TestClusterModifyDiskTemplatesArguments(default_disk_template): """Tests argument handling of 'gnt-cluster modify' with respect to the parameter '--enabled-disk-templates'. This test is independent of instances. """ - AssertCommand( - ["gnt-cluster", "modify", - "--enabled-disk-template=%s" % - ",".join(enabled_disk_templates)], - fail=False) + _RestoreEnabledDiskTemplates() # bogus templates AssertCommand(["gnt-cluster", "modify", @@ -449,9 +667,93 @@ def _TestClusterModifyDiskTemplatesArguments(default_disk_template, AssertCommand( ["gnt-cluster", "modify", "--enabled-disk-templates=%s,%s" % - (default_disk_template, default_disk_template)], + (default_disk_template, default_disk_template), + "--ipolicy-disk-templates=%s" % default_disk_template], + fail=False) + + +def _TestClusterModifyDiskTemplatesVgName(enabled_disk_templates): + """Tests argument handling of 'gnt-cluster modify' with respect to + the parameter '--enabled-disk-templates' and '--vg-name'. This test is + independent of instances. + + """ + if not utils.IsLvmEnabled(enabled_disk_templates): + # These tests only make sense if lvm is enabled for QA + return + + # determine an LVM and a non-LVM disk template for the tests + non_lvm_template = _GetOtherEnabledDiskTemplate(constants.DTS_LVM, + enabled_disk_templates) + lvm_template = list(set(enabled_disk_templates) & constants.DTS_LVM)[0] + + vgname = qa_config.get("vg-name", constants.DEFAULT_VG) + + # Clean start: unset volume group name, disable lvm storage + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % non_lvm_template, + "--ipolicy-disk-templates=%s" % non_lvm_template, + "--vg-name="], + fail=False) + + # Try to enable lvm, when no volume group is given + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % lvm_template, + "--ipolicy-disk-templates=%s" % lvm_template], + fail=True) + + # Set volume group, with lvm still disabled: just a warning + AssertCommand(["gnt-cluster", "modify", "--vg-name=%s" % vgname], fail=False) + + # Try unsetting vg name and enabling lvm at the same time + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % lvm_template, + "--ipolicy-disk-templates=%s" % lvm_template, + "--vg-name="], + fail=True) + + # Enable lvm with vg name present + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % lvm_template, + "--ipolicy-disk-templates=%s" % lvm_template], fail=False) + # Try unsetting vg name with lvm still enabled + AssertCommand(["gnt-cluster", "modify", "--vg-name="], fail=True) + + # Disable lvm with vg name still set + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % non_lvm_template, + "--ipolicy-disk-templates=%s" % non_lvm_template, + ], + fail=False) + + # Try unsetting vg name with lvm disabled + AssertCommand(["gnt-cluster", "modify", "--vg-name="], fail=False) + + # Set vg name and enable lvm at the same time + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % lvm_template, + "--ipolicy-disk-templates=%s" % lvm_template, + "--vg-name=%s" % vgname], + fail=False) + + # Unset vg name and disable lvm at the same time + AssertCommand( + ["gnt-cluster", "modify", + "--enabled-disk-templates=%s" % non_lvm_template, + "--ipolicy-disk-templates=%s" % non_lvm_template, + "--vg-name="], + fail=False) + + _RestoreEnabledDiskTemplates() + def _TestClusterModifyUsedDiskTemplate(instance_template, enabled_disk_templates): @@ -465,31 +767,15 @@ def _TestClusterModifyUsedDiskTemplate(instance_template, new_disk_templates = list(set(enabled_disk_templates) - set([instance_template])) if not new_disk_templates: - new_disk_templates = list(set(constants.DISK_TEMPLATES) + new_disk_templates = list(set([constants.DT_DISKLESS, constants.DT_BLOCK]) - set([instance_template])) AssertCommand( ["gnt-cluster", "modify", - "--enabled-disk-templates=%s" % - ",".join(new_disk_templates)], + "--enabled-disk-templates=%s" % ",".join(new_disk_templates), + "--ipolicy-disk-templates=%s" % ",".join(new_disk_templates)], fail=True) -def _TestClusterModifyUnusedDiskTemplate(instance_template): - """Tests that unused disk templates can be disabled safely.""" - all_disk_templates = constants.DISK_TEMPLATES - AssertCommand( - ["gnt-cluster", "modify", - "--enabled-disk-templates=%s" % - ",".join(all_disk_templates)], - fail=False) - new_disk_templates = [instance_template] - AssertCommand( - ["gnt-cluster", "modify", - "--enabled-disk-templates=%s" % - ",".join(new_disk_templates)], - fail=False) - - def TestClusterModifyBe(): """gnt-cluster modify -B""" for fail, cmd in [ @@ -532,30 +818,17 @@ def _GetClusterIPolicy(): @rtype: tuple @return: (policy, specs), where: - policy is a dictionary of the policy values, instance specs excluded - - specs is dict of dict, specs[par][key] is a spec value, where key is - "min", "max", or "std" + - specs is a dictionary containing only the specs, using the internal + format (see L{constants.IPOLICY_DEFAULTS} for an example) """ info = qa_utils.GetObjectInfo(["gnt-cluster", "info"]) policy = info["Instance policy - limits for instances"] - ret_specs = {} - ret_policy = {} - ispec_keys = constants.ISPECS_MINMAX_KEYS | frozenset([constants.ISPECS_STD]) - for (key, val) in policy.items(): - if key in ispec_keys: - for (par, pval) in val.items(): - if par == "memory-size": - par = "mem-size" - d = ret_specs.setdefault(par, {}) - d[key] = pval - else: - ret_policy[key] = val + (ret_policy, ret_specs) = qa_utils.ParseIPolicy(policy) # Sanity checks - assert len(ret_specs) > 0 - good = all("min" in d and "std" in d and "max" in d - for d in ret_specs.values()) - assert good, "Missing item in specs: %s" % ret_specs + assert "minmax" in ret_specs and "std" in ret_specs + assert len(ret_specs["minmax"]) > 0 assert len(ret_policy) > 0 return (ret_policy, ret_specs) @@ -589,9 +862,14 @@ def TestClusterModifyIPolicy(): continue AssertEqual(eff_policy[p], old_policy[p]) + # Allowing disk templates via ipolicy requires them to be + # enabled on the cluster. + if not (qa_config.IsTemplateSupported(constants.DT_PLAIN) + and qa_config.IsTemplateSupported(constants.DT_DRBD8)): + return # Disk templates are treated slightly differently par = "disk-templates" - disp_str = "enabled disk templates" + disp_str = "allowed disk templates" curr_val = old_policy[disp_str] test_values = [ (True, constants.DT_PLAIN), @@ -617,54 +895,40 @@ def TestClusterModifyIPolicy(): AssertEqual(eff_policy[p], old_policy[p]) -def TestClusterSetISpecs(new_specs, fail=False, old_values=None): +def TestClusterSetISpecs(new_specs=None, diff_specs=None, fail=False, + old_values=None): """Change instance specs. - @type new_specs: dict of dict - @param new_specs: new_specs[par][key], where key is "min", "max", "std". It - can be an empty dictionary. + At most one of new_specs or diff_specs can be specified. + + @type new_specs: dict + @param new_specs: new complete specs, in the same format returned by + L{_GetClusterIPolicy} + @type diff_specs: dict + @param diff_specs: partial specs, it can be an incomplete specifications, but + if min/max specs are specified, their number must match the number of the + existing specs @type fail: bool @param fail: if the change is expected to fail @type old_values: tuple @param old_values: (old_policy, old_specs), as returned by - L{_GetClusterIPolicy} + L{_GetClusterIPolicy} @return: same as L{_GetClusterIPolicy} """ - if old_values: - (old_policy, old_specs) = old_values - else: - (old_policy, old_specs) = _GetClusterIPolicy() - if new_specs: - cmd = ["gnt-cluster", "modify"] - for (par, keyvals) in new_specs.items(): - if par == "spindle-use": - # ignore spindle-use, which is not settable - continue - cmd += [ - "--specs-%s" % par, - ",".join(["%s=%s" % (k, v) for (k, v) in keyvals.items()]), - ] - AssertCommand(cmd, fail=fail) - # Check the new state - (eff_policy, eff_specs) = _GetClusterIPolicy() - AssertEqual(eff_policy, old_policy) - if fail: - AssertEqual(eff_specs, old_specs) - else: - for par in eff_specs: - for key in eff_specs[par]: - if par in new_specs and key in new_specs[par]: - AssertEqual(int(eff_specs[par][key]), int(new_specs[par][key])) - else: - AssertEqual(int(eff_specs[par][key]), int(old_specs[par][key])) - return (eff_policy, eff_specs) + build_cmd = lambda opts: ["gnt-cluster", "modify"] + opts + return qa_utils.TestSetISpecs( + new_specs=new_specs, diff_specs=diff_specs, + get_policy_fn=_GetClusterIPolicy, build_cmd_fn=build_cmd, + fail=fail, old_values=old_values) def TestClusterModifyISpecs(): """gnt-cluster modify --specs-*""" - params = ["mem-size", "disk-size", "disk-count", "cpu-count", "nic-count"] + params = ["memory-size", "disk-size", "disk-count", "cpu-count", "nic-count"] (cur_policy, cur_specs) = _GetClusterIPolicy() + # This test assumes that there is only one min/max bound + assert len(cur_specs[constants.ISPECS_MINMAX]) == 1 for par in params: test_values = [ (True, 0, 4, 12), @@ -681,14 +945,22 @@ def TestClusterModifyISpecs(): (False, 0, 4, "a"), # This is to restore the old values (True, - cur_specs[par]["min"], cur_specs[par]["std"], cur_specs[par]["max"]) + cur_specs[constants.ISPECS_MINMAX][0][constants.ISPECS_MIN][par], + cur_specs[constants.ISPECS_STD][par], + cur_specs[constants.ISPECS_MINMAX][0][constants.ISPECS_MAX][par]) ] for (good, mn, st, mx) in test_values: - new_vals = {par: {"min": str(mn), "std": str(st), "max": str(mx)}} + new_vals = { + constants.ISPECS_MINMAX: [{ + constants.ISPECS_MIN: {par: mn}, + constants.ISPECS_MAX: {par: mx} + }], + constants.ISPECS_STD: {par: st} + } cur_state = (cur_policy, cur_specs) # We update cur_specs, as we've copied the values to restore already - (cur_policy, cur_specs) = TestClusterSetISpecs(new_vals, fail=not good, - old_values=cur_state) + (cur_policy, cur_specs) = TestClusterSetISpecs( + diff_specs=new_vals, fail=not good, old_values=cur_state) # Get the ipolicy command mnode = qa_config.GetMasterNode() @@ -817,7 +1089,9 @@ def TestClusterBurnin(): try: disks = qa_config.GetDiskOptions() # Run burnin - cmd = [script, + cmd = ["env", + "PYTHONPATH=%s" % _constants.VERSIONEDSHAREDIR, + script, "--os=%s" % qa_config.get("os"), "--minmem-size=%s" % qa_config.get(constants.BE_MINMEM), "--maxmem-size=%s" % qa_config.get(constants.BE_MAXMEM), @@ -851,10 +1125,13 @@ def TestClusterMasterFailover(): failovermaster = qa_config.AcquireNode(exclude=master) cmd = ["gnt-cluster", "master-failover"] + node_list_cmd = ["gnt-node", "list"] try: AssertCommand(cmd, node=failovermaster) + AssertCommand(node_list_cmd, node=failovermaster) # Back to original master node AssertCommand(cmd, node=master) + AssertCommand(node_list_cmd, node=master) finally: failovermaster.Release()