redisbench-admin 0.10.20__tar.gz → 0.10.22__tar.gz

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.10.20
+Version: 0.10.22
 Summary: Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... ).
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redisbench-admin"
-version = "0.10.20"
+version = "0.10.22"
 description = "Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... )."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "README.md"

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/compare/compare.py

@@ -722,7 +722,7 @@ def from_rts_to_regression_table(
     total_comparison_points = 0
     noise_waterline = 3
     progress = tqdm(unit="benchmark time-series", total=len(test_names))
-    at_comparison=0
+    at_comparison = 0
     for test_name in test_names:
         multi_value_baseline = check_multi_value_filter(baseline_str)
         multi_value_comparison = check_multi_value_filter(comparison_str)

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/run/args.py

@@ -40,9 +40,10 @@ COMMANDSTATS_ENABLED = bool(int(os.getenv("COMMANDSTATS_ENABLED", 1)))
 PROFILERS = os.getenv("PROFILERS", PROFILERS_DEFAULT)
 MAX_PROFILERS_PER_TYPE = int(os.getenv("MAX_PROFILERS", 1))
 PROFILE_FREQ = os.getenv("PROFILE_FREQ", PROFILE_FREQ_DEFAULT)
-KEEP_ENV = bool(os.getenv("KEEP_ENV", False))
+KEEP_ENV = bool(int(os.getenv("KEEP_ENV", "0")))
 ALLOWED_TOOLS_DEFAULT = "memtier_benchmark,redis-benchmark,redisgraph-benchmark-go,ycsb,go-ycsb,tsbs_run_queries_redistimeseries,tsbs_load_redistimeseries,ftsb_redisearch,aibench_run_inference_redisai_vision,ann-benchmarks"
 ALLOWED_BENCH_TOOLS = os.getenv("ALLOWED_BENCH_TOOLS", ALLOWED_TOOLS_DEFAULT)
+SKIP_DB_SETUP = bool(int(os.getenv("SKIP_DB_SETUP", "0")))
 
 
 def common_run_args(parser):
@@ -53,6 +54,12 @@ def common_run_args(parser):
         action="store_true",
         help="Keep environment and topology up after benchmark.",
     )
