def _create_volume(self, size, **kwargs):
"""Create one volume.
Returns when the volume is actually created and is in the "Available"
state.
:param size: int be size of volume in GB, or
dictionary, must contain two values:
min - minimum size volumes will be created as;
max - maximum size volumes will be created as.
:param kwargs: Other optional parameters to initialize the volume
:returns: Created volume object
"""
kwargs["display_name"] = kwargs.get("display_name", self._generate_random_name())
if isinstance(size, dict):
size = random.randint(size["min"], size["max"])
volume = self.clients("cinder").volumes.create(size, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the volume is ready => less API calls.
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval,
)
return volume
def _create_snapshot(self, volume_id, force=False, **kwargs):
"""Create one snapshot.
Returns when the snapshot is actually created and is in the "Available"
state.
:param volume_id: volume uuid for creating snapshot
:param force: flag to indicate whether to snapshot a volume even if
it's attached to an instance
:param kwargs: Other optional parameters to initialize the volume
:returns: Created snapshot object
"""
kwargs["display_name"] = kwargs.get("display_name",
self._generate_random_name())
kwargs["force"] = force
snapshot = self.clients("cinder").volume_snapshots.create(volume_id,
**kwargs)
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
snapshot = bench_utils.wait_for(
snapshot,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
return snapshot
def _create_volume(self, size, **kwargs):
"""create one volume.
Returns when the volume is actually created and is in the "Available"
state.
:param size: int be size of volume in GB
:param **kwargs: Other optional parameters to initialize the volume
:returns: Created volume object
"""
kwargs["display_name"] = kwargs.get("display_name",
self._generate_random_name())
volume = self.clients("cinder").volumes.create(size, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the volume is ready => less API calls.
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
return volume
def _create_share(self, share_proto, size=1, **kwargs):
"""Create a share.
:param share_proto: share protocol for new share,
available values are NFS, CIFS, GlusterFS and HDFS.
:param size: size of a share in GB
:param snapshot_id: ID of the snapshot
:param name: name of new share
:param description: description of a share
:param metadata: optional metadata to set on share creation
:param share_network: either instance of ShareNetwork or str with ID
:param share_type: either instance of ShareType or str with ID
:param is_public: defines whether to set share as public or not.
:returns: instance of :class:`Share`
"""
if (self.context and
self.context.get("tenant", {}).get("share_networks", []) and
not kwargs.get("share_network")):
kwargs["share_network"] = next(self.context.get("tenant", {}).get(
"sn_iterator"))
if not kwargs.get("name"):
kwargs["name"] = self._generate_random_name()
share = self.clients("manila").shares.create(
share_proto, size, **kwargs)
time.sleep(CONF.benchmark.manila_share_create_prepoll_delay)
share = bench_utils.wait_for(
share,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.manila_share_create_timeout,
check_interval=CONF.benchmark.manila_share_create_poll_interval,
)
return share
def _create_image(self, image_name, container_format,
image_url, disk_format, **kwargs):
"""Create a new image.
:param image_name: String used to name the image
:param container_format: Container format of image.
Acceptable formats: ami, ari, aki, bare, and ovf.
:param image_url: URL for download image
:param disk_format: Disk format of image. Acceptable formats:
ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso.
:param **kwargs: optional parameters to create image
returns: object of image
"""
image = self.clients("glance").images.create(
name=image_name,
copy_from=image_url,
container_format=container_format,
disk_format=disk_format,
**kwargs)
time.sleep(CONF.benchmark.glance_image_create_prepoll_delay)
image = bench_utils.wait_for(
image,
is_ready=bench_utils.resource_is("active"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.glance_image_create_poll_interval)
return image
def _boot_server(cls, server_name, image_id, flavor_id, **kwargs):
"""Boots one server.
Returns when the server is actually booted and is in the "Active"
state.
:param server_name: String used to name the server
:param image_id: ID of the image to be used for server creation
:param flavor_id: ID of the flavor to be used for server creation
:param **kwargs: Other optional parameters to initialize the server
:returns: Created server object
"""
if 'security_groups' not in kwargs:
kwargs['security_groups'] = ['rally_open']
else:
if 'rally_open' not in kwargs['security_groups']:
kwargs['security_groups'].append('rally_open')
server = cls.clients("nova").servers.create(
server_name, image_id, flavor_id, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the server is ready => less API calls.
time.sleep(5)
server = utils.wait_for(server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
return server
def _create_stack(self, template):
"""Create a new stack.
:param template: template with stack description.
:returns: object of stack
"""
stack_name = self._generate_random_name()
kw = {
"stack_name": stack_name,
"disable_rollback": True,
"parameters": {},
"template": template,
"files": {},
"environment": {}
}
# heat client returns body instead manager object, so we should
# get manager object using stack_id
stack_id = self.clients("heat").stacks.create(**kw)["stack"]["id"]
stack = self.clients("heat").stacks.get(stack_id)
time.sleep(CONF.benchmark.heat_stack_create_prepoll_delay)
stack = bench_utils.wait_for(
stack,
is_ready=bench_utils.resource_is("CREATE_COMPLETE"),
update_resource=bench_utils.get_from_manager(["CREATE_FAILED"]),
timeout=CONF.benchmark.heat_stack_create_timeout,
check_interval=CONF.benchmark.heat_stack_create_poll_interval)
return stack
def _live_migrate(self, server, target_host, block_migration=False,
disk_over_commit=False, skip_host_check=False):
"""Run live migration of the given server.
:param server: Server object
:param target_host: Specifies the target compute node to migrate
:param block_migration: Specifies the migration type
:param disk_over_commit: Specifies whether to overcommit migrated
instance or not
:param skip_host_check: Specifies whether to verify the targeted host
availability
"""
server_admin = self.admin_clients("nova").servers.get(server.id)
host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host")
server_admin.live_migrate(target_host,
block_migration=block_migration,
disk_over_commit=disk_over_commit)
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_live_migrate_timeout,
check_interval=(
CONF.benchmark.nova_server_live_migrate_poll_interval)
)
server_admin = self.admin_clients("nova").servers.get(server.id)
if (host_pre_migrate == getattr(server_admin, "OS-EXT-SRV-ATTR:host")
and not skip_host_check):
raise exceptions.LiveMigrateException(
"Migration complete but instance did not change host: %s" %
host_pre_migrate)
def _migrate(self, server, skip_host_check=False):
"""Run migration of the given server.
:param server: Server object
:param skip_host_check: Specifies whether to verify the targeted host
availability
"""
server_admin = self.admin_clients("nova").servers.get(server.id)
host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host")
server_admin.migrate()
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("VERIFY_RESIZE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_migrate_timeout,
check_interval=(
CONF.benchmark.nova_server_migrate_poll_interval)
)
if not skip_host_check:
server_admin = self.admin_clients("nova").servers.get(server.id)
host_after_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host")
if host_pre_migrate == host_after_migrate:
raise exceptions.MigrateException(
"Migration complete but instance did not change host: %s" %
host_pre_migrate)
def _update_stack(self, stack, template, parameters=None,
files=None, environment=None):
"""Update an existing stack
:param stack: stack that need to be updated
:param template: Updated template
:param parameters: template parameters for stack update
:param files: additional files used in template
:param environment: stack environment definition
:returns: object of updated stack
"""
kw = {
"stack_name": stack.stack_name,
"disable_rollback": True,
"parameters": parameters or {},
"template": template,
"files": files or {},
"environment": environment or {}
}
self.clients("heat").stacks.update(stack.id, **kw)
time.sleep(CONF.benchmark.heat_stack_update_prepoll_delay)
stack = bench_utils.wait_for(
stack,
is_ready=bench_utils.resource_is("UPDATE_COMPLETE"),
update_resource=bench_utils.get_from_manager(["UPDATE_FAILED"]),
timeout=CONF.benchmark.heat_stack_update_timeout,
check_interval=CONF.benchmark.heat_stack_update_poll_interval)
return stack
def _boot_server(self, server_name, image_id, flavor_id, **kwargs):
"""Boots one server.
Returns when the server is actually booted and is in the "Active"
state.
:param server_name: String used to name the server
:param image_id: ID of the image to be used for server creation
:param flavor_id: ID of the flavor to be used for server creation
:param **kwargs: Other optional parameters to initialize the server
:returns: Created server object
"""
if 'security_groups' not in kwargs:
kwargs['security_groups'] = [secgroup.SSH_GROUP_NAME]
else:
if secgroup.SSH_GROUP_NAME not in kwargs['security_groups']:
kwargs['security_groups'].append(secgroup.SSH_GROUP_NAME)
server = self.clients("nova").servers.create(server_name, image_id,
flavor_id, **kwargs)
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
server = bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
check_interval=CONF.benchmark.nova_server_boot_poll_interval
)
return server
def _wait_for_ping(self, server_ip):
server_ip = netaddr.IPAddress(server_ip)
bench_utils.wait_for(
server_ip,
is_ready=bench_utils.resource_is(ICMP_UP_STATUS,
self._ping_ip_address),
timeout=120
)
def _wait_finish_of_deploy(self, environment):
bench_utils.wait_for(
environment, is_ready=bench_utils.resource_is("READY"),
update_resource=bench_utils.get_from_manager(),
timeout=1200.0,
check_interval=5.0
)
def _do_server_reboot(self, server, reboottype):
server.reboot(reboot_type=reboottype)
time.sleep(CONF.benchmark.nova_server_reboot_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_reboot_timeout,
check_interval=CONF.benchmark.nova_server_reboot_poll_interval
)
def _resize(self, server, flavor):
server.resize(flavor)
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("VERIFY_RESIZE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_timeout,
check_interval=CONF.benchmark.nova_server_resize_poll_interval
)
def _resize_revert(self, server, status="ACTIVE"):
server.revert_resize()
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is(status),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_revert_timeout,
check_interval=(
CONF.benchmark.nova_server_resize_revert_poll_interval)
)
def _resize_confirm(self, server):
server.confirm_resize()
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_confirm_timeout,
check_interval=(
CONF.benchmark.nova_server_resize_confirm_poll_interval)
)
def _delete_image(cls, image):
"""Deletes the given image.
Returns when the image is actually deleted.
:param image: Image object
"""
image.delete()
utils.wait_for(image, is_ready=bench_utils.resource_is("DELETED"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
def _stop_server(cls, server):
"""Stop the given server.
Issues a stop on the given server and waits for the server
to become SHUTOFF.
:param server: The server to stop.
"""
server.stop()
utils.wait_for(server, is_ready=bench_utils.resource_is("SHUTOFF"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=2)
def _start_server(cls, server):
"""Starts the given server.
A start will be issued for the given server upon which time
this method will wait for it to become ACTIVE.
:param server: The server to start and wait to become ACTIVE.
"""
server.start()
utils.wait_for(server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=2)
def _detach_volume(self, server, volume):
server_id = server.id
volume_id = volume.id
self.clients("nova").volumes.delete_server_volume(server_id,
volume_id)
bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_detach_volume_timeout,
check_interval=CONF.benchmark.nova_detach_volume_poll_interval
)
def _unrescue_server(cls, server):
"""Unrescue the given server.
Returns when the server is unrescue and waits to become ACTIVE
:param server: Server object
"""
server.unrescue()
time.sleep(2)
utils.wait_for(server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
def _suspend_server(cls, server):
"""Suspends the given server.
Returns when the server is actually suspended and is in the "Suspended"
state.
:param server: Server object
"""
server.suspend()
time.sleep(2)
utils.wait_for(server, is_ready=bench_utils.resource_is("SUSPENDED"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
def _rescue_server(cls, server):
"""Rescue the given server.
Returns when the server is actually rescue and is in the "Rescue"
state.
:param server: Server object
"""
server.rescue()
time.sleep(2)
utils.wait_for(server, is_ready=bench_utils.resource_is("RESCUE"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
def _boot_server(self, server_name, image_id, flavor_id,
auto_assign_nic=False, **kwargs):
"""Boots one server.
Returns when the server is actually booted and is in the "Active"
state.
If multiple networks are present, the first network found that
isn't associated with a floating IP pool is used.
:param server_name: String used to name the server
:param image_id: ID of the image to be used for server creation
:param flavor_id: ID of the flavor to be used for server creation
:param auto_assign_nic: Boolean for whether or not to assign NICs
:param **kwargs: Other optional parameters to initialize the server
:returns: Created server object
"""
allow_ssh_secgroup = self.context().get("allow_ssh")
if allow_ssh_secgroup:
if 'security_groups' not in kwargs:
kwargs['security_groups'] = [allow_ssh_secgroup]
elif allow_ssh_secgroup not in kwargs['security_groups']:
kwargs['security_groups'].append(allow_ssh_secgroup)
nics = kwargs.get('nics', False)
if auto_assign_nic and nics is False:
nets = self.clients("nova").networks.list()
fip_pool = [
pool.name
for pool in
self.clients("nova").floating_ip_pools.list()
]
for net in nets:
if net.label not in fip_pool:
kwargs['nics'] = [{'net-id': net.id}]
break
server = self.clients("nova").servers.create(server_name, image_id,
flavor_id, **kwargs)
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
server = bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
check_interval=CONF.benchmark.nova_server_boot_poll_interval
)
return server
def _upload_volume_to_image(self, volume, force=False,
container_format="bare", disk_format="raw"):
"""Upload the given volume to image.
Returns created image.
:param volume: volume object
:param force: flag to indicate whether to snapshot a volume even if
it's attached to an instance
:param container_format: container format of image. Acceptable
formats: ami, ari, aki, bare, and ovf
:param: disk_format: disk format of image. Acceptable formats:
ami, ari, aki, vhd, vmdk, raw, qcow2, vdi
and iso
:returns: Returns created image object
"""
resp, img = volume.upload_to_image(force, self._generate_random_name(),
container_format, disk_format)
# NOTE (e0ne): upload_to_image changes volume status to uploading so
# we need to wait until it will be available.
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
image_id = img["os-volume_upload_image"]["image_id"]
image = self.clients("glance").images.get(image_id)
image = bench_utils.wait_for(
image,
is_ready=bench_utils.resource_is("active"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.glance_image_create_prepoll_delay,
check_interval=CONF.benchmark.glance_image_create_poll_interval
)
return image
def _resume_stack(self, stack):
"""Resume given stack.
:param stack: stack that needs to be resumed
"""
self.clients("heat").actions.resume(stack.id)
bench_utils.wait_for(
stack,
is_ready=bench_utils.resource_is("RESUME_COMPLETE"),
update_resource=bench_utils.get_from_manager(
["RESUME_FAILED"]),
timeout=CONF.benchmark.heat_stack_resume_timeout,
check_interval=CONF.benchmark.heat_stack_resume_poll_interval)
def _deploy_environment(self, environment, session):
"""Deploy environment.
:param environment: Environment instance
:param session: Session instance
"""
self.clients("murano").sessions.deploy(environment.id,
session.id)
bench_utils.wait_for(
environment, is_ready=bench_utils.resource_is("READY"),
update_resource=bench_utils.get_from_manager(["DEPLOY FAILURE"]),
timeout=CONF.benchmark.deploy_environment_timeout,
check_interval=CONF.benchmark.deploy_environment_check_interval
)
def _create_backup(self, volume_id, **kwargs):
"""Create a volume backup of the given volume.
:param volume_id: The ID of the volume to backup.
:param kwargs: Other optional parameters
"""
backup = self.clients("cinder").backups.create(volume_id, **kwargs)
return bench_utils.wait_for(
backup,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
def _attach_volume(self, server, volume, device=None):
server_id = server.id
volume_id = volume.id
self.clients("nova").volumes.create_server_volume(server_id,
volume_id,
device)
bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("in-use"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_revert_timeout,
check_interval=(
CONF.benchmark.nova_server_resize_revert_poll_interval)
)
def _unrescue_server(self, server):
"""Unrescue the given server.
Returns when the server is unrescue and waits to become ACTIVE
:param server: Server object
"""
server.unrescue()
time.sleep(CONF.benchmark.nova_server_unrescue_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_unrescue_timeout,
check_interval=CONF.benchmark.nova_server_unrescue_poll_interval
)
def _stop_server(self, server):
"""Stop the given server.
Issues a stop on the given server and waits for the server
to become SHUTOFF.
:param server: The server to stop.
"""
server.stop()
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("SHUTOFF"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_stop_timeout,
check_interval=CONF.benchmark.nova_server_stop_poll_interval
)
def _start_server(self, server):
"""Start the given server.
A start will be issued for the given server upon which time
this method will wait for it to become ACTIVE.
:param server: The server to start and wait to become ACTIVE.
"""
server.start()
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_start_timeout,
check_interval=CONF.benchmark.nova_server_start_poll_interval
)
def _extend_volume(self, volume, new_size):
"""Extend the given volume.
Returns when the volume is actually extended.
:param volume: volume object
:param new_size: new volume size in GB
"""
volume.extend(volume, new_size)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
def _rebuild_server(self, server, image, **kwargs):
"""Rebuild a server with a new image.
:param server: The server to rebuild.
:param image: The new image to rebuild the server with.
:param kwargs: Optional additional arguments to pass to the rebuild
"""
server.rebuild(image, **kwargs)
time.sleep(CONF.benchmark.nova_server_rebuild_prepoll_delay)
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_rebuild_timeout,
check_interval=CONF.benchmark.nova_server_rebuild_poll_interval)
def _boot_server(self, image_id, flavor_id,
auto_assign_nic=False, name=None, **kwargs):
"""Boot a server.
Returns when the server is actually booted and in "ACTIVE" state.
If multiple networks are present, the first network found that
isn't associated with a floating IP pool is used.
:param image_id: int, image ID for server creation
:param flavor_id: int, flavor ID for server creation
:param auto_assign_nic: bool, whether or not to auto assign NICs
:param name: str, server name
:param kwargs: other optional parameters to initialize the server
:returns: nova Server instance
"""
server_name = name or self._generate_random_name()
secgroup = self.context.get("user", {}).get("secgroup")
if secgroup:
if "security_groups" not in kwargs:
kwargs["security_groups"] = [secgroup["name"]]
elif secgroup["name"] not in kwargs["security_groups"]:
kwargs["security_groups"].append(secgroup["name"])
if auto_assign_nic and not kwargs.get("nics", False):
nets = [net["id"] for net in
self.context.get("tenant", {}).get("networks", [])]
if nets:
# NOTE(amaretskiy): Balance servers among networks:
# divmod(iteration % tenants_num, nets_num)[1]
net_idx = divmod(
(self.context["iteration"]
% self.context["config"]["users"]["tenants"]),
len(nets))[1]
kwargs["nics"] = [{"net-id": nets[net_idx]}]
server = self.clients("nova").servers.create(
server_name, image_id, flavor_id, **kwargs)
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
server = bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
check_interval=CONF.benchmark.nova_server_boot_poll_interval
)
return server
def _suspend_server(self, server):
"""Suspends the given server.
Returns when the server is actually suspended and is in the "Suspended"
state.
:param server: Server object
"""
server.suspend()
time.sleep(CONF.benchmark.nova_server_suspend_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("SUSPENDED"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_suspend_timeout,
check_interval=CONF.benchmark.nova_server_suspend_poll_interval
)
def _rescue_server(self, server):
"""Rescue the given server.
Returns when the server is actually rescue and is in the "Rescue"
state.
:param server: Server object
"""
server.rescue()
time.sleep(CONF.benchmark.nova_server_rescue_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("RESCUE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_rescue_timeout,
check_interval=CONF.benchmark.nova_server_rescue_poll_interval
)
def _set_alarm_state(self, alarm, state, timeout):
"""Set the state of the alarm.
:param alarm: alarm instance
:param state: an alarm state to be set
:param timeout: The number of seconds for which to attempt a
successful check of the alarm state.
:returns: alarm in the set state
"""
self.clients("ceilometer").alarms.set_state(alarm.alarm_id, state)
return bench_utils.wait_for(
alarm,
is_ready=bench_utils.resource_is(state),
update_resource=bench_utils.get_from_manager(),
timeout=timeout,
check_interval=1)
def _unpause_server(self, server):
"""Unpause the paused server.
Returns when the server is actually unpaused and is in the "ACTIVE"
state.
:param server: Server object
"""
server.unpause()
time.sleep(CONF.benchmark.nova_server_unpause_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_unpause_timeout,
check_interval=CONF.benchmark.nova_server_unpause_poll_interval
)
def _shelve_server(self, server):
"""Shelve the given server.
Returns when the server is actually shelved and is in the
"SHELVED_OFFLOADED" state.
:param server: Server object
"""
server.shelve()
time.sleep(CONF.benchmark.nova_server_shelve_prepoll_delay)
bench_utils.wait_for(
server, is_ready=bench_utils.resource_is("SHELVED_OFFLOADED"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_shelve_timeout,
check_interval=CONF.benchmark.nova_server_shelve_poll_interval
)
def _boot_servers(self,
image_id,
flavor_id,
requests,
name_prefix=None,
instances_amount=1,
**kwargs):
"""Boot multiple servers.
Returns when all the servers are actually booted and are in the
"Active" state.
:param image_id: ID of the image to be used for server creation
:param flavor_id: ID of the flavor to be used for server creation
:param requests: Number of booting requests to perform
:param name_prefix: The prefix to use while naming the created servers.
The rest of the server names will be '_<number>'
:param instances_amount: Number of instances to boot per each request
:returns: List of created server objects
"""
if not name_prefix:
name_prefix = self._generate_random_name()
for i in range(requests):
self.clients("nova").servers.create("%s_%d" % (name_prefix, i),
image_id,
flavor_id,
min_count=instances_amount,
max_count=instances_amount,
**kwargs)
# NOTE(msdubov): Nova python client returns only one server even when
# min_count > 1, so we have to rediscover all the
# created servers manually.
servers = filter(lambda server: server.name.startswith(name_prefix),
self.clients("nova").servers.list())
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
servers = [
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
check_interval=CONF.benchmark.nova_server_boot_poll_interval)
for server in servers
]
return servers
def test_wait_for_timeout_failure(self):
self.resource.name = "fake_name"
self.resource.id = "fake_id"
self.resource.status = "fake_stale_status"
is_ready = utils.resource_is("fake_new_status")
exc = self.assertRaises(exceptions.TimeoutException, utils.wait_for,
self.resource, is_ready, self.fake_updater,
self.load_secs, self.load_secs / 3)
self.assertEqual(exc.kwargs["resource_name"], "fake_name")
self.assertEqual(exc.kwargs["resource_id"], "fake_id")
self.assertEqual(exc.kwargs["desired_status"], "fake_new_status")
self.assertEqual(exc.kwargs["resource_status"], "FAKE_STALE_STATUS")
self.assertIn("FakeResource", str(exc))
self.assertIn("fake_new_status", str(exc))
def _create_image(self, image_name, container_format, image_location,
disk_format, **kwargs):
"""Create a new image.
:param image_name: String used to name the image
:param container_format: Container format of image.
Acceptable formats: ami, ari, aki, bare, and ovf.
:param image_location: image file location used to upload
:param disk_format: Disk format of image. Acceptable formats:
ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso.
:param **kwargs: optional parameters to create image
returns: object of image
"""
kw = {
"name": image_name,
"container_format": container_format,
"disk_format": disk_format,
}
kw.update(kwargs)
try:
if os.path.isfile(image_location):
kw["data"] = open(image_location)
else:
kw["copy_from"] = image_location
image = self.clients("glance").images.create(**kw)
time.sleep(CONF.benchmark.glance_image_create_prepoll_delay)
image = bench_utils.wait_for(
image,
is_ready=bench_utils.resource_is("active"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.glance_image_create_poll_interval
)
finally:
if "data" in kw:
kw["data"].close()
return image
def _reboot_server(self, server, soft=True):
"""Reboots the given server using hard or soft reboot.
A reboot will be issued on the given server upon which time
this method will wait for the server to become active.
:param server: The server to reboot.
:param soft: False if hard reboot should be used, otherwise
soft reboot is done (default).
"""
server.reboot(reboot_type=("SOFT" if soft else "HARD"))
time.sleep(CONF.benchmark.nova_server_reboot_prepoll_delay)
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_reboot_timeout,
check_interval=CONF.benchmark.nova_server_reboot_poll_interval)
def create_servers(self):
"""Create VMs with chosen image."""
image_uuid = self.get_image_uuid()
userdata = self.get_userdata()
flavor = self.config['flavor_id']
nics = self.get_nics()
keypair, public_key_path = self.create_keypair()
os_servers = []
for i in range(self.config.get('amount', 1)):
name = "%s-%d" % (self.config['deployment_name'], i)
server = self.nova.servers.create(name,
image_uuid,
flavor,
nics=nics,
key_name=keypair.name,
userdata=userdata)
os_servers.append(server)
self.resources.create({'id': server.id}, type=SERVER_TYPE)
kwargs = {
'is_ready': benchmark_utils.resource_is("ACTIVE"),
'update_resource': benchmark_utils.get_from_manager(),
'timeout': 120,
'check_interval': 5
}
for os_server in os_servers:
benchmark_utils.wait_for(os_server, **kwargs)
servers = [
provider.Server(host=s.addresses.values()[0][0]['addr'],
user='******',
key=public_key_path) for s in os_servers
]
for s in servers:
s.ssh.wait(timeout=120, interval=5)
# NOTE(eyerediskin): usually ssh is ready much earlier then cloud-init
time.sleep(8)
return servers
def _create_image(self, server):
"""Creates an image of the given server
Uses the server name to name the created image. Returns when the image
is actually created and is in the "Active" state.
:param server: Server object for which the image will be created
:returns: Created image object
"""
image_uuid = self.clients("nova").servers.create_image(
server, server.name)
image = self.clients("nova").images.get(image_uuid)
check_interval = CONF.benchmark.nova_server_image_create_poll_interval
image = bench_utils.wait_for(
image,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_image_create_timeout,
check_interval=check_interval)
return image
def _create_stack(self,
template,
parameters=None,
files=None,
environment=None):
"""Create a new stack.
:param template: template with stack description.
:param parameters: template parameters used during stack creation
:param files: additional files used in template
:param environment: stack environment definition
:returns: object of stack
"""
stack_name = self._generate_random_name(prefix="rally_stack_")
kw = {
"stack_name": stack_name,
"disable_rollback": True,
"parameters": parameters or {},
"template": template,
"files": files or {},
"environment": environment or {}
}
# heat client returns body instead manager object, so we should
# get manager object using stack_id
stack_id = self.clients("heat").stacks.create(**kw)["stack"]["id"]
stack = self.clients("heat").stacks.get(stack_id)
time.sleep(CONF.benchmark.heat_stack_create_prepoll_delay)
stack = bench_utils.wait_for(
stack,
is_ready=bench_utils.resource_is("CREATE_COMPLETE"),
update_resource=bench_utils.get_from_manager(["CREATE_FAILED"]),
timeout=CONF.benchmark.heat_stack_create_timeout,
check_interval=CONF.benchmark.heat_stack_create_poll_interval)
return stack
def _extend_volume(self, volume, new_size):
"""Extend the given volume.
Returns when the volume is actually extended.
:param volume: volume object
:param new_size: new 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.
Notice: should be bigger volume size
"""
if isinstance(new_size, dict):
new_size = random.randint(new_size["min"], new_size["max"])
volume.extend(volume, new_size)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
def _create_volume(self, size, **kwargs):
"""Create one volume.
Returns when the volume is actually created and is in the "Available"
state.
:param size: int be size of volume in GB
:param kwargs: Other optional parameters to initialize the volume
:returns: Created volume object
"""
kwargs["display_name"] = kwargs.get("display_name",
self._generate_random_name())
volume = self.clients("cinder").volumes.create(size, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the volume is ready => less API calls.
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
return volume
def _migrate(self, server, skip_host_check=False):
"""Run migration of the given server.
:param server: Server object
:param skip_host_check: Specifies whether to verify the targeted host
availability
"""
server_admin = self.admin_clients("nova").servers.get(server.id)
host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host")
server_admin.migrate()
bench_utils.wait_for(
server,
is_ready=bench_utils.resource_is("VERIFY_RESIZE"),
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_migrate_timeout,
check_interval=(CONF.benchmark.nova_server_migrate_poll_interval))
if not skip_host_check:
server_admin = self.admin_clients("nova").servers.get(server.id)
host_after_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host")
if host_pre_migrate == host_after_migrate:
raise exceptions.MigrateException(
"Migration complete but instance did not change host: %s" %
host_pre_migrate)
def test_resource_is_with_fake_status_getter(self):
fake_getter = mock.MagicMock(return_value="LGTM")
fake_res = mock.MagicMock()
is_lgtm = utils.resource_is("LGTM", fake_getter)
self.assertTrue(is_lgtm(fake_res))
fake_getter.assert_called_once_with(fake_res)
def test_resource_is(self):
is_active = utils.resource_is("ACTIVE")
self.assertTrue(is_active(fakes.FakeResource(status="active")))
self.assertTrue(is_active(fakes.FakeResource(status="aCtIvE")))
self.assertFalse(is_active(fakes.FakeResource(status="ERROR")))
def _wait_for_ping(self, server_ip):
server_ip = netaddr.IPAddress(server_ip)
bench_utils.wait_for(server_ip,
is_ready=bench_utils.resource_is(
ICMP_UP_STATUS, self._ping_ip_address),
timeout=120)
