redisbench-admin 0.11.19__py3-none-any.whl → 0.11.22__py3-none-any.whl

redisbench_admin/run_local/local_db.py

@@ -158,7 +158,7 @@ def local_db_spin(
             logging.info("Skipping DB spin step...")
 
     if setup_type == "oss-standalone":
-        r = redis.Redis(port=args.port, host=args.host)
+        r = redis.Redis(port=args.port, host=args.host, password=args.password)
         r.ping()
         r.client_setname("redisbench-admin-standalone")
         redis_conns.append(r)
@@ -192,6 +192,11 @@ def local_db_spin(
             benchmark_tool_workdir,
             cluster_api_enabled,
             "dbconfig",
+            None,
+            None,
+            None,
+            None,
+            args.password,
         )
 
         # run the benchmark
@@ -206,7 +211,6 @@ def local_db_spin(
                 load_via_benchmark_duration_seconds
             )
         )
-
     dbconfig_keyspacelen_check(benchmark_config, redis_conns, ignore_keyspace_errors)
 
     artifact_version = run_redis_pre_steps(

redisbench_admin/run_local/run_local.py

@@ -298,6 +298,12 @@ def run_local_command_logic(args, project_name, project_version):
                                     False,
                                     benchmark_tool_workdir,
                                     cluster_api_enabled,
+                                    "clientconfig",
+                                    None,
+                                    None,
+                                    None,
+                                    None,
+                                    args.password,
                                 )
                                 redis_pids = [
                                     redis_process.pid
@@ -680,17 +686,17 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict[
-                "command_and_metric_and_version"
-            ] = "{} - {} - {}".format(command, metric, version)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_version"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            variant_labels_dict["command_and_metric_and_version"] = (
+                "{} - {} - {}".format(command, metric, version)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            )
 
         if branch is not None:
-            variant_labels_dict[
-                "command_and_metric_and_branch"
-            ] = "{} - {} - {}".format(command, metric, branch)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_branch"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            variant_labels_dict["command_and_metric_and_branch"] = (
+                "{} - {} - {}".format(command, metric, branch)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            )

redisbench_admin/run_remote/remote_db.py

