redisbench-admin 0.11.39__py3-none-any.whl → 0.11.41__py3-none-any.whl

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)
@@ -687,17 +744,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/args.py

@@ -112,11 +112,43 @@ 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,
         action="store_true",
         help="Continue running benchmarks even if module check failed",
     )
+    parser.add_argument(
+        "--redis-conf",
+        required=False,
+        default=None,
+        type=str,
+        help="Path to custom redis.conf file to copy to remote host",
+    )
+    parser.add_argument(
+        "--redis-server-binary",
+        required=False,
+        default=None,
+        type=str,
+        help="Path to custom redis-server binary to copy to remote host",
+    )
+    parser.add_argument(
+        "--spin-test",
+        default=False,
+        action="store_true",
+        help="Setup standalone Redis server, run INFO SERVER, print output as markdown and exit",
+    )
 
     return parser

redisbench_admin/run_remote/remote_helpers.py

@@ -106,7 +106,11 @@ def remote_tool_pre_bench_step(
         )
 
     if "ftsb_" in benchmark_tool:
-        (queries_file_link, remote_tool_link, tool_link,) = extract_ftsb_extra_links(
+        (
+            queries_file_link,
+            remote_tool_link,
+            tool_link,
+        ) = extract_ftsb_extra_links(
             benchmark_config, benchmark_tool, config_key, architecture
         )
         logging.info(

redisbench_admin/run_remote/run_remote.py

@@ -51,6 +51,7 @@ from redisbench_admin.run_remote.remote_db import (
     remote_db_spin,
     db_error_artifacts,
 )
+from redisbench_admin.run_remote.standalone import spin_test_standalone_redis
 from redisbench_admin.run_remote.remote_env import remote_env_setup
 from redisbench_admin.run_remote.remote_failures import failed_remote_run_artifact_store
 from redisbench_admin.run_remote.terraform import (
@@ -69,6 +70,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 (
@@ -121,12 +123,15 @@ def run_remote_command_logic(args, project_name, project_version):
     tf_setup_name_sufix = "{}-{}".format(args.setup_name_sufix, tf_github_sha)
     s3_bucket_name = args.s3_bucket_name
     local_module_files = args.module_path
-    for pos, module_file in enumerate(local_module_files):
-        if " " in module_file:
-            logging.info(
-                "Detected multiple files in single module path {}".format(module_file)
-            )
-            local_module_files[pos] = module_file.split(" ")
+    if local_module_files is not None:
+        for pos, module_file in enumerate(local_module_files):
+            if " " in module_file:
+                logging.info(
+                    "Detected multiple files in single module path {}".format(
+                        module_file
+                    )
+                )
+                local_module_files[pos] = module_file.split(" ")
     dbdir_folder = args.dbdir_folder
     private_key = args.private_key
     grafana_profile_dashboard = args.grafana_profile_dashboard
@@ -237,6 +242,50 @@ def run_remote_command_logic(args, project_name, project_version):
 
     ssh_pem_check(EC2_PRIVATE_PEM, private_key)
 
+    # Handle spin-test mode
+    if args.spin_test:
+        logging.info(
+            "🚀 Spin-test mode detected - setting up standalone Redis and running INFO SERVER"
+        )
+
+        # Parse inventory to get server details
+        if args.inventory is None:
+            logging.error(
+                "❌ --spin-test requires --inventory to specify the remote server"
+            )
+            exit(1)
+
+        # Parse inventory string
+        inventory_parts = args.inventory.split(",")
+        server_public_ip = None
+
+        for part in inventory_parts:
+            if "=" in part:
+                key, value = part.split("=", 1)
+                if key.strip() == "server_public_ip":
+                    server_public_ip = value.strip()
+                    break
+
+        if server_public_ip is None:
+            logging.error("❌ --spin-test requires server_public_ip in --inventory")
+            exit(1)
+
+        # Run spin test
+        success = spin_test_standalone_redis(
+            server_public_ip=server_public_ip,
+            username=args.user,
+            private_key=private_key,
+            db_ssh_port=args.db_ssh_port,
+            redis_port=args.db_port,
+            local_module_files=local_module_files,
+            redis_configuration_parameters=None,
+            modules_configuration_parameters_map=None,
+            custom_redis_conf_path=args.redis_conf,
+            custom_redis_server_path=args.redis_server_binary,
+        )
+
+        exit(0 if success else 1)
+
     (
         benchmark_defs_result,
         benchmark_definitions,
@@ -695,6 +744,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
@@ -1429,20 +1534,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):