async def __init__(self,
controller_name: str,
http_config: HTTPOptions,
checkpoint_path: str,
detached: bool = False):
# Used to read/write checkpoints.
self.controller_namespace = ray.get_runtime_context().namespace
self.controller_name = controller_name
self.kv_store = make_kv_store(
checkpoint_path,
namespace=f"{self.controller_name}-{self.controller_namespace}")
# Dictionary of backend_tag -> proxy_name -> most recent queue length.
self.backend_stats = defaultdict(lambda: defaultdict(dict))
# Used to ensure that only a single state-changing operation happens
# at any given time.
self.write_lock = asyncio.Lock()
self.long_poll_host = LongPollHost()
self.goal_manager = AsyncGoalManager()
self.http_state = HTTPState(controller_name, detached, http_config)
self.endpoint_state = EndpointState(self.kv_store, self.long_poll_host)
# Fetch all running actors in current cluster as source of current
# replica state for controller failure recovery
all_current_actor_names = ray.util.list_named_actors()
self.backend_state_manager = BackendStateManager(
controller_name, detached, self.kv_store, self.long_poll_host,
self.goal_manager, all_current_actor_names)
# TODO(simon): move autoscaling related stuff into a manager.
self.autoscaling_metrics_store = InMemoryMetricsStore()
asyncio.get_event_loop().create_task(self.run_control_loop())
async def __init__(self,
controller_name: str,
http_config: HTTPOptions,
detached: bool = False):
# Used to read/write checkpoints.
controller_namespace = ray.get_runtime_context().namespace
self.kv_store = RayInternalKVStore(
namespace=f"{controller_name}-{controller_namespace}")
# Dictionary of backend_tag -> proxy_name -> most recent queue length.
self.backend_stats = defaultdict(lambda: defaultdict(dict))
# Used to ensure that only a single state-changing operation happens
# at any given time.
self.write_lock = asyncio.Lock()
self.long_poll_host = LongPollHost()
self.goal_manager = AsyncGoalManager()
self.http_state = HTTPState(controller_name, detached, http_config)
self.endpoint_state = EndpointState(self.kv_store, self.long_poll_host)
self.backend_state_manager = BackendStateManager(
controller_name, detached, self.kv_store, self.long_poll_host,
self.goal_manager)
asyncio.get_event_loop().create_task(self.run_control_loop())
async def __init__(self,
controller_name: str,
http_config: HTTPOptions,
detached: bool = False):
# Used to read/write checkpoints.
self.kv_store = RayInternalKVStore(namespace=controller_name)
# Dictionary of backend_tag -> proxy_name -> most recent queue length.
self.backend_stats = defaultdict(lambda: defaultdict(dict))
# Used to ensure that only a single state-changing operation happens
# at any given time.
self.write_lock = asyncio.Lock()
# NOTE(simon): Currently we do all-to-all broadcast. This means
# any listeners will receive notification for all changes. This
# can be problem at scale, e.g. updating a single backend config
# will send over the entire configs. In the future, we should
# optimize the logic to support subscription by key.
self.long_poll_host = LongPollHost()
self.goal_manager = AsyncGoalManager()
self.http_state = HTTPState(controller_name, detached, http_config)
self.endpoint_state = EndpointState(self.kv_store, self.long_poll_host)
self.backend_state = BackendState(controller_name, detached,
self.kv_store, self.long_poll_host,
self.goal_manager)
asyncio.get_event_loop().create_task(self.run_control_loop())
async def test_wait_for_goals():
manager = AsyncGoalManager()
# Check empty goal
await manager.wait_for_goal(None)
goal_id = manager.create_goal()
waiting = asyncio.create_task(manager.wait_for_goal(goal_id))
assert not waiting.done(), "Unfinished task should not be done"
manager.complete_goal(goal_id)
await waiting
# Test double waiting is okay
await manager.wait_for_goal(goal_id)
def mock_backend_state() -> Tuple[BackendState, Mock, Mock]:
timer = MockTimer()
with patch(
"ray.serve.backend_state.ActorReplicaWrapper",
new=MockReplicaActorWrapper), patch(
"time.time",
new=timer.time), patch("ray.serve.kv_store.RayInternalKVStore"
) as mock_kv_store, patch(
"ray.serve.long_poll.LongPollHost"
) as mock_long_poll, patch.object(
BackendState,
"_checkpoint") as mock_checkpoint:
mock_kv_store.get = Mock(return_value=None)
goal_manager = AsyncGoalManager()
backend_state = BackendState("name", True, mock_kv_store,
mock_long_poll, goal_manager)
mock_checkpoint.return_value = None
yield backend_state, timer, goal_manager