import pkg_resources
import logging
import json
+import re
+import time
+import os
import yardstick.ssh as ssh
from yardstick.benchmark.scenarios import base
__scenario_type__ = "Cyclictest"
TARGET_SCRIPT = "cyclictest_benchmark.bash"
+ WORKSPACE = "/root/workspace/"
+ REBOOT_CMD_PATTERN = r";\s*reboot\b"
- def __init__(self, context):
- self.context = context
+ def __init__(self, scenario_cfg, context_cfg):
+ self.scenario_cfg = scenario_cfg
+ self.context_cfg = context_cfg
self.setup_done = False
+ def _put_files(self, client):
+ setup_options = self.scenario_cfg["setup_options"]
+ rpm_dir = setup_options["rpm_dir"]
+ script_dir = setup_options["script_dir"]
+ image_dir = setup_options["image_dir"]
+ LOG.debug("Send RPMs from %s to workspace %s" %
+ (rpm_dir, self.WORKSPACE))
+ client.put(rpm_dir, self.WORKSPACE, recursive=True)
+ LOG.debug("Send scripts from %s to workspace %s" %
+ (script_dir, self.WORKSPACE))
+ client.put(script_dir, self.WORKSPACE, recursive=True)
+ LOG.debug("Send guest image from %s to workspace %s" %
+ (image_dir, self.WORKSPACE))
+ client.put(image_dir, self.WORKSPACE, recursive=True)
+
+ def _connect_host(self):
+ host = self.context_cfg["host"]
+ user = host.get("user", "root")
+ ip = host.get("ip", None)
+ key_filename = host.get("key_filename", "~/.ssh/id_rsa")
+
+ LOG.debug("user:%s, host:%s", user, ip)
+ self.host = ssh.SSH(user, ip, key_filename=key_filename)
+ self.host.wait(timeout=600)
+
+ def _connect_guest(self):
+ host = self.context_cfg["host"]
+ user = host.get("user", "root")
+ ip = host.get("ip", None)
+ key_filename = host.get("key_filename", "~/.ssh/id_rsa")
+
+ LOG.debug("user:%s, host:%s", user, ip)
+ self.guest = ssh.SSH(user, ip, port=5555, key_filename=key_filename)
+ self.guest.wait(timeout=600)
+
+ def _run_setup_cmd(self, client, cmd):
+ LOG.debug("Run cmd: %s" % cmd)
+ status, stdout, stderr = client.execute(cmd)
+ if status:
+ if re.search(self.REBOOT_CMD_PATTERN, cmd):
+ LOG.debug("Error on reboot")
+ else:
+ raise RuntimeError(stderr)
+
+ def _run_host_setup_scripts(self, scripts):
+ setup_options = self.scenario_cfg["setup_options"]
+ script_dir = os.path.basename(setup_options["script_dir"])
+
+ for script in scripts:
+ cmd = "cd %s/%s; export PATH=./:$PATH; %s" %\
+ (self.WORKSPACE, script_dir, script)
+ self._run_setup_cmd(self.host, cmd)
+
+ if re.search(self.REBOOT_CMD_PATTERN, cmd):
+ time.sleep(3)
+ self._connect_host()
+
+ def _run_guest_setup_scripts(self, scripts):
+ setup_options = self.scenario_cfg["setup_options"]
+ script_dir = os.path.basename(setup_options["script_dir"])
+
+ for script in scripts:
+ cmd = "cd %s/%s; export PATH=./:$PATH; %s" %\
+ (self.WORKSPACE, script_dir, script)
+ self._run_setup_cmd(self.guest, cmd)
+
+ if re.search(self.REBOOT_CMD_PATTERN, cmd):
+ time.sleep(3)
+ self._connect_guest()
+
def setup(self):
'''scenario setup'''
- self.target_script = pkg_resources.resource_filename(
- "yardstick.benchmark.scenarios.compute",
- Cyclictest.TARGET_SCRIPT)
- user = self.context.get("user", "root")
- host = self.context.get("host", None)
- key_filename = self.context.get("key_filename", "~/.ssh/id_rsa")
+ setup_options = self.scenario_cfg["setup_options"]
+ host_setup_seqs = setup_options["host_setup_seqs"]
+ guest_setup_seqs = setup_options["guest_setup_seqs"]
+
+ self._connect_host()
+ self._put_files(self.host)
+ self._run_host_setup_scripts(host_setup_seqs)
- LOG.debug("user:%s, host:%s", user, host)
- print "key_filename:" + key_filename
- self.client = ssh.SSH(user, host, key_filename=key_filename)
- self.client.wait(timeout=600)
+ self._connect_guest()
+ self._put_files(self.guest)
+ self._run_guest_setup_scripts(guest_setup_seqs)
# copy script to host
- self.client.run("cat > ~/cyclictest_benchmark.sh",
- stdin=open(self.target_script, "rb"))
+ self.target_script = pkg_resources.resource_filename(
+ "yardstick.benchmark.scenarios.compute",
+ Cyclictest.TARGET_SCRIPT)
+ self.guest.run("cat > ~/cyclictest_benchmark.sh",
+ stdin=open(self.target_script, "rb"))
self.setup_done = True
- def run(self, args, result):
+ def run(self, result):
"""execute the benchmark"""
default_args = "-m -n -q"
if not self.setup_done:
self.setup()
- options = args["options"]
+ options = self.scenario_cfg["options"]
affinity = options.get("affinity", 1)
interval = options.get("interval", 1000)
priority = options.get("priority", 99)
cmd_args = "-a %s -i %s -p %s -l %s -t %s -h %s %s" \
% (affinity, interval, priority, loops,
threads, histogram, default_args)
- cmd = "sudo bash cyclictest_benchmark.sh %s" % (cmd_args)
+ cmd = "bash cyclictest_benchmark.sh %s" % (cmd_args)
LOG.debug("Executing command: %s", cmd)
- status, stdout, stderr = self.client.execute(cmd)
+ status, stdout, stderr = self.guest.execute(cmd)
if status:
raise RuntimeError(stderr)
result.update(json.loads(stdout))
- if "sla" in args:
+ if "sla" in self.scenario_cfg:
sla_error = ""
for t, latency in result.items():
- if 'max_%s_latency' % t not in args['sla']:
+ if 'max_%s_latency' % t not in self.scenario_cfg['sla']:
continue
- sla_latency = int(args['sla']['max_%s_latency' % t])
+ sla_latency = int(self.scenario_cfg['sla'][
+ 'max_%s_latency' % t])
latency = int(latency)
if latency > sla_latency:
sla_error += "%s latency %d > sla:max_%s_latency(%d); " % \
assert sla_error == "", sla_error
-def _test():
+def _test(): # pragma: no cover
'''internal test function'''
key_filename = pkg_resources.resource_filename("yardstick.resources",
"files/yardstick_key")
ctx = {
- "host": "192.168.50.28",
- "user": "root",
- "key_filename": key_filename
+ "host": {
+ "ip": "10.229.47.137",
+ "user": "root",
+ "key_filename": key_filename
+ }
}
logger = logging.getLogger("yardstick")
logger.setLevel(logging.DEBUG)
- cyclictest = Cyclictest(ctx)
-
options = {
"affinity": 2,
"interval": 100,
"options": options,
"sla": sla
}
+ result = {}
- result = cyclictest.run(args)
+ cyclictest = Cyclictest(args, ctx)
+ cyclictest.run(result)
print result
-if __name__ == '__main__':
+if __name__ == '__main__': # pragma: no cover
_test()
Code Review / yardstick.git / blobdiff