Synnefo » snf-ganeti

          if len(inodes) > 1:

            RunTestIf("group-rwops", qa_group.TestAssignNodesIncludingSplit,

                      constants.INITIAL_NODE_GROUP_NAME,

          if qa_config.TestEnabled("instance-convert-disk"):

            RunTest(qa_instance.TestInstanceShutdown, instance)

            RunTest(qa_instance.TestInstanceConvertDiskToPlain,

          RunTest(qa_instance.TestInstanceRemove, instance)

        finally:

          instance.Release()

        del instance

      finally:

        qa_config.ReleaseManyNodes(inodes)

  qa_config.Load(config_file)

  qa_utils.StartMultiplexer(primary)

  print ("SSH command for primary node: %s" %

         utils.ShellQuoteArgs(qa_utils.GetSSHCommand(primary, "")))

  """

  cmd = utils.ShellQuoteArgs(["cat", filename])

  for node in qa_config.get("nodes"):

# "gnt-cluster info" fields

  """

  master = qa_config.GetMasterNode()

  infocmd = "gnt-cluster info"

  ret = None

  for l in info_out.splitlines():

    m = _CIFIELD_RE.match(l)

  cvcmd = "gnt-cluster verify"

  mnode = qa_config.GetMasterNode()

  if errors:

                             fail=True)

    actual = _GetCVErrorCodes(cvout)

    expected = compat.UniqueFrozenset(e for (_, e, _) in errors)

    fh.write("%s %s write\n" % (rapi_user, rapi_secret))

    fh.flush()

    try:

      AssertCommand(["mkdir", "-p", rapi_dir])

      AssertCommand(["mv", tmpru, pathutils.RAPI_USERS_FILE])

      if spec:

        cmd.append("--specs-%s=%s=%d" % (spec_type, spec_val, spec))

  vgname = qa_config.get("vg-name", None)

  if vgname:

  master = qa_config.GetMasterNode()

  # Assert that OOB is unavailable for all nodes

                                   "gnt-node list --verbose --no-headers -o"

                                   " powered")

  AssertEqual(compat.all(powered == "(unavail)"

  AssertCommand(["gnt-cluster", "epo", "--all", "some_arg"], fail=True)

  # Unless --all is given master is not allowed to be in the list

  # This shouldn't fail

  AssertCommand(["gnt-cluster", "epo", "-f", "--all"])

  # All instances should have been stopped now

                                   "gnt-instance list --no-headers -o status")

  # ERROR_down because the instance is stopped but not recorded as such

  AssertEqual(compat.all(status == "ERROR_down"

  AssertCommand(["gnt-cluster", "epo", "--on", "-f", "--all"])

  # All instances should have been started now

                                   "gnt-instance list --no-headers -o status")

  AssertEqual(compat.all(status == "running"

                         for status in result_output.splitlines()), True)

  AssertCommand(["gnt-debug", "delay", "1"])

  AssertCommand(["gnt-debug", "delay", "--no-master", "1"])

  AssertCommand(["gnt-debug", "delay", "--no-master",

def TestClusterReservedLvs():

         "--rapi-certificate=/dev/null"]

  AssertCommand(cmd, fail=True)

                                         pathutils.RAPI_CERT_FILE)

  try:

    # Custom RAPI certificate

    utils.GenerateSelfSignedSslCert(fh.name, validity=validity)

    try:

      AssertCommand(["gnt-cluster", "renew-crypto", "--force",

                     "--rapi-certificate=%s" % tmpcert])

    cds_fh.write("\n")

    cds_fh.flush()

    try:

      AssertCommand(["gnt-cluster", "renew-crypto", "--force",

                     "--cluster-domain-secret=%s" % tmpcds])

    if len(instances) < 1:

      raise qa_error.Error("Burnin needs at least one instance")

    try:

      # Run burnin

      cmd = [script,

  f.seek(0)

  # Upload file to master node

  try:

    # Copy file to all nodes

    AssertCommand(["gnt-cluster", "copyfile", testname])

  """cluster-verify reports exclusive_storage set only on one node.

  """

  es_val = _GetBoolClusterField("exclusive_storage")

  assert not es_val

  AssertCommand(_BuildSetESCmd(True, node_name))

  vgname = qa_config.get("vg-name", constants.DEFAULT_VG)

  lvname1 = _QA_LV_PREFIX + "vol1"

  lvname2 = _QA_LV_PREFIX + "vol2"

  AssertCommand(["lvcreate", "-L1G", "-n", lvname1, vgname], node=node_name)

  AssertClusterVerify(fail=True, errors=[constants.CV_ENODEORPHANLV])

  AssertCommand(["lvcreate", "-L1G", "-n", lvname2, vgname], node=node_name)

  cmd = (utils.ShellQuoteArgs(["gnt-instance", "list", "-o", "status", name]) +

         ' | grep running')

  return ret == 0

  AssertCommand(["gnt-cluster", "watcher", "pause", "4h"])

  cmd = ["gnt-cluster", "watcher", "info"]

                            utils.ShellQuoteArgs(cmd))

  AssertMatch(output, r"^.*\bis paused\b.*")

  AssertCommand(["gnt-cluster", "watcher", "continue"])

  cmd = ["gnt-cluster", "watcher", "info"]

                            utils.ShellQuoteArgs(cmd))

  AssertMatch(output, r"^.*\bis not paused\b.*")

  pricmd = [pingprimary, "-e"]

  seccmd = [pingsecondary, "-e"]

  for i in nodes:

  pristr = utils.ShellQuoteArgs(pricmd)

  if seccmd:

  (other_group, ) = qa_utils.GetNonexistentGroups(1)

  def AssertInGroup(group, nodes):

    real_output = GetCommandOutput(master_node,

  """

  master = qa_config.GetMasterNode()

  infocmd = utils.ShellQuoteArgs(["gnt-instance", "info", instance])

  re_node = re.compile(r"^\s+-\s+(?:primary|secondaries):\s+(\S.+)$")

  node_elem = r"([^,()]+)(?:\s+\([^)]+\))?"

  # re_nodelist matches a list of nodes returned by gnt-instance info, e.g.:

  master = qa_config.GetMasterNode()

  infocmd = utils.ShellQuoteArgs(["gnt-instance", "list", "--no-headers",

                                  "-o", field, instance])

  if info_out == "Y":

    return True

  elif info_out == "N":

def TestInstanceAddWithPlainDisk(nodes):

  """gnt-instance add -t plain"""

  assert len(nodes) == 1

@InstanceCheck(None, INST_UP, RETURN_VALUE)

def TestInstanceAddWithDrbdDisk(nodes):

  """gnt-instance add -t drbd"""

  assert len(nodes) == 2

                   "drbd")

  master = qa_config.GetMasterNode()

  cmd = ["gnt-instance", "list", "--no-headers", "-o", "status", name]

                                            utils.ShellQuoteArgs(cmd))

  AssertEqual(result_output.strip(), constants.INSTST_RUNNING)

  cmd = ["cat", utils.PathJoin(pathutils.DATA_DIR,

                               "ssconf_%s" % constants.SS_INSTANCE_LIST)]

                                   utils.ShellQuoteArgs(cmd)).splitlines()

  assert len(inodes) == 2

  AssertCommand(["gnt-instance", "modify", "-t", "plain", name])

  AssertCommand(["gnt-instance", "modify", "-t", "drbd",

@InstanceCheck(INST_DOWN, INST_DOWN, FIRST_ARG)

    # A placeholder; the actual command choice depends on use_ialloc

    None,

    # Restore the original secondary

    ]:

    if data is None:

      if use_ialloc:

        data = ["-I", constants.DEFAULT_IALLOCATOR_SHORTCUT]

      else:

    AssertCommand(buildcmd(data))

  AssertCommand(buildcmd(["-a"]))

  """

  options = qa_config.get("options", {})

  use_ialloc = options.get("use-iallocators", True)

  # These fail because the instance is running

  _AssertRecreateDisks(["-n", other_seq], instance, fail=True, destroy=False)

  if use_ialloc:

def TestInstanceExport(instance, node):

  """gnt-backup export -n ..."""

  name = instance["name"]

  return qa_utils.ResolveInstanceName(name)

@InstanceCheck(None, INST_DOWN, FIRST_ARG)

def TestInstanceExportWithRemove(instance, node):

  """gnt-backup export --remove-instance"""

                 "--remove-instance", instance["name"]])

  cmd = (["gnt-backup", "import",

          "--disk-template=%s" % templ,

          "--no-ip-check",

          "--src-dir=%s/%s" % (pathutils.EXPORT_DIR, name),

         _GetGenericAddParameters(newinst, force_mac=constants.VALUE_GENERATE))

  cmd.append(newinst["name"])

  AssertCommand(cmd)

def TestBackupList(expnode):

  """gnt-backup list"""

  qa_utils.GenericQueryTest("gnt-backup", query.EXPORT_FIELDS.keys(),

                            namefield=None, test_unknown=False)

  finally:

    set_online(snode)

  # Clean up the disks on the offline node

    AssertCommand(["drbdsetup", str(minor), "down"], node=snode)

  AssertCommand(["lvremove", "-f"] + info["volumes"], node=snode)

def _NodeAdd(node, readd=False):

  if not readd and node.added:

  elif readd and not node.added:

  cmd = ["gnt-node", "add", "--no-ssh-key-check"]

  if readd:

    cmd.append("--readd")

  AssertCommand(cmd)

def _NodeRemove(node):

  node.MarkRemoved()

def MakeNodeOffline(node, value):

  """gnt-node modify --offline=value"""

  # value in ["yes", "no"]

def TestNodeAddAll():

    cmd = ["gnt-node", "list-storage", "--storage-type", storage_type,

           "--output=node,name,allocatable", "--separator=|",

           "--no-headers"]

                                       utils.ShellQuoteArgs(cmd))

    # Test with up to two devices

        cmd = ["gnt-node", "list-storage", "--storage-type", storage_type,

               "--output=name,allocatable", "--separator=|",

               "--no-headers", node_name]

                                            utils.ShellQuoteArgs(cmd))

        for line in listout.splitlines():

          (vfy_name, vfy_allocatable) = line.split("|")

                                     " it to have no primary instances.")

  # Fail over to secondary node

  # ... and back again.

