import multiprocessing
import subprocess
import time
-
-log = logging.getLogger(__name__)
+import traceback
from oslo_config import cfg
from yardstick.benchmark.scenarios import base as base_scenario
from yardstick.dispatcher.base import Base as DispatcherBase
+log = logging.getLogger(__name__)
+
CONF = cfg.CONF
# blocks until data becomes available
record = queue.get()
if record == '_TERMINATE_':
+ dispatcher.flush_result_data()
break
else:
dispatcher.record_result_data(record)
+def _execute_shell_command(command):
+ '''execute shell script with error handling'''
+ exitcode = 0
+ output = []
+ try:
+ output = subprocess.check_output(command, shell=True)
+ except Exception:
+ exitcode = -1
+ output = traceback.format_exc()
+ log.error("exec command '%s' error:\n " % command)
+ log.error(traceback.format_exc())
+
+ return exitcode, output
+
+
def _single_action(seconds, command, queue):
'''entrypoint for the single action process'''
log.debug("single action, fires after %d seconds (from now)", seconds)
time.sleep(seconds)
log.debug("single action: executing command: '%s'", command)
- data = subprocess.check_output(command, shell=True)
- log.debug("\n%s" % data)
+ ret_code, data = _execute_shell_command(command)
+ if ret_code < 0:
+ log.error("single action error! command:%s" % command)
+ queue.put({'single-action-data': data})
+ return
+ log.debug("single action data: \n%s" % data)
+ queue.put({'single-action-data': data})
def _periodic_action(interval, command, queue):
time.sleep(interval)
time_spent += interval
log.debug("periodic action, executing command: '%s'", command)
- data = subprocess.check_output(command, shell=True)
- log.debug("\n%s" % data)
+ ret_code, data = _execute_shell_command(command)
+ if ret_code < 0:
+ log.error("periodic action error! command:%s", command)
+ queue.put({'periodic-action-data': data})
+ break
+ log.debug("periodic action data: \n%s" % data)
+ queue.put({'periodic-action-data': data})
class Runner(object):
return Runner.get_cls(config["type"])(config, Runner.queue)
+ @staticmethod
+ def release_dump_process():
+ '''Release the dumper process'''
+ log.debug("Stopping dump process")
+ if Runner.dump_process:
+ Runner.queue.put('_TERMINATE_')
+ Runner.dump_process.join()
+ Runner.dump_process = None
+
@staticmethod
def release(runner):
'''Release the runner'''
- Runner.runners.remove(runner)
+ if runner in Runner.runners:
+ Runner.runners.remove(runner)
+
# if this was the last runner, stop the output serializer subprocess
if len(Runner.runners) == 0:
- log.debug("Stopping dump process")
- Runner.queue.put('_TERMINATE_')
- Runner.dump_process.join()
+ Runner.release_dump_process()
+
+ @staticmethod
+ def terminate(runner):
+ '''Terminate the runner'''
+ if runner.process and runner.process.is_alive():
+ runner.process.terminate()
@staticmethod
def terminate_all():
'''Terminate all runners (subprocesses)'''
log.debug("Terminating all runners")
+
+ # release dumper process as some errors before any runner is created
+ if len(Runner.runners) == 0:
+ Runner.release_dump_process()
+ return
+
for runner in Runner.runners:
+ log.debug("Terminating runner: %s", runner)
+ if runner.process:
+ runner.process.terminate()
+ runner.process.join()
if runner.periodic_action_process:
log.debug("Terminating periodic action process")
runner.periodic_action_process.terminate()
runner.periodic_action_process = None
- runner.process.terminate()
- runner.process.join()
Runner.release(runner)
def __init__(self, config, queue):
- self.context = {}
self.config = config
self.periodic_action_process = None
self.result_queue = queue
+ self.process = None
+ self.aborted = multiprocessing.Event()
Runner.runners.append(self)
- def run_pre_start_action(self):
- '''run a potentially configured pre-start action'''
- if "pre-start-action" in self.config:
- command = self.config["pre-start-action"]["command"]
- log.debug("pre start action: command: '%s'" % command)
- data = subprocess.check_output(command, shell=True)
- log.debug("pre-start data: \n%s" % data)
- output = "{'pre-start-action-data': %s}" % data
- self.result_queue.put(output)
-
def run_post_stop_action(self):
'''run a potentially configured post-stop action'''
if "post-stop-action" in self.config:
command = self.config["post-stop-action"]["command"]
log.debug("post stop action: command: '%s'" % command)
- data = subprocess.check_output(command, shell=True)
+ ret_code, data = _execute_shell_command(command)
+ if ret_code < 0:
+ log.error("post action error! command:%s", command)
+ self.result_queue.put({'post-stop-action-data': data})
+ return
log.debug("post-stop data: \n%s" % data)
- output = "{'post-stop-action-data': %s}" % data
- self.result_queue.put(output)
+ self.result_queue.put({'post-stop-action-data': data})
- def run(self, scenario_type, scenario_cfg):
+ def run(self, scenario_cfg, context_cfg):
+ scenario_type = scenario_cfg["type"]
class_name = base_scenario.Scenario.get(scenario_type)
path_split = class_name.split(".")
module_path = ".".join(path_split[:-1])
cls = getattr(module, path_split[-1])
self.config['object'] = class_name
+ self.aborted.clear()
- self.run_pre_start_action()
+ # run a potentially configured pre-start action
+ if "pre-start-action" in self.config:
+ command = self.config["pre-start-action"]["command"]
+ log.debug("pre start action: command: '%s'" % command)
+ ret_code, data = _execute_shell_command(command)
+ if ret_code < 0:
+ log.error("pre-start action error! command:%s", command)
+ self.result_queue.put({'pre-start-action-data': data})
+ return
+ log.debug("pre-start data: \n%s" % data)
+ self.result_queue.put({'pre-start-action-data': data})
if "single-shot-action" in self.config:
single_action_process = multiprocessing.Process(
self.result_queue))
self.periodic_action_process.start()
- self._run_benchmark(cls, "run", scenario_cfg)
+ self._run_benchmark(cls, "run", scenario_cfg, context_cfg)
- def join(self):
- self.process.join()
+ def abort(self):
+ '''Abort the execution of a scenario'''
+ self.aborted.set()
+
+ def join(self, timeout=None):
+ self.process.join(timeout)
if self.periodic_action_process:
self.periodic_action_process.terminate()
self.periodic_action_process = None
+
self.run_post_stop_action()
return self.process.exitcode