+    parser.add_argument(
+        "--skip-db-setup",
+        type=bool,
+        default=SKIP_DB_SETUP,
+        help="skip db setup/teardown steps. Usefull when you want to target an existing DB",
+    )
     parser.add_argument(
         "--fail_fast",
         required=False,

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/run_local/args.py

@@ -3,13 +3,22 @@
 #  Copyright (c) 2021., Redis Labs Modules
 #  All rights reserved.
 #
+import os
 
 from redisbench_admin.run.args import common_run_args
 from redisbench_admin.run.common import REDIS_BINARY
 
+FLUSHALL_AT_START = bool(int(os.getenv("FLUSHALL_AT_START", "0")))
+
 
 def create_run_local_arguments(parser):
     parser = common_run_args(parser)
     parser.add_argument("--port", type=int, default=6379)
     parser.add_argument("--redis-binary", type=str, default=REDIS_BINARY)
+    parser.add_argument(
+        "--flushall_on_every_test_start",
+        type=bool,
+        default=FLUSHALL_AT_START,
+        help="At the start of every test send a FLUSHALL",
+    )
     return parser

redisbench_admin-0.10.22/redisbench_admin/run_local/local_db.py

@@ -0,0 +1,216 @@
+#  BSD 3-Clause License
+#
+#  Copyright (c) 2021., Redis Labs Modules
+#  All rights reserved.
+#
+import logging
+import tempfile
+import datetime
+
+import redis
+
+from redisbench_admin.run.run import calculate_client_tool_duration_and_check
+from redisbench_admin.run_local.local_helpers import (
+    check_benchmark_binaries_local_requirements,
+    run_local_benchmark,
+)
+
+from redisbench_admin.environments.oss_cluster import (
+    spin_up_local_redis_cluster,
+    setup_redis_cluster_from_conns,
+)
+from redisbench_admin.environments.oss_standalone import spin_up_local_redis
+from redisbench_admin.run.cluster import cluster_init_steps
+from redisbench_admin.run.common import (
+    run_redis_pre_steps,
+    check_dbconfig_tool_requirement,
+    prepare_benchmark_parameters,
+    dbconfig_keyspacelen_check,
+)
+from redisbench_admin.utils.benchmark_config import extract_redis_dbconfig_parameters
+from redisbench_admin.utils.local import (
+    check_dataset_local_requirements,
+    is_process_alive,
+)
+
+
+def local_db_spin(
+    binary,
+    args,
+    benchmark_config,
+    clusterconfig,
+    dbdir_folder,
+    dirname,
+    local_module_file,
+    redis_processes,
+    required_modules,
+    setup_type,
+    shard_count,
+    flushall_on_every_test_start=False,
+):
+    redis_conns = []
+    artifact_version = "n/a"
+    result = True
+    temporary_dir = tempfile.mkdtemp()
+    cluster_api_enabled = False
+    if setup_type == "oss-cluster":
+        cluster_api_enabled = True
+    dataset, dataset_name, _, _ = check_dataset_local_requirements(
+        benchmark_config,
+        temporary_dir,
+        dirname,
+        "./datasets",
+        "dbconfig",
+        shard_count,
+        cluster_api_enabled,
+    )
+
+    if args.skip_db_setup:
+        logging.info("Skipping DB Setup...")
+        if dataset is not None:
+            logging.info("Given this benchmark requires an RDB load will skip it...")
+            result = False
+            return (
+                result,
+                artifact_version,
+                cluster_api_enabled,
+                redis_conns,
+                redis_processes,
+            )
+    else:
+        # setup Redis
+        # copy the rdb to DB machine
+        redis_7 = args.redis_7
+        logging.info(
+            "Using local temporary dir to spin up Redis Instance. Path: {}".format(
+                temporary_dir
+            )
+        )
+        if dbdir_folder is not None:
+            from distutils.dir_util import copy_tree
+
+            copy_tree(dbdir_folder, temporary_dir)
+            logging.info(
+                "Copied entire content of {} into temporary path: {}".format(
+                    dbdir_folder, temporary_dir
+                )
+            )
+        (
+            _,
+            _,
+            redis_configuration_parameters,
+            dataset_load_timeout_secs,
+            modules_configuration_parameters_map,
+        ) = extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
+
+        logging.info(
+            "Using a dataset load timeout of {} seconds.".format(
+                dataset_load_timeout_secs
+            )
+        )
+
+        if setup_type == "oss-cluster":
+            cluster_api_enabled = True
+            shard_host = "127.0.0.1"
+            redis_processes, redis_conns = spin_up_local_redis_cluster(
+                binary,
+                temporary_dir,
+                shard_count,
+                shard_host,
+                args.port,
+                local_module_file,
+                redis_configuration_parameters,
+                dataset_load_timeout_secs,
+                modules_configuration_parameters_map,
+                redis_7,
+            )
+
+            status = setup_redis_cluster_from_conns(
+                redis_conns, shard_count, shard_host, args.port
+            )
+            if status is False:
+                raise Exception("Redis cluster setup failed. Failing test.")
+
+        if setup_type == "oss-standalone":
+            redis_processes = spin_up_local_redis(
+                binary,
+                args.port,
+                temporary_dir,
+                local_module_file,
+                redis_configuration_parameters,
+                dbdir_folder,
+                dataset_load_timeout_secs,
+                modules_configuration_parameters_map,
+                redis_7,
+            )
+        if setup_type == "oss-cluster":
+            for shardn, redis_process in enumerate(redis_processes):
+                logging.info(
+                    "Checking if shard #{} process with pid={} is alive".format(
+                        shardn + 1, redis_process.pid
+                    )
+                )
+                if is_process_alive(redis_process) is False:
+                    raise Exception("Redis process is not alive. Failing test.")
+            cluster_init_steps(clusterconfig, redis_conns, local_module_file)
+
+    if setup_type == "oss-standalone":
+        r = redis.Redis(port=args.port)
+        r.ping()
+        r.client_setname("redisbench-admin-standalone")
+        redis_conns.append(r)
+
+    if dataset is None:
+        if flushall_on_every_test_start:
+            logging.info("Will flush all data at test start...")
+            for shard_n, shard_conn in enumerate(redis_conns):
+                logging.info(f"Flushing all in shard {shard_n}...")
+                shard_conn.flushall()
+
+    if check_dbconfig_tool_requirement(benchmark_config):
+        logging.info("Detected the requirements to load data via client tool")
+        local_benchmark_output_filename = "{}/load-data.txt".format(temporary_dir)
+        (
+            benchmark_tool,
+            full_benchmark_path,
+            benchmark_tool_workdir,
+        ) = check_benchmark_binaries_local_requirements(
+            benchmark_config, args.allowed_tools, "./binaries", "dbconfig"
+        )
+
+        # prepare the benchmark command
+        command, command_str = prepare_benchmark_parameters(
+            benchmark_config,
+            full_benchmark_path,
+            args.port,
+            "localhost",
+            local_benchmark_output_filename,
+            False,
+            benchmark_tool_workdir,
+            cluster_api_enabled,
+            "dbconfig",
+        )
+
+        # run the benchmark
+        load_via_benchmark_start_time = datetime.datetime.now()
+        run_local_benchmark(benchmark_tool, command)
+        load_via_benchmark_end_time = datetime.datetime.now()
+        load_via_benchmark_duration_seconds = calculate_client_tool_duration_and_check(
+            load_via_benchmark_end_time, load_via_benchmark_start_time
+        )
+        logging.info(
+            "Loading data via benchmark tool took {} secs.".format(
+                load_via_benchmark_duration_seconds
+            )
+        )
+
+    dbconfig_keyspacelen_check(
+        benchmark_config,
+        redis_conns,
+    )
+
+    artifact_version = run_redis_pre_steps(
+        benchmark_config, redis_conns[0], required_modules
+    )
+
+    return result, artifact_version, cluster_api_enabled, redis_conns, redis_processes

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/run_local/run_local.py

@@ -11,6 +11,7 @@ import sys
 import datetime
 import traceback
 import redis
+from redisbench_admin.run.git import git_vars_crosscheck
 
 import redisbench_admin.run.metrics
 from redisbench_admin.profilers.perf import PERF_CALLGRAPH_MODE
@@ -30,7 +31,10 @@ from redisbench_admin.run.metrics import (
     from_info_to_overall_shard_cpu,
     collect_cpu_data,
 )
-from redisbench_admin.run.redistimeseries import datasink_profile_tabular_data
+from redisbench_admin.run.redistimeseries import (
+    datasink_profile_tabular_data,
+    timeseries_test_sucess_flow,
+)
 from redisbench_admin.run.run import (
     calculate_client_tool_duration_and_check,
     define_benchmark_plan,
@@ -49,6 +53,7 @@ from redisbench_admin.profilers.profilers_local import (
 from redisbench_admin.utils.benchmark_config import (
     prepare_benchmark_definitions,
     results_dict_kpi_check,
+    get_metadata_tags,
 )
 from redisbench_admin.utils.local import (
     get_local_run_full_filename,
@@ -67,20 +72,28 @@ def run_local_command_logic(args, project_name, project_version):
             project_name=project_name, project_version=project_version
         )
     )
+    tf_github_org = args.github_org
+    tf_github_actor = args.github_actor
+    tf_github_repo = args.github_repo
+    tf_github_sha = args.github_sha
+    tf_github_branch = args.github_branch
+
     (
+        github_actor,
+        github_branch,
         github_org_name,
         github_repo_name,
         github_sha,
-        github_actor,
-        github_branch,
-        github_branch_detached,
-    ) = extract_git_vars()
+    ) = git_vars_crosscheck(
+        tf_github_actor, tf_github_branch, tf_github_org, tf_github_repo, tf_github_sha
+    )
 
     dbdir_folder = args.dbdir_folder
     os.path.abspath(".")
     required_modules = args.required_module
     profilers_enabled = args.enable_profilers
     s3_bucket_name = args.s3_bucket_name
+    flushall_on_every_test_start = args.flushall_on_every_test_start
     profilers_list = []
     if profilers_enabled:
         profilers_list = args.profilers.split(",")
@@ -125,7 +138,7 @@ def run_local_command_logic(args, project_name, project_version):
         _,
         benchmark_definitions,
         default_metrics,
-        _,
+        exporter_timemetric_path,
         default_specs,
         clusterconfig,
     ) = prepare_benchmark_definitions(args)
