openstack/rally
Code Issues Proposed changes

Merge "add ability to refer deployment by uuid or name"

Browse Source
This commit is contained in:
Jenkins 2014-11-21 16:31:06 +00:00 committed by Gerrit Code Review
commit cae77b17da
29 changed files with 341 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/source/usage.rst
View File

@ -59,8 +59,8 @@ Note the last line in the output. It says that the just created deployment is no
.. code-block:: none
$ rally use deployment --deploy-id=<Another deployment UUID>
Using deployment : <Another deployment UUID>
$ rally use deployment <Another deployment name or UUID>
Using deployment : <Another deployment name or UUID>
Finally, the **deployment check** command enables you to verify that your current deployment is healthy and ready to be benchmarked:

69
rally/cmd/commands/deployment.py
View File

@ -117,50 +117,53 @@ class DeploymentCommands(object):
except jsonschema.ValidationError:
print(_("Config schema validation error: %s.") % sys.exc_info()[1])
return(1)
except exceptions.DeploymentNameExists:
print(_("Error: %s") % sys.exc_info()[1])
return(1)
self.list(deployment_list=[deployment])
if do_use:
use.UseCommands().deployment(deployment['uuid'])
@cliutils.args('--uuid', dest='deploy_id', type=str, required=False,
help='UUID of a deployment.')
@envutils.with_default_deploy_id
def recreate(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment.')
@envutils.with_default_deployment
def recreate(self, deployment=None):
"""Destroy and create an existing deployment.
Unlike 'deployment destroy' command deployment database record will
not be deleted, so deployment's UUID stay same.
:param deploy_id: a UUID of the deployment
:param deployment: a UUID or name of the deployment
"""
api.recreate_deploy(deploy_id)
api.recreate_deploy(deployment)
@cliutils.args('--uuid', dest='deploy_id', type=str, required=False,
help='UUID of a deployment.')
@envutils.with_default_deploy_id
def destroy(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment.')
@envutils.with_default_deployment
def destroy(self, deployment=None):
"""Destroy existing deployment.
This will delete all containers, virtual machines, OpenStack instances
or Fuel clusters created during Rally deployment creation. Also it will
remove deployment record from Rally database.
:param deploy_id: a UUID of the deployment
:param deployment: a UUID or name of the deployment
"""
api.destroy_deploy(deploy_id)
api.destroy_deploy(deployment)
def list(self, deployment_list=None):
"""List existing deployments."""
headers = ['uuid', 'created_at', 'name', 'status', 'active']
current_deploy_id = envutils.get_global('RALLY_DEPLOYMENT')
current_deployment = envutils.get_global('RALLY_DEPLOYMENT')
deployment_list = deployment_list or db.deployment_list()
table_rows = []
if deployment_list:
for t in deployment_list:
r = [str(t[column]) for column in headers[:-1]]
r.append("" if t["uuid"] != current_deploy_id else "*")
r.append("" if t["uuid"] != current_deployment else "*")
table_rows.append(utils.Struct(**dict(zip(headers, r))))
common_cliutils.print_list(table_rows, headers,
sortby_index=headers.index(
@ -170,35 +173,35 @@ class DeploymentCommands(object):
"To create a new deployment, use:"
"\nrally deployment create"))
@cliutils.args('--uuid', dest='deploy_id', type=str, required=False,
help='UUID of a deployment.')
@envutils.with_default_deploy_id
def config(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment.')
@envutils.with_default_deployment
def config(self, deployment=None):
"""Display configuration of the deployment.
Output is the configuration of the deployment in a
pretty-printed JSON format.
:param deploy_id: a UUID of the deployment
:param deployment: a UUID or name of the deployment
"""
deploy = db.deployment_get(deploy_id)
result = deploy['config']
deploy = db.deployment_get(deployment)
result = deploy["config"]
print(json.dumps(result, sort_keys=True, indent=4))
@cliutils.args('--uuid', dest='deploy_id', type=str, required=False,
help='UUID of a deployment.')
@envutils.with_default_deploy_id
def show(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment.')
@envutils.with_default_deployment
def show(self, deployment=None):
"""Show the endpoints of the deployment.
:param deploy_id: a UUID of the deployment
:param deployment: a UUID or name of the deployment
"""
headers = ['auth_url', 'username', 'password', 'tenant_name',
'region_name', 'endpoint_type', 'admin_port']
table_rows = []
deployment = db.deployment_get(deploy_id)
deployment = db.deployment_get(deployment)
users = deployment.get("users", [])
admin = deployment.get("admin")
endpoints = users + [admin] if admin else users
@ -208,19 +211,19 @@ class DeploymentCommands(object):
table_rows.append(utils.Struct(**dict(zip(headers, data))))
common_cliutils.print_list(table_rows, headers)
@cliutils.args('--uuid', dest='deploy_id', type=str, required=False,
help='UUID of a deployment.')
@envutils.with_default_deploy_id
def check(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment.')
@envutils.with_default_deployment
def check(self, deployment=None):
"""Check keystone authentication and list all available services.
:param deploy_id: a UUID of the deployment
:param deployment: a UUID or name of the deployment
"""
headers = ['services', 'type', 'status']
table_rows = []
try:
admin = db.deployment_get(deploy_id)['admin']
admin = db.deployment_get(deployment)['admin']
# TODO(boris-42): make this work for users in future
for endpoint_dict in [admin]:
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))

58
rally/cmd/commands/show.py
View File

@ -35,20 +35,20 @@ class ShowCommands(object):
cloud represented by deployment.
"""
def _get_endpoints(self, deploy_id):
deployment = db.deployment_get(deploy_id)
def _get_endpoints(self, deployment):
deployment = db.deployment_get(deployment)
admin = deployment.get("admin")
admin = [admin] if admin else []
return admin + deployment.get("users", [])
@cliutils.args('--deploy-id', dest='deploy_id', type=str, required=False,
help='the UUID of a deployment')
@envutils.with_default_deploy_id
def images(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment')
@envutils.with_default_deployment
def images(self, deployment=None):
"""Display available images.
:param deploy_id: the UUID of a deployment
:param deployment: UUID or name of a deployment
"""
headers = ['UUID', 'Name', 'Size (B)']
@ -60,7 +60,7 @@ class ShowCommands(object):
for col in float_cols]))
try:
for endpoint_dict in self._get_endpoints(deploy_id):
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))
glance_client = clients.glance()
for image in glance_client.images.list():
@ -76,13 +76,13 @@ class ShowCommands(object):
print(_("Authentication Issues: %s") % e)
return(1)
@cliutils.args('--deploy-id', dest='deploy_id', type=str, required=False,
help='the UUID of a deployment')
@envutils.with_default_deploy_id
def flavors(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment')
@envutils.with_default_deployment
def flavors(self, deployment=None):
"""Display available flavors.
:param deploy_id: the UUID of a deployment
:param deployment: UUID or name of a deployment
"""
headers = ['ID', 'Name', 'vCPUs', 'RAM (MB)', 'Swap (MB)', 'Disk (GB)']
@ -93,7 +93,7 @@ class ShowCommands(object):
for col in float_cols]))
table_rows = []
try:
for endpoint_dict in self._get_endpoints(deploy_id):
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for flavor in nova_client.flavors.list():
@ -110,17 +110,17 @@ class ShowCommands(object):
print(_("Authentication Issues: %s") % e)
return(1)
@cliutils.args('--deploy-id', dest='deploy_id', type=str, required=False,
help='the UUID of a deployment')
@envutils.with_default_deploy_id
def networks(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment')
@envutils.with_default_deployment
def networks(self, deployment=None):
"""Display configured networks."""
headers = ['ID', 'Label', 'CIDR']
mixed_case_fields = ['ID', 'Label', 'CIDR']
table_rows = []
try:
for endpoint_dict in self._get_endpoints(deploy_id):
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for network in nova_client.networks.list():
@ -134,17 +134,17 @@ class ShowCommands(object):
print(_("Authentication Issues: %s") % e)
return(1)
@cliutils.args('--deploy-id', dest='deploy_id', type=str, required=False,
help='the UUID of a deployment')
@envutils.with_default_deploy_id
def secgroups(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment')
@envutils.with_default_deployment
def secgroups(self, deployment=None):
"""Display security groups."""
headers = ['ID', 'Name', 'Description']
mixed_case_fields = ['ID', 'Name', 'Description']
table_rows = []
try:
for endpoint_dict in self._get_endpoints(deploy_id):
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for secgroup in nova_client.security_groups.list():
@ -161,17 +161,17 @@ class ShowCommands(object):
print(_("Authentication Issues: %s") % e)
return(1)
@cliutils.args('--deploy-id', dest='deploy_id', type=str, required=False,
help='the UUID of a deployment')
@envutils.with_default_deploy_id
def keypairs(self, deploy_id=None):
@cliutils.args('--deployment', dest='deployment', type=str,
required=False, help='UUID or name of a deployment')
@envutils.with_default_deployment
def keypairs(self, deployment=None):
"""Display available ssh keypairs."""
headers = ['Name', 'Fingerprint']
mixed_case_fields = ['Name', 'Fingerprint']
table_rows = []
try:
for endpoint_dict in self._get_endpoints(deploy_id):
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(endpoint.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for keypair in nova_client.keypairs.list():

26
rally/cmd/commands/task.py
View File

@ -44,57 +44,57 @@ class TaskCommands(object):
Set of commands that allow you to manage benchmarking tasks and results.
"""
@cliutils.args('--deploy-id', type=str, dest='deploy_id', required=False,
help='UUID of the deployment')
@cliutils.args('--deployment', type=str, dest='deployment',
required=False, help='UUID or name of the deployment')
@cliutils.args('--task', '--filename',
help='Path to the file with full configuration of task')
@envutils.with_default_deploy_id
def validate(self, task, deploy_id=None):
@envutils.with_default_deployment
def validate(self, task, deployment=None):
"""Validate a task configuration file.
This will check that task configuration file has valid syntax and
all required options of scenarios, contexts, SLA and runners are set.
:param task: a file with yaml/json configration
:param deploy_id: a UUID of a deployment
:param deployment: UUID or name of a deployment
"""
task = os.path.expanduser(task)
with open(task, "rb") as task_file:
config_dict = yaml.safe_load(task_file.read())
try:
api.task_validate(deploy_id, config_dict)
api.task_validate(deployment, config_dict)
print("Task config is valid :)")
except exceptions.InvalidTaskException as e:
print("Task config is invalid: \n")
print(e)
@cliutils.args('--deploy-id', type=str, dest='deploy_id', required=False,
help='UUID of the deployment')
@cliutils.args('--deployment', type=str, dest='deployment',
required=False, help='UUID or name of the deployment')
@cliutils.args('--task', '--filename',
help='Path to the file with full configuration of task')
@cliutils.args('--tag',
help='Tag for this task')
@cliutils.args('--no-use', action='store_false', dest='do_use',
help='Don\'t set new task as default for future operations')
@envutils.with_default_deploy_id
def start(self, task, deploy_id=None, tag=None, do_use=False):
@envutils.with_default_deployment
def start(self, task, deployment=None, tag=None, do_use=False):
"""Start benchmark task.
:param task: a file with yaml/json configration
:param deploy_id: a UUID of a deployment
:param deployment: UUID or name of a deployment
:param tag: optional tag for this task
"""
task = os.path.expanduser(task)
with open(task, 'rb') as task_file:
config_dict = yaml.safe_load(task_file.read())
try:
task = api.create_task(deploy_id, tag)
task = api.create_task(deployment, tag)
print("=" * 80)
print(_("Task %(tag)s %(uuid)s is started")
% {"uuid": task["uuid"], "tag": task["tag"]})
print("-" * 80)
api.start_task(deploy_id, config_dict, task=task)
api.start_task(deployment, config_dict, task=task)
self.detailed(task_id=task['uuid'])
if do_use:
use.UseCommands().task(task['uuid'])

42
rally/cmd/commands/use.py
View File

@ -30,8 +30,8 @@ class UseCommands(object):
task UUID in the commands requiring this parameter.
"""
def _update_openrc_deployment_file(self, deploy_id, endpoint):
openrc_path = os.path.expanduser('~/.rally/openrc-%s' % deploy_id)
def _update_openrc_deployment_file(self, deployment, endpoint):
openrc_path = os.path.expanduser('~/.rally/openrc-%s' % deployment)
# NOTE(msdubov): In case of multiple endpoints write the first one.
with open(openrc_path, 'w+') as env_file:
env_file.write('export OS_AUTH_URL=%(auth_url)s\n'
@ -55,42 +55,22 @@ class UseCommands(object):
if not os.path.exists(os.path.expanduser('~/.rally/')):
os.makedirs(os.path.expanduser('~/.rally/'))
@cliutils.args('--uuid', type=str, dest='deploy_id', required=False,
help='UUID of the deployment')
@cliutils.args('--name', type=str, dest='name', required=False,
help='Name of the deployment')
def deployment(self, deploy_id=None, name=None):
@cliutils.args('--deployment', type=str, dest='deployment',
help='UUID or name of the deployment')
def deployment(self, deployment=None):
"""Set active deployment.
:param deploy_id: a UUID of a deployment
:param deployment: UUID or name of a deployment
"""
if not (name or deploy_id):
print('You should specify --name or --uuid of deployment')
return 1
deploy = None
if name:
deployments = db.deployment_list(name=name)
if len(deployments) > 1:
print("Multiple deployments found by name: `%s`" % name)
return 1
elif not deployments:
print("There is no `%s` deployment" % name)
return 1
else:
deploy = deployments[0]
deploy_id = deploy["uuid"]
try:
deploy = deploy or db.deployment_get(deploy_id)
print('Using deployment: %s' % deploy_id)
deploy = db.deployment_get(deployment)
print('Using deployment: %s' % deploy['uuid'])
self._ensure_rally_configuration_dir_exists()
self._update_attribute_in_global_file('RALLY_DEPLOYMENT',
deploy_id)
deploy['uuid'])
self._update_openrc_deployment_file(
deploy_id, deploy.get('admin') or deploy.get('users')[0])
deploy['uuid'], deploy.get('admin') or deploy.get('users')[0])
print ('~/.rally/openrc was updated\n\nHINTS:\n'
'* To get your cloud resources, run:\n\t'
'rally show [flavors|images|keypairs|networks|secgroups]\n'
@ -99,7 +79,7 @@ class UseCommands(object):
' OpenStack clients are now configured, e.g run:\n\t'
'glance image-list')
except exceptions.DeploymentNotFound:
print('Deployment %s is not found.' % deploy_id)
print('Deployment %s is not found.' % deployment)
return 1
@cliutils.args('--uuid', type=str, dest='task_id', required=False,

13
rally/cmd/commands/verify.py
View File

@ -42,8 +42,8 @@ class VerifyCommands(object):
OpenStack live cloud.
"""
@cliutils.args("--deploy-id", dest="deploy_id", type=str, required=False,
help="UUID of a deployment.")
@cliutils.args("--deployment", dest="deployment", type=str,
required=False, help="UUID or name of a deployment.")
@cliutils.args("--set", dest="set_name", type=str, required=False,
help="Name of tempest test set. Available sets: %s" % ", ".
join(consts.TEMPEST_TEST_SETS))
@ -54,13 +54,13 @@ class VerifyCommands(object):
help="User specified Tempest config file location")
@cliutils.args("--no-use", action="store_false", dest="do_use",
help="Don't set new task as default for future operations")
@envutils.with_default_deploy_id
def start(self, set_name="smoke", deploy_id=None, regex=None,
@envutils.with_default_deployment
def start(self, set_name="smoke", deployment=None, regex=None,
tempest_config=None, do_use=False):
"""Start set of tests.
:param set_name: Name of tempest test set
:param deploy_id: a UUID of a deployment
:param deployment: UUID or name of a deployment
:param regex: Regular expression of test
:param tempest_config: User specified Tempest config file location
"""
@ -71,7 +71,8 @@ class VerifyCommands(object):
print("Sorry, but there are no desired tempest test set. Please "
"choose from: %s" % ", ".join(consts.TEMPEST_TEST_SETS))
return (1)
verification = api.verify(deploy_id, set_name, regex, tempest_config)
verification = api.verify(deployment, set_name, regex,
tempest_config)
if do_use:
use.UseCommands().verification(verification["uuid"])

4
rally/cmd/envutils.py
View File

@ -65,8 +65,8 @@ def default_from_global(arg_name, env_name,
return f(*args, **kwargs)
return decorator.decorator(default_from_global)
with_default_deploy_id = default_from_global('deploy_id', ENV_DEPLOYMENT,
"uuid")
with_default_deployment = default_from_global(
"deployment", ENV_DEPLOYMENT, "uuid")
with_default_task_id = default_from_global('task_id', ENV_TASK,
"uuid")
with_default_verification_id = default_from_global(

12
rally/cmd/manage.py
View File

@ -37,12 +37,14 @@ class DBCommands(object):
class TempestCommands(object):
"""Commands for Tempest management."""
@cliutils.args('--deploy-id', type=str, dest='deploy_id', required=False,
help='UUID of the deployment')
@envutils.with_default_deploy_id
def install(self, deploy_id=None):
@cliutils.args("--deployment", type=str, dest="deployment",
required=False, help="UUID or name of the deployment")
@envutils.with_default_deployment
def install(self, deployment=None):
"""Install tempest."""
verifier = tempest.Tempest(deploy_id)
deployment_uuid = db.deployment_get(deployment)['uuid']
verifier = tempest.Tempest(deployment_uuid)
verifier.install()

6
rally/db/api.py
View File

@ -180,15 +180,15 @@ def deployment_delete(uuid):
return IMPL.deployment_delete(uuid)
def deployment_get(uuid):
def deployment_get(deployment):
"""Get a deployment by UUID.
:param uuid: UUID of the deployment.
:param deployment: UUID or name of the deployment.
:raises: :class:`rally.exceptions.DeploymentNotFound` if the deployment
does not exist.
:returns: a dict with data on the deployment.
"""
return IMPL.deployment_get(uuid)
return IMPL.deployment_get(deployment)
def deployment_update(uuid, values):

37
rally/db/sqlalchemy/api.py
View File

@ -164,17 +164,26 @@ class Connection(object):
return (self.model_query(models.TaskResult).
filter_by(task_uuid=uuid).all())
def _deployment_get(self, uuid, session=None):
deploy = (self.model_query(models.Deployment, session=session).
filter_by(uuid=uuid).first())
if not deploy:
raise exceptions.DeploymentNotFound(uuid=uuid)
return deploy
def _deployment_get(self, deployment, session=None):
stored_deployment = self.model_query(
models.Deployment,
session=session).filter_by(name=deployment).first()
if not stored_deployment:
stored_deployment = self.model_query(
models.Deployment,
session=session).filter_by(uuid=deployment).first()
if not stored_deployment:
raise exceptions.DeploymentNotFound(deployment=deployment)
return stored_deployment
def deployment_create(self, values):
deployment = models.Deployment()
deployment.update(values)
deployment.save()
try:
deployment.update(values)
deployment.save()
except db_exc.DBDuplicateEntry:
raise exceptions.DeploymentNameExists(deployment=values["name"])
return deployment
def deployment_delete(self, uuid):
@ -190,16 +199,16 @@ class Connection(object):
if not count:
raise exceptions.DeploymentNotFound(uuid=uuid)
def deployment_get(self, uuid):
return self._deployment_get(uuid)
def deployment_get(self, deployment):
return self._deployment_get(deployment)
def deployment_update(self, uuid, values):
def deployment_update(self, deployment, values):
session = get_session()
values.pop('uuid', None)
with session.begin():
deploy = self._deployment_get(uuid, session=session)
deploy.update(values)
return deploy
dpl = self._deployment_get(deployment, session=session)
dpl.update(values)
return dpl
def deployment_list(self, status=None, parent_uuid=None, name=None):
query = (self.model_query(models.Deployment).

2
rally/db/sqlalchemy/models.py
View File

@ -63,7 +63,7 @@ class Deployment(BASE, RallyBase):
sa.ForeignKey(uuid, use_alter=True, name='fk_parent_uuid'),
default=None,
)
name = sa.Column(sa.String(255))
name = sa.Column(sa.String(255), unique=True)
started_at = sa.Column(sa.DateTime)
completed_at = sa.Column(sa.DateTime)
# XXX(akscram): Do we need to explicitly store a name of the

8
rally/deploy/serverprovider/providers/openstack.py
View File

@ -232,9 +232,9 @@ class OpenStackProvider(provider.ProviderFactory):
except exceptions.ResourceNotFound:
LOG.warning(
'Instance resource record not found in DB, not removing.'
' Deployment: %(deploy_id)s Instance ID:%(id)s'
' Deployment: %(deployment)s Instance ID:%(id)s'
' Instance Nova UUID:%(uuid)s' %
dict(deploy_id=resource.deployment_uuid,
dict(deployment=resource.deployment_uuid,
id=resource.id,
uuid=resource['info']['id']
)
@ -252,9 +252,9 @@ class OpenStackProvider(provider.ProviderFactory):
except exceptions.ResourceNotFound:
LOG.warning(
'Keypair resource record not found in DB, not removing.'
' Deployment: %(deploy_id)s Keypair ID:%(id)s'
' Deployment: %(deployment)s Keypair ID:%(id)s'
' Keypair Name:%(name)s' %
dict(deploy_id=resource.deployment_uuid,
dict(deployment=resource.deployment_uuid,
id=resource.id,
name=resource['info']['id']
)

6
rally/exceptions.py
View File

@ -153,7 +153,11 @@ class TaskNotFound(NotFoundException):
class DeploymentNotFound(NotFoundException):
msg_fmt = _("Deployment with uuid=%(uuid)s not found.")
msg_fmt = _("Deployment %(deployment)s not found.")
class DeploymentNameExists(RallyException):
msg_fmt = _("Deployment name '%(deployment)s' already registered.")
class DeploymentIsBusy(RallyException):

4
rally/objects/deploy.py
View File

@ -32,8 +32,8 @@ class Deployment(object):
return self.deployment[key]
@staticmethod
def get(uuid):
return Deployment(db.deployment_get(uuid))
def get(deploy):
return Deployment(db.deployment_get(deploy))
@staticmethod
def delete_by_uuid(uuid):

64
rally/orchestrator/api.py
View File

@ -14,15 +14,18 @@
# under the License.
import jsonschema
from oslo.config import cfg
from rally.benchmark import engine
from rally import consts
from rally import deploy
from rally import exceptions
from rally.i18n import _
from rally import log as logging
from rally import objects
from rally.verification.verifiers.tempest import tempest
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -32,7 +35,14 @@ def create_deploy(config, name):
:param config: a dict with deployment configuration
:param name: a str represents a name of the deployment
"""
deployment = objects.Deployment(name=name, config=config)
try:
deployment = objects.Deployment(name=name, config=config)
except exceptions.DeploymentNameExists as e:
if CONF.debug:
LOG.exception(e)
raise
deployer = deploy.EngineFactory.get_engine(deployment['config']['type'],
deployment)
try:
@ -49,31 +59,31 @@ def create_deploy(config, name):
return deployment
def destroy_deploy(deploy_uuid):
def destroy_deploy(deployment):
"""Destroy the deployment.
:param deploy_uuid: UUID of the deployment
:param deployment: UUID or name of the deployment
"""
# TODO(akscram): We have to be sure that there are no running
# tasks for this deployment.
# TODO(akscram): Check that the deployment have got a status that
# is equal to "*->finished" or "deploy->inconsistent".
deployment = objects.Deployment.get(deploy_uuid)
deployment = objects.Deployment.get(deployment)
deployer = deploy.EngineFactory.get_engine(deployment['config']['type'],
deployment)
with deployer:
deployer.make_cleanup()
deployment.delete()
tempest.Tempest(deploy_uuid).uninstall()
tempest.Tempest(deployment['uuid']).uninstall()
def recreate_deploy(deploy_uuid):
def recreate_deploy(deployment):
"""Performs a clean up and then start to deploy.
:param deploy_uuid: UUID of the deployment
:param deployment: UUID or name of the deployment
"""
deployment = objects.Deployment.get(deploy_uuid)
deployment = objects.Deployment.get(deployment)
deployer = deploy.EngineFactory.get_engine(deployment['config']['type'],
deployment)
with deployer:
@ -82,43 +92,45 @@ def recreate_deploy(deploy_uuid):
deployment.update_endpoints(endpoints)
def create_task(deploy_uuid, tag):
def create_task(deployment, tag):
"""Create a task without starting it.
Task is a list of benchmarks that will be called one by one, results of
execution will be stored in DB.
:param deploy_uuid: UUID of the deployment
:param deployment: UUID or name of the deployment
:param tag: tag for this task
"""
return objects.Task(deployment_uuid=deploy_uuid, tag=tag)
deployment_uuid = objects.Deployment.get(deployment)['uuid']
return objects.Task(deployment_uuid=deployment_uuid, tag=tag)
def task_validate(deploy_uuid, config):
def task_validate(deployment, config):
"""Validate a task config against specified deployment.
:param deploy_uuid: UUID of the deployment
:param deployment: UUID or name of the deployment
:param config: a dict with a task configuration
"""
deployment = objects.Deployment.get(deploy_uuid)
task = objects.Task(deployment_uuid=deploy_uuid)
deployment = objects.Deployment.get(deployment)
task = objects.Task(deployment_uuid=deployment['uuid'])
benchmark_engine = engine.BenchmarkEngine(config, task)
benchmark_engine.bind(admin=deployment["admin"],
users=deployment["users"])
benchmark_engine.validate()
def start_task(deploy_uuid, config, task=None):
def start_task(deployment, config, task=None):
"""Start a task.
Task is a list of benchmarks that will be called one by one, results of
execution will be stored in DB.
:param deploy_uuid: UUID of the deployment
:param deployment: UUID or name of the deployment
:param config: a dict with a task configuration
"""
deployment = objects.Deployment.get(deploy_uuid)
task = task or objects.Task(deployment_uuid=deploy_uuid)
deployment = objects.Deployment.get(deployment)
task = task or objects.Task(deployment_uuid=deployment['uuid'])
LOG.info("Benchmark Task %s on Deployment %s" % (task['uuid'],
deployment['uuid']))
benchmark_engine = engine.BenchmarkEngine(config, task)
@ -157,23 +169,25 @@ def delete_task(task_uuid, force=False):
objects.Task.delete_by_uuid(task_uuid, status=status)
def verify(deploy_id, set_name, regex, tempest_config):
def verify(deployment, set_name, regex, tempest_config):
"""Start verifying.
:param deploy_id: a UUID of a deployment.
:param deployment: UUID or name of a deployment.
:param set_name: Valid name of tempest test set.
:param regex: Regular expression of test
:param tempest_config: User specified Tempest config file
"""
verification = objects.Verification(deployment_uuid=deploy_id)
verifier = tempest.Tempest(deploy_id, verification=verification,
deployment_uuid = objects.Deployment.get(deployment)["uuid"]
verification = objects.Verification(deployment_uuid=deployment_uuid)
verifier = tempest.Tempest(deployment_uuid, verification=verification,
tempest_config=tempest_config)
if not verifier.is_installed():
print("Tempest is not installed for specified deployment.")
print("Installing Tempest for deployment %s" % deploy_id)
print("Installing Tempest for deployment %s" % deploy)
verifier.install()
LOG.info("Starting verification of deployment: %s" % deploy_id)
LOG.info("Starting verification of deployment: %s" % deploy)
verification.set_running()
verifier.verify(set_name=set_name, regex=regex)

8
rally/verification/verifiers/tempest/config.py
View File

@ -52,8 +52,8 @@ class TempestConfigCreationFailure(exceptions.RallyException):
class TempestConf(object):
def __init__(self, deploy_id):
self.endpoint = db.deployment_get(deploy_id)['admin']
def __init__(self, deployment):
self.endpoint = db.deployment_get(deployment)['admin']
self.clients = osclients.Clients(endpoint.Endpoint(**self.endpoint))
try:
self.keystoneclient = self.clients.verified_keystone()
@ -67,7 +67,7 @@ class TempestConf(object):
self.conf = configparser.ConfigParser()
self.conf.read(os.path.join(os.path.dirname(__file__), 'config.ini'))
self.deploy_id = deploy_id
self.deployment = deployment
self.data_path = os.path.join(os.path.expanduser('~'), '.rally',
'tempest', 'data')
if not os.path.exists(self.data_path):
@ -111,7 +111,7 @@ class TempestConf(object):
def _set_default(self):
lock_path = os.path.join(self.data_path,
'lock_files_%s' % self.deploy_id)
'lock_files_%s' % self.deployment)
if not os.path.exists(lock_path):
os.makedirs(lock_path)
self.conf.set('DEFAULT', 'lock_path', lock_path)

8
rally/verification/verifiers/tempest/tempest.py
View File

@ -46,11 +46,11 @@ class Tempest(object):
base_repo = os.path.join(os.path.expanduser("~"), ".rally/tempest/base")
def __init__(self, deploy_id, verification=None, tempest_config=None):
self.deploy_id = deploy_id
def __init__(self, deployment, verification=None, tempest_config=None):
self.deployment = deployment
self._path = os.path.join(os.path.expanduser("~"),
".rally/tempest",
"for-deployment-%s" % deploy_id)
"for-deployment-%s" % deployment)
self.config_file = tempest_config or self.path("tempest.conf")
self.log_file_raw = self.path("subunit.stream")
self.venv_wrapper = self.path("tools/with_venv.sh")
@ -99,7 +99,7 @@ class Tempest(object):
msg = _("Creation of configuration file for tempest.")
LOG.info(_("Starting: ") + msg)
config.TempestConf(self.deploy_id).generate(self.config_file)
config.TempestConf(self.deployment).generate(self.config_file)
LOG.info(_("Completed: ") + msg)
else:
LOG.info("Tempest is already configured.")

2
tests/ci/rally-gate.sh
View File

@ -35,7 +35,7 @@ fi
env
set -o pipefail
rally use deployment --name devstack
rally use deployment --deployment devstack
rally deployment check
rally show flavors
rally show images

56
tests/unit/cmd/commands/test_deployment.py
View File

@ -28,7 +28,7 @@ class DeploymentCommandsTestCase(test.TestCase):
super(DeploymentCommandsTestCase, self).setUp()
self.deployment = deployment.DeploymentCommands()
@mock.patch.dict(os.environ, {'RALLY_DEPLOYMENT': 'my_deploy_id'})
@mock.patch.dict(os.environ, {'RALLY_DEPLOYMENT': 'my_deployment_id'})
@mock.patch('rally.cmd.commands.deployment.DeploymentCommands.list')
@mock.patch('rally.cmd.commands.deployment.api.create_deploy')
@mock.patch('rally.cmd.commands.deployment.open',
@ -78,24 +78,24 @@ class DeploymentCommandsTestCase(test.TestCase):
@mock.patch('rally.cmd.commands.deployment.api.recreate_deploy')
def test_recreate(self, mock_recreate):
deploy_id = '43924f8b-9371-4152-af9f-4cf02b4eced4'
self.deployment.recreate(deploy_id)
mock_recreate.assert_called_once_with(deploy_id)
deployment_id = '43924f8b-9371-4152-af9f-4cf02b4eced4'
self.deployment.recreate(deployment_id)
mock_recreate.assert_called_once_with(deployment_id)
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
def test_recreate_no_deploy_id(self, mock_default):
def test_recreate_no_deployment_id(self, mock_default):
mock_default.side_effect = exceptions.InvalidArgumentsException
self.assertRaises(exceptions.InvalidArgumentsException,
self.deployment.recreate, None)
@mock.patch('rally.cmd.commands.deployment.api.destroy_deploy')
def test_destroy(self, mock_destroy):
deploy_id = '53fd0273-60ce-42e5-a759-36f1a683103e'
self.deployment.destroy(deploy_id)
mock_destroy.assert_called_once_with(deploy_id)
deployment_id = '53fd0273-60ce-42e5-a759-36f1a683103e'
self.deployment.destroy(deployment_id)
mock_destroy.assert_called_once_with(deployment_id)
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
def test_destroy_no_deploy_id(self, mock_default):
def test_destroy_no_deployment_id(self, mock_default):
mock_default.side_effect = exceptions.InvalidArgumentsException
self.assertRaises(exceptions.InvalidArgumentsException,
self.deployment.destroy, None)
@ -104,11 +104,11 @@ class DeploymentCommandsTestCase(test.TestCase):
@mock.patch('rally.cmd.commands.deployment.utils.Struct')
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
@mock.patch('rally.cmd.commands.deployment.db.deployment_list')
def test_list_different_deploy_id(self, mock_deployments,
mock_default, mock_struct,
mock_print_list):
current_deploy_id = '26a3ce76-0efa-40e4-86e5-514574bd1ff6'
mock_default.return_value = current_deploy_id
def test_list_different_deployment_id(self, mock_deployments,
mock_default, mock_struct,
mock_print_list):
current_deployment_id = '26a3ce76-0efa-40e4-86e5-514574bd1ff6'
mock_default.return_value = current_deployment_id
fake_deployment_list = [
{'uuid': 'fa34aea2-ae2e-4cf7-a072-b08d67466e3e',
'created_at': '03-12-2014',
@ -132,12 +132,12 @@ class DeploymentCommandsTestCase(test.TestCase):
@mock.patch('rally.cmd.commands.deployment.utils.Struct')
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
@mock.patch('rally.cmd.commands.deployment.db.deployment_list')
def test_list_current_deploy_id(self, mock_deployments,
mock_default, mock_struct,
mock_print_list):
current_deploy_id = '64258e84-ffa1-4011-9e4c-aba07bdbcc6b'
mock_default.return_value = current_deploy_id
fake_deployment_list = [{'uuid': current_deploy_id,
def test_list_current_deployment_id(self, mock_deployments,
mock_default, mock_struct,
mock_print_list):
current_deployment_id = '64258e84-ffa1-4011-9e4c-aba07bdbcc6b'
mock_default.return_value = current_deployment_id
fake_deployment_list = [{'uuid': current_deployment_id,
'created_at': '13-12-2014',
'name': 'dep2',
'status': 'deploy->finished',
@ -157,16 +157,16 @@ class DeploymentCommandsTestCase(test.TestCase):
@mock.patch('rally.cmd.commands.deployment.db.deployment_get')
@mock.patch('json.dumps')
def test_config(self, mock_json_dumps, mock_deployment):
deploy_id = 'fa4a423e-f15d-4d83-971a-89574f892999'
deployment_id = 'fa4a423e-f15d-4d83-971a-89574f892999'
value = {'config': 'config'}
mock_deployment.return_value = value
self.deployment.config(deploy_id)
self.deployment.config(deployment_id)
mock_json_dumps.assert_called_once_with(value['config'],
sort_keys=True, indent=4)
mock_deployment.assert_called_once_with(deploy_id)
mock_deployment.assert_called_once_with(deployment_id)
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
def test_config_no_deploy_id(self, mock_default):
def test_config_no_deployment_id(self, mock_default):
mock_default.side_effect = exceptions.InvalidArgumentsException
self.assertRaises(exceptions.InvalidArgumentsException,
self.deployment.config, None)
@ -175,7 +175,7 @@ class DeploymentCommandsTestCase(test.TestCase):
@mock.patch('rally.cmd.commands.deployment.utils.Struct')
@mock.patch('rally.cmd.commands.deployment.db.deployment_get')
def test_show(self, mock_deployment, mock_struct, mock_print_list):
deploy_id = "b1a6153e-a314-4cb3-b63b-cf08c1a416c3"
deployment_id = "b1a6153e-a314-4cb3-b63b-cf08c1a416c3"
value = {
"admin": {
"auth_url": "url",
@ -189,8 +189,8 @@ class DeploymentCommandsTestCase(test.TestCase):
"users": []
}
mock_deployment.return_value = value
self.deployment.show(deploy_id)
mock_deployment.assert_called_once_with(deploy_id)
self.deployment.show(deployment_id)
mock_deployment.assert_called_once_with(deployment_id)
headers = ["auth_url", "username", "password", "tenant_name",
"region_name", "endpoint_type", "admin_port"]
@ -200,7 +200,7 @@ class DeploymentCommandsTestCase(test.TestCase):
mock_print_list.assert_called_once_with([mock_struct()], headers)
@mock.patch('rally.cmd.commands.deployment.envutils.get_global')
def test_deploy_no_deploy_id(self, mock_default):
def test_deploy_no_deployment_id(self, mock_default):
mock_default.side_effect = exceptions.InvalidArgumentsException
self.assertRaises(exceptions.InvalidArgumentsException,
self.deployment.show, None)

22
tests/unit/cmd/commands/test_show.py
View File

@ -29,7 +29,7 @@ class ShowCommandsTestCase(test.TestCase):
'password': 'fake_password',
'tenant_name': 'fake_tenant_name',
'auth_url': 'http://fake.auth.url'}
self.fake_deploy_id = '7f6e88e0-897e-45c0-947c-595ce2437bee'
self.fake_deployment_id = '7f6e88e0-897e-45c0-947c-595ce2437bee'
self.fake_clients = fakes.FakeClients()
self.fake_glance_client = fakes.FakeGlanceClient()
self.fake_nova_client = fakes.FakeNovaClient()
@ -46,8 +46,8 @@ class ShowCommandsTestCase(test.TestCase):
fake_image.size = 1
mock_get_glance.return_value = self.fake_glance_client
mock_deployment_get.return_value = {'admin': self.fake_endpoint}
self.show.images(self.fake_deploy_id)
mock_deployment_get.assert_called_once_with(self.fake_deploy_id)
self.show.images(self.fake_deployment_id)
mock_deployment_get.assert_called_once_with(self.fake_deployment_id)
mock_get_glance.assert_called_once_with()
headers = ['UUID', 'Name', 'Size (B)']
@ -75,8 +75,8 @@ class ShowCommandsTestCase(test.TestCase):
fake_flavor.ram, fake_flavor.swap, fake_flavor.disk = 1024, 128, 10
mock_get_nova.return_value = self.fake_nova_client
mock_deployment_get.return_value = {'admin': self.fake_endpoint}
self.show.flavors(self.fake_deploy_id)
mock_deployment_get.assert_called_once_with(self.fake_deploy_id)
self.show.flavors(self.fake_deployment_id)
mock_deployment_get.assert_called_once_with(self.fake_deployment_id)
mock_get_nova.assert_called_once_with()
headers = ['ID', 'Name', 'vCPUs', 'RAM (MB)', 'Swap (MB)', 'Disk (GB)']
@ -106,8 +106,8 @@ class ShowCommandsTestCase(test.TestCase):
fake_network.cidr = '10.0.0.0/24'
mock_get_nova.return_value = self.fake_nova_client
mock_deployment_get.return_value = {'admin': self.fake_endpoint}
self.show.networks(self.fake_deploy_id)
mock_deployment_get.assert_called_once_with(self.fake_deploy_id)
self.show.networks(self.fake_deployment_id)
mock_deployment_get.assert_called_once_with(self.fake_deployment_id)
mock_get_nova.assert_called_once_with()
headers = ['ID', 'Label', 'CIDR']
@ -130,8 +130,8 @@ class ShowCommandsTestCase(test.TestCase):
fake_secgroup.id = 0
mock_get_nova.return_value = self.fake_nova_client
mock_deployment_get.return_value = {'admin': self.fake_endpoint}
self.show.secgroups(self.fake_deploy_id)
mock_deployment_get.assert_called_once_with(self.fake_deploy_id)
self.show.secgroups(self.fake_deployment_id)
mock_deployment_get.assert_called_once_with(self.fake_deployment_id)
mock_get_nova.assert_called_once_with()
headers = ['ID', 'Name', 'Description']
@ -155,8 +155,8 @@ class ShowCommandsTestCase(test.TestCase):
fake_keypair.fingerprint = '84:87:58'
mock_get_nova.return_value = self.fake_nova_client
mock_deployment_get.return_value = {'admin': self.fake_endpoint}
self.show.keypairs(self.fake_deploy_id)
mock_deployment_get.assert_called_once_with(self.fake_deploy_id)
self.show.keypairs(self.fake_deployment_id)
mock_deployment_get.assert_called_once_with(self.fake_deployment_id)
mock_get_nova.assert_called_once_with()
headers = ['Name', 'Fingerprint']

12
tests/unit/cmd/commands/test_task.py
View File

@ -38,13 +38,13 @@ class TaskCommandsTestCase(test.TestCase):
dict(uuid='fc1a9bbe-1ead-4740-92b5-0feecf421634',
created_at='2014-01-14 09:14:45.395822',
status='init', failed=False, tag=None))
deploy_id = 'e0617de9-77d1-4875-9b49-9d5789e29f20'
self.task.start('path_to_config.json', deploy_id)
mock_api.assert_called_once_with(deploy_id, {u'some': u'json'},
deployment_id = 'e0617de9-77d1-4875-9b49-9d5789e29f20'
self.task.start('path_to_config.json', deployment_id)
mock_api.assert_called_once_with(deployment_id, {u'some': u'json'},
task=mock_create_task.return_value)
@mock.patch('rally.cmd.commands.task.envutils.get_global')
def test_start_no_deploy_id(self, mock_default):
def test_start_no_deployment_id(self, mock_default):
mock_default.side_effect = exceptions.InvalidArgumentsException
self.assertRaises(exceptions.InvalidArgumentsException,
self.task.start, 'path_to_config.json', None)
@ -62,9 +62,9 @@ class TaskCommandsTestCase(test.TestCase):
created_at='2014-01-14 09:14:45.395822',
status='init', failed=False, tag=None))
mock_api.start_task.side_effect = KeyboardInterrupt
deploy_id = 'f586dcd7-8473-4c2e-a4d4-22be26371c10'
deployment_id = 'f586dcd7-8473-4c2e-a4d4-22be26371c10'
self.assertRaises(KeyboardInterrupt, self.task.start,
'path_to_config.json', deploy_id)
'path_to_config.json', deployment_id)
mock_api.abort_task.assert_called_once_with(
mock_api.create_task.return_value['uuid'])

44
tests/unit/cmd/commands/test_use.py
View File

@ -20,6 +20,7 @@ import mock
from rally.cmd.commands import use
from rally.cmd import envutils
from rally import exceptions
from tests.unit import fakes
from tests.unit import test
MOD = 'rally.cmd.commands.use.'
@ -30,7 +31,9 @@ class UseCommandsTestCase(test.TestCase):
super(UseCommandsTestCase, self).setUp()
self.use = use.UseCommands()
def test_deployment_use_no_args(self):
@mock.patch('rally.cmd.commands.use.db.deployment_get',
side_effect=exceptions.DeploymentNotFound())
def test_deployment_use_no_args(self, mock_d_get):
status = self.use.deployment()
self.assertEqual(1, status)
@ -39,58 +42,61 @@ class UseCommandsTestCase(test.TestCase):
@mock.patch(MOD + 'UseCommands._ensure_rally_configuration_dir_exists')
@mock.patch(MOD + 'db')
def test_deployment_use_by_name(self, m_db, m_ercde, m_uaigf, m_uodf):
fake_deployment = {'uuid': 'fake_uuid',
'admin': 'fake_endpoints'}
fake_deployment = fakes.FakeDeployment(
uuid='fake_uuid',
admin='fake_endpoints')
m_db.deployment_list.return_value = [fake_deployment]
m_db.deployment_get.return_value = fake_deployment
status = self.use.deployment(name='fake_name')
status = self.use.deployment(deployment='fake_name')
self.assertIsNone(status)
m_db.deployment_list.assert_called_once_with(name='fake_name')
m_db.deployment_get.assert_called_once_with('fake_name')
m_ercde.assert_called_once_with()
m_uaigf.assert_called_once_with(envutils.ENV_DEPLOYMENT, 'fake_uuid')
m_uodf.assert_called_once_with('fake_uuid', 'fake_endpoints')
@mock.patch('os.remove')
@mock.patch('os.symlink')
@mock.patch(MOD + 'db.deployment_get')
@mock.patch(
MOD + 'db.deployment_get',
return_value=fakes.FakeDeployment(
uuid='593b683c-4b16-4b2b-a56b-e162bd60f10b'))
@mock.patch('os.path.exists', return_value=True)
@mock.patch(MOD + 'fileutils.update_env_file')
def test_deployment(self, mock_env, mock_path, mock_deployment,
mock_symlink, mock_remove):
deploy_id = '593b683c-4b16-4b2b-a56b-e162bd60f10b'
endpoints = {
'admin': {
deployment_id = mock_deployment.return_value["uuid"]
mock_deployment.return_value["admin"] = {
'auth_url': 'fake_auth_url',
'username': 'fake_username',
'password': 'fake_password',
'tenant_name': 'fake_tenant_name',
'region_name': None
}
}
mock_deployment.return_value = endpoints
'region_name': None}
with mock.patch('rally.cmd.commands.use.open', mock.mock_open(),
create=True) as mock_file:
self.use.deployment(deploy_id)
self.use.deployment(deployment_id)
self.assertEqual(2, mock_path.call_count)
mock_env.assert_called_once_with(os.path.expanduser(
'~/.rally/globals'), 'RALLY_DEPLOYMENT', '%s\n' % deploy_id)
'~/.rally/globals'),
'RALLY_DEPLOYMENT', '%s\n' % deployment_id)
mock_file.return_value.write.assert_called_once_with(
'export OS_AUTH_URL=fake_auth_url\n'
'export OS_USERNAME=fake_username\n'
'export OS_PASSWORD=fake_password\n'
'export OS_TENANT_NAME=fake_tenant_name\n')
mock_symlink.assert_called_once_with(
os.path.expanduser('~/.rally/openrc-%s' % deploy_id),
os.path.expanduser('~/.rally/openrc-%s' % deployment_id),
os.path.expanduser('~/.rally/openrc'))
mock_remove.assert_called_once_with(os.path.expanduser(
'~/.rally/openrc'))
@mock.patch(MOD + 'db.deployment_get')
def test_deployment_not_found(self, mock_deployment):
deploy_id = 'e87e4dca-b515-4477-888d-5f6103f13b42'
deployment_id = 'e87e4dca-b515-4477-888d-5f6103f13b42'
mock_deployment.side_effect = exceptions.DeploymentNotFound(
uuid=deploy_id)
self.assertEqual(1, self.use.deployment(deploy_id))
uuid=deployment_id)
self.assertEqual(1, self.use.deployment(deployment_id))
@mock.patch(MOD + 'fileutils._rewrite_env_file')
@mock.patch(MOD + 'db.task_get', return_value=True)

16
tests/unit/cmd/commands/test_verify.py
View File

@ -47,17 +47,17 @@ class VerifyCommandsTestCase(test.TestCase):
@mock.patch("rally.osclients.Clients")
@mock.patch("rally.orchestrator.api.verify")
def test_start(self, mock_verify, mock_clients):
deploy_id = "0fba91c6-82d5-4ce1-bd00-5d7c989552d9"
deployment_id = "0fba91c6-82d5-4ce1-bd00-5d7c989552d9"
mock_clients().glance().images.list.return_value = [
self.image1, self.image2]
mock_clients().nova().flavors.list.return_value = [
self.flavor1, self.flavor2]
self.verify.start(deploy_id=deploy_id)
self.verify.start(deployment=deployment_id)
default_set_name = "smoke"
default_regex = None
mock_verify.assert_called_once_with(deploy_id,
mock_verify.assert_called_once_with(deployment_id,
default_set_name, default_regex,
None)
@ -65,29 +65,29 @@ class VerifyCommandsTestCase(test.TestCase):
@mock.patch("rally.orchestrator.api.verify")
def test_start_with_user_specified_tempest_config(self, mock_verify,
mock_clients):
deploy_id = "0fba91c6-82d5-4ce1-bd00-5d7c989552d9"
deployment_id = "0fba91c6-82d5-4ce1-bd00-5d7c989552d9"
mock_clients().glance().images.list.return_value = [
self.image1, self.image2]
mock_clients().nova().flavors.list.return_value = [
self.flavor1, self.flavor2]
tempest_config = tempfile.NamedTemporaryFile()
self.verify.start(deploy_id=deploy_id,
self.verify.start(deployment=deployment_id,
tempest_config=tempest_config.name)
default_set_name = "smoke"
default_regex = None
mock_verify.assert_called_once_with(deploy_id,
mock_verify.assert_called_once_with(deployment_id,
default_set_name, default_regex,
tempest_config.name)
tempest_config.close()
@mock.patch("rally.orchestrator.api.verify")
def test_start_with_wrong_set_name(self, mock_verify):
deploy_id = "f2009aae-6ef3-468e-96b2-3c987d584010"
deployment_id = "f2009aae-6ef3-468e-96b2-3c987d584010"
wrong_set_name = "unexpected_value"
self.verify.start(deploy_id, wrong_set_name)
self.verify.start(deployment_id, wrong_set_name)
self.assertNotIn(wrong_set_name, consts.TEMPEST_TEST_SETS)
self.assertFalse(mock_verify.called)

6
tests/unit/cmd/test_envutils.py
View File

@ -40,11 +40,11 @@ class EnvUtilsTestCase(test.TestCase):
"Missing argument: --test_missing_arg\n")
@mock.patch.dict(os.environ,
values={envutils.ENV_DEPLOYMENT: 'my_deploy_id'},
values={envutils.ENV_DEPLOYMENT: 'my_deployment_id'},
clear=True)
def test_get_deployment_id_in_env(self):
deploy_id = envutils.get_global(envutils.ENV_DEPLOYMENT)
self.assertEqual('my_deploy_id', deploy_id)
deployment_id = envutils.get_global(envutils.ENV_DEPLOYMENT)
self.assertEqual('my_deployment_id', deployment_id)
@mock.patch.dict(os.environ, values={}, clear=True)
@mock.patch('rally.cmd.envutils.fileutils.load_env_file')

10
tests/unit/cmd/test_manage.py
View File

@ -51,9 +51,11 @@ class TempestCommandsTestCase(test.TestCase):
self.tempest_commands = manage.TempestCommands()
self.tempest = mock.Mock()
@mock.patch('rally.verification.verifiers.tempest.tempest.Tempest')
def test_install(self, mock_tempest):
deploy_id = 'e24b5af0-0e2a-4a70-9443-b30a88ab152e'
@mock.patch("rally.cmd.manage.db.deployment_get",
return_value={"uuid": "e24b5af0-0e2a-4a70-9443-b30a88ab152e"})
@mock.patch("rally.verification.verifiers.tempest.tempest.Tempest")
def test_install(self, mock_tempest, mock_d_get):
deployment_id = mock_d_get.return_value["uuid"]
mock_tempest.return_value = self.tempest
self.tempest_commands.install(deploy_id)
self.tempest_commands.install(deployment_id)
self.tempest.install.assert_called_once_with()

60
tests/unit/orchestrator/test_api.py
View File

@ -22,6 +22,7 @@ import mock
from rally import consts
from rally import exceptions
from rally.orchestrator import api
from tests.unit import fakes
from tests.unit import test
@ -70,12 +71,12 @@ class APITestCase(test.TestCase):
@mock.patch("rally.orchestrator.api.objects.Task")
@mock.patch("rally.orchestrator.api.objects.Deployment.get",
return_value={"uuid": "deploy_uuid",
"admin": mock.MagicMock(),
"users": []})
return_value=fakes.FakeDeployment(uuid="deploy_uuid",
admin=mock.MagicMock(),
users=[]))
@mock.patch("rally.orchestrator.api.engine.BenchmarkEngine")
def test_task_validate(self, mock_engine, mock_deployment_get, mock_task):
api.task_validate(self.deploy_uuid, "config")
api.task_validate(mock_deployment_get.return_value['uuid'], "config")
mock_engine.assert_has_calls([
mock.call("config", mock_task.return_value),
@ -84,25 +85,29 @@ class APITestCase(test.TestCase):
mock.call().validate(),
])
mock_task.assert_called_once_with(deployment_uuid=self.deploy_uuid)
mock_deployment_get.assert_called_once_with(self.deploy_uuid)
mock_task.assert_called_once_with(
deployment_uuid=mock_deployment_get.return_value["uuid"])
mock_deployment_get.assert_called_once_with(
mock_deployment_get.return_value["uuid"])
@mock.patch("rally.objects.Deployment.get",
return_value={'uuid': 'b0d9cd6c-2c94-4417-a238-35c7019d0257'})
@mock.patch("rally.objects.Task")
def test_create_task(self, mock_task):
deployment_uuid = "b0d9cd6c-2c94-4417-a238-35c7019d0257"
def test_create_task(self, mock_task, mock_d_get):
tag = "a"
api.create_task(deployment_uuid, tag)
mock_task.assert_called_once_with(deployment_uuid=deployment_uuid,
tag=tag)
api.create_task(mock_d_get.return_value["uuid"], tag)
mock_task.assert_called_once_with(
deployment_uuid=mock_d_get.return_value["uuid"], tag=tag)
@mock.patch("rally.orchestrator.api.objects.Task")
@mock.patch("rally.orchestrator.api.objects.Deployment.get",
return_value={"uuid": "deploy_uuid",
"admin": mock.MagicMock(),
"users": []})
return_value=fakes.FakeDeployment(uuid="deploy_uuid",
admin=mock.MagicMock(),
users=[]))
@mock.patch("rally.orchestrator.api.engine.BenchmarkEngine")
def test_start_task(self, mock_engine, mock_deployment_get, mock_task):
api.start_task(self.deploy_uuid, "config")
api.start_task(mock_deployment_get.return_value["uuid"], "config")
mock_engine.assert_has_calls([
mock.call("config", mock_task.return_value),
@ -112,8 +117,10 @@ class APITestCase(test.TestCase):
mock.call().run(),
])
mock_task.assert_called_once_with(deployment_uuid=self.deploy_uuid)
mock_deployment_get.assert_called_once_with(self.deploy_uuid)
mock_task.assert_called_once_with(
deployment_uuid=mock_deployment_get.return_value["uuid"])
mock_deployment_get.assert_called_once_with(
mock_deployment_get.return_value["uuid"])
@mock.patch("rally.orchestrator.api.objects.Task")
@mock.patch("rally.orchestrator.api.objects.Deployment.get")
@ -184,6 +191,16 @@ class APITestCase(test.TestCase):
self.deploy_uuid,
{'status': consts.DeployStatus.DEPLOY_FAILED})
@mock.patch("rally.orchestrator.api.LOG")
@mock.patch("rally.objects.deploy.db.deployment_create",
side_effect=exceptions.DeploymentNameExists(
deployment='fake_deploy'))
def test_create_deploy_duplication_error(self, mock_d_create,
mock_log):
self.assertRaises(exceptions.DeploymentNameExists,
api.create_deploy, self.deploy_config, "fake_deploy")
@mock.patch("rally.objects.deploy.db.deployment_delete")
@mock.patch("rally.objects.deploy.db.deployment_update")
@mock.patch("rally.objects.deploy.db.deployment_get")
@ -205,9 +222,12 @@ class APITestCase(test.TestCase):
mock.call(self.deploy_uuid, self.endpoints)
])
@mock.patch("rally.objects.Deployment.get")
@mock.patch("rally.orchestrator.api.objects.Verification")
@mock.patch("rally.verification.verifiers.tempest.tempest.Tempest")
def test_verify(self, mock_tempest, mock_verification):
def test_verify(self, mock_tempest, mock_verification, mock_d_get):
mock_d_get.return_value = {"uuid": self.deploy_uuid}
mock_tempest.return_value = self.tempest
self.tempest.is_installed.return_value = True
api.verify(self.deploy_uuid, "smoke", None, None)
@ -216,10 +236,12 @@ class APITestCase(test.TestCase):
self.tempest.verify.assert_called_once_with(set_name="smoke",
regex=None)
@mock.patch("rally.orchestrator.api.objects.Deployment.get")
@mock.patch("rally.orchestrator.api.objects.Verification")
@mock.patch("rally.verification.verifiers.tempest.tempest.Tempest")
def test_verify_tempest_not_installed(self, mock_tempest,
mock_verification):
mock_verification, mock_d_get):
mock_d_get.return_value = {"uuid": self.deploy_uuid}
mock_tempest.return_value = self.tempest
self.tempest.is_installed.return_value = False
api.verify(self.deploy_uuid, "smoke", None, None)

6
tests/unit/verification/verifiers/test_config.py
View File

@ -42,8 +42,8 @@ class ConfigTestCase(test.TestCase):
"auth_url": "http://test/v2.0",
"permission": "admin"}
mock_get.return_value = {"admin": self.endpoint}
self.deploy_id = "fake_deploy_id"
self.conf_generator = config.TempestConf(self.deploy_id)
self.deployment = "fake_deployment"
self.conf_generator = config.TempestConf(self.deployment)
self.conf_generator.clients.services = mock_services
keystone_patcher = mock.patch("rally.osclients.create_keystone_client")
@ -212,7 +212,7 @@ class ConfigTestCase(test.TestCase):
def test__set_default(self, mock_makedirs, mock_exists):
self.conf_generator._set_default()
lock_path = os.path.join(self.conf_generator.data_path, "lock_files_%s"
% self.deploy_id)
% self.deployment)
mock_makedirs.assert_called_once_with(lock_path)
expected = (("debug", "True"), ("log_file", "tempest.log"),
("use_stderr", "False"),

4
tests/unit/verification/verifiers/test_tempest.py
View File

@ -34,7 +34,7 @@ TEMPEST_PATH = "rally.verification.verifiers.tempest"
class BaseTestCase(test.TestCase):
def setUp(self):
super(BaseTestCase, self).setUp()
self.verifier = tempest.Tempest('fake_deploy_id',
self.verifier = tempest.Tempest('fake_deployment_id',
verification=mock.MagicMock())
self.verifier._path = "/tmp"
@ -268,7 +268,7 @@ class TempestVerifyTestCase(BaseTestCase):
self.verifier.verify(set_name, None)
self.assertEqual(2, mock_is_configured.call_count)
mock_conf.assert_called_once_with(self.verifier.deploy_id)
mock_conf.assert_called_once_with(self.verifier.deployment)
mock_conf().generate.assert_called_once_with(self.verifier.config_file)
self.verifier.verification.start_verifying.assert_called_once_with(
set_name)

30
tools/rally.bash_completion
View File

@ -12,7 +12,7 @@ _rally()
OPTS["info_ServerProviders"]=""
OPTS["info_find"]="--query"
OPTS["info_list"]=""
OPTS["use_deployment"]="--uuid --name"
OPTS["use_deployment"]="--deployment"
OPTS["use_task"]="--uuid"
OPTS["use_verification"]="--uuid"
OPTS["task_abort"]="--uuid"
@ -23,27 +23,27 @@ _rally()
OPTS["task_report"]="--uuid --out --open"
OPTS["task_results"]="--uuid"
OPTS["task_sla_check"]="--uuid --json"
OPTS["task_start"]="--deploy-id --task --tag --no-use"
OPTS["task_start"]="--deployment --task --tag --no-use"
OPTS["task_status"]="--uuid"
OPTS["task_validate"]="--deploy-id --task"
OPTS["show_flavors"]="--deploy-id"
OPTS["show_images"]="--deploy-id"
OPTS["show_keypairs"]="--deploy-id"
OPTS["show_networks"]="--deploy-id"
OPTS["show_secgroups"]="--deploy-id"
OPTS["task_validate"]="--deployment --task"
OPTS["show_flavors"]="--deployment"
OPTS["show_images"]="--deployment"
OPTS["show_keypairs"]="--deployment"
OPTS["show_networks"]="--deployment"
OPTS["show_secgroups"]="--deployment"
OPTS["verify_compare"]="--uuid-1 --uuid-2 --csv --html --json --output-file --threshold"
OPTS["verify_detailed"]="--uuid --sort-by"
OPTS["verify_list"]=""
OPTS["verify_results"]="--uuid --html --json --output-file"
OPTS["verify_show"]="--uuid --sort-by --detailed"
OPTS["verify_start"]="--deploy-id --set --regex --tempest-config --no-use"
OPTS["deployment_check"]="--uuid"
OPTS["deployment_config"]="--uuid"
OPTS["verify_start"]="--deployment --set --regex --tempest-config --no-use"
OPTS["deployment_check"]="--deployment"
OPTS["deployment_config"]="--deployment"
OPTS["deployment_create"]="--name --fromenv --filename --no-use"
OPTS["deployment_destroy"]="--uuid"
OPTS["deployment_destroy"]="--deployment"
OPTS["deployment_list"]=""
OPTS["deployment_recreate"]="--uuid"
OPTS["deployment_show"]="--uuid"
OPTS["deployment_recreate"]="--deployment"
OPTS["deployment_show"]="--deployment"
for OPT in ${!OPTS[*]} ; do
@ -75,4 +75,4 @@ _rally()
fi
return 0
}
complete -F _rally rally
complete -F _rally rally