code: def main(
      min_replicas: Optional[int],
      max_replicas: Optional[int],
      num_deployments: Optional[int],
      trial_length: Optional[str],
  ):
      # Give default cluster parameter values based on smoke_test config
      # if user provided values explicitly, use them instead.
      # IS_SMOKE_TEST is set by args of releaser's e2e.py
      if is_smoke_test():
          min_replicas = (
              min_replicas or DEFAULT_SMOKE_TEST_MIN_NUM_REPLICA
          )
          max_replicas = (
              max_replicas or DEFAULT_SMOKE_TEST_MAX_NUM_REPLICA
          )
          num_deployments = (
              num_deployments or DEFAULT_SMOKE_TEST_NUM_DEPLOYMENTS
          )
          trial_length = trial_length or DEFAULT_SMOKE_TEST_TRIAL_LENGTH
          logger.info(
              f"Running smoke test with min {min_replicas} and max "
              f"{max_replicas} replicas, {num_deployments} deployments "
              f".. \n"
          )
          # Choose cluster setup based on user config. Local test uses Cluster()
          # to mock actors that requires # of nodes to be specified, but ray
          # client doesn't need to
          num_nodes = int(math.ceil(max_replicas / NUM_CPU_PER_NODE))
          logger.info(
              f"Setting up local ray cluster with {num_nodes} nodes .. \n"
          )
          serve_client = setup_local_single_node_cluster(num_nodes)[0]
      else:
          min_replicas = (
              min_replicas or DEFAULT_FULL_TEST_MIN_NUM_REPLICA
          )
          max_replicas = (
              max_replicas or DEFAULT_FULL_TEST_MAX_NUM_REPLICA
          )
          num_deployments = (
              num_deployments or DEFAULT_FULL_TEST_NUM_DEPLOYMENTS
          )
          trial_length = trial_length or DEFAULT_FULL_TEST_TRIAL_LENGTH
          logger.info(
              f"Running full test with min {min_replicas} and max "
              f"{max_replicas} replicas, {num_deployments} deployments "
              f".. \n"
          )
          logger.info("Setting up anyscale ray cluster .. \n")
          serve_client = setup_anyscale_cluster()
  
      http_host = str(serve_client._http_config.host)
      http_port = str(serve_client._http_config.port)
      logger.info(
          f"Ray serve http_host: {http_host}, http_port: {http_port}"
      )
  
      logger.info(
          f"Deploying with min {min_replicas} and max {max_replicas}"
          f"target replicas ....\n"
      )
      all_endpoints = setup_multi_deployment_replicas(
          min_replicas, max_replicas, num_deployments
      )
  
      logger.info("Warming up cluster ....\n")
      endpoint_refs = []
      for endpoint in all_endpoints:
          endpoint_refs.append(
              warm_up_one_cluster.options(num_cpus=0).remote(
                  10, http_host, http_port, endpoint
              )
          )
      for endpoint in ray.get(endpoint_refs):
          logger.info(f"Finished warming up {endpoint}")
  
      logger.info(
          f"Starting wrk trial on all nodes for {trial_length} ....\n"
      )
      # For detailed discussion, see https://github.com/wg/wrk/issues/205
      # TODO:(jiaodong) What's the best number to use here ?
      all_metrics, all_wrk_stdout = run_wrk_on_all_nodes(
          trial_length,
          NUM_CONNECTIONS,
          http_host,
          http_port,
          all_endpoints=all_endpoints,
          debug=True,
      )
  
      aggregated_metrics = aggregate_all_metrics(all_metrics)
      logger.info("Wrk stdout on each node: ")
      for wrk_stdout in all_wrk_stdout:
          logger.info(wrk_stdout)
      logger.info("Final aggregated metrics: ")
      for key, val in aggregated_metrics.items():
          logger.info(f"{key}: {val}")
      save_test_results(
          aggregated_metrics,
          default_output_file="/tmp/autoscaling_multi_deployment.json",
      )
  
file_path: ray/release/serve_tests/workloads/autoscaling_multi_deployment.py
imports: import click
  import logging
  import math
  import random
  from typing import Optional
  from starlette.requests import Request
  import ray
  from ray import serve
  from serve_test_utils import aggregate_all_metrics, run_wrk_on_all_nodes, save_test_results, is_smoke_test
  from serve_test_cluster_utils import setup_local_single_node_cluster, setup_anyscale_cluster, warm_up_one_cluster, NUM_CPU_PER_NODE, NUM_CONNECTIONS
label_desc: Use image node_id 2 for calling a global function with example usage: main(min_replicas, max_replicas, num_deployments, trial_length) without return types