entrypoints/cli/serve.py: the vllm serve subcommand and its launch modes

    def cmd(args: argparse.Namespace) -> None:
        # If model is specified in CLI (as positional arg), it takes precedence
        if hasattr(args, "model_tag") and args.model_tag is not None:
            args.model = args.model_tag

        if getattr(args, "grpc", False):
            from vllm.entrypoints.launchers.grpc_server import serve_grpc

            uvloop.run(serve_grpc(args))
            return

        rust_frontend_path = (
            envs.VLLM_RUST_FRONTEND_PATH if envs.VLLM_USE_RUST_FRONTEND else None
        )

        if args.headless:
            if args.api_server_count is not None and args.api_server_count > 0:
                raise ValueError(
                    f"--api-server-count={args.api_server_count} cannot be "
                    "used with --headless (no API servers are started in "
                    "headless mode)."
                )
            # Default to 0 in headless mode (no API servers)
            args.api_server_count = 0

        # Detect LB mode for defaulting api_server_count.
        # Multi-port: --data-parallel-multi-port-external-lb
        # External LB: --data-parallel-external-lb or --data-parallel-rank
        # Hybrid LB: --data-parallel-hybrid-lb or --data-parallel-start-rank
        is_external_lb = (
            args.data_parallel_external_lb or args.data_parallel_rank is not None
        )

        # If --data_parallel_multi_port_external_lb and --data_parallel_hybrid_lb
        # are unset, default to hybrid if --data-parallel-start-rank is set
        is_hybrid_lb = is_multi_port = False
        if (
            not args.data_parallel_hybrid_lb
            and not args.data_parallel_multi_port_external_lb
        ):
            is_hybrid_lb = args.data_parallel_start_rank is not None
        else:
            is_hybrid_lb = args.data_parallel_hybrid_lb
            is_multi_port = args.data_parallel_multi_port_external_lb

        if sum([is_multi_port, is_external_lb, is_hybrid_lb]) > 1:
            raise ValueError(
                "Cannot use more than one data parallel load balancing mode. "
                "Choose one of: --data-parallel-multi-port-external-lb, "
                "--data-parallel-external-lb (or --data-parallel-rank), "
                "--data-parallel-hybrid-lb (or --data-parallel-start-rank)."
            )

        if args.api_server_count is None:
            if is_multi_port or is_external_lb or rust_frontend_path:
                args.api_server_count = 1
            elif is_hybrid_lb:
                args.api_server_count = args.data_parallel_size_local or 1
                if args.api_server_count > 1:
                    logger.info(
                        "Defaulting api_server_count to data_parallel_size_local "
                        "(%d) for hybrid LB mode.",
                        args.api_server_count,
                    )
            else:
                args.api_server_count = args.data_parallel_size
                if args.api_server_count > 1:
                    logger.info(
                        "Defaulting api_server_count to data_parallel_size (%d).",
                        args.api_server_count,
                    )
        elif rust_frontend_path and args.api_server_count > 1:
            logger.warning(
                "Ignoring --api-server-count=%d when using rust front-end process",
                args.api_server_count,
            )
            args.api_server_count = 1

        # Elastic EP currently only supports running with at most one API server.
        if getattr(args, "enable_elastic_ep", False) and args.api_server_count > 1:
            logger.warning(
                "Elastic EP only supports running with with at most one API server. "
                "Capping api_server_count from %d to 1.",
                args.api_server_count,
            )
            args.api_server_count = 1

        if is_multi_port:
            run_dp_supervisor(args)
        elif args.api_server_count < 1:
            run_headless(args)
        elif args.api_server_count > 1 or rust_frontend_path:
            run_multi_api_server(args)
        else:
            # Single API server (this process).
            args.api_server_count = None
            uvloop.run(run_server(args))

