redisbench-admin 0.11.38__py3-none-any.whl → 0.11.40__py3-none-any.whl

redisbench_admin/environments/oss_cluster.py

@@ -89,6 +89,20 @@ def generate_meet_cmds(shard_count, shard_host, start_port):
 def setup_oss_cluster_from_conns(meet_cmds, redis_conns, shard_count):
     status = False
     try:
+        # Pre-setup validation: check uptime and cluster mode
+        for primary_pos, redis_conn in enumerate(redis_conns):
+            redis_conn.ping()
+
+            server_info = redis_conn.info("server")
+            uptime = server_info.get("uptime_in_seconds", 0)
+            cluster_enabled = server_info.get("cluster_enabled", 0)
+            tcp_port = server_info.get("tcp_port", "n/a")
+
+            logging.info(
+                f"Node {primary_pos} ({tcp_port}): uptime={uptime}s cluster_enabled={cluster_enabled}"
+            )
+
+        # Send meet commands
         for primary_pos, redis_conn in enumerate(redis_conns):
             logging.info(
                 "Sending to primary #{} a total of {} MEET commands".format(
@@ -138,6 +152,29 @@ def setup_oss_cluster_from_conns(meet_cmds, redis_conns, shard_count):
                 )
                 logging.info("Node {}: cluster_state {}".format(n, cluster_state_ok))
                 sleep(1)
+
+        # Post-setup validation: check uptime and cluster mode
+        sleep(10)
+        for primary_pos, redis_conn in enumerate(redis_conns):
+            redis_conn.ping()
+
+            server_info = redis_conn.info("server")
+            uptime = server_info.get("uptime_in_seconds", 0)
+            server_info = redis_conn.info("cluster")
+            cluster_enabled = server_info.get("cluster_enabled", -1)
+            tcp_port = server_info.get("tcp_port", "n/a")
+
+            logging.info(
+                f"Node {primary_pos} ({tcp_port}): uptime={uptime}s cluster_enabled={cluster_enabled}"
+            )
+
+            if cluster_enabled != 1:
+                logging.error(
+                    "Node {}: cluster mode is not enabled (cluster_enabled={})".format(
+                        primary_pos, cluster_enabled
+                    )
+                )
+                return False
         status = True
     except redis.exceptions.RedisError as e:
         logging.warning("Received an error {}".format(e.__str__()))

redisbench_admin/run/cluster.py

@@ -115,6 +115,12 @@ def spin_up_redis_cluster_remote_redis(
     logname,
     redis_7=True,
 ):
+    # Import the function from standalone module
+    from redisbench_admin.run_remote.standalone import ensure_redis_server_available
+
+    # Ensure redis-server is available before trying to start cluster
+    ensure_redis_server_available(server_public_ip, username, private_key, ssh_port)
+
     logging.info("Generating the remote redis-server command arguments")
     redis_process_commands = []
     logfiles = []

redisbench_admin/run/metrics.py

@@ -188,8 +188,6 @@ BENCHMARK_CPU_STATS_GLOBAL = {}
 
 
 def collect_cpu_data(redis_conns=[], delta_secs: float = 5.0, delay_start: float = 1.0):
-    global BENCHMARK_CPU_STATS_GLOBAL
-    global BENCHMARK_RUNNING_GLOBAL
     import time
 
     counter = 0

redisbench_admin/run_local/args.py

@@ -40,4 +40,16 @@ def create_run_local_arguments(parser):
         default=IGNORE_KEYSPACE_ERRORS,
         help="Ignore keyspace check errors. Will still log them as errors",
     )
+    parser.add_argument(
+        "--dry-run",
+        default=False,
+        action="store_true",
+        help="Setup environment and test connectivity without running benchmarks",
+    )
+    parser.add_argument(
+        "--dry-run-with-preload",
+        default=False,
+        action="store_true",
+        help="Setup environment, preload data, and test connectivity without running benchmarks",
+    )
     return parser

redisbench_admin/run_local/run_local.py

