# # # Copyright (C) 2010, 2011, 2012 Google Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. """QA tests for node groups. """ from ganeti import constants from ganeti import netutils from ganeti import query from ganeti import utils import qa_iptables import qa_config import qa_utils from qa_utils import AssertCommand, AssertEqual, GetCommandOutput def GetDefaultGroup(): """Returns the default node group. """ groups = qa_config.get("groups", {}) return groups.get("group-with-nodes", constants.INITIAL_NODE_GROUP_NAME) def ConfigureGroups(): """Configures groups and nodes for tests such as custom SSH ports. """ defgroup = GetDefaultGroup() nodes = qa_config.get("nodes") options = qa_config.get("options", {}) # Clear any old configuration qa_iptables.CleanRules(nodes) # Custom SSH ports: ssh_port = options.get("ssh-port") default_ssh_port = netutils.GetDaemonPort(constants.SSH) if (ssh_port is not None) and (ssh_port != default_ssh_port): ModifyGroupSshPort(qa_iptables.GLOBAL_RULES, defgroup, nodes, ssh_port) def ModifyGroupSshPort(ipt_rules, group, nodes, ssh_port): """Modifies the node group settings and sets up iptable rules. For each pair of nodes add two rules that affect SSH connections from one to the other one. The first one redirects port 22 to some unused port so that connecting through 22 fails. The second redirects port `ssh_port` to port 22. Together this results in master seeing the SSH daemons on the nodes on `ssh_port` instead of 22. """ default_ssh_port = netutils.GetDaemonPort(constants.SSH) all_nodes = qa_config.get("nodes") AssertCommand(["gnt-group", "modify", "--node-parameters=ssh_port=" + str(ssh_port), group]) for node in nodes: ipt_rules.RedirectPort(node.primary, "localhost", default_ssh_port, 65535) ipt_rules.RedirectPort(node.primary, "localhost", ssh_port, default_ssh_port) for node2 in all_nodes: ipt_rules.RedirectPort(node2.primary, node.primary, default_ssh_port, 65535) ipt_rules.RedirectPort(node2.primary, node.primary, ssh_port, default_ssh_port) def TestGroupAddRemoveRename(): """gnt-group add/remove/rename""" existing_group_with_nodes = GetDefaultGroup() (group1, group2, group3) = qa_utils.GetNonexistentGroups(3) AssertCommand(["gnt-group", "add", group1]) AssertCommand(["gnt-group", "add", group2]) AssertCommand(["gnt-group", "add", group2], fail=True) AssertCommand(["gnt-group", "add", existing_group_with_nodes], fail=True) AssertCommand(["gnt-group", "rename", group1, group2], fail=True) AssertCommand(["gnt-group", "rename", group1, group3]) try: AssertCommand(["gnt-group", "rename", existing_group_with_nodes, group1]) AssertCommand(["gnt-group", "remove", group2]) AssertCommand(["gnt-group", "remove", group3]) AssertCommand(["gnt-group", "remove", group1], fail=True) finally: # Try to ensure idempotency re groups that already existed. AssertCommand(["gnt-group", "rename", group1, existing_group_with_nodes]) def TestGroupAddWithOptions(): """gnt-group add with options""" (group1, ) = qa_utils.GetNonexistentGroups(1) AssertCommand(["gnt-group", "add", "--alloc-policy", "notvalid", group1], fail=True) AssertCommand(["gnt-group", "add", "--alloc-policy", "last_resort", "--node-parameters", "oob_program=/bin/true", group1]) AssertCommand(["gnt-group", "remove", group1]) class NewGroupCtx(object): """Creates a new group and disposes afterwards.""" def __enter__(self): (self._group, ) = qa_utils.GetNonexistentGroups(1) AssertCommand(["gnt-group", "add", self._group]) return self._group def __exit__(self, exc_type, exc_val, exc_tb): AssertCommand(["gnt-group", "remove", self._group]) def _GetGroupIPolicy(groupname): """Return the run-time values of the cluster-level instance policy. @type groupname: string @param groupname: node group name @rtype: tuple @return: (policy, specs), where: - policy is a dictionary of the policy values, instance specs excluded - specs is a dictionary containing only the specs, using the internal format (see L{constants.IPOLICY_DEFAULTS} for an example), but without the standard values """ info = qa_utils.GetObjectInfo(["gnt-group", "info", groupname]) assert len(info) == 1 policy = info[0]["Instance policy"] (ret_policy, ret_specs) = qa_utils.ParseIPolicy(policy) # Sanity checks assert "minmax" in ret_specs assert len(ret_specs["minmax"]) > 0 assert len(ret_policy) > 0 return (ret_policy, ret_specs) def _TestGroupSetISpecs(groupname, new_specs=None, diff_specs=None, fail=False, old_values=None): """Change instance specs on a group. At most one of new_specs or diff_specs can be specified. @type groupname: string @param groupname: group name @type new_specs: dict @param new_specs: new complete specs, in the same format returned by L{_GetGroupIPolicy} @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{_GetGroupIPolicy} @return: same as L{_GetGroupIPolicy} """ build_cmd = lambda opts: ["gnt-group", "modify"] + opts + [groupname] get_policy = lambda: _GetGroupIPolicy(groupname) return qa_utils.TestSetISpecs( new_specs=new_specs, diff_specs=diff_specs, get_policy_fn=get_policy, build_cmd_fn=build_cmd, fail=fail, old_values=old_values) def _TestGroupModifyISpecs(groupname): # This test is built on the assumption that the default ipolicy holds for # the node group under test old_values = _GetGroupIPolicy(groupname) samevals = dict((p, 4) for p in constants.ISPECS_PARAMETERS) base_specs = { constants.ISPECS_MINMAX: [{ constants.ISPECS_MIN: samevals, constants.ISPECS_MAX: samevals, }], } mod_values = _TestGroupSetISpecs(groupname, new_specs=base_specs, old_values=old_values) for par in constants.ISPECS_PARAMETERS: # First make sure that the test works with good values good_specs = { constants.ISPECS_MINMAX: [{ constants.ISPECS_MIN: {par: 8}, constants.ISPECS_MAX: {par: 8}, }], } mod_values = _TestGroupSetISpecs(groupname, diff_specs=good_specs, old_values=mod_values) bad_specs = { constants.ISPECS_MINMAX: [{ constants.ISPECS_MIN: {par: 8}, constants.ISPECS_MAX: {par: 4}, }], } _TestGroupSetISpecs(groupname, diff_specs=bad_specs, fail=True, old_values=mod_values) AssertCommand(["gnt-group", "modify", "--ipolicy-bounds-specs", "default", groupname]) AssertEqual(_GetGroupIPolicy(groupname), old_values) # Get the ipolicy command (from the cluster config) mnode = qa_config.GetMasterNode() addcmd = GetCommandOutput(mnode.primary, utils.ShellQuoteArgs([ "gnt-group", "show-ispecs-cmd", "--include-defaults", groupname, ])) modcmd = ["gnt-group", "modify"] opts = addcmd.split() assert opts[0:2] == ["gnt-group", "add"] for k in range(2, len(opts) - 1): if opts[k].startswith("--ipolicy-"): assert k + 2 <= len(opts) modcmd.extend(opts[k:k + 2]) modcmd.append(groupname) # Apply the ipolicy to the group and verify the result AssertCommand(modcmd) new_addcmd = GetCommandOutput(mnode.primary, utils.ShellQuoteArgs([ "gnt-group", "show-ispecs-cmd", groupname, ])) AssertEqual(addcmd, new_addcmd) def _TestGroupModifyIPolicy(groupname): _TestGroupModifyISpecs(groupname) # We assume that the default ipolicy holds (old_policy, old_specs) = _GetGroupIPolicy(groupname) for (par, setval, iname, expval) in [ ("vcpu-ratio", 1.5, None, 1.5), ("spindle-ratio", 1.5, None, 1.5), ("disk-templates", constants.DT_PLAIN, "allowed disk templates", constants.DT_PLAIN) ]: if not iname: iname = par build_cmdline = lambda val: ["gnt-group", "modify", "--ipolicy-" + par, str(val), groupname] AssertCommand(build_cmdline(setval)) (new_policy, new_specs) = _GetGroupIPolicy(groupname) AssertEqual(new_specs, old_specs) for (p, val) in new_policy.items(): if p == iname: AssertEqual(val, expval) else: AssertEqual(val, old_policy[p]) AssertCommand(build_cmdline("default")) (new_policy, new_specs) = _GetGroupIPolicy(groupname) AssertEqual(new_specs, old_specs) AssertEqual(new_policy, old_policy) def TestGroupModify(): """gnt-group modify""" # This tests assumes LVM to be enabled, thus it should skip if # this is not the case if not qa_config.IsStorageTypeSupported(constants.ST_LVM_VG): return (group1, ) = qa_utils.GetNonexistentGroups(1) AssertCommand(["gnt-group", "add", group1]) try: _TestGroupModifyIPolicy(group1) AssertCommand(["gnt-group", "modify", "--alloc-policy", "unallocable", "--node-parameters", "oob_program=/bin/false", group1]) AssertCommand(["gnt-group", "modify", "--alloc-policy", "notvalid", group1], fail=True) AssertCommand(["gnt-group", "modify", "--node-parameters", "spindle_count=10", group1]) if qa_config.TestEnabled("htools"): AssertCommand(["hbal", "-L", "-G", group1]) AssertCommand(["gnt-group", "modify", "--node-parameters", "spindle_count=default", group1]) finally: AssertCommand(["gnt-group", "remove", group1]) def TestGroupList(): """gnt-group list""" qa_utils.GenericQueryTest("gnt-group", query.GROUP_FIELDS.keys()) def TestGroupListFields(): """gnt-group list-fields""" qa_utils.GenericQueryFieldsTest("gnt-group", query.GROUP_FIELDS.keys()) def TestAssignNodesIncludingSplit(orig_group, node1, node2): """gnt-group assign-nodes --force Expects node1 and node2 to be primary and secondary for a common instance. """ assert node1 != node2 (other_group, ) = qa_utils.GetNonexistentGroups(1) master_node = qa_config.GetMasterNode().primary def AssertInGroup(group, nodes): real_output = GetCommandOutput(master_node, "gnt-node list --no-headers -o group " + utils.ShellQuoteArgs(nodes)) AssertEqual(real_output.splitlines(), [group] * len(nodes)) AssertInGroup(orig_group, [node1, node2]) AssertCommand(["gnt-group", "add", other_group]) try: AssertCommand(["gnt-group", "assign-nodes", other_group, node1, node2]) AssertInGroup(other_group, [node1, node2]) # This should fail because moving node1 to orig_group would leave their # common instance split between orig_group and other_group. AssertCommand(["gnt-group", "assign-nodes", orig_group, node1], fail=True) AssertInGroup(other_group, [node1, node2]) AssertCommand(["gnt-group", "assign-nodes", "--force", orig_group, node1]) AssertInGroup(orig_group, [node1]) AssertInGroup(other_group, [node2]) AssertCommand(["gnt-group", "assign-nodes", orig_group, node2]) AssertInGroup(orig_group, [node1, node2]) finally: AssertCommand(["gnt-group", "remove", other_group])