@@ -372,6 +372,7 @@ def remote_db_spin(
         benchmark_config,
         redis_conns,
         ignore_keyspace_errors,
+        keyspace_check_timeout,
     )
     artifact_version = run_redis_pre_steps(
         benchmark_config, redis_conns[0], required_modules

redisbench_admin/run_remote/remote_env.py

@@ -7,6 +7,7 @@ import logging
 
 from python_terraform import TerraformCommandError
 
+from redisbench_admin.run.args import ARCH_X86, ARCH_ARM
 from redisbench_admin.run_remote.terraform import (
     retrieve_inventory_info,
     terraform_spin_or_reuse_env,
@@ -33,11 +34,22 @@ def remote_env_setup(
     spot_instance_error=False,
     spot_price_counter=0,
     full_price_counter=0,
+    architecture=ARCH_X86,
 ):
     server_plaintext_port = args.db_port
     db_ssh_port = args.db_ssh_port
     client_ssh_port = args.client_ssh_port
     username = args.user
+    if architecture != ARCH_X86 and tf_folder_path is not None:
+        logging.info(
+            f"Checking if the architecture info is specified on the terraform path {tf_folder_path}"
+        )
+        if architecture is ARCH_ARM and ARCH_ARM not in tf_folder_path:
+            logging.info(f"adding suffix '-{ARCH_ARM}' to {tf_folder_path}")
+            tf_folder_path = "{tf_folder_path}-{ARCH_ARM}"
+        else:
+            logging.info(f"'-{ARCH_ARM}' suffix already in {tf_folder_path}")
+
     if args.inventory is not None:
         (
             status,

redisbench_admin/run_remote/remote_helpers.py

@@ -274,7 +274,6 @@ def post_process_remote_run(
     tmp,
     result_csv_filename="result.csv",
 ):
-    results_dict = {}
     if benchmark_tool == "redis-benchmark":
         local_benchmark_output_filename = tmp
         with open(result_csv_filename, "r", encoding="utf-8") as txt_file:

redisbench_admin/run_remote/run_remote.py

@@ -21,7 +21,7 @@ from redisbench_admin.profilers.perf_daemon_caller import (
     PerfDaemonRemoteCaller,
     PERF_DAEMON_LOGNAME,
 )
-from redisbench_admin.run.args import PROFILE_FREQ
+from redisbench_admin.run.args import PROFILE_FREQ, VALID_ARCHS
 from redisbench_admin.run.common import (
     get_start_time_vars,
     BENCHMARK_REPETITIONS,
@@ -300,6 +300,14 @@ def run_remote_command_logic(args, project_name, project_version):
     benchmark_artifacts_table_name = "Benchmark client artifacts"
     benchmark_artifacts_table_headers = ["Setup", "Test-case", "Artifact", "link"]
     benchmark_artifacts_links = []
+    architecture = args.architecture
+    if architecture not in VALID_ARCHS:
+        logging.critical(
+            f"The specified architecture {architecture} is not valid. Specify one of {VALID_ARCHS}"
+        )
+        exit(1)
+    else:
+        logging.info("Running benchmark for architecture {architecture}")
 
     # contains the overall target-tables ( if any target is defined )
     overall_tables = {}
@@ -346,10 +354,7 @@ def run_remote_command_logic(args, project_name, project_version):
 
                 # map from setup name to overall target-tables ( if any target is defined )
                 overall_tables[setup_name] = {}
-                total_benchmarks = len(benchmarks_map.keys())
-                import tqdm
 
-                pbar = tqdm.tqdm(total=total_benchmarks, unit="benchmarks")
                 for test_name, benchmark_config in benchmarks_map.items():
                     if return_code != 0 and args.fail_fast:
                         logging.warning(
@@ -374,7 +379,9 @@ def run_remote_command_logic(args, project_name, project_version):
                             continue
                         remote_perf = None
                         logging.info(
-                            f"Repetition {repetition} of {BENCHMARK_REPETITIONS}. Running test {test_name}. Total benchmarks {total_benchmarks}"
+                            "Repetition {} of {}. Running test {}".format(
+                                repetition, BENCHMARK_REPETITIONS, test_name
+                            )
                         )
                         (
                             setup_name,
@@ -442,6 +449,7 @@ def run_remote_command_logic(args, project_name, project_version):
                                     spot_instance_error,
                                     0,
                                     0,
+                                    architecture,
                                 )
 
                                 # after we've created the env, even on error we should always teardown
@@ -1093,7 +1101,6 @@ def run_remote_command_logic(args, project_name, project_version):
                                     f"Test {test_name} does not have remote config. Skipping test."
                                 )
 
-                    pbar.update()
     if len(benchmark_artifacts_links) > 0:
         writer = MarkdownTableWriter(
             table_name=benchmark_artifacts_table_name,
@@ -1376,20 +1383,20 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict[
-                "command_and_metric_and_version"
-            ] = "{} - {} - {}".format(command, metric, version)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_version"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            variant_labels_dict["command_and_metric_and_version"] = (
+                "{} - {} - {}".format(command, metric, version)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            )
 
         if branch is not None:
-            variant_labels_dict[
-                "command_and_metric_and_branch"
-            ] = "{} - {} - {}".format(command, metric, branch)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_branch"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            variant_labels_dict["command_and_metric_and_branch"] = (
+                "{} - {} - {}".format(command, metric, branch)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            )
 
 
 def shutdown_remote_redis(redis_conns, ssh_tunnel):

redisbench_admin/run_remote/standalone.py

@@ -76,7 +76,6 @@ def remote_module_files_cp(
 ):
     remote_module_files = []
     if local_module_files is not None:
-        logging.info(f"local_module_files: {local_module_files}")
         for local_module_file in local_module_files:
             splitted_module_and_plugins = []
             if type(local_module_file) is str:
@@ -136,10 +135,7 @@ def remote_module_files_cp(
                 if pos > 1:
                     remote_module_files_in = remote_module_files_in + " "
                 remote_module_files_in = remote_module_files_in + remote_module_file
-            logging.info(
-                f"appending to {remote_module_files} remote file {remote_module_files_in}"
-            )
-            remote_module_files.append(remote_module_files_in)
+        remote_module_files.append(remote_module_files_in)
     logging.info(
         "There are a total of {} remote files {}".format(
             len(remote_module_files), remote_module_files
@@ -157,9 +153,12 @@ def generate_remote_standalone_redis_cmd(
     enable_redis_7_config_directives=True,
     enable_debug_command="yes",
 ):
-    initial_redis_cmd = "redis-server --save '' --logfile {} --dir {} --daemonize yes --protected-mode no --enable-debug-command yes ".format(
+    initial_redis_cmd = "redis-server --save '' --logfile {} --dir {} --daemonize yes --protected-mode no ".format(
         logfile, temporary_dir
     )
+    if enable_redis_7_config_directives:
+        extra_str = " --enable-debug-command {} ".format(enable_debug_command)
+        initial_redis_cmd = initial_redis_cmd + extra_str
     full_logfile = "{}/{}".format(temporary_dir, logfile)
     if redis_configuration_parameters is not None:
         for (

redisbench_admin/run_remote/terraform.py

@@ -31,7 +31,11 @@ def terraform_spin_or_reuse_env(
     tf_override_name=None,
     tf_folder_path=None,
 ):
-    (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
+    (
+        remote_setup,
+        deployment_type,
+        remote_id,
+    ) = fetch_remote_setup_from_config(
         benchmark_config["remote"],
         "https://github.com/redis-performance/testing-infrastructure.git",
         "master",

redisbench_admin/utils/benchmark_config.py

@@ -565,7 +565,6 @@ def get_testfiles_to_process(
 
 
 def check_required_modules(module_names, required_modules):
-    position = -1
     if required_modules is not None:
         if len(required_modules) > 0:
             logging.info(
@@ -573,12 +572,6 @@ def check_required_modules(module_names, required_modules):
                     required_modules
                 )
             )
-            first_module = required_modules[0]
-            if first_module in module_names:
-                position = module_names.index(first_module)
-                logging.info(
-                    f"POSITION of 1st required module :{first_module} in the module names list {module_names}: pos={position} "
-                )
             for required_module in required_modules:
                 if required_module not in module_names:
                     raise Exception(
@@ -587,7 +580,6 @@ def check_required_modules(module_names, required_modules):
                             module_names,
                         )
                     )
-    return position
 
 
 def results_dict_kpi_check(benchmark_config, results_dict, return_code):

redisbench_admin/utils/remote.py

@@ -21,6 +21,7 @@ from tqdm import tqdm
 
 from redisbench_admin.environments.oss_cluster import get_cluster_dbfilename
 from redisbench_admin.run.metrics import extract_results_table
+from redisbench_admin.run.args import ARCH_X86
 from redisbench_admin.utils.local import check_dataset_local_requirements
 from redisbench_admin.utils.utils import (
     get_ts_metric_name,
@@ -142,7 +143,7 @@ def execute_remote_commands(
     c = connect_remote_ssh(port, private_key, server_public_ip, username)
     for command in commands:
         logging.info('Executing remote command "{}"'.format(command))
-        stdin, stdout, stderr = c.exec_command(command, get_pty=get_pty, timeout=180)
+        stdin, stdout, stderr = c.exec_command(command, get_pty=get_pty)
         recv_exit_status = stdout.channel.recv_exit_status()  # status is 0
         stdout = stdout.readlines()
         stderr = stderr.readlines()
@@ -158,46 +159,13 @@ def execute_remote_commands(
 
 
 def connect_remote_ssh(port, private_key, server_public_ip, username):
-    import time
-    import socket
-
     k = paramiko.RSAKey.from_private_key_file(private_key)
     c = paramiko.SSHClient()
     c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-    max_retries = 20
-    base_delay = 8  # Initial backoff time in seconds
-    max_delay = 900  # Maximum delay in seconds
-
-    for attempt in range(max_retries):
-        try:
-            logging.info(
-                f"Connecting to remote server {server_public_ip}, attempt {attempt + 1}"
-            )
-            c.connect(
-                hostname=server_public_ip,
-                port=port,
-                username=username,
-                pkey=k,
-                timeout=300,
-            )
-            logging.info(f"Connected to remote server {server_public_ip}")
-            return c
-        except (
-            paramiko.ssh_exception.NoValidConnectionsError,
-            socket.timeout,
-            paramiko.ssh_exception.SSHException,
-        ) as e:
-            wait_time = min(base_delay * (2**attempt), max_delay)
-            logging.warning(
-                f"Connection attempt {attempt + 1} failed: {e}. Retrying in {wait_time} seconds..."
-            )
-            time.sleep(wait_time)
-
-    logging.error("Failed to connect after multiple attempts.")
-    raise Exception(
-        f"Could not connect to {server_public_ip} after {max_retries} attempts."
-    )
+    logging.info("Connecting to remote server {}".format(server_public_ip))
+    c.connect(hostname=server_public_ip, port=port, username=username, pkey=k)
+    logging.info("Connected to remote server {}".format(server_public_ip))
+    return c
 
 
 def check_dataset_remote_requirements(
@@ -303,9 +271,7 @@ def setup_remote_environment(
     _, _, _ = tf.init(
         capture_output=True,
         backend_config={
-            "key": "benchmarks/infrastructure/{}.tfstate".format(tf_setup_name).replace(
-                "/", "-"
-            )
+            "key": "benchmarks/infrastructure/{}.tfstate".format(tf_setup_name)
         },
     )
     _, _, _ = tf.refresh()
@@ -579,21 +545,12 @@ def common_tf(branch, path, repo, temporary_dir=None, destroy=False):
         temporary_dir = tempfile.mkdtemp()
     if destroy is False:
         logging.info(
-            "Fetching infrastructure definition from git repo {}{} (branch={}). Using local dir {} to store state".format(
+            "Fetching infrastructure definition from git repo {}/{} (branch={}). Using local dir {} to store state".format(
                 repo, path, branch, temporary_dir
             )
         )
         git.Repo.clone_from(repo, temporary_dir, branch=branch, depth=1)
-        logging.info(f"ensuring folder exists: {temporary_dir}")
-        assert os.path.exists(temporary_dir) and os.path.isdir(
-            temporary_dir
-        ), f"Folder '{temporary_dir}' does not exist"
-    if path[0] != "/":
-        temporary_dir = temporary_dir + "/"
     terraform_working_dir = temporary_dir + path
-    logging.info(
-        f"terraform_working_dir={terraform_working_dir}. temporary_dir={temporary_dir}. path={path}"
-    )
     return terraform_working_dir
 
 
@@ -605,7 +562,7 @@ def check_remote_setup_spot_instance(
     contains_spot_instance = False
     for remote_setup_property in remote_setup_config:
         if "spot_instance" in remote_setup_property:
-            spot_path = "terraform/" + remote_setup_property["spot_instance"]
+            spot_path = "/terraform/" + remote_setup_property["spot_instance"]
             contains_spot_instance = True
             logging.info(f"Detected spot instance config. Setup path: {spot_path}")
 
@@ -775,7 +732,10 @@ def extract_perversion_timeseries_from_results(
 ):
     break_by_key = "version"
     break_by_str = "by.{}".format(break_by_key)
-    (branch_time_series_dict, target_tables,) = common_timeseries_extraction(
+    (
+        branch_time_series_dict,
+        target_tables,
+    ) = common_timeseries_extraction(
         break_by_key,
         break_by_str,
         datapoints_timestamp,
@@ -946,9 +906,9 @@ def from_metric_kv_to_timeserie(
 
         target_table_dict[target_name] = target_value
 
-        target_table_dict[
-            "{}:percent {}".format(target_name, comparison_type)
-        ] = target_value_pct_str
+        target_table_dict["{}:percent {}".format(target_name, comparison_type)] = (
+            target_value_pct_str
+        )
     return target_table_keyname, target_table_dict
 
 
@@ -970,6 +930,7 @@ def get_ts_tags_and_name(
     tf_github_repo,
     tf_triggering_env,
     use_metric_context_path,
+    arch=ARCH_X86,
 ):
     # prepare tags
     timeserie_tags = get_project_ts_tags(
@@ -997,6 +958,7 @@ def get_ts_tags_and_name(
         )
     timeserie_tags["metric"] = str(metric_name)
     timeserie_tags["metric_name"] = metric_name
+    timeserie_tags["arch"] = arch
     timeserie_tags["metric_context_path"] = metric_context_path
     if metric_context_path is not None:
         timeserie_tags["test_name:metric_context_path"] = "{}:{}".format(
@@ -1019,6 +981,7 @@ def get_ts_tags_and_name(
         use_metric_context_path,
         build_variant_name,
         running_platform,
+        arch,
     )
     return timeserie_tags, ts_name
 

redisbench_admin/utils/utils.py

@@ -100,12 +100,17 @@ def generate_common_server_args(
             "''",
             "--port",
             "{}".format(port),
-            "--enable-debug-command",
-            "yes",
             "--dir",
             dbdir,
         ]
     )
+    if enable_redis_7_config_directives:
+        command.extend(
+            [
+                "--enable-debug-command",
+                enable_debug_command,
+            ]
+        )
 
     return command
 
@@ -326,6 +331,7 @@ def get_ts_metric_name(
     use_metric_context_path=False,
     build_variant_name=None,
     running_platform=None,
+    arch="x86_64",
 ):
     if use_metric_context_path:
         metric_name = "{}/{}".format(metric_name, metric_context_path)
@@ -356,6 +362,11 @@ def get_ts_metric_name(
             metric=metric_name,
         )
     )
+    if arch != "x86_64":
+        logging.info(
+            f"Extending timeseries name with architecture given it's not x86. arch={arch}"
+        )
+        ts_name = ts_name + f"arch={arch}"
     return ts_name
 
 

redisbench_admin/watchdog/watchdog.py

@@ -31,15 +31,14 @@ def get_ci_ec2_instances_by_state(ec2_client, ci_machines_prefix, requested_stat
         instances = group["Instances"]
         for instance in instances:
             state = instance["State"]["Name"]
-            if "Tags" in instance:
-                for tag_dict in instance["Tags"]:
-                    key = tag_dict["Key"]
-                    key_v = tag_dict["Value"]
-                    if key == "Name":
-                        if ci_machines_prefix in key_v:
-                            if state == requested_state:
-                                count = count + 1
-                                state_instances.append(instance)
+            for tag_dict in instance["Tags"]:
+                key = tag_dict["Key"]
+                key_v = tag_dict["Value"]
+                if key == "Name":
+                    if ci_machines_prefix in key_v:
+                        if state == requested_state:
+                            count = count + 1
+                            state_instances.append(instance)
     return count, state_instances
 
 

{redisbench_admin-0.11.19.dist-info → redisbench_admin-0.11.22.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.19
+Version: 0.11.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
-Requires-Python: >=3.9.0,<4.0.0
+Requires-Python: >=3.10.0,<4.0.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12