@@ -16,6 +16,7 @@ from redisbench_admin.run.git import git_vars_crosscheck
 from redisbench_admin.utils.remote import (
     get_project_ts_tags,
     push_data_to_redistimeseries,
+    perform_connectivity_test,
 )
 
 import redisbench_admin.run.metrics
@@ -326,6 +327,7 @@ def run_local_command_logic(args, project_name, project_version):
                                 )
 
                                 # run the benchmark
+
                                 cpu_stats_thread = threading.Thread(
                                     target=collect_cpu_data,
                                     args=(redis_conns, 5.0, 1.0),
@@ -335,9 +337,60 @@ def run_local_command_logic(args, project_name, project_version):
                                 )
                                 cpu_stats_thread.start()
                                 benchmark_start_time = datetime.datetime.now()
-                                stdout, stderr = run_local_benchmark(
-                                    benchmark_tool, command
+                                logging.info(
+                                    "Running benchmark command: {}".format(command)
                                 )
+                                # Handle dry-run modes
+                                if args.dry_run or args.dry_run_with_preload:
+                                    logging.info(
+                                        "🏃 Dry-run mode detected - performing connectivity tests"
+                                    )
+
+                                    # Test basic connectivity after setup
+                                    connectivity_success = perform_connectivity_test(
+                                        redis_conns, "after local environment setup"
+                                    )
+
+                                    if args.dry_run_with_preload:
+                                        logging.info(
+                                            "📦 Dry-run with preload - data loading already completed during setup"
+                                        )
+                                        # Test connectivity after preload (data was loaded during local_db_spin)
+                                        connectivity_success = (
+                                            perform_connectivity_test(
+                                                redis_conns, "after data preloading"
+                                            )
+                                            and connectivity_success
+                                        )
+
+                                    # Print dry-run summary
+                                    logging.info("=" * 50)
+                                    logging.info("🎯 DRY-RUN SUMMARY")
+                                    logging.info("=" * 50)
+                                    logging.info(
+                                        f"✅ Database: {setup_type} ({'cluster' if cluster_api_enabled else 'standalone'}) started locally"
+                                    )
+                                    logging.info(
+                                        f"✅ Client tools: {benchmark_tool} available"
+                                    )
+                                    logging.info(
+                                        f"{'✅' if connectivity_success else '❌'} Connectivity: {len(redis_conns)} connection(s) tested"
+                                    )
+                                    if args.dry_run_with_preload:
+                                        logging.info(
+                                            "✅ Data preload: Completed during setup"
+                                        )
+                                    logging.info("🏁 Dry-run completed successfully")
+                                    logging.info(
+                                        "⏭️  Benchmark execution skipped (dry-run mode)"
+                                    )
+                                    logging.info("=" * 50)
+
+                                    # Skip benchmark execution and continue to next test
+                                else:
+                                    stdout, stderr = run_local_benchmark(
+                                        benchmark_tool, command
+                                    )
                                 benchmark_end_time = datetime.datetime.now()
                                 redisbench_admin.run.metrics.BENCHMARK_RUNNING_GLOBAL = (
                                     False
@@ -364,10 +417,10 @@ def run_local_command_logic(args, project_name, project_version):
                                         benchmark_end_time, benchmark_start_time
                                     )
                                 )
-
-                                logging.info("Extracting the benchmark results")
-                                logging.info("stdout: {}".format(stdout))
-                                logging.info("stderr: {}".format(stderr))
+                                if args.dry_run is False:
+                                    logging.info("Extracting the benchmark results")
+                                    logging.info("stdout: {}".format(stdout))
+                                    logging.info("stderr: {}".format(stderr))
 
                                 (
                                     _,
@@ -420,53 +473,54 @@ def run_local_command_logic(args, project_name, project_version):
                                         test_name,
                                         tf_triggering_env,
                                     )
-
-                                post_process_benchmark_results(
-                                    benchmark_tool,
-                                    local_benchmark_output_filename,
-                                    start_time_ms,
-                                    start_time_str,
-                                    stdout,
-                                )
                                 results_dict = {}
