import qa_utils
import qa_error
-from qa_utils import AssertEqual, AssertNotEqual, StartSSH
+from qa_utils import AssertEqual, AssertCommand
def _RemoveFileFromAllNodes(filename):
"""Removes a file from all nodes.
"""
- for node in qa_config.get('nodes'):
- cmd = ['rm', '-f', filename]
- AssertEqual(StartSSH(node['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ for node in qa_config.get("nodes"):
+ AssertCommand(["rm", "-f", filename], node=node)
def _CheckFileOnAllNodes(filename, content):
"""
cmd = utils.ShellQuoteArgs(["cat", filename])
- for node in qa_config.get('nodes'):
- AssertEqual(qa_utils.GetCommandOutput(node['primary'], cmd),
- content)
+ for node in qa_config.get("nodes"):
+ AssertEqual(qa_utils.GetCommandOutput(node["primary"], cmd), content)
def TestClusterInit(rapi_user, rapi_secret):
tmpru = qa_utils.UploadFile(master["primary"], fh.name)
try:
- cmd = ["mv", tmpru, constants.RAPI_USERS_FILE]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["mv", tmpru, constants.RAPI_USERS_FILE])
finally:
- cmd = ["rm", "-f", tmpru]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-f", tmpru])
finally:
fh.close()
cmd.append(qa_config.get('name'))
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
def TestClusterRename():
"""gnt-cluster rename"""
- master = qa_config.GetMasterNode()
-
cmd = ['gnt-cluster', 'rename', '-f']
original_name = qa_config.get('name')
print qa_utils.FormatError('"rename" entry is missing')
return
- cmd_1 = cmd + [rename_target]
- cmd_2 = cmd + [original_name]
-
cmd_verify = ['gnt-cluster', 'verify']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd_1)).wait(), 0)
-
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd_verify)).wait(), 0)
-
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd_2)).wait(), 0)
-
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd_verify)).wait(), 0)
+ for data in [
+ cmd + [rename_target],
+ cmd_verify,
+ cmd + [original_name],
+ cmd_verify,
+ ]:
+ AssertCommand(data)
def TestClusterVerify():
"""gnt-cluster verify"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-cluster', 'verify']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "verify"])
def TestJobqueue():
"""gnt-debug test-jobqueue"""
- master = qa_config.GetMasterNode()
-
- cmd = ["gnt-debug", "test-jobqueue"]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-debug", "test-jobqueue"])
def TestClusterReservedLvs():
"""gnt-cluster reserved lvs"""
- master = qa_config.GetMasterNode()
- CVERIFY = ['gnt-cluster', 'verify']
- for rcode, cmd in [
- (0, CVERIFY),
- (0, ['gnt-cluster', 'modify', '--reserved-lvs', '']),
- (0, ['lvcreate', '-L1G', '-nqa-test', 'xenvg']),
- (1, CVERIFY),
- (0, ['gnt-cluster', 'modify', '--reserved-lvs', 'qa-test,other-test']),
- (0, CVERIFY),
- (0, ['gnt-cluster', 'modify', '--reserved-lvs', 'qa-.*']),
- (0, CVERIFY),
- (0, ['gnt-cluster', 'modify', '--reserved-lvs', '']),
- (1, CVERIFY),
- (0, ['lvremove', '-f', 'xenvg/qa-test']),
- (0, CVERIFY),
+ 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),
]:
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), rcode)
+ AssertCommand(cmd, fail=fail)
def TestClusterModifyBe():
"""gnt-cluster modify -B"""
- master = qa_config.GetMasterNode()
-
- for rcode, cmd in [
+ for fail, cmd in [
# mem
- (0, ["gnt-cluster", "modify", "-B", "memory=256"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *memory: 256$'"]),
- (1, ["gnt-cluster", "modify", "-B", "memory=a"]),
- (0, ["gnt-cluster", "modify", "-B", "memory=128"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *memory: 128$'"]),
+ (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
- (0, ["gnt-cluster", "modify", "-B", "vcpus=4"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *vcpus: 4$'"]),
- (1, ["gnt-cluster", "modify", "-B", "vcpus=a"]),
- (0, ["gnt-cluster", "modify", "-B", "vcpus=1"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *vcpus: 1$'"]),
+ (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
- (0, ["gnt-cluster", "modify", "-B", "auto_balance=False"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *auto_balance: False$'"]),
- (1, ["gnt-cluster", "modify", "-B", "auto_balance=1"]),
- (0, ["gnt-cluster", "modify", "-B", "auto_balance=True"]),
- (0, ["sh", "-c", "gnt-cluster info|grep '^ *auto_balance: True$'"]),
+ (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$'"]),
]:
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), rcode)
+ AssertCommand(cmd, fail=fail)
def TestClusterInfo():
"""gnt-cluster info"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-cluster', 'info']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "info"])
def TestClusterGetmaster():
"""gnt-cluster getmaster"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-cluster', 'getmaster']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "getmaster"])
def TestClusterVersion():
"""gnt-cluster version"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-cluster', 'version']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "version"])
def TestClusterRenewCrypto():
["--new-cluster-domain-secret", "--cluster-domain-secret=/dev/null"],
]
for i in conflicting:
- AssertNotEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd + i)).wait(), 0)
+ AssertCommand(cmd+i, fail=True)
# Invalid RAPI certificate
cmd = ["gnt-cluster", "renew-crypto", "--force",
"--rapi-certificate=/dev/null"]
- AssertNotEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd, fail=True)
rapi_cert_backup = qa_utils.BackupFile(master["primary"],
constants.RAPI_CERT_FILE)
tmpcert = qa_utils.UploadFile(master["primary"], fh.name)
try:
- cmd = ["gnt-cluster", "renew-crypto", "--force",
- "--rapi-certificate=%s" % tmpcert]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+ "--rapi-certificate=%s" % tmpcert])
finally:
- cmd = ["rm", "-f", tmpcert]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-f", tmpcert])
# Custom cluster domain secret
cds_fh = tempfile.NamedTemporaryFile()
tmpcds = qa_utils.UploadFile(master["primary"], cds_fh.name)
try:
- cmd = ["gnt-cluster", "renew-crypto", "--force",
- "--cluster-domain-secret=%s" % tmpcds]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+ "--cluster-domain-secret=%s" % tmpcds])
finally:
- cmd = ["rm", "-f", tmpcds]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-f", tmpcds])
# Normal case
- cmd = ["gnt-cluster", "renew-crypto", "--force",
- "--new-cluster-certificate", "--new-confd-hmac-key",
- "--new-rapi-certificate", "--new-cluster-domain-secret"]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+ "--new-cluster-certificate", "--new-confd-hmac-key",
+ "--new-rapi-certificate", "--new-cluster-domain-secret"])
# Restore RAPI certificate
- cmd = ["gnt-cluster", "renew-crypto", "--force",
- "--rapi-certificate=%s" % rapi_cert_backup]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "renew-crypto", "--force",
+ "--rapi-certificate=%s" % rapi_cert_backup])
finally:
- cmd = ["rm", "-f", rapi_cert_backup]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-f", rapi_cert_backup])
def TestClusterBurnin():
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 master-failover"""
master = qa_config.GetMasterNode()
-
failovermaster = qa_config.AcquireNode(exclude=master)
- try:
- cmd = ['gnt-cluster', 'master-failover']
- AssertEqual(StartSSH(failovermaster['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
- cmd = ['gnt-cluster', 'master-failover']
- 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)
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:
_RemoveFileFromAllNodes(testname)
def TestClusterCommand():
"""gnt-cluster command"""
- master = qa_config.GetMasterNode()
-
uniqueid = utils.NewUUID()
rfile = "/tmp/gnt%s" % utils.NewUUID()
rcmd = utils.ShellQuoteArgs(['echo', '-n', uniqueid])
"%s >%s" % (rcmd, rfile)])
try:
- AssertEqual(StartSSH(master['primary'], cmd).wait(), 0)
+ AssertCommand(cmd)
_CheckFileOnAllNodes(rfile, uniqueid)
finally:
_RemoveFileFromAllNodes(rfile)
def TestClusterDestroy():
"""gnt-cluster destroy"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-cluster', 'destroy', '--yes-do-it']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "destroy", "--yes-do-it"])
import qa_utils
import qa_error
-from qa_utils import AssertEqual, AssertMatch, StartSSH, GetCommandOutput
+from qa_utils import AssertMatch, AssertCommand, StartSSH, GetCommandOutput
def _InstanceRunning(node, name):
"""Checks whether an instance is running.
- Args:
- node: Node the instance runs on
- name: Full name of Xen instance
+ @param node: node the instance runs on
+ @param name: full name of the Xen instance
+
"""
cmd = utils.ShellQuoteArgs(['xm', 'list', name]) + ' >/dev/null'
ret = StartSSH(node['primary'], cmd).wait()
def _XmShutdownInstance(node, name):
"""Shuts down instance using "xm" and waits for completion.
- Args:
- node: Node the instance runs on
- name: Full name of Xen instance
- """
- master = qa_config.GetMasterNode()
+ @param node: node the instance runs on
+ @param name: full name of Xen instance
- cmd = ['xm', 'shutdown', name]
- AssertEqual(StartSSH(node['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ """
+ AssertCommand(["xm", "shutdown", name], node=node)
# Wait up to a minute
end = time.time() + 60
def _ResetWatcherDaemon():
"""Removes the watcher daemon's state file.
- Args:
- node: Node to be reset
"""
- master = qa_config.GetMasterNode()
-
- cmd = ['rm', '-f', constants.WATCHER_STATEFILE]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-f", constants.WATCHER_STATEFILE])
def _RunWatcherDaemon():
"""Runs the ganeti-watcher daemon on the master node.
"""
- master = qa_config.GetMasterNode()
-
- cmd = ["ganeti-watcher", "-d", "--ignore-pause"]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["ganeti-watcher", "-d", "--ignore-pause"])
def TestPauseWatcher():
"""
master = qa_config.GetMasterNode()
- cmd = ["gnt-cluster", "watcher", "pause", "4h"]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "watcher", "pause", "4h"])
cmd = ["gnt-cluster", "watcher", "info"]
output = GetCommandOutput(master["primary"],
"""
master = qa_config.GetMasterNode()
- cmd = ["gnt-cluster", "watcher", "continue"]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "watcher", "continue"])
cmd = ["gnt-cluster", "watcher", "info"]
output = GetCommandOutput(master["primary"],
"""Test automatic restart of instance by ganeti-watcher.
"""
- master = qa_config.GetMasterNode()
inst_name = qa_utils.ResolveInstanceName(instance["name"])
_ResetWatcherDaemon()
if not _InstanceRunning(node, inst_name):
raise qa_error.Error("Daemon didn't restart instance")
- cmd = ['gnt-instance', 'info', inst_name]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "info", inst_name])
def TestInstanceConsecutiveFailures(node, instance):
"""Test five consecutive instance failures.
"""
- master = qa_config.GetMasterNode()
inst_name = qa_utils.ResolveInstanceName(instance["name"])
_ResetWatcherDaemon()
msg = "Instance started when it shouldn't"
raise qa_error.Error(msg)
- cmd = ['gnt-instance', 'info', inst_name]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "info", inst_name])
from ganeti import utils
import qa_config
-import qa_utils
-from qa_utils import AssertEqual, StartSSH
+from qa_utils import AssertCommand
def TestSshConnection():
"""Test SSH connection.
"""
- for node in qa_config.get('nodes'):
- AssertEqual(StartSSH(node['primary'], 'exit').wait(), 0)
+ for node in qa_config.get("nodes"):
+ AssertCommand("exit", node=node)
def TestGanetiCommands():
cmd = ' && '.join([utils.ShellQuoteArgs(i) for i in cmds])
for node in qa_config.get('nodes'):
- AssertEqual(StartSSH(node['primary'], cmd).wait(), 0)
+ AssertCommand(cmd, node=node)
def TestIcmpPing():
if qa_config.get("primary_ip_version") == 6:
pingprimary = "ping6"
- for node in nodes:
- check = []
- for i in nodes:
- cmd = [pingprimary] + pingargs + [i['primary']]
+ check = []
+ for i in nodes:
+ cmd = [pingprimary] + pingargs + [i["primary"]]
+ check.append(utils.ShellQuoteArgs(cmd))
+ if i.has_key("secondary"):
+ cmd = ["ping"] + pingargs + [i["secondary"]]
check.append(utils.ShellQuoteArgs(cmd))
- if i.has_key('secondary'):
- cmd = ["ping"] + pingargs + [i["secondary"]]
- check.append(utils.ShellQuoteArgs(cmd))
+ cmdall = " && ".join(check)
- cmdall = ' && '.join(check)
- AssertEqual(StartSSH(node['primary'], cmdall).wait(), 0)
+ for node in nodes:
+ AssertCommand(cmdall, node=node)
import qa_utils
import qa_error
-from qa_utils import AssertEqual, AssertNotEqual, AssertIn, StartSSH
+from qa_utils import AssertIn, AssertCommand
def _GetDiskStatePath(disk):
def _DiskTest(node, disk_template):
- master = qa_config.GetMasterNode()
-
instance = qa_config.AcquireInstance()
try:
cmd = (['gnt-instance', 'add',
_GetGenericAddParameters())
cmd.append(instance['name'])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
_CheckSsconfInstanceList(instance["name"])
def TestInstanceRemove(instance):
"""gnt-instance remove"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'remove', '-f', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "remove", "-f", instance["name"]])
qa_config.ReleaseInstance(instance)
def TestInstanceStartup(instance):
"""gnt-instance startup"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'startup', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "startup", instance["name"]])
def TestInstanceShutdown(instance):
"""gnt-instance shutdown"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'shutdown', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "shutdown", instance["name"]])
def TestInstanceReboot(instance):
"""gnt-instance reboot"""
- master = qa_config.GetMasterNode()
-
options = qa_config.get('options', {})
reboot_types = options.get("reboot-types", constants.REBOOT_TYPES)
-
+ name = instance["name"]
for rtype in reboot_types:
- cmd = ['gnt-instance', 'reboot', '--type=%s' % rtype, instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "reboot", "--type=%s" % rtype, name])
def TestInstanceReinstall(instance):
"""gnt-instance reinstall"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'reinstall', '-f', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "reinstall", "-f", instance["name"]])
def _ReadSsconfInstanceList():
def TestInstanceRename(instance, rename_target):
"""gnt-instance rename"""
- master = qa_config.GetMasterNode()
-
rename_source = instance['name']
for name1, name2 in [(rename_source, rename_target),
(rename_target, rename_source)]:
_CheckSsconfInstanceList(name1)
- cmd = ['gnt-instance', 'rename', name1, name2]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "rename", name1, name2])
_CheckSsconfInstanceList(name2)
def TestInstanceFailover(instance):
"""gnt-instance failover"""
- master = qa_config.GetMasterNode()
-
cmd = ['gnt-instance', 'failover', '--force', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
+ # failover ...
+ AssertCommand(cmd)
# ... and back
- cmd = ['gnt-instance', 'failover', '--force', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
def TestInstanceMigrate(instance):
"""gnt-instance migrate"""
- master = qa_config.GetMasterNode()
-
cmd = ["gnt-instance", "migrate", "--force", instance["name"]]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
+ # migrate ...
+ AssertCommand(cmd)
# ... and back
- cmd = ["gnt-instance", "migrate", "--force", instance["name"]]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
def TestInstanceInfo(instance):
"""gnt-instance info"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'info', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "info", instance["name"]])
def TestInstanceModify(instance):
"""gnt-instance modify"""
- master = qa_config.GetMasterNode()
-
# Assume /sbin/init exists on all systems
test_kernel = "/sbin/init"
test_initrd = test_kernel
orig_memory = qa_config.get('mem')
- orig_bridge = qa_config.get('bridge', 'xen-br0')
+ #orig_bridge = qa_config.get("bridge", "xen-br0")
args = [
["-B", "%s=128" % constants.BE_MEMORY],
["-B", "%s=%s" % (constants.BE_MEMORY, orig_memory)],
#["-H", "%s=%s" % (constants.HV_BOOT_ORDER, constants.VALUE_DEFAULT)],
]
for alist in args:
- cmd = ['gnt-instance', 'modify'] + alist + [instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "modify"] + alist + [instance["name"]])
# check no-modify
- cmd = ['gnt-instance', 'modify', instance['name']]
- AssertNotEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "modify", instance["name"]], fail=True)
def TestInstanceConvertDisk(instance, snode):
"""gnt-instance modify -t"""
- master = qa_config.GetMasterNode()
- cmd = ['gnt-instance', 'modify', '-t', 'plain', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
- cmd = ['gnt-instance', 'modify', '-t', 'drbd', '-n', snode['primary'],
- instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ name = instance["name"]
+ AssertCommand(["gnt-instance", "modify", "-t", "plain", name])
+ AssertCommand(["gnt-instance", "modify", "-t", "drbd",
+ "-n", snode["primary"], name])
def TestInstanceList():
"""gnt-instance list"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'list']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "list"])
def TestInstanceConsole(instance):
"""gnt-instance console"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-instance', 'console', '--show-cmd', instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "console", "--show-cmd", instance["name"]])
def TestReplaceDisks(instance, pnode, snode, othernode):
"""gnt-instance replace-disks"""
- master = qa_config.GetMasterNode()
-
def buildcmd(args):
cmd = ['gnt-instance', 'replace-disks']
cmd.extend(args)
cmd.append(instance["name"])
return cmd
- cmd = buildcmd(["-p"])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = buildcmd(["-s"])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = buildcmd(["--new-secondary=%s" % othernode["primary"]])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- # Restore
- cmd = buildcmd(["--new-secondary=%s" % snode["primary"]])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ for data in [
+ ["-p"],
+ ["-s"],
+ ["--new-secondary=%s" % othernode["primary"]],
+ # and restore
+ ["--new-secondary=%s" % snode["primary"]],
+ ]:
+ AssertCommand(buildcmd(data))
def TestInstanceExport(instance, node):
"""gnt-backup export -n ..."""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-backup', 'export', '-n', node['primary'], instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- return qa_utils.ResolveInstanceName(instance["name"])
+ name = instance["name"]
+ AssertCommand(["gnt-backup", "export", "-n", node["primary"], name])
+ return qa_utils.ResolveInstanceName(name)
def TestInstanceExportWithRemove(instance, node):
"""gnt-backup export --remove-instance"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-backup', 'export', '-n', node['primary'], "--remove-instance",
- instance['name']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-backup", "export", "-n", node["primary"],
+ "--remove-instance", instance["name"]])
def TestInstanceExportNoTarget(instance):
"""gnt-backup export (without target node, should fail)"""
- master = qa_config.GetMasterNode()
-
- cmd = ["gnt-backup", "export", instance["name"]]
- AssertNotEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-backup", "export", instance["name"]], fail=True)
def TestInstanceImport(node, newinst, expnode, name):
"""gnt-backup import"""
- master = qa_config.GetMasterNode()
-
cmd = (['gnt-backup', 'import',
'--disk-template=plain',
'--no-ip-check',
'--node=%s' % node['primary']] +
_GetGenericAddParameters())
cmd.append(newinst['name'])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
def TestBackupList(expnode):
"""gnt-backup list"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-backup', 'list', '--node=%s' % expnode['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-backup", "list", "--node=%s" % expnode["primary"]])
def _TestInstanceDiskFailure(instance, node, node2, onmaster):
m = re_disk.match(phys)
if not m:
- raise qa_error.Error("Unknown disk name format: %s" % disk)
+ raise qa_error.Error("Unknown disk name format: %s" % phys)
name = m.group(1)
if name not in node2disk[node_name]:
cmds = []
for disk in disks:
cmds.append(sq(["test", "-f", _GetDiskStatePath(disk)]))
- AssertEqual(StartSSH(node_name, ' && '.join(cmds)).wait(), 0)
+ AssertCommand(" && ".join(cmds), node=node_name)
print qa_utils.FormatInfo("Getting device paths")
cmd = ['gnt-instance', 'activate-disks', instance['name']]
for name in node2disk[[node2_full, node_full][int(onmaster)]]:
halted_disks.append(name)
cmds.append(sq(["echo", "offline"]) + " >%s" % _GetDiskStatePath(name))
- AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
- ' && '.join(cmds)).wait(), 0)
+ AssertCommand(" && ".join(cmds), node=[node2, node][int(onmaster)])
print qa_utils.FormatInfo("Write to disks and give some time to notice"
" to notice the problem")
cmds.append(sq(["dd", "count=1", "bs=512", "conv=notrunc",
"if=%s" % disk, "of=%s" % disk]))
for _ in (0, 1, 2):
- AssertEqual(StartSSH(node['primary'], ' && '.join(cmds)).wait(), 0)
+ AssertCommand(" && ".join(cmds), node=node)
time.sleep(3)
print qa_utils.FormatInfo("Debugging info")
for name in drbddevs:
- cmd = ['drbdsetup', name, 'show']
- AssertEqual(StartSSH(node['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["drbdsetup", name, "show"], node=node)
- cmd = ['gnt-instance', 'info', instance['name']]
- AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "info", instance["name"]])
finally:
print qa_utils.FormatInfo("Activating disks again")
cmds = []
for name in halted_disks:
cmds.append(sq(["echo", "running"]) + " >%s" % _GetDiskStatePath(name))
- AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
- '; '.join(cmds)).wait(), 0)
+ AssertCommand("; ".join(cmds), node=[node2, node][int(onmaster)])
if onmaster:
for name in drbddevs:
- cmd = ['drbdsetup', name, 'detach']
- AssertEqual(StartSSH(node['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["drbdsetup", name, "detach"], node=node)
else:
for name in drbddevs:
- cmd = ['drbdsetup', name, 'disconnect']
- AssertEqual(StartSSH(node2['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["drbdsetup", name, "disconnect"], node=node2)
# TODO
- #cmd = ['vgs']
- #AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
- # sq(cmd)).wait(), 0)
+ #AssertCommand(["vgs"], [node2, node][int(onmaster)])
print qa_utils.FormatInfo("Making sure disks are up again")
- cmd = ['gnt-instance', 'replace-disks', instance['name']]
- AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "replace-disks", instance["name"]])
print qa_utils.FormatInfo("Restarting instance")
- cmd = ['gnt-instance', 'shutdown', instance['name']]
- AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
-
- cmd = ['gnt-instance', 'startup', instance['name']]
- AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["gnt-instance", "shutdown", instance["name"]])
+ AssertCommand(["gnt-instance", "startup", instance["name"]])
- cmd = ['gnt-cluster', 'verify']
- AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
+ AssertCommand(["gnt-cluster", "verify"])
def TestInstanceMasterDiskFailure(instance, node, node2):
import qa_error
import qa_utils
-from qa_utils import AssertEqual, AssertNotEqual, StartSSH
+from qa_utils import AssertCommand
def _NodeAdd(node, readd=False):
- master = qa_config.GetMasterNode()
-
if not readd and node.get('_added', False):
raise qa_error.Error("Node %s already in cluster" % node['primary'])
elif readd and not node.get('_added', False):
if readd:
cmd.append('--readd')
cmd.append(node['primary'])
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+
+ AssertCommand(cmd)
node['_added'] = True
def _NodeRemove(node):
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-node', 'remove', node['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "remove", node["primary"]])
node['_added'] = False
def TestNodeInfo():
"""gnt-node info"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-node', 'info']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "info"])
def TestNodeVolumes():
"""gnt-node volumes"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-node', 'volumes']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "volumes"])
def TestNodeStorage():
for storage_type in constants.VALID_STORAGE_TYPES:
# Test simple list
- cmd = ["gnt-node", "list-storage", "--storage-type", storage_type]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "list-storage", "--storage-type", storage_type])
# Test all storage fields
cmd = ["gnt-node", "list-storage", "--storage-type", storage_type,
"--output=%s" % ",".join(list(constants.VALID_STORAGE_FIELDS) +
[constants.SF_NODE, constants.SF_TYPE])]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
# Get list of valid storage devices
cmd = ["gnt-node", "list-storage", "--storage-type", storage_type,
# Dummy modification without any changes
cmd = ["gnt-node", "modify-storage", node_name, storage_type, st_name]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(cmd)
# Make sure we end up with the same value as before
if st_allocatable.lower() == "y":
else:
test_allocatable = ["yes", "no"]
- if (constants.SF_ALLOCATABLE in
- constants.MODIFIABLE_STORAGE_FIELDS.get(storage_type, [])):
- assert_fn = AssertEqual
- else:
- assert_fn = AssertNotEqual
+ fail = (constants.SF_ALLOCATABLE not in
+ constants.MODIFIABLE_STORAGE_FIELDS.get(storage_type, []))
for i in test_allocatable:
- cmd = ["gnt-node", "modify-storage", "--allocatable", i,
- node_name, storage_type, st_name]
- assert_fn(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "modify-storage", "--allocatable", i,
+ node_name, storage_type, st_name], fail=fail)
# Test repair functionality
- cmd = ["gnt-node", "repair-storage", node_name, storage_type, st_name]
-
- if (constants.SO_FIX_CONSISTENCY in
- constants.VALID_STORAGE_OPERATIONS.get(storage_type, [])):
- assert_fn = AssertEqual
- else:
- assert_fn = AssertNotEqual
-
- assert_fn(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ fail = (constants.SO_FIX_CONSISTENCY not in
+ constants.VALID_STORAGE_OPERATIONS.get(storage_type, []))
+ AssertCommand(["gnt-node", "repair-storage", node_name,
+ storage_type, st_name], fail=fail)
def TestNodeFailover(node, node2):
"""gnt-node failover"""
- master = qa_config.GetMasterNode()
-
if qa_utils.GetNodeInstances(node2, secondaries=False):
raise qa_error.UnusableNodeError("Secondary node has at least one"
" primary instance. This test requires"
" it to have no primary instances.")
# Fail over to secondary node
- cmd = ['gnt-node', 'failover', '-f', node['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "failover", "-f", node["primary"]])
# ... and back again.
- cmd = ['gnt-node', 'failover', '-f', node2['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "failover", "-f", node2["primary"]])
def TestNodeEvacuate(node, node2):
"""gnt-node evacuate"""
- master = qa_config.GetMasterNode()
-
node3 = qa_config.AcquireNode(exclude=[node, node2])
try:
if qa_utils.GetNodeInstances(node3, secondaries=True):
" it to have no secondary instances.")
# Evacuate all secondary instances
- cmd = ['gnt-node', 'evacuate', '-f',
- "--new-secondary=%s" % node3['primary'], node2['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "evacuate", "-f",
+ "--new-secondary=%s" % node3["primary"], node2["primary"]])
# ... and back again.
- cmd = ['gnt-node', 'evacuate', '-f',
- "--new-secondary=%s" % node2['primary'], node3['primary']]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "evacuate", "-f",
+ "--new-secondary=%s" % node2["primary"], node3["primary"]])
finally:
qa_config.ReleaseNode(node3)
def TestNodeModify(node):
"""gnt-node modify"""
- master = qa_config.GetMasterNode()
-
for flag in ["master-candidate", "drained", "offline"]:
for value in ["yes", "no"]:
- cmd = ["gnt-node", "modify", "--force",
- "--%s=%s" % (flag, value), node["primary"]]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = ["gnt-node", "modify", "--master-candidate=yes", "--auto-promote",
- node["primary"]]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-node", "modify", "--force",
+ "--%s=%s" % (flag, value), node["primary"]])
+
+ AssertCommand(["gnt-node", "modify", "--master-candidate=yes",
+ "--auto-promote", node["primary"]])
import qa_config
import qa_utils
-from qa_utils import AssertEqual, StartSSH
+from qa_utils import AssertCommand
_TEMP_OS_NAME = "TEMP-Ganeti-QA-OS"
def TestOsList():
"""gnt-os list"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-os', 'list']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-os", "list"])
def TestOsDiagnose():
"""gnt-os diagnose"""
- master = qa_config.GetMasterNode()
-
- cmd = ['gnt-os', 'diagnose']
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["gnt-os", "diagnose"])
-def _TestOsModify(hvp_dict, expected_result=0):
+def _TestOsModify(hvp_dict, fail=False):
"""gnt-os modify"""
- master = qa_config.GetMasterNode()
-
cmd = ['gnt-os', 'modify']
for hv_name, hv_params in hvp_dict.items():
cmd.append('%s:%s' % (hv_name, ','.join(options)))
cmd.append(_TEMP_OS_NAME)
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), expected_result)
+ AssertCommand(cmd, fail=fail)
def _TestOsStates():
"""gnt-os modify, more stuff"""
- master = qa_config.GetMasterNode()
-
cmd = ["gnt-os", "modify"]
for param in ["hidden", "blacklisted"]:
for val in ["yes", "no"]:
new_cmd = cmd + ["--%s" % param, val, _TEMP_OS_NAME]
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(new_cmd)).wait(), 0)
+ AssertCommand(new_cmd)
# check that double-running the command is OK
- AssertEqual(StartSSH(master["primary"],
- utils.ShellQuoteArgs(new_cmd)).wait(), 0)
+ AssertCommand(new_cmd)
def _SetupTempOs(node, dir, valid):
(node["primary"],
["an invalid", "a valid"][int(valid)]))
- AssertEqual(StartSSH(node['primary'], cmd).wait(), 0)
+ AssertCommand(cmd, node=node)
def _RemoveTempOs(node, dir):
"""Removes a temporary OS definition.
"""
- cmd = ['rm', '-rf', dir]
- AssertEqual(StartSSH(node['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ AssertCommand(["rm", "-rf", dir], node=node)
def _TestOs(mode):
"""Generic function for OS definition testing
"""
- master = qa_config.GetMasterNode()
dir = _TEMP_OS_PATH
nodes = []
try:
- i = 0
- for node in qa_config.get('nodes'):
+ for i, node in enumerate(qa_config.get("nodes")):
nodes.append(node)
if mode == 0:
valid = False
else:
valid = bool(i % 2)
_SetupTempOs(node, dir, valid)
- i += 1
-
- cmd = ['gnt-os', 'diagnose']
- result = StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait()
- if mode == 1:
- AssertEqual(result, 0)
- else:
- AssertEqual(result, 1)
+
+ AssertCommand(["gnt-os", "diagnose"], fail=not mode==1)
finally:
for node in nodes:
_RemoveTempOs(node, dir)
"blahblahblubb": {"bar": ""},
}
- return _TestOsModify(hv_dict, 1)
+ return _TestOsModify(hv_dict, fail=True)
def TestOsStates():
"""
-from ganeti import utils
from ganeti import constants
-import qa_config
-import qa_utils
import qa_rapi
-from qa_utils import AssertEqual, StartSSH
+from qa_utils import AssertCommand
_TEMP_TAG_NAMES = ["TEMP-Ganeti-QA-Tag%d" % i for i in range(3)]
"""Generic function for add-tags.
"""
- master = qa_config.GetMasterNode()
-
def cmdfn(subcmd):
cmd = [_KIND_TO_COMMAND[kind], subcmd]
return cmd
- cmd = cmdfn('add-tags') + _TEMP_TAG_NAMES
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = cmdfn('list-tags')
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = ['gnt-cluster', 'search-tags', _TEMP_TAG_RE]
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
-
- cmd = cmdfn('remove-tags') + _TEMP_TAG_NAMES
- AssertEqual(StartSSH(master['primary'],
- utils.ShellQuoteArgs(cmd)).wait(), 0)
+ for cmd in [
+ cmdfn("add-tags") + _TEMP_TAG_NAMES,
+ cmdfn("list-tags"),
+ ["gnt-cluster", "search-tags", _TEMP_TAG_RE],
+ cmdfn("remove-tags") + _TEMP_TAG_NAMES,
+ ]:
+ AssertCommand(cmd)
if qa_rapi.Enabled():
qa_rapi.TestTags(kind, name, _TEMP_TAG_NAMES)
raise qa_error.Error("%r doesn't match /%r/" % (string, pattern))
+def AssertCommand(cmd, fail=False, node=None):
+ """Checks that a remote command succeeds.
+
+ @param cmd: either a string (the command to execute) or a list (to
+ be converted using L{utils.ShellQuoteArgs} into a string)
+ @type fail: boolean
+ @param fail: if the command is expected to fail instead of succeeding
+ @param node: if passed, it should be the node on which the command
+ should be executed, instead of the master node (can be either a
+ dict or a string)
+
+ """
+ if node is None:
+ node = qa_config.GetMasterNode()
+
+ if isinstance(node, basestring):
+ nodename = node
+ else:
+ nodename = node["primary"]
+
+ if isinstance(cmd, basestring):
+ cmdstr = cmd
+ else:
+ cmdstr = utils.ShellQuoteArgs(cmd)
+
+ rcode = StartSSH(nodename, cmdstr).wait()
+
+ if fail:
+ if rcode == 0:
+ raise qa_error.Error("Command '%s' on node %s was expected to fail but"
+ " didn't" % (cmdstr, nodename))
+ else:
+ if rcode != 0:
+ raise qa_error.Error("Command '%s' on node %s failed, exit code %s" %
+ (cmdstr, nodename, rcode))
+
+
def GetSSHCommand(node, cmd, strict=True):
"""Builds SSH command to be executed.
projects / ganeti-local / commitdiff