def run_headless(args: argparse.Namespace):
    if args.api_server_count > 1:
        raise ValueError("api_server_count can't be set in headless mode")

    if args.reasoning_parser_plugin and len(args.reasoning_parser_plugin) > 3:
        ReasoningParserManager.import_reasoning_parser(args.reasoning_parser_plugin)

    # Create the EngineConfig.
    engine_args = vllm.AsyncEngineArgs.from_cli_args(args)
    propagate_flash_late_interaction(args, engine_args)
    usage_context = UsageContext.OPENAI_API_SERVER
    vllm_config = engine_args.create_engine_config(
        usage_context=usage_context, headless=True
    )

    if engine_args.data_parallel_hybrid_lb:
        raise ValueError("data_parallel_hybrid_lb is not applicable in headless mode")

    parallel_config = vllm_config.parallel_config
    local_engine_count = parallel_config.data_parallel_size_local

    if local_engine_count <= 0:
        raise ValueError("data_parallel_size_local must be > 0 in headless mode")

    shutdown_requested = False

    # Catch SIGTERM and SIGINT to allow graceful shutdown.
    def signal_handler(signum, frame):
        nonlocal shutdown_requested
        logger.debug("Received %d signal.", signum)
        if not shutdown_requested:
            shutdown_requested = True
            raise SystemExit

    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)

    if parallel_config.node_rank_within_dp > 0:
        from vllm.version import __version__ as VLLM_VERSION

        # Run headless workers (for multi-node PP/TP).
        host = parallel_config.master_addr
        head_node_address = f"{host}:{parallel_config.master_port}"
        logger.info(
            "Launching vLLM (v%s) headless multiproc executor, "
            "with head node address %s for torch.distributed process group.",
            VLLM_VERSION,
            head_node_address,
        )

        executor = MultiprocExecutor(vllm_config, monitor_workers=False)
        executor.start_worker_monitor(inline=True)
        return

    if num_api_servers > 1:
        setup_multiprocess_prometheus()

    shutdown_requested = False

    # Catch SIGTERM and SIGINT to allow graceful shutdown.
    def signal_handler(signum, frame):
        nonlocal shutdown_requested
        logger.debug("Received %d signal.", signum)
        if not shutdown_requested:
            shutdown_requested = True
            raise SystemExit

    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)

    listen_address, sock = setup_server(args, reuse_port=num_api_servers > 1)
    # `--grpc-port` is only accepted for the Rust frontend, which inherits this
    # listener like the HTTP one. gRPC follows the HTTP TCP host, or IPv4
    # loopback when HTTP uses a Unix socket.
    grpc_sock = None
    if args.grpc_port is not None:
        grpc_host = "127.0.0.1" if args.uds else (args.host or "")
        grpc_sock = create_server_socket((grpc_host, args.grpc_port), reuse_port=False)

    engine_args = vllm.AsyncEngineArgs.from_cli_args(args)
    propagate_flash_late_interaction(args, engine_args)
    engine_args._api_process_count = num_api_servers
    engine_args._api_process_rank = -1

    usage_context = UsageContext.OPENAI_API_SERVER
    vllm_config = engine_args.create_engine_config(usage_context=usage_context)

    if num_api_servers > 1 and envs.VLLM_ALLOW_RUNTIME_LORA_UPDATING:
        raise ValueError(
            "VLLM_ALLOW_RUNTIME_LORA_UPDATING cannot be used with api_server_count > 1"
        )

    from vllm.v1.engine.utils import bind_engine_zmq_listeners

    zmq_listeners = bind_engine_zmq_listeners(vllm_config, num_api_servers)
    addresses = zmq_listeners.addresses

    with launch_core_engines(
        vllm_config, executor_class, log_stats, addresses
    ) as engine_launch:
        local_engine_manager = engine_launch.engine_manager
        coordinator = engine_launch.coordinator
        addresses = engine_launch.addresses
        stats_update_address = (
            coordinator.get_stats_publish_address() if coordinator else None
        )

        if rust_frontend_path:
            if parallel_config.local_engines_only:
                expected_engine_start_index = parallel_config.data_parallel_rank
                expected_engine_count = parallel_config.data_parallel_size_local
            else:
                expected_engine_start_index = 0
                expected_engine_count = parallel_config.data_parallel_size
            # Start rust front-end process.
            api_server_manager = RustFrontendProcessManager(
                binary_path=rust_frontend_path,
                sock=sock,
                grpc_sock=grpc_sock,
                args=args,
                input_listener=zmq_listeners.inputs[0],
                output_listener=zmq_listeners.outputs[0],
                engine_start_index=expected_engine_start_index,
                engine_count=expected_engine_count,
                data_parallel_size=parallel_config.data_parallel_size,
                stats_update_address=stats_update_address,
            )
        else:
            # Start API server(s).
            api_server_manager = APIServerProcessManager(
                listen_address=listen_address,
                sock=sock,
                args=args,
                num_servers=num_api_servers,
                input_listeners=zmq_listeners.inputs,
                output_listeners=zmq_listeners.outputs,
                stats_update_address=stats_update_address,
                tensor_queue=engine_launch.tensor_queue,
            )

        # Set frontend processes to watch during engine startup.
        # If any of these processes exit before the engines are up, the engine startup
        # will be aborted with an error.
        engine_launch.watched_frontend_processes = api_server_manager.processes

    # Wait for API servers.
    try:
        wait_for_completion_or_failure(
            api_server_manager=api_server_manager,
            engine_manager=local_engine_manager,
            coordinator=coordinator,
        )