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

redisbench_admin/compare/args.py

@@ -6,7 +6,7 @@
 
 # environment variables
 import datetime
-
+import os
 from redisbench_admin.run.common import get_start_time_vars, PERFORMANCE_GH_TOKEN
 from redisbench_admin.utils.remote import (
     PERFORMANCE_RTS_HOST,
@@ -29,6 +29,10 @@ _, NOW_UTC, _ = get_start_time_vars()
 LAST_MONTH_UTC = NOW_UTC - (31 * 24 * 60 * 60 * 1000)
 START_TIME_NOW_UTC, _, _ = get_start_time_vars()
 START_TIME_LAST_MONTH_UTC = START_TIME_NOW_UTC - datetime.timedelta(days=30)
+ARCH_X86 = "x86_64"
+ARCH_ARM = "aarch64"
+VALID_ARCHS = [ARCH_X86, ARCH_ARM]
+ARCH = os.getenv("ARCH", ARCH_X86)
 
 
 def create_compare_arguments(parser):
@@ -53,11 +57,23 @@ def create_compare_arguments(parser):
     parser.add_argument("--deployment_type", type=str, default="oss-standalone")
     parser.add_argument("--baseline_deployment_name", type=str, default="")
     parser.add_argument("--comparison_deployment_name", type=str, default="")
-    parser.add_argument("--baseline_github_org", type=str, default=GITHUB_ORG)
-    parser.add_argument("--comparison_github_org", type=str, default=GITHUB_ORG)
     parser.add_argument("--metric_name", type=str, default=None)
     parser.add_argument("--running_platform", type=str, default=None)
     parser.add_argument("--extra-filter", type=str, default=None)
+    parser.add_argument(
+        "--baseline_architecture",
+        type=str,
+        required=False,
+        default=ARCH,
+        help=f"Architecture to filter baseline time-series. One of {VALID_ARCHS}.",
+    )
+    parser.add_argument(
+        "--comparison_architecture",
+        type=str,
+        required=False,
+        default=ARCH,
+        help=f"Architecture to filter comparison time-series. One of {VALID_ARCHS}.",
+    )
     parser.add_argument(
         "--last_n",
         type=int,

redisbench_admin/compare/compare.py

@@ -22,6 +22,7 @@ from redisbench_admin.run_remote.notifications import (
     generate_new_pr_comment_notification,
 )
 from redisbench_admin.utils.remote import get_overall_dashboard_keynames
+from redisbench_admin.compare.args import ARCH_X86
 
 
 def get_project_compare_zsets(triggering_env, org, repo):
@@ -166,8 +167,6 @@ def compare_command_logic(args, project_name, project_version):
     auto_approve = args.auto_approve
     running_platform = args.running_platform
     grafana_base_dashboard = args.grafana_base_dashboard
-    baseline_github_org = args.baseline_github_org
-    comparison_github_org = args.comparison_github_org
     # using an access token
     is_actionable_pr = False
     contains_regression_comment = False
@@ -193,38 +192,32 @@ def compare_command_logic(args, project_name, project_version):
         logging.info("Detected github token")
         g = Github(github_token)
         if pull_request is not None and pull_request != "":
-            try:
-                pull_request_n = int(pull_request)
-                github_pr = (
-                    g.get_user(tf_github_org)
-                    .get_repo(tf_github_repo)
-                    .get_issue(pull_request_n)
-                )
-                comments = github_pr.get_comments()
-                pr_link = github_pr.html_url
-                logging.info("Working on github PR already: {}".format(pr_link))
-                is_actionable_pr = True
-                contains_regression_comment, pos = check_regression_comment(comments)
-                if contains_regression_comment:
-                    regression_comment = comments[pos]
-                    old_regression_comment_body = regression_comment.body
-                    logging.info(
-                        "Already contains regression comment. Link: {}".format(
-                            regression_comment.html_url
-                        )
+            pull_request_n = int(pull_request)
+            github_pr = (
+                g.get_user(tf_github_org)
+                .get_repo(tf_github_repo)
+                .get_issue(pull_request_n)
+            )
+            comments = github_pr.get_comments()
+            pr_link = github_pr.html_url
+            logging.info("Working on github PR already: {}".format(pr_link))
+            is_actionable_pr = True
+            contains_regression_comment, pos = check_regression_comment(comments)
+            if contains_regression_comment:
+                regression_comment = comments[pos]
+                old_regression_comment_body = regression_comment.body
+                logging.info(
+                    "Already contains regression comment. Link: {}".format(
+                        regression_comment.html_url
                     )
-                    if verbose:
-                        logging.info("Printing old regression comment:")
-                        print("".join(["-" for x in range(1, 80)]))
-                        print(regression_comment.body)
-                        print("".join(["-" for x in range(1, 80)]))
-                else:
-                    logging.info("Does not contain regression comment")
-
-            except Exception as e:
-                logging.error(
-                    f"Error while working with github. exception {e.__str__()}"
                 )
+                if verbose:
+                    logging.info("Printing old regression comment:")
+                    print("".join(["-" for x in range(1, 80)]))
+                    print(regression_comment.body)
+                    print("".join(["-" for x in range(1, 80)]))
+            else:
+                logging.info("Does not contain regression comment")
 
     grafana_dashboards_uids = {
         "redisgraph": "SH9_rQYGz",
@@ -233,6 +226,8 @@ def compare_command_logic(args, project_name, project_version):
         "redisjson": "UErSC0jGk",
         "redistimeseries": "2WMw61UGz",
     }
+    baseline_architecture = args.baseline_architecture
+    comparison_architecture = args.comparison_architecture
     uid = None
     if tf_github_repo.lower() in grafana_dashboards_uids:
         uid = grafana_dashboards_uids[tf_github_repo.lower()]
@@ -282,8 +277,8 @@ def compare_command_logic(args, project_name, project_version):
         to_ts_ms,
         use_metric_context_path,
         running_platform,
-        baseline_github_org,
-        comparison_github_org,
+        baseline_architecture,
+        comparison_architecture,
     )
     comment_body = ""
     if total_comparison_points > 0:
@@ -508,8 +503,8 @@ def compute_regression_table(
     to_ts_ms=None,
     use_metric_context_path=None,
     running_platform=None,
-    baseline_github_org="",
-    comparison_github_org="",
+    baseline_architecture=ARCH_X86,
+    comparison_architecture=ARCH_X86,
 ):
     START_TIME_NOW_UTC, _, _ = get_start_time_vars()
     START_TIME_LAST_MONTH_UTC = START_TIME_NOW_UTC - datetime.timedelta(days=31)
@@ -595,9 +590,9 @@ def compute_regression_table(
         test_names,
         tf_triggering_env,
         verbose,
-        baseline_github_org,
-        comparison_github_org,
         running_platform,
+        baseline_architecture,
+        comparison_architecture,
     )
     logging.info(
         "Printing differential analysis between {} and {}".format(
@@ -667,7 +662,7 @@ def get_by_strings(
         comparison_str = comparison_branch
 
     if baseline_tag is not None:
-        if baseline_covered:
+        if comparison_covered:
             logging.error(
                 "--baseline-branch and --baseline-tag are mutually exclusive. Pick one..."
             )
@@ -724,9 +719,9 @@ def from_rts_to_regression_table(
     test_names,
     tf_triggering_env,
     verbose,
-    baseline_github_org="",
-    comparison_github_org="",
     running_platform=None,
+    baseline_architecture=ARCH_X86,
+    comparison_architecture=ARCH_X86,
 ):
     print_all = print_regressions_only is False and print_improvements_only is False
     table = []
@@ -748,20 +743,22 @@ def from_rts_to_regression_table(
             "{}={}".format(test_filter, test_name),
             "deployment_name={}".format(baseline_deployment_name),
             "triggering_env={}".format(tf_triggering_env),
-            "github_org={}".format(baseline_github_org),
         ]
         if running_platform is not None:
             filters_baseline.append("running_platform={}".format(running_platform))
+        if baseline_architecture != ARCH_X86:
+            filters_baseline.append(f"arch={baseline_architecture}")
         filters_comparison = [
             "{}={}".format(by_str_comparison, comparison_str),
             "metric={}".format(metric_name),
             "{}={}".format(test_filter, test_name),
             "deployment_name={}".format(comparison_deployment_name),
             "triggering_env={}".format(tf_triggering_env),
-            "github_org={}".format(comparison_github_org),
         ]
         if running_platform is not None:
             filters_comparison.append("running_platform={}".format(running_platform))
+        if comparison_architecture != ARCH_X86:
+            filters_comparison.append(f"arch={comparison_architecture}")
         baseline_timeseries = rts.ts().queryindex(filters_baseline)
         comparison_timeseries = rts.ts().queryindex(filters_comparison)
 
@@ -1061,9 +1058,9 @@ def get_v_pct_change_and_largest_var(
             if last_n < 0 or (last_n > 0 and len(comparison_values) < last_n):
                 comparison_values.append(tuple[1])
         comparison_df = pd.DataFrame(comparison_values)
-        comparison_median = float(comparison_df.median().iloc[0])
+        comparison_median = float(comparison_df.median())
         comparison_v = comparison_median
-        comparison_std = float(comparison_df.std().iloc[0])
+        comparison_std = float(comparison_df.std())
         if verbose:
             logging.info(
                 "comparison_datapoints: {} value: {}; std-dev: {}; median: {}".format(

redisbench_admin/deploy/deploy.py

@@ -69,13 +69,19 @@ def deploy_command_logic(args, project_name, project_version):
     )
     tf_setup_name_sufix = "{}-{}".format(args.setup_name_sufix, tf_github_sha)
     tf_setup_name = "{}{}".format(remote_setup, tf_setup_name_sufix)
-    terraform_backend_key = "benchmarks/infrastructure/{}.tfstate".format(
-        tf_setup_name
-    ).replace("/", "-")
+    terraform_backend_key = "benchmarks/infrastructure/{}.tfstate".format(tf_setup_name)
     tf_triggering_env = "redisbench-admin-deploy"
     logging.info("Setting an infra timeout of {} secs".format(infra_timeout_secs))
     if args.destroy is False:
-        (tf_return_code, _, _, _, _, _, _,) = setup_remote_environment(
+        (
+            tf_return_code,
+            _,
+            _,
+            _,
+            _,
+            _,
+            _,
+        ) = setup_remote_environment(
             tf,
             tf_github_sha,
             tf_github_actor,
@@ -103,7 +109,6 @@ def deploy_command_logic(args, project_name, project_version):
         _, _, _ = tf.init(
             capture_output=True,
             backend_config={"key": terraform_backend_key},
-            reconfigure=True,
         )
         logging.info("Refreshing remote state")
         _, _, _ = tf.refresh()

redisbench_admin/export/export.py

@@ -42,7 +42,13 @@ def export_command_logic(args, project_name, project_version):
     deployment_name = args.deployment_name
     deployment_type = args.deployment_type
     results_format = args.results_format
-    (_, github_branch, github_org, github_repo, _,) = git_vars_crosscheck(
+    (
+        _,
+        github_branch,
+        github_org,
+        github_repo,
+        _,
+    ) = git_vars_crosscheck(
         None, args.github_branch, args.github_org, args.github_repo, None
     )
     exporter_timemetric_path = None

redisbench_admin/profilers/perf.py

@@ -400,9 +400,9 @@ class Perf:
             "Main THREAD Flame Graph: " + use_case, details
         )
         if artifact_result is True:
-            outputs[
-                "Main THREAD Flame Graph {}".format(identifier)
-            ] = flame_graph_output
+            outputs["Main THREAD Flame Graph {}".format(identifier)] = (
+                flame_graph_output
+            )
         result &= artifact_result
 
         tid = self.pid
@@ -440,9 +440,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report per dso,sym
@@ -460,9 +460,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym with callgraph {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym with callgraph {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report per dso,sym,srcline
@@ -487,9 +487,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym,srcline {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym,srcline {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         self.logger.info(
@@ -527,9 +527,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report top self-cpu {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report top self-cpu {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report --stdio report
@@ -546,9 +546,9 @@ class Perf:
             )
 
             if artifact_result is True:
-                outputs[
-                    "perf report top self-cpu (dso={})".format(binary)
-                ] = perf_report_artifact
+                outputs["perf report top self-cpu (dso={})".format(binary)] = (
+                    perf_report_artifact
+                )
         result &= artifact_result
 
         if self.callgraph_mode == "dwarf":
@@ -590,9 +590,9 @@ class Perf:
                 )
                 result &= artifact_result
                 if artifact_result is True:
-                    outputs[
-                        "Top entries in text form by LOC"
-                    ] = pprof_artifact_text_output
+                    outputs["Top entries in text form by LOC"] = (
+                        pprof_artifact_text_output
+                    )
                     tabular_data_map["text-lines"] = tabular_data
                 self.logger.info("Generating pprof png output")
                 pprof_png_output = self.output + ".pprof.png"
@@ -604,9 +604,9 @@ class Perf:
                     self.output,
                 )
                 if artifact_result is True:
-                    outputs[
-                        "Output graph image in PNG format"
-                    ] = pprof_artifact_png_output
+                    outputs["Output graph image in PNG format"] = (
+                        pprof_artifact_png_output
+                    )
                 result &= artifact_result
 
         # save stack collapsed

redisbench_admin/run/args.py

@@ -44,9 +44,20 @@ 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")))
+ARCH_X86 = "x86_64"
+ARCH_ARM = "aarch64"
+VALID_ARCHS = [ARCH_X86, ARCH_ARM]
+ARCH = os.getenv("ARCH", ARCH_X86)
 
 
 def common_run_args(parser):
+    parser.add_argument(
+        "--architecture",
+        type=str,
+        required=False,
+        default=ARCH,
+        help=f"Architecture to run the benchmark on. One of {VALID_ARCHS}.",
+    )
     parser.add_argument(
         "--keep_env_and_topo",
         required=False,

redisbench_admin/run/common.py

@@ -206,7 +206,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_tsbs_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_tsbs_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -218,7 +221,10 @@ def prepare_benchmark_parameters_specif_tooling(
             cluster_api_enabled,
         )
     if "memtier_benchmark" in benchmark_tool:
-        (command_arr, command_str,) = prepare_memtier_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_memtier_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -236,7 +242,10 @@ def prepare_benchmark_parameters_specif_tooling(
             ann_path = stdout[0].strip() + "/run/ann/pkg/multirun.py"
             logging.info("Remote ann-benchmark path: {}".format(ann_path))
 
-        (command_arr, command_str,) = prepare_ann_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_ann_benchmark_command(
             server_private_ip,
             server_plaintext_port,
             cluster_api_enabled,
@@ -250,7 +259,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_ftsb_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_ftsb_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -267,7 +279,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_aibench_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_aibench_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -619,11 +634,9 @@ def run_redis_pre_steps(benchmark_config, r, required_modules):
         )
         search_specific_init(r, module_names)
     if required_modules is not None and len(required_modules) > 0:
-        artifact_pos = check_required_modules(module_names, required_modules)
-        version = artifact_versions[artifact_pos]
-        logging.info(
-            f"Using version {version} in by version timeseries coming from {module_names[artifact_pos]}"
-        )
+        check_required_modules(module_names, required_modules)
+
+        version = artifact_versions[0]
     else:
         version = r.info("server")["redis_version"]
 
@@ -689,45 +702,54 @@ def dso_check(dso, local_module_file):
 
 
 def dbconfig_keyspacelen_check(
-    benchmark_config, redis_conns, ignore_keyspace_errors=False
+    benchmark_config, redis_conns, ignore_keyspace_errors=False, timeout=60
 ):
-    result = True
+    start_time = time.time()
     (
         requires_keyspacelen_check,
         keyspacelen,
     ) = check_dbconfig_keyspacelen_requirement(benchmark_config)
-    if requires_keyspacelen_check:
-        result = False
+
+    if not requires_keyspacelen_check:
+        return True
+
+    attempt = 0
+    while time.time() - start_time < timeout:
         logging.info(
-            "Ensuring keyspace length requirement = {} is met.".format(keyspacelen)
+            f"Ensuring keyspace length requirement = {keyspacelen} is met. attempt #{attempt+1}"
         )
         total_keys = 0
         for shard_conn in redis_conns:
             keyspace_dict = shard_conn.info("keyspace")
             for _, dbdict in keyspace_dict.items():
-                shard_keys = dbdict["keys"]
-                total_keys += shard_keys
+                total_keys += dbdict.get("keys", 0)
 
         if total_keys == keyspacelen:
             logging.info(
-                "The total numbers of keys in setup matches the expected spec: {}=={}".format(
+                "The total number of keys in setup matches the expected spec: {} == {}".format(
                     keyspacelen, total_keys
                 )
             )
-            result = True
-        else:
-            logging.error(
-                "The total numbers of keys in setup does not match the expected spec: {}!={}. Aborting...".format(
-                    keyspacelen, total_keys
-                )
+            return True
+
+        logging.warning(
+            "Keyspace length mismatch ({} != {}). Retrying in {} seconds...".format(
+                total_keys, keyspacelen, 2**attempt
             )
-            if ignore_keyspace_errors is False:
-                raise Exception(
-                    "The total numbers of keys in setup does not match the expected spec: {}!={}. Aborting...".format(
-                        keyspacelen, total_keys
-                    )
-                )
-    return result
+        )
+        time.sleep(2**attempt)  # Exponential backoff
+        attempt += 1
+
+    logging.error(
+        f"The total number of keys in setup does not match the expected spec: {keyspacelen} != {total_keys}. Aborting after {attempt+1} tries..."
+    )
+
+    if not ignore_keyspace_errors:
+        raise Exception(
+            f"The total number of keys in setup does not match the expected spec: {keyspacelen} != {total_keys}. Aborting after {attempt+1} tries..."
+        )
+
+    return False
 
 
 def common_properties_log(
@@ -765,7 +787,10 @@ def print_results_table_stdout(
     metric_names=[],
 ):
     # check which metrics to extract
-    (_, metrics,) = merge_default_and_config_metrics(
+    (
+        _,
+        metrics,
+    ) = merge_default_and_config_metrics(
         benchmark_config,
         default_metrics,
         None,

redisbench_admin/run/ftsb/ftsb.py

@@ -29,7 +29,6 @@ def prepare_ftsb_benchmark_command(
     :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)]
     )

redisbench_admin/run/ssh.py

@@ -42,7 +42,6 @@ def ssh_tunnel_redisconn(
         ),  # remote redis server
         # Bind the socket to port 0. A random free port from 1024 to 65535 will be selected.
         local_bind_address=("0.0.0.0", 0),  # enable local forwarding port
-        set_keepalive=60,
     )
     ssh_tunel.start()  # start tunnel
     redis_conn = redis.Redis(
@@ -70,19 +69,6 @@ def check_connection(ssh_conn):
         return False
 
 
-def ensure_400_permissions(file_path):
-    import stat
-
-    file_stat = os.stat(file_path)
-    current_permissions = stat.S_IMODE(file_stat.st_mode)
-
-    if current_permissions != 0o400:
-        logging.info(f"Changing permissions of {file_path} to 400")
-        os.chmod(file_path, 0o400)
-    else:
-        logging.info(f"{file_path} already has 400 permissions.")
-
-
 def ssh_pem_check(EC2_PRIVATE_PEM, private_key):
     if os.path.exists(private_key) is False:
         if EC2_PRIVATE_PEM is not None and EC2_PRIVATE_PEM != "":
@@ -103,4 +89,3 @@ def ssh_pem_check(EC2_PRIVATE_PEM, private_key):
         logging.info(
             "Confirmed that private key path artifact: '{}' exists!".format(private_key)
         )
-    ensure_400_permissions(private_key)

redisbench_admin/run_async/async_terraform.py

@@ -114,7 +114,11 @@ class TerraformClass:
     def async_runner_setup(
         self,
     ):
-        (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
+        (
+            remote_setup,
+            deployment_type,
+            remote_id,
+        ) = fetch_remote_setup_from_config(
             [{"type": "async", "setup": "runner"}],
             "https://github.com/RedisLabsModules/testing-infrastructure.git",
             "master",
@@ -229,7 +233,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/RedisLabsModules/testing-infrastructure.git",
         "master",

redisbench_admin/run_async/render_files.py

@@ -28,9 +28,9 @@ WantedBy=multi-user.target
         argv.append("--private_key")
         argv.append("/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem")
     else:
-        argv[
-            argv.index(args.private_key)
-        ] = "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
+        argv[argv.index(args.private_key)] = (
+            "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
+        )
     if len(args.module_path) != 0:
         argv[argv.index(args.module_path[0])] = (
             "/home/ubuntu/work_dir/tests/benchmarks/"

redisbench_admin/run_local/args.py

@@ -12,6 +12,7 @@ FLUSHALL_AT_START = bool(int(os.getenv("FLUSHALL_AT_START", "1")))
 IGNORE_KEYSPACE_ERRORS = bool(int(os.getenv("IGNORE_KEYSPACE_ERRORS", "0")))
 SKIP_REDIS_SPIN = bool(int(os.getenv("SKIP_REDIS_SPIN", "0")))
 REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
+REDIS_AUTH = os.getenv("REDIS_AUTH", None)
 REDIS_HOST = os.getenv("REDIS_HOST", "127.0.0.1")
 
 
@@ -19,6 +20,7 @@ def create_run_local_arguments(parser):
     parser = common_run_args(parser)
     parser.add_argument("--port", type=int, default=REDIS_PORT)
     parser.add_argument("--host", type=str, default=REDIS_HOST)
+    parser.add_argument("--password", type=str, default=REDIS_AUTH)
     parser.add_argument("--redis-binary", type=str, default=REDIS_BINARY)
     parser.add_argument(
         "--flushall_on_every_test_start",