X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/cec9845cb50cd5a76b3f8421895ee52684ae4d5c..2f4b4f78:/qa/qa_cluster.py

diff --git a/qa/qa_cluster.py b/qa/qa_cluster.py
index d9ba6e2..596c573 100644
--- a/qa/qa_cluster.py
+++ b/qa/qa_cluster.py
@@ -1,4 +1,7 @@
-# Copyright (C) 2007 Google Inc.
+#
+#
+
+# Copyright (C) 2007, 2010 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
@@ -22,21 +25,57 @@
 
 import tempfile
 
+from ganeti import constants
 from ganeti import utils
 
 import qa_config
 import qa_utils
 import qa_error
 
-from qa_utils import AssertEqual, StartSSH
+from qa_utils import AssertEqual, AssertCommand
+
+
+def _RemoveFileFromAllNodes(filename):
+  """Removes a file from all nodes.
+
+  """
+  for node in qa_config.get("nodes"):
+    AssertCommand(["rm", "-f", filename], node=node)
+
+
+def _CheckFileOnAllNodes(filename, content):
+  """Verifies the content of the given file on all nodes.
 
+  """
+  cmd = utils.ShellQuoteArgs(["cat", filename])
+  for node in qa_config.get("nodes"):
+    AssertEqual(qa_utils.GetCommandOutput(node["primary"], cmd), content)
 
-def TestClusterInit():
+
+def TestClusterInit(rapi_user, rapi_secret):
   """gnt-cluster init"""
   master = qa_config.GetMasterNode()
 
+  # First create the RAPI credentials
+  fh = tempfile.NamedTemporaryFile()
+  try:
+    fh.write("%s %s write\n" % (rapi_user, rapi_secret))
+    fh.flush()
+
+    tmpru = qa_utils.UploadFile(master["primary"], fh.name)
+    try:
+      AssertCommand(["mv", tmpru, constants.RAPI_USERS_FILE])
+    finally:
+      AssertCommand(["rm", "-f", tmpru])
+  finally:
+    fh.close()
+
+  # Initialize cluster
   cmd = ['gnt-cluster', 'init']
 
+  cmd.append("--primary-ip-version=%d" %
+             qa_config.get("primary_ip_version", 4))
+
   if master.get('secondary', None):
     cmd.append('--secondary-ip=%s' % master['secondary'])
 
@@ -45,79 +84,231 @@ def TestClusterInit():
     cmd.append('--bridge=%s' % bridge)
     cmd.append('--master-netdev=%s' % bridge)
 
+  htype = qa_config.get('enabled-hypervisors', None)
+  if htype:
+    cmd.append('--enabled-hypervisors=%s' % htype)
+
   cmd.append(qa_config.get('name'))
 
-  AssertEqual(StartSSH(master['primary'],
-                       utils.ShellQuoteArgs(cmd)).wait(), 0)
+  AssertCommand(cmd)
+
+
+def TestClusterRename():
+  """gnt-cluster rename"""
+  cmd = ['gnt-cluster', 'rename', '-f']
+
+  original_name = qa_config.get('name')
+  rename_target = qa_config.get('rename', None)
+  if rename_target is None:
+    print qa_utils.FormatError('"rename" entry is missing')
+    return
+
+  cmd_verify = ['gnt-cluster', 'verify']
+
+  for data in [
+    cmd + [rename_target],
+    cmd_verify,
+    cmd + [original_name],
+    cmd_verify,
+    ]:
+    AssertCommand(data)
 
 
 def TestClusterVerify():
   """gnt-cluster verify"""
