code: def test_autoscaler_shutdown_node_http_everynode(
      monkeypatch, shutdown_ray, call_ray_stop_only  # noqa: F811
  ):
      monkeypatch.setenv("RAY_SERVE_PROXY_MIN_DRAINING_PERIOD_S", "1")
      cluster = AutoscalingCluster(
          head_resources={"CPU": 4},
          worker_node_types={
              "cpu_node": {
                  "resources": {
                      "CPU": 4,
                      "IS_WORKER": 100,
                  },
                  "node_config": {},
                  "max_workers": 1,
              },
          },
          idle_timeout_minutes=0.05,
      )
      cluster.start()
      ray.init(address="auto")
  
      serve.start(http_options={"location": "EveryNode"})
  
      @serve.deployment(
          num_replicas=2,
          ray_actor_options={"num_cpus": 3},
      )
      class A:
          def __call__(self, *args):
              return "hi"
  
      serve.run(A.bind(), name="app_f")
  
      # 2 proxies, 1 controller, 2 replicas.
      wait_for_condition(lambda: len(ray._private.state.actors()) == 5)
      assert len(ray.nodes()) == 2
  
      # Stop all deployment replicas.
      serve.delete("app_f")
  
      # The http proxy on worker node should exit as well.
      wait_for_condition(
          lambda: len(
              list(
                  filter(
                      lambda a: a["State"] == "ALIVE",
                      ray._private.state.actors().values(),
                  )
              )
          )
          == 2
      )
      client = _get_global_client()
      serve_details = ServeInstanceDetails(
          **ray.get(
              client._controller.get_serve_instance_details.remote()
          )
      )
      assert len(serve_details.proxies) == 1
      assert (
          serve_details.proxies[get_head_node_id()].status
          == ProxyStatus.HEALTHY
      )
  
      # Only head node should exist now.
      wait_for_condition(
          lambda: len(list(filter(lambda n: n["Alive"], ray.nodes())))
          == 1
      )
  
      # Clean up serve.
      serve.shutdown()
  
imports: import os
  import subprocess
  import sys
  from contextlib import contextmanager
  from tempfile import NamedTemporaryFile
  import pytest
  import requests
  import ray
  import ray._private.state
  import ray.actor
  from ray import serve
  from ray._private.test_utils import SignalActor, wait_for_condition
  from ray.cluster_utils import AutoscalingCluster, Cluster
  from ray.exceptions import RayActorError
  from ray.serve._private.common import ProxyStatus
  from ray.serve._private.constants import SERVE_DEFAULT_APP_NAME
  from ray.serve._private.logging_utils import get_serve_logs_dir
  from ray.serve._private.utils import get_head_node_id
  from ray.serve.context import _get_global_client
  from ray.serve.schema import ServeInstanceDetails
  from ray.tests.conftest import call_ray_stop_only
label_desc: Use image node_id 8 for calling a global function with example usage: test_autoscaler_shutdown_node_http_everynode(monkeypatch, shutdown_ray, call_ray_stop_only) and returns: str