wehub-resource-sync
664 lines
24 KiB
Python
664 lines
24 KiB
Python
import asyncio
|
|
import io
|
|
import logging
|
|
import os
|
|
import sys
|
|
import time
|
|
from typing import Dict
|
|
from unittest.mock import MagicMock
|
|
|
|
import pytest
|
|
|
|
import ray
|
|
import ray.serve._private.long_poll as long_poll_module
|
|
from ray._common.test_utils import async_wait_for_condition, wait_for_condition
|
|
from ray._common.utils import get_or_create_event_loop
|
|
from ray.serve._private.common import (
|
|
DeploymentID,
|
|
DeploymentTargetInfo,
|
|
EndpointInfo,
|
|
ReplicaID,
|
|
RunningReplicaInfo,
|
|
)
|
|
from ray.serve._private.long_poll import (
|
|
LongPollClient,
|
|
LongPollHost,
|
|
LongPollNamespace,
|
|
LongPollState,
|
|
UpdatedObject,
|
|
_get_metric_namespace_tag,
|
|
)
|
|
from ray.serve.generated.serve_pb2 import (
|
|
DeploymentTargetInfo as DeploymentTargetInfoProto,
|
|
EndpointSet,
|
|
LongPollRequest,
|
|
LongPollResult,
|
|
)
|
|
|
|
|
|
def test_notifier_events_cleared_without_update(serve_instance):
|
|
"""Verify that notifier events are not leaked.
|
|
|
|
Previously, events were leaked if there were timeouts and no updates on the key.
|
|
"""
|
|
host = ray.remote(LongPollHost).remote(
|
|
listen_for_change_request_timeout_s=(0.1, 0.1)
|
|
)
|
|
ray.get(host.notify_changed.remote({"key_1": 999}))
|
|
|
|
# Get an initial object snapshot for the key.
|
|
object_ref = host.listen_for_change.remote({"key_1": -1})
|
|
result: Dict[str, UpdatedObject] = ray.get(object_ref)
|
|
assert set(result.keys()) == {"key_1"}
|
|
assert {v.object_snapshot for v in result.values()} == {999}
|
|
new_snapshot_ids = {k: v.snapshot_id for k, v in result.items()}
|
|
|
|
# Listen for changes -- this should time out without an update.
|
|
object_ref = host.listen_for_change.remote(new_snapshot_ids)
|
|
assert ray.get(object_ref) == LongPollState.TIME_OUT
|
|
|
|
# Verify that the `asyncio.Event` used for the `listen_for_change` task
|
|
# is removed.
|
|
assert ray.get(host._get_num_notifier_events.remote()) == 0
|
|
|
|
|
|
def test_host_standalone(serve_instance):
|
|
host = ray.remote(LongPollHost).remote()
|
|
|
|
# Write two values
|
|
ray.get(host.notify_changed.remote({"key_1": 999}))
|
|
ray.get(host.notify_changed.remote({"key_2": 999}))
|
|
object_ref = host.listen_for_change.remote({"key_1": -1, "key_2": -1})
|
|
|
|
# We should be able to get the result immediately
|
|
result: Dict[str, UpdatedObject] = ray.get(object_ref)
|
|
assert set(result.keys()) == {"key_1", "key_2"}
|
|
assert {v.object_snapshot for v in result.values()} == {999}
|
|
|
|
# Now try to pull it again, nothing should happen
|
|
# because we have the updated snapshot_id
|
|
new_snapshot_ids = {k: v.snapshot_id for k, v in result.items()}
|
|
object_ref = host.listen_for_change.remote(new_snapshot_ids)
|
|
_, not_done = ray.wait([object_ref], timeout=0.2)
|
|
assert len(not_done) == 1
|
|
|
|
# Now update the value, we should immediately get updated value
|
|
ray.get(host.notify_changed.remote({"key_2": 999}))
|
|
result = ray.get(object_ref)
|
|
assert len(result) == 1
|
|
assert "key_2" in result
|
|
|
|
|
|
def test_long_poll_wait_for_keys(serve_instance):
|
|
# Variation of the basic case, but the keys are requests before any values
|
|
# are set.
|
|
host = ray.remote(LongPollHost).remote()
|
|
object_ref = host.listen_for_change.remote({"key_1": -1, "key_2": -1})
|
|
|
|
ray.get(host.notify_changed.remote({"key_1": 123, "key_2": 456}))
|
|
|
|
# We should be able to get the both results immediately
|
|
result: Dict[str, UpdatedObject] = ray.get(object_ref)
|
|
assert result.keys() == {"key_1", "key_2"}
|
|
assert {v.object_snapshot for v in result.values()} == {123, 456}
|
|
|
|
|
|
def test_long_poll_restarts(serve_instance):
|
|
@ray.remote(
|
|
max_restarts=-1,
|
|
max_task_retries=-1,
|
|
)
|
|
class RestartableLongPollHost:
|
|
def __init__(self) -> None:
|
|
print("actor started")
|
|
self.host = LongPollHost()
|
|
self.host.notify_changed({"timer": time.time()})
|
|
self.should_exit = False
|
|
|
|
async def listen_for_change(self, key_to_ids):
|
|
print("listening for change ", key_to_ids)
|
|
return await self.host.listen_for_change(key_to_ids)
|
|
|
|
async def set_exit(self):
|
|
self.should_exit = True
|
|
|
|
async def exit_if_set(self):
|
|
if self.should_exit:
|
|
print("actor exit")
|
|
os._exit(1)
|
|
|
|
host = RestartableLongPollHost.remote()
|
|
updated_values = ray.get(host.listen_for_change.remote({"timer": -1}))
|
|
timer: UpdatedObject = updated_values["timer"]
|
|
|
|
on_going_ref = host.listen_for_change.remote({"timer": timer.snapshot_id})
|
|
ray.get(host.set_exit.remote())
|
|
# This task should trigger the actor to exit.
|
|
# But the retried task will not because self.should_exit is false.
|
|
host.exit_if_set.remote()
|
|
|
|
# on_going_ref should return successfully with a differnt value.
|
|
new_timer: UpdatedObject = ray.get(on_going_ref)["timer"]
|
|
assert new_timer.snapshot_id != timer.snapshot_id + 1
|
|
assert new_timer.object_snapshot != timer.object_snapshot
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_client_callbacks(serve_instance):
|
|
host = ray.remote(LongPollHost).remote()
|
|
|
|
# Write two values
|
|
ray.get(host.notify_changed.remote({"key_1": 100}))
|
|
ray.get(host.notify_changed.remote({"key_2": 999}))
|
|
|
|
callback_results = dict()
|
|
|
|
def key_1_callback(result):
|
|
callback_results["key_1"] = result
|
|
|
|
def key_2_callback(result):
|
|
callback_results["key_2"] = result
|
|
|
|
_ = LongPollClient(
|
|
host,
|
|
{
|
|
"key_1": key_1_callback,
|
|
"key_2": key_2_callback,
|
|
},
|
|
call_in_event_loop=get_or_create_event_loop(),
|
|
client_id="test_client_callbacks",
|
|
)
|
|
|
|
await async_wait_for_condition(
|
|
lambda: callback_results == {"key_1": 100, "key_2": 999},
|
|
timeout=1,
|
|
)
|
|
|
|
ray.get(host.notify_changed.remote({"key_2": 1999}))
|
|
|
|
await async_wait_for_condition(
|
|
lambda: callback_results == {"key_1": 100, "key_2": 999},
|
|
timeout=1,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_client_threadsafe(serve_instance):
|
|
host = ray.remote(LongPollHost).remote()
|
|
ray.get(host.notify_changed.remote({"key_1": 100}))
|
|
|
|
e = asyncio.Event()
|
|
|
|
def key_1_callback(_):
|
|
e.set()
|
|
|
|
_ = LongPollClient(
|
|
host,
|
|
{
|
|
"key_1": key_1_callback,
|
|
},
|
|
call_in_event_loop=get_or_create_event_loop(),
|
|
client_id="test_client_threadsafe",
|
|
)
|
|
|
|
await e.wait()
|
|
|
|
|
|
def test_listen_for_change_java(serve_instance):
|
|
host = ray.remote(LongPollHost).remote()
|
|
ray.get(host.notify_changed.remote({"key_1": 999}))
|
|
request_1 = {"keys_to_snapshot_ids": {"key_1": -1}}
|
|
object_ref = host.listen_for_change_java.remote(
|
|
LongPollRequest(**request_1).SerializeToString()
|
|
)
|
|
result_1: bytes = ray.get(object_ref)
|
|
poll_result_1 = LongPollResult.FromString(result_1)
|
|
assert set(poll_result_1.updated_objects.keys()) == {"key_1"}
|
|
assert poll_result_1.updated_objects["key_1"].object_snapshot.decode() == "999"
|
|
request_2 = {"keys_to_snapshot_ids": {"ROUTE_TABLE": -1}}
|
|
endpoints: Dict[DeploymentID, EndpointInfo] = dict()
|
|
endpoints["deployment_name"] = EndpointInfo(route="/test/xlang/poll")
|
|
endpoints["deployment_name1"] = EndpointInfo(route="/test/xlang/poll1")
|
|
ray.get(host.notify_changed.remote({LongPollNamespace.ROUTE_TABLE: endpoints}))
|
|
object_ref_2 = host.listen_for_change_java.remote(
|
|
LongPollRequest(**request_2).SerializeToString()
|
|
)
|
|
result_2: bytes = ray.get(object_ref_2)
|
|
poll_result_2 = LongPollResult.FromString(result_2)
|
|
assert set(poll_result_2.updated_objects.keys()) == {"ROUTE_TABLE"}
|
|
endpoint_set = EndpointSet.FromString(
|
|
poll_result_2.updated_objects["ROUTE_TABLE"].object_snapshot
|
|
)
|
|
assert set(endpoint_set.endpoints.keys()) == {"deployment_name", "deployment_name1"}
|
|
assert endpoint_set.endpoints["deployment_name"].route == "/test/xlang/poll"
|
|
|
|
request_3 = {"keys_to_snapshot_ids": {"(DEPLOYMENT_TARGETS,deployment_name)": -1}}
|
|
replicas = [
|
|
RunningReplicaInfo(
|
|
replica_id=ReplicaID(
|
|
str(i), deployment_id=DeploymentID(name="deployment_name")
|
|
),
|
|
node_id="node_id",
|
|
node_ip="node_ip",
|
|
availability_zone="some-az",
|
|
actor_name=f"SERVE_REPLICA::default#deployment_name#{i}",
|
|
max_ongoing_requests=1,
|
|
)
|
|
for i in range(2)
|
|
]
|
|
ray.get(
|
|
host.notify_changed.remote(
|
|
{
|
|
(
|
|
LongPollNamespace.DEPLOYMENT_TARGETS,
|
|
"deployment_name",
|
|
): DeploymentTargetInfo(is_available=True, running_replicas=replicas)
|
|
}
|
|
)
|
|
)
|
|
object_ref_3 = host.listen_for_change_java.remote(
|
|
LongPollRequest(**request_3).SerializeToString()
|
|
)
|
|
result_3: bytes = ray.get(object_ref_3)
|
|
poll_result_3 = LongPollResult.FromString(result_3)
|
|
da = DeploymentTargetInfoProto.FromString(
|
|
poll_result_3.updated_objects[
|
|
"(DEPLOYMENT_TARGETS,deployment_name)"
|
|
].object_snapshot
|
|
)
|
|
assert da.replica_names == [
|
|
"SERVE_REPLICA::default#deployment_name#0",
|
|
"SERVE_REPLICA::default#deployment_name#1",
|
|
]
|
|
|
|
|
|
def test_listen_for_change_java_timeout_returns_empty_result(serve_instance):
|
|
host = ray.remote(LongPollHost).remote(
|
|
listen_for_change_request_timeout_s=(0.5, 0.5)
|
|
)
|
|
ray.get(host.notify_changed.remote({"key_1": 999}))
|
|
|
|
initial_result = LongPollResult.FromString(
|
|
ray.get(
|
|
host.listen_for_change_java.remote(
|
|
LongPollRequest(keys_to_snapshot_ids={"key_1": -1}).SerializeToString()
|
|
)
|
|
)
|
|
)
|
|
snapshot_id = initial_result.updated_objects["key_1"].snapshot_id
|
|
|
|
timeout_result = LongPollResult.FromString(
|
|
ray.get(
|
|
host.listen_for_change_java.remote(
|
|
LongPollRequest(
|
|
keys_to_snapshot_ids={"key_1": snapshot_id}
|
|
).SerializeToString()
|
|
)
|
|
)
|
|
)
|
|
|
|
assert len(timeout_result.updated_objects) == 0
|
|
|
|
|
|
def test_get_metric_namespace_tag(monkeypatch):
|
|
"""Test _get_metric_namespace_tag in both default and compact modes.
|
|
|
|
When RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS is disabled (default), metric
|
|
tags use str(key) which preserves deployment-level granularity.
|
|
When enabled, tags use only the LongPollNamespace enum name to bound
|
|
cardinality for workloads with many deployments.
|
|
See https://github.com/ray-project/ray/issues/62299.
|
|
"""
|
|
# --- Default mode (compact=False): str(key) is used ---
|
|
monkeypatch.setattr(
|
|
long_poll_module, "RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS", False
|
|
)
|
|
|
|
# String keys pass through unchanged
|
|
assert _get_metric_namespace_tag("test_key") == "test_key"
|
|
|
|
# LongPollNamespace enum keys use str() representation
|
|
assert _get_metric_namespace_tag(LongPollNamespace.DEPLOYMENT_CONFIG) == str(
|
|
LongPollNamespace.DEPLOYMENT_CONFIG
|
|
)
|
|
|
|
# Tuple keys include the full string (deployment name visible)
|
|
tuple_key = (LongPollNamespace.DEPLOYMENT_CONFIG, "app1:deployment1")
|
|
assert _get_metric_namespace_tag(tuple_key) == str(tuple_key)
|
|
|
|
# --- Compact mode (compact=True): low-cardinality tags ---
|
|
monkeypatch.setattr(
|
|
long_poll_module, "RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS", True
|
|
)
|
|
|
|
# String keys still pass through unchanged
|
|
assert _get_metric_namespace_tag("test_key") == "test_key"
|
|
assert _get_metric_namespace_tag("key_1") == "key_1"
|
|
|
|
# LongPollNamespace enum keys return just the name
|
|
assert (
|
|
_get_metric_namespace_tag(LongPollNamespace.DEPLOYMENT_CONFIG)
|
|
== "DEPLOYMENT_CONFIG"
|
|
)
|
|
assert (
|
|
_get_metric_namespace_tag(LongPollNamespace.DEPLOYMENT_TARGETS)
|
|
== "DEPLOYMENT_TARGETS"
|
|
)
|
|
assert _get_metric_namespace_tag(LongPollNamespace.ROUTE_TABLE) == "ROUTE_TABLE"
|
|
|
|
# Tuple keys extract only the namespace, discarding per-deployment identifier
|
|
assert (
|
|
_get_metric_namespace_tag(
|
|
(LongPollNamespace.DEPLOYMENT_CONFIG, "app1:deployment1")
|
|
)
|
|
== "DEPLOYMENT_CONFIG"
|
|
)
|
|
assert (
|
|
_get_metric_namespace_tag(
|
|
(LongPollNamespace.DEPLOYMENT_TARGETS, "app2:deployment2")
|
|
)
|
|
== "DEPLOYMENT_TARGETS"
|
|
)
|
|
|
|
# Tuple keys with long deployment identifiers (the real-world case)
|
|
long_key = (
|
|
LongPollNamespace.DEPLOYMENT_CONFIG,
|
|
"Deployment(name='model', app='workday:perf-test-model-00005:"
|
|
"key-value-v1:baked-in:global:global:1')",
|
|
)
|
|
assert _get_metric_namespace_tag(long_key) == "DEPLOYMENT_CONFIG"
|
|
|
|
# All LongPollNamespace enum values should work, both bare and in tuples
|
|
for ns in LongPollNamespace:
|
|
assert _get_metric_namespace_tag(ns) == ns.name
|
|
assert _get_metric_namespace_tag((ns, "any_deployment")) == ns.name
|
|
|
|
# Defensive: tuple with non-enum first element falls back to str()
|
|
assert _get_metric_namespace_tag(("custom_ns", "value")) == "custom_ns"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pending_clients_gauge_aggregates_across_keys(serve_instance):
|
|
"""Test that pending_clients_by_namespace correctly aggregates across keys.
|
|
|
|
When compact metric tags are enabled and multiple keys share a namespace
|
|
tag (e.g., two DEPLOYMENT_CONFIG keys for different deployments), the gauge
|
|
must reflect the total pending clients for the namespace, not just the last
|
|
key's count.
|
|
See https://github.com/ray-project/ray/issues/62299.
|
|
"""
|
|
host = (
|
|
ray.remote(LongPollHost)
|
|
.options(
|
|
runtime_env={"env_vars": {"RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS": "1"}}
|
|
)
|
|
.remote(listen_for_change_request_timeout_s=(0.5, 0.5))
|
|
)
|
|
|
|
key_a = (LongPollNamespace.DEPLOYMENT_CONFIG, "app1:deploy1")
|
|
key_b = (LongPollNamespace.DEPLOYMENT_CONFIG, "app2:deploy2")
|
|
|
|
# Notify initial values so the keys exist
|
|
ray.get(host.notify_changed.remote({key_a: "v1", key_b: "v2"}))
|
|
|
|
# Subscribe to both keys — this should register 2 pending clients
|
|
# for the DEPLOYMENT_CONFIG namespace
|
|
ref = host.listen_for_change.remote({key_a: -1, key_b: -1})
|
|
result = ray.get(ref)
|
|
assert key_a in result and key_b in result
|
|
|
|
# Now subscribe with up-to-date snapshot IDs so we actually block
|
|
snapshot_ids = {k: v.snapshot_id for k, v in result.items()}
|
|
ref = host.listen_for_change.remote(snapshot_ids)
|
|
|
|
# The pending clients count for DEPLOYMENT_CONFIG should be 2
|
|
# (one event per key). We can't read the gauge directly, but we
|
|
# verify the internal tracking counter.
|
|
counter = ray.get(
|
|
host._get_pending_clients_by_namespace.remote("DEPLOYMENT_CONFIG")
|
|
)
|
|
assert counter == 2, f"Expected 2 pending clients, got {counter}"
|
|
|
|
# Notify one key — should decrement by 1, not set to 0
|
|
ray.get(host.notify_changed.remote({key_a: "v1_updated"}))
|
|
|
|
# Wait for the listen_for_change to return
|
|
result2 = ray.get(ref)
|
|
assert key_a in result2
|
|
|
|
# After notification, the counter should have been decremented
|
|
counter_after = ray.get(
|
|
host._get_pending_clients_by_namespace.remote("DEPLOYMENT_CONFIG")
|
|
)
|
|
# Counter should be 0 now (both events cleaned up: one by notify_changed,
|
|
# one by the not_done cleanup in listen_for_change)
|
|
assert counter_after == 0, f"Expected 0 pending clients, got {counter_after}"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pending_clients_gauge_non_compact_mode(serve_instance):
|
|
"""Test pending_clients bookkeeping when RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS=0.
|
|
|
|
In non-compact mode, each key maps to its own namespace tag via str(key).
|
|
Verify that pending client counts are correctly incremented, decremented,
|
|
and cleaned up for each per-key tag, with no regressions in the new
|
|
bookkeeping logic.
|
|
See https://github.com/ray-project/ray/issues/62299.
|
|
"""
|
|
host = (
|
|
ray.remote(LongPollHost)
|
|
.options(
|
|
runtime_env={"env_vars": {"RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS": "0"}}
|
|
)
|
|
.remote(listen_for_change_request_timeout_s=(0.5, 0.5))
|
|
)
|
|
|
|
key_a = (LongPollNamespace.DEPLOYMENT_CONFIG, "app1:deploy1")
|
|
key_b = (LongPollNamespace.DEPLOYMENT_CONFIG, "app2:deploy2")
|
|
|
|
# Notify initial values so the keys exist
|
|
ray.get(host.notify_changed.remote({key_a: "v1", key_b: "v2"}))
|
|
|
|
# Get initial snapshots
|
|
ref = host.listen_for_change.remote({key_a: -1, key_b: -1})
|
|
result = ray.get(ref)
|
|
assert key_a in result and key_b in result
|
|
|
|
# Subscribe with up-to-date snapshot IDs so we block (pending)
|
|
snapshot_ids = {k: v.snapshot_id for k, v in result.items()}
|
|
ref = host.listen_for_change.remote(snapshot_ids)
|
|
|
|
# In non-compact mode, each key has its own namespace tag (str(key)),
|
|
# so each should have exactly 1 pending client.
|
|
tag_a = str(key_a)
|
|
tag_b = str(key_b)
|
|
counter_a = ray.get(host._get_pending_clients_by_namespace.remote(tag_a))
|
|
counter_b = ray.get(host._get_pending_clients_by_namespace.remote(tag_b))
|
|
assert counter_a == 1, f"Expected 1 pending client for {tag_a}, got {counter_a}"
|
|
assert counter_b == 1, f"Expected 1 pending client for {tag_b}, got {counter_b}"
|
|
|
|
# Notify key_a — its pending count should drop, key_b unaffected
|
|
ray.get(host.notify_changed.remote({key_a: "v1_updated"}))
|
|
result2 = ray.get(ref)
|
|
assert key_a in result2
|
|
|
|
# After notification + cleanup, both counters should be 0
|
|
counter_a_after = ray.get(host._get_pending_clients_by_namespace.remote(tag_a))
|
|
counter_b_after = ray.get(host._get_pending_clients_by_namespace.remote(tag_b))
|
|
assert (
|
|
counter_a_after == 0
|
|
), f"Expected 0 pending clients for {tag_a}, got {counter_a_after}"
|
|
assert (
|
|
counter_b_after == 0
|
|
), f"Expected 0 pending clients for {tag_b}, got {counter_b_after}"
|
|
|
|
# Verify cleanup with timeout: subscribe and let it time out
|
|
snapshot_ids2 = {k: v.snapshot_id for k, v in result2.items()}
|
|
# Also include key_b's latest snapshot
|
|
snapshot_ids2[key_b] = result[key_b].snapshot_id
|
|
ref2 = host.listen_for_change.remote(snapshot_ids2)
|
|
timeout_result = ray.get(ref2)
|
|
assert timeout_result == LongPollState.TIME_OUT
|
|
|
|
# After timeout, all pending counters should be cleaned up to 0
|
|
counter_a_timeout = ray.get(host._get_pending_clients_by_namespace.remote(tag_a))
|
|
counter_b_timeout = ray.get(host._get_pending_clients_by_namespace.remote(tag_b))
|
|
assert (
|
|
counter_a_timeout == 0
|
|
), f"Expected 0 after timeout for {tag_a}, got {counter_a_timeout}"
|
|
assert (
|
|
counter_b_timeout == 0
|
|
), f"Expected 0 after timeout for {tag_b}, got {counter_b_timeout}"
|
|
|
|
|
|
def test_remove_keys_evicts_per_key_state(serve_instance):
|
|
"""After remove_keys, a poll with a stale snapshot id must time out
|
|
instead of returning the stale snapshot."""
|
|
host = ray.remote(LongPollHost).remote(
|
|
listen_for_change_request_timeout_s=(0.2, 0.2)
|
|
)
|
|
key = (LongPollNamespace.DEPLOYMENT_CONFIG, "app1:deploy1")
|
|
|
|
ray.get(host.notify_changed.remote({key: "config-v1"}))
|
|
|
|
initial = ray.get(host.listen_for_change.remote({key: -1}))
|
|
assert key in initial
|
|
stale_snapshot_ids = {key: initial[key].snapshot_id}
|
|
|
|
ray.get(host.remove_keys.remote([key]))
|
|
|
|
poll_result = ray.get(host.listen_for_change.remote(stale_snapshot_ids))
|
|
assert poll_result == LongPollState.TIME_OUT
|
|
|
|
|
|
def test_remove_keys_wakes_parked_waiters(serve_instance):
|
|
"""Parked RPCs return promptly after remove_keys (not at the 30 s
|
|
timeout); the evicted key is filtered out of the returned dict."""
|
|
host = ray.remote(LongPollHost).remote(listen_for_change_request_timeout_s=(30, 30))
|
|
key = (LongPollNamespace.DEPLOYMENT_CONFIG, "app:deploy")
|
|
|
|
ray.get(host.notify_changed.remote({key: "v1"}))
|
|
initial = ray.get(host.listen_for_change.remote({key: -1}))
|
|
snapshot_id = initial[key].snapshot_id
|
|
|
|
parked_ref = host.listen_for_change.remote({key: snapshot_id})
|
|
wait_for_condition(
|
|
lambda: ray.get(host._get_num_notifier_events.remote()) == 1,
|
|
timeout=5,
|
|
)
|
|
|
|
ray.get(host.remove_keys.remote([key]))
|
|
|
|
start = time.time()
|
|
result = ray.get(parked_ref, timeout=5)
|
|
elapsed = time.time() - start
|
|
assert elapsed < 5, f"parked RPC took {elapsed:.2f}s; should have woken"
|
|
assert result == {}, f"expected empty dict, got {result}"
|
|
assert ray.get(host._get_num_notifier_events.remote()) == 0
|
|
|
|
|
|
def test_remove_keys_decrements_pending_clients_gauge(serve_instance):
|
|
"""Gauge must return to 0 after remove_keys wakes parked waiters.
|
|
Otherwise the listen_for_change timeout cleanup skips the decrement
|
|
on the now-missing notifier_events entry and inflates the gauge."""
|
|
host = (
|
|
ray.remote(LongPollHost)
|
|
.options(
|
|
runtime_env={"env_vars": {"RAY_SERVE_COMPACT_LONG_POLL_METRIC_TAGS": "1"}}
|
|
)
|
|
.remote(listen_for_change_request_timeout_s=(30, 30))
|
|
)
|
|
key = (LongPollNamespace.DEPLOYMENT_CONFIG, "app:deploy")
|
|
|
|
ray.get(host.notify_changed.remote({key: "v1"}))
|
|
initial = ray.get(host.listen_for_change.remote({key: -1}))
|
|
snapshot_id = initial[key].snapshot_id
|
|
|
|
parked_ref = host.listen_for_change.remote({key: snapshot_id})
|
|
|
|
wait_for_condition(
|
|
lambda: ray.get(
|
|
host._get_pending_clients_by_namespace.remote("DEPLOYMENT_CONFIG")
|
|
)
|
|
== 1,
|
|
timeout=5,
|
|
)
|
|
|
|
ray.get(host.remove_keys.remote([key]))
|
|
ray.get(parked_ref, timeout=5)
|
|
|
|
assert (
|
|
ray.get(host._get_pending_clients_by_namespace.remote("DEPLOYMENT_CONFIG")) == 0
|
|
)
|
|
|
|
|
|
def test_delete_tombstone_reaches_parked_subscriber(serve_instance):
|
|
"""Parked subscriber must receive the DEPLOYMENT_TARGETS tombstone.
|
|
|
|
Evicting the tombstoned key in the same sync tick would race the
|
|
waiter: it wakes after update() returns, sees the key gone, and
|
|
drops the tombstone.
|
|
"""
|
|
host = ray.remote(LongPollHost).remote(listen_for_change_request_timeout_s=(30, 30))
|
|
|
|
targets_key = (LongPollNamespace.DEPLOYMENT_TARGETS, "d1")
|
|
config_key = (LongPollNamespace.DEPLOYMENT_CONFIG, "d1")
|
|
|
|
target_info_initial = DeploymentTargetInfo(is_available=True, running_replicas=[])
|
|
ray.get(
|
|
host.notify_changed.remote(
|
|
{targets_key: target_info_initial, config_key: "config-v1"}
|
|
)
|
|
)
|
|
|
|
initial = ray.get(host.listen_for_change.remote({targets_key: -1, config_key: -1}))
|
|
targets_snapshot_id = initial[targets_key].snapshot_id
|
|
|
|
parked_ref = host.listen_for_change.remote({targets_key: targets_snapshot_id})
|
|
wait_for_condition(
|
|
lambda: ray.get(host._get_num_notifier_events.remote()) == 1,
|
|
timeout=5,
|
|
)
|
|
|
|
# Simulate the delete path: tombstone TARGETS, evict only CONFIG.
|
|
tombstone = DeploymentTargetInfo(is_available=False, running_replicas=[])
|
|
ray.get(host.notify_changed.remote({targets_key: tombstone}))
|
|
ray.get(host.remove_keys.remote([config_key]))
|
|
|
|
result = ray.get(parked_ref, timeout=5)
|
|
assert targets_key in result, f"Subscriber missed the tombstone: {result}"
|
|
delivered = result[targets_key].object_snapshot
|
|
assert delivered.is_available is False
|
|
assert delivered.running_replicas == []
|
|
|
|
|
|
def test_long_poll_client_disable_propagates_to_host_log():
|
|
host = LongPollHost()
|
|
host_actor = MagicMock()
|
|
host_actor.notify_long_poll_client_disabled.remote.side_effect = (
|
|
host.notify_client_disabled
|
|
)
|
|
|
|
serve_logger = logging.getLogger("ray.serve")
|
|
buf = io.StringIO()
|
|
handler = logging.StreamHandler(buf)
|
|
serve_logger.addHandler(handler)
|
|
loop = asyncio.new_event_loop() # never run; is_running() == False
|
|
try:
|
|
client = LongPollClient(
|
|
host_actor, {}, call_in_event_loop=loop, client_id="TestClient"
|
|
)
|
|
client._schedule_to_event_loop(lambda: None)
|
|
finally:
|
|
loop.close()
|
|
serve_logger.removeHandler(handler)
|
|
|
|
assert client.is_running is False
|
|
output = buf.getvalue()
|
|
assert "TestClient" in output, output
|
|
assert "not running" in output.lower(), output
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(pytest.main(["-v", "-s", __file__]))
|