-  cmd = ['gnt-cluster', 'verify']
-  master = qa_config.GetMasterNode()
-
-  AssertEqual(StartSSH(master['primary'],
-                       utils.ShellQuoteArgs(cmd)).wait(), 0)
+  AssertCommand(["gnt-cluster", "verify"])
+
+
+def TestJobqueue():
+  """gnt-debug test-jobqueue"""
+  AssertCommand(["gnt-debug", "test-jobqueue"])
+
+
+def TestClusterReservedLvs():
+  """gnt-cluster reserved lvs"""
+  CVERIFY = ["gnt-cluster", "verify"]
+  for fail, cmd in [
+    (False, CVERIFY),
+    (False, ["gnt-cluster", "modify", "--reserved-lvs", ""]),
+    (False, ["lvcreate", "-L1G", "-nqa-test", "xenvg"]),
+    (True,  CVERIFY),
+    (False, ["gnt-cluster", "modify", "--reserved-lvs", "qa-test,other-test"]),
+    (False, CVERIFY),
+    (False, ["gnt-cluster", "modify", "--reserved-lvs", "qa-.*"]),
+    (False, CVERIFY),
+    (False, ["gnt-cluster", "modify", "--reserved-lvs", ""]),
+    (True,  CVERIFY),
+    (False, ["lvremove", "-f", "xenvg/qa-test"]),
+    (False, CVERIFY),
+    ]:
+    AssertCommand(cmd, fail=fail)
+
+
+def TestClusterModifyBe():
+  """gnt-cluster modify -B"""
+  for fail, cmd in [
+    # mem
+    (False, ["gnt-cluster", "modify", "-B", "memory=256"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *memory: 256$'"]),
+    (True,  ["gnt-cluster", "modify", "-B", "memory=a"]),
+    (False, ["gnt-cluster", "modify", "-B", "memory=128"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *memory: 128$'"]),
+    # vcpus
+    (False, ["gnt-cluster", "modify", "-B", "vcpus=4"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *vcpus: 4$'"]),
+    (True,  ["gnt-cluster", "modify", "-B", "vcpus=a"]),
+    (False, ["gnt-cluster", "modify", "-B", "vcpus=1"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *vcpus: 1$'"]),
+    # auto_balance
+    (False, ["gnt-cluster", "modify", "-B", "auto_balance=False"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *auto_balance: False$'"]),
+    (True,  ["gnt-cluster", "modify", "-B", "auto_balance=1"]),
+    (False, ["gnt-cluster", "modify", "-B", "auto_balance=True"]),
+    (False, ["sh", "-c", "gnt-cluster info|grep '^ *auto_balance: True$'"]),
+    ]:
+    AssertCommand(cmd, fail=fail)
 
 
 def TestClusterInfo():
   """gnt-cluster info"""
-  cmd = ['gnt-cluster', 'info']
+  AssertCommand(["gnt-cluster", "info"])
+
+
+def TestClusterGetmaster():
+  """gnt-cluster getmaster"""
+  AssertCommand(["gnt-cluster", "getmaster"])
+
+
+def TestClusterVersion():
+  """gnt-cluster version"""
+  AssertCommand(["gnt-cluster", "version"])
+
+
+def TestClusterRenewCrypto():
+  """gnt-cluster renew-crypto"""
   master = qa_config.GetMasterNode()
 
-  AssertEqual(StartSSH(master['primary'],
-                       utils.ShellQuoteArgs(cmd)).wait(), 0)
+  # Conflicting options
+  cmd = ["gnt-cluster", "renew-crypto", "--force",
+         "--new-cluster-certificate", "--new-confd-hmac-key"]
+  conflicting = [
+    ["--new-rapi-certificate", "--rapi-certificate=/dev/null"],
+    ["--new-cluster-domain-secret", "--cluster-domain-secret=/dev/null"],
+    ]
+  for i in conflicting:
+    AssertCommand(cmd+i, fail=True)
+
+  # Invalid RAPI certificate
+  cmd = ["gnt-cluster", "renew-crypto", "--force",
+         "--rapi-certificate=/dev/null"]
+  AssertCommand(cmd, fail=True)
+
+  rapi_cert_backup = qa_utils.BackupFile(master["primary"],
+                                         constants.RAPI_CERT_FILE)
+  try:
+    # Custom RAPI certificate
+    fh = tempfile.NamedTemporaryFile()
+
+    # Ensure certificate doesn't cause "gnt-cluster verify" to complain
+    validity = constants.SSL_CERT_EXPIRATION_WARN * 3
+
+    utils.GenerateSelfSignedSslCert(fh.name, validity=validity)
+
+    tmpcert = qa_utils.UploadFile(master["primary"], fh.name)
+    try:
+      AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+                     "--rapi-certificate=%s" % tmpcert])
+    finally:
+      AssertCommand(["rm", "-f", tmpcert])
+
+    # Custom cluster domain secret
+    cds_fh = tempfile.NamedTemporaryFile()
+    cds_fh.write(utils.GenerateSecret())
+    cds_fh.write("\n")
+    cds_fh.flush()
+
+    tmpcds = qa_utils.UploadFile(master["primary"], cds_fh.name)
+    try:
+      AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+                     "--cluster-domain-secret=%s" % tmpcds])
+    finally:
+      AssertCommand(["rm", "-f", tmpcds])
+
+    # Normal case
+    AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+                   "--new-cluster-certificate", "--new-confd-hmac-key",
+                   "--new-rapi-certificate", "--new-cluster-domain-secret"])
+
+    # Restore RAPI certificate
+    AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+                   "--rapi-certificate=%s" % rapi_cert_backup])
+  finally:
+    AssertCommand(["rm", "-f", rapi_cert_backup])
 
 
 def TestClusterBurnin():
   """Burnin"""
   master = qa_config.GetMasterNode()
 
+  options = qa_config.get('options', {})
+  disk_template = options.get('burnin-disk-template', 'drbd')
+  parallel = options.get('burnin-in-parallel', False)
+  check_inst = options.get('burnin-check-instances', False)
+  do_rename = options.get('burnin-rename', '')
+  do_reboot = options.get('burnin-reboot', True)
+  reboot_types = options.get("reboot-types", constants.REBOOT_TYPES)
+
   # Get as many instances as we need
   instances = []
   try:
-    num = qa_config.get('options', {}).get('burnin-instances', 1)
-    for _ in xrange(0, num):
-      instances.append(qa_config.AcquireInstance())
-  except qa_error.OutOfInstancesError:
-    print "Not enough instances, continuing anyway."
+    try:
+      num = qa_config.get('options', {}).get('burnin-instances', 1)
+      for _ in range(0, num):
+        instances.append(qa_config.AcquireInstance())
+    except qa_error.OutOfInstancesError:
+      print "Not enough instances, continuing anyway."
 
-  if len(instances) < 1:
-    raise qa_error.Error("Burnin needs at least one instance")
+    if len(instances) < 1:
+      raise qa_error.Error("Burnin needs at least one instance")
 
-  # Run burnin
-  try:
     script = qa_utils.UploadFile(master['primary'], '../tools/burnin')
     try:
+      # Run burnin
       cmd = [script,
              '--os=%s' % qa_config.get('os'),
-             '--os-size=%s' % qa_config.get('os-size'),
-             '--swap-size=%s' % qa_config.get('swap-size')]
+             '--disk-size=%s' % ",".join(qa_config.get('disk')),
+             '--disk-growth=%s' % ",".join(qa_config.get('disk-growth')),
+             '--disk-template=%s' % disk_template]
+      if parallel:
+        cmd.append('--parallel')
+        cmd.append('--early-release')
+      if check_inst:
+        cmd.append('--http-check')
+      if do_rename:
+        cmd.append('--rename=%s' % do_rename)
+      if not do_reboot:
+        cmd.append('--no-reboot')
+      else:
+        cmd.append('--reboot-types=%s' % ",".join(reboot_types))
       cmd += [inst['name'] for inst in instances]
-      AssertEqual(StartSSH(master['primary'],
-                           utils.ShellQuoteArgs(cmd)).wait(), 0)
+      AssertCommand(cmd)
     finally:
-      cmd = ['rm', '-f', script]
-      AssertEqual(StartSSH(master['primary'],
-                           utils.ShellQuoteArgs(cmd)).wait(), 0)
+      AssertCommand(["rm", "-f", script])
+
   finally:
     for inst in instances:
       qa_config.ReleaseInstance(inst)
 
 
 def TestClusterMasterFailover():
-  """gnt-cluster masterfailover"""
+  """gnt-cluster master-failover"""
   master = qa_config.GetMasterNode()
-
   failovermaster = qa_config.AcquireNode(exclude=master)
-  try:
-    cmd = ['gnt-cluster', 'masterfailover']
-    AssertEqual(StartSSH(failovermaster['primary'],
-                         utils.ShellQuoteArgs(cmd)).wait(), 0)
 
-    cmd = ['gnt-cluster', 'masterfailover']
-    AssertEqual(StartSSH(master['primary'],
-                         utils.ShellQuoteArgs(cmd)).wait(), 0)
+  cmd = ["gnt-cluster", "master-failover"]
+  try:
+    AssertCommand(cmd, node=failovermaster)
+    AssertCommand(cmd, node=master)
   finally:
     qa_config.ReleaseNode(failovermaster)
 
@@ -126,9 +317,11 @@ def TestClusterCopyfile():
   """gnt-cluster copyfile"""
   master = qa_config.GetMasterNode()
 
+  uniqueid = utils.NewUUID()
+
   # Create temporary file
   f = tempfile.NamedTemporaryFile()
-  f.write("I'm a testfile.\n")
+  f.write(uniqueid)
   f.flush()
   f.seek(0)
 
@@ -136,21 +329,27 @@ def TestClusterCopyfile():
   testname = qa_utils.UploadFile(master['primary'], f.name)
   try:
     # Copy file to all nodes
-    cmd = ['gnt-cluster', 'copyfile', testname]
-    AssertEqual(StartSSH(master['primary'],
-                         utils.ShellQuoteArgs(cmd)).wait(), 0)
+    AssertCommand(["gnt-cluster", "copyfile", testname])
+    _CheckFileOnAllNodes(testname, uniqueid)
   finally:
-    # Remove file from all nodes
-    for node in qa_config.get('nodes'):
-      cmd = ['rm', '-f', testname]
-      AssertEqual(StartSSH(node['primary'],
-                           utils.ShellQuoteArgs(cmd)).wait(), 0)
+    _RemoveFileFromAllNodes(testname)
+
+
+def TestClusterCommand():
+  """gnt-cluster command"""
+  uniqueid = utils.NewUUID()
+  rfile = "/tmp/gnt%s" % utils.NewUUID()
+  rcmd = utils.ShellQuoteArgs(['echo', '-n', uniqueid])
+  cmd = utils.ShellQuoteArgs(['gnt-cluster', 'command',
+                              "%s >%s" % (rcmd, rfile)])
+
+  try:
+    AssertCommand(cmd)
+    _CheckFileOnAllNodes(rfile, uniqueid)
+  finally:
+    _RemoveFileFromAllNodes(rfile)
 
 
 def TestClusterDestroy():
   """gnt-cluster destroy"""
-  cmd = ['gnt-cluster', 'destroy', '--yes-do-it']
-  master = qa_config.GetMasterNode()
-
-  AssertEqual(StartSSH(master['primary'],
-                       utils.ShellQuoteArgs(cmd)).wait(), 0)
+  AssertCommand(["gnt-cluster", "destroy", "--yes-do-it"])