-                                with open(
-                                    local_benchmark_output_filename, "r"
-                                ) as json_file:
-                                    results_dict = json.load(json_file)
-                                    print_results_table_stdout(
-                                        benchmark_config,
-                                        default_metrics,
-                                        results_dict,
-                                        setup_name,
-                                        setup_type,
-                                        test_name,
-                                        total_shards_cpu_usage,
-                                        overall_end_time_metrics,
-                                        [
-                                            "memory_used_memory",
-                                            "memory_used_memory_dataset",
-                                        ],
-                                    )
-                                    export_redis_metrics(
-                                        artifact_version,
-                                        end_time_ms,
-                                        overall_end_time_metrics,
-                                        rts,
-                                        setup_name,
-                                        setup_type,
-                                        test_name,
-                                        tf_github_branch,
-                                        tf_github_org,
-                                        tf_github_repo,
-                                        tf_triggering_env,
-                                        {"metric-type": "redis-metrics"},
-                                        0,
+                                if args.dry_run is False:
+                                    post_process_benchmark_results(
+                                        benchmark_tool,
+                                        local_benchmark_output_filename,
+                                        start_time_ms,
+                                        start_time_str,
+                                        stdout,
                                     )
 
-                                    # check KPIs
-                                    return_code = results_dict_kpi_check(
-                                        benchmark_config, results_dict, return_code
-                                    )
+                                    with open(
+                                        local_benchmark_output_filename, "r"
+                                    ) as json_file:
+                                        results_dict = json.load(json_file)
+                                        print_results_table_stdout(
+                                            benchmark_config,
+                                            default_metrics,
+                                            results_dict,
+                                            setup_name,
+                                            setup_type,
+                                            test_name,
+                                            total_shards_cpu_usage,
+                                            overall_end_time_metrics,
+                                            [
+                                                "memory_used_memory",
+                                                "memory_used_memory_dataset",
+                                            ],
+                                        )
+                                        export_redis_metrics(
+                                            artifact_version,
+                                            end_time_ms,
+                                            overall_end_time_metrics,
+                                            rts,
+                                            setup_name,
+                                            setup_type,
+                                            test_name,
+                                            tf_github_branch,
+                                            tf_github_org,
+                                            tf_github_repo,
+                                            tf_triggering_env,
+                                            {"metric-type": "redis-metrics"},
+                                            0,
+                                        )
+
+                                        # check KPIs
+                                        return_code = results_dict_kpi_check(
+                                            benchmark_config, results_dict, return_code
+                                        )
 
                                 metadata_tags = get_metadata_tags(benchmark_config)
                                 (
@@ -508,7 +562,10 @@ def run_local_command_logic(args, project_name, project_version):
                                     "Some unexpected exception was caught "
                                     "during local work. Failing test...."
                                 )
-                                logging.critical(sys.exc_info()[0])
+                                if len(sys.exc_info()) > 0:
+                                    logging.critical(sys.exc_info()[0])
+                                else:
+                                    logging.critical(sys.exc_info())
                                 print("-" * 60)
                                 traceback.print_exc(file=sys.stdout)
                                 print("-" * 60)

redisbench_admin/run_remote/args.py

@@ -112,6 +112,18 @@ def create_run_remote_arguments(parser):
         action="store_true",
         help="skip environment variables check",
     )