def TestNodeEvacuate(node, node2):

    # Evacuate all secondary instances

    AssertCommand(["gnt-node", "evacuate", "-f",

    # ... and back again.

    AssertCommand(["gnt-node", "evacuate", "-f",

  finally:

    node3.Release()

  for flag in ["master-candidate", "drained", "offline"]:

    for value in ["yes", "no"]:

      AssertCommand(["gnt-node", "modify", "--force",

  AssertCommand(["gnt-node", "modify", "--master-candidate=yes",

  # Test setting secondary IP address

def _CreateOobScriptStructure():

  """Create a simple OOB handling script and its structure."""

  master = qa_config.GetMasterNode()

  oob_script = (("#!/bin/bash\n"

                 "echo \"$@\" > %s\n"

                 "exit $(< %s)\n") %

                (utils.ShellQuote(verify_path), utils.ShellQuote(data_path),

                 utils.ShellQuote(exit_code_path)))

  return [oob_path, verify_path, data_path, exit_code_path]

def _UpdateOobFile(path, data):

  """Updates the data file with data."""

  master = qa_config.GetMasterNode()

def _AssertOobCall(verify_path, expected_args):

  master = qa_config.GetMasterNode()

  verify_output_cmd = utils.ShellQuoteArgs(["cat", verify_path])

                                     tty=False)

  AssertEqual(expected_args, output.strip())

  node = qa_config.AcquireNode(exclude=master)

  full_node_name = qa_utils.ResolveNodeName(node)

  (oob_path, verify_path,

    AssertCommand(["gnt-node", "health"], fail=True)

    # Different OOB script for node

    oob_script = ("#!/bin/sh\n"

                  "echo \"$@\" > %s\n") % verify_path2

    try:

      AssertCommand(["gnt-node", "modify", "--node-parameters",

def TestNodeListDrbd(node):

  """gnt-node list-drbd"""

  cmd = " && ".join(parts)

  print qa_utils.FormatInfo("Setting up %s with %s OS definition" %

                             ["an invalid", "a valid"][int(valid)]))

  AssertCommand(cmd, node=node)

      AssertCommand(["gnt-os", "diagnose"], fail=(mode != _ALL_VALID))

      # Diagnose again, ignoring exit status

                                         "gnt-os diagnose || :")

      for line in output.splitlines():

        if line.startswith("OS: %s [global status:" % name):

      # Check info for all

      cmd = ["gnt-os", "info"]

                                         utils.ShellQuoteArgs(cmd))

      AssertIn("%s:" % name, output.splitlines())

      # Check info for OS

      cmd = ["gnt-os", "info", name]

                                         utils.ShellQuoteArgs(cmd)).splitlines()

      AssertIn("%s:" % name, output)

      for (field, value) in [("valid", mode == _ALL_VALID),

      # Only valid OSes should be listed

      cmd = ["gnt-os", "list", "--no-headers"]

                                         utils.ShellQuoteArgs(cmd))

      if mode == _ALL_VALID and not (hidden or blacklisted):

        assert_fn = AssertIn

  # Write to temporary file

  _rapi_ca = tempfile.NamedTemporaryFile()

                                           utils.ShellQuoteArgs(cmd)))

  _rapi_ca.flush()

  cfg_curl = rapi.client.GenericCurlConfig(cafile=_rapi_ca.name,

                                           proxy="")

                                              username=username,

                                              password=password,

                                              curl_config_fn=cfg_curl)

      _VerifyNode(node_data)

  _DoTests([

    ("/2/nodes", _VerifyNodesList, "GET", None),

    ("/2/nodes?bulk=1", _VerifyNodesBulk, "GET", None),

    ])

                                           constants.DT_PLAIN,

                                           disks, nics,

                                           os=qa_config.get("os"),

                                           beparams=beparams)

    else:

      body = {

        "name": instance["name"],

        "os_type": qa_config.get("os"),

        "disk_template": constants.DT_PLAIN,

        "beparams": beparams,

        "disks": disks,

        "nics": nics,

  # note: pnode:snode are the *current* nodes, so we move it first to

  # tnode:pnode, then back to pnode:snode

  for si, di, pn, sn in [(src_instance["name"], dest_instance["name"],

                         (dest_instance["name"], src_instance["name"],

    cmd = [

      "../tools/move-instance",

      "--verbose",

      "--dest-primary-node=%s" % pn,

      "--dest-secondary-node=%s" % sn,

      "--net=0:mac=%s" % constants.VALUE_GENERATE,

      si,

      ]

def TestNodeTags(node):

  """gnt-node tags"""

def TestGroupTags(group):

  """

  master = qa_config.GetMasterNode()

  for line in output.splitlines():

    (lkey, lvalue) = line.split(":", 1)

    if lkey == key:

  """Gets the full name of a node.

  """

                      "Node name")

  # Get list of all instances

  cmd = ["gnt-instance", "list", "--separator=:", "--no-headers",

         "--output=name,pnode,snodes"]

  instances = []

  for line in output.splitlines():

  if names:

    cmd.extend(names)

                          utils.ShellQuoteArgs(cmd)).splitlines()

  # Check listed fields (all, must be sorted)

  realcmd = [cmd, "list-fields", "--separator=|", "--no-headers"]

                            utils.ShellQuoteArgs(realcmd)).splitlines()

  AssertEqual([line.split("|", 1)[0] for line in output],

              utils.NiceSort(fields))

  """

  master = qa_config.GetMasterNode()

  data = []

  for localhost in ("::1", "127.0.0.1"):

  """

  master = qa_config.GetMasterNode()

  quoted_tmp_hosts = utils.ShellQuote(tmp_hosts)

  sed_data = " ".join(hostnames)

  master_node = qa_config.GetMasterNode()

  # Build command to connect to master node

  if running:

    running_shellval = "1"