@@ -189,6 +202,8 @@ def run_local_command_logic(args, project_name, project_version):
                                     if " " in binary:
                                         binary = binary.split(" ")
                                     (
+                                        result_db_spin,
+                                        artifact_version,
                                         cluster_api_enabled,
                                         redis_conns,
                                         redis_processes,
@@ -204,7 +219,13 @@ def run_local_command_logic(args, project_name, project_version):
                                         required_modules,
                                         setup_type,
                                         shard_count,
+                                        flushall_on_every_test_start,
                                     )
+                                    if result_db_spin is False:
+                                        logging.warning(
+                                            "Skipping this test given DB spin stage failed..."
+                                        )
+                                        continue
                                     if benchmark_type == "read-only":
                                         logging.info(
                                             "Given the benchmark for this setup is ready-only we will prepare to reuse it on the next read-only benchmarks (if any )."
@@ -352,6 +373,7 @@ def run_local_command_logic(args, project_name, project_version):
                                     s3_bucket_name,
                                     test_name,
                                 )
+
                                 if (
                                     profilers_enabled
                                     and args.push_results_redistimeseries
@@ -377,7 +399,7 @@ def run_local_command_logic(args, project_name, project_version):
                                     start_time_str,
                                     stdout,
                                 )
-
+                                results_dict = {}
                                 with open(
                                     local_benchmark_output_filename, "r"
                                 ) as json_file:
