Rally Plugins ReferenceΒΆ

Scenario Runners [task]

constant [scenario runner]

Creates constant load executing a scenario a specified number of times.

This runner will place a constant load on the cloud under test by
executing each scenario iteration without pausing between iterations
up to the number of times specified in the scenario config.

The concurrency parameter of the scenario config controls the
number of concurrent scenarios which execute during a single
iteration in order to simulate the activities of multiple users
placing load on the cloud under test.

MODULE:
rally.plugins.common.runners.constant

constant_for_duration [scenario runner]

Creates constant load executing a scenario for an interval of time.

This runner will place a constant load on the cloud under test by
executing each scenario iteration without pausing between iterations
until a specified interval of time has elapsed.

The concurrency parameter of the scenario config controls the
number of concurrent scenarios which execute during a single
iteration in order to simulate the activities of multiple users
placing load on the cloud under test.

MODULE:
rally.plugins.common.runners.constant

serial [scenario runner]

Scenario runner that executes benchmark scenarios serially.

Unlike scenario runners that execute in parallel, the serial scenario
runner executes scenarios one-by-one in the same python interpreter process
as Rally. This allows you to benchmark your scenario without introducing
any concurrent operations as well as interactively debug the scenario
from the same command that you use to start Rally.

MODULE:
rally.plugins.common.runners.serial

rps [scenario runner]

Scenario runner that does the job with specified frequency.

Every single benchmark scenario iteration is executed with specified
frequency (runs per second) in a pool of processes. The scenario will be
launched for a fixed number of times in total (specified in the config).

An example of a rps scenario is booting 1 VM per second. This
execution type is thus very helpful in understanding the maximal load that
a certain cloud can handle.

MODULE:
rally.plugins.common.runners.rps

SLAs [task]

max_seconds_per_iteration [SLA]

Maximum time for one iteration in seconds.

MODULE:
rally.plugins.common.sla.iteration_time

max_avg_duration [SLA]

Maximum average duration of one iteration in seconds.

MODULE:
rally.plugins.common.sla.max_average_duration

outliers [SLA]

Limit the number of outliers (iterations that take too much time).

The outliers are detected automatically using the computation of the mean
and standard deviation (std) of the data.

MODULE:
rally.plugins.common.sla.outliers

failure_rate [SLA]

Failure rate minimum and maximum in percents.

MODULE:
rally.plugins.common.sla.failure_rate

Contexts [task]

flavors [context]

Context creates a list of flavors.

MODULE:
rally.plugins.openstack.context.nova.flavors

api_versions [context]

Context for specifying OpenStack clients versions and service types.

Some OpenStack services support several API versions. To recognize
the endpoints of each version, separate service types are provided in
Keystone service catalog.

Rally has the map of default service names - service types. But since
service type is an entity, which can be configured manually by admin(
via keystone api) without relation to service name, such map can be
insufficient.

Also, Keystone service catalog does not provide a map types to name
(this statement is true for keystone < 3.3 ).

This context was designed for not-default service types and not-default
API versions usage.

An example of specifying API version:

.. code-block:: json

    # In this example we will launch NovaKeypair.create_and_list_keypairs
    # scenario on 2.2 api version.
    {
        "NovaKeypair.create_and_list_keypairs": [
            {
                "args": {
                    "key_type": "x509"
                },
                "runner": {
                    "type": "constant",
                    "times": 10,
                    "concurrency": 2
                },
                "context": {
                    "users": {
                        "tenants": 3,
                        "users_per_tenant": 2
                    },
                    "api_versions": {
                        "nova": {
                            "version": 2.2
                        }
                    }
                }
            }
        ]
    }

An example of specifying API version along with service type:

.. code-block:: json

    # In this example we will launch CinderVolumes.create_and_attach_volume
    # scenario on Cinder V2
    {
        "CinderVolumes.create_and_attach_volume": [
            {
                "args": {
                    "size": 10,
                    "image": {
                        "name": "^cirros.*uec$"
                    },
                    "flavor": {
                        "name": "m1.tiny"
                    },
                    "create_volume_params": {
                        "availability_zone": "nova"
                    }
                },
                "runner": {
                    "type": "constant",
                    "times": 5,
                    "concurrency": 1
                },
                "context": {
                    "users": {
                        "tenants": 2,
                        "users_per_tenant": 2
                    },
                    "api_versions": {
                        "cinder": {
                            "version": 2,
                            "service_type": "volumev2"
                        }
                    }
                }
            }
        ]
    }

Also, it possible to use service name as an identifier of service endpoint,
but an admin user is required (Keystone can return map of service
names - types, but such API is permitted only for admin). An example:

.. code-block:: json

    # Similar to the previous example, but `service_name` argument is used
    # instead of `service_type`
    {
        "CinderVolumes.create_and_attach_volume": [
            {
                "args": {
                    "size": 10,
                    "image": {
                        "name": "^cirros.*uec$"
                    },
                    "flavor": {
                        "name": "m1.tiny"
                    },
                    "create_volume_params": {
                        "availability_zone": "nova"
                    }
                },
                "runner": {
                    "type": "constant",
                    "times": 5,
                    "concurrency": 1
                },
                "context": {
                    "users": {
                        "tenants": 2,
                        "users_per_tenant": 2
                    },
                    "api_versions": {
                        "cinder": {
                            "version": 2,
                            "service_name": "cinderv2"
                        }
                    }
                }
            }
        ]
    }

MODULE:
rally.plugins.openstack.context.api_versions

fuel_environments [context]

Context for generating Fuel environments.

MODULE:
rally.plugins.openstack.context.fuel

keypair [context]



MODULE:
rally.plugins.openstack.context.nova.keypairs

servers [context]

Context class for adding temporary servers for benchmarks.

Servers are added for each tenant.

MODULE:
rally.plugins.openstack.context.nova.servers

manila_share_networks [context]

This context creates resources specific for Manila project.

MODULE:
rally.plugins.openstack.context.manila.manila_share_networks

users [context]

Context class for generating temporary users/tenants for benchmarks.

MODULE:
rally.plugins.openstack.context.keystone.users

existing_users [context]

This context supports using existing users in Rally.

It uses information about deployment to properly
initialize context["users"] and context["tenants"]

So there won't be big difference between usage of "users" and
"existing_users" context.

MODULE:
rally.plugins.openstack.context.keystone.existing_users

roles [context]

Context class for adding temporary roles for benchmarks.

MODULE:
rally.plugins.openstack.context.keystone.roles

quotas [context]

Context class for updating benchmarks' tenants quotas.

MODULE:
rally.plugins.openstack.context.quotas.quotas

tempest [context]



MODULE:
rally.plugins.openstack.context.not_for_production.tempest

zones [context]

Context to add `zones_per_tenant` zones for each tenant.

MODULE:
rally.plugins.openstack.context.designate.zones

custom_image [context]

Base class for the contexts providing customized image with.

Every context class for the specific customization must implement
the method `_customize_image` that is able to connect to the server
using SSH and e.g. install applications inside it.

This is used e.g. to install the benchmark application using SSH
access.

This base context class provides a way to prepare an image with
custom preinstalled applications. Basically, this code boots a VM, calls
the `_customize_image` and then snapshots the VM disk, removing the VM
afterwards. The image UUID is stored in the user["custom_image"]["id"]
and can be used afterwards by scenario.

MODULE:
rally.plugins.openstack.context.vm.custom_image

image_command_customizer [context]

Context class for generating image customized by a command execution.

Run a command specified by configuration to prepare image.

Use this script e.g. to download and install something.

MODULE:
rally.plugins.openstack.context.vm.image_command_customizer

stacks [context]

Context class for create temporary stacks with resources.

Stack generator allows to generate arbitrary number of stacks for
each tenant before test scenarios. In addition, it allows to define
number of resources (namely OS::Heat::RandomString) that will be created
inside each stack. After test execution the stacks will be
automatically removed from heat.

MODULE:
rally.plugins.openstack.context.heat.stacks

admin_cleanup [context]

Context class for admin resources cleanup.

MODULE:
rally.plugins.openstack.context.cleanup

cleanup [context]

Context class for user resources cleanup.

MODULE:
rally.plugins.openstack.context.cleanup

ceilometer [context]

Context for creating samples and collecting resources for benchmarks.

MODULE:
rally.plugins.openstack.context.ceilometer.samples

swift_objects [context]



MODULE:
rally.plugins.openstack.context.swift.objects

lbaas [context]



MODULE:
rally.plugins.openstack.context.neutron.lbaas

ec2_servers [context]

Context class for adding temporary servers for benchmarks.

Servers are added for each tenant.

MODULE:
rally.plugins.openstack.context.ec2.servers

allow_ssh [context]

Sets up security groups for all users to access VM via SSH.

MODULE:
rally.plugins.openstack.context.network.allow_ssh

existing_network [context]

This context supports using existing networks in Rally.

This context should be used on a deployment with existing users.

MODULE:
rally.plugins.openstack.context.network.existing_network

network [context]



MODULE:
rally.plugins.openstack.context.network.networks

volumes [context]

Context class for adding volumes to each user for benchmarks.

MODULE:
rally.plugins.openstack.context.cinder.volumes

sahara_image [context]

Context class for adding and tagging Sahara images.

MODULE:
rally.plugins.openstack.context.sahara.sahara_image

sahara_input_data_sources [context]

Context class for setting up Input Data Sources for an EDP job.

MODULE:
rally.plugins.openstack.context.sahara.sahara_input_data_sources

sahara_output_data_sources [context]

Context class for setting up Output Data Sources for an EDP job.

MODULE:
rally.plugins.openstack.context.sahara.sahara_output_data_sources

sahara_job_binaries [context]

Context class for setting up Job Binaries for an EDP job.

MODULE:
rally.plugins.openstack.context.sahara.sahara_job_binaries

sahara_cluster [context]

Context class for setting up the Cluster an EDP job.

MODULE:
rally.plugins.openstack.context.sahara.sahara_cluster

murano_packages [context]

Context class for uploading applications for murano.

MODULE:
rally.plugins.openstack.context.murano.murano_packages

images [context]

Context class for adding images to each user for benchmarks.

MODULE:
rally.plugins.openstack.context.glance.images

dummy_context [context]

Dummy context.

MODULE:
rally.plugins.common.context.dummy

Scenarios [task]

NovaFlavors.list_flavors [scenario]

List all flavors.

Measure the "nova flavor-list" command performance.

PARAMETERS:
* detailed: True if the flavor listing
                 should contain detailed information


* kwargs: Optional additional arguments for flavor listing


MODULE:
rally.plugins.openstack.scenarios.nova.flavors

NovaImages.list_images [scenario]

List all images.

Measure the "nova image-list" command performance.

PARAMETERS:
* detailed: True if the image listing
                 should contain detailed information

* kwargs: Optional additional arguments for image listing


MODULE:
rally.plugins.openstack.scenarios.nova.images

NovaHypervisors.list_hypervisors [scenario]

List hypervisors.

Measure the "nova hypervisor-list" command performance.

PARAMETERS:
* detailed: True if the hypervisor listing should contain
                 detailed information about all of them


