def stop(self):
"""
Stop the scenario from being maintained by stopping all the
loops that may be executing.
:return Deferred[Optional[Dict[unicode, Any]]]: Scenario metrics.
"""
self.is_started = False
if self.monitor_loop.running:
self.monitor_loop.stop()
if self.loop.running:
self.loop.stop()
outstanding_requests = self.rate_measurer.outstanding()
if outstanding_requests > 0:
msg = (
"There are {num_requests} outstanding requests. " "Waiting {num_seconds} seconds for them to complete."
).format(num_requests=outstanding_requests, num_seconds=self.timeout)
Message.log(key="outstanding_requests", value=msg)
with start_action(action_type=u"flocker:benchmark:scenario:stop", scenario="request_load"):
def no_outstanding_requests():
return self.rate_measurer.outstanding() == 0
scenario_stopped = loop_until(self.reactor, no_outstanding_requests, repeat(1))
timeout(self.reactor, scenario_stopped, self.timeout)
scenario = DeferredContext(scenario_stopped)
def handle_timeout(failure):
failure.trap(CancelledError)
msg = ("Force stopping the scenario. " "There are {num_requests} outstanding requests").format(
num_requests=outstanding_requests
)
Message.log(key="force_stop_request", value=msg)
scenario.addErrback(handle_timeout)
def scenario_cleanup(ignored):
"""
Calls the scenario cleanup, and wraps it inside an eliot
start action, so we can see the logs if something goes
wrong within the cleanup
:return Deferred: that will fire once the cleanup has been
completed
"""
with start_action(action_type=u"flocker:benchmark:scenario:cleanup", scenario="request_load"):
return self.request.run_cleanup()
scenario.addBoth(scenario_cleanup)
def return_metrics(_ignore):
return self.rate_measurer.get_metrics()
scenario.addCallback(return_metrics)
return scenario.addActionFinish()
def start(self):
"""
:return: A Deferred that fires when the desired scenario is
established (e.g. that a certain load is being applied).
"""
self.loop.start(interval=1)
def reached_target_rate():
return self.rate_measurer.rate() >= self.request_rate
def handle_timeout(failure):
failure.trap(CancelledError)
raise RequestRateNotReached
waiting_for_target_rate = loop_until(self.reactor,
reached_target_rate,
repeat(1))
timeout(self.reactor, waiting_for_target_rate, self.timeout)
waiting_for_target_rate.addErrback(handle_timeout)
# Start monitoring the scenario as soon as the target rate is reached.
def monitor_scenario_status(result):
self.monitor_loop.start(interval=1)
waiting_for_target_rate.addCallback(monitor_scenario_status)
return waiting_for_target_rate
def run_scenario(self, result):
"""
:return: A Deferred that fires when the desired scenario is
established (e.g. that a certain load is being applied).
:raise RequestRateNotReached: if the target rate could not be
reached.
"""
self.loop.start(interval=1)
def reached_target_rate():
return self.rate_measurer.rate() >= self.rate_tolerated
def handle_timeout(failure):
failure.trap(CancelledError)
raise RequestRateNotReached()
waiting_for_target_rate = loop_until(self.reactor,
reached_target_rate,
repeat(1))
timeout(self.reactor, waiting_for_target_rate, self.timeout)
waiting_for_target_rate.addErrback(handle_timeout)
# Start monitoring the scenario as soon as the target rate is reached.
def monitor_scenario_status(result):
self.monitor_loop.start(interval=1)
waiting_for_target_rate.addCallback(monitor_scenario_status)
return waiting_for_target_rate
def run_scenario(self, dataset):
"""
:param dataset `Dataset` we will use to run the write scenario
:return: A `Deferred` that fires when the desired scenario is
established (e.g. that a certain load is being applied).
"""
# The fist thing we need to do before actually running the scenario
# is to update the dataset_id, as we need the information to do the
# write requests to generate the load
self.dataset_id = dataset.dataset_id
self.loop.start(interval=1)
def reached_target_rate():
return self.rate_measurer.rate() >= self.request_rate
def handle_timeout(failure):
failure.trap(CancelledError)
raise WRequestRateNotReached
# Loop until we reach the expected rate, or we timeout
waiting_for_target_rate = loop_until(self.reactor,
reached_target_rate,
repeat(1))
timeout(self.reactor, waiting_for_target_rate, self.timeout)
waiting_for_target_rate.addErrback(handle_timeout)
# Start monitoring the scenario as soon as the target rate is reached.
def monitor_scenario_status(result):
self.monitor_loop.start(interval=1)
waiting_for_target_rate.addCallback(monitor_scenario_status)
return waiting_for_target_rate
def stop(self):
"""
Stop the scenario from being maintained by stopping all the
loops that may be executing.
:return Deferred[Optional[Dict[unicode, Any]]]: Scenario metrics.
"""
self.is_started = False
if self.monitor_loop.running:
self.monitor_loop.stop()
if self.loop.running:
self.loop.stop()
outstanding_requests = self.rate_measurer.outstanding()
if outstanding_requests > 0:
msg = (
"There are {num_requests} outstanding requests. "
"Waiting {num_seconds} seconds for them to complete."
).format(
num_requests=outstanding_requests,
num_seconds=self.timeout
)
Message.log(key='outstanding_requests', value=msg)
with start_action(
action_type=u'flocker:benchmark:scenario:stop',
scenario='request_load'
):
def no_outstanding_requests():
return self.rate_measurer.outstanding() == 0
scenario_stopped = loop_until(self.reactor,
no_outstanding_requests,
repeat(1))
timeout(self.reactor, scenario_stopped, self.timeout)
scenario = DeferredContext(scenario_stopped)
def handle_timeout(failure):
failure.trap(CancelledError)
msg = (
"Force stopping the scenario. "
"There are {num_requests} outstanding requests"
).format(
num_requests=outstanding_requests
)
Message.log(key='force_stop_request', value=msg)
scenario.addErrback(handle_timeout)
def return_metrics(_ignore):
return self.rate_measurer.get_metrics()
scenario.addCallback(return_metrics)
return scenario.addActionFinish()
def stop(self):
"""
Stop the scenario from being maintained by stopping all the
loops that may be executing.
:return: A ``Deferred`` that fires when the scenario has stopped.
"""
self.is_started = False
if self.monitor_loop.running:
self.monitor_loop.stop()
if self.loop.running:
self.loop.stop()
outstanding_requests = self.rate_measurer.outstanding()
if outstanding_requests > 0:
msg = (
"There are {num_requests} outstanding requests. "
"Waiting {num_seconds} seconds for them to complete."
).format(
num_requests=outstanding_requests,
num_seconds=self.timeout
)
Message.log(key='outstanding_requests', value=msg)
with start_action(
action_type=u'flocker:benchmark:scenario:stop',
scenario='request_load'
):
def handle_timeout(failure):
failure.trap(CancelledError)
msg = (
"Force stopping the scenario. "
"There are {num_requests} outstanding requests"
).format(
num_requests=outstanding_requests
)
Message.log(key='force_stop_request', value=msg)
def no_outstanding_requests():
return self.rate_measurer.outstanding() == 0
scenario_stopped = loop_until(self.reactor,
no_outstanding_requests,
repeat(1))
timeout(self.reactor, scenario_stopped, self.timeout)
scenario_stopped.addErrback(handle_timeout)
scenario = DeferredContext(scenario_stopped)
scenario.addActionFinish()
return scenario.result
def stop(self):
"""
Stop the scenario from being maintained by stopping all the
loops that may be executing.
:return: A Deferred that fires when the scenario has stopped.
"""
if self.monitor_loop.running:
self.monitor_loop.stop()
if self.loop.running:
self.loop.stop()
outstanding_requests = self.rate_measurer.outstanding()
if outstanding_requests > 0:
msg = (
"There are {num_requests} outstanding requests. "
"Waiting {num_seconds} seconds for them to complete."
).format(
num_requests=outstanding_requests,
num_seconds=self.timeout
)
Message.log(key='outstanding_requests', value=msg)
with start_action(
action_type=u'flocker:benchmark:scenario:stop',
scenario='write_request_load'
):
def handle_timeout(failure):
failure.trap(CancelledError)
msg = (
"Force stopping the scenario. "
"There are {num_requests} outstanding requests"
).format(
num_requests=outstanding_requests
)
Message.log(key='force_stop_request', value=msg)
def no_outstanding_requests():
return self.rate_measurer.outstanding() == 0
scenario_stopped = loop_until(self.reactor,
no_outstanding_requests,
repeat(1))
timeout(self.reactor, scenario_stopped, self.timeout)
scenario_stopped.addErrback(handle_timeout)
scenario = DeferredContext(scenario_stopped)
scenario.addActionFinish()
return scenario.result
def _create_dataset(self, node):
"""
Creates a dataset in the node given.
:param node: node where we want the dataset.
:return: A ``Deferred`` that fires when the dataset has been created.
:raise DatasetCreationTimeout: if the creation goes wrong.
"""
self.dataset_node = node
creating = self.control_service.create_dataset(primary=node.uuid)
def handle_timeout_and_errors(failure):
failure.trap(CancelledError)
raise DatasetCreationTimeout()
timeout(self.reactor, creating, self.timeout)
creating.addErrback(handle_timeout_and_errors)
return creating
def _create_dataset(self, node):
"""
Creates a dataset in the node given.
:param node: node where we want the dataset.
:return: A ``Deferred`` that fires when the dataset has been created.
:raise DatasetCreationTimeout: if the creation goes wrong.
"""
self.dataset_node = node
creating = self.control_service.create_dataset(primary=node.uuid)
def handle_timeout_and_errors(failure):
failure.trap(CancelledError)
raise DatasetCreationTimeout()
timeout(self.reactor, creating, self.timeout)
creating.addErrback(handle_timeout_and_errors)
return creating
def _create_dataset(self, node):
"""
Creates a dataset in the node given.
:param node: node where we want the dataset.
:return: A Deferred that fires when the dataset has been created.
:raises: `DatasetCreationTimeout` if the creation goes wrong.
"""
self.dataset_node = node
creating = self.control_service.create_dataset(
primary=node.uuid)
# Not sure about handling errors and timeout in the same errback.
# How could I handle them differently?
def handle_timeout_and_errors(failure):
failure.trap(CancelledError)
raise DatasetCreationTimeout()
timeout(self.reactor, creating, self.timeout)
creating.addErrback(handle_timeout_and_errors)
return creating
def stop(self):
"""
Stop the scenario from being maintained by stopping all the
loops that may be executing.
:return Deferred[Optional[Dict[unicode, Any]]]: Scenario metrics.
"""
self.is_started = False
if self.monitor_loop.running:
self.monitor_loop.stop()
if self.loop.running:
self.loop.stop()
outstanding_requests = self.rate_measurer.outstanding()
if outstanding_requests > 0:
msg = (
"There are {num_requests} outstanding requests. "
"Waiting {num_seconds} seconds for them to complete."
).format(
num_requests=outstanding_requests,
num_seconds=self.timeout
)
Message.log(key='outstanding_requests', value=msg)
with start_action(
action_type=u'flocker:benchmark:scenario:stop',
scenario='request_load'
):
def no_outstanding_requests():
return self.rate_measurer.outstanding() == 0
scenario_stopped = loop_until(self.reactor,
no_outstanding_requests,
repeat(1))
timeout(self.reactor, scenario_stopped, self.timeout)
scenario = DeferredContext(scenario_stopped)
def handle_timeout(failure):
failure.trap(CancelledError)
msg = (
"Force stopping the scenario. "
"There are {num_requests} outstanding requests"
).format(
num_requests=outstanding_requests
)
Message.log(key='force_stop_request', value=msg)
scenario.addErrback(handle_timeout)
def scenario_cleanup(ignored):
"""
Calls the scenario cleanup, and wraps it inside an eliot
start action, so we can see the logs if something goes
wrong within the cleanup
:return Deferred: that will fire once the cleanup has been
completed
"""
with start_action(
action_type=u'flocker:benchmark:scenario:cleanup',
scenario='request_load'
):
return self.request.run_cleanup()
scenario.addBoth(scenario_cleanup)
def return_metrics(_ignore):
return self.rate_measurer.get_metrics()
scenario.addCallback(return_metrics)
return scenario.addActionFinish()