@@ -395,6 +417,31 @@ def run_local_command_logic(args, project_name, project_version):
                                     return_code = results_dict_kpi_check(
                                         benchmark_config, results_dict, return_code
                                     )
+
+                                metadata_tags = get_metadata_tags(benchmark_config)
+                                (
+                                    _,
+                                    branch_target_tables,
+                                ) = timeseries_test_sucess_flow(
+                                    args.push_results_redistimeseries,
+                                    artifact_version,
+                                    benchmark_config,
+                                    benchmark_duration_seconds,
+                                    0,
+                                    default_metrics,
+                                    setup_name,
+                                    setup_type,
+                                    exporter_timemetric_path,
+                                    results_dict,
+                                    rts,
+                                    start_time_ms,
+                                    test_name,
+                                    github_branch,
+                                    github_org_name,
+                                    github_repo_name,
+                                    tf_triggering_env,
+                                )
+
                                 if setup_details["env"] is None:
                                     if args.keep_env_and_topo is False:
                                         for conn in redis_conns:

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/run_remote/args.py

@@ -21,7 +21,6 @@ TF_OVERRIDE_NAME = os.getenv("TF_OVERRIDE_NAME", None)
 REMOTE_DB_PORT = int(os.getenv("REMOTE_DB_PORT", "6379"))
 REMOTE_DB_PASS = os.getenv("REMOTE_DB_PASS", None)
 REMOTE_PRIVATE_KEYNAME = os.getenv("REMOTE_PRIVATE_KEYNAME", DEFAULT_PRIVATE_KEY)
-REMOTE_SKIP_DB_SETUP = bool(int(os.getenv("REMOTE_SKIP_DB_SETUP", "0")))
 FLUSHALL_AT_START = bool(int(os.getenv("FLUSHALL_AT_START", "0")))
 FLUSHALL_AT_END = bool(int(os.getenv("FLUSHALL_AT_END", "0")))
 IGNORE_KEYSPACE_ERRORS = bool(int(os.getenv("IGNORE_KEYSPACE_ERRORS", "0")))
