class Dummy(base.Scenario):
"""Benchmarks for testing Rally benchmark engine at scale."""
@base.scenario()
def dummy(self, sleep=0):
"""Test the performance of ScenarioRunners.
Dummy.dummy can be used for testing performance of different
ScenarioRunners and ability of rally to store a large
amount of results.
:param sleep: Idle time of method.
"""
if sleep:
time.sleep(sleep)
@validation.add(
validation.number("size_of_message",
minval=1,
integer_only=True,
nullable=True))
@base.scenario()
def dummy_exception(self, size_of_message=1):
"""Test if exceptions are processed properly.
Dummy.dummy_exception can be used for test if Exceptions are processed
properly by ScenarioRunners and benchmark and analyze rally
results storing process.
:param size_of_message: the size of the message.
"""
raise exceptions.DummyScenarioException("M" * size_of_message)
@validation.add(
validation.number("exception_probability",
minval=0,
maxval=1,
integer_only=False,
nullable=True))
@base.scenario()
def dummy_exception_probability(self, exception_probability=0.5):
"""Test if exceptions are processed properly.
This scenario will throw an exception sometimes.
:param exception_probability: Sets how likely it is that an exception
will be thrown. Float between 0 and 1
0=never 1=always.
"""
if random.random() < exception_probability:
raise exceptions.DummyScenarioException(
"Dummy Scenario Exception: Probability: %s" %
exception_probability)
@base.scenario()
def dummy_with_scenario_output(self):
out = {'value_1': random.randint(1, 100), 'value_2': random.random()}
err = ""
return {"data": out, "errors": err}
def test_number_integer_only(self):
validator = validation.number("param", 0, 10, nullable=False, integer_only=True)
result = validator(param="5.0")
self.assertFalse(result.is_valid)
validator = validation.number("param", 0, 10, nullable=False, integer_only=False)
result = validator(param="5.0")
self.assertTrue(result.is_valid)
def test_number_integer_only(self):
validator = validation.number('param', 0, 10, nullable=False,
integer_only=True)
config = {"args": {"param": "5.0"}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
validator = validation.number('param', 0, 10, nullable=False,
integer_only=False)
config = {"args": {"param": "5.0"}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_integer_only(self):
validator = validation.number('param',
0,
10,
nullable=False,
integer_only=True)
result = validator(param="5.0")
self.assertFalse(result.is_valid)
validator = validation.number('param',
0,
10,
nullable=False,
integer_only=False)
result = validator(param="5.0")
self.assertTrue(result.is_valid)
def test_number_invalid(self):
validator = validation.number('param', 0, 10, nullable=False)
config = {"args": {"param": -1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": 11}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": "not an int"}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": None}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": -0.1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
def test_number_invalid(self):
validator = validation.number('param', 0, 10, nullable=False)
config = {"args": {"param": -1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": 11}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": "not an int"}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": None}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": -0.1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
def test_number_integer_only(self):
validator = validation.number('param',
0,
10,
nullable=False,
integer_only=True)
config = {"args": {"param": "5.0"}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
validator = validation.number('param',
0,
10,
nullable=False,
integer_only=False)
config = {"args": {"param": "5.0"}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_nullable(self):
validator = validation.number('param', 0, 10, nullable=True)
result = validator(param=None)
self.assertTrue(result.is_valid)
result = validator()
self.assertTrue(result.is_valid)
result = validator(param=-1)
self.assertFalse(result.is_valid)
result = validator(param=0)
self.assertTrue(result.is_valid)
def test_number_nullable(self):
validator = validation.number('param', 0, 10, nullable=True)
result = validator(param=None)
self.assertTrue(result.is_valid)
result = validator()
self.assertTrue(result.is_valid)
result = validator(param=-1)
self.assertFalse(result.is_valid)
result = validator(param=0)
self.assertTrue(result.is_valid)
def test_number_valid(self):
validator = validation.number('param', 0, 10, nullable=False)
result = validator(param=0)
self.assertTrue(result.is_valid)
result = validator(param=10)
self.assertTrue(result.is_valid)
result = validator(param=10.0)
self.assertTrue(result.is_valid)
result = validator(param=5.6)
self.assertTrue(result.is_valid)
def test_number_valid(self):
validator = validation.number('param', 0, 10, nullable=False)
result = validator(param=0)
self.assertTrue(result.is_valid)
result = validator(param=10)
self.assertTrue(result.is_valid)
result = validator(param=10.0)
self.assertTrue(result.is_valid)
result = validator(param=5.6)
self.assertTrue(result.is_valid)
def test_number_valid(self):
validator = validation.number('param', 0, 10, nullable=False)
config = {"args": {"param": 0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 10}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 10.0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 5.6}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_valid(self):
validator = validation.number('param', 0, 10, nullable=False)
config = {"args": {"param": 0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 10}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 10.0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": 5.6}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_nullable(self):
validator = validation.number('param', 0, 10, nullable=True)
config = {"args": {"param": None}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": -1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": 0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_nullable(self):
validator = validation.number('param', 0, 10, nullable=True)
config = {"args": {"param": None}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
config = {"args": {"param": -1}}
result = validator(config, None, None)
self.assertFalse(result.is_valid)
config = {"args": {"param": 0}}
result = validator(config, None, None)
self.assertTrue(result.is_valid)
def test_number_invalid(self):
validator = validation.number('param', 0, 10, nullable=False)
result = validator(param=-1)
self.assertFalse(result.is_valid)
result = validator(param=11)
self.assertFalse(result.is_valid)
result = validator(param="not an int")
self.assertFalse(result.is_valid)
result = validator(param=None)
self.assertFalse(result.is_valid)
result = validator()
self.assertFalse(result.is_valid)
result = validator(param=-0.1)
self.assertFalse(result.is_valid)
def test_number_invalid(self):
validator = validation.number('param', 0, 10, nullable=False)
result = validator(param=-1)
self.assertFalse(result.is_valid)
result = validator(param=11)
self.assertFalse(result.is_valid)
result = validator(param="not an int")
self.assertFalse(result.is_valid)
result = validator(param=None)
self.assertFalse(result.is_valid)
result = validator()
self.assertFalse(result.is_valid)
result = validator(param=-0.1)
self.assertFalse(result.is_valid)
class SaharaClusters(utils.SaharaScenario):
@types.set(flavor=types.FlavorResourceType)
@validation.add(validation.flavor_exists('flavor'))
@validation.required_services(consts.Service.SAHARA)
@validation.required_contexts("users", "sahara_image")
@validation.add(
validation.number("node_count", minval=2, integer_only=True))
@base.scenario(context={"cleanup": ["sahara"]})
def create_and_delete_cluster(self,
flavor,
node_count,
plugin_name="vanilla",
hadoop_version="2.3.0"):
"""Test the Sahara Cluster launch and delete commands.
This scenario launches a Hadoop cluster, waits until it becomes
'Active' and deletes it.
:param flavor: The Nova flavor that will be for nodes in the
created node groups
:param node_count: The total number of instances in a cluster (>= 2)
:param plugin_name: The name of a provisioning plugin
:param hadoop_version: The version of Hadoop distribution supported by
the specified plugin.
"""
tenant_id = self.clients("keystone").tenant_id
image_id = self.context()["sahara_images"][tenant_id]
LOG.debug("Using Image: %s" % image_id)
cluster = self._launch_cluster(flavor_id=flavor,
image_id=image_id,
node_count=node_count,
plugin_name=plugin_name,
hadoop_version=hadoop_version)
self._delete_cluster(cluster)
class VMTasks(nova_utils.NovaScenario, vm_utils.VMScenario):
def __init__(self, *args, **kwargs):
super(VMTasks, self).__init__(*args, **kwargs)
@types.set(image=types.ImageResourceType, flavor=types.FlavorResourceType)
@validation.add(validation.image_valid_on_flavor("flavor", "image"))
@validation.add(validation.file_exists("script"))
@validation.add(
validation.number("port",
minval=1,
maxval=65535,
nullable=True,
integer_only=True))
@validation.add(
validation.external_network_exists("floating_network",
"use_floatingip"))
@base.scenario(context={
"cleanup": ["nova"],
"keypair": {},
"allow_ssh": {}
})
@validation.required_services(consts.Service.NOVA)
def boot_runcommand_delete(self,
image,
flavor,
script,
interpreter,
username,
fixed_network="private",
floating_network="public",
ip_version=4,
port=22,
use_floatingip=True,
**kwargs):
"""Boot server, run a script that outputs JSON, delete server.
:param script: script to run on the server, must output JSON mapping
metric names to values. See sample script below.
:param interpreter: The shell interpreter to use when running script
:param username: User to SSH to instance as
:param fixed_network: Network where instance is part of
:param floating_network: External network used to get floating ip from
:param ip_version: Version of ip protocol to use for connection
:param port: Port to use for SSH connection
:param use_floatingip: Whether to associate a floating ip for
connection
:returns: Dictionary containing two keys, data and errors. Data is JSON
data output by the script. Errors is raw data from the
script's standard error stream.
Example Script in doc/samples/tasks/support/instance_dd_test.sh
"""
server = None
floating_ip = None
try:
server = self._boot_server(
self._generate_random_name("rally_novaserver_"),
image,
flavor,
key_name='rally_ssh_key',
**kwargs)
self.check_network(server, fixed_network)
fixed_ip = [
ip for ip in server.addresses[fixed_network]
if ip["version"] == ip_version
][0]["addr"]
if use_floatingip:
floating_ip = self._create_floating_ip(floating_network)
self._associate_floating_ip(server, floating_ip)
server_ip = floating_ip.ip
else:
server_ip = fixed_ip
code, out, err = self.run_command(server_ip, port, username,
interpreter, script)
if code:
raise exceptions.ScriptError("Error running script %(script)s."
"Error %(code)s: %(error)s" % {
"script": script,
"code": code,
"error": err
})
try:
out = json.loads(out)
except ValueError as e:
raise exceptions.ScriptError(
"Script %(script)s did not output valid JSON: %(error)s" %
{
"script": script,
"error": str(e)
})
# Always try to free resources
finally:
if use_floatingip:
self._release_server_floating_ip(server, floating_ip)
if server:
self._delete_server(server)
return {"data": out, "errors": err}
def _release_server_floating_ip(self, server, floating_ip):
"""Release a floating ip associated to a server.
This method check that the given floating ip is associated with the
specified server and tries to dissociate it.
Once dissociated, release the floating ip to reintegrate
it to the pool of available ips.
:param server: The server to dissociate the floating ip from
:param floating_ip: The floating ip to release
"""
if floating_ip and server:
if self.check_ip_address(floating_ip)(server):
self._dissociate_floating_ip(server, floating_ip)
if floating_ip:
self._delete_floating_ip(floating_ip)
class VMTasks(nova_utils.NovaScenario, vm_utils.VMScenario):
def __init__(self, *args, **kwargs):
super(VMTasks, self).__init__(*args, **kwargs)
@types.set(image=types.ImageResourceType, flavor=types.FlavorResourceType)
@valid.add_validator(valid.image_valid_on_flavor("flavor", "image"))
@valid.add_validator(valid.file_exists("script"))
@valid.add_validator(
valid.number("port",
minval=1,
maxval=65535,
nullable=True,
integer_only=True))
@base.scenario(context={
"cleanup": ["nova"],
"keypair": {},
"allow_ssh": {}
})
def boot_runcommand_delete(self,
image,
flavor,
script,
interpreter,
network='private',
username='******',
ip_version=4,
port=22,
**kwargs):
"""Boot server, run a script that outputs JSON, delete server.
Parameters:
script: script to run on the server, must output JSON mapping metric
names to values. See sample script below.
network: Network to choose address to connect to instance from
username: User to SSH to instance as
ip_version: Version of ip protocol to use for connection
returns: Dictionary containing two keys, data and errors. Data is JSON
data output by the script. Errors is raw data from the
script's standard error stream.
Example Script in doc/samples/support/instance_dd_test.sh
"""
server = self._boot_server(
self._generate_random_name("rally_novaserver_"),
image,
flavor,
key_name='rally_ssh_key',
**kwargs)
code, out, err = self.run_command(server, username, network, port,
ip_version, interpreter, script)
if code:
LOG.error(
_("Error running script on instance via SSH. "
"Error: %s") % err)
try:
out = json.loads(out)
except ValueError:
LOG.warning(_("Script %s did not output valid JSON.") % script)
self._delete_server(server)
LOG.debug("Output streams from in-instance script execution: "
"stdout: %(stdout)s, stderr: $(stderr)s" %
dict(stdout=out, stderr=err))
return {"data": out, "errors": err}
