def TestAdHocReasonRateLimit():
"""Tests that ad-hoc rate limiting using --reason="rate-limit:n:..." works.
"""
# Make sure our test is not constrained by "max-running-jobs"
# (simply set it to the default).
AssertCommand(["gnt-cluster", "modify", "--max-running-jobs=20"])
AssertCommand(["gnt-cluster", "modify", "--max-tracked-jobs=25"])
# Only the first 2 jobs must be scheduled.
jid1 = int(
stdout_of([
"gnt-debug",
"delay",
"--print-jobid",
"--submit",
"--reason=rate-limit:2:hello",
"20",
]))
jid2 = int(
stdout_of([
"gnt-debug",
"delay",
"--print-jobid",
"--submit",
"--reason=rate-limit:2:hello",
"20",
]))
jid3 = int(
stdout_of([
"gnt-debug",
"delay",
"--print-jobid",
"--submit",
"--reason=rate-limit:2:hello",
"20",
]))
time.sleep(0.1) # give the scheduler some time to notice
AssertIn(GetJobStatus(jid1), ["running", "waiting"],
msg="Job should not be rate-limited")
AssertIn(GetJobStatus(jid2), ["running", "waiting"],
msg="Job should not be rate-limited")
AssertEqual(GetJobStatus(jid3), "queued", msg="Job should be rate-limited")
# Clean up.
KillWaitJobs([jid1, jid2, jid3])
def CheckSsconfInstanceList(instance):
"""Checks if a certain instance is in the ssconf instance list.
@type instance: string
@param instance: Instance name
"""
AssertIn(qa_utils.ResolveInstanceName(instance), _ReadSsconfInstanceList())
def TestFilterRateLimit():
"""Tests that the RATE_LIMIT filter does reject new jobs when all
rate-limiting buckets are taken.
"""
# Make sure our test is not constrained by "max-running-jobs"
# (simply set it to the default).
AssertCommand(["gnt-cluster", "modify", "--max-running-jobs=20"])
AssertCommand(["gnt-cluster", "modify", "--max-tracked-jobs=25"])
AssertCommand(["gnt-cluster", "watcher", "pause", "600"])
# Add a filter that rejects all new jobs.
uuid = stdout_of([
"gnt-filter",
"add",
'--predicates=[["jobid", [">", "id", "watermark"]]]',
"--action=RATE_LIMIT 2",
])
# Now only the first 2 jobs must be scheduled.
jid1 = int(
stdout_of(["gnt-debug", "delay", "--print-jobid", "--submit", "200"]))
jid2 = int(
stdout_of(["gnt-debug", "delay", "--print-jobid", "--submit", "200"]))
jid3 = int(
stdout_of(["gnt-debug", "delay", "--print-jobid", "--submit", "200"]))
time.sleep(5) # give the scheduler some time to notice
AssertIn(GetJobStatus(jid1), ["running", "waiting"],
msg="Job should not be rate-limited")
AssertIn(GetJobStatus(jid2), ["running", "waiting"],
msg="Job should not be rate-limited")
AssertEqual(GetJobStatus(jid3), "queued", msg="Job should be rate-limited")
# Clean up.
AssertCommand(["gnt-filter", "delete", uuid])
KillWaitJobs([jid1, jid2, jid3])
AssertCommand(["gnt-cluster", "watcher", "continue"])
def TestInstance(instance):
"""Testing getting instance(s) info via remote API.
"""
def _VerifyInstance(data):
for entry in INSTANCE_FIELDS:
AssertIn(entry, data)
def _VerifyInstancesList(data):
for instance in data:
for entry in LIST_FIELDS:
AssertIn(entry, instance)
def _VerifyInstancesBulk(data):
for instance_data in data:
_VerifyInstance(instance_data)
_DoTests([
("/2/instances/%s" % instance.name, _VerifyInstance, "GET", None),
("/2/instances", _VerifyInstancesList, "GET", None),
("/2/instances?bulk=1", _VerifyInstancesBulk, "GET", None),
("/2/instances/%s/activate-disks" % instance.name, _VerifyReturnsJob,
"PUT", None),
("/2/instances/%s/deactivate-disks" % instance.name, _VerifyReturnsJob,
"PUT", None),
])
# Test OpBackupPrepare
(job_id, ) = _DoTests([
("/2/instances/%s/prepare-export?mode=%s" %
(instance.name, constants.EXPORT_MODE_REMOTE), _VerifyReturnsJob,
"PUT", None),
])
result = _WaitForRapiJob(job_id)[0]
AssertEqual(len(result["handshake"]), 3)
AssertEqual(result["handshake"][0], constants.RIE_VERSION)
AssertEqual(len(result["x509_key_name"]), 3)
AssertIn("-----BEGIN CERTIFICATE-----", result["x509_ca"])
def TestNodeListDrbd(node, is_drbd):
"""gnt-node list-drbd"""
master = qa_config.GetMasterNode()
result_output = GetCommandOutput(master.primary,
"gnt-node list-drbd --no-header %s" %
node.primary)
# Meaningful to note: there is but one instance, and the node is either the
# primary or one of the secondaries
if is_drbd:
# Invoked for both primary and secondary
per_disk_info = result_output.splitlines()
for line in per_disk_info:
try:
drbd_node, _, _, _, _, drbd_peer = line.split()
except ValueError:
raise qa_error.Error("Could not examine list-drbd output: expected a"
" single row of 6 entries, found the following:"
" %s" % line)
AssertIn(node.primary, [drbd_node, drbd_peer],
msg="The output %s does not contain the node" % line)
else:
# Output should be empty, barring newlines
AssertEqual(result_output.strip(), "")
def _VerifyNodesList(data):
for node in data:
for entry in LIST_FIELDS:
AssertIn(entry, node)
def _VerifyNode(data):
for entry in NODE_FIELDS:
AssertIn(entry, data)
def _VerifyInstancesList(data):
for instance in data:
for entry in LIST_FIELDS:
AssertIn(entry, instance)
def _VerifyInstance(data):
for entry in INSTANCE_FIELDS:
AssertIn(entry, data)
def _VerifyFiltersBulk(data):
for group in data:
for field in FILTER_FIELDS:
AssertIn(field, group)
def _VerifyGroups(data):
default_group = {
"name": constants.INITIAL_NODE_GROUP_NAME,
"uri": "/2/groups/" + constants.INITIAL_NODE_GROUP_NAME,
}
AssertIn(default_group, data)
def _VerifyNodesBulk(data):
for node in data:
for entry in NODE_FIELDS:
AssertIn(entry, node)
def _VerifyNodes(data):
master_entry = {
"id": master_full,
"uri": "/2/nodes/%s" % master_full,
}
AssertIn(master_entry, data)
def _VerifyInfo(data):
AssertIn("name", data)
AssertIn("master", data)
AssertEqual(data["master"], master_full)
def _VerifyJob(data):
AssertEqual(data["id"], job_id)
for field in JOB_FIELDS:
AssertIn(field, data)
def _TestOs(mode, rapi_cb):
"""Generic function for OS definition testing
"""
master = qa_config.GetMasterNode()
name = _TEMP_OS_NAME
variant = "default"
fullname = "%s+%s" % (name, variant)
dirname = _TEMP_OS_PATH
# Ensure OS is usable
cmd = ["gnt-os", "modify", "--hidden=no", "--blacklisted=no", name]
AssertCommand(cmd)
nodes = []
try:
for i, node in enumerate(qa_config.get("nodes")):
nodes.append(node)
if mode == _ALL_INVALID:
valid = False
elif mode == _ALL_VALID:
valid = True
elif mode == _PARTIALLY_VALID:
valid = bool(i % 2)
else:
raise AssertionError("Unknown mode %s" % mode)
_SetupTempOs(node, dirname, variant, valid)
# TODO: Use Python 2.6's itertools.permutations
for (hidden, blacklisted) in [(False, False), (True, False),
(False, True), (True, True)]:
# Change OS' visibility
cmd = ["gnt-os", "modify", "--hidden", ["no", "yes"][int(hidden)],
"--blacklisted", ["no", "yes"][int(blacklisted)], name]
AssertCommand(cmd)
# Diagnose, checking exit status
AssertCommand(["gnt-os", "diagnose"], fail=(mode != _ALL_VALID))
# Diagnose again, ignoring exit status
output = qa_utils.GetCommandOutput(master.primary,
"gnt-os diagnose || :")
for line in output.splitlines():
if line.startswith("OS: %s [global status:" % name):
break
else:
raise qa_error.Error("Didn't find OS '%s' in 'gnt-os diagnose'" % name)
# Check info for all
cmd = ["gnt-os", "info"]
output = qa_utils.GetCommandOutput(master.primary,
utils.ShellQuoteArgs(cmd))
AssertIn("%s:" % name, output.splitlines())
# Check info for OS
cmd = ["gnt-os", "info", name]
output = qa_utils.GetCommandOutput(master.primary,
utils.ShellQuoteArgs(cmd)).splitlines()
AssertIn("%s:" % name, output)
for (field, value) in [("valid", mode == _ALL_VALID),
("hidden", hidden),
("blacklisted", blacklisted)]:
AssertIn(" - %s: %s" % (field, value), output)
# Only valid OSes should be listed
cmd = ["gnt-os", "list", "--no-headers"]
output = qa_utils.GetCommandOutput(master.primary,
utils.ShellQuoteArgs(cmd))
if mode == _ALL_VALID and not (hidden or blacklisted):
assert_fn = AssertIn
else:
assert_fn = AssertNotIn
assert_fn(fullname, output.splitlines())
# Check via RAPI
if rapi_cb:
assert_fn(fullname, rapi_cb())
finally:
for node in nodes:
_RemoveTempOs(node, dirname)
def _VerifyGroupsBulk(data):
for group in data:
for field in GROUP_FIELDS:
AssertIn(field, group)