@@ -60,12 +59,6 @@ def create_run_remote_arguments(parser):
     )
     parser.add_argument("--db_port", type=int, default=REMOTE_DB_PORT)
     parser.add_argument("--db_pass", type=str, default=REMOTE_DB_PASS)
-    parser.add_argument(
-        "--skip-db-setup",
-        type=bool,
-        default=REMOTE_SKIP_DB_SETUP,
-        help="skip db setup/teardown steps. Usefull when you want to target an existing DB",
-    )
     parser.add_argument(
         "--flushall_on_every_test_start",
         type=bool,

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/redisbench_admin/utils/remote.py

@@ -30,7 +30,7 @@ from redisbench_admin.utils.utils import (
 )
 
 # environment variables
-PERFORMANCE_RTS_PUSH = bool(os.getenv("PUSH_RTS", False))
+PERFORMANCE_RTS_PUSH = bool(int(os.getenv("PUSH_RTS", "0")))
 PERFORMANCE_RTS_AUTH = os.getenv("PERFORMANCE_RTS_AUTH", None)
 PERFORMANCE_RTS_USER = os.getenv("PERFORMANCE_RTS_USER", None)
 PERFORMANCE_RTS_HOST = os.getenv("PERFORMANCE_RTS_HOST", "localhost")
@@ -51,7 +51,7 @@ def get_git_root(path):
 
 def view_bar_simple(a, b):
     res = a / int(b) * 100
-    sys.stdout.write("\r    Complete precent: %.2f %%" % res)
+    sys.stdout.write("\r    Complete percent: %.2f %%" % res)
     sys.stdout.flush()
 
 

{redisbench_admin-0.10.20 → redisbench_admin-0.10.22}/setup.py

@@ -82,7 +82,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'redisbench-admin',
-    'version': '0.10.20',
+    'version': '0.10.22',
     'description': 'Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... ).',
     'long_description': '[![codecov](https://codecov.io/gh/redis-performance/redisbench-admin/branch/master/graph/badge.svg)](https://codecov.io/gh/redis-performance/redisbench-admin)\n![Actions](https://github.com/redis-performance/redisbench-admin/workflows/Run%20Tests/badge.svg?branch=master)\n![Actions](https://badge.fury.io/py/redisbench-admin.svg)\n\n# [redisbench-admin](https://github.com/redis-performance/redisbench-admin)\n\nRedis benchmark run helper can help you with the following tasks:\n\n- Setup abd teardown of benchmarking infrastructure specified\n  on [redis-performance/testing-infrastructure](https://github.com/redis-performance/testing-infrastructure)\n- Setup and teardown of an Redis and Redis Modules DBs for benchmarking\n- Management of benchmark data and specifications across different setups\n- Running benchmarks and recording results\n- Exporting performance results in several formats (CSV, RedisTimeSeries, JSON)\n- Finding on-cpu, off-cpu, io, and threading performance problems by attaching profiling tools/probers ( perf (a.k.a. perf_events), bpf tooling, vtune )\n- **[SOON]** Finding performance problems by attaching telemetry probes\n\nCurrent supported benchmark tools:\n\n- [redis-benchmark](https://github.com/redis/redis)\n- [memtier_benchmark](https://github.com/RedisLabs/memtier_benchmark)\n- [redis-benchmark-go](https://github.com/redis-performance/redis-benchmark-go)\n- [YCSB](https://github.com/RediSearch/YCSB)\n- [tsbs](https://github.com/RedisTimeSeries/tsbs)\n- [redisgraph-benchmark-go](https://github.com/RedisGraph/redisgraph-benchmark-go)\n- [ftsb_redisearch](https://github.com/RediSearch/ftsb)\n- [ann-benchmarks](https://github.com/RedisAI/ann-benchmarks)\n\n## Installation\n\nInstallation is done using pip, the package installer for Python, in the following manner:\n\n```bash\npython3 -m pip install redisbench-admin\n```\n\n## Profiler daemon\n\nYou can use the profiler daemon by itself in the following manner. \nOn the target machine do as follow:\n\n```bash\npip3 install --upgrade pip\npip3 install redisbench-admin --ignore-installed PyYAML\n\n# install perf\napt install linux-tools-common linux-tools-generic linux-tools-`uname -r` -y\n\n# ensure perf is working\nperf --version\n\n# install awscli\nsnap install aws-cli --classic\n\n\n# configure aws\naws configure\n\n# start the perf-daemon\nperf-daemon start\nWARNING:root:Unable to detected github_actor. caught the following error: No section: \'user\'\nWritting log to /tmp/perf-daemon.log\nStarting perf-daemon. PID file /tmp/perfdaemon.pid. Daemon workdir: /root/RedisGraph\n\n# check daemon is working appropriatelly\ncurl localhost:5000/ping\n\n# start a profile\ncurl -X POST localhost:5000/profiler/perf/start/<pid to profile>\n\n# stop a profile\ncurl -X POST -d \'{"aws_access_key_id":$AWS_ACCESS_KEY_ID,"aws_secret_access_key":$AWS_SECRET_ACCESS_KEY}\' localhost:5000/profiler/perf/stop/<pid to profile>\n```\n\n\n## Development\n\n1. Install [pypoetry](https://python-poetry.org/) to manage your dependencies and trigger tooling.\n```sh\npip install poetry\n```\n\n2. Installing dependencies from lock file\n\n```\npoetry install\n```\n\n### Running formaters\n\n```sh\npoetry run black .\n```\n\n\n### Running linters\n\n```sh\npoetry run flake8\n```\n\n\n### Running tests\n\nA test suite is provided, and can be run with:\n\n```sh\n$ tox\n```\n\nTo run a specific test:\n```sh\n$ tox -- tests/test_redistimeseries.py\n```\n\n## License\n\nredisbench-admin is distributed under the BSD3 license - see [LICENSE](LICENSE)\n',
     'author': 'filipecosta90',

redisbench_admin-0.10.20/redisbench_admin/run_local/local_db.py

@@ -1,185 +0,0 @@
-#  BSD 3-Clause License
-#
-#  Copyright (c) 2021., Redis Labs Modules
-#  All rights reserved.
-#
-import logging
-import tempfile
-import datetime
-
-import redis
-
-from redisbench_admin.run.run import calculate_client_tool_duration_and_check
-from redisbench_admin.run_local.local_helpers import (
-    check_benchmark_binaries_local_requirements,
-    run_local_benchmark,
-)
-
-from redisbench_admin.environments.oss_cluster import (
-    spin_up_local_redis_cluster,
-    setup_redis_cluster_from_conns,
-)
-from redisbench_admin.environments.oss_standalone import spin_up_local_redis
-from redisbench_admin.run.cluster import cluster_init_steps
-from redisbench_admin.run.common import (
-    run_redis_pre_steps,
-    check_dbconfig_tool_requirement,
-    prepare_benchmark_parameters,
-    dbconfig_keyspacelen_check,
-)
-from redisbench_admin.utils.benchmark_config import extract_redis_dbconfig_parameters
-from redisbench_admin.utils.local import (
-    check_dataset_local_requirements,
-    is_process_alive,
-)
-
-
-def local_db_spin(
-    binary,
-    args,
-    benchmark_config,
-    clusterconfig,
-    dbdir_folder,
-    dirname,
-    local_module_file,
-    redis_processes,
-    required_modules,
-    setup_type,
-    shard_count,
-):
-    # setup Redis
-    # copy the rdb to DB machine
-    temporary_dir = tempfile.mkdtemp()
-    redis_7 = args.redis_7
-    logging.info(
-        "Using local temporary dir to spin up Redis Instance. Path: {}".format(
-            temporary_dir
-        )
-    )
-    if dbdir_folder is not None:
-        from distutils.dir_util import copy_tree
-
-        copy_tree(dbdir_folder, temporary_dir)
-        logging.info(
-            "Copied entire content of {} into temporary path: {}".format(
-                dbdir_folder, temporary_dir
-            )
-        )
-    (
-        _,
-        _,
-        redis_configuration_parameters,
-        dataset_load_timeout_secs,
-        modules_configuration_parameters_map,
-    ) = extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
-    cluster_api_enabled = False
-    logging.info(
-        "Using a dataset load timeout of {} seconds.".format(dataset_load_timeout_secs)
-    )
-    redis_conns = []
-    if setup_type == "oss-cluster":
-        cluster_api_enabled = True
-        shard_host = "127.0.0.1"
-        redis_processes, redis_conns = spin_up_local_redis_cluster(
-            binary,
-            temporary_dir,
-            shard_count,
-            shard_host,
-            args.port,
-            local_module_file,
-            redis_configuration_parameters,
-            dataset_load_timeout_secs,
-            modules_configuration_parameters_map,
-            redis_7,
-        )
-
-        status = setup_redis_cluster_from_conns(
-            redis_conns, shard_count, shard_host, args.port
-        )
-        if status is False:
-            raise Exception("Redis cluster setup failed. Failing test.")
-
-    dataset, dataset_name, _, _ = check_dataset_local_requirements(
-        benchmark_config,
-        temporary_dir,
-        dirname,
-        "./datasets",
-        "dbconfig",
-        shard_count,
-        cluster_api_enabled,
-    )
-    if setup_type == "oss-standalone":
-        redis_processes = spin_up_local_redis(
-            binary,
-            args.port,
-            temporary_dir,
-            local_module_file,
-            redis_configuration_parameters,
-            dbdir_folder,
-            dataset_load_timeout_secs,
-            modules_configuration_parameters_map,
-            redis_7,
-        )
-
-        r = redis.Redis(port=args.port)
-        r.ping()
-        r.client_setname("redisbench-admin-stadalone")
-        redis_conns.append(r)
-    if setup_type == "oss-cluster":
-        for shardn, redis_process in enumerate(redis_processes):
-            logging.info(
-                "Checking if shard #{} process with pid={} is alive".format(
-                    shardn + 1, redis_process.pid
-                )
-            )
-            if is_process_alive(redis_process) is False:
-                raise Exception("Redis process is not alive. Failing test.")
-
-    if setup_type == "oss-cluster":
-        cluster_init_steps(clusterconfig, redis_conns, local_module_file)
-
-    if check_dbconfig_tool_requirement(benchmark_config):
-        logging.info("Detected the requirements to load data via client tool")
-        local_benchmark_output_filename = "{}/load-data.txt".format(temporary_dir)
-        (
-            benchmark_tool,
-            full_benchmark_path,
-            benchmark_tool_workdir,
-        ) = check_benchmark_binaries_local_requirements(
-            benchmark_config, args.allowed_tools, "./binaries", "dbconfig"
-        )
-
-        # prepare the benchmark command
-        command, command_str = prepare_benchmark_parameters(
-            benchmark_config,
-            full_benchmark_path,
-            args.port,
-            "localhost",
-            local_benchmark_output_filename,
-            False,
-            benchmark_tool_workdir,
-            cluster_api_enabled,
-            "dbconfig",
-        )
-
-        # run the benchmark
-        load_via_benchmark_start_time = datetime.datetime.now()
-        run_local_benchmark(benchmark_tool, command)
-        load_via_benchmark_end_time = datetime.datetime.now()
-        load_via_benchmark_duration_seconds = calculate_client_tool_duration_and_check(
-            load_via_benchmark_end_time, load_via_benchmark_start_time
-        )
-        logging.info(
-            "Loading data via benchmark tool took {} secs.".format(
-                load_via_benchmark_duration_seconds
-            )
-        )
-
-    dbconfig_keyspacelen_check(
-        benchmark_config,
-        redis_conns,
-    )
-
-    run_redis_pre_steps(benchmark_config, redis_conns[0], required_modules)
-
-    return cluster_api_enabled, redis_conns, redis_processes