MODULE:
rally.plugins.openstack.scenarios.nova.hypervisors

NovaNetworks.create_and_list_networks [scenario]

Create nova network and list all networks.

PARAMETERS:
* start_cidr: IP range

* kwargs: Optional additional arguments for network creation


MODULE:
rally.plugins.openstack.scenarios.nova.networks

NovaNetworks.create_and_delete_network [scenario]

Create nova network and delete it.

PARAMETERS:
* start_cidr: IP range

* kwargs: Optional additional arguments for network creation


MODULE:
rally.plugins.openstack.scenarios.nova.networks

NovaSecGroup.create_and_delete_secgroups [scenario]

Create and delete security groups.

This scenario creates N security groups with M rules per group and then
deletes them.

PARAMETERS:
* security_group_count: Number of security groups

* rules_per_security_group: Number of rules per security group


MODULE:
rally.plugins.openstack.scenarios.nova.security_group

NovaSecGroup.create_and_list_secgroups [scenario]

Create and list security groups.

This scenario creates N security groups with M rules per group and then
lists them.

PARAMETERS:
* security_group_count: Number of security groups

* rules_per_security_group: Number of rules per security group


MODULE:
rally.plugins.openstack.scenarios.nova.security_group

NovaSecGroup.create_and_update_secgroups [scenario]

Create and update security groups.

This scenario creates 'security_group_count' security groups
then updates their name and description.

PARAMETERS:
* security_group_count: Number of security groups


MODULE:
rally.plugins.openstack.scenarios.nova.security_group

NovaSecGroup.boot_and_delete_server_with_secgroups [scenario]

Boot and delete server with security groups attached.

Plan of this scenario:
 - create N security groups with M rules per group
   vm with security groups)
 - boot a VM with created security groups
 - get list of attached security groups to server
 - delete server
 - delete all security groups
 - check that all groups were attached to server

PARAMETERS:
* image: ID of the image to be used for server creation

* flavor: ID of the flavor to be used for server creation

* security_group_count: Number of security groups

* rules_per_security_group: Number of rules per security group

* **kwargs: Optional arguments for booting the instance


MODULE:
rally.plugins.openstack.scenarios.nova.security_group

NovaKeypair.create_and_list_keypairs [scenario]

Create a keypair with random name and list keypairs.

This scenario creates a keypair and then lists all keypairs.

PARAMETERS:
* kwargs: Optional additional arguments for keypair creation


MODULE:
rally.plugins.openstack.scenarios.nova.keypairs

NovaKeypair.create_and_delete_keypair [scenario]

Create a keypair with random name and delete keypair.

This scenario creates a keypair and then delete that keypair.

PARAMETERS:
* kwargs: Optional additional arguments for keypair creation


MODULE:
rally.plugins.openstack.scenarios.nova.keypairs

NovaKeypair.boot_and_delete_server_with_keypair [scenario]

Boot and delete server with keypair.

Plan of this scenario:
 - create a keypair
 - boot a VM with created keypair
 - delete server
 - delete keypair

PARAMETERS:
* image: ID of the image to be used for server creation

* flavor: ID of the flavor to be used for server creation

* server_kwargs: Optional additional arguments for VM creation

* kwargs: Optional additional arguments for keypair creation


MODULE:
rally.plugins.openstack.scenarios.nova.keypairs

NovaServers.boot_and_list_server [scenario]

Boot a server from an image and then list all servers.

Measure the "nova list" command performance.

If you have only 1 user in your context, you will
add 1 server on every iteration. So you will have more
and more servers and will be able to measure the
performance of the "nova list" command depending on
the number of servers owned by users.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* detailed: True if the server listing should contain
                 detailed information about all of them

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.list_servers [scenario]

List all servers.

This simple scenario test the nova list command by listing
all the servers.

PARAMETERS:
* detailed: True if detailed information about servers
                 should be listed


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_delete_server [scenario]

Boot and delete a server.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between volume creation and deletion
(of random duration from [min_sleep, max_sleep]).

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_delete_multiple_servers [scenario]

Boot multiple servers in a single request and delete them.

Deletion is done in parallel with one request per server, not
with a single request for all servers.

PARAMETERS:
* image: The image to boot from

* flavor: Flavor used to boot instance

* count: Number of instances to boot

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for instance creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_from_volume_and_delete [scenario]

Boot a server from volume and then delete it.

The scenario first creates a volume and then a server.
Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between volume creation and deletion
(of random duration from [min_sleep, max_sleep]).

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* volume_size: volume size (in GB)

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_bounce_server [scenario]

Boot a server and run specified actions against it.

Actions should be passed into the actions parameter. Available actions
are 'hard_reboot', 'soft_reboot', 'stop_start' and 'rescue_unrescue'.
Delete server after all actions were completed.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* force_delete: True if force_delete should be used

* actions: list of action dictionaries, where each action
                dictionary speicifes an action to be performed
                in the following format:
                {"action_name": <no_of_iterations>}

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_lock_unlock_and_delete [scenario]

Boot a server, lock it, then unlock and delete it.

Optional 'min_sleep' and 'max_sleep' parameters allow the
scenario to simulate a pause between locking and unlocking the
server (of random duration from min_sleep to max_sleep).

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* min_sleep: Minimum sleep time between locking and unlocking
                  in seconds

* max_sleep: Maximum sleep time between locking and unlocking
                  in seconds

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.snapshot_server [scenario]

Boot a server, make its snapshot and delete both.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server [scenario]

Boot a server.

Assumes that cleanup is done elsewhere.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* auto_assign_nic: True if NICs should be assigned

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_from_volume [scenario]

Boot a server from volume.

The scenario first creates a volume and then a server.
Assumes that cleanup is done elsewhere.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* volume_size: volume size (in GB)

* auto_assign_nic: True if NICs should be assigned

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.resize_server [scenario]

Boot a server, then resize and delete it.

This test will confirm the resize by default,
or revert the resize if confirm is set to false.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* to_flavor: flavor to be used to resize the booted instance

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_attach_created_volume_and_resize [scenario]

Create a VM from image, attach a volume to it and resize.

Simple test to create a VM and attach a volume, then resize the VM,
detach the volume then delete volume and VM.
Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between attaching a volume and running resize
(of random duration from range [min_sleep, max_sleep]).

PARAMETERS:
* image: Glance image name to use for the VM

* flavor: VM flavor name

* to_flavor: flavor to be used to resize the booted instance

* volume_size: volume size (in GB)

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* force_delete: True if force_delete should be used

* confirm: True if need to confirm resize else revert resize

* do_delete: True if resources needs to be deleted explicitly
                else use rally cleanup to remove resources

* boot_server_kwargs: optional arguments for VM creation

* create_volume_kwargs: optional arguments for volume creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_from_volume_and_resize [scenario]

Boot a server from volume, then resize and delete it.

The scenario first creates a volume and then a server.
Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between volume creation and deletion
(of random duration from [min_sleep, max_sleep]).

This test will confirm the resize by default,
or revert the resize if confirm is set to false.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* to_flavor: flavor to be used to resize the booted instance

* volume_size: volume size (in GB)

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* force_delete: True if force_delete should be used

* confirm: True if need to confirm resize else revert resize

* do_delete: True if resources needs to be deleted explicitly
                else use rally cleanup to remove resources

* boot_server_kwargs: optional arguments for VM creation

* create_volume_kwargs: optional arguments for volume creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.suspend_and_resume_server [scenario]

Create a server, suspend, resume and then delete it

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.pause_and_unpause_server [scenario]

Create a server, pause, unpause and then delete it

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.shelve_and_unshelve_server [scenario]

Create a server, shelve, unshelve and then delete it

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* force_delete: True if force_delete should be used

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_live_migrate_server [scenario]

Live Migrate a server.

This scenario launches a VM on a compute node available in
the availability zone and then migrates the VM to another
compute node on the same availability zone.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between VM booting and running live migration
(of random duration from range [min_sleep, max_sleep]).

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* block_migration: Specifies the migration type

* disk_over_commit: Specifies whether to allow overcommit
                         on migrated instance or not

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_from_volume_and_live_migrate [scenario]

Boot a server from volume and then migrate it.

The scenario first creates a volume and a server booted from
the volume on a compute node available in the availability zone and
then migrates the VM to another compute node on the same availability
zone.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between VM booting and running live migration
(of random duration from range [min_sleep, max_sleep]).

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* volume_size: volume size (in GB)

* block_migration: Specifies the migration type

* disk_over_commit: Specifies whether to allow overcommit
                         on migrated instance or not

* force_delete: True if force_delete should be used

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_server_attach_created_volume_and_live_migrate [scenario]

Create a VM, attach a volume to it and live migrate.

Simple test to create a VM and attach a volume, then migrate the VM,
detach the volume and delete volume/VM.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between attaching a volume and running live
migration (of random duration from range [min_sleep, max_sleep]).

PARAMETERS:
* image: Glance image name to use for the VM

* flavor: VM flavor name

* size: volume size (in GB)

* block_migration: Specifies the migration type

* disk_over_commit: Specifies whether to allow overcommit
                         on migrated instance or not

* boot_server_kwargs: optional arguments for VM creation

* create_volume_kwargs: optional arguments for volume creation

* min_sleep: Minimum sleep time in seconds (non-negative)

* max_sleep: Maximum sleep time in seconds (non-negative)


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_migrate_server [scenario]

Migrate a server.

This scenario launches a VM on a compute node available in
the availability zone and stops the VM, and then migrates the VM
to another compute node on the same availability zone.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_rebuild_server [scenario]

Rebuild a server.

This scenario launches a VM, then rebuilds that VM with a
different image.

PARAMETERS:
* from_image: image to be used to boot an instance

* to_image: image to be used to rebuild the instance

* flavor: flavor to be used to boot an instance

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_associate_floating_ip [scenario]

Boot a server and associate a floating IP to it.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* kwargs: Optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_show_server [scenario]

Show server details.

This simple scenario tests the nova show command by retrieving
the server details.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* kwargs: Optional additional arguments for server creation




RETURNS:
Server details

MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaServers.boot_and_get_console_output [scenario]

Get text console output from server.

This simple scenario tests the nova console-log command by retrieving
the text console log output.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* length: The number of tail log lines you would like to retrieve.
               None (default value) or -1 means unlimited length.

* kwargs: Optional additional arguments for server creation




RETURNS:
Text console log output for server

MODULE:
rally.plugins.openstack.scenarios.nova.servers

NovaFloatingIpsBulk.create_and_list_floating_ips_bulk [scenario]

Create nova floating IP by range and list it.

This scenario creates a floating IP by range and then lists all.

PARAMETERS:
* start_cidr: Floating IP range

* kwargs: Optional additional arguments for range IP creation


MODULE:
rally.plugins.openstack.scenarios.nova.floating_ips_bulk

NovaFloatingIpsBulk.create_and_delete_floating_ips_bulk [scenario]

Create nova floating IP by range and delete it.

This scenario creates a floating IP by range and then delete it.

PARAMETERS:
* start_cidr: Floating IP range

* kwargs: Optional additional arguments for range IP creation


MODULE:
rally.plugins.openstack.scenarios.nova.floating_ips_bulk

