Initial support for tsbs_run_queries_redistimeseries (#89)

* [add] Initial support for tsbs_run_queries_redistimeseries

* Bumping version from 0.1.66 to 0.1.67

Author: filipecosta90

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redisbench-admin"
-version = "0.1.66"
+version = "0.1.67"
 description = "Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... )."
 authors = ["filipecosta90 <[email protected]>"]
 readme = "README.md"

redisbench_admin/run/common.py

@@ -10,6 +10,9 @@
 from redisbench_admin.run.redisgraph_benchmark_go.redisgraph_benchmark_go import (
     prepare_redisgraph_benchmark_go_command,
 )
+from redisbench_admin.run.tsbs_run_queries_redistimeseries.tsbs_run_queries_redistimeseries import (
+    prepare_tsbs_run_queries_redistimeseries_benchmark_command,
+)
 from redisbench_admin.run.ycsb.ycsb import prepare_ycsb_benchmark_command
 from redisbench_admin.utils.benchmark_config import (
     parse_exporter_metrics_definition,
@@ -112,6 +115,23 @@ def prepare_benchmark_parameters(
                     entry,
                     current_workdir,
                 )
+            if "tsbs_run_queries_redistimeseries" in benchmark_tool:
+                remote_queries_file = None
+                if isremote is True:
+                    benchmark_tool = "/tmp/tsbs_run_queries_redistimeseries"
+                    remote_queries_file = "/tmp/queries-file.input"
+                (
+                    command_arr,
+                    command_str,
+                ) = prepare_tsbs_run_queries_redistimeseries_benchmark_command(
+                    benchmark_tool,
+                    server_private_ip,
+                    server_plaintext_port,
+                    entry,
+                    current_workdir,
+                    remote_results_file,
+                    remote_queries_file,
+                )
     printed_command_str = command_str
     printed_command_arr = command_arr
     if len(command_str) > 200:

redisbench_admin/run/tsbs_run_queries_redistimeseries/__init__.py

@@ -0,0 +1,72 @@
+import csv
+import re
+
+from redisbench_admin.utils.local import check_if_needs_remote_fetch
+
+
+def prepare_tsbs_run_queries_redistimeseries_benchmark_command(
+    executable_path: str,
+    server_private_ip: object,
+    server_plaintext_port: object,
+    benchmark_config: object,
+    current_workdir,
+    result_file: str,
+    remote_queries_file,
+):
+    """
+    Prepares tsbs_run_queries_redistimeseries command parameters
+    :param executable_path:
+    :param server_private_ip:
+    :param server_plaintext_port:
+    :param benchmark_config:
+    :param current_workdir:
+    :return: [string] containing the required command to run the benchmark given the configurations
+    """
+    command_arr = [executable_path]
+
+    command_arr.extend(
+        ["--host", "{}:{}".format(server_private_ip, server_plaintext_port)]
+    )
+
+    for k in benchmark_config["parameters"]:
+        if "workers" in k:
+            command_arr.extend(["--workers", str(k["workers"])])
+        if "file" in k:
+            input_file = k["file"]
+            input_file = check_if_needs_remote_fetch(
+                input_file, "/tmp", None, remote_queries_file
+            )
+            command_arr.extend(["--file", input_file])
+
+    command_arr.extend(["--results-file", result_file])
+    command_arr.extend(["--print-interval", "1000"])
+
+    command_str = " ".join(command_arr)
+    return command_arr, command_str
+
+
+def post_process_ycsb_results(stdout, start_time_ms, start_time_str):
+    results_dict = {
+        "Tests": {},
+        "StartTime": start_time_ms,
+        "StartTimeHuman": start_time_str,
+    }
+    if type(stdout) == bytes:
+        stdout = stdout.decode("ascii")
+    csv_data = list(csv.reader(stdout.splitlines(), delimiter=","))
+    start_row = 0
+    for row in csv_data:
+        if len(row) >= 1:
+            if "[OVERALL]" in row[0]:
+                break
+        start_row = start_row + 1
+    for row in csv_data[start_row:]:
+        if len(row) >= 3:
+            op_group = row[0].strip()[1:-1]
+            metric_name = row[1].strip()
+            metric_name = re.sub("[^0-9a-zA-Z]+", "_", metric_name)
+            value = row[2].strip()
+            if op_group not in results_dict["Tests"]:
+                results_dict["Tests"][op_group] = {}
+            results_dict["Tests"][op_group][metric_name] = value
+    return results_dict

redisbench_admin/run/tsbs_run_queries_redistimeseries/tsbs_run_queries_redistimeseries.py

@@ -3,7 +3,7 @@ def create_run_local_arguments(parser):
     parser.add_argument(
         "--allowed-tools",
         type=str,
-        default="redis-benchmark,redisgraph-benchmark-go,ycsb",
+        default="redis-benchmark,redisgraph-benchmark-go,ycsb,tsbs_run_queries_redistimeseries",
         help="comma separated list of allowed tools for this module. By default all the supported are allowed.",
     )
     parser.add_argument(

redisbench_admin/run_local/args.py

@@ -13,7 +13,7 @@ def create_run_remote_arguments(parser):
     parser.add_argument(
         "--allowed-tools",
         type=str,
-        default="redis-benchmark,redisgraph-benchmark-go,ycsb",
+        default="redis-benchmark,redisgraph-benchmark-go,ycsb,tsbs_run_queries_redistimeseries",
         help="comma separated list of allowed tools for this module. By default all the supported are allowed.",
     )
     parser.add_argument(

redisbench_admin/run_remote/args.py

@@ -38,6 +38,7 @@
     check_and_fix_pem_str,
     get_run_full_filename,
     fetch_remote_setup_from_config,
+    execute_remote_commands,
 )
 
 # internal aux vars
@@ -64,6 +65,23 @@
 
 
 # noinspection PyBroadException
+def setup_remote_benchmark_tool_requirements_tsbs_run_queries_redistimeseries(
+    client_public_ip,
+    username,
+    private_key,
+    tool_link,
+    queries_file_link,
+    remote_tool_link="/tmp/tsbs_run_queries_redistimeseries",
+    remote_queries_file="/tmp/queries-file.input",
+):
+    commands = [
+        "wget {} -q -O {}".format(tool_link, remote_tool_link),
+        "wget {} -q -O {}".format(queries_file_link, remote_queries_file),
+        "chmod 755 {}".format(remote_tool_link),
+    ]
+    execute_remote_commands(client_public_ip, username, private_key, commands)
+
+
 def run_remote_command_logic(args):
     tf_bin_path = args.terraform_bin_path
     tf_github_org = args.github_org
@@ -345,6 +363,26 @@ def run_remote_command_logic(args):
                             private_key,
                             redisbenchmark_go_link,
                         )
+                    if benchmark_tool == "tsbs_run_queries_redistimeseries":
+                        tool_link = (
+                            "https://s3.amazonaws.com/benchmarks.redislabs/"
+                            + "redistimeseries/tools/tsbs/tsbs_run_queries_redistimeseries_linux_amd64"
+                        )
+
+                        queries_file_link = None
+                        for entry in benchmark_config["clientconfig"]:
+                            if "parameters" in entry:
+                                for parameter in entry["parameters"]:
+                                    if "file" in parameter:
+                                        queries_file_link = parameter["file"]
+
+                        setup_remote_benchmark_tool_requirements_tsbs_run_queries_redistimeseries(
+                            client_public_ip,
+                            username,
+                            private_key,
+                            tool_link,
+                            queries_file_link,
+                        )
 
                     if (
                         benchmark_min_tool_version is not None

redisbench_admin/run_remote/run_remote.py

@@ -23,34 +23,43 @@ def check_dataset_local_requirements(
             if "dataset" in k:
                 dataset = k["dataset"]
         if dataset is not None:
-            if dataset.startswith("http"):
-                if not os.path.isdir(datasets_localtemp_dir):
-                    os.mkdir(datasets_localtemp_dir)
-                filename = dataset.split("/")[-1]
-                full_path = "{}/{}".format(datasets_localtemp_dir, filename)
-                if not os.path.exists(full_path):
-                    logging.info(
-                        "Retrieving remote file from {} to {}. Using the dir {} as a cache for next time.".format(
-                            dataset, full_path, datasets_localtemp_dir
-                        )
-                    )
-                    wget.download(dataset, full_path)
-                else:
-                    logging.info(
-                        "Reusing cached remote file (located at {} ).".format(full_path)
-                    )
-            else:
-                full_path = dataset
-                if dirname is not None:
-                    full_path = "{}/{}".format(dirname, full_path)
-                logging.info(
-                    "Copying rdb from {} to {}/dump.rdb".format(full_path, redis_dbdir)
-                )
+            full_path = check_if_needs_remote_fetch(
+                dataset, datasets_localtemp_dir, dirname
+            )
             tmp_path = "{}/dump.rdb".format(redis_dbdir)
+            logging.info(
+                "Copying rdb from {} to {}/dump.rdb".format(full_path, redis_dbdir)
+            )
             copyfile(full_path, tmp_path)
     return dataset, full_path, tmp_path
 
 
+def check_if_needs_remote_fetch(property, localtemp_dir, dirname, full_path=None):
+    if property.startswith("http"):
+        if not os.path.isdir(localtemp_dir):
+            os.mkdir(localtemp_dir)
+        if full_path is None:
+            filename = property.split("/")[-1]
+            full_path = "{}/{}".format(localtemp_dir, filename)
+        if not os.path.exists(full_path):
+            logging.info(
+                "Retrieving remote file from {} to {}. Using the dir {} as a cache for next time.".format(
+                    property, full_path, localtemp_dir
+                )
+            )
+            wget.download(property, full_path)
+        else:
+            logging.info(
+                "Reusing cached remote file (located at {} ).".format(full_path)
+            )
+    else:
+        full_path = property
+        if dirname is not None:
+            full_path = "{}/{}".format(dirname, full_path)
+
+    return full_path
+
+
 def wait_for_conn(conn, retries=20, command="PING", should_be=True):
     """Wait until a given Redis connection is ready"""
     result = False

redisbench_admin/utils/local.py

@@ -0,0 +1,11 @@
+name: "tsbs-scale100-cpu-max-all-1"
+remote:
+  - type: oss-standalone
+  - setup: redistimeseries-m5
+dbconfig:
+  - dataset: "https://s3.amazonaws.com/benchmarks.redislabs/redistimeseries/tsbs/datasets/devops/scale100/devops-scale100-4days.rdb"
+clientconfig:
+  - tool: tsbs_run_queries_redistimeseries
+  - parameters:
+    - workers: 64
+    - file: "https://s3.amazonaws.com/benchmarks.redislabs/redistimeseries/tsbs/queries/devops/scale100/devops-scale100-4days/queries_cpu-only_redistimeseries_100_cpu-max-all-1_10000_123_2016-01-01T00%3A00%3A00Z_2016-01-04T00%3A00%3A00Z.dat"