def _create_cluster(self, cluster_template, node_count, **kwargs):
"""Create a cluster
:param cluster_template: cluster_template for the cluster
:param node_count: the cluster node count
:param kwargs: optional additional arguments for cluster creation
:returns: magnum cluster
"""
name = self.generate_random_name()
cluster = self.clients("magnum").clusters.create(
name=name,
cluster_template_id=cluster_template,
node_count=node_count,
**kwargs)
common_utils.interruptable_sleep(
CONF.openstack.magnum_cluster_create_prepoll_delay)
cluster = utils.wait_for_status(
cluster,
ready_statuses=["CREATE_COMPLETE"],
update_resource=utils.get_from_manager(),
timeout=CONF.openstack.magnum_cluster_create_timeout,
check_interval=CONF.openstack.magnum_cluster_create_poll_interval,
id_attr="uuid")
return cluster
def check_metric(self, seed, sleep_time, retries_total):
"""Check metric with seed name in Grafana datasource.
:param seed: random metric name
:param sleep_time: sleep time between checking metrics in seconds
:param retries_total: total number of retries to check metric in
Grafana
:return: True if metric in Grafana datasource and False otherwise
"""
check_url = ("http://%(vip)s:%(port)s/api/datasources/proxy/:"
"%(datasource)s/api/v1/query?query=%(seed)s" % {
"vip": self._spec["monitor_vip"],
"port": self._spec["grafana"]["port"],
"datasource": self._spec["datasource_id"],
"seed": seed
})
i = 0
LOG.info("Check metric %s in Grafana" % seed)
while i < retries_total:
LOG.debug("Attempt number %s" % (i + 1))
resp = requests.get(check_url,
auth=(self._spec["grafana"]["user"],
self._spec["grafana"]["password"]))
result = resp.json()
LOG.debug("Grafana response code: %s" % resp.status_code)
if len(result["data"]["result"]) < 1 and i + 1 >= retries_total:
LOG.debug("No instance metrics found in Grafana")
return False
elif len(result["data"]["result"]) < 1:
i += 1
commonutils.interruptable_sleep(sleep_time)
else:
LOG.debug("Metric instance found in Grafana")
return True
def wait_for_status(name, status, read_method, resource_type=None, **kwargs):
"""Util method for polling status until it won't be equals to `status`.
:param name: resource name
:param status: status waiting for
:param read_method: method to poll
:param resource_type: resource type for extended exceptions
:param kwargs: additional kwargs for read_method
"""
sleep_time = CONF.kubernetes.status_poll_interval
retries_total = CONF.kubernetes.status_total_retries
commonutils.interruptable_sleep(CONF.kubernetes.start_prepoll_delay)
i = 0
while i < retries_total:
resp = read_method(name=name, **kwargs)
resp_id = resp.metadata.uid
current_status = resp.status.phase
if resp.status.phase != status:
i += 1
commonutils.interruptable_sleep(sleep_time)
else:
return
if i == retries_total:
raise exceptions.TimeoutException(desired_status=status,
resource_name=name,
resource_type=resource_type,
resource_id=resp_id or "<no id>",
resource_status=current_status,
timeout=(retries_total *
sleep_time))
def delete_pod(self, name, namespace, sleep_time=5, retries_total=30):
"""Delete pod from namespace.
:param name: pod's name
:param namespace: pod's namespace
:param sleep_time: sleep time between each two retries
:param retries_total: total number of retries
:returns True if delete successful and False otherwise
"""
resp = self.api.delete_namespaced_pod(name=name,
namespace=namespace,
body=client.V1DeleteOptions())
LOG.info("Pod %(name)s delete started. Status: %(status)s" % {
"name": name,
"status": resp.status
})
i = 0
while i < retries_total:
LOG.debug("Attempt number %s" % i)
try:
self.api.read_namespaced_pod_status(name=name,
namespace=namespace)
except Exception:
return True
else:
commonutils.interruptable_sleep(sleep_time)
i += 1
return False
def wait_for_not_found(name, read_method, resource_type=None, **kwargs):
"""Util method for polling status while resource exists.
:param name: resource name
:param read_method: method to poll
:param resource_type: resource type for extended exceptions
:param kwargs: additional kwargs for read_method
"""
sleep_time = CONF.kubernetes.status_poll_interval
retries_total = CONF.kubernetes.status_total_retries
commonutils.interruptable_sleep(CONF.kubernetes.start_prepoll_delay)
i = 0
while i < retries_total:
try:
resp = read_method(name=name, **kwargs)
resp_id = resp.metadata.uid
current_status = resp.status.phase
except rest.ApiException as ex:
if ex.status == 404:
return
else:
raise
else:
commonutils.interruptable_sleep(sleep_time)
i += 1
if i == retries_total:
raise exceptions.TimeoutException(desired_status="Terminated",
resource_name=name,
resource_type=resource_type,
resource_id=resp_id or "<no id>",
resource_status=current_status,
timeout=(retries_total *
sleep_time))
def _create_v1rc(self, manifest):
"""Create rc on the specify cluster.
:param manifest: manifest use to create the replication controller
"""
k8s_api = self._get_k8s_api_client()
suffix = "-"
for i in range(5):
suffix = suffix + random.choice(string.ascii_lowercase)
rcname = manifest["metadata"]["name"] + suffix
manifest["metadata"]["name"] = rcname
resp = k8s_api.create_namespaced_replication_controller(
body=manifest, namespace="default")
expectd_status = resp.spec.replicas
start = time.time()
while True:
resp = k8s_api.read_namespaced_replication_controller(
name=rcname, namespace="default")
status = resp.status.replicas
if status == expectd_status:
return resp
else:
if time.time() - start > CONF.openstack.k8s_rc_create_timeout:
raise exceptions.TimeoutException(
desired_status=expectd_status,
resource_name=rcname,
resource_type="ReplicationController",
resource_id=resp.metadata.uid,
resource_status=status,
timeout=CONF.openstack.k8s_rc_create_timeout)
common_utils.interruptable_sleep(
CONF.openstack.k8s_rc_create_poll_interval)
def create_snapshot(self, volume_id, force=False,
name=None, description=None, metadata=None):
"""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 name: Name of the snapshot
:param description: Description of the snapshot
:returns: Created snapshot object
"""
kwargs = {"force": force,
"name": name or self.generate_random_name(),
"description": description,
"metadata": metadata}
snapshot = self._get_client().volume_snapshots.create(volume_id,
**kwargs)
rutils.interruptable_sleep(
CONF.openstack.cinder_volume_create_prepoll_delay)
snapshot = self._wait_available_volume(snapshot)
return snapshot
def create_image(self, image_name=None, container_format=None,
image_location=None, disk_format=None,
visibility=None, min_disk=0,
min_ram=0, properties=None):
"""Creates new image.
:param image_name: Image name for which need to be created
:param container_format: Container format
:param image_location: The new image's location
:param disk_format: Disk format
:param visibility: The created image's visible status.
:param min_disk: The min disk of created images
:param min_ram: The min ram of created images
:param properties: Dict of image properties
"""
image_name = image_name or self.generate_random_name()
properties = properties or {}
image_obj = self._clients.glance("2").images.create(
name=image_name,
container_format=container_format,
disk_format=disk_format,
visibility=visibility,
min_disk=min_disk,
min_ram=min_ram,
**properties)
image_location = os.path.expanduser(image_location)
rutils.interruptable_sleep(CONF.benchmark.
glance_image_create_prepoll_delay)
start = time.time()
image_obj = utils.wait_for_status(
image_obj.id, ["queued"],
update_resource=self.get_image,
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.glance_image_create_poll_interval)
timeout = time.time() - start
image_data = None
response = None
try:
if os.path.isfile(image_location):
image_data = open(image_location)
else:
response = requests.get(image_location, stream=True)
image_data = response.raw
self._clients.glance("2").images.upload(image_obj.id, image_data)
finally:
if image_data is not None:
image_data.close()
if response is not None:
response.close()
image_obj = utils.wait_for_status(
image_obj, ["active"],
update_resource=self.get_image,
timeout=timeout,
check_interval=CONF.benchmark.glance_image_create_poll_interval)
return image_obj
def delete_rc(self, name, namespace, sleep_time=5, retries_total=30):
"""Delete RC from namespace and wait until it won't be terminated.
:param name: replication controller name
:param namespace: namespace name of defined RC
:param sleep_time: sleep time between each two retries
:param retries_total: total number of retries
:returns True if delete successful and False otherwise
"""
resp = self.api.delete_namespaced_replication_controller(
name=name, namespace=namespace, body=client.V1DeleteOptions())
LOG.info("RC %(name)s delete started. Status: %(status)s" % {
"name": name,
"status": resp.status
})
i = 0
while i < retries_total:
LOG.debug("Attempt number %s" % i)
try:
self.api.read_namespaced_replication_controller_status(
name=name, namespace=namespace)
except Exception:
return True
else:
commonutils.interruptable_sleep(sleep_time)
i += 1
return False
def _create_bay(self, baymodel, node_count, **kwargs):
"""Create a bay
:param baymodel: baymodel for the bay
:param node_count: the bay node count
:param kwargs: optional additional arguments for bay creation
:returns: magnum bay
"""
name = self.generate_random_name()
bay = self.clients("magnum").bays.create(
name=name, baymodel_id=baymodel,
node_count=node_count, **kwargs)
common_utils.interruptable_sleep(
CONF.benchmark.magnum_bay_create_prepoll_delay)
bay = utils.wait_for_status(
bay,
ready_statuses=["CREATE_COMPLETE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.magnum_bay_create_timeout,
check_interval=CONF.benchmark.magnum_bay_create_poll_interval,
id_attr="uuid"
)
return bay
def _create_v1rc(self, manifest):
"""Create rc on the specify cluster.
:param manifest: manifest use to create the replication controller
"""
k8s_api = self._get_k8s_api_client()
suffix = "-"
for i in range(5):
suffix = suffix + random.choice(string.ascii_lowercase)
rcname = manifest["metadata"]["name"] + suffix
manifest["metadata"]["name"] = rcname
resp = k8s_api.create_namespaced_replication_controller(
body=manifest,
namespace="default")
expectd_status = resp.spec.replicas
start = time.time()
while True:
resp = k8s_api.read_namespaced_replication_controller(
name=rcname,
namespace="default")
status = resp.status.replicas
if status == expectd_status:
return resp
else:
if time.time() - start > CONF.openstack.k8s_rc_create_timeout:
raise exceptions.TimeoutException(
desired_status=expectd_status,
resource_name=rcname,
resource_type="ReplicationController",
resource_id=resp.metadata.uid,
resource_status=status,
timeout=CONF.openstack.k8s_rc_create_timeout)
common_utils.interruptable_sleep(
CONF.openstack.k8s_rc_create_poll_interval)
def _create_cluster(self, cluster_template, node_count, **kwargs):
"""Create a cluster
:param cluster_template: cluster_template for the cluster
:param node_count: the cluster node count
:param kwargs: optional additional arguments for cluster creation
:returns: magnum cluster
"""
name = self.generate_random_name()
cluster = self.clients("magnum").clusters.create(
name=name, cluster_template_id=cluster_template,
node_count=node_count, **kwargs)
common_utils.interruptable_sleep(
CONF.openstack.magnum_cluster_create_prepoll_delay)
cluster = utils.wait_for_status(
cluster,
ready_statuses=["CREATE_COMPLETE"],
update_resource=utils.get_from_manager(),
timeout=CONF.openstack.magnum_cluster_create_timeout,
check_interval=CONF.openstack.magnum_cluster_create_poll_interval,
id_attr="uuid"
)
return cluster
def create_snapshot(self, volume_id, force=False,
name=None, description=None, metadata=None):
"""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 name: Name of the snapshot
:param description: Description of the snapshot
:returns: Created snapshot object
"""
kwargs = {"force": force,
"name": name or self.generate_random_name(),
"description": description,
"metadata": metadata}
snapshot = self._get_client().volume_snapshots.create(volume_id,
**kwargs)
rutils.interruptable_sleep(
CONF.benchmark.cinder_volume_create_prepoll_delay)
snapshot = self._wait_available_volume(snapshot)
return snapshot
def create_volume(self,
size,
consistencygroup_id=None,
snapshot_id=None,
source_volid=None,
name=None,
description=None,
volume_type=None,
user_id=None,
project_id=None,
availability_zone=None,
metadata=None,
imageRef=None,
scheduler_hints=None):
"""Creates a volume.
:param size: Size of volume in GB
:param consistencygroup_id: ID of the consistencygroup
:param snapshot_id: ID of the snapshot
:param name: Name of the volume
:param description: Description of the volume
:param volume_type: Type of volume
:param user_id: User id derived from context
:param project_id: Project id derived from context
:param availability_zone: Availability Zone to use
:param metadata: Optional metadata to set on volume creation
:param imageRef: reference to an image stored in glance
:param source_volid: ID of source volume to clone from
:param scheduler_hints: (optional extension) arbitrary key-value pairs
specified by the client to help boot an instance
:param multiattach: Allow the volume to be attached to more than
one instance
:returns: Return a new volume.
"""
kwargs = {
"name": name or self.generate_random_name(),
"description": description,
"consistencygroup_id": consistencygroup_id,
"snapshot_id": snapshot_id,
"source_volid": source_volid,
"volume_type": volume_type,
"user_id": user_id,
"project_id": project_id,
"availability_zone": availability_zone,
"metadata": metadata,
"imageRef": imageRef,
"scheduler_hints": scheduler_hints
}
if isinstance(size, dict):
size = random.randint(size["min"], size["max"])
volume = (self._get_client().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.
rutils.interruptable_sleep(
CONF.openstack.cinder_volume_create_prepoll_delay)
return self._wait_available_volume(volume)
def create_namespace_and_wait_active(self,
name,
sleep_time=5,
retries_total=30):
"""Create namespace and wait until status phase won't be Active.
:param name: namespace name
:param sleep_time: sleep time between each two retries
:param retries_total: total number of retries
:return: True if create successful and False otherwise
"""
self.create_namespace(name)
i = 0
LOG.debug("Wait until namespace status won't be active")
while i < retries_total:
LOG.debug("Attempt number %s" % i)
try:
resp = self.api.read_namespace(name=name)
except Exception as ex:
LOG.warning("Unable to read namespace status: %s" % ex.message)
i += 1
commonutils.interruptable_sleep(sleep_time)
else:
if resp.status.phase != "Active":
i += 1
commonutils.interruptable_sleep(sleep_time)
else:
return True
return False
def _delete_single_resource(self, resource):
"""Safe resource deletion with retries and timeouts.
Send request to delete resource, in case of failures repeat it few
times. After that pull status of resource until it's deleted.
Writes in LOG warning with UUID of resource that wasn't deleted
:param resource: instance of resource manager initiated with resource
that should be deleted.
"""
msg_kw = {
"uuid": resource.id(),
"name": resource.name() or "",
"service": resource._service,
"resource": resource._resource
}
LOG.debug(
"Deleting %(service)s %(resource)s object %(name)s (%(uuid)s)" %
msg_kw)
try:
rutils.retry(resource._max_attempts, resource.delete)
except Exception as e:
msg_kw["reason"] = e
LOG.warning(
_("Resource deletion failed, max retries exceeded for "
"%(service)s.%(resource)s: %(uuid)s. Reason: %(reason)s") %
msg_kw)
if logging.is_debug():
LOG.exception(e)
else:
started = time.time()
failures_count = 0
while time.time() - started < resource._timeout:
try:
if resource.is_deleted():
return
except Exception as e:
LOG.warning(
_("Seems like %s.%s.is_deleted(self) method is broken "
"It shouldn't raise any exceptions.") %
(resource.__module__, type(resource).__name__))
LOG.exception(e)
# NOTE(boris-42): Avoid LOG spamming in case of bad
# is_deleted() method
failures_count += 1
if failures_count > resource._max_attempts:
break
finally:
rutils.interruptable_sleep(resource._interval)
LOG.warning(
_("Resource deletion failed, timeout occurred for "
"%(service)s.%(resource)s: %(uuid)s.") % msg_kw)
def _delete_single_resource(self, resource):
"""Safe resource deletion with retries and timeouts.
Send request to delete resource, in case of failures repeat it few
times. After that pull status of resource until it's deleted.
Writes in LOG warning with UUID of resource that wasn't deleted
:param resource: instance of resource manager initiated with resource
that should be deleted.
"""
msg_kw = {
"uuid": resource.id(),
"name": resource.name() or "",
"service": resource._service,
"resource": resource._resource
}
LOG.debug(
"Deleting %(service)s %(resource)s object %(name)s (%(uuid)s)" %
msg_kw)
try:
rutils.retry(resource._max_attempts, resource.delete)
except Exception as e:
msg_kw["reason"] = e
LOG.warning(
_("Resource deletion failed, max retries exceeded for "
"%(service)s.%(resource)s: %(uuid)s. Reason: %(reason)s")
% msg_kw)
if logging.is_debug():
LOG.exception(e)
else:
started = time.time()
failures_count = 0
while time.time() - started < resource._timeout:
try:
if resource.is_deleted():
return
except Exception as e:
LOG.warning(
_("Seems like %s.%s.is_deleted(self) method is broken "
"It shouldn't raise any exceptions.")
% (resource.__module__, type(resource).__name__))
LOG.exception(e)
# NOTE(boris-42): Avoid LOG spamming in case of bad
# is_deleted() method
failures_count += 1
if failures_count > resource._max_attempts:
break
finally:
rutils.interruptable_sleep(resource._interval)
LOG.warning(_("Resource deletion failed, timeout occurred for "
"%(service)s.%(resource)s: %(uuid)s.")
% msg_kw)
def run(self, number_of_actions=5, sleep_factor=1):
"""Run some sleepy atomic actions for SLA atomic action tests.
:param number_of_actions: int number of atomic actions to create
:param sleep_factor: int multiplier for number of seconds to sleep
"""
for sleeptime in range(number_of_actions):
with atomic.ActionTimer(self, "action_%d" % sleeptime):
utils.interruptable_sleep(sleeptime * sleep_factor)
def run(self, number_of_actions=5, sleep_factor=1):
"""Run some sleepy atomic actions for SLA atomic action tests.
:param number_of_actions: int number of atomic actions to create
:param sleep_factor: int multiplier for number of seconds to sleep
"""
for sleeptime in range(number_of_actions):
with atomic.ActionTimer(self, "action_%d" % sleeptime):
utils.interruptable_sleep(sleeptime * sleep_factor)
def run(self, sleep=0):
"""Do nothing and sleep for the given number of seconds (0 by default).
Dummy.dummy can be used for testing performance of different
ScenarioRunners and of the ability of rally to store a large
amount of results.
:param sleep: idle time of method (in seconds).
"""
utils.interruptable_sleep(sleep)
def run(self, sleep=0):
"""Do nothing and sleep for the given number of seconds (0 by default).
Dummy.dummy can be used for testing performance of different
ScenarioRunners and of the ability of rally to store a large
amount of results.
:param sleep: idle time of method (in seconds).
"""
utils.interruptable_sleep(sleep)
def create_image(self,
image_name=None,
container_format=None,
image_location=None,
disk_format=None,
is_public=True,
min_disk=0,
min_ram=0,
properties=None):
"""Creates new image.
:param image_name: Image name for which need to be created
:param container_format: Container format
:param image_location: The new image's location
:param disk_format: Disk format
:param is_public: The created image's public status
:param min_disk: The min disk of created images
:param min_ram: The min ram of created images
:param properties: Dict of image properties
"""
image_location = os.path.expanduser(image_location)
image_name = image_name or self.generate_random_name()
kwargs = {}
try:
if os.path.isfile(image_location):
kwargs["data"] = open(image_location, "rb")
else:
kwargs["copy_from"] = image_location
image_obj = self._clients.glance("1").images.create(
name=image_name,
container_format=container_format,
disk_format=disk_format,
is_public=is_public,
min_disk=min_disk,
min_ram=min_ram,
properties=properties,
**kwargs)
rutils.interruptable_sleep(
CONF.openstack.glance_image_create_prepoll_delay)
image_obj = utils.wait_for_status(
image_obj, ["active"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval
)
finally:
if "data" in kwargs:
kwargs["data"].close()
return image_obj
def create_volume(self, size, consistencygroup_id=None,
snapshot_id=None, source_volid=None, name=None,
description=None, volume_type=None, user_id=None,
project_id=None, availability_zone=None,
metadata=None, imageRef=None, scheduler_hints=None,
source_replica=None, multiattach=False):
"""Creates a volume.
:param size: Size of volume in GB
:param consistencygroup_id: ID of the consistencygroup
:param snapshot_id: ID of the snapshot
:param name: Name of the volume
:param description: Description of the volume
:param volume_type: Type of volume
:param user_id: User id derived from context
:param project_id: Project id derived from context
:param availability_zone: Availability Zone to use
:param metadata: Optional metadata to set on volume creation
:param imageRef: reference to an image stored in glance
:param source_volid: ID of source volume to clone from
:param source_replica: ID of source volume to clone replica
:param scheduler_hints: (optional extension) arbitrary key-value pairs
specified by the client to help boot an instance
:param multiattach: Allow the volume to be attached to more than
one instance
:returns: Return a new volume.
"""
kwargs = {"name": name or self.generate_random_name(),
"description": description,
"consistencygroup_id": consistencygroup_id,
"snapshot_id": snapshot_id,
"source_volid": source_volid,
"volume_type": volume_type,
"user_id": user_id,
"project_id": project_id,
"availability_zone": availability_zone,
"metadata": metadata,
"imageRef": imageRef,
"scheduler_hints": scheduler_hints,
"source_replica": source_replica,
"multiattach": multiattach}
if isinstance(size, dict):
size = random.randint(size["min"], size["max"])
volume = (self._get_client()
.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.
rutils.interruptable_sleep(
CONF.openstack.cinder_volume_create_prepoll_delay)
return self._wait_available_volume(volume)
def run(self, actions_num=5, sleep_min=0, sleep_max=2):
"""Sleep random time in dummy actions.
:param actions_num: int number of actions to generate
:param sleep_min: minimal time to sleep, numeric seconds
:param sleep_max: maximum time to sleep, numeric seconds
"""
for idx in range(actions_num):
duration = random.uniform(sleep_min, sleep_max)
with atomic.ActionTimer(self, "action_%d" % idx):
utils.interruptable_sleep(duration)
def run(self, actions_num=5, sleep_min=0, sleep_max=2):
"""Sleep random time in dummy actions.
:param actions_num: int number of actions to generate
:param sleep_min: minimal time to sleep, numeric seconds
:param sleep_max: maximum time to sleep, numeric seconds
"""
for idx in range(actions_num):
duration = random.uniform(sleep_min, sleep_max)
with atomic.ActionTimer(self, "action_%d" % idx):
utils.interruptable_sleep(duration)
def delete(self, env_id, retries=5, retry_pause=0.5):
env = self.get(env_id)
retry_number = 0
while env:
if retry_number > retries:
raise RuntimeError(_("Can't delete environment "
"id: %s ") % env_id)
try:
self.client.delete_by_id(env_id)
except BaseException:
rutils.interruptable_sleep(retry_pause)
env = self.get(env_id)
retry_number += 1
def run(self, image, port, protocol, command=None, status_wait=True):
"""Create pod and clusterIP svc, check with curl job, delete then.
:param image: pod's image
:param port: pod's container port and svc port integer
:param protocol: pod's container port and svc port protocol
:param command: pod's array of strings representing command
:param status_wait: wait for pod status if True
"""
namespace = self.choose_namespace()
labels = {"app": self.generate_random_name()}
name = self.client.create_pod(image,
namespace=namespace,
command=command,
port=port,
protocol=protocol,
labels=labels,
status_wait=status_wait)
self.client.create_service(name,
namespace=namespace,
port=port,
protocol=protocol,
type="ClusterIP",
labels=labels)
commonutils.interruptable_sleep(CONF.kubernetes.start_prepoll_delay)
endpoints = self.client.get_endpoints(name, namespace=namespace)
ips = []
for subset in endpoints.subsets:
addrs = [addr.ip for addr in subset.addresses]
ports = [p.port for p in subset.ports]
ips.extend(["%s:%s" % (a, p) for a in addrs for p in ports])
command = ["curl"]
command.extend(ips)
self.client.create_job(name,
namespace=namespace,
image="appropriate/curl",
command=command,
status_wait=True)
self.client.delete_job(name,
namespace=namespace,
status_wait=status_wait)
self.client.delete_service(name, namespace=namespace)
self.client.delete_pod(name,
namespace=namespace,
status_wait=status_wait)
def create_image(self,
image_name=None,
container_format=None,
image_location=None,
disk_format=None,
visibility=None,
min_disk=0,
min_ram=0,
properties=None):
"""Creates new image.
:param image_name: Image name for which need to be created
:param container_format: Container format
:param image_location: The new image's location
:param disk_format: Disk format
:param visibility: The created image's visible status.
:param min_disk: The min disk of created images
:param min_ram: The min ram of created images
:param properties: Dict of image properties
"""
image_name = image_name or self.generate_random_name()
properties = properties or {}
image_obj = self._clients.glance("2").images.create(
name=image_name,
container_format=container_format,
disk_format=disk_format,
visibility=visibility,
min_disk=min_disk,
min_ram=min_ram,
**properties)
rutils.interruptable_sleep(
CONF.openstack.glance_image_create_prepoll_delay)
start = time.time()
image_obj = utils.wait_for_status(
image_obj.id, ["queued"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval)
timeout = time.time() - start
self.upload_data(image_obj.id, image_location=image_location)
image_obj = utils.wait_for_status(
image_obj, ["active"],
update_resource=self.get_image,
timeout=timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval)
return image_obj
def create_image(self, container_format, image_location,
disk_format, **kwargs):
kw = {
"container_format": container_format,
"disk_format": disk_format,
}
kw.update(kwargs)
if "name" not in kw:
kw["name"] = self.owner.generate_random_name()
if "is_public" in kw:
LOG.warning("is_public is not supported by Glance v2, and is "
"deprecated in Rally v0.8.0")
kw["visibility"] = "public" if kw.pop("is_public") else "private"
image_location = os.path.expanduser(image_location)
image = self.client.images.create(**kw)
rutils.interruptable_sleep(CONF.openstack.
glance_image_create_prepoll_delay)
start = time.time()
image = utils.wait_for_status(
image, ["queued"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.
glance_image_create_poll_interval)
timeout = time.time() - start
image_data = None
response = None
try:
if os.path.isfile(image_location):
image_data = open(image_location)
else:
response = requests.get(image_location, stream=True)
image_data = response.raw
self.client.images.upload(image.id, image_data)
finally:
if image_data is not None:
image_data.close()
if response is not None:
response.close()
return utils.wait_for_status(
image, ["active"],
update_resource=self.get_image,
timeout=timeout,
check_interval=CONF.openstack.
glance_image_create_poll_interval)
def create_image(self, image_name=None, container_format=None,
image_location=None, disk_format=None,
is_public=True, min_disk=0, min_ram=0,
properties=None):
"""Creates new image.
:param image_name: Image name for which need to be created
:param container_format: Container format
:param image_location: The new image's location
:param disk_format: Disk format
:param is_public: The created image's public status
:param min_disk: The min disk of created images
:param min_ram: The min ram of created images
:param properties: Dict of image properties
"""
image_location = os.path.expanduser(image_location)
image_name = image_name or self.generate_random_name()
kwargs = {}
try:
if os.path.isfile(image_location):
kwargs["data"] = open(image_location)
else:
kwargs["copy_from"] = image_location
image_obj = self._clients.glance("1").images.create(
name=image_name,
container_format=container_format,
disk_format=disk_format,
is_public=is_public,
min_disk=min_disk,
min_ram=min_ram,
properties=properties,
**kwargs)
rutils.interruptable_sleep(CONF.openstack.
glance_image_create_prepoll_delay)
image_obj = utils.wait_for_status(
image_obj, ["active"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval
)
finally:
if "data" in kwargs:
kwargs["data"].close()
return image_obj
def create_volume(self,
size,
snapshot_id=None,
source_volid=None,
display_name=None,
display_description=None,
volume_type=None,
user_id=None,
project_id=None,
availability_zone=None,
metadata=None,
imageRef=None):
"""Creates a volume.
:param size: Size of volume in GB
:param snapshot_id: ID of the snapshot
:param display_name: Name of the volume
:param display_description: Description of the volume
:param volume_type: Type of volume
:param user_id: User id derived from context
:param project_id: Project id derived from context
:param availability_zone: Availability Zone to use
:param metadata: Optional metadata to set on volume creation
:param imageRef: reference to an image stored in glance
:returns: Return a new volume.
"""
kwargs = {
"display_name": display_name or self.generate_random_name(),
"display_description": display_description,
"snapshot_id": snapshot_id,
"source_volid": source_volid,
"volume_type": volume_type,
"user_id": user_id,
"project_id": project_id,
"availability_zone": availability_zone,
"metadata": metadata,
"imageRef": imageRef
}
if isinstance(size, dict):
size = random.randint(size["min"], size["max"])
volume = (self._get_client().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.
rutils.interruptable_sleep(
CONF.benchmark.cinder_volume_create_prepoll_delay)
return self._wait_available_volume(volume)
def run(self, sleep=0.1, from_iteration=0, to_iteration=0, each=1):
"""Raise errors in some iterations.
:param sleep: float iteration sleep time in seconds
:param from_iteration: int iteration number which starts range
of failed iterations
:param to_iteration: int iteration number which ends range of
failed iterations
:param each: int cyclic number of iteration which actually raises
an error in selected range. For example, each=3 will
raise error in each 3rd iteration.
"""
utils.interruptable_sleep(sleep)
if from_iteration <= self.context["iteration"] <= to_iteration:
if each and not self.context["iteration"] % each:
raise DummyScenarioException(_("Expected failure"))
def run(self, size_of_message=1, sleep=1, message=""):
"""Throw an exception.
Dummy.dummy_exception can be used for test if exceptions are processed
properly by ScenarioRunners and benchmark and analyze rally
results storing process.
:param size_of_message: int size of the exception message
:param sleep: idle time of method (in seconds).
:param message: message of the exception
:raises DummyScenarioException: raise exception for test
"""
utils.interruptable_sleep(sleep)
message = message or "M" * size_of_message
raise DummyScenarioException(message)
def run(self, sleep=0.1, from_iteration=0, to_iteration=0, each=1):
"""Raise errors in some iterations.
:param sleep: float iteration sleep time in seconds
:param from_iteration: int iteration number which starts range
of failed iterations
:param to_iteration: int iteration number which ends range of
failed iterations
:param each: int cyclic number of iteration which actually raises
an error in selected range. For example, each=3 will
raise error in each 3rd iteration.
"""
utils.interruptable_sleep(sleep)
if from_iteration <= self.context["iteration"] <= to_iteration:
if each and not self.context["iteration"] % each:
raise DummyScenarioException(_("Expected failure"))
def run(self, size_of_message=1, sleep=1, message=""):
"""Throws an exception.
Dummy.dummy_exception used for testing if exceptions are processed
properly by task engine and analyze rally results storing & displaying
capabilities.
:param size_of_message: int size of the exception message
:param sleep: idle time of method (in seconds).
:param message: message of the exception
:raises DummyScenarioException: raise exception for test
"""
utils.interruptable_sleep(sleep)
message = message or "M" * size_of_message
raise DummyScenarioException(message)
def run(self, size_of_message=1, sleep=1, message=""):
"""Throws an exception.
Dummy.dummy_exception used for testing if exceptions are processed
properly by task engine and analyze rally results storing & displaying
capabilities.
:param size_of_message: int size of the exception message
:param sleep: idle time of method (in seconds).
:param message: message of the exception
:raises DummyScenarioException: raise exception for test
"""
utils.interruptable_sleep(sleep)
message = message or "M" * size_of_message
raise DummyScenarioException(message)
def run(self, size_of_message=1, sleep=1, message=""):
"""Throw an exception.
Dummy.dummy_exception can be used for test if exceptions are processed
properly by ScenarioRunners and benchmark and analyze rally
results storing process.
:param size_of_message: int size of the exception message
:param sleep: idle time of method (in seconds).
:param message: message of the exception
:raises DummyScenarioException: raise exception for test
"""
utils.interruptable_sleep(sleep)
message = message or "M" * size_of_message
raise DummyScenarioException(message)
def create_image(self, container_format, image_location,
disk_format, **kwargs):
kw = {
"container_format": container_format,
"disk_format": disk_format,
}
kw.update(kwargs)
if "name" not in kw:
kw["name"] = self.owner.generate_random_name()
image_location = os.path.expanduser(image_location)
image = self.client.images.create(**kw)
rutils.interruptable_sleep(CONF.benchmark.
glance_image_create_prepoll_delay)
start = time.time()
image = utils.wait_for_status(
image, ["queued"],
update_resource=self.get_image,
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.
glance_image_create_poll_interval)
timeout = time.time() - start
image_data = None
response = None
try:
if os.path.isfile(image_location):
image_data = open(image_location)
else:
response = requests.get(image_location, stream=True)
image_data = response.raw
self.client.images.upload(image.id, image_data)
finally:
if image_data is not None:
image_data.close()
if response is not None:
response.close()
return utils.wait_for_status(
image, ["active"],
update_resource=self.get_image,
timeout=timeout,
check_interval=CONF.benchmark.
glance_image_create_poll_interval)
def create_image(self, image_name=None, container_format=None,
image_location=None, disk_format=None,
visibility=None, min_disk=0,
min_ram=0, properties=None):
"""Creates new image.
:param image_name: Image name for which need to be created
:param container_format: Container format
:param image_location: The new image's location
:param disk_format: Disk format
:param visibility: The created image's visible status.
:param min_disk: The min disk of created images
:param min_ram: The min ram of created images
:param properties: Dict of image properties
"""
image_name = image_name or self.generate_random_name()
properties = properties or {}
image_obj = self._clients.glance("2").images.create(
name=image_name,
container_format=container_format,
disk_format=disk_format,
visibility=visibility,
min_disk=min_disk,
min_ram=min_ram,
**properties)
rutils.interruptable_sleep(CONF.openstack.
glance_image_create_prepoll_delay)
start = time.time()
image_obj = utils.wait_for_status(
image_obj.id, ["queued"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval)
timeout = time.time() - start
self.upload_data(image_obj.id, image_location=image_location)
image_obj = utils.wait_for_status(
image_obj, ["active"],
update_resource=self.get_image,
timeout=timeout,
check_interval=CONF.openstack.glance_image_create_poll_interval)
return image_obj
def setup(self):
self.context["kubernetes"].update({
"namespace_choice_method": self.config["namespace_choice_method"],
"serviceaccounts": self.config.get("with_serviceaccount") or False,
"serviceaccount_delay": self.config.get("serviceaccount_delay") or 0
})
self.context["kubernetes"].setdefault("namespaces", [])
for _ in range(self.config.get("count")):
name = self.client.create_namespace(status_wait=False)
self.context["kubernetes"]["namespaces"].append(name)
if self.config.get("with_serviceaccount"):
self.client.create_serviceaccount(name, namespace=name)
self.client.create_secret(name, namespace=name)
commonutils.interruptable_sleep(
self.context["kubernetes"]["serviceaccount_delay"]
)
def setup(self):
new_metric = {}
if "dimensions" in self.config:
new_metric = {"dimensions": self.config["dimensions"]}
for user, tenant_id in self._iterate_per_tenants():
scenario = monasca_utils.MonascaScenario(
context={
"user": user,
"task": self.context["task"]
})
for i in range(self.config["metrics_per_tenant"]):
scenario._create_metrics(**new_metric)
rutils.interruptable_sleep(0.001)
rutils.interruptable_sleep(
monasca_utils.CONF.openstack.monasca_metric_create_prepoll_delay,
atomic_delay=1)
def create_volume(self, size, snapshot_id=None, source_volid=None,
display_name=None, display_description=None,
volume_type=None, user_id=None,
project_id=None, availability_zone=None,
metadata=None, imageRef=None):
"""Creates a volume.
:param size: Size of volume in GB
:param snapshot_id: ID of the snapshot
:param display_name: Name of the volume
:param display_description: Description of the volume
:param volume_type: Type of volume
:param user_id: User id derived from context
:param project_id: Project id derived from context
:param availability_zone: Availability Zone to use
:param metadata: Optional metadata to set on volume creation
:param imageRef: reference to an image stored in glance
:returns: Return a new volume.
"""
if isinstance(size, dict):
size = random.randint(size["min"], size["max"])
volume = self._get_client().volumes.create(
size,
display_name=(display_name or self.generate_random_name()),
display_description=display_description,
snapshot_id=snapshot_id,
source_volid=source_volid,
volume_type=volume_type,
user_id=user_id,
project_id=project_id,
availability_zone=availability_zone,
metadata=metadata,
imageRef=imageRef
)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the volume is ready => less API calls.
rutils.interruptable_sleep(
CONF.openstack.cinder_volume_create_prepoll_delay)
return self._wait_available_volume(volume)
def setup(self):
new_metric = {}
if "dimensions" in self.config:
new_metric = {
"dimensions": self.config["dimensions"]
}
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
scenario = monasca_utils.MonascaScenario(
context={"user": user, "task": self.context["task"]}
)
for i in moves.xrange(self.config["metrics_per_tenant"]):
scenario._create_metrics(**new_metric)
rutils.interruptable_sleep(0.001)
rutils.interruptable_sleep(
monasca_utils.CONF.benchmark.monasca_metric_create_prepoll_delay,
atomic_delay=1)
def _check_server_name(self, name, logging_vip, elasticsearch_port,
sleep_time, retries_total):
request_data = {
"query": {
"bool": {
"must": [{
"match_phrase": {
"Payload": name
}
}],
"should": [{
"range": {
"Timestamp": {
"gte": "now-2m",
"lte": "now"
}
}
}],
"minimum_should_match":
1
}
}
}
LOG.info("Check server name %s in elasticsearch" % name)
i = 0
while i < retries_total:
LOG.debug("Attempt number %s" % (i + 1))
resp = requests.get("http://%(ip)s:%(port)s/_search" % {
"ip": logging_vip,
"port": elasticsearch_port
},
data=json.dumps(request_data))
result = resp.json()
if result["hits"]["total"] < 1 and i + 1 >= retries_total:
LOG.debug("No instance data found in Elasticsearch")
self.assertGreater(result["hits"]["total"], 0)
elif result["hits"]["total"] < 1:
i += 1
commonutils.interruptable_sleep(sleep_time)
else:
LOG.debug("Instance data found in Elasticsearch")
self.assertGreater(result["hits"]["total"], 0)
break
def sleep_between(self, min_sleep, max_sleep, atomic_delay=0.1):
"""Call an interruptable_sleep() for a random amount of seconds.
The exact time is chosen uniformly randomly from the interval
[min_sleep; max_sleep). The method also updates the idle_duration
variable to take into account the overall time spent on sleeping.
:param min_sleep: Minimum sleep time in seconds (non-negative)
:param max_sleep: Maximum sleep time in seconds (non-negative)
:param atomic_delay: parameter with which time.sleep would be called
int(sleep_time / atomic_delay) times.
"""
if not 0 <= min_sleep <= max_sleep:
raise exceptions.InvalidArgumentsException(
"0 <= min_sleep <= max_sleep")
sleep_time = random.uniform(min_sleep, max_sleep)
utils.interruptable_sleep(sleep_time, atomic_delay)
self._idle_duration += sleep_time
def sleep_between(self, min_sleep, max_sleep, atomic_delay=0.1):
"""Call an interruptable_sleep() for a random amount of seconds.
The exact time is chosen uniformly randomly from the interval
[min_sleep; max_sleep). The method also updates the idle_duration
variable to take into account the overall time spent on sleeping.
:param min_sleep: Minimum sleep time in seconds (non-negative)
:param max_sleep: Maximum sleep time in seconds (non-negative)
:param atomic_delay: parameter with which time.sleep would be called
int(sleep_time / atomic_delay) times.
"""
if not 0 <= min_sleep <= max_sleep:
raise exceptions.InvalidArgumentsException(
"0 <= min_sleep <= max_sleep")
sleep_time = random.uniform(min_sleep, max_sleep)
utils.interruptable_sleep(sleep_time, atomic_delay)
self._idle_duration += sleep_time
def _create_v1pod(self, manifest):
"""Create a pod on the specify cluster.
:param manifest: manifest use to create the pod
"""
k8s_api = self._get_k8s_api_client()
podname = manifest["metadata"]["name"] + "-"
for i in range(5):
podname = podname + random.choice(string.ascii_lowercase)
manifest["metadata"]["name"] = podname
for i in range(150):
try:
k8s_api.create_namespaced_pod(body=manifest,
namespace="default")
break
except ApiException as e:
if e.status != 403:
raise
time.sleep(2)
start = time.time()
while True:
resp = k8s_api.read_namespaced_pod(
name=podname, namespace="default")
if resp.status.conditions:
for condition in resp.status.conditions:
if condition.type.lower() == "ready" and \
condition.status.lower() == "true":
return resp
if (time.time() - start > CONF.openstack.k8s_pod_create_timeout):
raise exceptions.TimeoutException(
desired_status="Ready",
resource_name=podname,
resource_type="Pod",
resource_id=resp.metadata.uid,
resource_status=resp.status,
timeout=CONF.openstack.k8s_pod_create_timeout)
common_utils.interruptable_sleep(
CONF.openstack.k8s_pod_create_poll_interval)
def _create_v1pod(self, manifest):
"""Create a pod on the specify cluster.
:param manifest: manifest use to create the pod
"""
k8s_api = self._get_k8s_api_client()
podname = manifest["metadata"]["name"] + "-"
for i in range(5):
podname = podname + random.choice(string.ascii_lowercase)
manifest["metadata"]["name"] = podname
for i in range(150):
try:
k8s_api.create_namespaced_pod(body=manifest,
namespace="default")
break
except ApiException as e:
if e.status != 403:
raise
time.sleep(2)
start = time.time()
while True:
resp = k8s_api.read_namespaced_pod(name=podname,
namespace="default")
if resp.status.conditions:
for condition in resp.status.conditions:
if condition.type.lower() == "ready" and \
condition.status.lower() == "true":
return resp
if (time.time() - start > CONF.openstack.k8s_pod_create_timeout):
raise exceptions.TimeoutException(
desired_status="Ready",
resource_name=podname,
resource_type="Pod",
resource_id=resp.metadata.uid,
resource_status=resp.status,
timeout=CONF.openstack.k8s_pod_create_timeout)
common_utils.interruptable_sleep(
CONF.openstack.k8s_pod_create_poll_interval)
def create_image(self, container_format, image_location,
disk_format, **kwargs):
kw = {
"container_format": container_format,
"disk_format": disk_format,
}
kw.update(kwargs)
if "name" not in kw:
kw["name"] = self.owner.generate_random_name()
if "visibility" in kw:
kw["is_public"] = kw.pop("visibility") == "public"
image_location = os.path.expanduser(image_location)
try:
if os.path.isfile(image_location):
kw["data"] = open(image_location)
else:
kw["copy_from"] = image_location
image = self.client.images.create(**kw)
rutils.interruptable_sleep(CONF.openstack.
glance_image_create_prepoll_delay)
image = utils.wait_for_status(
image, ["active"],
update_resource=self.get_image,
timeout=CONF.openstack.glance_image_create_timeout,
check_interval=CONF.openstack.
glance_image_create_poll_interval)
finally:
if "data" in kw:
kw["data"].close()
return image
def bar(self, sleep):
utils.interruptable_sleep(sleep)