ZaqarBasic.create_queue [scenario]

Create a Zaqar queue with a random name.

PARAMETERS:
* kwargs: other optional parameters to create queues like
               "metadata"


MODULE:
rally.plugins.openstack.scenarios.zaqar.basic

ZaqarBasic.producer_consumer [scenario]

Serial message producer/consumer.

Creates a Zaqar queue with random name, sends a set of messages
and then retrieves an iterator containing those.

PARAMETERS:
* min_msg_count: min number of messages to be posted

* max_msg_count: max number of messages to be posted

* kwargs: other optional parameters to create queues like
               "metadata"


MODULE:
rally.plugins.openstack.scenarios.zaqar.basic

ManilaShares.create_and_delete_share [scenario]

Create and delete a share.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between share creation and deletion
(of random duration from [min_sleep, max_sleep]).

PARAMETERS:
* share_proto: share protocol, valid values are NFS, CIFS,
    GlusterFS and HDFS

* size: share size in GB, should be greater than 0

* min_sleep: minimum sleep time in seconds (non-negative)

* max_sleep: maximum sleep time in seconds (non-negative)

* kwargs: optional args to create a share


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.list_shares [scenario]

Basic scenario for 'share list' operation.

PARAMETERS:
* detailed: defines either to return detailed list of
    objects or not.

* search_opts: container of search opts such as
    "name", "host", "share_type", etc.


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.create_share_network_and_delete [scenario]

Creates share network and then deletes.

PARAMETERS:
* neutron_net_id: ID of Neutron network

* neutron_subnet_id: ID of Neutron subnet

* nova_net_id: ID of Nova network

* description: share network description


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.create_share_network_and_list [scenario]

Creates share network and then lists it.

PARAMETERS:
* neutron_net_id: ID of Neutron network

* neutron_subnet_id: ID of Neutron subnet

* nova_net_id: ID of Nova network

* description: share network description

* detailed: defines either to return detailed list of
    objects or not.

* search_opts: container of search opts such as
    "name", "nova_net_id", "neutron_net_id", etc.


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.list_share_servers [scenario]

Lists share servers.

Requires admin creds.

PARAMETERS:
* search_opts: container of following search opts:
    "host", "status", "share_network" and "project_id".


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.create_security_service_and_delete [scenario]

Creates security service and then deletes.

PARAMETERS:
* security_service_type: security service type, permitted values
    are 'ldap', 'kerberos' or 'active_directory'.

* dns_ip: dns ip address used inside tenant's network

* server: security service server ip address or hostname

* domain: security service domain

* user: security identifier used by tenant

* password: password used by user

* description: security service description


MODULE:
rally.plugins.openstack.scenarios.manila.shares

ManilaShares.attach_security_service_to_share_network [scenario]

Attaches security service to share network.

PARAMETERS:
* security_service_type: type of security service to use.
    Should be one of following: 'ldap', 'kerberos' or
    'active_directory'.


MODULE:
rally.plugins.openstack.scenarios.manila.shares

KeystoneBasic.create_user [scenario]

Create a keystone user with random name.

PARAMETERS:
* kwargs: Other optional parameters to create users like
                 "tenant_id", "enabled".


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_delete_user [scenario]

Create a keystone user with random name and then delete it.

PARAMETERS:
* kwargs: Other optional parameters to create users like
                 "tenant_id", "enabled".


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_user_set_enabled_and_delete [scenario]

Create a keystone user, enable or disable it, and delete it.

PARAMETERS:
* enabled: Initial state of user 'enabled' flag. The user
                will be created with 'enabled' set to this
                value, and then it will be toggled.

* kwargs: Other optional parameters to create user.


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_tenant [scenario]

Create a keystone tenant with random name.

PARAMETERS:
* kwargs: Other optional parameters


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_tenant_with_users [scenario]

Create a keystone tenant and several users belonging to it.

PARAMETERS:
* users_per_tenant: number of users to create for the tenant

* kwargs: Other optional parameters for tenant creation



RETURNS:
keystone tenant instance

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_list_users [scenario]

Create a keystone user with random name and list all users.

PARAMETERS:
* kwargs: Other optional parameters to create users like
                 "tenant_id", "enabled".


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_list_tenants [scenario]

Create a keystone tenant with random name and list all tenants.

PARAMETERS:
* kwargs: Other optional parameters


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.add_and_remove_user_role [scenario]

Create a user role add to a user and disassociate.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_delete_role [scenario]

Create a user role and delete it.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_add_and_list_user_roles [scenario]

Create user role, add it and list user roles for given user.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.get_entities [scenario]

Get instance of a tenant, user, role and service by id's.

An ephemeral tenant, user, and role are each created. By
default, fetches the 'keystone' service. This can be
overridden (for instance, to get the 'Identity Service'
service on older OpenStack), or None can be passed explicitly
to service_name to create a new service and then query it by
ID.

PARAMETERS:
* service_name: The name of the service to get by ID; or
                     None, to create an ephemeral service and
                     get it by ID.


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_delete_service [scenario]

Create and delete service.

PARAMETERS:
* service_type: type of the service

* description: description of the service


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_update_and_delete_tenant [scenario]

Create, update and delete tenant.

PARAMETERS:
* kwargs: Other optional parameters for tenant creation


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_user_update_password [scenario]

Create user and update password for that user.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_list_services [scenario]

Create and list services.

PARAMETERS:
* service_type: type of the service

* description: description of the service


MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_list_ec2credentials [scenario]

Create and List all keystone ec2-credentials.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

KeystoneBasic.create_and_delete_ec2credential [scenario]

Create and delete keystone ec2-credential.

MODULE:
rally.plugins.openstack.scenarios.keystone.basic

Quotas.nova_update [scenario]

Update quotas for Nova.

PARAMETERS:
* max_quota: Max value to be updated for quota.


MODULE:
rally.plugins.openstack.scenarios.quotas.quotas

Quotas.nova_update_and_delete [scenario]

Update and delete quotas for Nova.

PARAMETERS:
* max_quota: Max value to be updated for quota.


MODULE:
rally.plugins.openstack.scenarios.quotas.quotas

Quotas.cinder_update [scenario]

Update quotas for Cinder.

PARAMETERS:
* max_quota: Max value to be updated for quota.


MODULE:
rally.plugins.openstack.scenarios.quotas.quotas

Quotas.cinder_update_and_delete [scenario]

Update and Delete quotas for Cinder.

PARAMETERS:
* max_quota: Max value to be updated for quota.


MODULE:
rally.plugins.openstack.scenarios.quotas.quotas

Quotas.neutron_update [scenario]

Update quotas for neutron.

PARAMETERS:
* max_quota: Max value to be updated for quota.


MODULE:
rally.plugins.openstack.scenarios.quotas.quotas

VMTasks.boot_runcommand_delete [scenario]

Boot a server, run a script that outputs JSON, delete the server.

Example Script in samples/tasks/support/instance_dd_test.sh

PARAMETERS:
* image: glance image name to use for the vm

* flavor: VM flavor name

* username: ssh username on server, str

* password: Password on SSH authentication

* script: DEPRECATED. Use `command' instead. Script to run on
    server, must output JSON mapping metric names to values (see the
    sample script below)

* interpreter: DEPRECATED. Use `command' instead. server's
    interpreter to run the script