+    parser.add_argument(
+        "--dry-run",
+        default=False,
+        action="store_true",
+        help="Setup environment and test connectivity without running benchmarks",
+    )
+    parser.add_argument(
+        "--dry-run-with-preload",
+        default=False,
+        action="store_true",
+        help="Setup environment, preload data, and test connectivity without running benchmarks",
+    )
     parser.add_argument(
         "--continue-on-module-check-error",
         default=False,

redisbench_admin/run_remote/remote_db.py

@@ -406,9 +406,17 @@ def db_error_artifacts(
     upload_s3,
     username,
 ):
+    # Import the zip check function
+    from redisbench_admin.run_remote.standalone import ensure_zip_available
+
+    # Ensure zip is available before trying to use it
+    ensure_zip_available(server_public_ip, username, private_key, db_ssh_port)
+
     local_zipfile = "{}.zip".format(logname)
     remote_zipfile = "/home/{}/{}".format(username, local_zipfile)
-    execute_remote_commands(
+
+    # Create zip file
+    zip_result = execute_remote_commands(
         server_public_ip,
         username,
         private_key,
@@ -417,26 +425,57 @@ def db_error_artifacts(
         ],
         db_ssh_port,
     )
-    failed_remote_run_artifact_store(
-        upload_s3,
-        server_public_ip,
-        dirname,
-        remote_zipfile,
-        local_zipfile,
-        s3_bucket_name,
-        s3_bucket_path,
-        username,
-        private_key,
-    )
+
+    # Check if zip creation was successful
+    zip_success = True
+    for pos, res_pos in enumerate(zip_result):
+        [recv_exit_status, stdout, stderr] = res_pos
+        if recv_exit_status != 0:
+            logging.warning(
+                "Zip creation failed with exit code {}. stdout: {}. stderr: {}".format(
+                    recv_exit_status, stdout, stderr
+                )
+            )
+            zip_success = False
+
+    # Only try to upload if zip was created successfully
+    if zip_success:
+        try:
+            failed_remote_run_artifact_store(
+                upload_s3,
+                server_public_ip,
+                dirname,
+                remote_zipfile,
+                local_zipfile,
+                s3_bucket_name,
+                s3_bucket_path,
+                username,
+                private_key,
+            )
+        except Exception as e:
+            logging.warning(
+                "Failed to upload zip file to S3: {}. Continuing without upload.".format(
+                    e
+                )
+            )
+    else:
+        logging.warning("Skipping S3 upload due to zip creation failure")
     if len(full_logfiles) > 0:
-        failed_remote_run_artifact_store(
-            upload_s3,
-            server_public_ip,
-            dirname,
-            full_logfiles[0],
-            logname,
-            s3_bucket_name,
-            s3_bucket_path,
-            username,
-            private_key,
-        )
+        try:
+            failed_remote_run_artifact_store(
+                upload_s3,
+                server_public_ip,
+                dirname,
+                full_logfiles[0],
+                logname,
+                s3_bucket_name,
+                s3_bucket_path,
+                username,
+                private_key,
+            )
+        except Exception as e:
+            logging.warning(
+                "Failed to upload logfile to S3: {}. Continuing without upload.".format(
+                    e
+                )
+            )

redisbench_admin/run_remote/remote_helpers.py

@@ -71,6 +71,23 @@ def remote_tool_pre_bench_step(
     logging.info(
         f"Settting up remote tool {benchmark_tool} requirements. architecture ={architecture}"
     )
+
+    # Check and install benchmark tools if needed
+    if benchmark_tool == "memtier_benchmark":
+        from redisbench_admin.run_remote.standalone import (
+            ensure_memtier_benchmark_available,
+        )
+
+        ensure_memtier_benchmark_available(
+            client_public_ip, username, private_key, client_ssh_port
+        )
+    elif benchmark_tool == "redis-benchmark":
+        from redisbench_admin.run_remote.standalone import ensure_redis_server_available
+
+        # redis-benchmark comes with redis-server, so ensure redis-server is installed
+        ensure_redis_server_available(
+            client_public_ip, username, private_key, client_ssh_port
+        )
     if benchmark_tool == "redisgraph-benchmark-go":
         setup_remote_benchmark_tool_redisgraph_benchmark_go(
             client_public_ip,

redisbench_admin/run_remote/run_remote.py

@@ -69,6 +69,7 @@ from redisbench_admin.utils.remote import (
     get_project_ts_tags,
     push_data_to_redistimeseries,
     fetch_remote_id_from_config,
+    perform_connectivity_test,
 )
 
 from redisbench_admin.utils.utils import (
@@ -161,7 +162,24 @@ def run_remote_command_logic(args, project_name, project_version):
         )
         webhook_client_slack = WebhookClient(webhook_url)
 
-    if args.skip_env_vars_verify is False:
+    # Only check AWS credentials when actually needed
+    needs_aws_for_infrastructure = (
+        args.inventory is None
+    )  # No inventory = need to deploy with Terraform
+    needs_aws_for_s3 = args.upload_results_s3  # S3 upload enabled
+
+    if args.skip_env_vars_verify is False and (
+        needs_aws_for_infrastructure or needs_aws_for_s3
+    ):
+        # Log why AWS credentials are being checked
+        aws_reasons = []
+        if needs_aws_for_infrastructure:
+            aws_reasons.append("infrastructure deployment (no --inventory provided)")
+        if needs_aws_for_s3:
+            aws_reasons.append("S3 upload (--upload_results_s3 enabled)")
+
+        logging.info("AWS credentials required for: {}".format(", ".join(aws_reasons)))
+
         env_check_status, failure_reason = check_ec2_env()
         if env_check_status is False:
             if webhook_notifications_active:
@@ -177,6 +195,10 @@ def run_remote_command_logic(args, project_name, project_version):
                 )
             logging.critical("{}. Exiting right away!".format(failure_reason))
             exit(1)
+    elif args.skip_env_vars_verify is False:
+        logging.info(
+            "AWS credentials check skipped (using --inventory and S3 upload disabled)"
+        )
 
     continue_on_module_check_error = args.continue_on_module_check_error
     module_check_status, error_message = redis_modules_check(local_module_files)
@@ -674,6 +696,62 @@ def run_remote_command_logic(args, project_name, project_version):
                                                 )
                                             )
 
+                                    # Handle dry-run modes
+                                    if args.dry_run or args.dry_run_with_preload:
+                                        logging.info(
+                                            "🏃 Dry-run mode detected - performing connectivity tests"
+                                        )
+
+                                        # Test basic connectivity after setup
+                                        connectivity_success = (
+                                            perform_connectivity_test(
+                                                redis_conns, "after environment setup"
+                                            )
+                                        )
+
+                                        if args.dry_run_with_preload:
+                                            logging.info(
+                                                "📦 Dry-run with preload - data loading already completed during setup"
+                                            )
+                                            # Test connectivity after preload (data was loaded during remote_db_spin)
+                                            connectivity_success = (
+                                                perform_connectivity_test(
+                                                    redis_conns, "after data preloading"
+                                                )
+                                                and connectivity_success
+                                            )
+
+                                        # Print dry-run summary
+                                        logging.info("=" * 50)
+                                        logging.info("🎯 DRY-RUN SUMMARY")
+                                        logging.info("=" * 50)
+                                        logging.info(
+                                            f"✅ Infrastructure: {'Deployed' if args.inventory is None else 'Using existing'}"
+                                        )
+                                        logging.info(
+                                            f"✅ Database: {setup_type} ({'cluster' if cluster_enabled else 'standalone'}) started"
+                                        )
+                                        logging.info(
+                                            f"✅ Client tools: Setup completed on {client_public_ip}"
+                                        )
+                                        logging.info(
+                                            f"{'✅' if connectivity_success else '❌'} Connectivity: {len(redis_conns)} connection(s) tested"
+                                        )
+                                        if args.dry_run_with_preload:
+                                            logging.info(
+                                                "✅ Data preload: Completed during setup"
+                                            )
+                                        logging.info(
+                                            "🏁 Dry-run completed successfully"
+                                        )
+                                        logging.info(
+                                            "⏭️  Benchmark execution skipped (dry-run mode)"
+                                        )
+                                        logging.info("=" * 50)
+
+                                        # Skip benchmark execution and continue to next test
+                                        continue
+
                                     logging.info(
                                         "Will store benchmark json output to local file {}".format(
                                             local_bench_fname