* command: Command-specifying dictionary that either specifies
    remote command path via `remote_path' (can be uploaded from a
    local file specified by `local_path`), an inline script via
    `script_inline' or a local script file path using `script_file'.
    Both `script_file' and `local_path' are checked to be accessible
    by the `file_exists' validator code.

    The `script_inline' and `script_file' both require an `interpreter'
    value to specify the interpreter script should be run with.

    Note that any of `interpreter' and `remote_path' can be an array
    prefixed with environment variables and suffixed with args for
    the `interpreter' command. `remote_path's last component must be
    a path to a command to execute (also upload destination if a
    `local_path' is given). Uploading an interpreter is possible
    but requires that `remote_path' and `interpreter' path do match.


    Examples::

        # Run a `local_script.pl' file sending it to a remote
        # Perl interpreter
        command = {
            "script_file": "local_script.pl",
            "interpreter": "/usr/bin/perl"
        }

        # Run an inline script sending it to a remote interpreter
        command = {
            "script_inline": "echo 'Hello, World!'",
            "interpreter": "/bin/sh"
        }

        # Run a remote command
        command = {
            "remote_path": "/bin/false"
        }

        # Copy a local command and run it
        command = {
            "remote_path": "/usr/local/bin/fio",
            "local_path": "/home/foobar/myfiodir/bin/fio"
        }

        # Copy a local command and run it with environment variable
        command = {
            "remote_path": ["HOME=/root", "/usr/local/bin/fio"],
            "local_path": "/home/foobar/myfiodir/bin/fio"
        }

        # Run an inline script sending it to a remote interpreter
        command = {
            "script_inline": "echo "Hello, ${NAME:-World}"",
            "interpreter": ["NAME=Earth", "/bin/sh"]
        }

        # Run an inline script sending it to an uploaded remote
        # interpreter
        command = {
            "script_inline": "echo "Hello, ${NAME:-World}"",
            "interpreter": ["NAME=Earth", "/tmp/sh"],
            "remote_path": "/tmp/sh",
            "local_path": "/home/user/work/cve/sh-1.0/bin/sh"
        }



* volume_args: volume args for booting server from volume

* floating_network: external network name, for floating ip

* port: ssh port for SSH connection

* use_floating_ip: bool, floating or fixed IP for SSH connection

* force_delete: whether to use force_delete for servers

* wait_for_ping: whether to check connectivity on server creation

* **kwargs: extra arguments for booting the server

* max_log_length: The number of tail nova console-log lines user
                       would like to retrieve



RETURNS:
dictionary with keys `data' and `errors':
data: dict, JSON output from the script
errors: str, raw data from the script's stderr stream

MODULE:
rally.plugins.openstack.scenarios.vm.vmtasks

VMTasks.boot_runcommand_delete_custom_image [scenario]

Boot a server from a custom image, run a command that outputs JSON.

Example Script in rally-jobs/extra/install_benchmark.sh

MODULE:
rally.plugins.openstack.scenarios.vm.vmtasks

VMTasks.runcommand_heat [scenario]

Run workload on stack deployed by heat.

Workload can be either file or resource:
    {"file": "/path/to/file.sh"}
    {"resource": ["package.module", "workload.py"]}
Also it should contain "username" key.
Given file will be uploaded to `gate_node` and started. This script
should print `key` `value` pairs separated by colon. These pairs will
be presented in results.

Gate node should be accessible via ssh with keypair `key_name`, so
heat template should accept parameter `key_name`.

PARAMETERS:
* workload: workload to run

* template: path to heat template file

* files: additional template files

* parameters: parameters for heat template


MODULE:
rally.plugins.openstack.scenarios.vm.vmtasks

HeatStacks.create_and_list_stack [scenario]

Create a stack and then list all stacks.

Measure the "heat stack-create" and "heat stack-list" commands
performance.

PARAMETERS:
* template_path: path to stack template file

* parameters: parameters to use in heat template

* files: files used in template

* environment: stack environment definition


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.list_stacks_and_resources [scenario]

List all resources from tenant stacks.

MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_and_delete_stack [scenario]

Create and then delete a stack.

Measure the "heat stack-create" and "heat stack-delete" commands
performance.

PARAMETERS:
* template_path: path to stack template file

* parameters: parameters to use in heat template

* files: files used in template

* environment: stack environment definition


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_check_delete_stack [scenario]

Create, check and delete a stack.

Measure the performance of the following commands:
- heat stack-create
- heat action-check
- heat stack-delete

PARAMETERS:
* template_path: path to stack template file

* parameters: parameters to use in heat template

* files: files used in template

* environment: stack environment definition


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_update_delete_stack [scenario]

Create, update and then delete a stack.

Measure the "heat stack-create", "heat stack-update"
and "heat stack-delete" commands performance.

PARAMETERS:
* template_path: path to stack template file

* updated_template_path: path to updated stack template file

* parameters: parameters to use in heat template

* updated_parameters: parameters to use in updated heat template
                           If not specified then parameters will be
                           used instead

* files: files used in template

* updated_files: files used in updated template. If not specified
                      files value will be used instead

* environment: stack environment definition

* updated_environment: environment definition for updated stack


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_stack_and_scale [scenario]

Create an autoscaling stack and invoke a scaling policy.

Measure the performance of autoscaling webhooks.

PARAMETERS:
* template_path: path to template file that includes an
                      OS::Heat::AutoScalingGroup resource

* output_key: the stack output key that corresponds to
                   the scaling webhook

* delta: the number of instances the stack is expected to
              change by.

* parameters: parameters to use in heat template

* files: files used in template (dict of file name to
              file path)

* environment: stack environment definition (dict)


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_suspend_resume_delete_stack [scenario]

Create, suspend-resume and then delete a stack.

Measure performance of the following commands:
heat stack-create
heat action-suspend
heat action-resume
heat stack-delete

PARAMETERS:
* template_path: path to stack template file

* parameters: parameters to use in heat template

* files: files used in template

* environment: stack environment definition


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.list_stacks_and_events [scenario]

List events from tenant stacks.

MODULE:
rally.plugins.openstack.scenarios.heat.stacks

HeatStacks.create_snapshot_restore_delete_stack [scenario]

Create, snapshot-restore and then delete a stack.

Measure performance of the following commands:
heat stack-create
heat stack-snapshot
heat stack-restore
heat stack-delete

PARAMETERS:
* template_path: path to stack template file

* parameters: parameters to use in heat template

* files: files used in template

* environment: stack environment definition


MODULE:
rally.plugins.openstack.scenarios.heat.stacks

MistralWorkbooks.list_workbooks [scenario]

Scenario test mistral workbook-list command.

This simple scenario tests the Mistral workbook-list
command by listing all the workbooks.

MODULE:
rally.plugins.openstack.scenarios.mistral.workbooks

MistralWorkbooks.create_workbook [scenario]

Scenario tests workbook creation and deletion.

This scenario is a very useful tool to measure the
"mistral workbook-create" and "mistral workbook-delete"
commands performance.

PARAMETERS:
* definition: string (yaml string) representation of given
                   file content (Mistral workbook definition)

* do_delete: if False than it allows to check performance
                  in "create only" mode.


MODULE:
rally.plugins.openstack.scenarios.mistral.workbooks

CeilometerTraits.create_user_and_list_traits [scenario]

Create user and fetch all event traits.

This scenario creates user to store new event and
fetches list of all traits for certain event type and
trait name using GET /v2/event_types/<event_type>/traits/<trait_name>.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.traits

CeilometerTraits.create_user_and_list_trait_descriptions [scenario]

Create user and fetch all trait descriptions.

This scenario creates user to store new event and
fetches list of all traits for certain event type using
GET /v2/event_types/<event_type>/traits.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.traits

CeilometerAlarms.create_alarm [scenario]

Create an alarm.

This scenarios test POST /v2/alarms.
meter_name and threshold are required parameters for alarm creation.
kwargs stores other optional parameters like 'ok_actions',
'project_id' etc that may be passed while creating an alarm.

PARAMETERS:
* meter_name: specifies meter name of the alarm

* threshold: specifies alarm threshold

* kwargs: specifies optional arguments for alarm creation.


MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerAlarms.list_alarms [scenario]

Fetch all alarms.

This scenario fetches list of all alarms using GET /v2/alarms.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerAlarms.create_and_list_alarm [scenario]

Create and get the newly created alarm.

This scenarios test GET /v2/alarms/(alarm_id)
Initially alarm is created and then the created alarm is fetched using
its alarm_id. meter_name and threshold are required parameters
for alarm creation. kwargs stores other optional parameters like
'ok_actions', 'project_id' etc. that may be passed while creating
an alarm.

PARAMETERS:
* meter_name: specifies meter name of the alarm

* threshold: specifies alarm threshold

* kwargs: specifies optional arguments for alarm creation.


MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerAlarms.create_and_update_alarm [scenario]

Create and update the newly created alarm.

This scenarios test PUT /v2/alarms/(alarm_id)
Initially alarm is created and then the created alarm is updated using
its alarm_id. meter_name and threshold are required parameters
for alarm creation. kwargs stores other optional parameters like
'ok_actions', 'project_id' etc that may be passed while alarm creation.

PARAMETERS:
* meter_name: specifies meter name of the alarm

* threshold: specifies alarm threshold

* kwargs: specifies optional arguments for alarm creation.


MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerAlarms.create_and_delete_alarm [scenario]

Create and delete the newly created alarm.

This scenarios test DELETE /v2/alarms/(alarm_id)
Initially alarm is created and then the created alarm is deleted using
its alarm_id. meter_name and threshold are required parameters
for alarm creation. kwargs stores other optional parameters like
'ok_actions', 'project_id' etc that may be passed while alarm creation.

PARAMETERS:
* meter_name: specifies meter name of the alarm

* threshold: specifies alarm threshold

* kwargs: specifies optional arguments for alarm creation.


MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerAlarms.create_alarm_and_get_history [scenario]

Create an alarm, get and set the state and get the alarm history.

This scenario makes following queries:
    GET /v2/alarms/{alarm_id}/history
    GET /v2/alarms/{alarm_id}/state
    PUT /v2/alarms/{alarm_id}/state
Initially alarm is created and then get the state of the created alarm
using its alarm_id. Then get the history of the alarm. And finally the
state of the alarm is updated using given state. meter_name and
threshold are required parameters for alarm creation. kwargs stores
other optional parameters like 'ok_actions', 'project_id' etc that may
be passed while alarm creation.

PARAMETERS:
* meter_name: specifies meter name of the alarm

* threshold: specifies alarm threshold

* state: an alarm state to be set

* timeout: The number of seconds for which to attempt a
                successful check of the alarm state

* kwargs: specifies optional arguments for alarm creation.


MODULE:
rally.plugins.openstack.scenarios.ceilometer.alarms

CeilometerEvents.create_user_and_list_events [scenario]

Create user and fetch all events.

This scenario creates user to store new event and
fetches list of all events using GET /v2/events.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.events

CeilometerEvents.create_user_and_list_event_types [scenario]

Create user and fetch all event types.

This scenario creates user to store new event and
fetches list of all events types using GET /v2/event_types.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.events

CeilometerEvents.create_user_and_get_event [scenario]

Create user and gets event.

This scenario creates user to store new event and
fetches one event using GET /v2/events/<message_id>.

MODULE:
rally.plugins.openstack.scenarios.ceilometer.events

CeilometerResource.list_resources [scenario]

Check all available queries for list resource request.

This scenario fetches list of all resources using GET /v2/resources.

PARAMETERS:
* metadata_query: dict with metadata fields and values for query

* start_time: lower bound of resource timestamp in isoformat

* end_time: upper bound of resource timestamp in isoformat

* limit: count of resources in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.resources

CeilometerResource.get_tenant_resources [scenario]

Get all tenant resources.

This scenario retrieves information about tenant resources using
GET /v2/resources/(resource_id)

MODULE:
rally.plugins.openstack.scenarios.ceilometer.resources

CeilometerResource.list_matched_resources [scenario]

Get resources that matched fields from context and args.

PARAMETERS:
* filter_by_user_id: flag for query by user_id

* filter_by_project_id: flag for query by project_id

* filter_by_resource_id: flag for query by resource_id

* metadata_query: dict with metadata fields and values for query

* start_time: lower bound of resource timestamp in isoformat

* end_time: upper bound of resource timestamp in isoformat

* limit: count of resources in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.resources

CeilometerStats.create_meter_and_get_stats [scenario]

Create a meter and fetch its statistics.

Meter is first created and then statistics is fetched for the same
using GET /v2/meters/(meter_name)/statistics.

PARAMETERS:
* kwargs: contains optional arguments to create a meter


MODULE:
rally.plugins.openstack.scenarios.ceilometer.stats

CeilometerStats.get_stats [scenario]

Fetch statistics for certain meter.

Statistics is fetched for the using
GET /v2/meters/(meter_name)/statistics.

PARAMETERS:
* meter_name: meter to take statistic for

* filter_by_user_id: flag for query by user_id

* filter_by_project_id: flag for query by project_id

* filter_by_resource_id: flag for query by resource_id

* metadata_query: dict with metadata fields and values for query

* period: the length of the time range covered by these stats

* groupby: the fields used to group the samples

* aggregates: name of function for samples aggregation




RETURNS:
list of statistics data

MODULE:
rally.plugins.openstack.scenarios.ceilometer.stats

CeilometerQueries.create_and_query_alarms [scenario]

Create an alarm and then query it with specific parameters.

This scenario tests POST /v2/query/alarms
An alarm is first created and then fetched using the input query.

PARAMETERS:
* meter_name: specifies meter name of alarm

* threshold: specifies alarm threshold

* filter: optional filter query dictionary

* orderby: optional param for specifying ordering of results

* limit: optional param for maximum number of results returned

* kwargs: optional parameters for alarm creation


MODULE:
rally.plugins.openstack.scenarios.ceilometer.queries

CeilometerQueries.create_and_query_alarm_history [scenario]

Create an alarm and then query for its history.

This scenario tests POST /v2/query/alarms/history
An alarm is first created and then its alarm_id is used to fetch the
history of that specific alarm.

PARAMETERS:
* meter_name: specifies meter name of alarm

* threshold: specifies alarm threshold

* orderby: optional param for specifying ordering of results

* limit: optional param for maximum number of results returned

* kwargs: optional parameters for alarm creation


MODULE:
rally.plugins.openstack.scenarios.ceilometer.queries

CeilometerQueries.create_and_query_samples [scenario]

Create a sample and then query it with specific parameters.

This scenario tests POST /v2/query/samples
A sample is first created and then fetched using the input query.

PARAMETERS:
* counter_name: specifies name of the counter

* counter_type: specifies type of the counter

* counter_unit: specifies unit of the counter

* counter_volume: specifies volume of the counter

* resource_id: specifies resource id for the sample created

* filter: optional filter query dictionary

* orderby: optional param for specifying ordering of results

* limit: optional param for maximum number of results returned

* kwargs: parameters for sample creation


MODULE:
rally.plugins.openstack.scenarios.ceilometer.queries

CeilometerSamples.list_matched_samples [scenario]

Get list of samples that matched fields from context and args.

PARAMETERS:
* filter_by_user_id: flag for query by user_id

* filter_by_project_id: flag for query by project_id

* filter_by_resource_id: flag for query by resource_id

* metadata_query: dict with metadata fields and values for query

* limit: count of samples in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.samples

CeilometerSamples.list_samples [scenario]

Fetch all available queries for list sample request.

PARAMETERS:
* metadata_query: dict with metadata fields and values for query

* limit: count of samples in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.samples

CeilometerMeters.list_meters [scenario]

Check all available queries for list resource request.

PARAMETERS:
* metadata_query: dict with metadata fields and values

* limit: limit of meters in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.meters

CeilometerMeters.list_matched_meters [scenario]

Get meters that matched fields from context and args.

PARAMETERS:
* filter_by_user_id: flag for query by user_id

* filter_by_project_id: flag for query by project_id

* filter_by_resource_id: flag for query by resource_id

* metadata_query: dict with metadata fields and values for query

* limit: count of resources in response


MODULE:
rally.plugins.openstack.scenarios.ceilometer.meters

FuelEnvironments.create_and_delete_environment [scenario]

Create and delete Fuel environments.

PARAMETERS:
* release_id: release id (default 1)

* network_provider: network provider (default 'neutron')

* deployment_mode: deployment mode (default 'ha_compact')

* net_segment_type: net segment type (default 'vlan')

* delete_retries: retries count on delete oprations (default 5)


MODULE:
rally.plugins.openstack.scenarios.fuel.environments

FuelEnvironments.create_and_list_environments [scenario]

Create and list Fuel environments

PARAMETERS:
* release_id: release id (default 1)

* network_provider: network provider (default 'neutron')

* deployment_mode: deployment mode (default 'ha_compact')

* net_segment_type: net segment type (default 'vlan')


MODULE:
rally.plugins.openstack.scenarios.fuel.environments

FuelNodes.add_and_remove_node [scenario]

Add node to environment and remove

PARAMETERS:
* node_roles: list. Roles, which node should be assigned to
    env with


MODULE:
rally.plugins.openstack.scenarios.fuel.nodes

SwiftObjects.create_container_and_object_then_list_objects [scenario]

Create container and objects then list all objects.

PARAMETERS:
* objects_per_container: int, number of objects to upload

* object_size: int, temporary local object size

* kwargs: dict, optional parameters to create container


MODULE:
rally.plugins.openstack.scenarios.swift.objects

SwiftObjects.create_container_and_object_then_delete_all [scenario]

Create container and objects then delete everything created.

PARAMETERS:
* objects_per_container: int, number of objects to upload

* object_size: int, temporary local object size

* kwargs: dict, optional parameters to create container


MODULE:
rally.plugins.openstack.scenarios.swift.objects

SwiftObjects.create_container_and_object_then_download_object [scenario]

Create container and objects then download all objects.

PARAMETERS:
* objects_per_container: int, number of objects to upload

* object_size: int, temporary local object size

* kwargs: dict, optional parameters to create container


MODULE:
rally.plugins.openstack.scenarios.swift.objects

SwiftObjects.list_objects_in_containers [scenario]

List objects in all containers.

MODULE:
rally.plugins.openstack.scenarios.swift.objects

SwiftObjects.list_and_download_objects_in_containers [scenario]

List and download objects in all containers.

MODULE:
rally.plugins.openstack.scenarios.swift.objects

TempestScenario.single_test [scenario]

Launch a single Tempest test by its name.

PARAMETERS:
* test_name: name of tempest scenario for launching

* log_file: name of file for junitxml results

* tempest_conf: User specified tempest.conf location


MODULE:
rally.plugins.openstack.scenarios.tempest.tempest

TempestScenario.all [scenario]

Launch all discovered Tempest tests by their names.

PARAMETERS:
* log_file: name of file for junitxml results

* tempest_conf: User specified tempest.conf location


MODULE:
rally.plugins.openstack.scenarios.tempest.tempest

TempestScenario.set [scenario]

Launch all Tempest tests from a given set.

PARAMETERS:
* set_name: set name of tempest scenarios for launching

* log_file: name of file for junitxml results

* tempest_conf: User specified tempest.conf location


MODULE:
rally.plugins.openstack.scenarios.tempest.tempest

TempestScenario.list_of_tests [scenario]

Launch all Tempest tests from a given list of their names.

PARAMETERS:
* test_names: list of tempest scenarios for launching

* log_file: name of file for junitxml results

* tempest_conf: User specified tempest.conf location


MODULE:
rally.plugins.openstack.scenarios.tempest.tempest

TempestScenario.specific_regex [scenario]

Launch Tempest tests whose names match a given regular expression.

PARAMETERS:
* regex: regexp to match Tempest test names against

* log_file: name of file for junitxml results

* tempest_conf: User specified tempest.conf location


MODULE:
rally.plugins.openstack.scenarios.tempest.tempest

NeutronSecurityGroup.create_and_list_security_groups [scenario]

Create and list Neutron security-groups.

Measure the "neutron security-group-create" and "neutron
security-group-list" command performance.

PARAMETERS:
* security_group_create_args: dict, POST /v2.0/security-groups
                                   request options


MODULE:
rally.plugins.openstack.scenarios.neutron.security_groups

NeutronSecurityGroup.create_and_delete_security_groups [scenario]

Create and delete Neutron security-groups.

Measure the "neutron security-group-create" and "neutron
security-group-delete" command performance.

PARAMETERS:
* security_group_create_args: dict, POST /v2.0/security-groups
                                   request options


MODULE:
rally.plugins.openstack.scenarios.neutron.security_groups

NeutronSecurityGroup.create_and_update_security_groups [scenario]

Create and update Neutron security-groups.

Measure the "neutron security-group-create" and "neutron
security-group-update" command performance.

PARAMETERS:
* security_group_create_args: dict, POST /v2.0/security-groups
                                   request options

* security_group_update_args: dict, POST /v2.0/security-groups
                                   update options


MODULE:
rally.plugins.openstack.scenarios.neutron.security_groups

NeutronLoadbalancerV1.create_and_list_pools [scenario]

Create a pool(v1) and then list pools(v1).

Measure the "neutron lb-pool-list" command performance.
The scenario creates a pool for every subnet and then lists pools.

PARAMETERS:
* pool_create_args: dict, POST /lb/pools request options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_delete_pools [scenario]

Create pools(v1) and delete pools(v1).

Measure the "neutron lb-pool-create" and "neutron lb-pool-delete"
command performance. The scenario creates a pool for every subnet
and then deletes those pools.

PARAMETERS:
* pool_create_args: dict, POST /lb/pools request options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_update_pools [scenario]

Create pools(v1) and update pools(v1).

Measure the "neutron lb-pool-create" and "neutron lb-pool-update"
command performance. The scenario creates a pool for every subnet
and then update those pools.

PARAMETERS:
* pool_create_args: dict, POST /lb/pools request options

* pool_update_args: dict, POST /lb/pools update options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_list_vips [scenario]

Create a vip(v1) and then list vips(v1).

Measure the "neutron lb-vip-create" and "neutron lb-vip-list" command
performance. The scenario creates a vip for every pool created and
then lists vips.

PARAMETERS:
* vip_create_args: dict, POST /lb/vips request options

* pool_create_args: dict, POST /lb/pools request options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_delete_vips [scenario]

Create a vip(v1) and then delete vips(v1).

Measure the "neutron lb-vip-create" and "neutron lb-vip-delete"
command performance. The scenario creates a vip for pool and
then deletes those vips.

PARAMETERS:
* pool_create_args: dict, POST /lb/pools request options

* vip_create_args: dict, POST /lb/vips request options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_update_vips [scenario]

Create vips(v1) and update vips(v1).

Measure the "neutron lb-vip-create" and "neutron lb-vip-update"
command performance. The scenario creates a pool for every subnet
and then update those pools.

PARAMETERS:
* pool_create_args: dict, POST /lb/pools request options

* vip_create_args: dict, POST /lb/vips request options

* vip_update_args: dict, POST /lb/vips update options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_list_healthmonitors [scenario]

Create healthmonitors(v1) and list healthmonitors(v1).

Measure the "neutron lb-healthmonitor-list" command performance. This
scenario creates healthmonitors and lists them.

PARAMETERS:
* healthmonitor_create_args: dict, POST /lb/healthmonitors request
options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_delete_healthmonitors [scenario]

Create a healthmonitor(v1) and delete healthmonitors(v1).

Measure the "neutron lb-healthmonitor-create" and "neutron
lb-healthmonitor-delete" command performance. The scenario creates
healthmonitors and deletes those healthmonitors.

PARAMETERS:
* healthmonitor_create_args: dict, POST /lb/healthmonitors request
options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronLoadbalancerV1.create_and_update_healthmonitors [scenario]

Create a healthmonitor(v1) and update healthmonitors(v1).

Measure the "neutron lb-healthmonitor-create" and "neutron
lb-healthmonitor-update" command performance. The scenario creates
healthmonitors and then updates them.

PARAMETERS:
* healthmonitor_create_args: dict, POST /lb/healthmonitors request
options

* healthmonitor_update_args: dict, POST /lb/healthmonitors update
options


MODULE:
rally.plugins.openstack.scenarios.neutron.loadbalancer_v1

NeutronNetworks.create_and_list_networks [scenario]

Create a network and then list all networks.

Measure the "neutron net-list" command performance.

If you have only 1 user in your context, you will
add 1 network on every iteration. So you will have more
and more networks and will be able to measure the
performance of the "neutron net-list" command depending on
the number of networks owned by users.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_update_networks [scenario]

Create and update a network.

Measure the "neutron net-create and net-update" command performance.

PARAMETERS:
* network_update_args: dict, PUT /v2.0/networks update request

* network_create_args: dict, POST /v2.0/networks request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_delete_networks [scenario]

Create and delete a network.

Measure the "neutron net-create" and "net-delete" command performance.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_list_subnets [scenario]

Create and a given number of subnets and list all subnets.

The scenario creates a network, a given number of subnets and then
lists subnets.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_update_subnets [scenario]

Create and update a subnet.

The scenario creates a network, a given number of subnets
and then updates the subnet. This scenario measures the
"neutron subnet-update" command performance.

PARAMETERS:
* subnet_update_args: dict, PUT /v2.0/subnets update options

* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_delete_subnets [scenario]

Create and delete a given number of subnets.

The scenario creates a network, a given number of subnets and then
deletes subnets.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_list_routers [scenario]

Create and a given number of routers and list all routers.

Create a network, a given number of subnets and routers
and then list all routers.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network

* router_create_args: dict, POST /v2.0/routers request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_update_routers [scenario]

Create and update a given number of routers.

Create a network, a given number of subnets and routers
and then updating all routers.

PARAMETERS:
* router_update_args: dict, PUT /v2.0/routers update options

* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network

* router_create_args: dict, POST /v2.0/routers request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_delete_routers [scenario]

Create and delete a given number of routers.

Create a network, a given number of subnets and routers
and then delete all routers.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* subnet_create_args: dict, POST /v2.0/subnets request options

* subnet_cidr_start: str, start value for subnets CIDR

* subnets_per_network: int, number of subnets for one network

* router_create_args: dict, POST /v2.0/routers request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_list_ports [scenario]

Create and a given number of ports and list all ports.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* port_create_args: dict, POST /v2.0/ports request options

* ports_per_network: int, number of ports for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_update_ports [scenario]

Create and update a given number of ports.

Measure the "neutron port-create" and "neutron port-update" commands
performance.

PARAMETERS:
* port_update_args: dict, PUT /v2.0/ports update request options

* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* port_create_args: dict, POST /v2.0/ports request options

* ports_per_network: int, number of ports for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_delete_ports [scenario]

Create and delete a port.

Measure the "neutron port-create" and "neutron port-delete" commands
performance.

PARAMETERS:
* network_create_args: dict, POST /v2.0/networks request
                            options. Deprecated.

* port_create_args: dict, POST /v2.0/ports request options

* ports_per_network: int, number of ports for one network


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_list_floating_ips [scenario]

Create and list floating IPs.

Measure the "neutron floating-ip-create" and "neutron floating-ip-list"
commands performance.

PARAMETERS:
* floating_network: str, external network for floating IP creation

* floating_ip_args: dict, POST /floatingips request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

NeutronNetworks.create_and_delete_floating_ips [scenario]

Create and delete floating IPs.

Measure the "neutron floating-ip-create" and "neutron
floating-ip-delete" commands performance.

PARAMETERS:
* floating_network: str, external network for floating IP creation

* floating_ip_args: dict, POST /floatingips request options


MODULE:
rally.plugins.openstack.scenarios.neutron.network

DesignateBasic.create_and_list_domains [scenario]

Create a domain and list all domains.

Measure the "designate domain-list" command performance.

If you have only 1 user in your context, you will
add 1 domain on every iteration. So you will have more
and more domain and will be able to measure the
performance of the "designate domain-list" command depending on
the number of domains owned by users.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.list_domains [scenario]

List Designate domains.

This simple scenario tests the designate domain-list command by listing
all the domains.

Suppose if we have 2 users in context and each has 2 domains
uploaded for them we will be able to test the performance of
designate domain-list command in this case.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_delete_domain [scenario]

Create and then delete a domain.

Measure the performance of creating and deleting domains
with different level of load.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_update_domain [scenario]

Create and then update a domain.

Measure the performance of creating and updating domains
with different level of load.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_delete_records [scenario]

Create and then delete records.

Measure the performance of creating and deleting records
with different level of load.

PARAMETERS:
* records_per_domain: Records to create pr domain.


MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.list_records [scenario]

List Designate records.

This simple scenario tests the designate record-list command by listing
all the records in a domain.

Suppose if we have 2 users in context and each has 2 domains
uploaded for them we will be able to test the performance of
designate record-list command in this case.

PARAMETERS:
* domain_id: Domain ID


MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_list_records [scenario]

Create and then list records.

If you have only 1 user in your context, you will
add 1 record on every iteration. So you will have more
and more records and will be able to measure the
performance of the "designate record-list" command depending on
the number of domains/records owned by users.

PARAMETERS:
* records_per_domain: Records to create pr domain.


MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_list_servers [scenario]

Create a Designate server and list all servers.

If you have only 1 user in your context, you will
add 1 server on every iteration. So you will have more
and more server and will be able to measure the
performance of the "designate server-list" command depending on
the number of servers owned by users.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_delete_server [scenario]

Create and then delete a server.

Measure the performance of creating and deleting servers
with different level of load.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.list_servers [scenario]

List Designate servers.

This simple scenario tests the designate server-list command by listing
all the servers.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_list_zones [scenario]

Create a zone and list all zones.

Measure the "openstack zone list" command performance.

If you have only 1 user in your context, you will
add 1 zone on every iteration. So you will have more
and more zone and will be able to measure the
performance of the "openstack zone list" command depending on
the number of zones owned by users.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.list_zones [scenario]

List Designate zones.

This simple scenario tests the openstack zone list command by listing
all the zones.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.create_and_delete_zone [scenario]

Create and then delete a zone.

Measure the performance of creating and deleting zones
with different level of load.

MODULE:
rally.plugins.openstack.scenarios.designate.basic

DesignateBasic.list_recordsets [scenario]

List Designate recordsets.

This simple scenario tests the openstack recordset list command by
listing all the recordsets in a zone.

PARAMETERS:
* zone_id: Zone ID


MODULE:
rally.plugins.openstack.scenarios.designate.basic

Authenticate.keystone [scenario]

Check Keystone Client.

MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_glance [scenario]

Check Glance Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.
In following we are checking for non-existent image.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_nova [scenario]

Check Nova Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_cinder [scenario]

Check Cinder Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_neutron [scenario]

Check Neutron Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_heat [scenario]

Check Heat Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

Authenticate.validate_monasca [scenario]

Check Monasca Client to ensure validation of token.

Creation of the client does not ensure validation of the token.
We have to do some minimal operation to make sure token gets validated.

PARAMETERS:
* repetitions: number of times to validate


MODULE:
rally.plugins.openstack.scenarios.authenticate.authenticate

EC2Servers.list_servers [scenario]

List all servers.

This simple scenario tests the EC2 API list function by listing
all the servers.

MODULE:
rally.plugins.openstack.scenarios.ec2.servers

EC2Servers.boot_server [scenario]

Boot a server.

Assumes that cleanup is done elsewhere.

PARAMETERS:
* image: image to be used to boot an instance

* flavor: flavor to be used to boot an instance

* kwargs: optional additional arguments for server creation


MODULE:
rally.plugins.openstack.scenarios.ec2.servers

CinderVolumes.create_and_list_volume [scenario]

Create a volume and list all volumes.

Measure the "cinder volume-list" command performance.

If you have only 1 user in your context, you will
add 1 volume on every iteration. So you will have more
and more volumes and will be able to measure the
performance of the "cinder volume-list" command depending on
the number of images owned by users.

PARAMETERS:
* size: volume size (integer, in GB) or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* detailed: determines whether the volume listing should contain
                 detailed information about all of them

* image: image to be used to create volume

* kwargs: optional args to create a volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.list_volumes [scenario]

List all volumes.

This simple scenario tests the cinder list command by listing
all the volumes.

PARAMETERS:
* detailed: True if detailed information about volumes
                 should be listed


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_update_volume [scenario]

Create a volume and update its name and description.

PARAMETERS:
* size: volume size (integer, in GB)

* image: image to be used to create volume

* create_volume_kwargs: dict, to be used to create volume

* update_volume_kwargs: dict, to be used to update volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_delete_volume [scenario]

Create and then delete a volume.

Good for testing a maximal bandwidth of cloud. Optional 'min_sleep'
and 'max_sleep' parameters allow the scenario to simulate a pause
between volume creation and deletion (of random duration from
[min_sleep, max_sleep]).

PARAMETERS:
* size: volume size (integer, in GB) or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* image: image to be used to create volume

* min_sleep: minimum sleep time between volume creation and
                  deletion (in seconds)

* max_sleep: maximum sleep time between volume creation and
                  deletion (in seconds)

* kwargs: optional args to create a volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_volume [scenario]

Create a volume.

Good test to check how influence amount of active volumes on
performance of creating new.

PARAMETERS:
* size: volume size (integer, in GB) or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* image: image to be used to create volume

* kwargs: optional args to create a volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.modify_volume_metadata [scenario]

Modify a volume's metadata.

This requires a volume to be created with the volumes
context. Additionally, ``sets * set_size`` must be greater
than or equal to ``deletes * delete_size``.

PARAMETERS:
* sets: how many set_metadata operations to perform

* set_size: number of metadata keys to set in each
                 set_metadata operation

* deletes: how many delete_metadata operations to perform

* delete_size: number of metadata keys to delete in each
                    delete_metadata operation


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_extend_volume [scenario]

Create and extend a volume and then delete it.

PARAMETERS:
* size: volume size (in GB) or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* new_size: volume new size (in GB) or
                dictionary, must contain two values:
                     min - minimum size volumes will be created as;
                     max - maximum size volumes will be created as.
                to extend.
                Notice: should be bigger volume size

* min_sleep: minimum sleep time between volume extension and
                  deletion (in seconds)

* max_sleep: maximum sleep time between volume extension and
                  deletion (in seconds)

* kwargs: optional args to extend the volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_from_volume_and_delete_volume [scenario]

Create volume from volume and then delete it.

Scenario for testing volume clone.Optional 'min_sleep' and 'max_sleep'
parameters allow the scenario to simulate a pause between volume
creation and deletion (of random duration from [min_sleep, max_sleep]).

PARAMETERS:
* size: volume size (in GB), or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.
             Should be equal or bigger source volume size


* min_sleep: minimum sleep time between volume creation and
                  deletion (in seconds)

* max_sleep: maximum sleep time between volume creation and
                  deletion (in seconds)

* kwargs: optional args to create a volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_delete_snapshot [scenario]

Create and then delete a volume-snapshot.

Optional 'min_sleep' and 'max_sleep' parameters allow the scenario
to simulate a pause between snapshot creation and deletion
(of random duration from [min_sleep, max_sleep]).

PARAMETERS:
* force: when set to True, allows snapshot of a volume when
              the volume is attached to an instance

* min_sleep: minimum sleep time between snapshot creation and
                  deletion (in seconds)

* max_sleep: maximum sleep time between snapshot creation and
                  deletion (in seconds)

* kwargs: optional args to create a snapshot


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_attach_volume [scenario]

Create a VM and attach a volume to it.

Simple test to create a VM and attach a volume, then
detach the volume and delete volume/VM.

PARAMETERS:
* size: volume size (integer, in GB) or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* image: Glance image name to use for the VM

* flavor: VM flavor name

* create_volume_params: optional arguments for volume creation

* create_vm_params: optional arguments for VM creation

* kwargs: (deprecated) optional arguments for VM creation


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_snapshot_and_attach_volume [scenario]

Create volume, snapshot and attach/detach volume.

This scenario is based on the standalone qaStressTest.py
(https://github.com/WaltHP/cinder-stress).

PARAMETERS:
* volume_type: Whether or not to specify volume type when creating
                    volumes.

* size: Volume size - dictionary, contains two values:
                min - minimum size volumes will be created as;
                max - maximum size volumes will be created as.
             default values: {"min": 1, "max": 5}

* kwargs: Optional parameters used during volume
               snapshot creation.


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_nested_snapshots_and_attach_volume [scenario]

Create a volume from snapshot and attach/detach the volume

This scenario create volume, create it's snapshot, attach volume,
then create new volume from existing snapshot and so on,
with defined nested level, after all detach and delete them.
volume->snapshot->volume->snapshot->volume ...

PARAMETERS:
* size: Volume size - dictionary, contains two values:
                min - minimum size volumes will be created as;
                max - maximum size volumes will be created as.
             default values: {"min": 1, "max": 5}

* nested_level: Nested level - dictionary or int, dictionary
                     contains two values:
                       min - minimum number of volumes will be created
                             from snapshot;
                       max - maximum number of volumes will be created
                             from snapshot.
                     due to its deprecated would be taken min value.
                     int, means the exact nested level.
                     default value: 1.

* kwargs: Optional parameters used during volume
               snapshot creation.


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_list_snapshots [scenario]

Create and then list a volume-snapshot.

PARAMETERS:
* force: when set to True, allows snapshot of a volume when
              the volume is attached to an instance

* detailed: True if detailed information about snapshots
                 should be listed

* kwargs: optional args to create a snapshot


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_upload_volume_to_image [scenario]

Create and upload a volume to image.

PARAMETERS:
* size: volume size (integers, in GB), or
             dictionary, must contain two values:
                 min - minimum size volumes will be created as;
                 max - maximum size volumes will be created as.

* force: when set to True volume that is attached to an instance
              could be uploaded to image

* container_format: image container format

* disk_format: disk format for image

* do_delete: deletes image and volume after uploading if True

* kwargs: optional args to create a volume


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_volume_backup [scenario]

Create a volume backup.

PARAMETERS:
* size: volume size in GB

* do_delete: if True, a volume and a volume backup will
                  be deleted after creation.

* create_volume_kwargs: optional args to create a volume

* create_backup_kwargs: optional args to create a volume backup


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_restore_volume_backup [scenario]

Restore volume backup.

PARAMETERS:
* size: volume size in GB

* do_delete: if True, the volume and the volume backup will
                  be deleted after creation.

* create_volume_kwargs: optional args to create a volume

* create_backup_kwargs: optional args to create a volume backup


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

CinderVolumes.create_and_list_volume_backups [scenario]

Create and then list a volume backup.

PARAMETERS:
* size: volume size in GB

* detailed: True if detailed information about backup
                 should be listed

* do_delete: if True, a volume backup will be deleted

* create_volume_kwargs: optional args to create a volume

* create_backup_kwargs: optional args to create a volume backup


MODULE:
rally.plugins.openstack.scenarios.cinder.volumes

SaharaClusters.create_and_delete_cluster [scenario]

Launch and delete a Sahara Cluster.

This scenario launches a Hadoop cluster, waits until it becomes
'Active' and deletes it.

PARAMETERS:
* flavor: Nova flavor that will be for nodes in the
               created node groups. Deprecated.

* master_flavor: Nova flavor that will be used for the master
                      instance of the cluster

* worker_flavor: Nova flavor that will be used for the workers of
                      the cluster

* workers_count: number of worker instances in a cluster

* plugin_name: name of a provisioning plugin

* hadoop_version: version of Hadoop distribution supported by
                       the specified plugin.

* floating_ip_pool: floating ip pool name from which Floating
                         IPs will be allocated. Sahara will determine
                         automatically how to treat this depending on
                         its own configurations. Defaults to None
                         because in some cases Sahara may work w/o
                         Floating IPs.

* volumes_per_node: number of Cinder volumes that will be
                         attached to every cluster node

* volumes_size: size of each Cinder volume in GB

* auto_security_group: boolean value. If set to True Sahara will
                            create a Security Group for each Node Group
                            in the Cluster automatically.

* security_groups: list of security groups that will be used
                        while creating VMs. If auto_security_group
                        is set to True, this list can be left empty.

* node_configs: config dict that will be passed to each Node
                     Group

* cluster_configs: config dict that will be passed to the
                        Cluster

* enable_anti_affinity: If set to true the vms will be scheduled
                             one per compute node.

* enable_proxy: Use Master Node of a Cluster as a Proxy node and
                     do not assign floating ips to workers.


MODULE:
rally.plugins.openstack.scenarios.sahara.clusters

SaharaClusters.create_scale_delete_cluster [scenario]

Launch, scale and delete a Sahara Cluster.

This scenario launches a Hadoop cluster, waits until it becomes
'Active'. Then a series of scale operations is applied. The scaling
happens according to numbers listed in

PARAMETERS:
* flavor: Nova flavor that will be for nodes in the
               created node groups. Deprecated.

* master_flavor: Nova flavor that will be used for the master
                      instance of the cluster

* worker_flavor: Nova flavor that will be used for the workers of
                      the cluster

* workers_count: number of worker instances in a cluster

* plugin_name: name of a provisioning plugin

* hadoop_version: version of Hadoop distribution supported by
                       the specified plugin.

* deltas: list of integers which will be used to add or
               remove worker nodes from the cluster

* floating_ip_pool: floating ip pool name from which Floating
                         IPs will be allocated. Sahara will determine
                         automatically how to treat this depending on
                         its own configurations. Defaults to None
                         because in some cases Sahara may work w/o
                         Floating IPs.

* neutron_net_id: id of a Neutron network that will be used
                       for fixed IPs. This parameter is ignored when
                       Nova Network is set up.

* volumes_per_node: number of Cinder volumes that will be
                         attached to every cluster node

* volumes_size: size of each Cinder volume in GB

* auto_security_group: boolean value. If set to True Sahara will
                            create a Security Group for each Node Group
                            in the Cluster automatically.

* security_groups: list of security groups that will be used
                        while creating VMs. If auto_security_group
                        is set to True this list can be left empty.

* node_configs: configs dict that will be passed to each Node
                     Group

* cluster_configs: configs dict that will be passed to the
                        Cluster

* enable_anti_affinity: If set to true the vms will be scheduled
                             one per compute node.

* enable_proxy: Use Master Node of a Cluster as a Proxy node and
                     do not assign floating ips to workers.


MODULE:
rally.plugins.openstack.scenarios.sahara.clusters

SaharaNodeGroupTemplates.create_and_list_node_group_templates [scenario]

Create and list Sahara Node Group Templates.

This scenario creates two Node Group Templates with different set of
node processes. The master Node Group Template contains Hadoop's
management processes. The worker Node Group Template contains
Hadoop's worker processes.

By default the templates are created for the vanilla Hadoop
provisioning plugin using the version 1.2.1

After the templates are created the list operation is called.

PARAMETERS:
* flavor: Nova flavor that will be for nodes in the
               created node groups

* plugin_name: name of a provisioning plugin

* hadoop_version: version of Hadoop distribution supported by
                       the specified plugin.


MODULE:
rally.plugins.openstack.scenarios.sahara.node_group_templates

SaharaNodeGroupTemplates.create_delete_node_group_templates [scenario]

Create and delete Sahara Node Group Templates.

This scenario creates and deletes two most common types of
Node Group Templates.

By default the templates are created for the vanilla Hadoop
provisioning plugin using the version 1.2.1

PARAMETERS:
* flavor: Nova flavor that will be for nodes in the
               created node groups

* plugin_name: name of a provisioning plugin

* hadoop_version: version of Hadoop distribution supported by
                       the specified plugin.


MODULE:
rally.plugins.openstack.scenarios.sahara.node_group_templates

SaharaJob.create_launch_job [scenario]

Create and execute a Sahara EDP Job.

This scenario Creates a Job entity and launches an execution on a
Cluster.

PARAMETERS:
* job_type: type of the Data Processing Job

* configs: config dict that will be passed to a Job Execution

* job_idx: index of a job in a sequence. This index will be
                used to create different atomic actions for each job
                in a sequence


MODULE:
rally.plugins.openstack.scenarios.sahara.jobs

SaharaJob.create_launch_job_sequence [scenario]

Create and execute a sequence of the Sahara EDP Jobs.

This scenario Creates a Job entity and launches an execution on a
Cluster for every job object provided.

PARAMETERS:
* jobs: list of jobs that should be executed in one context


MODULE:
rally.plugins.openstack.scenarios.sahara.jobs

SaharaJob.create_launch_job_sequence_with_scaling [scenario]

Create and execute Sahara EDP Jobs on a scaling Cluster.

This scenario Creates a Job entity and launches an execution on a
Cluster for every job object provided. The Cluster is scaled according
to the deltas values and the sequence is launched again.

PARAMETERS:
* jobs: list of jobs that should be executed in one context

* deltas: list of integers which will be used to add or
               remove worker nodes from the cluster


MODULE:
rally.plugins.openstack.scenarios.sahara.jobs

MuranoEnvironments.list_environments [scenario]

List the murano environments.

Run murano environment-list for listing all environments.

MODULE:
rally.plugins.openstack.scenarios.murano.environments

MuranoEnvironments.create_and_delete_environment [scenario]

Create environment, session and delete environment.

MODULE:
rally.plugins.openstack.scenarios.murano.environments

MuranoEnvironments.create_and_deploy_environment [scenario]

Create environment, session and deploy environment.

Create environment, create session, add app to environment
packages_per_env times, send environment to deploy.

PARAMETERS:
* packages_per_env: number of packages per environment


MODULE:
rally.plugins.openstack.scenarios.murano.environments

MuranoPackages.import_and_list_packages [scenario]

Import Murano package and get list of packages.

Measure the "murano import-package" and "murano package-list" commands
performance.
It imports Murano package from "package" (if it is not a zip archive
then zip archive will be prepared) and gets list of imported packages.

PARAMETERS:
* package: path to zip archive that represents Murano
                application package or absolute path to folder with
                package components

* include_disabled: specifies whether the disabled packages will
                         be included in a the result or not.
                         Default value is False.


MODULE:
rally.plugins.openstack.scenarios.murano.packages

MuranoPackages.import_and_delete_package [scenario]

Import Murano package and then delete it.

Measure the "murano import-package" and "murano package-delete"
commands performance.
It imports Murano package from "package" (if it is not a zip archive
then zip archive will be prepared) and deletes it.

PARAMETERS:
* package: path to zip archive that represents Murano
                application package or absolute path to folder with
                package components


MODULE:
rally.plugins.openstack.scenarios.murano.packages

MuranoPackages.package_lifecycle [scenario]

Import Murano package, modify it and then delete it.

Measure the Murano import, update and delete package
commands performance.
It imports Murano package from "package" (if it is not a zip archive
then zip archive will be prepared), modifies it (using data from
"body") and deletes.

PARAMETERS:
* package: path to zip archive that represents Murano
                application package or absolute path to folder with
                package components

* body: dict object that defines what package property will be
             updated, e.g {"tags": ["tag"]} or {"enabled": "true"}

* operation: string object that defines the way of how package
                  property will be updated, allowed operations are
                  "add", "replace" or "delete".
                  Default value is "replace".


MODULE:
rally.plugins.openstack.scenarios.murano.packages

MuranoPackages.import_and_filter_applications [scenario]

Import Murano package and then filter packages by some criteria.

Measure the performance of package import and package
filtering commands.
It imports Murano package from "package" (if it is not a zip archive
then zip archive will be prepared) and filters packages by some
criteria.

PARAMETERS:
* package: path to zip archive that represents Murano
                application package or absolute path to folder with
                package components

* filter_query: dict that contains filter criteria, lately it
                     will be passed as **kwargs to filter method
                     e.g. {"category": "Web"}


MODULE:
rally.plugins.openstack.scenarios.murano.packages

IronicNodes.create_and_list_node [scenario]

Create and list nodes.

PARAMETERS:
* associated: Optional. Either a Boolean or a string
                   representation of a Boolean that indicates whether
                   to return a list of associated (True or "True") or
                   unassociated (False or "False") nodes.

* maintenance: Optional. Either a Boolean or a string
                    representation of a Boolean that indicates whether
                    to return nodes in maintenance mode (True or
                    "True"), or not in maintenance mode (False or
                    "False").

* marker: Optional, the UUID of a node, eg the last
               node from a previous result set. Return
               the next result set.

* limit: The maximum number of results to return per
              request, if:
    1) limit > 0, the maximum number of nodes to return.
    2) limit == 0, return the entire list of nodes.
    3) limit param is NOT specified (None), the number of items
       returned respect the maximum imposed by the Ironic API
       (see Ironic's api.max_limit option).

* detail: Optional, boolean whether to return detailed
               information about nodes.

* sort_key: Optional, field used for sorting.

* sort_dir: Optional, direction of sorting, either 'asc' (the
                 default) or 'desc'.

* kwargs: Optional additional arguments for node creation


MODULE:
rally.plugins.openstack.scenarios.ironic.nodes

IronicNodes.create_and_delete_node [scenario]

Create and delete node.

PARAMETERS:
* kwargs: Optional additional arguments for node creation


MODULE:
rally.plugins.openstack.scenarios.ironic.nodes

GlanceImages.create_and_list_image [scenario]

Create an image and then list all images.

Measure the "glance image-list" command performance.

If you have only 1 user in your context, you will
add 1 image on every iteration. So you will have more
and more images and will be able to measure the
performance of the "glance image-list" command depending on
the number of images owned by users.

PARAMETERS:
* container_format: container format of image. Acceptable
                         formats: ami, ari, aki, bare, and ovf

* image_location: image file location

* disk_format: disk format of image. Acceptable formats:
                    ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso

* kwargs: optional parameters to create image


MODULE:
rally.plugins.openstack.scenarios.glance.images

GlanceImages.list_images [scenario]

List all images.

This simple scenario tests the glance image-list command by listing
all the images.

Suppose if we have 2 users in context and each has 2 images
uploaded for them we will be able to test the performance of
glance image-list command in this case.

MODULE:
rally.plugins.openstack.scenarios.glance.images

GlanceImages.create_and_delete_image [scenario]

Create and then delete an image.

PARAMETERS:
* container_format: container format of image. Acceptable
                         formats: ami, ari, aki, bare, and ovf

* image_location: image file location

* disk_format: disk format of image. Acceptable formats:
                    ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso

* kwargs: optional parameters to create image


MODULE:
rally.plugins.openstack.scenarios.glance.images

GlanceImages.create_image_and_boot_instances [scenario]

Create an image and boot several instances from it.

PARAMETERS:
* container_format: container format of image. Acceptable
                         formats: ami, ari, aki, bare, and ovf

* image_location: image file location

* disk_format: disk format of image. Acceptable formats:
                    ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso

* flavor: Nova flavor to be used to launch an instance

* number_instances: number of Nova servers to boot

* kwargs: optional parameters to create server


MODULE:
rally.plugins.openstack.scenarios.glance.images

Dummy.dummy [scenario]

Do nothing and sleep for the given number of seconds (0 by default).

Dummy.dummy can be used for testing performance of different
ScenarioRunners and of the ability of rally to store a large
amount of results.

PARAMETERS:
* sleep: idle time of method (in seconds).


MODULE:
rally.plugins.common.scenarios.dummy.dummy

Dummy.dummy_exception [scenario]

Throw an exception.

Dummy.dummy_exception can be used for test if exceptions are processed
properly by ScenarioRunners and benchmark and analyze rally
results storing process.

PARAMETERS:
* size_of_message: int size of the exception message

* sleep: idle time of method (in seconds).

* message: message of the exception



MODULE:
rally.plugins.common.scenarios.dummy.dummy

Dummy.dummy_exception_probability [scenario]

Throw an exception with given probability.

Dummy.dummy_exception_probability can be used to test if exceptions
are processed properly by ScenarioRunners. This scenario will throw
an exception sometimes, depending on the given exception probability.

PARAMETERS:
* exception_probability: Sets how likely it is that an exception
                              will be thrown. Float between 0 and 1
                              0=never 1=always.


MODULE:
rally.plugins.common.scenarios.dummy.dummy

Dummy.dummy_output [scenario]

Generate dummy output.

This scenario generates example of output data.

PARAMETERS:
* random_range: max int limit for generated random values


MODULE:
rally.plugins.common.scenarios.dummy.dummy

Dummy.dummy_with_scenario_output [scenario]

Return a dummy scenario output.

Dummy.dummy_with_scenario_output can be used to test the scenario
output processing.

MODULE:
rally.plugins.common.scenarios.dummy.dummy

Dummy.dummy_random_fail_in_atomic [scenario]

Randomly throw exceptions in atomic actions.

Dummy.dummy_random_fail_in_atomic can be used to test atomic actions
failures processing.

PARAMETERS:
* exception_probability: Probability with which atomic actions
                              fail in this dummy scenario (0 <= p <= 1)


MODULE:
rally.plugins.common.scenarios.dummy.dummy

HttpRequests.check_request [scenario]

Standard way to benchmark web services.

This benchmark is used to make request and check it with expected
Response.

PARAMETERS:
* url: url for the Request object

* method: method for the Request object

* status_code: expected response code

* kwargs: optional additional request parameters


MODULE:
rally.plugins.common.scenarios.requests.http_requests

HttpRequests.check_random_request [scenario]

Benchmark the list of requests

This scenario takes random url from list of requests, and raises
exception if the response is not the expected response.

PARAMETERS:
* requests: List of request dicts

* status_code: Expected Response Code it will
be used only if we doesn't specified it in request proper


MODULE:
rally.plugins.common.scenarios.requests.http_requests

Engines [deployment]

ExistingCloud [engine]

Just use an existing OpenStack deployment without deploying anything.

To use ExistingCloud, you should put credential information to the config:

    {
        "type": "ExistingCloud",
        "auth_url": "http://localhost:5000/v2.0/",
        "region_name": "RegionOne",
        "endpoint_type": "public",
        "admin": {
            "username": "admin",
            "password": "password",
            "tenant_name": "demo"
        },
        "https_insecure": False,
        "https_cacert": "",
    }

Or, using keystone v3 API endpoint:

    {
        "type": "ExistingCloud",
        "auth_url": "http://localhost:5000/v3/",
        "region_name": "RegionOne",
        "endpoint_type": "public",
        "admin": {
            "username": "admin",
            "password": "admin",
            "user_domain_name": "admin",
            "project_name": "admin",
            "project_domain_name": "admin",
        },
        "https_insecure": False,
        "https_cacert": "",
    }

MODULE:
rally.deployment.engines.existing

MultihostEngine [engine]

Deploy multihost cloud with existing engines.

Sample configuration:

    {
        "type": "MultihostEngine",
        "controller": {
            "type": "DevstackEngine",
            "provider": {
                "type": "DummyProvider"
            }
        },
        "nodes": [
            {"type": "Engine1", "config": "Config1"},
            {"type": "Engine2", "config": "Config2"},
            {"type": "Engine3", "config": "Config3"},
        ]
    }

If {controller_ip} is specified in configuration values, it will be
replaced with controller address taken from credential returned by
controller engine:

    ...
    "nodes": [
        {
            "type": "DevstackEngine",
            "local_conf": {
                "GLANCE_HOSTPORT": "{controller_ip}:9292",
    ...

MODULE:
rally.deployment.engines.multihost

LxcEngine [engine]

Deploy with other engines in lxc containers.

Sample configuration:

    {
        "type": "LxcEngine",
        "provider": {
            "type": "DummyProvider",
            "credentials": [{"user": "root", "host": "example.net"}]
        },
        "distribution": "ubuntu",
        "release": "raring",
        "tunnel_to": ["10.10.10.10", "10.10.10.11"],
        "start_lxc_network": "10.1.1.0/24",
        "container_name_prefix": "devstack-node",
        "containers_per_host": 16,
        "start_script": "~/start.sh",
        "engine": { ... }
    }

MODULE:
rally.deployment.engines.lxc

DevstackEngine [engine]

Deploy Devstack cloud.

Sample configuration:

    {
        "type": "DevstackEngine",
        "devstack_repo": "https://example.com/devstack/",
        "local_conf": {
            "ADMIN_PASSWORD": "secret"
        },
        "provider": {
            "type": "ExistingServers",
            "credentials": [{"user": "root", "host": "10.2.0.8"}]
        }
    }

MODULE:
rally.deployment.engines.devstack

Server Providers [deployment]

LxcProvider [server provider]

Provide lxc container(s) on given host.

Sample configuration:
{
    "type": "LxcProvider",
    "distribution": "ubuntu",
    "start_lxc_network": "10.1.1.0/24",
    "containers_per_host": 32,
    "tunnel_to": ["10.10.10.10"],
    "forward_ssh": false,
    "container_name_prefix": "rally-multinode-02",
    "host_provider": {
        "type": "ExistingServers",
        "credentials": [{"user": "root", "host": "host.net"}]
    }
}

MODULE:
rally.deployment.serverprovider.providers.lxc

ExistingServers [server provider]

Just return endpoints from its own configuration.

Sample configuration:

    {
        "type": "ExistingServers",
        "credentials": [{"user": "root", "host": "localhost"}]
    }

MODULE:
rally.deployment.serverprovider.providers.existing

CobblerProvider [server provider]

Creates servers via PXE boot from given cobbler selector.

Cobbler selector may contain a combination of fields
to select a number of system. It's user responsibility to provide selector
which selects something. Since cobbler stores servers password encrypted
the user needs to specify it configuration. All servers selected must have
the same password.

Sample configuration:

    {
        'type': 'CobblerProvider',
        'host': '172.29.74.8',
        'user': 'cobbler',
        'password': 'cobbler',
        'system_password': 'password'
        'selector': {'profile': 'cobbler_profile_name', 'owners': 'user1'}
    }

MODULE:
rally.deployment.serverprovider.providers.cobbler

VirshProvider [server provider]

Create VMs from prebuilt templates.

Sample configuration:

    {
        "type": "VirshProvider",
        "connection": "alex@performance-01",  # ssh connection to vms host
        "template_name": "stack-01-devstack-template",  # vm image template
        "template_user": "ubuntu",  # vm user to launch devstack
        "template_password": "password" # vm password to launch devstack
    }

MODULE:
rally.deployment.serverprovider.providers.virsh

OpenStackProvider [server provider]

Provide VMs using an existing OpenStack cloud.

Sample configuration:

       {
           "type": "OpenStackProvider",
           "amount": 42
           "user": "admin",
           "tenant": "admin",
           "password": "secret",
           "auth_url": "http://example.com/",
           "flavor_id": 2,
           "image": {
               "checksum": "75846dd06e9fcfd2b184aba7fa2b2a8d",
               "url": "http://example.com/disk1.img",
               "name": "Ubuntu Precise(added by rally)",
               "format": "qcow2",
               "userdata": "#cloud-config
disable_root: false"
           },
           "secgroup_name": "Rally"
       }

MODULE:
rally.deployment.serverprovider.providers.openstack