diff --git a/lib/python3.12/site-packages/ray/autoscaler/__pycache__/node_launch_exception.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/__pycache__/node_launch_exception.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bb3f56b73b65e8c2b970a1a373e5a1f8726100a Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/__pycache__/node_launch_exception.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/__pycache__/tags.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/__pycache__/tags.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4da873e6fd2eb361d75d4e386217bb2e2f72f71 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/__pycache__/tags.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ba7695e6b17e075bc2a66c6a8f39c3226ab217e Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/autoscaler.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/autoscaler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2de458ed2a06b037c6c4e36065118f4a3b05c8d0 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/autoscaler.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/event_logger.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/event_logger.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6b8db5cdd2010362e50f65ba98b4a1e252356a7 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/event_logger.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/metrics_reporter.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/metrics_reporter.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..293abc426b585f32ded2f43296da17088087409f Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/metrics_reporter.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/monitor.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/monitor.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13a02f8fae42e00988ef18fd1110a91e8c9caa11 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/monitor.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/scheduler.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/scheduler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad54a55f5efbc4980ce0263754ca55b372c9038e Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/scheduler.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/schema.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/schema.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b299729f56def48db280f22be12949785e0bb5eb Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/schema.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/sdk.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/sdk.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc85d914adc174fffd59658a697b0a61545d4655 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/sdk.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/utils.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/utils.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9df3f2866f343685a863092a0087bdfb510aa5b2 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/__pycache__/utils.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/autoscaler.py b/lib/python3.12/site-packages/ray/autoscaler/v2/autoscaler.py new file mode 100644 index 0000000000000000000000000000000000000000..cdc8620bc2b77ed9e4645e270c9b4b52dba228b7 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/autoscaler.py @@ -0,0 +1,216 @@ +import logging +from queue import Queue +from typing import List, Optional +from urllib.parse import urlsplit + +from ray._raylet import GcsClient +from ray.autoscaler._private.providers import _get_node_provider +from ray.autoscaler.v2.event_logger import AutoscalerEventLogger +from ray.autoscaler.v2.instance_manager.cloud_providers.kuberay.cloud_provider import ( + KubeRayProvider, +) +from ray.autoscaler.v2.instance_manager.cloud_providers.read_only.cloud_provider import ( # noqa + ReadOnlyProvider, +) +from ray.autoscaler.v2.instance_manager.config import ( + AutoscalingConfig, + IConfigReader, + Provider, +) +from ray.autoscaler.v2.instance_manager.instance_manager import ( + InstanceManager, + InstanceUpdatedSubscriber, +) +from ray.autoscaler.v2.instance_manager.instance_storage import InstanceStorage +from ray.autoscaler.v2.instance_manager.node_provider import ( + ICloudInstanceProvider, + NodeProviderAdapter, +) +from ray.autoscaler.v2.instance_manager.ray_installer import RayInstaller +from ray.autoscaler.v2.instance_manager.reconciler import Reconciler +from ray.autoscaler.v2.instance_manager.storage import InMemoryStorage +from ray.autoscaler.v2.instance_manager.subscribers.cloud_instance_updater import ( + CloudInstanceUpdater, +) +from ray.autoscaler.v2.instance_manager.subscribers.ray_stopper import RayStopper +from ray.autoscaler.v2.instance_manager.subscribers.threaded_ray_installer import ( + ThreadedRayInstaller, +) +from ray.autoscaler.v2.metrics_reporter import AutoscalerMetricsReporter +from ray.autoscaler.v2.scheduler import ResourceDemandScheduler +from ray.autoscaler.v2.sdk import get_cluster_resource_state +from ray.core.generated.autoscaler_pb2 import AutoscalingState + +logger = logging.getLogger(__name__) + + +class Autoscaler: + def __init__( + self, + session_name: str, + config_reader: IConfigReader, + gcs_client: GcsClient, + event_logger: Optional[AutoscalerEventLogger] = None, + metrics_reporter: Optional[AutoscalerMetricsReporter] = None, + ) -> None: + """ + Args: + session_name: The current Ray session name. + config_reader: The config reader. + gcs_client: The GCS client. + event_logger: The event logger for emitting cluster events. + metrics_reporter: The metrics reporter for emitting cluster metrics. + """ + + self._config_reader = config_reader + + config = config_reader.get_cached_autoscaling_config() + logger.info(f"Using Autoscaling Config: \n{config.dump()}") + + self._gcs_client = gcs_client + self._cloud_instance_provider = None + self._instance_manager = None + self._ray_stop_errors_queue = Queue() + self._ray_install_errors_queue = Queue() + self._event_logger = event_logger + self._metrics_reporter = metrics_reporter + + self._init_cloud_instance_provider(config, config_reader) + self._init_instance_manager( + session_name=session_name, + config=config, + cloud_provider=self._cloud_instance_provider, + gcs_client=self._gcs_client, + ) + self._scheduler = ResourceDemandScheduler(self._event_logger) + + def _init_cloud_instance_provider( + self, config: AutoscalingConfig, config_reader: IConfigReader + ): + """ + Initialize the cloud provider, and its dependencies (the v1 node provider) + + Args: + config: The autoscaling config. + config_reader: The config reader. + + """ + provider_config = config.get_provider_config() + if provider_config["type"] == "kuberay": + provider_config["head_node_type"] = config.get_head_node_type() + self._cloud_instance_provider = KubeRayProvider( + config.get_config("cluster_name"), + provider_config, + ) + elif config.provider == Provider.READ_ONLY: + provider_config["gcs_address"] = self._gcs_client.address + self._cloud_instance_provider = ReadOnlyProvider( + provider_config=provider_config, + ) + else: + node_provider_v1 = _get_node_provider( + provider_config, + config.get_config("cluster_name"), + ) + + self._cloud_instance_provider = NodeProviderAdapter( + v1_provider=node_provider_v1, + config_reader=config_reader, + ) + + def _init_instance_manager( + self, + session_name: str, + cloud_provider: ICloudInstanceProvider, + gcs_client: GcsClient, + config: AutoscalingConfig, + ): + """ + Initialize the instance manager, and its dependencies. + """ + + instance_storage = InstanceStorage( + cluster_id=session_name, + storage=InMemoryStorage(), + ) + subscribers: List[InstanceUpdatedSubscriber] = [] + subscribers.append(CloudInstanceUpdater(cloud_provider=cloud_provider)) + subscribers.append( + RayStopper(gcs_client=gcs_client, error_queue=self._ray_stop_errors_queue) + ) + if not config.disable_node_updaters() and isinstance( + cloud_provider, NodeProviderAdapter + ): + head_node_ip = urlsplit("//" + self._gcs_client.address).hostname + assert head_node_ip is not None, "Invalid GCS address format" + subscribers.append( + ThreadedRayInstaller( + head_node_ip=head_node_ip, + instance_storage=instance_storage, + ray_installer=RayInstaller( + provider=cloud_provider.v1_provider, + config=config, + ), + error_queue=self._ray_install_errors_queue, + # TODO(rueian): Rewrite the ThreadedRayInstaller and its underlying + # NodeUpdater and CommandRunner to use the asyncio, so that we don't + # need to use so many threads. We use so many threads now because + # they are blocking and letting the new cloud machines to wait for + # previous machines to finish installing Ray is quite inefficient. + max_concurrent_installs=config.get_max_num_worker_nodes() or 50, + ) + ) + + self._instance_manager = InstanceManager( + instance_storage=instance_storage, + instance_status_update_subscribers=subscribers, + ) + + def update_autoscaling_state( + self, + ) -> Optional[AutoscalingState]: + """Update the autoscaling state of the cluster by reconciling the current + state of the cluster resources, the cloud providers as well as instance + update subscribers with the desired state. + + Returns: + AutoscalingState: The new autoscaling state of the cluster or None if + the state is not updated. + + Raises: + None: No exception. + """ + + try: + ray_stop_errors = [] + while not self._ray_stop_errors_queue.empty(): + ray_stop_errors.append(self._ray_stop_errors_queue.get()) + + ray_install_errors = [] + while not self._ray_install_errors_queue.empty(): + ray_install_errors.append(self._ray_install_errors_queue.get()) + + # Get the current state of the ray cluster resources. + ray_cluster_resource_state = get_cluster_resource_state(self._gcs_client) + + # Refresh the config from the source + self._config_reader.refresh_cached_autoscaling_config() + autoscaling_config = self._config_reader.get_cached_autoscaling_config() + + return Reconciler.reconcile( + instance_manager=self._instance_manager, + scheduler=self._scheduler, + cloud_provider=self._cloud_instance_provider, + ray_cluster_resource_state=ray_cluster_resource_state, + non_terminated_cloud_instances=( + self._cloud_instance_provider.get_non_terminated() + ), + cloud_provider_errors=self._cloud_instance_provider.poll_errors(), + ray_install_errors=ray_install_errors, + ray_stop_errors=ray_stop_errors, + autoscaling_config=autoscaling_config, + metrics_reporter=self._metrics_reporter, + ) + except Exception as e: + logger.exception(e) + return None diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/event_logger.py b/lib/python3.12/site-packages/ray/autoscaler/v2/event_logger.py new file mode 100644 index 0000000000000000000000000000000000000000..b4db3d2b798b54fcf917ecf3e4fb4a05429e1252 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/event_logger.py @@ -0,0 +1,185 @@ +import logging +from collections import defaultdict +from typing import Dict, List, Optional + +from ray._private.event.event_logger import EventLoggerAdapter +from ray.autoscaler.v2.utils import ResourceRequestUtil +from ray.core.generated.autoscaler_pb2 import ( + ClusterResourceConstraint, + GangResourceRequest, + ResourceRequest, +) +from ray.core.generated.common_pb2 import LabelSelectorOperator +from ray.core.generated.instance_manager_pb2 import LaunchRequest, TerminationRequest + +logger = logging.getLogger(__name__) + + +class AutoscalerEventLogger: + """ + Logs events related to the autoscaler. + + # TODO: + - Add more logging for other events. + - Rate limit the events if too spammy. + """ + + def __init__(self, logger: EventLoggerAdapter): + self._logger = logger + + def log_cluster_scheduling_update( + self, + cluster_resources: Dict[str, float], + launch_requests: Optional[List[LaunchRequest]] = None, + terminate_requests: Optional[List[TerminationRequest]] = None, + infeasible_requests: Optional[List[ResourceRequest]] = None, + infeasible_gang_requests: Optional[List[GangResourceRequest]] = None, + infeasible_cluster_resource_constraints: Optional[ + List[ClusterResourceConstraint] + ] = None, + ) -> None: + """ + Log updates to the autoscaler scheduling state. + + Emits: + - info logs for node launches and terminations (counts grouped by node type). + - an info log summarizing the cluster size after a resize (CPUs/GPUs/TPUs). + - warnings describing infeasible single resource requests, infeasible gang + (placement group) requests, and infeasible cluster resource constraints. + + Args: + cluster_resources: Mapping of resource name to total resources for the + current cluster state. + launch_requests: Node launch requests issued in this scheduling step. + terminate_requests: Node termination requests issued in this scheduling + step. + infeasible_requests: Resource requests that could not be satisfied by + any available node type. + infeasible_gang_requests: Gang/placement group requests that could not + be scheduled. + infeasible_cluster_resource_constraints: Cluster-level resource + constraints that could not be satisfied. + + Returns: + None + """ + + # Log any launch events. + if launch_requests: + launch_type_count = defaultdict(int) + for req in launch_requests: + launch_type_count[req.instance_type] += req.count + + for idx, (instance_type, count) in enumerate(launch_type_count.items()): + log_str = f"Adding {count} node(s) of type {instance_type}." + self._logger.info(f"{log_str}") + logger.info(f"{log_str}") + + # Log any terminate events. + if terminate_requests: + termination_by_causes_and_type = defaultdict(int) + for req in terminate_requests: + termination_by_causes_and_type[(req.cause, req.instance_type)] += 1 + + cause_reason_map = { + TerminationRequest.Cause.OUTDATED: "outdated", + TerminationRequest.Cause.MAX_NUM_NODES: "max number of worker nodes reached", # noqa + TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE: "max number of worker nodes per type reached", # noqa + TerminationRequest.Cause.IDLE: "idle", + } + + for idx, ((cause, instance_type), count) in enumerate( + termination_by_causes_and_type.items() + ): + log_str = f"Removing {count} nodes of type {instance_type} ({cause_reason_map[cause]})." # noqa + self._logger.info(f"{log_str}") + logger.info(f"{log_str}") + + # Cluster shape changes. + if launch_requests or terminate_requests: + num_cpus = cluster_resources.get("CPU", 0) + log_str = f"Resized to {int(num_cpus)} CPUs" + + if "GPU" in cluster_resources: + log_str += f", {int(cluster_resources['GPU'])} GPUs" + if "TPU" in cluster_resources: + log_str += f", {int(cluster_resources['TPU'])} TPUs" + + self._logger.info(f"{log_str}.") + self._logger.debug(f"Current cluster resources: {dict(cluster_resources)}.") + + # Log any infeasible requests. + if infeasible_requests: + requests_by_count = ResourceRequestUtil.group_by_count(infeasible_requests) + log_str = "No available node types can fulfill resource requests " + for idx, req_count in enumerate(requests_by_count): + resource_map = ResourceRequestUtil.to_resource_map(req_count.request) + log_str += f"{resource_map}*{req_count.count}" + if idx < len(requests_by_count) - 1: + log_str += ", " + + # Parse and log label selectors if present + if req_count.request.label_selectors: + selector_strs = [] + for selector in req_count.request.label_selectors: + for constraint in selector.label_constraints: + op = LabelSelectorOperator.Name(constraint.operator) + values = ",".join(constraint.label_values) + selector_strs.append( + f"{constraint.label_key} {op} [{values}]" + ) + if selector_strs: + log_str += ( + " with label selectors: [" + "; ".join(selector_strs) + "]" + ) + + log_str += ( + ". Add suitable node types to this cluster to resolve this issue." + ) + self._logger.warning(log_str) + + if infeasible_gang_requests: + # Log for each placement group requests. + for gang_request in infeasible_gang_requests: + log_str = ( + "No available node types can fulfill " + "placement group requests (detail={details}): ".format( + details=gang_request.details + ) + ) + requests_by_count = ResourceRequestUtil.group_by_count( + gang_request.requests + ) + for idx, req_count in enumerate(requests_by_count): + resource_map = ResourceRequestUtil.to_resource_map( + req_count.request + ) + log_str += f"{resource_map}*{req_count.count}" + if idx < len(requests_by_count) - 1: + log_str += ", " + + log_str += ( + ". Add suitable node types to this cluster to resolve this issue." + ) + self._logger.warning(log_str) + + if infeasible_cluster_resource_constraints: + # We will only have max 1 cluster resource constraint for now since it's + # from `request_resources()` sdk, where the most recent call would override + # the previous one. + for infeasible_constraint in infeasible_cluster_resource_constraints: + log_str = "No available node types can fulfill cluster constraint: " + for i, requests_by_count in enumerate( + infeasible_constraint.resource_requests + ): + resource_map = ResourceRequestUtil.to_resource_map( + requests_by_count.request + ) + log_str += f"{resource_map}*{requests_by_count.count}" + if i < len(infeasible_constraint.resource_requests) - 1: + log_str += ", " + + log_str += ( + ". Add suitable node types to this cluster to resolve this issue." + ) + self._logger.warning(log_str) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f499fb5df7813b124b76f4ff4a2d5d0fb0ac84b8 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/common.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/common.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7dee23ae3d661c0601f4bbce2d917bea150eb597 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/common.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/config.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d785a6d696a2dac8a7989e52f949f4275510d799 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/config.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_manager.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_manager.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cba95ef839491fa5a124088241face34e7e45c5a Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_manager.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_storage.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_storage.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7833e0236e2fed9dead81c34923afa4f25d2b059 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/instance_storage.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/node_provider.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/node_provider.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcea979b68319286dd0826ea89832dbd18e9417c Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/node_provider.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/ray_installer.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/ray_installer.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fba2cfd1b69e2b1beb548db74528493d22c0a2e8 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/ray_installer.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/reconciler.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/reconciler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dfc8528b0fdf11e5a995539038710d2a08996cb Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/reconciler.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/storage.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/storage.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94035b49f1bd27e3fb78fae86beab989d4c1af35 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/__pycache__/storage.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a67b3b48102399378ba3cacae97789623888fe0b Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82b5324a882c83b680d321e41a1a72c4044095d2 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/cloud_provider.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/cloud_provider.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8de88d635cf85cee5ca66972b4c82eea410ddb6a Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/cloud_provider.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/cloud_provider.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/cloud_provider.py new file mode 100644 index 0000000000000000000000000000000000000000..b7ab28bd077b7dbbe555a42fbbf8fb994d6937fc --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/cloud_provider.py @@ -0,0 +1,595 @@ +import copy +import logging +import time +from collections import defaultdict +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional, Set, Tuple + +import requests + +# TODO(rickyx): We should eventually remove these imports +# when we deprecate the v1 kuberay node provider. +from ray.autoscaler._private.kuberay.node_provider import ( + KUBERAY_KIND_HEAD, + KUBERAY_KIND_WORKER, + KUBERAY_LABEL_KEY_KIND, + KUBERAY_LABEL_KEY_TYPE, + RAY_HEAD_POD_NAME, + IKubernetesHttpApiClient, + KubernetesHttpApiClient, + _worker_group_index, + _worker_group_max_replicas, + _worker_group_num_of_hosts, + _worker_group_replicas, + worker_delete_patch, + worker_replica_patch, +) +from ray.autoscaler.v2.instance_manager.node_provider import ( + CloudInstance, + CloudInstanceId, + CloudInstanceProviderError, + ICloudInstanceProvider, + LaunchNodeError, + NodeKind, + TerminateNodeError, +) +from ray.autoscaler.v2.schema import NodeType + +logger = logging.getLogger(__name__) + + +class KubeRayProvider(ICloudInstanceProvider): + """ + This class is a thin wrapper around the Kubernetes API client. It modifies + the RayCluster resource spec on the Kubernetes API server to scale the cluster: + + It launches new instances/nodes by submitting patches to the Kubernetes API + to update the RayCluster CRD. + """ + + def __init__( + self, + cluster_name: str, + provider_config: Dict[str, Any], + k8s_api_client: Optional[IKubernetesHttpApiClient] = None, + ): + """ + Args: + cluster_name: The name of the RayCluster resource. + provider_config: The namespace of the RayCluster. + k8s_api_client: The client to the Kubernetes API server. + This could be used to mock the Kubernetes API server for testing. + """ + self._cluster_name = cluster_name + self._namespace = provider_config["namespace"] + + self._k8s_api_client = k8s_api_client or KubernetesHttpApiClient( + namespace=self._namespace + ) + + # Below are states that are cached locally. + self._requests = set() + self._launch_errors_queue = [] + self._terminate_errors_queue = [] + + # Below are states that are fetched from the Kubernetes API server. + self._ray_cluster = None + self._cached_instances: Dict[CloudInstanceId, CloudInstance] + + @dataclass + class ScaleRequest: + """Represents a scale request that contains the current states and go-to states + for the ray cluster. + + This class will be converted to patches to be submitted to the Kubernetes API + server: + - For launching new instances, it will adjust the `replicas` field in the + workerGroupSpecs. + - For terminating instances, it will adjust the `workersToDelete` field in the + workerGroupSpecs. + + """ + + # The desired number of workers for each node type. + desired_num_workers: Dict[NodeType, int] = field(default_factory=dict) + # The workers to delete for each node type. + workers_to_delete: Dict[NodeType, List[CloudInstanceId]] = field( + default_factory=dict + ) + # The worker groups with empty workersToDelete field. + # This is needed since we will also need to clear the workersToDelete field + # for the worker groups that have finished deletes. + worker_groups_without_pending_deletes: Set[NodeType] = field( + default_factory=set + ) + # The worker groups that still have workers to be deleted. + worker_groups_with_pending_deletes: Set[NodeType] = field(default_factory=set) + + ################################ + # Interface for ICloudInstanceProvider + ################################ + + def get_non_terminated(self) -> Dict[CloudInstanceId, CloudInstance]: + self._sync_with_api_server() + return copy.deepcopy(dict(self._cached_instances)) + + def terminate(self, ids: List[CloudInstanceId], request_id: str) -> None: + if request_id in self._requests: + # This request is already processed. + logger.warning(f"Request {request_id} is already processed for: {ids}") + return + self._requests.add(request_id) + logger.info("Terminating worker pods: {}".format(ids)) + + scale_request = self._initialize_scale_request( + to_launch={}, to_delete_instances=ids + ) + if scale_request.worker_groups_with_pending_deletes: + errors_msg = ( + "There are workers to be deleted from: " + f"{scale_request.worker_groups_with_pending_deletes}. " + "Waiting for them to be deleted before adding new workers " + " to be deleted" + ) + logger.warning(errors_msg) + self._add_terminate_errors( + ids, + request_id, + details=errors_msg, + ) + return + + try: + self._submit_scale_request(scale_request) + except Exception as e: + logger.exception(f"Error terminating nodes: {scale_request}") + self._add_terminate_errors(ids, request_id, details=str(e), e=e) + + def launch(self, shape: Dict[NodeType, int], request_id: str) -> None: + if request_id in self._requests: + # This request is already processed. + return + self._requests.add(request_id) + + scale_request = self._initialize_scale_request( + to_launch=shape, to_delete_instances=[] + ) + + if scale_request.worker_groups_with_pending_deletes: + error_msg = ( + "There are workers to be deleted from: " + f"{scale_request.worker_groups_with_pending_deletes}. " + "Waiting for them to be deleted before creating new workers." + ) + logger.warning(error_msg) + self._add_launch_errors( + shape, + request_id, + details=error_msg, + ) + return + + try: + self._submit_scale_request(scale_request) + except Exception as e: + logger.exception(f"Error launching nodes: {scale_request}") + self._add_launch_errors(shape, request_id, details=str(e), e=e) + + def poll_errors(self) -> List[CloudInstanceProviderError]: + errors = [] + errors += self._launch_errors_queue + errors += self._terminate_errors_queue + self._launch_errors_queue = [] + self._terminate_errors_queue = [] + return errors + + ############################ + # Private + ############################ + + def _initialize_scale_request( + self, to_launch: Dict[NodeType, int], to_delete_instances: List[CloudInstanceId] + ) -> "KubeRayProvider.ScaleRequest": + """ + Initialize the scale request based on the current state of the cluster and + the desired state (to launch, to delete). + + Args: + to_launch: The desired number of workers to launch for each node type. + to_delete_instances: The instances to delete. + + Returns: + The scale request. + """ + + # Update the cached states. + self._sync_with_api_server() + ray_cluster = self.ray_cluster + cur_instances = self.instances + + # Get the worker groups that have pending deletes and the worker groups that + # have finished deletes, and the set of workers included in the workersToDelete + # field of any worker group. + ( + worker_groups_with_pending_deletes, + worker_groups_without_pending_deletes, + worker_to_delete_set, + ) = self._get_workers_delete_info(ray_cluster, set(cur_instances.keys())) + + observed_workers_dict = defaultdict(int) + for instance in cur_instances.values(): + if instance.node_kind != NodeKind.WORKER: + continue + if instance.cloud_instance_id in worker_to_delete_set: + continue + observed_workers_dict[instance.node_type] += 1 + + # Calculate the desired number of workers by type. + num_workers_dict = defaultdict(int) + worker_groups = ray_cluster["spec"].get("workerGroupSpecs", []) + for worker_group in worker_groups: + node_type = worker_group["groupName"] + # Handle the case where users manually increase `minReplicas` + # to scale up the number of worker Pods. In this scenario, + # `replicas` will be smaller than `minReplicas`. + # num_workers_dict should account for multi-host replicas when + # `numOfHosts`` is set. + num_of_hosts = worker_group.get("numOfHosts", 1) + replicas = ( + max(worker_group["replicas"], worker_group["minReplicas"]) + * num_of_hosts + ) + + # The `replicas` field in worker group specs can be updated by users at any time. + # However, users should only increase the field (manually upscaling the worker group), not decrease it, + # because downscaling the worker group requires specifying which workers to delete explicitly in the `workersToDelete` field. + # Since we don't have a way to enforce this, we need to fix unexpected decreases on the `replicas` field by using actual observations. + # For example, if the user manually decreases the `replicas` field to 0 without specifying which workers to delete, + # we should fix the `replicas` field back to the number of observed workers excluding the workers to be deleted, + # otherwise, we won't have a correct `replicas` matches the actual number of workers eventually. + num_workers_dict[node_type] = max( + replicas, observed_workers_dict[node_type] + ) + + # Add to launch nodes. + for node_type, count in to_launch.items(): + num_workers_dict[node_type] += count + + to_delete_instances_by_type = defaultdict(list) + # Update the number of workers with to_delete_instances + # and group them by type. + for to_delete_id in to_delete_instances: + to_delete_instance = cur_instances.get(to_delete_id, None) + if to_delete_instance is None: + # This instance has already been deleted. + continue + + if to_delete_instance.node_kind == NodeKind.HEAD: + # Not possible to delete head node. + continue + + if to_delete_instance.cloud_instance_id in worker_to_delete_set: + # If the instance is already in the workersToDelete field of + # any worker group, skip it. + continue + + num_workers_dict[to_delete_instance.node_type] -= 1 + assert num_workers_dict[to_delete_instance.node_type] >= 0 + to_delete_instances_by_type[to_delete_instance.node_type].append( + to_delete_instance + ) + + scale_request = KubeRayProvider.ScaleRequest( + desired_num_workers=num_workers_dict, + workers_to_delete=to_delete_instances_by_type, + worker_groups_without_pending_deletes=worker_groups_without_pending_deletes, + worker_groups_with_pending_deletes=worker_groups_with_pending_deletes, + ) + + return scale_request + + def _submit_scale_request( + self, scale_request: "KubeRayProvider.ScaleRequest" + ) -> None: + """Submits a scale request to the Kubernetes API server. + + This method will convert the scale request to patches and submit the patches + to the Kubernetes API server. + + Args: + scale_request: The scale request. + + Raises: + Exception: An exception is raised if the Kubernetes API server returns an + error. + """ + # Get the current ray cluster spec. + patch_payload = [] + + raycluster = self.ray_cluster + + # Collect patches for replica counts. + for node_type, num_workers in scale_request.desired_num_workers.items(): + group_index = _worker_group_index(raycluster, node_type) + group_max_replicas = _worker_group_max_replicas(raycluster, group_index) + group_num_of_hosts = _worker_group_num_of_hosts(raycluster, group_index) + # the num_workers from the scale request is multiplied by numOfHosts, so we need to divide it back. + target_replicas = num_workers // group_num_of_hosts + # Cap the replica count to maxReplicas. + if group_max_replicas is not None and group_max_replicas < target_replicas: + logger.warning( + "Autoscaler attempted to create " + + "more than maxReplicas pods of type {}.".format(node_type) + ) + target_replicas = group_max_replicas + # Check if we need to change the target count. + if target_replicas == _worker_group_replicas(raycluster, group_index): + # No patch required. + continue + # Need to patch replica count. Format the patch and add it to the payload. + patch = worker_replica_patch(group_index, target_replicas) + patch_payload.append(patch) + + # Maps node_type to nodes to delete for that group. + for ( + node_type, + workers_to_delete_of_type, + ) in scale_request.workers_to_delete.items(): + group_index = _worker_group_index(raycluster, node_type) + worker_ids_to_delete = [ + worker.cloud_instance_id for worker in workers_to_delete_of_type + ] + patch = worker_delete_patch(group_index, worker_ids_to_delete) + patch_payload.append(patch) + + # Clear the workersToDelete field for the worker groups that have been deleted. + for node_type in scale_request.worker_groups_without_pending_deletes: + if node_type in scale_request.workers_to_delete: + # This node type is still being deleted. + continue + group_index = _worker_group_index(raycluster, node_type) + patch = worker_delete_patch(group_index, []) + patch_payload.append(patch) + + if len(patch_payload) == 0: + # No patch required. + return + + logger.info(f"Submitting a scale request: {scale_request}") + self._patch(f"rayclusters/{self._cluster_name}", patch_payload) + + def _add_launch_errors( + self, + shape: Dict[NodeType, int], + request_id: str, + details: str, + e: Optional[Exception] = None, + ) -> None: + """ + Adds launch errors to the error queue. + + Args: + shape: The shape of the nodes that failed to launch. + request_id: The request id of the launch request. + details: The details of the error. + e: The exception that caused the error. + """ + for node_type, count in shape.items(): + self._launch_errors_queue.append( + LaunchNodeError( + node_type=node_type, + timestamp_ns=time.time_ns(), + count=count, + request_id=request_id, + details=details, + cause=e, + ) + ) + + def _add_terminate_errors( + self, + ids: List[CloudInstanceId], + request_id: str, + details: str, + e: Optional[Exception] = None, + ) -> None: + """ + Adds terminate errors to the error queue. + + Args: + ids: The ids of the nodes that failed to terminate. + request_id: The request id of the terminate request. + details: The details of the error. + e: The exception that caused the error. + """ + for id in ids: + self._terminate_errors_queue.append( + TerminateNodeError( + cloud_instance_id=id, + timestamp_ns=time.time_ns(), + request_id=request_id, + details=details, + cause=e, + ) + ) + + def _sync_with_api_server(self) -> None: + """Fetches the RayCluster resource from the Kubernetes API server.""" + self._ray_cluster = self._get(f"rayclusters/{self._cluster_name}") + self._cached_instances = self._fetch_instances() + + @property + def ray_cluster(self) -> Dict[str, Any]: + return copy.deepcopy(self._ray_cluster) + + @property + def instances(self) -> Dict[CloudInstanceId, CloudInstance]: + return copy.deepcopy(self._cached_instances) + + @staticmethod + def _get_workers_delete_info( + ray_cluster_spec: Dict[str, Any], node_set: Set[CloudInstanceId] + ) -> Tuple[Set[NodeType], Set[NodeType], Set[CloudInstanceId]]: + """ + Gets the worker groups that have pending deletes and the worker groups that + have finished deletes. + + Returns: + worker_groups_with_pending_deletes: The worker groups that have pending + deletes. + worker_groups_with_finished_deletes: The worker groups that have finished + deletes. + worker_to_delete_set: A set of Pods that are included in the workersToDelete + field of any worker group. + """ + + worker_groups_with_pending_deletes = set() + worker_groups_with_deletes = set() + worker_to_delete_set = set() + + worker_groups = ray_cluster_spec["spec"].get("workerGroupSpecs", []) + for worker_group in worker_groups: + workersToDelete = worker_group.get("scaleStrategy", {}).get( + "workersToDelete", [] + ) + if not workersToDelete: + # No workers to delete in this group. + continue + + node_type = worker_group["groupName"] + worker_groups_with_deletes.add(node_type) + + for worker in workersToDelete: + worker_to_delete_set.add(worker) + if worker in node_set: + worker_groups_with_pending_deletes.add(node_type) + + worker_groups_with_finished_deletes = ( + worker_groups_with_deletes - worker_groups_with_pending_deletes + ) + return ( + worker_groups_with_pending_deletes, + worker_groups_with_finished_deletes, + worker_to_delete_set, + ) + + def _fetch_instances(self) -> Dict[CloudInstanceId, CloudInstance]: + """ + Fetches the pods from the Kubernetes API server and convert them to Ray + CloudInstance. + + Returns: + A dict of CloudInstanceId to CloudInstance. + """ + # Get the pods resource version. + # Specifying a resource version in list requests is important for scalability: + # https://kubernetes.io/docs/reference/using-api/api-concepts/#semantics-for-get-and-list + resource_version = self._get_head_pod_resource_version() + if resource_version: + logger.info( + f"Listing pods for RayCluster {self._cluster_name}" + f" in namespace {self._namespace}" + f" at pods resource version >= {resource_version}." + ) + + # Filter pods by cluster_name. + label_selector = requests.utils.quote(f"ray.io/cluster={self._cluster_name}") + + resource_path = f"pods?labelSelector={label_selector}" + if resource_version: + resource_path += ( + f"&resourceVersion={resource_version}" + + "&resourceVersionMatch=NotOlderThan" + ) + + pod_list = self._get(resource_path) + fetched_resource_version = pod_list["metadata"]["resourceVersion"] + logger.info( + f"Fetched pod data at resource version" f" {fetched_resource_version}." + ) + + # Extract node data from the pod list. + cloud_instances = {} + for pod in pod_list["items"]: + # Kubernetes sets metadata.deletionTimestamp immediately after admitting a + # request to delete an object. Full removal of the object may take some time + # after the deletion timestamp is set. See link for details: + # https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-deletion + if "deletionTimestamp" in pod["metadata"]: + # Ignore pods marked for termination. + continue + pod_name = pod["metadata"]["name"] + cloud_instance = self._cloud_instance_from_pod(pod) + if cloud_instance: + cloud_instances[pod_name] = cloud_instance + return cloud_instances + + @staticmethod + def _cloud_instance_from_pod(pod: Dict[str, Any]) -> Optional[CloudInstance]: + """ + Convert a pod to a Ray CloudInstance. + + Args: + pod: The pod resource dict. + """ + labels = pod["metadata"]["labels"] + if labels[KUBERAY_LABEL_KEY_KIND] == KUBERAY_KIND_HEAD: + kind = NodeKind.HEAD + type = labels[KUBERAY_LABEL_KEY_TYPE] + elif labels[KUBERAY_LABEL_KEY_KIND] == KUBERAY_KIND_WORKER: + kind = NodeKind.WORKER + type = labels[KUBERAY_LABEL_KEY_TYPE] + else: + # Other ray nodes types defined by KubeRay. + # e.g. this could also be `redis-cleanup` + # We will not track these nodes. + return None + + # TODO: we should prob get from the pod's env var (RAY_CLOUD_INSTANCE_ID) + # directly. + cloud_instance_id = pod["metadata"]["name"] + return CloudInstance( + cloud_instance_id=cloud_instance_id, + node_type=type, + node_kind=kind, + is_running=KubeRayProvider._is_running(pod), + ) + + @staticmethod + def _is_running(pod) -> bool: + """Convert pod state to Ray NodeStatus + + A cloud instance is considered running if the pod is in the running state, + else it could be pending/containers-terminated. + + When it disappears from the list, it is considered terminated. + """ + if ( + "containerStatuses" not in pod["status"] + or not pod["status"]["containerStatuses"] + ): + return False + + state = pod["status"]["containerStatuses"][0]["state"] + if "running" in state: + return True + + return False + + def _get(self, remote_path: str) -> Dict[str, Any]: + """Get a resource from the Kubernetes API server.""" + return self._k8s_api_client.get(remote_path) + + def _patch(self, remote_path: str, payload: List[Dict[str, Any]]) -> Dict[str, Any]: + """Patch a resource on the Kubernetes API server.""" + return self._k8s_api_client.patch(remote_path, payload) + + def _get_head_pod_resource_version(self) -> str: + """ + Extract a recent pods resource version by reading the head pod's + metadata.resourceVersion of the response. + """ + if not RAY_HEAD_POD_NAME: + return None + pod_resp = self._get(f"pods/{RAY_HEAD_POD_NAME}") + return pod_resp["metadata"]["resourceVersion"] diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13cdb521a5538957dee0eb45361c35c0a5385f00 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/cloud_provider.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/cloud_provider.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf691f2840c239dce20c5b73295b111fa1df2456 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/cloud_provider.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/cloud_provider.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/cloud_provider.py new file mode 100644 index 0000000000000000000000000000000000000000..01c11c35fe7cac0fca41e3b3bbad23c48dcbbaa6 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/cloud_providers/read_only/cloud_provider.py @@ -0,0 +1,73 @@ +from typing import Dict, List + +from ray._common.utils import binary_to_hex +from ray._raylet import GcsClient +from ray.autoscaler._private.util import format_readonly_node_type +from ray.autoscaler.v2.instance_manager.node_provider import ( + CloudInstance, + CloudInstanceId, + CloudInstanceProviderError, + ICloudInstanceProvider, + NodeKind, +) +from ray.autoscaler.v2.sdk import get_cluster_resource_state +from ray.autoscaler.v2.utils import is_head_node +from ray.core.generated.autoscaler_pb2 import NodeStatus + + +class ReadOnlyProvider(ICloudInstanceProvider): + """ + A read only provider that use the ray node states from the GCS as the + cloud instances. + + This is used for laptop mode / manual cluster setup modes, in order to + provide status reporting in the same way for users. + """ + + def __init__(self, provider_config: dict): + self._provider_config = provider_config + self._gcs_address = provider_config["gcs_address"] + + self._gcs_client = GcsClient(address=self._gcs_address) + + def get_non_terminated(self) -> Dict[str, CloudInstance]: + cluster_resource_state = get_cluster_resource_state(self._gcs_client) + cloud_instances = {} + for gcs_node_state in cluster_resource_state.node_states: + if gcs_node_state.status == NodeStatus.DEAD: + # Skip dead nodes. + continue + + # Use node's node id if instance id is not available + cloud_instance_id = ( + gcs_node_state.instance_id + if gcs_node_state.instance_id + else binary_to_hex(gcs_node_state.node_id) + ) + + # TODO: we should add a field to the proto to indicate if the node is head + # or not. + is_head = is_head_node(gcs_node_state) + + cloud_instances[cloud_instance_id] = CloudInstance( + cloud_instance_id=cloud_instance_id, + node_kind=NodeKind.HEAD if is_head else NodeKind.WORKER, + node_type=format_readonly_node_type( + binary_to_hex(gcs_node_state.node_id) # Legacy behavior. + ), + is_running=True, + request_id="", + ) + + return cloud_instances + + def terminate(self, instance_id: CloudInstanceId) -> None: + raise NotImplementedError("Cannot terminate instances in read-only mode.") + + def launch( + self, shape: Dict[CloudInstanceId, int], request_id: CloudInstanceId + ) -> None: + raise NotImplementedError("Cannot launch instances in read-only mode.") + + def poll_errors(self) -> List[CloudInstanceProviderError]: + return [] diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/common.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/common.py new file mode 100644 index 0000000000000000000000000000000000000000..fa792f29e820b9d75c26f0120cf2de03be94c3ca --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/common.py @@ -0,0 +1,472 @@ +import time +import uuid +from typing import Dict, List, Optional, Set + +from ray.core.generated.instance_manager_pb2 import Instance, InstanceUpdateEvent + + +class InstanceUtil: + """ + A helper class to group updates and operations on an Instance object defined + in instance_manager.proto + """ + + # Memoized reachable from sets, where the key is the instance status, and + # the value is the set of instance status that is reachable from the key + # instance status. + _reachable_from: Optional[ + Dict["Instance.InstanceStatus", Set["Instance.InstanceStatus"]] + ] = None + + @staticmethod + def new_instance( + instance_id: str, + instance_type: str, + status: Instance.InstanceStatus, + details: str = "", + ) -> Instance: + """ + Returns a new instance with the given status. + + Args: + instance_id: The instance id. + instance_type: The instance type. + status: The status of the new instance. + details: The details of the status transition. + """ + instance = Instance() + instance.version = 0 # it will be populated by the underlying storage. + instance.instance_id = instance_id + instance.instance_type = instance_type + instance.status = status + InstanceUtil._record_status_transition(instance, status, details) + return instance + + @staticmethod + def random_instance_id() -> str: + """ + Returns a random instance id. + """ + return str(uuid.uuid4()) + + @staticmethod + def is_cloud_instance_allocated(instance_status: Instance.InstanceStatus) -> bool: + """ + Returns True if the instance is in a status where there could exist + a cloud instance allocated by the cloud provider. + """ + assert instance_status != Instance.UNKNOWN + return instance_status in { + Instance.ALLOCATED, + Instance.RAY_INSTALLING, + Instance.RAY_RUNNING, + Instance.RAY_STOPPING, + Instance.RAY_STOP_REQUESTED, + Instance.RAY_STOPPED, + Instance.TERMINATING, + Instance.RAY_INSTALL_FAILED, + Instance.TERMINATION_FAILED, + } + + @staticmethod + def is_ray_running(instance_status: Instance.InstanceStatus) -> bool: + """ + Returns True if the instance is in a status where the ray process is + running on the cloud instance. + i.e. RAY_RUNNING, RAY_STOP_REQUESTED, RAY_STOPPING + """ + assert instance_status != Instance.UNKNOWN + + if instance_status in InstanceUtil.get_reachable_statuses( + Instance.RAY_STOPPING + ): + return False + + if instance_status in InstanceUtil.get_reachable_statuses(Instance.RAY_RUNNING): + return True + + return False + + @staticmethod + def is_ray_pending(instance_status: Instance.InstanceStatus) -> bool: + """ + Returns True if the instance is in a status where the ray process is + pending to be started on the cloud instance. + + """ + assert instance_status != Instance.UNKNOWN + # Not gonna be in a RAY_RUNNING status. + if Instance.RAY_RUNNING not in InstanceUtil.get_reachable_statuses( + instance_status + ): + return False + + # Already running ray. + if instance_status in InstanceUtil.get_reachable_statuses(Instance.RAY_RUNNING): + return False + + return True + + def is_ray_running_reachable(instance_status: Instance.InstanceStatus) -> bool: + """ + Returns True if the instance is in a status where it may transition + to RAY_RUNNING status. + """ + return Instance.RAY_RUNNING in InstanceUtil.get_reachable_statuses( + instance_status + ) + + @staticmethod + def set_status( + instance: Instance, + new_instance_status: Instance.InstanceStatus, + details: str = "", + ) -> bool: + """Transitions the instance to the new state. + + Args: + instance: The instance to update. + new_instance_status: The new status to transition to. + details: The details of the transition. + + Returns: + True if the status transition is successful, False otherwise. + """ + if ( + new_instance_status + not in InstanceUtil.get_valid_transitions()[instance.status] + ): + return False + instance.status = new_instance_status + InstanceUtil._record_status_transition(instance, new_instance_status, details) + return True + + @staticmethod + def _record_status_transition( + instance: Instance, status: Instance.InstanceStatus, details: str + ): + """Records the status transition. + + Args: + instance: The instance to update. + status: The new status to transition to. + """ + now_ns = time.time_ns() + instance.status_history.append( + Instance.StatusHistory( + instance_status=status, + timestamp_ns=now_ns, + details=details, + ) + ) + + @staticmethod + def has_timeout(instance: Instance, timeout_s: int) -> bool: + """ + Returns True if the instance has been in the current status for more + than the timeout_seconds. + + Args: + instance: The instance to check. + timeout_seconds: The timeout in seconds. + + Returns: + True if the instance has been in the current status for more than + the timeout_s seconds. + """ + cur_status = instance.status + + status_times_ns = InstanceUtil.get_status_transition_times_ns( + instance, select_instance_status=cur_status + ) + assert len(status_times_ns) >= 1, ( + f"instance {instance.instance_id} has {len(status_times_ns)} " + f"{Instance.InstanceStatus.Name(cur_status)} status" + ) + status_time_ns = sorted(status_times_ns)[-1] + if time.time_ns() - status_time_ns <= (timeout_s * 1e9): + return False + + return True + + @staticmethod + def get_valid_transitions() -> Dict[ + "Instance.InstanceStatus", Set["Instance.InstanceStatus"] + ]: + return { + # This is the initial status of a new instance. + Instance.QUEUED: { + # Cloud provider requested to launch a node for the instance. + # This happens when the a launch request is made to the node provider. + Instance.REQUESTED, + }, + # When in this status, a launch request to the node provider is made. + Instance.REQUESTED: { + # Cloud provider allocated a cloud instance for the instance. + # This happens when the cloud instance first appears in the list of + # running cloud instances from the cloud instance provider. + Instance.ALLOCATED, + # Retry the allocation, become queueing again. + Instance.QUEUED, + # Cloud provider fails to allocate one. Either as a timeout or + # the launch request fails immediately. + Instance.ALLOCATION_FAILED, + }, + # When in this status, the cloud instance is allocated and running. This + # happens when the cloud instance is present in node provider's list of + # running cloud instances. + Instance.ALLOCATED: { + # Ray needs to be install and launch on the provisioned cloud instance. + # This happens when the cloud instance is allocated, and the autoscaler + # is responsible for installing and launching ray on the cloud instance. + # For node provider that manages the ray installation and launching, + # this state is skipped. + Instance.RAY_INSTALLING, + # Ray is already installed on the provisioned cloud + # instance. It could be any valid ray status. + Instance.RAY_RUNNING, + Instance.RAY_STOPPING, + Instance.RAY_STOPPED, + # Instance is requested to be stopped, e.g. instance leaked: no matching + # Instance with the same type is found in the autoscaler's state. + Instance.TERMINATING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # Ray process is being installed and started on the cloud instance. + # This status is skipped for node provider that manages the ray + # installation and launching. (e.g. Ray-on-Spark) + Instance.RAY_INSTALLING: { + # Ray installed and launched successfully, reported by the ray cluster. + # Similar to the Instance.ALLOCATED -> Instance.RAY_RUNNING transition, + # where the ray process is managed by the node provider. + Instance.RAY_RUNNING, + # Ray installation failed. This happens when the ray process failed to + # be installed and started on the cloud instance. + Instance.RAY_INSTALL_FAILED, + # Wen the ray node is reported as stopped by the ray cluster. + # This could happen that the ray process was stopped quickly after start + # such that a ray running node wasn't discovered and the RAY_RUNNING + # transition was skipped. + Instance.RAY_STOPPED, + # A cloud instance is being terminated (when the instance itself is no + # longer needed, e.g. instance is outdated, autoscaler is scaling down) + Instance.TERMINATING, + # cloud instance somehow failed during the installation process. + Instance.TERMINATED, + }, + # Ray process is installed and running on the cloud instance. When in this + # status, a ray node must be present in the ray cluster. + Instance.RAY_RUNNING: { + # Ray is requested to be stopped. + Instance.RAY_STOP_REQUESTED, + # Ray is stopping (currently draining), + # e.g. idle termination. + Instance.RAY_STOPPING, + # Ray is already stopped, as reported by the ray cluster. + Instance.RAY_STOPPED, + # A cloud instance is being terminated (when the instance itself is no + # longer needed, e.g. instance is outdated, autoscaler is scaling down) + Instance.TERMINATING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # Ray process should be stopped on the cloud instance. The RayStopper + # subscriber will listen to this status and stop the ray process. + Instance.RAY_STOP_REQUESTED: { + # Ray is stopping on the cloud instance. + Instance.RAY_STOPPING, + # Ray stopped already. + Instance.RAY_STOPPED, + # Ray stop request failed (e.g. idle node no longer idle), + # ray is still running. + Instance.RAY_RUNNING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # When in this status, the ray process is requested to be stopped to the + # ray cluster, but not yet present in the dead ray node list reported by + # the ray cluster. + Instance.RAY_STOPPING: { + # Ray is stopped, and the ray node is present in the dead ray node list + # reported by the ray cluster. + Instance.RAY_STOPPED, + # A cloud instance is being terminated (when the instance itself is no + # longer needed, e.g. instance is outdated, autoscaler is scaling down) + Instance.TERMINATING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # When in this status, the ray process is stopped, and the ray node is + # present in the dead ray node list reported by the ray cluster. + Instance.RAY_STOPPED: { + # A cloud instance is being terminated (when the instance itself is no + # longer needed, e.g. instance is outdated, autoscaler is scaling down) + Instance.TERMINATING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # When in this status, the cloud instance is requested to be stopped to + # the node provider. + Instance.TERMINATING: { + # When a cloud instance no longer appears in the list of running cloud + # instances from the node provider. + Instance.TERMINATED, + # When the cloud instance failed to be terminated. + Instance.TERMINATION_FAILED, + }, + # When in this status, the cloud instance failed to be terminated by the + # node provider. We will keep retrying. + Instance.TERMINATION_FAILED: { + # Retry the termination, become terminating again. + Instance.TERMINATING, + }, + # Whenever a cloud instance disappears from the list of running cloud + # instances from the node provider, the instance is marked as stopped. Since + # we guarantee 1:1 mapping of a Instance to a cloud instance, this is a + # terminal state. + Instance.TERMINATED: set(), # Terminal state. + # When in this status, the cloud instance failed to be allocated by the + # node provider. + Instance.ALLOCATION_FAILED: set(), # Terminal state. + Instance.RAY_INSTALL_FAILED: { + # Autoscaler requests to shutdown the instance when ray install failed. + Instance.TERMINATING, + # cloud instance somehow failed. + Instance.TERMINATED, + }, + # Initial state before the instance is created. Should never be used. + Instance.UNKNOWN: set(), + } + + @staticmethod + def get_status_transitions( + instance: Instance, + select_instance_status: Optional["Instance.InstanceStatus"] = None, + ) -> List["Instance.StatusHistory"]: + """ + Returns the status history of the instance. + + Args: + instance: The instance. + select_instance_status: The go-to status to search for, i.e. select + only status history when the instance transitions into the status. + If None, returns all status updates. + """ + history = [] + for status_update in instance.status_history: + if ( + select_instance_status + and status_update.instance_status != select_instance_status + ): + continue + history.append(status_update) + return history + + @staticmethod + def get_last_status_transition( + instance: Instance, + select_instance_status: Optional["Instance.InstanceStatus"] = None, + ) -> Optional["Instance.StatusHistory"]: + """ + Returns the last status transition of the instance. + + Args: + instance: The instance. + instance_status: The status to search for. If None, returns the last + status update. + """ + history = InstanceUtil.get_status_transitions(instance, select_instance_status) + history.sort(key=lambda x: x.timestamp_ns) + if history: + return history[-1] + return None + + @staticmethod + def get_status_transition_times_ns( + instance: Instance, + select_instance_status: Optional["Instance.InstanceStatus"] = None, + ) -> List[int]: + """ + Returns a list of timestamps of the instance status update. + + Args: + instance: The instance. + instance_status: The status to search for. If None, returns all + status updates timestamps. + + Returns: + The list of timestamps of the instance status updates. + """ + return [ + e.timestamp_ns + for e in InstanceUtil.get_status_transitions( + instance, select_instance_status + ) + ] + + @classmethod + def get_reachable_statuses( + cls, + instance_status: Instance.InstanceStatus, + ) -> Set["Instance.InstanceStatus"]: + """ + Returns the set of instance status that is reachable from the given + instance status following the status transitions. + This method is memoized. + Args: + instance_status: The instance status to start from. + Returns: + The set of instance status that is reachable from the given instance + status. + """ + if cls._reachable_from is None: + cls._compute_reachable() + return cls._reachable_from[instance_status] + + @staticmethod + def get_log_str_for_update(instance: Instance, update: InstanceUpdateEvent) -> str: + """Returns a log string for the given instance update.""" + if update.upsert: + return ( + f"New instance " + f"{Instance.InstanceStatus.Name(update.new_instance_status)} (id=" + f"{instance.instance_id}, type={instance.instance_type}, " + f"cloud_instance_id={instance.cloud_instance_id}, " + f"ray_id={instance.node_id}): {update.details}" + ) + return ( + f"Update instance " + f"{Instance.InstanceStatus.Name(instance.status)}->" + f"{Instance.InstanceStatus.Name(update.new_instance_status)} (id=" + f"{instance.instance_id}, type={instance.instance_type}, " + f"cloud_instance_id={instance.cloud_instance_id}, " + f"ray_id={instance.node_id}): {update.details}" + ) + + @classmethod + def _compute_reachable(cls): + """ + Computes and memorize the from status sets for each status machine with + a DFS search. + """ + valid_transitions = cls.get_valid_transitions() + + def dfs(graph, start, visited): + """ + Regular DFS algorithm to find all reachable nodes from a given node. + """ + for next_node in graph[start]: + if next_node not in visited: + # We delay adding the visited set here so we could capture + # the self loop. + visited.add(next_node) + dfs(graph, next_node, visited) + return visited + + # Initialize the graphs + cls._reachable_from = {} + for status in Instance.InstanceStatus.values(): + # All nodes reachable from 'start' + visited = set() + cls._reachable_from[status] = dfs(valid_transitions, status, visited) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/config.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/config.py new file mode 100644 index 0000000000000000000000000000000000000000..6abf836e3f299821f9f9714dc0fab1d9ad91f546 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/config.py @@ -0,0 +1,552 @@ +import copy +import logging +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from enum import Enum +from pathlib import Path +from typing import Any, Dict, List, Optional + +import yaml + +from ray._common.utils import binary_to_hex +from ray._private.ray_constants import env_integer +from ray._raylet import GcsClient +from ray.autoscaler._private.constants import ( + AUTOSCALER_MAX_CONCURRENT_LAUNCHES, + DEFAULT_UPSCALING_SPEED, + DISABLE_LAUNCH_CONFIG_CHECK_KEY, + DISABLE_NODE_UPDATERS_KEY, +) +from ray.autoscaler._private.kuberay.autoscaling_config import AutoscalingConfigProducer +from ray.autoscaler._private.monitor import BASE_READONLY_CONFIG +from ray.autoscaler._private.util import ( + format_readonly_node_type, + hash_launch_conf, + hash_runtime_conf, + prepare_config, + validate_config, +) +from ray.autoscaler.v2.schema import NodeType +from ray.autoscaler.v2.sdk import get_cluster_resource_state +from ray.autoscaler.v2.utils import is_head_node + +logger = logging.getLogger(__name__) + + +class Provider(Enum): + UNKNOWN = 0 + ALIYUN = 1 + AWS = 2 + AZURE = 3 + GCP = 4 + KUBERAY = 5 + LOCAL = 6 + READ_ONLY = 7 + + +class IConfigReader(ABC): + """An interface for reading Autoscaling config. + + A utility class that reads autoscaling configs from various sources: + - File + - In-memory dict + - Remote config service (e.g. KubeRay's config) + + Example: + reader = FileConfigReader("path/to/config.yaml") + # Get the recently cached config. + config = reader.get_cached_autoscaling_config() + + ... + # Refresh the cached config. + reader.refresh_cached_autoscaling_config() + config = reader.get_cached_autoscaling_config() + + """ + + @abstractmethod + def get_cached_autoscaling_config(self) -> "AutoscalingConfig": + """Returns the recently read autoscaling config. + + Returns: + AutoscalingConfig: The recently read autoscaling config. + """ + pass + + @abstractmethod + def refresh_cached_autoscaling_config(self): + """Read the config from the source.""" + pass + + +@dataclass(frozen=True) +class InstanceReconcileConfig: + # The timeout for waiting for a REQUESTED instance to be ALLOCATED. + request_status_timeout_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_REQUEST_STATUS_TIMEOUT_S", 10 * 60 + ) + # The timeout for waiting for a ALLOCATED instance to be RAY_RUNNING. + allocate_status_timeout_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_ALLOCATE_STATUS_TIMEOUT_S", 300 + ) + # The timeout for waiting for a RAY_INSTALLING instance to be RAY_RUNNING. + ray_install_status_timeout_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_RAY_INSTALL_STATUS_TIMEOUT_S", 30 * 60 + ) + # The timeout for waiting for a TERMINATING instance to be TERMINATED. + terminating_status_timeout_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_TERMINATING_STATUS_TIMEOUT_S", 300 + ) + # The timeout for waiting for a RAY_STOP_REQUESTED instance + # to be RAY_STOPPING or RAY_STOPPED. + ray_stop_requested_status_timeout_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_RAY_STOP_REQUESTED_STATUS_TIMEOUT_S", 300 + ) + # The interval for raise a warning when an instance in transient status + # is not updated for a long time. + transient_status_warn_interval_s: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_TRANSIENT_STATUS_WARN_INTERVAL_S", 90 + ) + # The number of times to retry requesting to allocate an instance. + max_num_retry_request_to_allocate: int = env_integer( + "RAY_AUTOSCALER_RECONCILE_MAX_NUM_RETRY_REQUEST_TO_ALLOCATE", 3 + ) + + +@dataclass +class NodeTypeConfig: + """ + NodeTypeConfig is the helper class to provide node type specific configs. + This maps to subset of the `available_node_types` field in the + autoscaling config. + """ + + # Node type name + name: NodeType + # The minimal number of worker nodes to be launched for this node type. + min_worker_nodes: int + # The maximal number of worker nodes can be launched for this node type. + max_worker_nodes: int + # Idle timeout seconds for worker nodes of this node type. + idle_timeout_s: Optional[float] = None + # The total resources on the node. + resources: Dict[str, float] = field(default_factory=dict) + # The labels on the node. + labels: Dict[str, str] = field(default_factory=dict) + # The node config's launch config hash. It's calculated from the auth + # config, and the node's config in the `AutoscalingConfig` for the node + # type when launching the node. It's used to detect config changes. + launch_config_hash: str = "" + + def __post_init__(self): + assert self.min_worker_nodes <= self.max_worker_nodes + assert self.min_worker_nodes >= 0 + + +class AutoscalingConfig: + """ + AutoscalingConfig is the helper class to provide autoscaling + related configs. + + # TODO(rickyx): + 1. Move the config validation logic here. + 2. Deprecate the ray-schema.json for validation because it's + static thus not possible to validate the config with interdependency + of each other. + """ + + def __init__( + self, + configs: Dict[str, Any], + skip_content_hash: bool = False, + ) -> None: + """ + Args: + configs : The raw configs dict. + skip_content_hash : + Whether to skip file mounts/ray command hash calculation. + """ + self._sync_continuously = False + self.update_configs(configs, skip_content_hash) + + def update_configs(self, configs: Dict[str, Any], skip_content_hash: bool) -> None: + self._configs = prepare_config(configs) + validate_config(self._configs) + if skip_content_hash: + return + self._calculate_hashes() + self._sync_continuously = self._configs.get( + "generate_file_mounts_contents_hash", True + ) + + def _calculate_hashes(self) -> None: + logger.info("Calculating hashes for file mounts and ray commands.") + self._runtime_hash, self._file_mounts_contents_hash = hash_runtime_conf( + self._configs.get("file_mounts", {}), + self._configs.get("cluster_synced_files", []), + [ + self._configs.get("worker_setup_commands", []), + self._configs.get("worker_start_ray_commands", []), + ], + generate_file_mounts_contents_hash=self._configs.get( + "generate_file_mounts_contents_hash", True + ), + ) + + def get_cloud_node_config(self, ray_node_type: NodeType) -> Dict[str, Any]: + return copy.deepcopy( + self.get_node_type_specific_config(ray_node_type, "node_config") or {} + ) + + def get_docker_config(self, ray_node_type: NodeType) -> Dict[str, Any]: + """ + Return the docker config for the specified node type. + If it's a head node, the image will be chosen in the following order: + 1. Node specific docker image. + 2. The 'docker' config's 'head_image' field. + 3. The 'docker' config's 'image' field. + If it's a worker node, the image will be chosen in the following order: + 1. Node specific docker image. + 2. The 'docker' config's 'worker_image' field. + 3. The 'docker' config's 'image' field. + """ + # TODO(rickyx): It's unfortunate we have multiple fields in ray-schema.json + # that can specify docker images. We should consolidate them. + docker_config = copy.deepcopy(self._configs.get("docker", {})) + node_specific_docker_config = self._configs["available_node_types"][ + ray_node_type + ].get("docker", {}) + # Override the global docker config with node specific docker config. + docker_config.update(node_specific_docker_config) + + if self._configs.get("head_node_type") == ray_node_type: + if "head_image" in docker_config: + logger.info( + "Overwriting image={} by head_image({}) for head node docker.".format( # noqa: E501 + docker_config["image"], docker_config["head_image"] + ) + ) + docker_config["image"] = docker_config["head_image"] + else: + if "worker_image" in docker_config: + logger.info( + "Overwriting image={} by worker_image({}) for worker node docker.".format( # noqa: E501 + docker_config["image"], docker_config["worker_image"] + ) + ) + docker_config["image"] = docker_config["worker_image"] + + # These fields should be merged. + docker_config.pop("head_image", None) + docker_config.pop("worker_image", None) + return docker_config + + def get_worker_start_ray_commands(self) -> List[str]: + return self._configs.get("worker_start_ray_commands", []) + + def get_head_setup_commands(self) -> List[str]: + return self._configs.get("head_setup_commands", []) + + def get_head_start_ray_commands(self) -> List[str]: + return self._configs.get("head_start_ray_commands", []) + + def get_worker_setup_commands(self, ray_node_type: NodeType) -> List[str]: + """ + Return the worker setup commands for the specified node type. + + If the node type specific worker setup commands are not specified, + return the global worker setup commands. + """ + worker_setup_command = self.get_node_type_specific_config( + ray_node_type, "worker_setup_commands" + ) + if worker_setup_command is None: + # Return global worker setup commands if node type specific + # worker setup commands are not specified. + logger.info( + "Using global worker setup commands for {}".format(ray_node_type) + ) + return self._configs.get("worker_setup_commands", []) + return worker_setup_command + + def get_initialization_commands(self, ray_node_type: NodeType) -> List[str]: + """ + Return the initialization commands for the specified node type. + + If the node type specific initialization commands are not specified, + return the global initialization commands. + """ + initialization_command = self.get_node_type_specific_config( + ray_node_type, "initialization_commands" + ) + if initialization_command is None: + logger.info( + "Using global initialization commands for {}".format(ray_node_type) + ) + return self._configs.get("initialization_commands", []) + return initialization_command + + def get_node_type_specific_config( + self, ray_node_type: NodeType, config_name: str + ) -> Optional[Any]: + node_specific_config = self._configs["available_node_types"].get( + ray_node_type, {} + ) + return node_specific_config.get(config_name, None) + + def get_node_resources(self, ray_node_type: NodeType) -> Dict[str, float]: + return copy.deepcopy( + self.get_node_type_specific_config(ray_node_type, "resources") or {} + ) + + def get_node_labels(self, ray_node_type: NodeType) -> Dict[str, str]: + return copy.deepcopy( + self.get_node_type_specific_config(ray_node_type, "labels") or {} + ) + + def get_config(self, config_name, default=None) -> Any: + return self._configs.get(config_name, default) + + def get_provider_instance_type(self, ray_node_type: NodeType) -> str: + provider = self.provider + node_config = self.get_node_type_specific_config(ray_node_type, "node_config") + if provider in [Provider.AWS, Provider.ALIYUN]: + return node_config.get("InstanceType", "") + elif provider == Provider.AZURE: + return node_config.get("azure_arm_parameters", {}).get("vmSize", "") + elif provider == Provider.GCP: + return node_config.get("machineType", "") + elif provider in [Provider.KUBERAY, Provider.LOCAL, Provider.UNKNOWN]: + return "" + else: + raise ValueError(f"Unknown provider {provider}") + + def get_node_type_configs(self) -> Dict[NodeType, NodeTypeConfig]: + """ + Returns the node type configs from the `available_node_types` field. + + Returns: + Dict[NodeType, NodeTypeConfig]: The node type configs. + """ + available_node_types = self._configs.get("available_node_types", {}) + if not available_node_types: + return None + node_type_configs = {} + auth_config = self._configs.get("auth", {}) + head_node_type = self.get_head_node_type() + assert head_node_type + for node_type, node_config in available_node_types.items(): + launch_config_hash = hash_launch_conf( + node_config.get("node_config", {}), auth_config + ) + max_workers_nodes = node_config.get("max_workers", 0) + if head_node_type == node_type: + max_workers_nodes += 1 + + node_type_configs[node_type] = NodeTypeConfig( + name=node_type, + min_worker_nodes=node_config.get("min_workers", 0), + max_worker_nodes=max_workers_nodes, + idle_timeout_s=node_config.get("idle_timeout_s", None), + resources=node_config.get("resources", {}), + labels=node_config.get("labels", {}), + launch_config_hash=launch_config_hash, + ) + return node_type_configs + + def get_head_node_type(self) -> NodeType: + """ + Returns the head node type. + + If there is only one node type, return the only node type as the head + node type. + If there are multiple node types, return the head node type specified + in the config. + """ + available_node_types = self._configs.get("available_node_types", {}) + if len(available_node_types) == 1: + return list(available_node_types.keys())[0] + return self._configs.get("head_node_type") + + def get_max_num_worker_nodes(self) -> Optional[int]: + return self.get_config("max_workers", None) + + def get_max_num_nodes(self) -> Optional[int]: + max_num_workers = self.get_max_num_worker_nodes() + if max_num_workers is not None: + return max_num_workers + 1 # For head node + return None + + def get_raw_config_mutable(self) -> Dict[str, Any]: + return self._configs + + def get_upscaling_speed(self) -> float: + return self.get_config("upscaling_speed", DEFAULT_UPSCALING_SPEED) + + def get_max_concurrent_launches(self) -> int: + return AUTOSCALER_MAX_CONCURRENT_LAUNCHES + + def disable_node_updaters(self) -> bool: + provider_config = self._configs.get("provider", {}) + return provider_config.get(DISABLE_NODE_UPDATERS_KEY, False) + + def get_idle_timeout_s(self) -> Optional[float]: + """ + Returns the idle timeout in seconds if present in config, otherwise None. + """ + idle_timeout_s = self.get_config("idle_timeout_minutes", None) + return idle_timeout_s * 60 if idle_timeout_s is not None else None + + def disable_launch_config_check(self) -> bool: + provider_config = self.get_provider_config() + return provider_config.get(DISABLE_LAUNCH_CONFIG_CHECK_KEY, True) + + def get_instance_reconcile_config(self) -> InstanceReconcileConfig: + # TODO(rickyx): we need a way to customize these configs, + # either extending the current ray-schema.json, or just use another + # schema validation paths. + return InstanceReconcileConfig() + + def get_provider_config(self) -> Dict[str, Any]: + return self._configs.get("provider", {}) + + def dump(self) -> str: + return yaml.safe_dump(self._configs) + + @property + def provider(self) -> Provider: + provider_str = self._configs.get("provider", {}).get("type", "") + if provider_str == "local": + return Provider.LOCAL + elif provider_str == "aws": + return Provider.AWS + elif provider_str == "azure": + return Provider.AZURE + elif provider_str == "gcp": + return Provider.GCP + elif provider_str == "aliyun": + return Provider.ALIYUN + elif provider_str == "kuberay": + return Provider.KUBERAY + elif provider_str == "readonly": + return Provider.READ_ONLY + else: + return Provider.UNKNOWN + + @property + def runtime_hash(self) -> str: + if not hasattr(self, "_runtime_hash"): + self._calculate_hashes() + return self._runtime_hash + + @property + def file_mounts_contents_hash(self) -> str: + if not hasattr(self, "_file_mounts_contents_hash"): + self._calculate_hashes() + return self._file_mounts_contents_hash + + +class FileConfigReader(IConfigReader): + """A class that reads cluster config from a yaml file.""" + + def __init__(self, config_file: str, skip_content_hash: bool = True) -> None: + """ + Args: + config_file: The path to the config file. + skip_content_hash: Whether to skip file mounts/ray command + hash calculation. Default to True. + """ + self._config_file_path = Path(config_file).resolve() + self._skip_content_hash = skip_content_hash + self._cached_config = self._read() + + def _read(self) -> AutoscalingConfig: + with open(self._config_file_path) as f: + config = yaml.safe_load(f.read()) + return AutoscalingConfig(config, skip_content_hash=self._skip_content_hash) + + def get_cached_autoscaling_config(self) -> AutoscalingConfig: + """ + Returns: + AutoscalingConfig: The autoscaling config. + """ + + return self._cached_config + + def refresh_cached_autoscaling_config(self): + self._cached_config = self._read() + + +class KubeRayConfigReader(IConfigReader): + """A class that reads cluster config from a K8s RayCluster CR.""" + + def __init__(self, config_producer: AutoscalingConfigProducer): + self._config_producer = config_producer + self._cached_config = self._generate_configs_from_k8s() + + def _generate_configs_from_k8s(self) -> AutoscalingConfig: + return AutoscalingConfig(self._config_producer()) + + def get_cached_autoscaling_config(self) -> AutoscalingConfig: + """ + Returns: + AutoscalingConfig: The autoscaling config. + """ + return self._cached_config + + def refresh_cached_autoscaling_config(self): + """ + Reads the configs from the K8s RayCluster CR. + + This reads from the K8s API server every time to pick up changes. + """ + self._cached_config = self._generate_configs_from_k8s() + + +class ReadOnlyProviderConfigReader(IConfigReader): + """A class that reads cluster config for a read-only provider. + + This is used for laptop mode / manual cluster setup modes, in order to + provide status reporting in the same way for users.""" + + def __init__(self, gcs_address: str): + self._configs = BASE_READONLY_CONFIG + self._gcs_client = GcsClient(address=gcs_address) + + def refresh_cached_autoscaling_config(self) -> AutoscalingConfig: + # Update the config with node types from GCS. + ray_cluster_resource_state = get_cluster_resource_state(self._gcs_client) + + # Format each node type's config from the running nodes. + available_node_types = {} + + head_node_type = None + for node_state in ray_cluster_resource_state.node_states: + node_type = node_state.ray_node_type_name + if not node_type: + node_type = format_readonly_node_type(binary_to_hex(node_state.node_id)) + + if is_head_node(node_state): + head_node_type = node_type + + if node_type not in available_node_types: + available_node_types[node_type] = { + "resources": dict(node_state.total_resources), + "min_workers": 0, + "max_workers": 0 if is_head_node(node_state) else 1, + "node_config": {}, + } + elif not is_head_node(node_state): + available_node_types[node_type]["max_workers"] += 1 + + if available_node_types: + self._configs["available_node_types"].update(available_node_types) + self._configs["max_workers"] = len(available_node_types) + assert head_node_type, "Head node type should be found." + self._configs["head_node_type"] = head_node_type + + # Don't idle terminated nodes in read-only mode. + self._configs.pop("idle_timeout_minutes", None) + + def get_cached_autoscaling_config(self) -> AutoscalingConfig: + return AutoscalingConfig(self._configs, skip_content_hash=True) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_manager.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..bff1fb9b6d2da30abf2c44e33b9a392be28859d0 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_manager.py @@ -0,0 +1,271 @@ +import logging +from abc import ABC, abstractmethod +from typing import List, Optional + +from ray.autoscaler.v2.instance_manager.common import InstanceUtil +from ray.autoscaler.v2.instance_manager.instance_storage import InstanceStorage +from ray.core.generated.instance_manager_pb2 import ( + GetInstanceManagerStateReply, + GetInstanceManagerStateRequest, + Instance, + InstanceUpdateEvent, + NodeKind, + StatusCode, + UpdateInstanceManagerStateReply, + UpdateInstanceManagerStateRequest, +) + +logger = logging.getLogger(__name__) + + +class InstanceUpdatedSubscriber(ABC): + """Subscribers to instance status changes.""" + + @abstractmethod + def notify(self, events: List[InstanceUpdateEvent]) -> None: + pass + + +class InstanceManager: + """ + See `InstanceManagerService` in instance_manager.proto + + This handles updates to an instance, or inserts a new instance if + it's an insert update. We should only be inserting new instances + of the below statuses: + 1. ALLOCATED: For unmanaged instance not initialized by InstanceManager, + e.g. head node + 2. QUEUED: For new instance being queued to launch. + 3. TERMINATING: For leaked cloud instance that needs to be terminated. + + For full status transitions, see: + https://docs.google.com/document/d/1NzQjA8Mh-oMc-QxXOa529oneWCoA8sDiVoNkBqqDb4U/edit#heading=h.k9a1sp4qpqj4 + + Not thread safe, should be used as a singleton. + """ + + def __init__( + self, + instance_storage: InstanceStorage, + instance_status_update_subscribers: Optional[List[InstanceUpdatedSubscriber]], + ): + self._instance_storage = instance_storage + self._status_update_subscribers = instance_status_update_subscribers or [] + + def update_instance_manager_state( + self, request: UpdateInstanceManagerStateRequest + ) -> UpdateInstanceManagerStateReply: + """ + Updates the instance manager state. + + If there's any failure, no updates would be made and the reply + would contain the latest version of the instance manager state, + and the error info. + + Args: + request: The request to update the instance manager state. + + Returns: + The reply to the request. + """ + + # Handle updates + ids_to_updates = {update.instance_id: update for update in request.updates} + to_update_instances, version = self._instance_storage.get_instances( + instance_ids=ids_to_updates.keys() + ) + + if request.expected_version >= 0 and request.expected_version != version: + err_str = ( + f"Version mismatch: expected: {request.expected_version}, " + f"actual: {version}" + ) + logger.warning(err_str) + return self._get_update_im_state_reply( + StatusCode.VERSION_MISMATCH, + version, + err_str, + ) + + # Handle instances states update. + to_upsert_instances = [] + for instance_id, update in ids_to_updates.items(): + if instance_id in to_update_instances: + instance = self._update_instance( + to_update_instances[instance_id], update + ) + else: + instance = self._create_instance(update) + + to_upsert_instances.append(instance) + + # Updates the instance storage. + result = self._instance_storage.batch_upsert_instances( + updates=to_upsert_instances, + expected_storage_version=version, + ) + + if not result.success: + if result.version != version: + err_str = ( + f"Version mismatch: expected: {version}, actual: {result.version}" + ) + logger.warning(err_str) + return self._get_update_im_state_reply( + StatusCode.VERSION_MISMATCH, result.version, err_str + ) + else: + err_str = "Failed to update instance storage." + logger.error(err_str) + return self._get_update_im_state_reply( + StatusCode.UNKNOWN_ERRORS, result.version, err_str + ) + + # Successful updates. + for subscriber in self._status_update_subscribers: + subscriber.notify(request.updates) + + return self._get_update_im_state_reply(StatusCode.OK, result.version) + + def get_instance_manager_state( + self, request: GetInstanceManagerStateRequest + ) -> GetInstanceManagerStateReply: + """ + Gets the instance manager state. + + Args: + request: The request to get the instance manager state. + + Returns: + The reply to the request. + """ + reply = GetInstanceManagerStateReply() + instances, version = self._instance_storage.get_instances() + reply.state.instances.extend(instances.values()) + reply.state.version = version + reply.status.code = StatusCode.OK + + return reply + + ######################################### + # Private methods + ######################################### + + @staticmethod + def _get_update_im_state_reply( + status_code: StatusCode, version: int, error_message: str = "" + ) -> UpdateInstanceManagerStateReply: + """ + Returns a UpdateInstanceManagerStateReply with the given status code and + version. + + Args: + status_code: The status code. + version: The version. + error_message: The error message if any. + + Returns: + The reply. + """ + reply = UpdateInstanceManagerStateReply() + reply.status.code = status_code + reply.version = version + if error_message: + reply.status.message = error_message + return reply + + @staticmethod + def _apply_update(instance: Instance, update: InstanceUpdateEvent): + """ + Apply status specific update to the instance. + + Args: + instance: The instance to update. + update: The update to apply. + """ + if update.new_instance_status == Instance.ALLOCATED: + assert ( + update.cloud_instance_id + ), "ALLOCATED update must have cloud_instance_id" + assert update.node_kind in [ + NodeKind.WORKER, + NodeKind.HEAD, + ], "ALLOCATED update must have node_kind as WORKER or HEAD" + assert update.instance_type, "ALLOCATED update must have instance_type" + assert ( + update.cloud_instance_id + ), "ALLOCATED update must have cloud_instance_id" + instance.cloud_instance_id = update.cloud_instance_id + instance.node_kind = update.node_kind + instance.instance_type = update.instance_type + instance.node_id = update.ray_node_id + elif update.new_instance_status == Instance.RAY_RUNNING: + assert update.ray_node_id, "RAY_RUNNING update must have ray_node_id" + instance.node_id = update.ray_node_id + elif update.new_instance_status == Instance.REQUESTED: + assert ( + update.launch_request_id + ), "REQUESTED update must have launch_request_id" + assert update.instance_type, "REQUESTED update must have instance_type" + instance.launch_request_id = update.launch_request_id + instance.instance_type = update.instance_type + elif update.new_instance_status == Instance.TERMINATING: + assert ( + update.cloud_instance_id + ), "TERMINATING update must have cloud instance id" + + @staticmethod + def _create_instance(update: InstanceUpdateEvent) -> Instance: + """ + Create a new instance from the given update. + """ + + assert update.upsert, "upsert must be true for creating new instance." + + assert update.new_instance_status in [ + # For unmanaged instance not initialized by InstanceManager, + # e.g. head node + Instance.ALLOCATED, + # For new instance being queued to launch. + Instance.QUEUED, + # For leaked cloud instance that needs to be terminated. + Instance.TERMINATING, + ], ( + "Invalid status for new instance, must be one of " + "[ALLOCATED, QUEUED, TERMINATING]" + ) + + # Create a new instance first for common fields. + instance = InstanceUtil.new_instance( + instance_id=update.instance_id, + instance_type=update.instance_type, + status=update.new_instance_status, + details=update.details, + ) + + # Apply the status specific updates. + logger.info(InstanceUtil.get_log_str_for_update(instance, update)) + InstanceManager._apply_update(instance, update) + return instance + + @staticmethod + def _update_instance(instance: Instance, update: InstanceUpdateEvent) -> Instance: + """ + Update the instance with the given update. + + Args: + instance: The instance to update. + update: The update to apply. + + Returns: + The updated instance. + """ + logger.info(InstanceUtil.get_log_str_for_update(instance, update)) + assert InstanceUtil.set_status(instance, update.new_instance_status), ( + "Invalid status transition from " + f"{Instance.InstanceStatus.Name(instance.status)} to " + f"{Instance.InstanceStatus.Name(update.new_instance_status)}" + ) + InstanceManager._apply_update(instance, update) + + return instance diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_storage.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_storage.py new file mode 100644 index 0000000000000000000000000000000000000000..645cd1eb904a83478f01803fd652ad82b4cb1b39 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/instance_storage.py @@ -0,0 +1,151 @@ +import copy +import logging +from typing import Dict, List, Optional, Set, Tuple + +from ray.autoscaler.v2.instance_manager.storage import Storage, StoreStatus +from ray.core.generated.instance_manager_pb2 import Instance + +logger = logging.getLogger(__name__) + + +class InstanceStorage: + """Instance storage stores the states of instances in the storage.""" + + def __init__( + self, + cluster_id: str, + storage: Storage, + ) -> None: + self._storage = storage + self._cluster_id = cluster_id + self._table_name = f"instance_table@{cluster_id}" + + def batch_upsert_instances( + self, + updates: List[Instance], + expected_storage_version: Optional[int] = None, + ) -> StoreStatus: + """Upsert instances into the storage. If the instance already exists, + it will be updated. Otherwise, it will be inserted. If the + expected_storage_version is specified, the update will fail if the + current storage version does not match the expected version. + + Note the version of the upserted instances will be set to the current + storage version. + + Args: + updates: A list of instances to be upserted. + expected_storage_version: The expected storage version. + + Returns: + StoreStatus: A tuple of (success, storage_version). + """ + mutations = {} + version = self._storage.get_version() + # handle version mismatch + if expected_storage_version and expected_storage_version != version: + return StoreStatus(False, version) + + for instance in updates: + instance = copy.deepcopy(instance) + # the instance version is set to 0, it will be + # populated by the storage entry's verion on read + instance.version = 0 + mutations[instance.instance_id] = instance.SerializeToString() + + result, version = self._storage.batch_update( + self._table_name, mutations, {}, expected_storage_version + ) + + return StoreStatus(result, version) + + def upsert_instance( + self, + instance: Instance, + expected_instance_version: Optional[int] = None, + expected_storage_verison: Optional[int] = None, + ) -> StoreStatus: + """Upsert an instance in the storage. + If the expected_instance_version is specified, the update will fail + if the current instance version does not match the expected version. + Similarly, if the expected_storage_version is + specified, the update will fail if the current storage version does not + match the expected version. + + Note the version of the upserted instances will be set to the current + storage version. + + Args: + instance: The instance to be updated. + expected_instance_version: The expected instance version. + expected_storage_version: The expected storage version. + + Returns: + StoreStatus: A tuple of (success, storage_version). + """ + instance = copy.deepcopy(instance) + # the instance version is set to 0, it will be + # populated by the storage entry's verion on read + instance.version = 0 + result, version = self._storage.update( + self._table_name, + key=instance.instance_id, + value=instance.SerializeToString(), + expected_entry_version=expected_instance_version, + expected_storage_version=expected_storage_verison, + insert_only=False, + ) + + return StoreStatus(result, version) + + def get_instances( + self, + instance_ids: List[str] = None, + status_filter: Set[int] = None, + ) -> Tuple[Dict[str, Instance], int]: + """Get instances from the storage. + + Args: + instance_ids: A list of instance ids to be retrieved. If empty, all + instances will be retrieved. + status_filter: Only instances with the specified status will be returned. + + Returns: + Tuple[Dict[str, Instance], int]: A tuple of (instances, version). + The instances is a dictionary of (instance_id, instance) pairs. + """ + instance_ids = instance_ids or [] + status_filter = status_filter or set() + pairs, version = self._storage.get(self._table_name, instance_ids) + instances = {} + for instance_id, (instance_data, entry_version) in pairs.items(): + instance = Instance() + instance.ParseFromString(instance_data) + instance.version = entry_version + if status_filter and instance.status not in status_filter: + continue + instances[instance_id] = instance + return instances, version + + def batch_delete_instances( + self, instance_ids: List[str], expected_storage_version: Optional[int] = None + ) -> StoreStatus: + """Delete instances from the storage. If the expected_version is + specified, the update will fail if the current storage version does not + match the expected version. + + Args: + to_delete: A list of instances to be deleted. + expected_version: The expected storage version. + + Returns: + StoreStatus: A tuple of (success, storage_version). + """ + version = self._storage.get_version() + if expected_storage_version and expected_storage_version != version: + return StoreStatus(False, version) + + result = self._storage.batch_update( + self._table_name, {}, instance_ids, expected_storage_version + ) + return result diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/node_provider.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/node_provider.py new file mode 100644 index 0000000000000000000000000000000000000000..263af5dc35217a0bd9a5cbf7271a7df0c93a3696 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/node_provider.py @@ -0,0 +1,529 @@ +import logging +import math +import time +from abc import ABC, abstractmethod +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass +from queue import Queue +from typing import Any, Dict, List, Optional + +from ray.autoscaler._private.constants import ( + AUTOSCALER_MAX_CONCURRENT_LAUNCHES, + AUTOSCALER_MAX_LAUNCH_BATCH, +) +from ray.autoscaler._private.util import hash_launch_conf +from ray.autoscaler.node_provider import NodeProvider as NodeProviderV1 +from ray.autoscaler.tags import ( + NODE_KIND_HEAD, + NODE_KIND_UNMANAGED, + NODE_KIND_WORKER, + STATUS_UNINITIALIZED, + TAG_RAY_LAUNCH_CONFIG, + TAG_RAY_LAUNCH_REQUEST, + TAG_RAY_NODE_KIND, + TAG_RAY_NODE_NAME, + TAG_RAY_NODE_STATUS, + TAG_RAY_USER_NODE_TYPE, +) +from ray.autoscaler.v2.instance_manager.config import IConfigReader +from ray.autoscaler.v2.schema import NodeType +from ray.core.generated.instance_manager_pb2 import NodeKind + +logger = logging.getLogger(__name__) + +# Type Alias. This is a **unique identifier** for a cloud instance in the cluster. +# The provider should guarantee that this id is unique across the cluster, +# such that: +# - When a cloud instance is created and running, no other cloud instance in the +# cluster has the same id. +# - When a cloud instance is terminated, no other cloud instance in the cluster will +# be assigned the same id later. +CloudInstanceId = str + + +@dataclass +class CloudInstance: + """ + A class that represents a cloud instance in the cluster, with necessary metadata + of the cloud instance. + """ + + # The cloud instance id. + cloud_instance_id: CloudInstanceId + # The node type of the cloud instance. + node_type: NodeType + # The node kind, i.e head or worker. + node_kind: NodeKind + # If the cloud instance is already running. + is_running: bool + # Update request id from which the cloud instance is launched. + # This could be None if the cloud instance couldn't be associated with requests + # by the cloud provider: e.g. cloud provider doesn't support per-instance + # extra metadata. + # This is fine for now since the reconciler should be able to know how + # to handle cloud instances w/o request ids. + # TODO: make this a required field. + request_id: Optional[str] = None + + +class CloudInstanceProviderError(Exception): + """ + An base error class that represents an error that happened in the cloud instance + provider. + """ + + # The timestamp of the error occurred in nanoseconds. + timestamp_ns: int + + def __init__(self, msg, timestamp_ns) -> None: + super().__init__(msg) + self.timestamp_ns = timestamp_ns + + +class LaunchNodeError(CloudInstanceProviderError): + # The node type that failed to launch. + node_type: NodeType + # Number of nodes that failed to launch. + count: int + # A unique id that identifies from which update request the error originates. + request_id: str + + def __init__( + self, + node_type: NodeType, + count: int, + request_id: str, + timestamp_ns: int, + details: str = "", + cause: Optional[Exception] = None, + ) -> None: + msg = ( + f"Failed to launch {count} nodes of type {node_type} with " + f"request id {request_id}: {details}" + ) + super().__init__(msg, timestamp_ns=timestamp_ns) + self.node_type = node_type + self.count = count + self.request_id = request_id + if cause: + self.__cause__ = cause + + def __repr__(self) -> str: + return ( + f"LaunchNodeError(node_type={self.node_type}, count={self.count}, " + f"request_id={self.request_id}): {self.__cause__}" + ) + + +class TerminateNodeError(CloudInstanceProviderError): + # The cloud instance id of the node that failed to terminate. + cloud_instance_id: CloudInstanceId + # A unique id that identifies from which update request the error originates. + request_id: str + + def __init__( + self, + cloud_instance_id: CloudInstanceId, + request_id: str, + timestamp_ns: int, + details: str = "", + cause: Optional[Exception] = None, + ) -> None: + msg = ( + f"Failed to terminate node {cloud_instance_id} with " + f"request id {request_id}: {details}" + ) + super().__init__(msg, timestamp_ns=timestamp_ns) + self.cloud_instance_id = cloud_instance_id + self.request_id = request_id + if cause: + self.__cause__ = cause + + def __repr__(self) -> str: + return ( + f"TerminateNodeError(cloud_instance_id={self.cloud_instance_id}, " + f"request_id={self.request_id}): {self.__cause__}" + ) + + +class ICloudInstanceProvider(ABC): + """ + The interface for a cloud instance provider. + + This interface is a minimal interface that should be implemented by the + various cloud instance providers (e.g. AWS, and etc). + + The cloud instance provider is responsible for managing the cloud instances in the + cluster. It provides the following main functionalities: + - Launch new cloud instances. + - Terminate existing running instances. + - Get the non-terminated cloud instances in the cluster. + - Poll the errors that happened for the updates to the cloud instance provider. + + Below properties of the cloud instance provider are assumed with this interface: + + 1. Eventually consistent + The cloud instance provider is expected to be eventually consistent with the + cluster state. For example, when a cloud instance is request to be terminated + or launched, the provider may not immediately reflect the change in its state. + However, the provider is expected to eventually reflect the change in its state. + + 2. Asynchronous + The provider could also be asynchronous, where the termination/launch + request may not immediately return the result of the request. + + 3. Unique cloud instance ids + Cloud instance ids are expected to be unique across the cluster. + + 4. Idempotent updates + For the update APIs (e.g. ensure_min_nodes, terminate), the provider may use the + request ids to provide idempotency. + + Usage: + ``` + provider: ICloudInstanceProvider = ... + + # Update the cluster with a desired shape. + provider.launch( + shape={ + "worker_nodes": 10, + "ray_head": 1, + }, + request_id="1", + ) + + # Get the non-terminated nodes of the cloud instance provider. + running = provider.get_non_terminated() + + # Poll the errors + errors = provider.poll_errors() + + # Terminate nodes. + provider.terminate( + ids=["cloud_instance_id_1", "cloud_instance_id_2"], + request_id="2", + ) + + # Process the state of the provider. + ... + ``` + """ + + @abstractmethod + def get_non_terminated(self) -> Dict[CloudInstanceId, CloudInstance]: + """Get the non-terminated cloud instances in the cluster. + + Returns: + A dictionary of the non-terminated cloud instances in the cluster. + The key is the cloud instance id, and the value is the cloud instance. + """ + pass + + @abstractmethod + def terminate(self, ids: List[CloudInstanceId], request_id: str) -> None: + """ + Terminate the cloud instances asynchronously. + + This method is expected to be idempotent, i.e. if the same request id is used + to terminate the same cloud instances, this should be a no-op if + the cloud instances are already terminated or being terminated. + + Args: + ids: the cloud instance ids to terminate. + request_id: a unique id that identifies the request. + """ + pass + + @abstractmethod + def launch( + self, + shape: Dict[NodeType, int], + request_id: str, + ) -> None: + """Launch the cloud instances asynchronously. + + Args: + shape: A map from node type to number of nodes to launch. + request_id: a unique id that identifies the update request. + """ + pass + + @abstractmethod + def poll_errors(self) -> List[CloudInstanceProviderError]: + """ + Poll the errors that happened since the last poll. + + This method would also clear the errors that happened since the last poll. + + Returns: + The errors that happened since the last poll. + """ + pass + + +@dataclass(frozen=True) +class CloudInstanceLaunchRequest: + """ + The arguments to launch a node. + """ + + # The node type to launch. + node_type: NodeType + # Number of nodes to launch. + count: int + # A unique id that identifies the request. + request_id: str + + +@dataclass(frozen=True) +class CloudInstanceTerminateRequest: + """ + The arguments to terminate a node. + """ + + # The cloud instance id of the node to terminate. + cloud_instance_id: CloudInstanceId + # A unique id that identifies the request. + request_id: str + + +class NodeProviderAdapter(ICloudInstanceProvider): + """ + Warps a NodeProviderV1 to a ICloudInstanceProvider. + + TODO(rickyx): + The current adapter right now consists of two sets of APIs: + - v1: the old APIs that are used by the autoscaler, where + we forward the calls to the NodeProviderV1. + - v2: the new APIs that are used by the autoscaler v2, this is + defined in the ICloudInstanceProvider interface. + + We should eventually remove the v1 APIs and only use the v2 APIs. + It's currently left as a TODO since changing the v1 APIs would + requires a lot of changes in the cluster launcher codebase. + """ + + def __init__( + self, + v1_provider: NodeProviderV1, + config_reader: IConfigReader, + max_launch_batch_per_type: int = AUTOSCALER_MAX_LAUNCH_BATCH, + max_concurrent_launches: int = AUTOSCALER_MAX_CONCURRENT_LAUNCHES, + ) -> None: + """ + Args: + v1_provider: The v1 node provider to wrap. + config_reader: The config reader to read the autoscaling config. + max_launch_batch_per_type: The maximum number of nodes to launch per + node type in a single batch. + max_concurrent_launches: The maximum number of concurrent launches. + """ + + super().__init__() + self._v1_provider = v1_provider + self._config_reader = config_reader + # Executor to async launching and terminating nodes. + self._main_executor = ThreadPoolExecutor( + max_workers=1, thread_name_prefix="ray::NodeProviderAdapter" + ) + + # v1 legacy rate limiting on the node provider launch calls. + self._max_launch_batch_per_type = max_launch_batch_per_type + max_batches = math.ceil( + max_concurrent_launches / float(max_launch_batch_per_type) + ) + self._node_launcher_executors = ThreadPoolExecutor( + max_workers=max_batches, + thread_name_prefix="ray::NodeLauncherPool", + ) + + # Queue to retrieve new errors occur in the multi-thread executors + # temporarily. + self._errors_queue = Queue() + + @property + def v1_provider(self) -> NodeProviderV1: + return self._v1_provider + + def get_non_terminated(self) -> Dict[CloudInstanceId, CloudInstance]: + nodes = {} + + cloud_instance_ids = self._v1_non_terminated_nodes({}) + # Filter out nodes that are not running. + # This is efficient since the provider is expected to cache the + # running status of the nodes. + for cloud_instance_id in cloud_instance_ids: + node_tags = self._v1_node_tags(cloud_instance_id) + node_kind_tag = node_tags.get(TAG_RAY_NODE_KIND, NODE_KIND_UNMANAGED) + if node_kind_tag == NODE_KIND_UNMANAGED: + # Filter out unmanaged nodes. + continue + elif node_kind_tag == NODE_KIND_WORKER: + node_kind = NodeKind.WORKER + elif node_kind_tag == NODE_KIND_HEAD: + node_kind = NodeKind.HEAD + else: + raise ValueError(f"Invalid node kind: {node_kind_tag}") + + nodes[cloud_instance_id] = CloudInstance( + cloud_instance_id=cloud_instance_id, + node_type=node_tags.get(TAG_RAY_USER_NODE_TYPE, ""), + is_running=self._v1_is_running(cloud_instance_id), + request_id=node_tags.get(TAG_RAY_LAUNCH_REQUEST, ""), + node_kind=node_kind, + ) + + return nodes + + def poll_errors(self) -> List[CloudInstanceProviderError]: + errors = [] + while not self._errors_queue.empty(): + errors.append(self._errors_queue.get_nowait()) + return errors + + def launch( + self, + shape: Dict[NodeType, int], + request_id: str, + ) -> None: + self._main_executor.submit(self._do_launch, shape, request_id) + + def terminate(self, ids: List[CloudInstanceId], request_id: str) -> None: + self._main_executor.submit(self._do_terminate, ids, request_id) + + ########################################### + # Private APIs + ########################################### + + def _do_launch( + self, + shape: Dict[NodeType, int], + request_id: str, + ) -> None: + """ + Launch the cloud instances by calling into the v1 base node provider. + + Args: + shape: The requested to launch node type and number of nodes. + request_id: The request id that identifies the request. + """ + for node_type, count in shape.items(): + # Keep submitting the launch requests to the launch pool in batches. + while count > 0: + to_launch = min(count, self._max_launch_batch_per_type) + self._node_launcher_executors.submit( + self._launch_nodes_by_type, + node_type, + to_launch, + request_id, + ) + count -= to_launch + + def _do_terminate(self, ids: List[CloudInstanceId], request_id: str) -> None: + """ + Terminate the cloud instances by calling into the v1 base node provider. + + If errors happen during the termination, the errors will be put into the + errors queue. + + Args: + ids: The cloud instance ids to terminate. + request_id: The request id that identifies the request. + """ + + try: + self._v1_terminate_nodes(ids) + except Exception as e: + for id in ids: + error = TerminateNodeError(id, request_id, int(time.time_ns())) + error.__cause__ = e + self._errors_queue.put(error) + + def _launch_nodes_by_type( + self, + node_type: NodeType, + count: int, + request_id: str, + ) -> None: + """ + Launch nodes of the given node type. + + Args: + node_type: The node type to launch. + count: Number of nodes to launch. + request_id: A unique id that identifies the request. + + Raises: + ValueError: If the node type is invalid. + LaunchNodeError: If the launch failed and raised by the underlying provider. + """ + # Check node type is valid. + try: + config = self._config_reader.get_cached_autoscaling_config() + launch_config = config.get_cloud_node_config(node_type) + resources = config.get_node_resources(node_type) + labels = config.get_node_labels(node_type) + + # This is to be compatible with the v1 node launcher. + # See more in https://github.com/ray-project/ray/blob/6f5a189bc463e52c51a70f8aea41fb2950b443e8/python/ray/autoscaler/_private/node_launcher.py#L78-L85 # noqa + # TODO: this should be synced with what's stored in the IM, it should + # probably be made as a metadata field in the cloud instance. This is + # another incompatibility with KubeRay. + launch_hash = hash_launch_conf(launch_config, config.get_config("auth", {})) + node_tags = { + TAG_RAY_NODE_NAME: "ray-{}-worker".format( + config.get_config("cluster_name", "") + ), + TAG_RAY_NODE_KIND: NODE_KIND_WORKER, + TAG_RAY_NODE_STATUS: STATUS_UNINITIALIZED, + TAG_RAY_LAUNCH_CONFIG: launch_hash, + TAG_RAY_LAUNCH_REQUEST: request_id, + TAG_RAY_USER_NODE_TYPE: node_type, + } + + logger.info("Launching {} nodes of type {}.".format(count, node_type)) + self._v1_provider.create_node_with_resources_and_labels( + launch_config, node_tags, count, resources, labels + ) + logger.info("Launched {} nodes of type {}.".format(count, node_type)) + except Exception as e: + logger.info( + "Failed to launch {} nodes of type {}: {}".format(count, node_type, e) + ) + error = LaunchNodeError(node_type, count, request_id, int(time.time_ns())) + error.__cause__ = e + self._errors_queue.put(error) + + ########################################### + # V1 Legacy APIs + ########################################### + """ + Below are the necessary legacy APIs from the V1 node provider. + These are needed as of now to provide the needed features + for V2 node provider. + The goal is to eventually remove these APIs and only use the + V2 APIs by modifying the individual node provider to inherit + from ICloudInstanceProvider. + """ + + def _v1_terminate_nodes( + self, ids: List[CloudInstanceId] + ) -> Optional[Dict[str, Any]]: + return self._v1_provider.terminate_nodes(ids) + + def _v1_non_terminated_nodes( + self, tag_filters: Dict[str, str] + ) -> List[CloudInstanceId]: + return self._v1_provider.non_terminated_nodes(tag_filters) + + def _v1_is_running(self, node_id: CloudInstanceId) -> bool: + return self._v1_provider.is_running(node_id) + + def _v1_post_process(self) -> None: + self._v1_provider.post_process() + + def _v1_node_tags(self, node_id: CloudInstanceId) -> Dict[str, str]: + return self._v1_provider.node_tags(node_id) + + def _v1_safe_to_scale(self) -> bool: + return self._v1_provider.safe_to_scale() diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/ray_installer.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/ray_installer.py new file mode 100644 index 0000000000000000000000000000000000000000..e99b2b1492cae16ffe27d4a909ba048005ee7505 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/ray_installer.py @@ -0,0 +1,96 @@ +import logging +import subprocess + +from ray.autoscaler._private.updater import ( + STATUS_UP_TO_DATE, + TAG_RAY_NODE_STATUS, + NodeUpdater, +) +from ray.autoscaler._private.util import with_envs, with_head_node_ip +from ray.autoscaler.node_provider import NodeProvider as NodeProviderV1 +from ray.autoscaler.v2.instance_manager.config import AutoscalingConfig +from ray.core.generated.instance_manager_pb2 import Instance + +logger = logging.getLogger(__name__) + + +class RayInstaller(object): + """ + RayInstaller is responsible for installing ray on the target instance. + """ + + def __init__( + self, + provider: NodeProviderV1, + config: AutoscalingConfig, + process_runner=subprocess, + ) -> None: + self._provider = provider + self._config = config + self._process_runner = process_runner + + def install_ray(self, instance: Instance, head_node_ip: str) -> None: + """ + Install ray on the target instance synchronously. + TODO:(rickyx): This runs in another thread, and errors are silently + ignored. We should propagate the error to the main thread. + """ + setup_commands = self._config.get_worker_setup_commands(instance.instance_type) + ray_start_commands = self._config.get_worker_start_ray_commands() + docker_config = self._config.get_docker_config(instance.instance_type) + + logger.info( + f"Creating new (spawn_updater) updater thread for node" + f" {instance.cloud_instance_id}." + ) + provider_instance_type_name = self._config.get_provider_instance_type( + instance.instance_type + ) + updater = NodeUpdater( + node_id=instance.cloud_instance_id, + provider_config=self._config.get_config("provider"), + provider=self._provider, + auth_config=self._config.get_config("auth"), + cluster_name=self._config.get_config("cluster_name"), + file_mounts=self._config.get_config("file_mounts"), + initialization_commands=with_head_node_ip( + self._config.get_initialization_commands(instance.instance_type), + head_node_ip, + ), + setup_commands=with_head_node_ip(setup_commands, head_node_ip), + # This will prepend envs to the begin of the ray start commands, e.g. + # `RAY_HEAD_IP= \ + # RAY_CLOUD_INSTANCE_ID= \ + # ray start --head ...` + # See src/ray/common/constants.h for ENV name definitions. + ray_start_commands=with_envs( + ray_start_commands, + { + "RAY_HEAD_IP": head_node_ip, + "RAY_CLOUD_INSTANCE_ID": instance.cloud_instance_id, + "RAY_NODE_TYPE_NAME": instance.instance_type, + "RAY_CLOUD_INSTANCE_TYPE_NAME": provider_instance_type_name, + }, + ), + runtime_hash=self._config.runtime_hash, + file_mounts_contents_hash=self._config.file_mounts_contents_hash, + is_head_node=False, + cluster_synced_files=self._config.get_config("cluster_synced_files"), + rsync_options={ + "rsync_exclude": self._config.get_config("rsync_exclude"), + "rsync_filter": self._config.get_config("rsync_filter"), + }, + use_internal_ip=True, + docker_config=docker_config, + node_resources=self._config.get_node_resources(instance.instance_type), + node_labels=self._config.get_node_labels(instance.instance_type), + process_runner=self._process_runner, + ) + updater.run() + # check if the updater was successful by checking the node tags + # since the updater could hide exceptions and just set the status tag + tags = self._provider.node_tags(instance.cloud_instance_id) + if tags.get(TAG_RAY_NODE_STATUS) != STATUS_UP_TO_DATE: + raise Exception( + f"Ray installation failed with unexpected status: {tags.get(TAG_RAY_NODE_STATUS)}" + ) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/reconciler.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/reconciler.py new file mode 100644 index 0000000000000000000000000000000000000000..b403803e577bdcff89ff475639fe7458a9d727a1 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/reconciler.py @@ -0,0 +1,1601 @@ +import logging +import math +import time +import uuid +from collections import defaultdict +from typing import Dict, List, Optional, Set, Tuple + +from ray._common.utils import binary_to_hex +from ray.autoscaler.v2.instance_manager.common import InstanceUtil +from ray.autoscaler.v2.instance_manager.config import ( + AutoscalingConfig, + InstanceReconcileConfig, + Provider, +) +from ray.autoscaler.v2.instance_manager.instance_manager import InstanceManager +from ray.autoscaler.v2.instance_manager.node_provider import ( + CloudInstance, + CloudInstanceId, + CloudInstanceProviderError, + ICloudInstanceProvider, + LaunchNodeError, + TerminateNodeError, +) +from ray.autoscaler.v2.instance_manager.subscribers.ray_stopper import RayStopError +from ray.autoscaler.v2.instance_manager.subscribers.threaded_ray_installer import ( + RayInstallError, +) +from ray.autoscaler.v2.metrics_reporter import AutoscalerMetricsReporter +from ray.autoscaler.v2.scheduler import IResourceScheduler, SchedulingRequest +from ray.autoscaler.v2.schema import AutoscalerInstance, NodeType +from ray.autoscaler.v2.utils import is_head_node +from ray.core.generated.autoscaler_pb2 import ( + AutoscalingState, + ClusterResourceState, + FailedInstanceRequest, + NodeState, + NodeStatus, + PendingInstance, + PendingInstanceRequest, +) +from ray.core.generated.instance_manager_pb2 import ( + GetInstanceManagerStateRequest, + Instance as IMInstance, + InstanceUpdateEvent as IMInstanceUpdateEvent, + NodeKind, + StatusCode, + UpdateInstanceManagerStateRequest, +) + +logger = logging.getLogger(__name__) + + +class Reconciler: + """ + A singleton class that reconciles the instance states of the instance manager + for autoscaler. + + """ + + @staticmethod + def reconcile( + instance_manager: InstanceManager, + scheduler: IResourceScheduler, + cloud_provider: ICloudInstanceProvider, + ray_cluster_resource_state: ClusterResourceState, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + autoscaling_config: AutoscalingConfig, + cloud_provider_errors: Optional[List[CloudInstanceProviderError]] = None, + ray_install_errors: Optional[List[RayInstallError]] = None, + ray_stop_errors: Optional[List[RayStopError]] = None, + metrics_reporter: Optional[AutoscalerMetricsReporter] = None, + _logger: Optional[logging.Logger] = None, + ) -> AutoscalingState: + """ + The reconcile method computes InstanceUpdateEvents for the instance manager + by: + + 1. Reconciling the instance manager's instances with external states like + the cloud provider's, the ray cluster's states, the ray installer's results. + It performs "passive" status transitions for the instances (where the status + transition should only be reflecting the external states of the cloud provider + and the ray cluster, and should not be actively changing them) + + 2. Stepping the instances to the active states by computing instance status + transitions that are needed and updating the instance manager's state. + These transitions should be "active" where the transitions have side effects + (through InstanceStatusSubscriber) to the cloud provider and the ray cluster. + + Args: + instance_manager: The instance manager to reconcile. + ray_cluster_resource_state: The ray cluster's resource state. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + cloud_provider_errors: The errors from the cloud provider. + ray_install_errors: The errors from RayInstaller. + ray_stop_errors: The errors from RayStopper. + metrics_reporter: The metric reporter to report the autoscaler metrics. + _logger: The logger (for testing). + + """ + cloud_provider_errors = cloud_provider_errors or [] + ray_install_errors = ray_install_errors or [] + ray_stop_errors = ray_stop_errors or [] + + autoscaling_state = AutoscalingState() + autoscaling_state.last_seen_cluster_resource_state_version = ( + ray_cluster_resource_state.cluster_resource_state_version + ) + + Reconciler._sync_from( + instance_manager=instance_manager, + ray_nodes=ray_cluster_resource_state.node_states, + non_terminated_cloud_instances=non_terminated_cloud_instances, + cloud_provider_errors=cloud_provider_errors, + ray_install_errors=ray_install_errors, + ray_stop_errors=ray_stop_errors, + autoscaling_config=autoscaling_config, + ) + + Reconciler._step_next( + autoscaling_state=autoscaling_state, + instance_manager=instance_manager, + scheduler=scheduler, + cloud_provider=cloud_provider, + ray_cluster_resource_state=ray_cluster_resource_state, + non_terminated_cloud_instances=non_terminated_cloud_instances, + autoscaling_config=autoscaling_config, + _logger=_logger, + ) + + Reconciler._report_metrics( + instance_manager=instance_manager, + autoscaling_config=autoscaling_config, + metrics_reporter=metrics_reporter, + ) + + return autoscaling_state + + @staticmethod + def _sync_from( + instance_manager: InstanceManager, + ray_nodes: List[NodeState], + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + cloud_provider_errors: List[CloudInstanceProviderError], + ray_install_errors: List[RayInstallError], + ray_stop_errors: List[RayStopError], + autoscaling_config: AutoscalingConfig, + ): + """ + Reconcile the instance states of the instance manager from external states like + the cloud provider's, the ray cluster's states, the ray installer's results, + etc. + + For each instance, we try to figure out if we need to transition the instance + status to a new status, and if so, what the new status should be. + + These transitions should be purely "passive", meaning they should only be + reflecting the external states of the cloud provider and the ray cluster, + and should not be actively changing the states of the cloud provider or the ray + cluster. + + More specifically, we will reconcile status transitions for: + 1. QUEUED/REQUESTED -> ALLOCATED: + When a instance with launch request id (indicating a previous launch + request was made) could be assigned to an unassigned cloud instance + of the same instance type. + 2. REQUESTED -> ALLOCATION_FAILED: + When there's an error from the cloud provider for launch failure so + that the instance becomes ALLOCATION_FAILED. + 3. * -> RAY_RUNNING: + When a ray node on a cloud instance joins the ray cluster, we will + transition the instance to RAY_RUNNING. + 4. * -> TERMINATED: + When the cloud instance is already terminated, we will transition the + instance to TERMINATED. + 5. TERMINATING -> TERMINATION_FAILED: + When there's an error from the cloud provider for termination failure. + 6. * -> RAY_STOPPED: + When ray was stopped on the cloud instance, we will transition the + instance to RAY_STOPPED. + 7. * -> RAY_INSTALL_FAILED: + When there's an error from RayInstaller. + 8. RAY_STOP_REQUESTED -> RAY_RUNNING: + When requested to stop ray, but failed to stop/drain the ray node + (e.g. idle termination drain rejected by the node). + + Args: + instance_manager: The instance manager to reconcile. + ray_nodes: The ray cluster's states of ray nodes. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + cloud_provider_errors: The errors from the cloud provider. + ray_install_errors: The errors from RayInstaller. + ray_stop_errors: The errors from RayStopper. + + """ + + # Handle 1 & 2 for cloud instance allocation. + Reconciler._handle_cloud_instance_allocation( + instance_manager, + non_terminated_cloud_instances, + cloud_provider_errors, + ) + Reconciler._handle_cloud_instance_terminated( + instance_manager, non_terminated_cloud_instances + ) + + Reconciler._handle_cloud_instance_termination_errors( + instance_manager, cloud_provider_errors + ) + + Reconciler._handle_extra_cloud_instances( + instance_manager, non_terminated_cloud_instances, ray_nodes + ) + + Reconciler._handle_ray_status_transition( + instance_manager, ray_nodes, autoscaling_config + ) + + Reconciler._handle_ray_install_failed(instance_manager, ray_install_errors) + + Reconciler._handle_ray_stop_failed(instance_manager, ray_stop_errors, ray_nodes) + + @staticmethod + def _step_next( + autoscaling_state: AutoscalingState, + instance_manager: InstanceManager, + scheduler: IResourceScheduler, + cloud_provider: ICloudInstanceProvider, + ray_cluster_resource_state: ClusterResourceState, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + autoscaling_config: AutoscalingConfig, + _logger: Optional[logging.Logger] = None, + ): + """ + Step the reconciler to the next state by computing instance status transitions + that are needed and updating the instance manager's state. + + Specifically, we will: + 1. Shut down leak cloud instances + Leaked cloud instances that are not managed by the instance manager. + 2. Terminating instances with ray stopped or ray install failure. + 3. Scale down the cluster: + (* -> RAY_STOP_REQUESTED/TERMINATING) + b. Extra cloud due to max nodes config. + c. Cloud instances with outdated configs. + 4. Scale up the cluster: + (new QUEUED) + Create new instances based on the IResourceScheduler's decision for + scaling up. + 5. Request cloud provider to launch new instances. + (QUEUED -> REQUESTED) + 6. Install ray + (ALLOCATED -> RAY_INSTALLING) + When ray could be installed and launched. + 7. Handle any stuck instances with timeouts. + + Args: + instance_manager: The instance manager to reconcile. + scheduler: The resource scheduler to make scaling decisions. + ray_cluster_resource_state: The ray cluster's resource state. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + autoscaling_config: The autoscaling config. + _logger: The logger (for testing). + + """ + + Reconciler._handle_stuck_instances( + instance_manager=instance_manager, + reconcile_config=autoscaling_config.get_instance_reconcile_config(), + _logger=_logger or logger, + ) + + Reconciler._scale_cluster( + autoscaling_state=autoscaling_state, + instance_manager=instance_manager, + ray_state=ray_cluster_resource_state, + scheduler=scheduler, + autoscaling_config=autoscaling_config, + ) + + Reconciler._handle_instances_launch( + instance_manager=instance_manager, autoscaling_config=autoscaling_config + ) + + Reconciler._terminate_instances(instance_manager=instance_manager) + if not autoscaling_config.disable_node_updaters(): + Reconciler._install_ray( + instance_manager=instance_manager, + non_terminated_cloud_instances=non_terminated_cloud_instances, + ) + + Reconciler._fill_autoscaling_state( + instance_manager=instance_manager, autoscaling_state=autoscaling_state + ) + + ####################################################### + # Utility methods for reconciling instance states. + ####################################################### + + @staticmethod + def _handle_cloud_instance_allocation( + instance_manager: InstanceManager, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + cloud_provider_errors: List[CloudInstanceProviderError], + ): + im_instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + + # Compute intermediate states. + + instances_with_launch_requests: List[IMInstance] = [] + for instance in im_instances: + if instance.status != IMInstance.REQUESTED: + continue + + assert ( + instance.launch_request_id + ), "Instance in REQUESTED status should have launch_request_id set." + instances_with_launch_requests.append(instance) + + assigned_cloud_instance_ids: Set[CloudInstanceId] = { + instance.cloud_instance_id + for instance in im_instances + if instance.cloud_instance_id + and instance.status + not in [IMInstance.TERMINATED, IMInstance.ALLOCATION_FAILED] + } + launch_errors: Dict[str, LaunchNodeError] = { + error.request_id: error + for error in cloud_provider_errors + if isinstance(error, LaunchNodeError) + } + unassigned_cloud_instances_by_type: Dict[ + str, List[CloudInstance] + ] = defaultdict(list) + + for cloud_instance_id, cloud_instance in non_terminated_cloud_instances.items(): + if cloud_instance_id not in assigned_cloud_instance_ids: + unassigned_cloud_instances_by_type[cloud_instance.node_type].append( + cloud_instance + ) + + # Sort the request instance by the increasing request time. + instances_with_launch_requests.sort( + key=lambda instance: InstanceUtil.get_status_transition_times_ns( + instance, IMInstance.REQUESTED + ) + ) + + # For each instance, try to allocate or fail the allocation. + for instance in instances_with_launch_requests: + # Try allocate or fail with errors. + update_event = Reconciler._try_resolve_pending_allocation( + instance, unassigned_cloud_instances_by_type, launch_errors + ) + if not update_event: + continue + + updates[instance.instance_id] = update_event + + # Update the instance manager for the events. + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _try_resolve_pending_allocation( + im_instance: IMInstance, + unassigned_cloud_instances_by_type: Dict[str, List[CloudInstance]], + launch_errors: Dict[str, LaunchNodeError], + ) -> Optional[IMInstanceUpdateEvent]: + """ + Allocate, or fail the cloud instance allocation for the instance. + + Args: + im_instance: The instance to allocate or fail. + unassigned_cloud_instances_by_type: The unassigned cloud instances by type. + launch_errors: The launch errors from the cloud provider. + + Returns: + Instance update to ALLOCATED: if there's a matching unassigned cloud + instance with the same type. + Instance update to ALLOCATION_FAILED: if the instance allocation failed + with errors. + None: if there's no update. + + """ + unassigned_cloud_instance = None + + # Try to allocate an unassigned cloud instance. + # TODO(rickyx): We could also look at the launch request id + # on the cloud node and the im instance later once all node providers + # support request id. For now, we only look at the instance type. + if len(unassigned_cloud_instances_by_type.get(im_instance.instance_type, [])): + unassigned_cloud_instance = unassigned_cloud_instances_by_type[ + im_instance.instance_type + ].pop() + + if unassigned_cloud_instance: + return IMInstanceUpdateEvent( + instance_id=im_instance.instance_id, + new_instance_status=IMInstance.ALLOCATED, + cloud_instance_id=unassigned_cloud_instance.cloud_instance_id, + node_kind=unassigned_cloud_instance.node_kind, + instance_type=unassigned_cloud_instance.node_type, + details=( + "allocated unassigned cloud instance " + f"{unassigned_cloud_instance.cloud_instance_id}" + ), + ) + + # If there's a launch error, transition to ALLOCATION_FAILED. + launch_error = launch_errors.get(im_instance.launch_request_id) + if launch_error and launch_error.node_type == im_instance.instance_type: + return IMInstanceUpdateEvent( + instance_id=im_instance.instance_id, + new_instance_status=IMInstance.ALLOCATION_FAILED, + details=f"launch failed with {str(launch_error)}", + ) + # No update. + return None + + @staticmethod + def _handle_ray_stop_failed( + instance_manager: InstanceManager, + ray_stop_errors: List[RayStopError], + ray_nodes: List[NodeState], + ): + """ + The instance requested to stop ray, but failed to stop/drain the ray node. + E.g. connection errors, idle termination drain rejected by the node. + + We will transition the instance back to RAY_RUNNING. + + Args: + instance_manager: The instance manager to reconcile. + ray_stop_errors: The errors from RayStopper. + + """ + instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + + ray_stop_errors_by_instance_id = { + error.im_instance_id: error for error in ray_stop_errors + } + + ray_nodes_by_ray_node_id = {binary_to_hex(n.node_id): n for n in ray_nodes} + + ray_stop_requested_instances = { + instance.instance_id: instance + for instance in instances + if instance.status == IMInstance.RAY_STOP_REQUESTED + } + + for instance_id, instance in ray_stop_requested_instances.items(): + stop_error = ray_stop_errors_by_instance_id.get(instance_id) + if not stop_error: + continue + + assert instance.node_id + ray_node = ray_nodes_by_ray_node_id.get(instance.node_id) + assert ray_node is not None and ray_node.status in [ + NodeStatus.RUNNING, + NodeStatus.IDLE, + ], ( + "There should be a running ray node for instance with ray stop " + "requested failed." + ) + + updates[instance_id] = IMInstanceUpdateEvent( + instance_id=instance_id, + new_instance_status=IMInstance.RAY_RUNNING, + details="failed to stop/drain ray", + ray_node_id=instance.node_id, + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _handle_ray_install_failed( + instance_manager: InstanceManager, ray_install_errors: List[RayInstallError] + ): + + instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + + # Get all instances with RAY_INSTALLING status. + instances_with_ray_installing = { + instance.instance_id: instance + for instance in instances + if instance.status == IMInstance.RAY_INSTALLING + } + + install_errors = {error.im_instance_id: error for error in ray_install_errors} + + # For each instance with RAY_INSTALLING status, check if there's any + # install error. + for instance_id, instance in instances_with_ray_installing.items(): + install_error = install_errors.get(instance_id) + if install_error: + updates[instance_id] = IMInstanceUpdateEvent( + instance_id=instance_id, + new_instance_status=IMInstance.RAY_INSTALL_FAILED, + details=( + f"failed to install ray with errors: {install_error.details}" + ), + ) + + # Update the instance manager for the events. + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _handle_cloud_instance_terminated( + instance_manager: InstanceManager, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + ): + """ + For any IM (instance manager) instance with a cloud node id, if the mapped + cloud instance is no longer running, transition the instance to TERMINATED. + + Args: + instance_manager: The instance manager to reconcile. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + """ + updates = {} + instances, version = Reconciler._get_im_instances(instance_manager) + + non_terminated_instances_with_cloud_instance_assigned = { + instance.cloud_instance_id: instance + for instance in instances + if instance.cloud_instance_id and instance.status != IMInstance.TERMINATED + } + + for ( + cloud_instance_id, + instance, + ) in non_terminated_instances_with_cloud_instance_assigned.items(): + if cloud_instance_id in non_terminated_cloud_instances.keys(): + # The cloud instance is still running. + continue + + # The cloud instance is terminated. + updates[instance.instance_id] = IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.TERMINATED, + details=f"cloud instance {cloud_instance_id} no longer found", + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _handle_cloud_instance_termination_errors( + instance_manager: InstanceManager, + cloud_provider_errors: List[CloudInstanceProviderError], + ): + """ + If any TERMINATING instances have termination errors, transition the instance to + TERMINATION_FAILED. + + We will retry the termination for the TERMINATION_FAILED instances in the next + reconciler step. + + Args: + instance_manager: The instance manager to reconcile. + cloud_provider_errors: The errors from the cloud provider. + + """ + instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + + termination_errors = { + error.cloud_instance_id: error + for error in cloud_provider_errors + if isinstance(error, TerminateNodeError) + } + + terminating_instances_by_cloud_instance_id = { + instance.cloud_instance_id: instance + for instance in instances + if instance.status == IMInstance.TERMINATING + } + + for cloud_instance_id, failure in termination_errors.items(): + instance = terminating_instances_by_cloud_instance_id.get(cloud_instance_id) + if not instance: + # The instance is no longer in TERMINATING status. + continue + + updates[instance.instance_id] = IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.TERMINATION_FAILED, + details=f"termination failed: {str(failure)}", + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _get_im_instances( + instance_manager: InstanceManager, + ) -> Tuple[List[IMInstance], int]: + reply = instance_manager.get_instance_manager_state( + request=GetInstanceManagerStateRequest() + ) + assert reply.status.code == StatusCode.OK + im_state = reply.state + return im_state.instances, im_state.version + + @staticmethod + def _update_instance_manager( + instance_manager: InstanceManager, + version: int, + updates: Dict[str, IMInstanceUpdateEvent], + ) -> None: + if not updates: + return + + updates = list(updates.values()) or [] + + reply = instance_manager.update_instance_manager_state( + request=UpdateInstanceManagerStateRequest( + expected_version=version, + updates=updates, + ) + ) + # TODO: While it's possible that a version mismatch + # happens, or some other failures could happen. But given + # the current implementation: + # 1. There's only 1 writer (the reconciler) for updating the instance + # manager states, so there shouldn't be version mismatch. + # 2. Any failures in one reconciler step should be caught at a higher + # level and be retried in the next reconciler step. If the IM + # fails to be updated, we don't have sufficient info to handle it + # here. + assert ( + reply.status.code == StatusCode.OK + ), f"Failed to update instance manager: {reply}" + + @staticmethod + def _handle_ray_status_transition( + instance_manager: InstanceManager, + ray_nodes: List[NodeState], + autoscaling_config: AutoscalingConfig, + ): + """ + Handle the ray status transition for the instance manager. + + If a new ray node running on the instance, transition it to RAY_RUNNING. + If a ray node stopped, transition it to RAY_STOPPED. + If a ray node is draining, transition it to RAY_STOPPING. + + Args: + instance_manager: The instance manager to reconcile. + ray_nodes: The ray cluster's states of ray nodes. + """ + instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + + im_instances_by_cloud_instance_id = { + instance.cloud_instance_id: instance + for instance in instances + if instance.cloud_instance_id + and instance.status + not in [IMInstance.TERMINATED, IMInstance.ALLOCATION_FAILED] + } + im_instances_by_ray_node_id = { + instance.node_id: instance for instance in instances if instance.node_id + } + + for ray_node in ray_nodes: + im_instance = None + ray_node_id = binary_to_hex(ray_node.node_id) + if ray_node_id in im_instances_by_ray_node_id: + im_instance = im_instances_by_ray_node_id[ray_node_id] + else: + if autoscaling_config.provider == Provider.READ_ONLY: + # We will use the node id as the cloud instance id for read-only + # provider. + im_instance = im_instances_by_cloud_instance_id[ray_node_id] + elif ray_node.instance_id: + im_instance = im_instances_by_cloud_instance_id[ + ray_node.instance_id + ] + else: + # This should only happen to a ray node that's not managed by us. + logger.warning( + f"Ray node {ray_node_id} has no instance id. " + "This only happens to a ray node not managed by autoscaler. " + "If not, please file a bug at " + "https://github.com/ray-project/ray" + ) + continue + + assert im_instance is not None, ( + f"Ray node {ray_node_id} has no matching " + f"instance with cloud instance id={ray_node.instance_id}. We should " + "not see a ray node with cloud instance id not found in IM since " + "we have reconciled all cloud instances, and ray nodes by now." + ) + + reconciled_im_status = Reconciler._reconciled_im_status_from_ray_status( + ray_node.status, im_instance.status + ) + + if reconciled_im_status != im_instance.status: + updates[ray_node_id] = IMInstanceUpdateEvent( + instance_id=im_instance.instance_id, + new_instance_status=reconciled_im_status, + details=( + f"ray node {ray_node_id} is " + f"{NodeStatus.Name(ray_node.status)}" + ), + ray_node_id=ray_node_id, + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _reconciled_im_status_from_ray_status( + ray_status: NodeStatus, cur_im_status: IMInstance.InstanceStatus + ) -> "IMInstance.InstanceStatus": + """ + Reconcile the instance status from the ray node status. + Args: + ray_status: the current ray node status. + cur_im_status: the current IM instance status. + Returns: + The reconciled IM instance status + + Raises: + ValueError: If the ray status is unknown. + """ + reconciled_im_status = None + if ray_status in [NodeStatus.RUNNING, NodeStatus.IDLE]: + reconciled_im_status = IMInstance.RAY_RUNNING + elif ray_status == NodeStatus.DEAD: + reconciled_im_status = IMInstance.RAY_STOPPED + elif ray_status == NodeStatus.DRAINING: + reconciled_im_status = IMInstance.RAY_STOPPING + else: + raise ValueError(f"Unknown ray status: {ray_status}") + + if ( + cur_im_status == reconciled_im_status + or cur_im_status + in InstanceUtil.get_reachable_statuses(reconciled_im_status) + ): + # No need to reconcile if the instance is already in the reconciled status + # or has already transitioned beyond it. + return cur_im_status + + return reconciled_im_status + + @staticmethod + def _handle_instances_launch( + instance_manager: InstanceManager, autoscaling_config: AutoscalingConfig + ): + + instances, version = Reconciler._get_im_instances(instance_manager) + + queued_instances = [] + requested_instances = [] + running_instances = [] + + for instance in instances: + if instance.status == IMInstance.QUEUED: + queued_instances.append(instance) + elif instance.status == IMInstance.REQUESTED: + requested_instances.append(instance) + elif instance.status == IMInstance.RAY_RUNNING: + running_instances.append(instance) + + if not queued_instances: + # No QUEUED instances + return + + to_launch = Reconciler._compute_to_launch( + queued_instances, + requested_instances, + running_instances, + autoscaling_config.get_upscaling_speed(), + autoscaling_config.get_max_concurrent_launches(), + ) + + # Transition the instances to REQUESTED for instance launcher to + # launch them. + updates = {} + new_launch_request_id = str(uuid.uuid4()) + for instance_type, instances in to_launch.items(): + for instance in instances: + # Reuse launch request id for any QUEUED instances that have been + # requested before due to retry. + launch_request_id = ( + new_launch_request_id + if len(instance.launch_request_id) == 0 + else instance.launch_request_id + ) + updates[instance.instance_id] = IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.REQUESTED, + launch_request_id=launch_request_id, + instance_type=instance_type, + details=( + f"requested to launch {instance_type} with request id " + f"{launch_request_id}" + ), + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _compute_to_launch( + queued_instances: List[IMInstance], + requested_instances: List[IMInstance], + running_instances: List[IMInstance], + upscaling_speed: float, + max_concurrent_launches: int, + ) -> Dict[NodeType, List[IMInstance]]: + def _group_by_type(instances): + instances_by_type = defaultdict(list) + for instance in instances: + instances_by_type[instance.instance_type].append(instance) + return instances_by_type + + # Sort the instances by the time they were queued. + def _sort_by_earliest_queued(instance: IMInstance) -> List[int]: + queue_times = InstanceUtil.get_status_transition_times_ns( + instance, IMInstance.QUEUED + ) + return sorted(queue_times) + + queued_instances_by_type = _group_by_type(queued_instances) + running_instances_by_type = _group_by_type(running_instances) + + total_num_requested_to_launch = len(requested_instances) + all_to_launch: Dict[NodeType : List[IMInstance]] = defaultdict(list) + + for ( + instance_type, + queued_instances_for_type, + ) in queued_instances_by_type.items(): + running_instances_for_type = running_instances_by_type.get( + instance_type, [] + ) + + # Enforce the max allowed pending nodes based on current running nodes + num_desired_to_upscale = max( + 1, + math.ceil(upscaling_speed * max(len(running_instances_for_type), 1)), + ) + + # Enforce global limit, at most we can launch `max_concurrent_launches` + num_to_launch = min( + max_concurrent_launches - total_num_requested_to_launch, + num_desired_to_upscale, + ) + + # Cap both ends 0 <= num_to_launch <= num_queued + num_to_launch = max(0, num_to_launch) + num_to_launch = min(len(queued_instances_for_type), num_to_launch) + + to_launch = sorted(queued_instances_for_type, key=_sort_by_earliest_queued)[ + :num_to_launch + ] + + all_to_launch[instance_type].extend(to_launch) + total_num_requested_to_launch += num_to_launch + + return all_to_launch + + @staticmethod + def _handle_stuck_instances( + instance_manager: InstanceManager, + reconcile_config: InstanceReconcileConfig, + _logger: logging.Logger, + ): + """ + Handle stuck instances with timeouts. + + Instances could be stuck in the following status and needs to be updated: + - REQUESTED: cloud provider is slow/fails to launch instances. + - ALLOCATED: ray fails to be started on the instance. + - RAY_INSTALLING: ray fails to be installed on the instance. + - TERMINATING: cloud provider is slow/fails to terminate instances. + + Instances could be in the following status which could be unbounded or + transient, and we don't have a timeout mechanism to handle them. We would + warn if they are stuck for too long: + - RAY_STOPPING: ray taking time to drain. + - QUEUED: cloud provider is slow to launch instances, resulting in long + queue. + + Reconciler should handle below statuses, if not, could be slow + reconcilation loop or a bug: + - RAY_INSTALL_FAILED + - RAY_STOPPED + - TERMINATION_FAILED + + + Args: + instance_manager: The instance manager to reconcile. + reconcile_config: The instance reconcile config. + _logger: The logger to log the warning messages. It's used for testing. + + """ + instances, version = Reconciler._get_im_instances(instance_manager) + + instances_by_status = defaultdict(list) + for instance in instances: + instances_by_status[instance.status].append(instance) + + im_updates = {} + + # Fail or retry the cloud instance allocation if it's stuck + # in the REQUESTED state. + for instance in instances_by_status[IMInstance.REQUESTED]: + update = Reconciler._handle_stuck_requested_instance( + instance, + reconcile_config.request_status_timeout_s, + reconcile_config.max_num_retry_request_to_allocate, + ) + if update: + im_updates[instance.instance_id] = update + + # Leaked ALLOCATED instances should be terminated. + # This usually happens when ray fails to be started on the instance, so + # it's unable to be RAY_RUNNING after a long time. + for instance in instances_by_status[IMInstance.ALLOCATED]: + assert ( + instance.cloud_instance_id + ), "cloud instance id should be set on ALLOCATED instance" + update = Reconciler._handle_stuck_instance( + instance, + reconcile_config.allocate_status_timeout_s, + new_status=IMInstance.TERMINATING, + cloud_instance_id=instance.cloud_instance_id, + ) + if update: + im_updates[instance.instance_id] = update + + # Fail the installation if it's stuck in RAY_INSTALLING for too long. + # If RAY_INSTALLING is stuck for too long, it's likely that the instance + # is not able to install ray, so we should also fail the installation. + for instance in instances_by_status[IMInstance.RAY_INSTALLING]: + update = Reconciler._handle_stuck_instance( + instance, + reconcile_config.ray_install_status_timeout_s, + new_status=IMInstance.RAY_INSTALL_FAILED, + ) + if update: + im_updates[instance.instance_id] = update + + # If we tried to terminate the instance, but it doesn't terminate (disappear + # from the cloud provider) after a long time, we fail the termination. + # This will trigger another attempt to terminate the instance. + for instance in instances_by_status[IMInstance.TERMINATING]: + update = Reconciler._handle_stuck_instance( + instance, + reconcile_config.terminating_status_timeout_s, + new_status=IMInstance.TERMINATION_FAILED, + ) + if update: + im_updates[instance.instance_id] = update + + # If we tried to stop ray on the instance, but it doesn't stop after a long + # time, we will transition it back to RAY_RUNNING as the stop/drain somehow + # failed. If it had succeed, we should have transitioned it to RAY_STOPPING + # or RAY_STOPPED. + for instance in instances_by_status[IMInstance.RAY_STOP_REQUESTED]: + update = Reconciler._handle_stuck_instance( + instance, + reconcile_config.ray_stop_requested_status_timeout_s, + new_status=IMInstance.RAY_RUNNING, + ray_node_id=instance.node_id, + ) + if update: + im_updates[instance.instance_id] = update + + # These statues could be unbounded or transient, and we don't have a timeout + # mechanism to handle them. We only warn if they are stuck for too long. + for status in [ + # Ray taking time to drain. We could also have a timeout when Drain protocol + # supports timeout. + IMInstance.RAY_STOPPING, + # These should just be transient, we will terminate instances with this + # status in the next reconciler step. + IMInstance.RAY_INSTALL_FAILED, + IMInstance.RAY_STOPPED, + IMInstance.TERMINATION_FAILED, + # Instances could be in the QUEUED status for a long time if the cloud + # provider is slow to launch instances. + IMInstance.QUEUED, + ]: + Reconciler._warn_stuck_instances( + instances_by_status[status], + status=status, + warn_interval_s=reconcile_config.transient_status_warn_interval_s, + logger=_logger, + ) + + Reconciler._update_instance_manager(instance_manager, version, im_updates) + + @staticmethod + def _warn_stuck_instances( + instances: List[IMInstance], + status: IMInstance.InstanceStatus, + warn_interval_s: int, + logger: logging.Logger, + ): + """Warn if any instance is stuck in a transient/unbounded status for too + long. + """ + for instance in instances: + status_times_ns = InstanceUtil.get_status_transition_times_ns( + instance, select_instance_status=status + ) + assert len(status_times_ns) >= 1 + status_time_ns = sorted(status_times_ns)[-1] + + if time.time_ns() - status_time_ns > warn_interval_s * 1e9: + logger.warning( + "Instance {}({}) is stuck in {} for {} seconds.".format( + instance.instance_id, + IMInstance.InstanceStatus.Name(instance.status), + IMInstance.InstanceStatus.Name(status), + (time.time_ns() - status_time_ns) // 1e9, + ) + ) + + @staticmethod + def _is_head_node_running(instance_manager: InstanceManager) -> bool: + """ + Check if the head node is running and ready. + + If we scale up the cluster before head node is running, + it would cause issues when launching the worker nodes. + + There are corner cases when the GCS is up (so the ray cluster resource + state is retrievable from the GCS), but the head node's raylet is not + running so the head node is missing from the reported nodes. This happens + when the head node is still starting up, or the raylet is not running + due to some issues, and this would yield false. + + Args: + instance_manager: The instance manager to reconcile. + + Returns: + True if the head node is running and ready, False otherwise. + """ + + im_instances, _ = Reconciler._get_im_instances(instance_manager) + + for instance in im_instances: + if instance.node_kind == NodeKind.HEAD: + if instance.status == IMInstance.RAY_RUNNING: + return True + return False + + @staticmethod + def _scale_cluster( + autoscaling_state: AutoscalingState, + instance_manager: InstanceManager, + ray_state: ClusterResourceState, + scheduler: IResourceScheduler, + autoscaling_config: AutoscalingConfig, + ) -> None: + """ + Scale the cluster based on the resource state and the resource scheduler's + decision: + + - It launches new instances if needed. + - It terminates extra ray nodes if they should be shut down (preemption + or idle termination) + + Args: + autoscaling_state: The autoscaling state to reconcile. + instance_manager: The instance manager to reconcile. + ray_state: The ray cluster's resource state. + scheduler: The resource scheduler to make scaling decisions. + autoscaling_config: The autoscaling config. + + """ + + # Get the current instance states. + im_instances, version = Reconciler._get_im_instances(instance_manager) + + im_instances_by_instance_id = { + i.instance_id: i for i in im_instances if i.instance_id + } + autoscaler_instances = [] + ray_nodes_by_id = { + binary_to_hex(node.node_id): node for node in ray_state.node_states + } + + for im_instance in im_instances: + ray_node = ray_nodes_by_id.get(im_instance.node_id) + autoscaler_instances.append( + AutoscalerInstance( + ray_node=ray_node, + im_instance=im_instance, + cloud_instance_id=( + im_instance.cloud_instance_id + if im_instance.cloud_instance_id + else None + ), + ) + ) + + # TODO(rickyx): We should probably name it as "Planner" or "Scaler" + # or "ClusterScaler" + sched_request = SchedulingRequest( + node_type_configs=autoscaling_config.get_node_type_configs(), + max_num_nodes=autoscaling_config.get_max_num_nodes(), + resource_requests=ray_state.pending_resource_requests, + gang_resource_requests=ray_state.pending_gang_resource_requests, + cluster_resource_constraints=ray_state.cluster_resource_constraints, + current_instances=autoscaler_instances, + idle_timeout_s=autoscaling_config.get_idle_timeout_s(), + disable_launch_config_check=( + autoscaling_config.disable_launch_config_check() + ), + ) + + # Ask scheduler for updates to the cluster shape. + reply = scheduler.schedule(sched_request) + + # Populate the autoscaling state. + autoscaling_state.infeasible_resource_requests.extend( + reply.infeasible_resource_requests + ) + autoscaling_state.infeasible_gang_resource_requests.extend( + reply.infeasible_gang_resource_requests + ) + autoscaling_state.infeasible_cluster_resource_constraints.extend( + reply.infeasible_cluster_resource_constraints + ) + + if not Reconciler._is_head_node_running(instance_manager): + # We shouldn't be scaling the cluster until the head node is ready. + # This could happen when the head node (i.e. the raylet) is still + # pending registration even though GCS is up. + # We will wait until the head node is running and ready to avoid + # scaling the cluster from min worker nodes constraint. + return + + if autoscaling_config.provider == Provider.READ_ONLY: + # We shouldn't be scaling the cluster if the provider is read-only. + return + + # Scale the clusters if needed. + to_launch = reply.to_launch + to_terminate = reply.to_terminate + updates = {} + # Add terminating instances. + for terminate_request in to_terminate: + instance_id = terminate_request.instance_id + if terminate_request.instance_status == IMInstance.ALLOCATED: + # The instance is not yet running, so we can't request to stop/drain Ray. + # Therefore, we can skip the RAY_STOP_REQUESTED state and directly terminate the node. + im_instance_to_terminate = im_instances_by_instance_id[instance_id] + updates[terminate_request.instance_id] = IMInstanceUpdateEvent( + instance_id=instance_id, + new_instance_status=IMInstance.TERMINATING, + cloud_instance_id=im_instance_to_terminate.cloud_instance_id, + termination_request=terminate_request, + details=f"terminating ray: {terminate_request.details}", + ) + else: + updates[terminate_request.instance_id] = IMInstanceUpdateEvent( + instance_id=instance_id, + new_instance_status=IMInstance.RAY_STOP_REQUESTED, + termination_request=terminate_request, + details=f"draining ray: {terminate_request.details}", + ) + + # Add new instances. + for launch_request in to_launch: + for _ in range(launch_request.count): + instance_id = InstanceUtil.random_instance_id() + updates[instance_id] = IMInstanceUpdateEvent( + instance_id=instance_id, + new_instance_status=IMInstance.QUEUED, + instance_type=launch_request.instance_type, + upsert=True, + details=( + f"queuing new instance of {launch_request.instance_type} " + "from scheduler" + ), + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _terminate_instances(instance_manager: InstanceManager): + """ + Terminate instances with the below statuses: + - RAY_STOPPED: ray was stopped on the cloud instance. + - RAY_INSTALL_FAILED: ray installation failed on the cloud instance, + we will not retry. + - TERMINATION_FAILED: cloud provider failed to terminate the instance + or timeout for termination happened, we will retry again. + + Args: + instance_manager: The instance manager to reconcile. + """ + + im_instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + for instance in im_instances: + if instance.status not in [ + IMInstance.RAY_STOPPED, + IMInstance.RAY_INSTALL_FAILED, + IMInstance.TERMINATION_FAILED, + ]: + continue + + # Terminate the instance. + updates[instance.instance_id] = IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.TERMINATING, + cloud_instance_id=instance.cloud_instance_id, + details="terminating instance from " + f"{IMInstance.InstanceStatus.Name(instance.status)}", + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _install_ray( + instance_manager: InstanceManager, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + ) -> None: + """ + Install ray on the allocated instances when it's ready (cloud instance + should be running) + + This is needed if ray installation needs to be performed by + the instance manager. + + Args: + instance_manager: The instance manager to reconcile. + """ + im_instances, version = Reconciler._get_im_instances(instance_manager) + updates = {} + for instance in im_instances: + if instance.status != IMInstance.ALLOCATED: + continue + + if instance.node_kind == NodeKind.HEAD: + # Skip head node. + continue + + cloud_instance = non_terminated_cloud_instances.get( + instance.cloud_instance_id + ) + + assert cloud_instance, ( + f"Cloud instance {instance.cloud_instance_id} is not found " + "in non_terminated_cloud_instances." + ) + + if not cloud_instance.is_running: + # It might still be pending (e.g. setting up ssh) + continue + + # Install ray on the running cloud instance + updates[instance.instance_id] = IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.RAY_INSTALLING, + details="installing ray", + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _fill_autoscaling_state( + instance_manager: InstanceManager, + autoscaling_state: AutoscalingState, + ) -> None: + + # Use the IM instance version for the autoscaler_state_version + instances, version = Reconciler._get_im_instances(instance_manager) + autoscaling_state.autoscaler_state_version = version + + # Group instances by status + instances_by_status = defaultdict(list) + for instance in instances: + instances_by_status[instance.status].append(instance) + + # Pending instance requests + instances_by_launch_request = defaultdict(list) + queued_instances = [] + for instance in ( + instances_by_status[IMInstance.REQUESTED] + + instances_by_status[IMInstance.QUEUED] + ): + if instance.launch_request_id: + instances_by_launch_request[instance.launch_request_id].append(instance) + else: + queued_instances.append(instance) + + for _, instances in instances_by_launch_request.items(): + num_instances_by_type = defaultdict(int) + for instance in instances: + num_instances_by_type[instance.instance_type] += 1 + + # All instances with same request id should have the same + # request time. + request_update = InstanceUtil.get_last_status_transition( + instances[0], IMInstance.REQUESTED + ) + request_time_ns = request_update.timestamp_ns if request_update else 0 + + for instance_type, count in num_instances_by_type.items(): + autoscaling_state.pending_instance_requests.append( + PendingInstanceRequest( + ray_node_type_name=instance_type, + count=int(count), + request_ts=int(request_time_ns // 1e9), + ) + ) + + # Pending instances + for instance in ( + instances_by_status[IMInstance.ALLOCATED] + + instances_by_status[IMInstance.RAY_INSTALLING] + ): + + status_history = sorted( + instance.status_history, key=lambda x: x.timestamp_ns, reverse=True + ) + autoscaling_state.pending_instances.append( + PendingInstance( + instance_id=instance.instance_id, + ray_node_type_name=instance.instance_type, + details=status_history[0].details, + ) + ) + + # Failed instance requests + for instance in instances_by_status[IMInstance.ALLOCATION_FAILED]: + request_status_update = InstanceUtil.get_last_status_transition( + instance, IMInstance.REQUESTED + ) + failed_status_update = InstanceUtil.get_last_status_transition( + instance, IMInstance.ALLOCATION_FAILED + ) + failed_time = ( + failed_status_update.timestamp_ns if failed_status_update else 0 + ) + request_time = ( + request_status_update.timestamp_ns if request_status_update else 0 + ) + autoscaling_state.failed_instance_requests.append( + FailedInstanceRequest( + ray_node_type_name=instance.instance_type, + start_ts=int(request_time // 1e9), + failed_ts=int( + failed_time // 1e9, + ), + reason=failed_status_update.details, + count=1, + ) + ) + + @staticmethod + def _handle_stuck_requested_instance( + instance: IMInstance, timeout_s: int, max_num_retry_request_to_allocate: int + ) -> Optional[IMInstanceUpdateEvent]: + """ + Fail the cloud instance allocation if it's stuck in the REQUESTED state. + + Args: + instance: The instance to handle. + timeout_s: The timeout in seconds. + max_num_retry_request_to_allocate: The maximum number of times an instance + could be requested to allocate. + + Returns: + Instance update to ALLOCATION_FAILED: if the instance allocation failed + with errors. + None: if there's no update. + + """ + if not InstanceUtil.has_timeout(instance, timeout_s): + # Not timeout yet, be patient. + return None + + all_request_times_ns = sorted( + InstanceUtil.get_status_transition_times_ns( + instance, select_instance_status=IMInstance.REQUESTED + ) + ) + + # Fail the allocation if we have tried too many times. + if len(all_request_times_ns) > max_num_retry_request_to_allocate: + return IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.ALLOCATION_FAILED, + details=( + "failed to allocate cloud instance after " + f"{len(all_request_times_ns)} attempts > " + f"max_num_retry_request_to_allocate={max_num_retry_request_to_allocate}" # noqa + ), + ) + + # Retry the allocation if we could by transitioning to QUEUED again. + return IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=IMInstance.QUEUED, + details=f"queue again to launch after timeout={timeout_s}s", + ) + + @staticmethod + def _handle_stuck_instance( + instance: IMInstance, + timeout_s: int, + new_status: IMInstance.InstanceStatus, + **update_kwargs: Dict, + ) -> Optional[IMInstanceUpdateEvent]: + """ + Fail the instance if it's stuck in the status for too long. + + Args: + instance: The instance to handle. + timeout_s: The timeout in seconds. + new_status: The new status to transition to. + update_kwargs: The update kwargs for InstanceUpdateEvent + + Returns: + Instance update to the new status: if the instance is stuck in the status + for too long. + None: if there's no update. + + """ + if not InstanceUtil.has_timeout(instance, timeout_s): + # Not timeout yet, be patient. + return None + + return IMInstanceUpdateEvent( + instance_id=instance.instance_id, + new_instance_status=new_status, + details=f"timeout={timeout_s}s at status " + f"{IMInstance.InstanceStatus.Name(instance.status)}", + **update_kwargs, + ) + + @staticmethod + def _handle_extra_cloud_instances( + instance_manager: InstanceManager, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + ray_nodes: List[NodeState], + ): + """ + For extra cloud instances (i.e. cloud instances that are non terminated as + returned by cloud provider, but not managed by the instance manager), we + will create new IM instances with ALLOCATED status. + + Such instances could either be: + 1. Leaked instances that are incorrectly started by the cloud instance + provider, and they would be terminated eventually if they fail to + transition to RAY_RUNNING by stuck instances reconciliation, or they + would join the ray cluster and be terminated when the cluster scales down. + 2. Instances that are started by the cloud instance provider intentionally + but not yet discovered by the instance manager. This could happen for + a. Head node that's started before the autoscaler. + b. Worker nodes that's started by the cloud provider upon users' + actions: i.e. KubeRay scaling up the cluster with ray cluster config + change. + 3. Ray nodes with cloud instance id not in the cloud provider. This could + happen if there's delay in the Ray's state (i.e. cloud instance already + terminated, but the ray node is still not dead yet). + + Args: + instance_manager: The instance manager to reconcile. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + ray_nodes: The ray cluster's states of ray nodes. + """ + Reconciler._handle_extra_cloud_instances_from_ray_nodes( + instance_manager, ray_nodes + ) + Reconciler._handle_extra_cloud_instances_from_cloud_provider( + instance_manager, non_terminated_cloud_instances + ) + + @staticmethod + def _handle_extra_cloud_instances_from_cloud_provider( + instance_manager: InstanceManager, + non_terminated_cloud_instances: Dict[CloudInstanceId, CloudInstance], + ): + """ + For extra cloud instances that are not managed by the instance manager but + are running in the cloud provider, we will create new IM instances with + ALLOCATED status. + + Args: + instance_manager: The instance manager to reconcile. + non_terminated_cloud_instances: The non-terminated cloud instances from + the cloud provider. + """ + updates = {} + + instances, version = Reconciler._get_im_instances(instance_manager) + cloud_instance_ids_managed_by_im = { + instance.cloud_instance_id + for instance in instances + if instance.cloud_instance_id + and instance.status + not in [IMInstance.TERMINATED, IMInstance.ALLOCATION_FAILED] + } + + # Find the extra cloud instances that are not managed by the instance manager. + for cloud_instance_id, cloud_instance in non_terminated_cloud_instances.items(): + if cloud_instance_id in cloud_instance_ids_managed_by_im: + continue + updates[cloud_instance_id] = IMInstanceUpdateEvent( + instance_id=InstanceUtil.random_instance_id(), # Assign a new id. + cloud_instance_id=cloud_instance_id, + new_instance_status=IMInstance.ALLOCATED, + node_kind=cloud_instance.node_kind, + instance_type=cloud_instance.node_type, + details=( + "allocated unmanaged cloud instance :" + f"{cloud_instance.cloud_instance_id} " + f"({NodeKind.Name(cloud_instance.node_kind)}) from cloud provider" + ), + upsert=True, + ) + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _handle_extra_cloud_instances_from_ray_nodes( + instance_manager: InstanceManager, ray_nodes: List[NodeState] + ): + """ + For extra cloud instances reported by Ray but not managed by the instance + manager, we will create new IM instances with ALLOCATED status. + + Args: + instance_manager: The instance manager to reconcile. + ray_nodes: The ray cluster's states of ray nodes. + """ + updates = {} + + instances, version = Reconciler._get_im_instances(instance_manager) + cloud_instance_ids_managed_by_im = { + instance.cloud_instance_id + for instance in instances + if instance.cloud_instance_id + and not instance.node_id + and instance.status + not in [IMInstance.TERMINATED, IMInstance.ALLOCATION_FAILED] + } + ray_node_ids_managed_by_im = { + instance.node_id for instance in instances if instance.node_id + } + + for ray_node in ray_nodes: + if not ray_node.instance_id: + continue + + ray_node_id = binary_to_hex(ray_node.node_id) + if ray_node_id in ray_node_ids_managed_by_im: + continue + + cloud_instance_id = ray_node.instance_id + if cloud_instance_id in cloud_instance_ids_managed_by_im: + continue + + is_head = is_head_node(ray_node) + updates[ray_node_id] = IMInstanceUpdateEvent( + instance_id=InstanceUtil.random_instance_id(), # Assign a new id. + cloud_instance_id=cloud_instance_id, + new_instance_status=IMInstance.ALLOCATED, + node_kind=NodeKind.HEAD if is_head else NodeKind.WORKER, + ray_node_id=ray_node_id, + instance_type=ray_node.ray_node_type_name, + details=( + "allocated unmanaged worker cloud instance from ray node: " + f"{ray_node_id}" + ), + upsert=True, + ) + + Reconciler._update_instance_manager(instance_manager, version, updates) + + @staticmethod + def _report_metrics( + instance_manager: InstanceManager, + autoscaling_config: AutoscalingConfig, + metrics_reporter: Optional[AutoscalerMetricsReporter] = None, + ): + if not metrics_reporter: + return + + instances, _ = Reconciler._get_im_instances(instance_manager) + node_type_configs = autoscaling_config.get_node_type_configs() + + metrics_reporter.report_instances(instances, node_type_configs) + metrics_reporter.report_resources(instances, node_type_configs) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/storage.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/storage.py new file mode 100644 index 0000000000000000000000000000000000000000..40447bf796962de488a8f11add7f3f0786dace3a --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/storage.py @@ -0,0 +1,180 @@ +import copy +from abc import ABCMeta, abstractmethod +from collections import defaultdict, namedtuple +from threading import Lock +from typing import Dict, List, Optional, Tuple + +StoreStatus = namedtuple("StoreStatus", ["success", "version"]) +VersionedValue = namedtuple("VersionedValue", ["value", "version"]) + + +class Storage(metaclass=ABCMeta): + """Interface for a storage backend that stores the state of nodes in the cluster. + + The storage is thread-safe. + + The storage is versioned, which means that each successful stage change to the + storage will bump the version number. The version number can be used to + implement optimistic concurrency control. + + Each entry in the storage table is also versioned. The version number of an entry + is the last version number when the entry is updated. + """ + + @abstractmethod + def batch_update( + self, + table: str, + mutation: Optional[Dict[str, str]] = None, + deletion: Optional[List[str]] = None, + expected_storage_version: Optional[int] = None, + ) -> StoreStatus: + """Batch update the storage table. This method is atomic. + + Args: + table: The name of the table. + mutation: A dictionary of key-value pairs to be updated. + deletion: A list of keys to be deleted. + expected_storage_version: The expected storage version. The + update will fail if the version does not match the + current storage version. + + Returns: + StoreStatus: A tuple of (success, version). If the update is + successful, returns (True, new_version). + Otherwise, returns (False, current_version). + """ + raise NotImplementedError("batch_update() has to be implemented") + + @abstractmethod + def update( + self, + table: str, + key: str, + value: str, + expected_entry_version: Optional[int] = None, + insert_only: bool = False, + ) -> StoreStatus: + """Update a single entry in the storage table. + + Args: + table: The name of the table. + key: The key of the entry. + value: The value of the entry. + expected_entry_version: The expected version of the entry. + The update will fail if the version does not match the current + version of the entry. + insert_only: If True, the update will + fail if the entry already exists. + Returns: + StoreStatus: A tuple of (success, version). If the update is + successful, returns (True, new_version). Otherwise, + returns (False, current_version). + """ + raise NotImplementedError("update() has to be implemented") + + @abstractmethod + def get_all(self, table: str) -> Tuple[Dict[str, Tuple[str, int]], int]: + raise NotImplementedError("get_all() has to be implemented") + + @abstractmethod + def get( + self, table: str, keys: List[str] + ) -> Tuple[Dict[str, Tuple[str, int]], int]: + """Get a list of entries from the storage table. + + Args: + table: The name of the table. + keys: A list of keys to be retrieved. If the list is empty, + all entries in the table will be returned. + + Returns: + Tuple[Dict[str, VersionedValue], int]: A tuple of + (entries, storage_version). The entries is a dictionary of + (key, (value, entry_version)) pairs. The entry_version is the + version of the entry when it was last updated. The + storage_version is the current storage version. + """ + raise NotImplementedError("get() has to be implemented") + + @abstractmethod + def get_version(self) -> int: + """Get the current storage version. + + Returns: + int: The current storage version. + """ + raise NotImplementedError("get_version() has to be implemented") + + +class InMemoryStorage(Storage): + """An in-memory implementation of the Storage interface. This implementation + is not durable""" + + def __init__(self): + self._version = 0 + self._tables = defaultdict(dict) + self._lock = Lock() + + def batch_update( + self, + table: str, + mutation: Dict[str, str] = None, + deletion: List[str] = None, + expected_version: Optional[int] = None, + ) -> StoreStatus: + mutation = mutation if mutation else {} + deletion = deletion if deletion else [] + with self._lock: + if expected_version is not None and expected_version != self._version: + return StoreStatus(False, self._version) + self._version += 1 + key_value_pairs_with_version = { + key: VersionedValue(value, self._version) + for key, value in mutation.items() + } + self._tables[table].update(key_value_pairs_with_version) + for deleted_key in deletion: + self._tables[table].pop(deleted_key, None) + return StoreStatus(True, self._version) + + def update( + self, + table: str, + key: str, + value: str, + expected_entry_version: Optional[int] = None, + expected_storage_version: Optional[int] = None, + insert_only: bool = False, + ) -> StoreStatus: + with self._lock: + if ( + expected_storage_version is not None + and expected_storage_version != self._version + ): + return StoreStatus(False, self._version) + if insert_only and key in self._tables[table]: + return StoreStatus(False, self._version) + _, version = self._tables[table].get(key, (None, -1)) + if expected_entry_version is not None and expected_entry_version != version: + return StoreStatus(False, self._version) + self._version += 1 + self._tables[table][key] = VersionedValue(value, self._version) + return StoreStatus(True, self._version) + + def get_all(self, table: str) -> Tuple[Dict[str, VersionedValue], int]: + with self._lock: + return (copy.deepcopy(self._tables[table]), self._version) + + def get(self, table: str, keys: List[str]) -> Tuple[Dict[str, VersionedValue], int]: + if not keys: + return self.get_all(table) + with self._lock: + result = {} + for key in keys: + if key in self._tables.get(table, {}): + result[key] = self._tables[table][key] + return StoreStatus(result, self._version) + + def get_version(self) -> int: + return self._version diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__init__.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..426702a52267d196d3864e903bf97c4c76a17cab Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/cloud_instance_updater.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/cloud_instance_updater.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c01532888673c546c6276eec8ce69dff557026e1 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/cloud_instance_updater.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/ray_stopper.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/ray_stopper.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c330c165825ec860cd4361dbd7198580a7edba0 Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/ray_stopper.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/threaded_ray_installer.cpython-312.pyc b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/threaded_ray_installer.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1250450432740286b7e55579d1b5f0e55bff43cc Binary files /dev/null and b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/__pycache__/threaded_ray_installer.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/cloud_instance_updater.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/cloud_instance_updater.py new file mode 100644 index 0000000000000000000000000000000000000000..747525439d2d1c157d6d276ec942744ba50a8fb5 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/cloud_instance_updater.py @@ -0,0 +1,93 @@ +import logging +import uuid +from collections import defaultdict +from typing import List + +from ray.autoscaler.v2.instance_manager.instance_manager import ( + InstanceUpdatedSubscriber, +) +from ray.autoscaler.v2.instance_manager.node_provider import ICloudInstanceProvider +from ray.core.generated.instance_manager_pb2 import Instance, InstanceUpdateEvent + +logger = logging.getLogger(__name__) + + +class CloudInstanceUpdater(InstanceUpdatedSubscriber): + """CloudInstanceUpdater is responsible for launching + new instances and terminating cloud instances + + It requests the cloud instance provider to launch new instances when + there are new instance requests (with REQUESTED status change). + + It requests the cloud instance provider to terminate instances when + there are new instance terminations (with TERMINATING status change). + + The cloud instance APIs are async and non-blocking. + """ + + def __init__( + self, + cloud_provider: ICloudInstanceProvider, + ) -> None: + self._cloud_provider = cloud_provider + + def notify(self, events: List[InstanceUpdateEvent]) -> None: + new_requests = [ + event for event in events if event.new_instance_status == Instance.REQUESTED + ] + new_terminations = [ + event + for event in events + if event.new_instance_status == Instance.TERMINATING + ] + self._launch_new_instances(new_requests) + self._terminate_instances(new_terminations) + + def _terminate_instances(self, new_terminations: List[InstanceUpdateEvent]): + """ + Terminate cloud instances through cloud provider. + + Args: + new_terminations: List of new instance terminations. + """ + if not new_terminations: + logger.debug("No instances to terminate.") + return + + # Terminate the instances. + cloud_instance_ids = [event.cloud_instance_id for event in new_terminations] + + # This is an async call. + self._cloud_provider.terminate( + ids=cloud_instance_ids, request_id=str(uuid.uuid4()) + ) + + def _launch_new_instances(self, new_requests: List[InstanceUpdateEvent]): + """ + Launches new instances by requesting the cloud provider. + + Args: + new_requests: List of new instance requests. + + """ + if not new_requests: + logger.debug("No instances to launch.") + return + + # Group new requests by launch request id. + requests_by_launch_request_id = defaultdict(list) + + for event in new_requests: + assert ( + event.launch_request_id + ), "Launch request id should have been set by the reconciler" + requests_by_launch_request_id[event.launch_request_id].append(event) + + for launch_request_id, events in requests_by_launch_request_id.items(): + request_shape = defaultdict(int) + for event in events: + request_shape[event.instance_type] += 1 + # Make requests to the cloud provider. + self._cloud_provider.launch( + shape=request_shape, request_id=launch_request_id + ) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/ray_stopper.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/ray_stopper.py new file mode 100644 index 0000000000000000000000000000000000000000..75b35b373a91c8f4f98914fc9b8573ea88334ee6 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/ray_stopper.py @@ -0,0 +1,154 @@ +import logging +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass +from queue import Queue +from typing import List + +from ray._common.utils import hex_to_binary +from ray._raylet import GcsClient +from ray.autoscaler.v2.instance_manager.instance_manager import ( + InstanceUpdatedSubscriber, +) +from ray.core.generated.autoscaler_pb2 import DrainNodeReason +from ray.core.generated.instance_manager_pb2 import ( + Instance, + InstanceUpdateEvent, + TerminationRequest, +) + +logger = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class RayStopError: + # Instance manager's instance id. + im_instance_id: str + + +class RayStopper(InstanceUpdatedSubscriber): + """RayStopper is responsible for stopping ray on instances. + + It will drain the ray node if it's for idle termination. + For other terminations, it will stop the ray node. (e.g. scale down, etc.) + + If any failures happen when stopping/draining the node, we will not retry + and rely on the reconciler to handle the failure. + + TODO: we could also surface the errors back to the reconciler for + quicker failure detection. + + """ + + def __init__(self, gcs_client: GcsClient, error_queue: Queue) -> None: + self._gcs_client = gcs_client + self._error_queue = error_queue + self._executor = ThreadPoolExecutor(max_workers=1) + + def notify(self, events: List[InstanceUpdateEvent]) -> None: + for event in events: + if event.new_instance_status == Instance.RAY_STOP_REQUESTED: + fut = self._executor.submit(self._stop_or_drain_ray, event) + + def _log_on_error(fut): + try: + fut.result() + except Exception: + logger.exception("Error stopping/drain ray.") + + fut.add_done_callback(_log_on_error) + + def _stop_or_drain_ray(self, event: InstanceUpdateEvent) -> None: + """ + Stops or drains the ray node based on the termination request. + """ + assert event.HasField("termination_request"), "Termination request is required." + termination_request = event.termination_request + ray_node_id = termination_request.ray_node_id + instance_id = event.instance_id + + if termination_request.cause == TerminationRequest.Cause.IDLE: + reason = DrainNodeReason.DRAIN_NODE_REASON_IDLE_TERMINATION + reason_str = "Termination of node that's idle for {} seconds.".format( + termination_request.idle_duration_ms / 1000 + ) + self._drain_ray_node( + self._gcs_client, + self._error_queue, + ray_node_id, + instance_id, + reason, + reason_str, + ) + return + + # If it's not an idle termination, we stop the ray node. + self._stop_ray_node( + self._gcs_client, self._error_queue, ray_node_id, instance_id + ) + + @staticmethod + def _drain_ray_node( + gcs_client: GcsClient, + error_queue: Queue, + ray_node_id: str, + instance_id: str, + reason: DrainNodeReason, + reason_str: str, + ): + """ + Drains the ray node. + + Args: + gcs_client: The gcs client to use. + ray_node_id: The ray node id to drain. + reason: The reason to drain the node. + reason_str: The reason message to drain the node. + """ + try: + accepted, reject_msg_str = gcs_client.drain_node( + node_id=ray_node_id, + reason=reason, + reason_message=reason_str, + # TODO: we could probably add a deadline here that's derived + # from the stuck instance reconciliation configs. + deadline_timestamp_ms=0, + ) + logger.info( + f"Drained ray on {ray_node_id}(success={accepted}, " + f"msg={reject_msg_str})" + ) + if not accepted: + error_queue.put_nowait(RayStopError(im_instance_id=instance_id)) + except Exception: + logger.exception(f"Error draining ray on {ray_node_id}") + error_queue.put_nowait(RayStopError(im_instance_id=instance_id)) + + @staticmethod + def _stop_ray_node( + gcs_client: GcsClient, + error_queue: Queue, + ray_node_id: str, + instance_id: str, + ): + """ + Stops the ray node. + + Args: + gcs_client: The gcs client to use. + ray_node_id: The ray node id to stop. + """ + try: + drained = gcs_client.drain_nodes(node_ids=[hex_to_binary(ray_node_id)]) + success = len(drained) > 0 + logger.info( + f"Stopping ray on {ray_node_id}(instance={instance_id}): " + f"success={success})" + ) + + if not success: + error_queue.put_nowait(RayStopError(im_instance_id=instance_id)) + except Exception: + logger.exception( + f"Error stopping ray on {ray_node_id}(instance={instance_id})" + ) + error_queue.put_nowait(RayStopError(im_instance_id=instance_id)) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/threaded_ray_installer.py b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/threaded_ray_installer.py new file mode 100644 index 0000000000000000000000000000000000000000..d525b1aeccaaf3d790c9b824d9d30c95d0d61cfe --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/instance_manager/subscribers/threaded_ray_installer.py @@ -0,0 +1,95 @@ +import dataclasses +import logging +import time +from concurrent.futures import ThreadPoolExecutor +from queue import Queue +from typing import List + +from ray.autoscaler.v2.instance_manager.instance_manager import ( + InstanceUpdatedSubscriber, +) +from ray.autoscaler.v2.instance_manager.instance_storage import InstanceStorage +from ray.autoscaler.v2.instance_manager.ray_installer import RayInstaller +from ray.core.generated.instance_manager_pb2 import ( + Instance, + InstanceUpdateEvent, + NodeKind, +) + +logger = logging.getLogger(__name__) + + +@dataclasses.dataclass(frozen=True) +class RayInstallError: + # Instance manager's instance id. + im_instance_id: str + # Error details. + details: str + + +class ThreadedRayInstaller(InstanceUpdatedSubscriber): + """ThreadedRayInstaller is responsible for install ray on new nodes.""" + + def __init__( + self, + head_node_ip: str, + instance_storage: InstanceStorage, + ray_installer: RayInstaller, + error_queue: Queue, + max_install_attempts: int = 3, + install_retry_interval: int = 10, + max_concurrent_installs: int = 50, + ) -> None: + self._head_node_ip = head_node_ip + self._instance_storage = instance_storage + self._ray_installer = ray_installer + self._max_concurrent_installs = max_concurrent_installs + self._max_install_attempts = max_install_attempts + self._install_retry_interval = install_retry_interval + self._error_queue = error_queue + self._ray_installation_executor = ThreadPoolExecutor( + max_workers=self._max_concurrent_installs + ) + + def notify(self, events: List[InstanceUpdateEvent]) -> None: + for event in events: + if event.new_instance_status == Instance.RAY_INSTALLING: + self._install_ray_on_new_nodes(event.instance_id) + + def _install_ray_on_new_nodes(self, instance_id: str) -> None: + allocated_instance, _ = self._instance_storage.get_instances( + instance_ids={instance_id}, + status_filter={Instance.RAY_INSTALLING}, + ) + for instance in allocated_instance.values(): + assert instance.node_kind == NodeKind.WORKER + self._ray_installation_executor.submit( + self._install_ray_on_single_node, instance + ) + + def _install_ray_on_single_node(self, instance: Instance) -> None: + assert instance.status == Instance.RAY_INSTALLING + + # install with exponential backoff + backoff_factor = 1 + last_exception = None + for _ in range(self._max_install_attempts): + try: + self._ray_installer.install_ray(instance, self._head_node_ip) + return + except Exception as e: + logger.info( + f"Ray installation failed on instance {instance.cloud_instance_id}: {e}" + ) + last_exception = e + + logger.warning("Failed to install ray, retrying...") + time.sleep(self._install_retry_interval * backoff_factor) + backoff_factor *= 2 + + self._error_queue.put_nowait( + RayInstallError( + im_instance_id=instance.instance_id, + details=str(last_exception), + ) + ) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/metrics_reporter.py b/lib/python3.12/site-packages/ray/autoscaler/v2/metrics_reporter.py new file mode 100644 index 0000000000000000000000000000000000000000..4fbe6e10f1db419ed2ee73949fde94129d55fee9 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/metrics_reporter.py @@ -0,0 +1,100 @@ +from collections import defaultdict +from typing import Dict, List + +from ray.autoscaler._private.prom_metrics import AutoscalerPrometheusMetrics +from ray.autoscaler.v2.instance_manager.common import InstanceUtil +from ray.autoscaler.v2.instance_manager.config import NodeTypeConfig +from ray.autoscaler.v2.schema import NodeType +from ray.core.generated.instance_manager_pb2 import Instance as IMInstance + + +class AutoscalerMetricsReporter: + def __init__(self, prom_metrics: AutoscalerPrometheusMetrics) -> None: + self._prom_metrics = prom_metrics + + def report_instances( + self, + instances: List[IMInstance], + node_type_configs: Dict[NodeType, NodeTypeConfig], + ): + """ + Record autoscaler metrics for: + - pending_nodes: Nodes that are launching/pending ray start + - active_nodes: Active nodes (nodes running ray) + - recently_failed_nodes: Nodes that are being terminated. + - stopped_nodes: Nodes that are terminated. + """ + # map of instance type to a dict of status to count. + status_count_by_type: Dict[NodeType : Dict[str, int]] = {} + # initialize the status count by type. + for instance_type in node_type_configs.keys(): + status_count_by_type[instance_type] = { + "pending": 0, + "running": 0, + "terminating": 0, + "terminated": 0, + } + + for instance in instances: + if InstanceUtil.is_ray_pending(instance.status): + status_count_by_type[instance.instance_type]["pending"] += 1 + elif InstanceUtil.is_ray_running(instance.status): + status_count_by_type[instance.instance_type]["running"] += 1 + elif instance.status == IMInstance.TERMINATING: + status_count_by_type[instance.instance_type]["terminating"] += 1 + elif instance.status == IMInstance.TERMINATED: + status_count_by_type[instance.instance_type]["terminated"] += 1 + + for instance_type, status_count in status_count_by_type.items(): + self._prom_metrics.pending_nodes.labels( + SessionName=self._prom_metrics.session_name, NodeType=instance_type + ).set(status_count["pending"]) + + self._prom_metrics.active_nodes.labels( + SessionName=self._prom_metrics.session_name, NodeType=instance_type + ).set(status_count["running"]) + + self._prom_metrics.recently_failed_nodes.labels( + SessionName=self._prom_metrics.session_name, NodeType=instance_type + ).set(status_count["terminating"]) + + self._prom_metrics.stopped_nodes.inc(status_count["terminated"]) + + def report_resources( + self, + instances: List[IMInstance], + node_type_configs: Dict[NodeType, NodeTypeConfig], + ): + """ + Record autoscaler metrics for: + - pending_resources: Pending resources + - cluster_resources: Cluster resources (resources running on the cluster) + """ + # pending resources. + pending_resources = defaultdict(float) + cluster_resources = defaultdict(float) + + def _add_resources(resource_map, node_type_configs, node_type, count): + node_resources = node_type_configs[node_type].resources + for resource_name, resource_value in node_resources.items(): + resource_map[resource_name] += resource_value * count + + for instance in instances: + if InstanceUtil.is_ray_pending(instance.status): + _add_resources( + pending_resources, node_type_configs, instance.instance_type, 1 + ) + elif InstanceUtil.is_ray_running(instance.status): + _add_resources( + cluster_resources, node_type_configs, instance.instance_type, 1 + ) + + for resource_name, resource_value in pending_resources.items(): + self._prom_metrics.pending_resources.labels( + SessionName=self._prom_metrics.session_name, resource=resource_name + ).set(resource_value) + + for resource_name, resource_value in cluster_resources.items(): + self._prom_metrics.cluster_resources.labels( + SessionName=self._prom_metrics.session_name, resource=resource_name + ).set(resource_value) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/monitor.py b/lib/python3.12/site-packages/ray/autoscaler/v2/monitor.py new file mode 100644 index 0000000000000000000000000000000000000000..34e31e7ac649d0673361fd7c848616f1e4c564ac --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/monitor.py @@ -0,0 +1,336 @@ +"""Autoscaler monitoring loop daemon. + +See autoscaler._private/monitor.py for the legacy implementation. All the legacy flags +are supported here, but the new implementation uses the new autoscaler v2. +""" + +import argparse +import logging +import os +import sys +import time +from typing import Optional + +import ray +import ray._private.ray_constants as ray_constants +from ray._common.network_utils import build_address, parse_address +from ray._common.ray_constants import ( + LOGGING_ROTATE_BACKUP_COUNT, + LOGGING_ROTATE_BYTES, +) +from ray._common.usage.usage_lib import record_extra_usage_tag +from ray._private import logging_utils +from ray._private.event.event_logger import get_event_logger +from ray._private.ray_logging import setup_component_logger +from ray._private.worker import SCRIPT_MODE +from ray._raylet import GcsClient +from ray.autoscaler._private.constants import ( + AUTOSCALER_METRIC_PORT, + AUTOSCALER_UPDATE_INTERVAL_S, +) +from ray.autoscaler._private.prom_metrics import AutoscalerPrometheusMetrics +from ray.autoscaler.v2.autoscaler import Autoscaler +from ray.autoscaler.v2.event_logger import AutoscalerEventLogger +from ray.autoscaler.v2.instance_manager.config import ( + FileConfigReader, + IConfigReader, + ReadOnlyProviderConfigReader, +) +from ray.autoscaler.v2.metrics_reporter import AutoscalerMetricsReporter +from ray.core.generated.autoscaler_pb2 import AutoscalingState +from ray.core.generated.event_pb2 import Event as RayEvent +from ray.core.generated.usage_pb2 import TagKey + +try: + import prometheus_client +except ImportError: + prometheus_client = None + + +logger = logging.getLogger(__name__) + + +class AutoscalerMonitor: + """Autoscaling monitor. + + This process periodically collects stats from the GCS and triggers + autoscaler updates. + + TODO: + We should also handle autoscaler failures properly in the future. + Right now, we don't restart autoscaler if it fails (internal reconciliation + however, should not fail the autoscaler process). + With the Reconciler able to handle extra cloud instances, we could in fact + recover the autoscaler process from reconciliation. + """ + + def __init__( + self, + address: str, + config_reader: IConfigReader, + log_dir: Optional[str] = None, + monitor_ip: Optional[str] = None, + ): + # Record v2 usage (we do this as early as possible to capture usage) + record_autoscaler_v2_usage(GcsClient(address)) + + self.gcs_address = address + worker = ray._private.worker.global_worker + # TODO: eventually plumb ClusterID through to here + self.gcs_client = GcsClient(address=self.gcs_address) + + if monitor_ip: + monitor_addr = build_address(monitor_ip, AUTOSCALER_METRIC_PORT) + self.gcs_client.internal_kv_put( + b"AutoscalerMetricsAddress", monitor_addr.encode(), True, None + ) + self._session_name = self._get_session_name(self.gcs_client) + logger.info(f"session_name: {self._session_name}") + worker.set_mode(SCRIPT_MODE) + head_node_ip = parse_address(self.gcs_address)[0] + + self.autoscaler = None + if log_dir: + try: + ray_event_logger = get_event_logger( + RayEvent.SourceType.AUTOSCALER, log_dir + ) + self.event_logger = AutoscalerEventLogger(ray_event_logger) + except Exception: + self.event_logger = None + else: + self.event_logger = None + + prom_metrics = AutoscalerPrometheusMetrics(session_name=self._session_name) + self.metric_reporter = AutoscalerMetricsReporter(prom_metrics) + + if monitor_ip and prometheus_client: + # If monitor_ip wasn't passed in, then don't attempt to start the + # metric server to keep behavior identical to before metrics were + # introduced + try: + logger.info( + "Starting autoscaler metrics server on port {}".format( + AUTOSCALER_METRIC_PORT + ) + ) + kwargs = {"addr": "127.0.0.1"} if head_node_ip == "127.0.0.1" else {} + prometheus_client.start_http_server( + port=AUTOSCALER_METRIC_PORT, + registry=prom_metrics.registry, + **kwargs, + ) + except Exception: + logger.exception( + "An exception occurred while starting the metrics server." + ) + elif not prometheus_client: + logger.warning( + "`prometheus_client` not found, so metrics will not be exported." + ) + + self.autoscaler = Autoscaler( + session_name=self._session_name, + config_reader=config_reader, + gcs_client=self.gcs_client, + event_logger=self.event_logger, + metrics_reporter=self.metric_reporter, + ) + + @staticmethod + def _get_session_name(gcs_client: GcsClient) -> Optional[str]: + """Obtain the session name from the GCS. + + If the GCS doesn't respond, session name is considered None. + In this case, the metrics reported from the monitor won't have + the correct session name. + """ + session_name = gcs_client.internal_kv_get( + b"session_name", + ray_constants.KV_NAMESPACE_SESSION, + timeout=10, + ) + + if session_name: + session_name = session_name.decode() + + return session_name + + @staticmethod + def _report_autoscaling_state( + gcs_client: GcsClient, autoscaling_state: AutoscalingState + ): + """Report the autoscaling state to the GCS.""" + try: + gcs_client.report_autoscaling_state(autoscaling_state.SerializeToString()) + except Exception: + logger.exception("Error reporting autoscaling state to GCS.") + + def _run(self): + """Run the monitor loop.""" + + while True: + autoscaling_state = self.autoscaler.update_autoscaling_state() + if autoscaling_state: + # report autoscaling state + self._report_autoscaling_state(self.gcs_client, autoscaling_state) + else: + logger.warning("No autoscaling state to report.") + + # Wait for a autoscaler update interval before processing the next + # round of messages. + time.sleep(AUTOSCALER_UPDATE_INTERVAL_S) + + def run(self): + try: + self._run() + except Exception: + logger.exception("Error in monitor loop") + raise + + +def record_autoscaler_v2_usage(gcs_client: GcsClient) -> None: + """ + Record usage for autoscaler v2. + """ + try: + record_extra_usage_tag(TagKey.AUTOSCALER_VERSION, "v2", gcs_client) + except Exception: + logger.exception("Error recording usage for autoscaler v2.") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=("Parse GCS server for the monitor to connect to.") + ) + parser.add_argument( + "--gcs-address", required=False, type=str, help="The address (ip:port) of GCS." + ) + parser.add_argument( + "--autoscaling-config", + required=False, + type=str, + help="the path to the autoscaling config file", + ) + parser.add_argument( + "--logging-level", + required=False, + type=str, + default=ray_constants.LOGGER_LEVEL, + choices=ray_constants.LOGGER_LEVEL_CHOICES, + help=ray_constants.LOGGER_LEVEL_HELP, + ) + parser.add_argument( + "--logging-format", + required=False, + type=str, + default=ray_constants.LOGGER_FORMAT, + help=ray_constants.LOGGER_FORMAT_HELP, + ) + parser.add_argument( + "--logging-filename", + required=False, + type=str, + default=ray_constants.MONITOR_LOG_FILE_NAME, + help="Specify the name of log file, " + "log to stdout if set empty, default is " + f'"{ray_constants.MONITOR_LOG_FILE_NAME}"', + ) + parser.add_argument( + "--logs-dir", + required=True, + type=str, + help="Specify the path of the temporary directory used by Ray processes.", + ) + parser.add_argument( + "--logging-rotate-bytes", + required=False, + type=int, + default=LOGGING_ROTATE_BYTES, + help="Specify the max bytes for rotating " + "log file, default is " + f"{LOGGING_ROTATE_BYTES} bytes.", + ) + parser.add_argument( + "--logging-rotate-backup-count", + required=False, + type=int, + default=LOGGING_ROTATE_BACKUP_COUNT, + help="Specify the backup count of rotated log file, default is " + f"{LOGGING_ROTATE_BACKUP_COUNT}.", + ) + parser.add_argument( + "--monitor-ip", + required=False, + type=str, + default=None, + help="The IP address of the machine hosting the monitor process.", + ) + parser.add_argument( + "--stdout-filepath", + required=False, + type=str, + default="", + help="The filepath to dump monitor stdout.", + ) + parser.add_argument( + "--stderr-filepath", + required=False, + type=str, + default="", + help="The filepath to dump monitor stderr.", + ) + + args = parser.parse_args() + + # Disable log rotation for windows platform. + logging_rotation_bytes = args.logging_rotate_bytes if sys.platform != "win32" else 0 + logging_rotation_backup_count = ( + args.logging_rotate_backup_count if sys.platform != "win32" else 1 + ) + + setup_component_logger( + logging_level=args.logging_level, + logging_format=args.logging_format, + log_dir=args.logs_dir, + filename=args.logging_filename, + max_bytes=logging_rotation_bytes, + backup_count=logging_rotation_backup_count, + ) + + # Setup stdout/stderr redirect files if redirection enabled. + logging_utils.redirect_stdout_stderr_if_needed( + args.stdout_filepath, + args.stderr_filepath, + logging_rotation_bytes, + logging_rotation_backup_count, + ) + + logger.info( + f"Starting autoscaler v2 monitor using ray installation: {ray.__file__}" + ) + logger.info(f"Ray version: {ray.__version__}") + logger.info(f"Ray commit: {ray.__commit__}") + logger.info(f"AutoscalerMonitor started with command: {sys.argv}") + + gcs_address = args.gcs_address + if gcs_address is None: + raise ValueError("--gcs-address must be set!") + + if not args.autoscaling_config: + logger.info("No autoscaling config provided: use read only node provider.") + config_reader = ReadOnlyProviderConfigReader(gcs_address) + else: + autoscaling_config = os.path.expanduser(args.autoscaling_config) + config_reader = FileConfigReader( + config_file=autoscaling_config, skip_content_hash=True + ) + + monitor = AutoscalerMonitor( + gcs_address, + config_reader, + log_dir=args.logs_dir, + monitor_ip=args.monitor_ip, + ) + + monitor.run() diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/scheduler.py b/lib/python3.12/site-packages/ray/autoscaler/v2/scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..924ccb9efa0124a724a9182b807d73dc4e2a4441 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/scheduler.py @@ -0,0 +1,1755 @@ +import copy +import logging +import time +import uuid +from abc import ABC, abstractmethod +from collections import defaultdict +from dataclasses import dataclass, field +from enum import Enum +from typing import Dict, List, Optional, Tuple + +from ray._private.protobuf_compat import message_to_dict +from ray.autoscaler._private.constants import AUTOSCALER_CONSERVE_GPU_NODES +from ray.autoscaler._private.resource_demand_scheduler import ( + UtilizationScore, + _fits, + _inplace_subtract, +) +from ray.autoscaler.v2.event_logger import AutoscalerEventLogger +from ray.autoscaler.v2.instance_manager.common import InstanceUtil +from ray.autoscaler.v2.instance_manager.config import NodeTypeConfig +from ray.autoscaler.v2.schema import AutoscalerInstance, NodeType +from ray.autoscaler.v2.utils import ProtobufUtil, ResourceRequestUtil +from ray.core.generated.autoscaler_pb2 import ( + ClusterResourceConstraint, + GangResourceRequest, + ResourceRequest, + ResourceRequestByCount, +) +from ray.core.generated.common_pb2 import LabelSelectorOperator +from ray.core.generated.instance_manager_pb2 import ( + Instance, + LaunchRequest, + NodeKind, + TerminationRequest, +) + +# ============= Resource Scheduling Service API ======================= +# +# ResourceSchedulerService is a service that schedules resource bundles +# to nodes. It's used by the autoscaler to schedule resource bundles +# to determine the desired cluster size to satisfy the current resource +# demands. +# +logger = logging.getLogger(__name__) + + +@dataclass +class SchedulingRequest: + # If outdated node check through launch config is disabled. + disable_launch_config_check: bool + # Available node type configs + node_type_configs: Dict[NodeType, NodeTypeConfig] = field(default_factory=dict) + # Max number of worker nodes. + max_num_nodes: Optional[int] = None + # Idle timeout in seconds. + idle_timeout_s: Optional[float] = None + # TODO: This prob could be refactored into the ClusterStatus data class later. + # The current ray resource requests. + resource_requests: List[ResourceRequestByCount] = field(default_factory=list) + # The Gang resource requests. + gang_resource_requests: List[GangResourceRequest] = field(default_factory=list) + # cluster resource constraints. + cluster_resource_constraints: List[ClusterResourceConstraint] = field( + default_factory=list + ) + # The current instances. + current_instances: List[AutoscalerInstance] = field(default_factory=list) + + +@dataclass +class SchedulingReply: + # Instances to launch. + to_launch: List[LaunchRequest] = field(default_factory=list) + # To terminate. + to_terminate: List[TerminationRequest] = field(default_factory=list) + # The infeasible resource bundles. + infeasible_resource_requests: List[ResourceRequest] = field(default_factory=list) + # The infeasible gang resource bundles. + infeasible_gang_resource_requests: List[GangResourceRequest] = field( + default_factory=list + ) + # The infeasible cluster resource constraints. + infeasible_cluster_resource_constraints: List[ClusterResourceConstraint] = field( + default_factory=list + ) + + +class IResourceScheduler(ABC): + """ + Interface for a resource scheduler. + + Implements the `instance_manager.proto ResourceSchedulerService` interface. + """ + + @abstractmethod + def schedule(self, request: SchedulingRequest) -> SchedulingReply: + """ + Given the resource requests and the current cluster state, calculate the + target cluster shape by trying to schedule the resource requests on the + nodes. + """ + pass + + +class SchedulingNodeStatus(Enum): + """ + The status of a scheduling node (`SchedulingNode`) + """ + + # The node is added by the ResourceDemandScheduler. + TO_LAUNCH = "TO_LAUNCH" + # The node is pending, i.e. there's already an autoscaler instance being launched + # The node is schedulable. It could be running ray or pending to run ray. Either + # Way, it should be able to accept new resource requests/resource constraints. + SCHEDULABLE = "SCHEDULABLE" + # The node is to be terminated by the ResourceDemandScheduler + TO_TERMINATE = "TO_TERMINATE" + + +class ResourceRequestSource(Enum): + """ + The source of the resource request. + """ + + # The resource request is from demand, e.g. ray tasks/actors, + # placement groups, etc. + PENDING_DEMAND = "PENDING_DEMAND" + # The resource request is from the cluster resource constraints, i.e. + # from ray.autoscaler.sdk.request_resources(). + CLUSTER_RESOURCE_CONSTRAINT = "CLUSTER_RESOURCE_CONSTRAINT" + + +@dataclass +class SchedulingNode: + """ + A abstraction of a node that can be scheduled on by the resource scheduler. + + A scheduling node is expected to be used as: + + node = SchedulingNode.new(instance, node_configs) + remaining, score = node.try_schedule(requests) + + .... do something with the score .... + + NOTE: + One could also extend the scheduling behavior by overriding `try_schedule` + """ + + # Node type name. + node_type: NodeType + # Status + status: SchedulingNodeStatus + # Resource requests scheduled on this nodes for different sources. + sched_requests: Dict[ResourceRequestSource, List[ResourceRequest]] = field( + default_factory=lambda: defaultdict(list) + ) + # Available resources for different sources of requests. + available_resources_for_sched: Dict[ + ResourceRequestSource, Dict[str, float] + ] = field(default_factory=dict) + # The node's current resource capacity. + total_resources: Dict[str, float] = field(default_factory=dict) + # Node's labels, including static or dynamic labels. + # Note that dynamic labels are a deprecated feature. And it is only used for the + # autoscaler’s strict-spread placement group scheduling (antiaffinity) + labels: Dict[str, str] = field(default_factory=dict) + # Observability descriptive message for why the node was launched in the + # first place. + launch_reason: Optional[str] = None + # Termination request, none when the node is not being terminated. + termination_request: Optional[TerminationRequest] = None + # The instance id of the IM(Instance Manager) instance. None if the node + # is not yet in IM. + im_instance_id: Optional[str] = None + # The instance status of the IM(Instance Manager) instance. None if the in-flight node + # has not yet been assigned to an IM instance. + im_instance_status: Optional[Instance.InstanceStatus.ValueType] = None + # The ray node id of the ray node. None if the node is not included in + # ray cluster's GCS report yet (not running ray yet). + ray_node_id: Optional[str] = None + # Idle duration in ms. Default not idle. + idle_duration_ms: int = 0 + # Launch config hash. + launch_config_hash: Optional[str] = None + # node kind. + node_kind: NodeKind = NodeKind.WORKER + + def __init__( + self, + node_type: NodeType, + total_resources: Dict[str, float], + available_resources: Dict[str, float], + labels: Dict[str, str], + status: SchedulingNodeStatus, + im_instance_id: str = "", + im_instance_status: Optional[Instance.InstanceStatus.ValueType] = None, + ray_node_id: str = "", + idle_duration_ms: int = 0, + launch_config_hash: str = "", + node_kind: NodeKind = NodeKind.WORKER, + termination_request: Optional[TerminationRequest] = None, + ): + self.node_type = node_type + self.total_resources = total_resources + self.available_resources_for_sched = { + ResourceRequestSource.PENDING_DEMAND: dict(available_resources), + ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT: dict(total_resources), + } + self.sched_requests = { + ResourceRequestSource.PENDING_DEMAND: [], + ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT: [], + } + self.labels = labels + self.status = status + self.im_instance_id = im_instance_id + self.im_instance_status = im_instance_status + self.ray_node_id = ray_node_id + self.idle_duration_ms = idle_duration_ms + self.launch_config_hash = launch_config_hash + self.node_kind = node_kind + self.termination_request = termination_request + + def get_available_resources(self, resource_request_source: ResourceRequestSource): + """Get the available resources for the given resource request source.""" + return self.available_resources_for_sched[resource_request_source] + + def get_sched_requests(self, resource_request_source: ResourceRequestSource): + """Get the resource requests for the given resource request source.""" + return self.sched_requests[resource_request_source] + + def add_sched_request( + self, + request: ResourceRequest, + resource_request_source: ResourceRequestSource, + ): + """ + Add the resource requests to the node. + + Args: + request: The resource request to be added. + resource_request_source: The source of the resource request. + """ + self.sched_requests[resource_request_source].append(request) + + @staticmethod + def new( + instance: AutoscalerInstance, + node_type_configs: Dict[NodeType, NodeTypeConfig], + disable_launch_config_check: bool, + ) -> Optional["SchedulingNode"]: + """ + Create a new scheduling node from an autoscaler instance. + + It creates: + - None if the instance is not schedulable by IM. + - A schedulable node if the instance is running ray or pending to run ray, + so it should be considered in the scheduling process. + + Args: + instance: The instance. + node_type_configs: The node type configs. + disable_launch_config_check: If outdated node check through launch config is + disabled. + + """ + if not SchedulingNode.is_schedulable(instance): + return None + + if instance.im_instance.status == Instance.RAY_RUNNING: + assert instance.ray_node is not None, ( + "ray node should not be None " + f"when the instance is running ray: instance={instance}" + ) + # An running ray node + return SchedulingNode( + node_type=instance.im_instance.instance_type, + total_resources=dict(instance.ray_node.total_resources), + # Available resources for scheduling requests of different + # sources. + available_resources=dict(instance.ray_node.available_resources), + labels={ + **(instance.ray_node.labels or {}), + # DEPRECATED: Dynamic labels are a deprecated feature. This field + # is used here only for the autoscaler’s strict-spread placement + # group scheduling (antiaffinity). + **(instance.ray_node.dynamic_labels or {}), + }, + status=SchedulingNodeStatus.SCHEDULABLE, + im_instance_id=instance.im_instance.instance_id, + im_instance_status=instance.im_instance.status, + ray_node_id=instance.im_instance.node_id, + idle_duration_ms=instance.ray_node.idle_duration_ms, + launch_config_hash=instance.im_instance.launch_config_hash, + node_kind=instance.im_instance.node_kind, + ) + + # This is an instance pending to run ray. Initialize a schedulable node + # from the node type config. + node_config = node_type_configs.get(instance.im_instance.instance_type, None) + if node_config is None: + if disable_launch_config_check: + # We are not terminating outdated nodes. + logger.info( + f"Node config for {instance.im_instance.instance_type} is missing, " + "but we are not terminating the outdated node because " + "`disable_launch_config_check` is True in " + "the autoscaler's provider config." + ) + return None + + # Configs might have been updated, and no more + # node_type_configs for this node type. We should terminate it. + return SchedulingNode( + node_type=instance.im_instance.instance_type, + total_resources={}, + available_resources={}, + labels={}, + status=SchedulingNodeStatus.TO_TERMINATE, + im_instance_id=instance.im_instance.instance_id, + im_instance_status=instance.im_instance.status, + termination_request=TerminationRequest( + id=str(uuid.uuid4()), + instance_id=instance.im_instance.instance_id, + instance_status=instance.im_instance.status, + cause=TerminationRequest.Cause.OUTDATED, + instance_type=instance.im_instance.instance_type, + ), + node_kind=NodeKind.WORKER, + ) + + return SchedulingNode.from_node_config( + node_config, + SchedulingNodeStatus.SCHEDULABLE, + node_kind=instance.im_instance.node_kind, + im_instance_id=instance.im_instance.instance_id, + im_instance_status=instance.im_instance.status, + ) + + @staticmethod + def is_schedulable(instance: AutoscalerInstance) -> bool: + """ + Check if the instance is schedulable by IM. + + Args: + instance: The instance. + + Returns: + True if the instance is schedulable by IM. + """ + if instance.im_instance is None: + # We will skip any instances that are not yet in IM which + # could be + # 1. an out-of-band ray node + # 2. an cloud instance running ray not yet discovered + # by the IM's Reconciler + # 3. an cloud instance already terminated but ray state + # still lagging behind. + # + # In all of these cases, the instance is not schedulable or + # shouldn't be managed by IM, so we don't consider them. + return False + + # These are the statuses where there's a running ray node or + # could eventually run ray. + if InstanceUtil.is_ray_running_reachable(instance.im_instance.status): + return True + + return False + + @staticmethod + def from_node_config( + node_config: NodeTypeConfig, + status: SchedulingNodeStatus, + node_kind: NodeKind, + im_instance_id: Optional[str] = None, + im_instance_status: Optional[str] = None, + ) -> "SchedulingNode": + """ + Create a scheduling node from a node config. + + Args: + node_config: The node config. + status: The status of the node. + node_kind: The node kind. + im_instance_id: The instance id of the im instance. + im_instance_status: The instance status of the im instance. + node_kind: The node kind. + """ + return SchedulingNode( + node_type=node_config.name, + total_resources=dict(node_config.resources), + available_resources=dict(node_config.resources), + labels=dict(node_config.labels), + status=status, + im_instance_id=im_instance_id, + im_instance_status=im_instance_status, + node_kind=node_kind, + ) + + def __post_init__(self): + assert self.node_type, "node_type should be set" + + def try_schedule( + self, + requests: List[ResourceRequest], + resource_request_source: ResourceRequestSource, + ) -> Tuple[List[ResourceRequest], UtilizationScore]: + """ + Try to schedule the resource requests on this node. + + This modifies the node's available resources if the requests are schedulable. + The requests are scheduled one by one in the sorted order, and no + backtracking is done. + + Args: + requests: The resource requests to be scheduled. + resource_request_source: The source of the resource request, i.e. + pending demands from ray actors/tasks or cluster resource constraints. + + Returns: + A tuple of: + - list of remaining requests that cannot be scheduled on this node. + - the utilization score for this node with respect to the current + resource requests being scheduled. + """ + # Track the resource requests that cannot be scheduled on this node. + unschedulable_requests = [] + + # Sort the requests and try schedule them one by one. + for r in requests: + if not self._try_schedule_one(r, resource_request_source): + unschedulable_requests.append(r) + + score = self._compute_score(resource_request_source) + + return unschedulable_requests, score + + def _compute_score( + self, resource_request_source: ResourceRequestSource + ) -> UtilizationScore: + """ + Compute the utilization score for this node with respect to the current resource + request being scheduled. + + A "higher" score means that this node is more suitable for scheduling the + current scheduled resource requests. + + The score is a tuple of 5 values: + 1. Whether this node has labels matching the current resource request's + label_selector requirements: + 0: if this node does not satisfy any label selector requirements or + no label selectors are provided. + len(label_selectors)-i: a score based on the priority of the label + selector in the resource request that this node satisfies. + 2. Whether this node is a GPU node and the current resource request has + GPU requirements: + 0: if this node is a GPU node and the current resource request + placed onto the node has no GPU requirements. + 1: if this node is not a GPU node or the current resource request + placed onto the node has GPU requirements. + 3. The number of resource types being scheduled. + 4. The minimum utilization rate across all resource types. + 5. The average utilization rate across all resource types. + + NOTE: + This function is adapted from _resource_based_utilization_scorer from + autoscaler v1. + + TODO(rickyx,jjyao): We should also consider node labels for + scoring. For example, if a node has a label that matches the affinity + label of the resource request, we should give it a higher score. + + TODO(rickyx): add pluggable scoring functions here. + + Returns: + A utilization score for this node. + """ + + sched_requests = self.get_sched_requests(resource_request_source) + available_resources = self.get_available_resources(resource_request_source) + + # Compute the number of resource types being scheduled. + num_matching_resource_types = 0 + sched_resource_types = set() + for req in sched_requests: + for resource_name, v in req.resources_bundle.items(): + if v > 0: + sched_resource_types.add(resource_name) + + for sched_resource_type in sched_resource_types: + if sched_resource_type in self.total_resources: + num_matching_resource_types += 1 + + # Compute the utilization rate for each resource type + util_by_resources = [] + for k, v in self.total_resources.items(): + if v == 0: + # Skip any zero values. + continue + if k in available_resources: + util = (v - available_resources.get(k, 0)) / v + assert util >= 0 and util <= 1, f"Invalid utilization: {util}" + util_by_resources.append(v * (util**3)) + + # Prefer not to launch a GPU node if there aren't any GPU requirements in the + # resource bundle. + gpu_ok = True + if AUTOSCALER_CONSERVE_GPU_NODES: + # TODO: we should also generalize this optimization for accelerators. + # https://github.com/ray-project/ray/issues/43079 + is_gpu_node = self.total_resources.get("GPU", 0) > 0 + any_gpu_requests = any("GPU" in r.resources_bundle for r in sched_requests) + if is_gpu_node and not any_gpu_requests: + gpu_ok = False + + # Check if node satisfies label requirements. + matches_labels = self._satisfies_label_constraints(sched_requests) + + # Prioritize avoiding gpu nodes for non-gpu workloads first, + # then prioritize matching multiple resource types, + # then prioritize using all resources, + # then prioritize overall balance of multiple resources. + return ( + matches_labels, + gpu_ok, + num_matching_resource_types, + min(util_by_resources) if util_by_resources else 0, + float(sum(util_by_resources)) / len(util_by_resources) + if util_by_resources + else 0, + ) + + def _satisfies_label_constraints( + self, sched_requests: List[ResourceRequest] + ) -> int: + """Returns a higher value based on the priority of the label selector this node + satisfies (first returns highest score, decreasing sequentially for fallback), 0 otherwise.""" + for req in sched_requests: + num_selectors = len(req.label_selectors) + for i, selector in enumerate(req.label_selectors): + all_constraints_pass = True + for constraint in selector.label_constraints: + key = constraint.label_key + values = set(constraint.label_values) + op = constraint.operator + node_val = self.labels.get(key) + + if op == LabelSelectorOperator.LABEL_OPERATOR_IN: + if node_val not in values: + all_constraints_pass = False + break + elif op == LabelSelectorOperator.LABEL_OPERATOR_NOT_IN: + if node_val in values: + all_constraints_pass = False + break + else: + all_constraints_pass = False + break + + if all_constraints_pass: + return num_selectors - i + return 0 + + def _try_schedule_one( + self, request: ResourceRequest, resource_request_source: ResourceRequestSource + ) -> bool: + """ + Try to schedule one resource request on this node. The request could be from + various sources, specified by `resource_request_source`. + + Args: + request: The resource request to be scheduled. + resource_request_source: The source of the resource request, i.e. + pending demands from ray actors/tasks or cluster resource constraints. + + Returns: + True if the resource request is scheduled on this node. + """ + + # Enforce label selector constraints + if request.label_selectors: + if self._satisfies_label_constraints([request]) == 0: + return False # Node doesn't satisfy any label selector in request. + + # Check if there's placement constraints that are not satisfied. + for constraint in request.placement_constraints: + if constraint.HasField("anti_affinity"): + anti_affinity = constraint.anti_affinity + if ( + anti_affinity.label_name in self.labels + and anti_affinity.label_value + == self.labels[anti_affinity.label_name] + ): + # The node already has a label that matches the anti-affinity + return False + + # We don't need to check for affinity constraints here since + # we have already combined resource requests with the affinity + # constraints into the same request at `combine_requests_with_affinity`. + pass + + available_resources_dict = self.get_available_resources(resource_request_source) + + # Check if there's enough resources to schedule the request. + if not _fits(available_resources_dict, dict(request.resources_bundle)): + return False + + # Schedule the request, update resources + _inplace_subtract(available_resources_dict, dict(request.resources_bundle)) + + # Add the request to the node. + self.add_sched_request(request, resource_request_source) + + # Update the placement group in labels if there's any + for constraint in request.placement_constraints: + # We don't need to check for affinity constraints here since + # we have already combined resource requests with the affinity + # constraints into the same request at `combine_requests_with_affinity`. + # We don't need node labels for enforcing affinity. + if constraint.HasField("anti_affinity"): + anti_affinity = constraint.anti_affinity + self._add_label(anti_affinity.label_name, anti_affinity.label_value) + + return True + + def _add_label(self, label_name: str, label_value: str): + """ + Add a label to the node. + This assumes a label key can only have one value. + """ + assert ( + self.labels.get(label_name) is None + or self.labels[label_name] == label_value + ), ( + f"Label {label_name} already exists with value " + f"{self.labels[label_name]}, cannot set to " + f"{label_value}" + ) + self.labels[label_name] = label_value + + def __repr__(self) -> str: + return ( + "SchedulingNode(node_type={node_type}, " + "node_kind={node_kind}, " + "instance_id={instance_id}," + "instance_status={instance_status}," + "ray_node_id={ray_node_id}," + "idle_duration_ms={idle_duration_ms}," + "termination_request={termination_request}," + "status={status}, " + "total_resources={total_resources}, " + "available_resources_for_demand={available_resources_for_demand}, " + "available_resources_for_cluster_resource_constraints=" + "{available_resources_for_cluster_resource_constraints}," + "labels={labels}, launch_reason={launch_reason}), " + "sched_requests_for_demand={sched_requests_for_demand}), " + "sched_requests_for_cluster_resource_constraints=" + "{sched_requests_for_cluster_resources_constraint})" + ).format( + node_type=self.node_type, + node_kind=self.node_kind, + instance_id=self.im_instance_id, + instance_status=self.im_instance_status, + ray_node_id=self.ray_node_id, + idle_duration_ms=self.idle_duration_ms, + termination_request=str(message_to_dict(self.termination_request)) + if self.termination_request + else None, + status=self.status, + total_resources=self.total_resources, + available_resources_for_demand=self.available_resources_for_sched[ + ResourceRequestSource.PENDING_DEMAND + ], + available_resources_for_cluster_resource_constraints=self.available_resources_for_sched[ # noqa + ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT + ], + labels=self.labels, + launch_reason=self.launch_reason, + sched_requests_for_demand="|".join( + str(message_to_dict(r)) + for r in self.sched_requests[ResourceRequestSource.PENDING_DEMAND] + ), + sched_requests_for_cluster_resources_constraint="|".join( + str(message_to_dict(r)) + for r in self.sched_requests[ + ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT + ] + ), + ) + + +class ResourceDemandScheduler(IResourceScheduler): + """ + A resource demand scheduler that schedules resource requests based on the + following rules: + 1. Enforce the minimal count of nodes for each worker node type. + 2. Enforce the cluster resource constraints. + 3. Schedule the gang resource requests. + 4. Schedule the tasks/actor resource requests + """ + + def __init__(self, event_logger: Optional[AutoscalerEventLogger] = None): + self._event_logger = event_logger + + @dataclass + class ScheduleContext: + """ + Encapsulates the context for processing one scheduling request. + + This exposes functions to read and write the scheduling nodes, to prevent + accidental modification of the internal state. + """ + + # The node type configs for this scheduling request. + _node_type_configs: Dict[NodeType, NodeTypeConfig] + # If outdated node check through launch config is disabled. + _disable_launch_config_check: bool + # The max number of nodes for the entire cluster. + _max_num_nodes: Optional[int] = None + # The idle timeout in seconds. + _idle_timeout_s: Optional[float] = None + # The current schedulable nodes (including pending nodes and pending requests). + _nodes: List[SchedulingNode] = field(default_factory=list) + # The number of nodes by node types available for launching based on the max + # number of workers in the config. This takes into account any pending/running + # nodes. + _node_type_available: Dict[NodeType, int] = field(default_factory=dict) + + def __init__( + self, + nodes: List[SchedulingNode], + node_type_configs: Dict[NodeType, NodeTypeConfig], + disable_launch_config_check: bool, + max_num_nodes: Optional[int] = None, + idle_timeout_s: Optional[float] = None, + ): + self._nodes = nodes + self._node_type_configs = node_type_configs + self._node_type_available = self._compute_available_node_types( + nodes, node_type_configs + ) + self._max_num_nodes = max_num_nodes + self._idle_timeout_s = idle_timeout_s + self._disable_launch_config_check = disable_launch_config_check + + @classmethod + def from_schedule_request( + cls, req: SchedulingRequest + ) -> "ResourceDemandScheduler.ScheduleContext": + """ + Create a schedule context from a schedule request. + It will populate the context with the existing nodes and the available node + types from the config. + + Args: + req: The scheduling request. The caller should make sure the + request is valid. + """ + + nodes = [] + node_type_configs = req.node_type_configs + + # Initialize the scheduling nodes. + for instance in req.current_instances: + node = SchedulingNode.new( + instance, node_type_configs, req.disable_launch_config_check + ) + if node: + nodes.append(node) + + return cls( + nodes=nodes, + node_type_configs=node_type_configs, + disable_launch_config_check=req.disable_launch_config_check, + max_num_nodes=req.max_num_nodes, + idle_timeout_s=req.idle_timeout_s, + ) + + @staticmethod + def _compute_available_node_types( + nodes: List[SchedulingNode], + node_type_configs: Dict[NodeType, NodeTypeConfig], + ) -> Dict[NodeType, int]: + """ + Compute the number of nodes by node types available for launching based on + the max number of workers in the config. + Args: + nodes: The current existing nodes. + node_type_configs: The node type configs. + Returns: + A dict of node types and the number of nodes available for launching. + """ + node_type_available: Dict[NodeType, int] = defaultdict(int) + node_type_existing: Dict[NodeType, int] = defaultdict(int) + for node in nodes: + node_type_existing[node.node_type] += 1 + + for ( + node_type, + node_type_config, + ) in node_type_configs.items(): + node_type_available[ + node_type + ] = node_type_config.max_worker_nodes - node_type_existing.get( + node_type, 0 + ) + + return node_type_available + + def get_nodes(self) -> List[SchedulingNode]: + """ + Get the current nodes with filter. + + Returns: + A list of nodes. + """ + nodes = copy.deepcopy(self._nodes) + return nodes + + def get_node_type_available(self) -> Dict[NodeType, int]: + return copy.deepcopy(self._node_type_available) + + def get_cluster_shape(self) -> Dict[NodeType, int]: + cluster_shape = defaultdict(int) + for node in self._nodes: + if node.status == SchedulingNodeStatus.TO_TERMINATE: + # Skip the nodes that are to be terminated. + continue + + cluster_shape[node.node_type] += 1 + return cluster_shape + + def get_cluster_resources(self) -> Dict[str, float]: + """ + Aggregate total cluster resources. + + Sums each node's `total_resources` across the current context, + excluding nodes marked `TO_TERMINATE`. + + Returns: + A dict mapping resource names to their summed resources. + """ + cluster_resources = defaultdict(float) + for node in self._nodes: + if node.status == SchedulingNodeStatus.TO_TERMINATE: + # Skip the nodes that are to be terminated. + continue + + for key, value in node.total_resources.items(): + cluster_resources[key] += value + return cluster_resources + + def get_idle_timeout_s(self) -> Optional[float]: + return self._idle_timeout_s + + def update(self, new_nodes: List[SchedulingNode]) -> None: + """ + Update the context with the new nodes. + """ + self._nodes = new_nodes + + # Update the available node types. + self._node_type_available = self._compute_available_node_types( + self._nodes, self._node_type_configs + ) + + def get_max_num_nodes(self) -> Optional[int]: + """ + Get the max number of nodes for the entire cluster. + """ + return self._max_num_nodes + + def get_node_type_configs(self) -> Dict[NodeType, NodeTypeConfig]: + return self._node_type_configs + + def __str__(self) -> str: + return "ScheduleContext({} nodes, node_type_available={})".format( + len(self._nodes), dict(self._node_type_available) + ) + + def get_launch_requests(self) -> List[LaunchRequest]: + """ + Get the launch requests for the nodes that are to be launched. + """ + launch_by_type = defaultdict(int) + for node in self._nodes: + if node.status == SchedulingNodeStatus.TO_LAUNCH: + launch_by_type[node.node_type] += 1 + + launch_requests = [] + for instance_type, count in launch_by_type.items(): + launch_requests.append( + LaunchRequest( + instance_type=instance_type, + count=count, + id=str(uuid.uuid4()), + request_ts_ms=time.time_ns() // 1000, + ) + ) + return launch_requests + + def get_terminate_requests( + self, + ) -> List[TerminationRequest]: + """ + Get the terminate requests for the nodes that are to be terminated. + """ + return [ + node.termination_request + for node in self._nodes + if node.termination_request is not None + ] + + def schedule(self, request: SchedulingRequest) -> SchedulingReply: + logger.debug( + "Scheduling for request: resource_request={}, gang_resource_request={}, " + "cluster_constraint={}".format( + ResourceRequestUtil.to_dict_list(request.resource_requests), + ProtobufUtil.to_dict_list(request.gang_resource_requests), + ProtobufUtil.to_dict_list(request.cluster_resource_constraints), + ) + ) + + ctx = ResourceDemandScheduler.ScheduleContext.from_schedule_request(request) + + # Enforce outdate nodes. + ResourceDemandScheduler._terminate_outdated_nodes(ctx) + + # Enforce the minimal count of nodes for each worker node type. + ResourceDemandScheduler._enforce_min_workers_per_type(ctx) + + # Enforce the max worker nodes count. + ResourceDemandScheduler._enforce_max_workers_per_type(ctx) + + # Enforce the max worker nodes count globally. + ResourceDemandScheduler._enforce_max_workers_global(ctx) + + # Enforce the cluster resource constraints. + infeasible_constraints = ResourceDemandScheduler._enforce_resource_constraints( + ctx, request.cluster_resource_constraints + ) + + # Schedule the gang resource requests. + infeasible_gang_requests = ( + ResourceDemandScheduler._sched_gang_resource_requests( + ctx, request.gang_resource_requests + ) + ) + + # Schedule the tasks/actor resource requests + infeasible_requests = ResourceDemandScheduler._sched_resource_requests( + ctx, + ResourceRequestUtil.ungroup_by_count(request.resource_requests), + ) + + # Shutdown any idle nodes that's not needed (e.g. no resource constraints. + # not needed by min_worker count, etc.) + ResourceDemandScheduler._enforce_idle_termination(ctx) + + # Compute the number of nodes to launch. + reply = SchedulingReply( + infeasible_resource_requests=infeasible_requests, + infeasible_gang_resource_requests=infeasible_gang_requests, + infeasible_cluster_resource_constraints=infeasible_constraints, + to_launch=ctx.get_launch_requests(), + to_terminate=ctx.get_terminate_requests(), + ) + + if self._event_logger is not None: + try: + self._event_logger.log_cluster_scheduling_update( + launch_requests=reply.to_launch, + terminate_requests=reply.to_terminate, + infeasible_requests=infeasible_requests, + infeasible_gang_requests=infeasible_gang_requests, + infeasible_cluster_resource_constraints=infeasible_constraints, + cluster_resources=ctx.get_cluster_resources(), + ) + except Exception: + logger.exception("Failed to emit event logs.") + + return reply + + @staticmethod + def _enforce_max_workers_per_type( + ctx: "ResourceDemandScheduler.ScheduleContext", + ) -> None: + """ + Enforce the max number of workers for each node type. + """ + + # Get all the nodes by type + all_nodes = ctx.get_nodes() + + non_terminating_nodes_by_type = defaultdict(list) + terminating_nodes = [] + for node in all_nodes: + if node.status == SchedulingNodeStatus.TO_TERMINATE: + terminating_nodes.append(node) + else: + non_terminating_nodes_by_type[node.node_type].append(node) + + # Step 1. Enforce the max number of workers for each node type. + for node_type in non_terminating_nodes_by_type.keys(): + non_terminate_nodes_of_type = non_terminating_nodes_by_type[node_type] + node_config = ctx.get_node_type_configs()[node_type] + num_max_nodes_per_type = node_config.max_worker_nodes + num_extra_nodes = len(non_terminate_nodes_of_type) - num_max_nodes_per_type + + if num_extra_nodes <= 0: + # No extra nodes for this type, continue. + continue + + # Terminate the nodes + ( + to_terminate, + remained_nodes, + ) = ResourceDemandScheduler._select_nodes_to_terminate( + non_terminate_nodes_of_type, + num_extra_nodes, + TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE, + max_num_nodes_per_type=num_max_nodes_per_type, + ) + + non_terminating_nodes_by_type[node_type] = remained_nodes + terminating_nodes.extend(to_terminate) + + non_terminating_nodes = [] + for nodes in non_terminating_nodes_by_type.values(): + non_terminating_nodes.extend(nodes) + + # Update the context + assert len(all_nodes) == len( + terminating_nodes + non_terminating_nodes + ), "The number of nodes should be the same after enforcing max nodes per type." + + ctx.update(terminating_nodes + non_terminating_nodes) + + if terminating_nodes: + logger.debug( + f"Terminating {len(terminating_nodes)} " + "nodes for per node type max num node's constraints." + ) + + @staticmethod + def _enforce_max_workers_global( + ctx: "ResourceDemandScheduler.ScheduleContext", + ) -> None: + """ + Enforce the max number of workers for the entire cluster. + """ + all_nodes = ctx.get_nodes() + + terminating_nodes = [] + non_terminating_nodes = [] + + for node in all_nodes: + if node.status == SchedulingNodeStatus.TO_TERMINATE: + terminating_nodes.append(node) + else: + non_terminating_nodes.append(node) + + num_max_nodes = ctx.get_max_num_nodes() + + num_to_terminate = ( + max(len(non_terminating_nodes) - num_max_nodes, 0) if num_max_nodes else 0 + ) + + if num_to_terminate <= 0: + # No extra nodes needed to terminate. + return + + # Terminate the nodes + ( + to_terminate_nodes, + non_terminating_nodes, + ) = ResourceDemandScheduler._select_nodes_to_terminate( + non_terminating_nodes, + num_to_terminate, + TerminationRequest.Cause.MAX_NUM_NODES, + max_num_nodes=num_max_nodes, + ) + + assert len(to_terminate_nodes) == num_to_terminate, ( + "Terminating {} nodes, failed to terminate {} nodes to " + "satisfy max_num_nodes={}".format( + len(to_terminate_nodes), + num_to_terminate - len(to_terminate_nodes), + num_max_nodes, + ) + ) + + # Update the context + terminating_nodes.extend(to_terminate_nodes) + assert len(all_nodes) == len( + terminating_nodes + non_terminating_nodes + ), "The number of nodes should be the same after enforcing max nodes." + + all_nodes = terminating_nodes + non_terminating_nodes + ctx.update(all_nodes) + + @staticmethod + def _select_nodes_to_terminate( + nodes: List[SchedulingNode], + num_to_terminate: int, + cause: TerminationRequest.Cause, + max_num_nodes: Optional[int] = None, + max_num_nodes_per_type: Optional[int] = None, + ) -> Tuple[List[SchedulingNode], List[SchedulingNode]]: + """ + Select 'num_to_terminate' of nodes to be terminated + from the 'nodes' list. It should never select a head node. + + Args: + nodes: The nodes to be terminated. + num_to_terminate: The number of nodes to be terminated. + cause: The cause of the termination. Should be one of + TerminationRequest.Cause.MAX_NUM_NODES or + TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE. + + max_num_nodes: The max number of nodes for the entire cluster only + used when the cause is TerminationRequest.Cause.MAX_NUM_NODES. + max_num_nodes_per_type: The max number of nodes for each node type. + Only used when the cause is + TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE. + + Returns: + A tuple of: + - The terminated nodes. + - The remained nodes. + """ + + # Sort the nodes for termination. + nodes.sort(key=ResourceDemandScheduler._sort_nodes_for_termination) + + # Remove the head node from the list. + head_node = None + for i, node in enumerate(nodes): + if node.node_kind == NodeKind.HEAD: + # Remove the head node from the list. + head_node = nodes.pop(i) + break + + terminated_nodes, remained_nodes = ( + nodes[:num_to_terminate], + # The head could be None if there's no head node being reported yet + # from the ray cluster. + nodes[num_to_terminate:] + ([head_node] if head_node else []), + ) + + assert cause in [ + TerminationRequest.Cause.MAX_NUM_NODES, + TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE, + ], "Other termination causes don't have to select nodes for termination." + + for node in terminated_nodes: + node.status = SchedulingNodeStatus.TO_TERMINATE + node.termination_request = TerminationRequest( + id=str(uuid.uuid4()), + instance_id=node.im_instance_id, + ray_node_id=node.ray_node_id, + cause=cause, + instance_type=node.node_type, + instance_status=node.im_instance_status, + details=( + f"Terminating node due to {TerminationRequest.Cause.Name(cause)}: " + f"max_num_nodes={max_num_nodes}, " + f"max_num_nodes_per_type={max_num_nodes_per_type}" + ), + ) + if cause == TerminationRequest.Cause.MAX_NUM_NODES: + node.termination_request.max_num_nodes = max_num_nodes + elif cause == TerminationRequest.Cause.MAX_NUM_NODE_PER_TYPE: + node.termination_request.max_num_nodes_per_type = max_num_nodes_per_type + else: + raise ValueError("Unknown termination cause: {}".format(cause)) + + return terminated_nodes, remained_nodes + + @staticmethod + def _sort_nodes_for_termination(node: SchedulingNode) -> Tuple: + """ + Sort the nodes for termination increasingly by: + + 1. First if ray hasn't been started yet + 2. Then if the nodes are idle + 3. Then with lower resources util nodes first. + + Such that nodes sorted earlier will be terminated first. + """ + + running_ray = len(node.ray_node_id) > 0 + # Reverse the idle duration such that the nodes with the largest idle duration + # will be terminated first. + idle_dur = -1 * node.idle_duration_ms + available_resources = node.get_available_resources( + ResourceRequestSource.PENDING_DEMAND + ) + + utils_per_resources = {} + for resource, total in node.total_resources.items(): + if total <= 0: + continue + utils_per_resources[resource] = ( + total - available_resources.get(resource, 0) + ) / total + + avg_util = ( + sum(utils_per_resources.values()) / len(utils_per_resources) + if utils_per_resources + else 0 + ) + + return (running_ray, idle_dur, avg_util) + + @staticmethod + def _enforce_min_workers_per_type( + ctx: "ResourceDemandScheduler.ScheduleContext", + ) -> None: + """ + Enforce the minimal count of nodes for each worker node type. + """ + + # Count the existing nodes by type + count_by_node_type = ctx.get_cluster_shape() + + new_nodes = [] + # Launch new nodes to satisfy min count for each node type. + for ( + node_type, + node_type_config, + ) in ctx.get_node_type_configs().items(): + cur_count = count_by_node_type.get(node_type, 0) + min_count = node_type_config.min_worker_nodes + if cur_count < min_count: + logger.info( + f"Adding {min_count - cur_count} nodes to satisfy min count for " + f"node type: {node_type}." + ) + new_nodes.extend( + [ + SchedulingNode.from_node_config( + copy.deepcopy(node_type_config), + status=SchedulingNodeStatus.TO_LAUNCH, + node_kind=NodeKind.WORKER, + ) + ] + * (min_count - cur_count) + ) + # NOTE: we assume the aggregated number of min workers across all node types + # should not exceed any globally enforced max_num_nodes + + # Add the new nodes to the existing nodes and update the context. + ctx.update(new_nodes + ctx.get_nodes()) + + @staticmethod + def _enforce_resource_constraints( + ctx: "ResourceDemandScheduler.ScheduleContext", + constraints: List[ClusterResourceConstraint], + ) -> List[ClusterResourceConstraint]: + """ + Enforce the cluster resource constraints. + + Args: + ctx: The schedule context. + constraints: The cluster resource constraints. + + Returns: + A list of infeasible constraints. + + Notes: + It's different from the other scheduling functions since it doesn't actually + schedule any resource requests. Instead, it asks if the cluster could be + upscale to a certain shape to fulfill the constraints. + """ + + # NOTE: we currently only have 1 constraint from a cluster, but + # we may have multiple in the future. + assert len(constraints) <= 1, "Max 1 cluster resource constraint is supported." + if len(constraints) == 0: + # No cluster resource constraints - nothing needs to be done. + return [] + + constraint = constraints[0] + # Flatten the requests for iterating through. + requests = ResourceRequestUtil.ungroup_by_count(constraint.resource_requests) + + # Pass the empty nodes to schedule. + scheduled_nodes, infeasible = ResourceDemandScheduler._try_schedule( + ctx, + requests, + resource_request_source=ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT, + ) + + if infeasible: + # Unable to satisfy the constraint. + return [constraint] + + ctx.update(scheduled_nodes) + return [] + + @staticmethod + def _sched_resource_requests( + ctx: "ResourceDemandScheduler.ScheduleContext", + requests: List[ResourceRequest], + ) -> List[ResourceRequest]: + """ + Schedule the resource requests. + + Args: + ctx: The schedule context. + requests_by_count: The resource requests. + + Returns: + A list of infeasible resource requests. + """ + nodes, infeasible = ResourceDemandScheduler._try_schedule( + ctx, requests, resource_request_source=ResourceRequestSource.PENDING_DEMAND + ) + + # Regardless if there's feasible, we will update the context for schedule nodes. + ctx.update(nodes) + + return infeasible + + @staticmethod + def _sched_gang_resource_requests( + ctx: "ResourceDemandScheduler.ScheduleContext", + gang_requests: List[GangResourceRequest], + ) -> List[GangResourceRequest]: + """ + Schedule the gang resource requests. + + These requests should be scheduled atomically, i.e. either all of the resources + requests in a gang request are scheduled or none of them are scheduled. + + For now, the gang resource requests represent Ray's placement groups, while it + could be more general in the future: + - For STRICT_PACK placement group requests, we combine them into a single + request and try to schedule them together. + - For STRICT_SPREAD placement groups requests, they should be scheduled on + different nodes by leveraging on the node labels that are associated with + the placement group. + If there are requests from rescheduling placement groups due to node + failures, these requests should not be scheduled on nodes with requests + from the same placement group. + + + Args: + ctx: The schedule context. + gang_requests: The gang resource requests. + + Returns: + A list of infeasible gang resource requests. + """ + + def _sort_gang_resource_requests(req: GangResourceRequest) -> Tuple: + """ + Key function for sorting the gang resource request by: + 1. the number of placement constraints in the gang request. + 2. the number of resource requests in the gang request. + """ + total_placement_constraints = 0 + for resource_request in req.requests: + total_placement_constraints += len( + resource_request.placement_constraints + ) + + return (total_placement_constraints, len(req.requests)) + + infeasible_gang_requests = [] + # Try fulfilling the gang requests one by one. + for gang_req in sorted( + gang_requests, key=_sort_gang_resource_requests, reverse=True + ): + if gang_req.bundle_selectors: + # TODO: @ryanaoleary multiple `bundle_selectors` will be supported + # for `fallback_strategy`. + requests = gang_req.bundle_selectors[0].resource_requests + else: + # Use legacy field if `bundle_selectors` not provided. + requests = gang_req.requests + # Try to combine requests with affinity constraints into the same request. + requests = ResourceRequestUtil.combine_requests_with_affinity(requests) + + nodes, infeasible = ResourceDemandScheduler._try_schedule( + ctx, requests, ResourceRequestSource.PENDING_DEMAND + ) + + if infeasible: + # Unable to satisfy the constraint. We will skip the gang request. + # Don't update the context. + infeasible_gang_requests.append(gang_req) + continue + + # We are able to satisfy the constraint and thus update the context. + ctx.update(nodes) + + return infeasible_gang_requests + + @staticmethod + def _try_schedule( + ctx: "ResourceDemandScheduler.ScheduleContext", + requests_to_sched: List[ResourceRequest], + resource_request_source: ResourceRequestSource, + ) -> Tuple[List[SchedulingNode], List[ResourceRequest]]: + """ + Try to schedule the resource requests on the current context. + + It tries to schedule the requests on the existing nodes first, and + then try to schedule the requests on new nodes if possible. + + Args: + requests_to_sched: The resource requests to be scheduled. + ctx: The current scheduling context. + resource_request_source: The source of the resource request, i.e. + pending demands from ray actors/tasks or cluster resource + constraints. + + Returns: + - List of scheduled nodes to that have part or all of the requests + scheduled. + - List of infeasible requests remained that cannot be scheduled. + """ + # First sort the requests. + def _sort_resource_request(req: ResourceRequest) -> Tuple: + """ + Sort the resource requests by: + 1. The length of its placement constraints. + 2. The length of its first label selector constraints (if any). + 3. The number of resources it requests. + 4. The values of resources it requests. + 5. lexicographically for each resource (for stable ordering) + + This is a legacy sorting function for the autoscaler's binpacking + algo - we do this so that we could have a deterministic scheduling + results with reasonable fragmentation. + """ + label_constraint_len = ( + len(req.label_selectors[0].label_constraints) + if req.label_selectors + else 0 + ) + return ( + len(req.placement_constraints), + label_constraint_len, + len(req.resources_bundle.values()), + sum(req.resources_bundle.values()), + sorted(req.resources_bundle.items()), + ) + + requests_to_sched = sorted( + requests_to_sched, key=_sort_resource_request, reverse=True + ) + + existing_nodes = ctx.get_nodes() + node_type_available = ctx.get_node_type_available() + + # A list of nodes that are either: + # 1. existing nodes in the cluster. or + # 2. new nodes that are launched to satisfy the resource requests. + target_nodes = [] + + # Try scheduling resource requests with existing nodes first. + while len(requests_to_sched) > 0 and len(existing_nodes) > 0: + ( + best_node, + requests_to_sched, + existing_nodes, + ) = ResourceDemandScheduler._sched_best_node( + requests_to_sched, existing_nodes, resource_request_source + ) + if best_node is None: + # No existing nodes can schedule any more requests. + break + + target_nodes.append(best_node) + + # If there's any existing nodes left, we will add to the target nodes + target_nodes.extend(existing_nodes) + + # Try scheduling resource requests with new nodes. + node_pools = [ + SchedulingNode.from_node_config( + ctx.get_node_type_configs()[node_type], + status=SchedulingNodeStatus.TO_LAUNCH, + node_kind=NodeKind.WORKER, + ) + for node_type, num_available in node_type_available.items() + if num_available > 0 + ] + while len(requests_to_sched) > 0 and len(node_pools) > 0: + # Max number of nodes reached. + max_num_nodes = ctx.get_max_num_nodes() + if max_num_nodes is not None and len(target_nodes) >= max_num_nodes: + logger.debug( + "Max number of nodes reached: {}, " + "cannot launch more nodes.".format(max_num_nodes) + ) + break + + ( + best_node, + requests_to_sched, + node_pools, + ) = ResourceDemandScheduler._sched_best_node( + requests_to_sched, node_pools, resource_request_source + ) + if best_node is None: + break + + target_nodes.append(best_node) + # Update the node pool if a node with the same node type of the + # added node can be launched. + node_type_available[best_node.node_type] -= 1 + if node_type_available[best_node.node_type] > 0: + node_pools.append( + SchedulingNode.from_node_config( + ctx.get_node_type_configs()[best_node.node_type], + status=SchedulingNodeStatus.TO_LAUNCH, + node_kind=NodeKind.WORKER, + ) + ) + + return target_nodes, requests_to_sched + + @staticmethod + def _sched_best_node( + requests: List[ResourceRequest], + nodes: List[SchedulingNode], + resource_request_source: ResourceRequestSource, + ) -> Tuple[SchedulingNode, List[ResourceRequest], List[SchedulingNode]]: + """ + Schedule the requests on the best node. + A simple greedy algorithm is used to schedule the requests: + 1. Try to schedule the requests on each node. + 2. Sort the nodes by a score + 3. Return the node with the highest score. + + The highest score node is updated with the scheduled requests, and the node is + removed from the node list. + + Args: + requests: The resource requests to be scheduled. + nodes: The node candidates to be scheduled on. The nodes will be updated + after the scheduling attempt, i.e. the node that is scheduled will be + removed from the list. + resource_request_source: The source of the resource request, i.e. + pending demands from ray actors/tasks or cluster resource constraints. + + Returns: + best_node: The best node to schedule the requests. + infeasible: The infeasible requests that cannot be scheduled on the best + node. + nodes: Remaining nodes after the best node is removed. + """ + results = [] + + # A temporary data class to store the scheduling result. + @dataclass + class ScheduleResult: + # The node candidate after a scheduling attempt. + node: SchedulingNode + # The infeasible resource requests that are not scheduled. + infeasible_requests: List[ResourceRequest] + # The index of the node in the original node list. + idx: int + # the score of the scheduling node to compare with others. + score: UtilizationScore + + nodes_copy = copy.deepcopy(nodes) + + # Iterate through each node and modify the node's available resources + # if the requests are schedulable. + for idx, node in enumerate(nodes_copy): + remaining, score = node.try_schedule(requests, resource_request_source) + + if len(remaining) == len(requests): + # The node cannot schedule any of the requests. + continue + + results.append(ScheduleResult(node, remaining, idx, score)) + + # No nodes can schedule any of the requests. + if len(results) == 0: + logger.debug( + "No nodes can schedule the requests: {}, for nodes: {}".format( + ResourceRequestUtil.to_dict_list(requests), nodes + ) + ) + return None, requests, nodes + + # Sort the results by score. + results = sorted(results, key=lambda r: r.score, reverse=True) + best_result = results[0] + + # Remove the best node from the nodes. + nodes.pop(best_result.idx) + logger.debug( + "Best node: {}, score: {}, remaining requests: {}".format( + best_result.node, + best_result.score, + ResourceRequestUtil.to_dict_list(best_result.infeasible_requests), + ) + ) + return best_result.node, best_result.infeasible_requests, nodes + + @staticmethod + def _terminate_outdated_nodes( + ctx: "ResourceDemandScheduler.ScheduleContext", + ) -> None: + """ + Terminate the nodes that are outdated, i.e. the node type config has been + updated or the node's launch config hash is outdated. + + Args: + ctx: The schedule context. + """ + nodes = ctx.get_nodes() + + if ctx._disable_launch_config_check: + # Outdated nodes check through launch config check is disabled. + return + + for node in nodes: + if node.status != SchedulingNodeStatus.SCHEDULABLE: + # We don't need to care about the non-running nodes. + continue + + if node.node_kind == NodeKind.HEAD: + # We should not be terminating the head node even if it's outdated. + logger.warning( + f"Head node {node.im_instance_id}(ray={node.ray_node_id}) is " + "outdated with node config changes. " + "Please check the node's config or restart the cluster or restart " + "the head node. Autoscaler is not able to shutdown the outdated " + "head node" + ) + continue + node_type = node.node_type + node_type_config = ctx.get_node_type_configs().get(node_type) + if node_type_config is None or ( + node_type_config.launch_config_hash + and node_type_config.launch_config_hash != node.launch_config_hash + ): + # The node type config has been updated, and the node's launch config + # hash is outdated. + node.status = SchedulingNodeStatus.TO_TERMINATE + node.termination_request = TerminationRequest( + id=str(time.time_ns()), + instance_id=node.im_instance_id, + ray_node_id=node.ray_node_id, + instance_type=node.node_type, + instance_status=node.im_instance_status, + cause=TerminationRequest.Cause.OUTDATED, + details=f"node from {node.node_type} has outdated config", + ) + + ctx.update(nodes) + + @staticmethod + def _enforce_idle_termination( + ctx: "ResourceDemandScheduler.ScheduleContext", + ) -> None: + """ + Enforce the idle termination for the nodes that are not needed by the cluster + resource constraints and idle for too long. + + Args: + ctx: The schedule context. + """ + count_by_node_type = ctx.get_cluster_shape() + node_type_configs = ctx.get_node_type_configs() + terminate_nodes_by_type: Dict[NodeType, int] = defaultdict(int) + + nodes = ctx.get_nodes() + s_to_ms = 1000 + for node in nodes: + if node.status != SchedulingNodeStatus.SCHEDULABLE: + # We don't need to care about the non-running nodes. + continue + + if node.node_kind == NodeKind.HEAD: + # The head node is not subject to idle termination. + continue + + idle_timeout_s = ctx.get_idle_timeout_s() + # Override the scheduler idle_timeout_s if set for this node_type. + node_type = node.node_type + if node_type in node_type_configs: + if node_type_configs[node_type].idle_timeout_s is not None: + idle_timeout_s = node_type_configs[node_type].idle_timeout_s + if idle_timeout_s is None: + # No idle timeout is set, skip the idle termination. + continue + + if node.idle_duration_ms <= idle_timeout_s * s_to_ms: + # The node is not idle for too long, skip it. + continue + + if node.sched_requests[ResourceRequestSource.PENDING_DEMAND]: + # The node is needed by the pending requests. + # Skip it. + logger.debug( + "Node {} (idle for {} secs) is needed by the pending requests, " + "skip idle termination.".format( + node.ray_node_id, node.idle_duration_ms / s_to_ms + ) + ) + continue + + if node.sched_requests[ResourceRequestSource.CLUSTER_RESOURCE_CONSTRAINT]: + # The node is needed by the resource constraints. + # Skip it. + logger.debug( + "Node {} (idle for {} secs) is needed by the cluster resource " + "constraints, skip idle termination.".format( + node.ray_node_id, node.idle_duration_ms / s_to_ms + ) + ) + continue + + # Honor the min_worker_nodes setting for the node type. + min_count = 0 + if node_type in node_type_configs: + min_count = node_type_configs[node_type].min_worker_nodes + if ( + count_by_node_type.get(node_type, 0) + - terminate_nodes_by_type[node_type] + <= min_count + ): + logger.info( + "Node {} (idle for {} secs) belongs to node_type {} and is " + "required by min_worker_nodes, skipping idle termination.".format( + node.ray_node_id, node.idle_duration_ms / s_to_ms, node_type + ) + ) + continue + + terminate_nodes_by_type[node.node_type] += 1 + # The node is idle for too long, terminate it. + node.status = SchedulingNodeStatus.TO_TERMINATE + node.termination_request = TerminationRequest( + id=str(uuid.uuid4()), + instance_id=node.im_instance_id, + ray_node_id=node.ray_node_id, + cause=TerminationRequest.Cause.IDLE, + instance_type=node.node_type, + instance_status=node.im_instance_status, + idle_duration_ms=node.idle_duration_ms, + details=f"idle for {node.idle_duration_ms/s_to_ms} secs > " + f"timeout={idle_timeout_s} secs", + ) + + ctx.update(nodes) diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/schema.py b/lib/python3.12/site-packages/ray/autoscaler/v2/schema.py new file mode 100644 index 0000000000000000000000000000000000000000..47c722c87cbad71f66a2186baada4af1858b17e6 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/schema.py @@ -0,0 +1,353 @@ +import re +from dataclasses import dataclass, field +from enum import Enum +from typing import Dict, List, Optional, Tuple + +from ray.autoscaler.v2.instance_manager.common import InstanceUtil +from ray.core.generated.autoscaler_pb2 import NodeState, NodeStatus +from ray.core.generated.instance_manager_pb2 import Instance + +# TODO(rickyx): once we have graceful shutdown, we could populate +# the failure detail with the actual termination message. As of now, +# we will use a more generic message to include cases such as: +# (idle termination, node death, crash, preemption, etc) +NODE_DEATH_CAUSE_RAYLET_DIED = "NodeTerminated" + + +# e.g., cpu_4_ondemand. +NodeType = str + + +@dataclass +class ResourceUsage: + # Resource name. + resource_name: str = "" + # Total resource. + total: float = 0.0 + # Resource used. + used: float = 0.0 + + +@dataclass +class NodeUsage: + # The node resource usage. + usage: List[ResourceUsage] + # How long the node has been idle. + idle_time_ms: int + + +@dataclass +class NodeInfo: + # The instance type name, e.g. p3.2xlarge + instance_type_name: str + # ray node type name. + ray_node_type_name: str + # Cloud instance id. + instance_id: str + # Ip address of the node when alive. + ip_address: str + # The status of the node. Optional for pending nodes. + node_status: Optional[str] = None + # ray node id in hex. None if still pending. + node_id: Optional[str] = None + # Resource usage breakdown if node is running. + resource_usage: Optional[NodeUsage] = None + # Failure detail if the node failed. + failure_detail: Optional[str] = None + # Descriptive details. + details: Optional[str] = None + # Activity on the node. + node_activity: Optional[List[str]] = None + # Ray node labels. + labels: Optional[Dict[str, str]] = None + + def total_resources(self) -> Dict[str, float]: + if self.resource_usage is None: + return {} + return {r.resource_name: r.total for r in self.resource_usage.usage} + + def available_resources(self) -> Dict[str, float]: + if self.resource_usage is None: + return {} + return {r.resource_name: r.total - r.used for r in self.resource_usage.usage} + + def used_resources(self) -> Dict[str, float]: + if self.resource_usage is None: + return {} + return {r.resource_name: r.used for r in self.resource_usage.usage} + + +@dataclass +class LaunchRequest: + class Status(Enum): + FAILED = "FAILED" + PENDING = "PENDING" + + # The instance type name, e.g. p3.2xlarge + instance_type_name: str + # ray node type name. + ray_node_type_name: str + # count. + count: int + # State: (e.g. PENDING, FAILED) + state: Status + # When the launch request was made in unix timestamp in secs. + request_ts_s: int + # When the launch request failed unix timestamp in secs if failed. + failed_ts_s: Optional[int] = None + # Request details, e.g. error reason if the launch request failed. + details: Optional[str] = None + + +@dataclass +class ResourceRequestByCount: + # Bundles in the demand. + bundle: Dict[str, float] + # Number of bundles with the same shape. + count: int + + def __str__(self) -> str: + return f"[{self.count} {self.bundle}]" + + +@dataclass +class ResourceDemand: + # The bundles in the demand with shape and count info. + bundles_by_count: List[ResourceRequestByCount] + + +@dataclass +class PlacementGroupResourceDemand(ResourceDemand): + # Details string (parsed into below information) + details: str + # Placement group's id. + pg_id: Optional[str] = None + # Strategy, e.g. STRICT_SPREAD + strategy: Optional[str] = None + # Placement group's state, e.g. PENDING + state: Optional[str] = None + + def __post_init__(self): + if not self.details: + return + + # Details in the format of :|, parse + # it into the above fields. + pattern = r"^.*:.*\|.*$" + match = re.match(pattern, self.details) + if not match: + return + + pg_id, details = self.details.split(":") + strategy, state = details.split("|") + self.pg_id = pg_id + self.strategy = strategy + self.state = state + + +@dataclass +class RayTaskActorDemand(ResourceDemand): + pass + + +@dataclass +class ClusterConstraintDemand(ResourceDemand): + pass + + +@dataclass +class ResourceDemandSummary: + # Placement group demand. + placement_group_demand: List[PlacementGroupResourceDemand] = field( + default_factory=list + ) + # Ray task actor demand. + ray_task_actor_demand: List[RayTaskActorDemand] = field(default_factory=list) + # Cluster constraint demand. + cluster_constraint_demand: List[ClusterConstraintDemand] = field( + default_factory=list + ) + + +@dataclass +class Stats: + # How long it took to get the GCS request. + # This is required when initializing the Stats since it should be calculated before + # the request was made. + gcs_request_time_s: float + # How long it took to get all live instances from node provider. + none_terminated_node_request_time_s: Optional[float] = None + # How long for autoscaler to process the scaling decision. + autoscaler_iteration_time_s: Optional[float] = None + # The last seen autoscaler state version from Ray. + autoscaler_version: Optional[str] = None + # The last seen cluster state resource version. + cluster_resource_state_version: Optional[str] = None + # Request made time unix timestamp: when the data was pulled from GCS. + request_ts_s: Optional[int] = None + + +@dataclass +class ClusterStatus: + # Healthy nodes information (non-idle) + active_nodes: List[NodeInfo] = field(default_factory=list) + # Idle node information + idle_nodes: List[NodeInfo] = field(default_factory=list) + # Pending launches. + pending_launches: List[LaunchRequest] = field(default_factory=list) + # Failed launches. + failed_launches: List[LaunchRequest] = field(default_factory=list) + # Pending nodes. + pending_nodes: List[NodeInfo] = field(default_factory=list) + # Failures + failed_nodes: List[NodeInfo] = field(default_factory=list) + # Resource usage summary for entire cluster. + cluster_resource_usage: List[ResourceUsage] = field(default_factory=list) + # Demand summary. + resource_demands: ResourceDemandSummary = field( + default_factory=ResourceDemandSummary + ) + # Query metics + stats: Stats = field(default_factory=Stats) + + def total_resources(self) -> Dict[str, float]: + return {r.resource_name: r.total for r in self.cluster_resource_usage} + + def available_resources(self) -> Dict[str, float]: + return {r.resource_name: r.total - r.used for r in self.cluster_resource_usage} + + # TODO(rickyx): we don't show infeasible requests as of now. + # (They will just be pending forever as part of the demands) + # We should show them properly in the future. + + +@dataclass +class AutoscalerInstance: + """ + AutoscalerInstance represents an instance that's managed by the autoscaler. + This includes two states: + 1. the instance manager state: information of the underlying cloud instance. + 2. the ray node state, e.g. resources, ray node status. + + The two states are linked by the cloud instance id, which should be set + when the ray node is started. + """ + + # The cloud instance id. It could be None if the instance hasn't been assigned + # a cloud instance id, e.g. the instance is still in QUEUED or REQUESTED status. + cloud_instance_id: Optional[str] = None + + # The ray node state status. It could be None when no ray node is running + # or has run on the cloud instance: for example, ray is still being installed + # or the instance manager hasn't had a cloud instance assigned (e.g. QUEUED, + # REQUESTED). + ray_node: Optional[NodeState] = None + + # The instance manager instance state. It would be None when the ray_node is not + # None. + # It could be None iff: + # 1. There's a ray node, but the instance manager hasn't discovered the + # cloud instance that's running this ray process yet. This could happen since + # the instance manager only discovers instances periodically. + # + # 2. There was a ray node running on the cloud instance, which was already stopped + # and removed from the instance manager state. But the ray state is still lagging + # behind. + # + # 3. There is a ray node that's unmanaged by the instance manager. + # + im_instance: Optional[Instance] = None + + # | cloud_instance_id | ray_node | im_instance | + # |-------------------|----------|-------------| + # | None | None | None | Not possible. + # | None | None | not None | OK. An instance hasn't had ray running on it yet. # noqa E501 + # | None | Not None | None | OK. Possible if the ray node is not started by autoscaler. # noqa E501 + # | None | Not None | not None | Not possible - no way to link im instance with ray node. # noqa E501 + # | not None | None | None | Not possible since cloud instance id is either part of im state or ray node. # noqa E501 + # | not None | None | not None | OK. e.g. An instance that's not running ray yet. # noqa E501 + # | not None | Not None | None | OK. See scenario 1, 2, 3 above. + # | not None | Not None | not None | OK. An instance that's running ray. + def validate(self) -> Tuple[bool, str]: + """Validate the autoscaler instance state. + + Returns: + A tuple of (valid, error_msg) where: + - valid is whether the state is valid + - error_msg is the error message for the validation results. + """ + + state_combinations = { + # (cloud_instance_id is None, ray_node is None, im_instance is None): (valid, error_msg) # noqa E501 + (True, True, True): (False, "Not possible"), + (True, True, False): (True, ""), + (True, False, True): ( + True, + "There's a ray node w/o cloud instance id, must be started not " + "by autoscaler", + ), + (True, False, False): ( + False, + "Not possible - no way to link im instance with ray node", + ), + (False, True, True): ( + False, + "Not possible since cloud instance id is either part of " + "im state or ray node", + ), + (False, True, False): (True, ""), + (False, False, True): (True, ""), + (False, False, False): (True, ""), + } + + valid, error_msg = state_combinations[ + ( + self.cloud_instance_id is None, + self.ray_node is None, + self.im_instance is None, + ) + ] + if not valid: + return valid, error_msg + + if self.im_instance is not None and self.ray_node is None: + # We don't see a ray node, but tracking an im instance. + if self.cloud_instance_id is None: + if InstanceUtil.is_cloud_instance_allocated(self.im_instance.status): + return ( + False, + "instance should be in a status where cloud instance " + "is not allocated.", + ) + else: + if not InstanceUtil.is_cloud_instance_allocated( + self.im_instance.status + ): + return ( + False, + "instance should be in a status where cloud instance is " + "allocated.", + ) + + if self.ray_node is not None: + if self.cloud_instance_id != self.ray_node.instance_id: + return False, "cloud instance id doesn't match." + + if self.im_instance is not None and self.cloud_instance_id is not None: + if self.cloud_instance_id != self.im_instance.cloud_instance_id: + return False, "cloud instance id doesn't match." + + return True, "" + + def is_ray_running(self) -> bool: + """Whether the ray node is running.""" + return self.ray_node is not None and self.ray_node.status in [ + NodeStatus.RUNNING, + NodeStatus.IDLE, + ] + + def is_ray_stop(self) -> bool: + """Whether the ray node is stopped.""" + return self.ray_node is None or self.ray_node.status in [ + NodeStatus.DEAD, + ] diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/sdk.py b/lib/python3.12/site-packages/ray/autoscaler/v2/sdk.py new file mode 100644 index 0000000000000000000000000000000000000000..ecce0aada532627d3936d14fdbc48037d898a42e --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/sdk.py @@ -0,0 +1,121 @@ +import time +from collections import Counter +from typing import List, NamedTuple + +from ray._raylet import GcsClient +from ray.autoscaler.v2.schema import ClusterStatus, Stats +from ray.autoscaler.v2.utils import ClusterStatusParser +from ray.core.generated.autoscaler_pb2 import ( + ClusterResourceState, + GetClusterResourceStateReply, + GetClusterStatusReply, +) + +DEFAULT_RPC_TIMEOUT_S = 10 + + +class ResourceRequest(NamedTuple): + resources: dict + label_selector: dict + + +def request_cluster_resources( + gcs_address: str, + to_request: List[dict], + timeout: int = DEFAULT_RPC_TIMEOUT_S, +): + """Request resources from the autoscaler. + + This will add a cluster resource constraint to GCS. GCS will asynchronously + pass the constraint to the autoscaler, and the autoscaler will try to provision the + requested minimal bundles in `to_request`. + + If the cluster already has `to_request` resources, this will be an no-op. + Future requests submitted through this API will overwrite the previous requests. + + Args: + gcs_address: The GCS address to query. + to_request: A list of resource requests to request the cluster to have. + Each resource request is a tuple of resources and a label_selector + to apply per-bundle. e.g.: [{"resources": {"CPU": 1, "GPU": 1}, "label_selector": {"accelerator-type": "A100"}}] + timeout: Timeout in seconds for the request to be timeout + + """ + assert len(gcs_address) > 0, "GCS address is not specified." + + # Convert bundle dicts to ResourceRequest tuples. + normalized: List[ResourceRequest] = [] + for r in to_request: + assert isinstance( + r, dict + ), f"Internal Error: Expected a dict, but got {type(r)}" + resources = r.get("resources", {}) + selector = r.get("label_selector", {}) + normalized.append(ResourceRequest(resources, selector)) + + to_request = normalized + + # Aggregate bundle by shape + def keyfunc(r): + return ( + frozenset(r.resources.items()), + frozenset(r.label_selector.items()), + ) + + grouped_requests = Counter(keyfunc(r) for r in to_request) + + bundles: List[dict] = [] + label_selectors: List[dict] = [] + counts: List[int] = [] + + for (bundle, selector), count in grouped_requests.items(): + bundles.append(dict(bundle)) + label_selectors.append(dict(selector)) + counts.append(count) + + GcsClient(gcs_address).request_cluster_resource_constraint( + bundles, label_selectors, counts, timeout_s=timeout + ) + + +def get_cluster_status( + gcs_address: str, timeout: int = DEFAULT_RPC_TIMEOUT_S +) -> ClusterStatus: + """ + Get the cluster status from the autoscaler. + + Args: + gcs_address: The GCS address to query. + timeout: Timeout in seconds for the request to be timeout + + Returns: + A ClusterStatus object. + """ + assert len(gcs_address) > 0, "GCS address is not specified." + req_time = time.time() + str_reply = GcsClient(gcs_address).get_cluster_status(timeout_s=timeout) + reply_time = time.time() + reply = GetClusterStatusReply() + reply.ParseFromString(str_reply) + + # TODO(rickyx): To be more accurate, we could add a timestamp field from the reply. + return ClusterStatusParser.from_get_cluster_status_reply( + reply, + stats=Stats(gcs_request_time_s=reply_time - req_time, request_ts_s=req_time), + ) + + +def get_cluster_resource_state(gcs_client: GcsClient) -> ClusterResourceState: + """ + Get the cluster resource state from GCS. + Args: + gcs_client: The GCS client to query. + Returns: + A ClusterResourceState object + Raises: + Exception: If the request times out or failed. + """ + str_reply = gcs_client.get_cluster_resource_state() + reply = GetClusterResourceStateReply() + reply.ParseFromString(str_reply) + return reply.cluster_resource_state diff --git a/lib/python3.12/site-packages/ray/autoscaler/v2/utils.py b/lib/python3.12/site-packages/ray/autoscaler/v2/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..bca10ddd17864e40d8403b853bb6f971572f19a2 --- /dev/null +++ b/lib/python3.12/site-packages/ray/autoscaler/v2/utils.py @@ -0,0 +1,1090 @@ +from collections import Counter, defaultdict +from copy import deepcopy +from datetime import datetime +from enum import Enum +from itertools import chain +from typing import Any, Dict, List, Optional, Tuple + +import ray +from ray._common.utils import binary_to_hex +from ray._raylet import GcsClient +from ray.autoscaler._private import constants +from ray.autoscaler._private.util import ( + format_pg, + format_resource_demand_summary, + parse_usage, +) +from ray.autoscaler.v2.schema import ( + NODE_DEATH_CAUSE_RAYLET_DIED, + ClusterConstraintDemand, + ClusterStatus, + LaunchRequest, + NodeInfo, + NodeUsage, + PlacementGroupResourceDemand, + RayTaskActorDemand, + ResourceDemand, + ResourceDemandSummary, + ResourceRequestByCount, + ResourceUsage, + Stats, +) +from ray.core.generated.autoscaler_pb2 import ( + AffinityConstraint, + AntiAffinityConstraint, + AutoscalingState, + ClusterResourceState, + GetClusterStatusReply, + NodeState, + NodeStatus, + PlacementConstraint, + ResourceRequest, + ResourceRequestByCount as ResourceRequestByCountProto, +) +from ray.core.generated.common_pb2 import ( + LabelSelector, + LabelSelectorConstraint, +) +from ray.experimental.internal_kv import internal_kv_get_gcs_client + + +def _count_by(data: Any, key: str) -> Dict[str, int]: + """ + Count the number of items by the given keys. + Args: + data: the data to be counted + keys: the keys to count by + Returns: + counts: the counts + """ + counts = defaultdict(int) + for item in data: + key_name = getattr(item, key) + counts[key_name] += 1 + return counts + + +class ProtobufUtil: + """ + A utility class for protobuf objects. + """ + + @staticmethod + def to_dict(proto): + """ + Convert a protobuf object to a dict. + + This is a slow conversion, and should only be used for debugging or + latency insensitve code. + + Args: + proto: the protobuf object + Returns: + dict: the dict + """ + from ray._private.protobuf_compat import message_to_dict + + return message_to_dict( + proto, + preserving_proto_field_name=True, + always_print_fields_with_no_presence=True, + ) + + @staticmethod + def to_dict_list(protos): + """ + Convert a list of protobuf objects to a list of dicts. + + Args: + protos: the list of protobuf objects + Returns: + dict_list: the list of dicts + """ + return [ProtobufUtil.to_dict(proto) for proto in protos] + + +class ResourceRequestUtil(ProtobufUtil): + """ + A utility class for resource requests, autoscaler.proto.ResourceRequest + """ + + class PlacementConstraintType(Enum): + """ + The affinity type for the resource request. + """ + + ANTI_AFFINITY = "ANTI_AFFINITY" + AFFINITY = "AFFINITY" + + @staticmethod + def group_by_count( + requests: List[ResourceRequest], + ) -> List[ResourceRequestByCountProto]: + """ + Aggregate resource requests by shape. + Args: + requests: the list of resource requests + Returns: + resource_requests_by_count: the aggregated resource requests by count + """ + resource_requests_by_count = defaultdict(int) + for request in requests: + serialized_request = request.SerializeToString() + resource_requests_by_count[serialized_request] += 1 + + results = [] + for serialized_request, count in resource_requests_by_count.items(): + request = ResourceRequest() + request.ParseFromString(serialized_request) + results.append(ResourceRequestByCountProto(request=request, count=count)) + + return results + + @staticmethod + def ungroup_by_count( + requests_by_count: List[ResourceRequestByCountProto], + ) -> List[ResourceRequest]: + """ + Flatten the resource requests by count to resource requests. + Args: + requests_by_count: the resource requests by count + Returns: + requests: the flattened resource requests + """ + reqs = [] + for r in requests_by_count: + reqs += [r.request] * r.count + + return reqs + + @staticmethod + def to_resource_map( + request: ResourceRequest, + ) -> Dict[str, float]: + """ + Convert the resource request by count to resource map. + Args: + request: the resource request + Returns: + resource_map: the resource map + """ + resource_map = defaultdict(float) + for k, v in request.resources_bundle.items(): + resource_map[k] += v + return dict(resource_map) + + @staticmethod + def to_resource_maps( + requests: List[ResourceRequest], + ) -> List[Dict[str, float]]: + """ + Convert the resource requests by count to resource map. + Args: + requests: the resource requests + Returns: + resource_maps: list of resource map + """ + return [ResourceRequestUtil.to_resource_map(r) for r in requests] + + @staticmethod + def make( + resources_map: Dict[str, float], + constraints: Optional[List[Tuple[PlacementConstraintType, str, str]]] = None, + label_selectors: Optional[List[List[Tuple[str, int, List[str]]]]] = None, + ) -> ResourceRequest: + """ + Make a resource request from the given resources map. + Args: + resources_map: Mapping of resource names to quantities. + constraints: Placement constraints. Each tuple is (constraint_type, + label_key, label_value), where `constraint_type` is a + PlacementConstraintType (AFFINITY or ANTI_AFFINITY). + label_selectors: Optional list of label selectors. Each selector is + a list of (label_key, operator_enum, label_values) tuples. + Returns: + request: the ResourceRequest object + """ + request = ResourceRequest() + for resource_name, quantity in resources_map.items(): + request.resources_bundle[resource_name] = quantity + + if constraints is not None: + for constraint_type, label, value in constraints: + if ( + constraint_type + == ResourceRequestUtil.PlacementConstraintType.AFFINITY + ): + request.placement_constraints.append( + PlacementConstraint( + affinity=AffinityConstraint( + label_name=label, label_value=value + ) + ) + ) + elif ( + constraint_type + == ResourceRequestUtil.PlacementConstraintType.ANTI_AFFINITY + ): + request.placement_constraints.append( + PlacementConstraint( + anti_affinity=AntiAffinityConstraint( + label_name=label, label_value=value + ) + ) + ) + else: + raise ValueError(f"Unknown constraint type: {constraint_type}") + + if label_selectors is not None: + for selector in label_selectors: + selector_proto = LabelSelector() + for label_key, operator_enum, label_values in selector: + selector_proto.label_constraints.append( + LabelSelectorConstraint( + label_key=label_key, + operator=operator_enum, + label_values=label_values, + ) + ) + request.label_selectors.append(selector_proto) + + return request + + @staticmethod + def combine_requests_with_affinity( + resource_requests: List[ResourceRequest], + ) -> List[ResourceRequest]: + """ + Combine the resource requests with affinity constraints + into the same request. This is so that requests with affinity + constraints could be considered and placed together. + + It merges the resource requests with the same affinity constraints + into one request, and dedup the placement constraints. + + This assumes following: + 1. There's only at most 1 placement constraint, either an affinity + constraint OR an anti-affinity constraint. + + Args: + resource_requests: The list of resource requests to be combined. + Returns: + A list of combined resource requests. + """ + + # Map of set of serialized affinity constraint to the list of resource requests + requests_by_affinity: Dict[ + Tuple[str, str, Tuple], List[ResourceRequest] + ] = defaultdict(list) + combined_requests: List[ResourceRequest] = [] + + for request in resource_requests: + assert len(request.placement_constraints) <= 1, ( + "There should be at most 1 placement constraint, " + "either an affinity constraint OR an anti-affinity constraint." + ) + + if len(request.placement_constraints) == 0: + # No affinity constraints, just add to the combined requests. + combined_requests.append(request) + continue + + constraint = request.placement_constraints[0] + + if constraint.HasField("affinity"): + # Combine requests with affinity and label selectors. + affinity = constraint.affinity + key = ( + affinity.label_name, + affinity.label_value, + ResourceRequestUtil._label_selector_key(request.label_selectors), + ) + requests_by_affinity[key].append(request) + elif constraint.HasField("anti_affinity"): + # We don't need to combine requests with anti-affinity constraints. + combined_requests.append(request) + + for ( + affinity_label_name, + affinity_label_value, + label_selector_key, + ), requests in requests_by_affinity.items(): + combined_request = ResourceRequest() + + # Merge the resource bundles with the same affinity constraint. + for request in requests: + for k, v in request.resources_bundle.items(): + combined_request.resources_bundle[k] = ( + combined_request.resources_bundle.get(k, 0) + v + ) + + # Add the placement constraint to the combined request. + affinity_constraint = AffinityConstraint( + label_name=affinity_label_name, label_value=affinity_label_value + ) + combined_request.placement_constraints.append( + PlacementConstraint(affinity=affinity_constraint) + ) + + combined_request.label_selectors.extend(requests[0].label_selectors) + + combined_requests.append(combined_request) + + return combined_requests + + def _label_selector_key( + label_selectors: List[LabelSelector], + ) -> Tuple: + """ + Convert label selectors into a hashable form for grouping. + This is used for gang requests with identical label_selectors. + """ + result = [] + for selector in label_selectors: + constraints = [] + for constraint in selector.label_constraints: + constraints.append( + ( + constraint.label_key, + constraint.operator, + tuple(sorted(constraint.label_values)), + ) + ) + result.append(tuple(constraints)) + return tuple(result) + + +class ClusterStatusFormatter: + """ + A formatter to format the ClusterStatus into a string. + + """ + + @classmethod + def format(cls, data: ClusterStatus, verbose: bool = False) -> str: + header, separator_len = cls._header_info(data, verbose) + separator = "-" * separator_len + + # Parse ClusterStatus information to reportable format + available_node_report = cls._available_node_report(data) + idle_node_report = cls._idle_node_report(data) + pending_report = cls._pending_node_report(data) + failure_report = cls._failed_node_report(data, verbose) + cluster_usage_report = cls._cluster_usage_report(data, verbose) + constraints_report = cls._constraint_report( + data.resource_demands.cluster_constraint_demand + ) + demand_report = cls._demand_report(data) + node_usage_report = ( + "" + if not verbose + else cls._node_usage_report(data.active_nodes, data.idle_nodes) + ) + + # Format Cluster Status reports into one output + formatted_output_lines = [ + header, + "Node status", + separator, + "Active:", + available_node_report, + "Idle:", + idle_node_report, + "Pending:", + pending_report, + failure_report, + "", + "Resources", + separator, + "Total Usage:", + cluster_usage_report, + "From request_resources:", + constraints_report, + "Pending Demands:", + demand_report, + node_usage_report, + ] + + formatted_output = "\n".join(formatted_output_lines) + + return formatted_output.strip() + + @staticmethod + def _node_usage_report( + active_nodes: List[NodeInfo], idle_nodes: List[NodeInfo] + ) -> str: + """[Example]: + Node: raycluster-autoscaler-small-group-worker-n8hrw (small-group) + Id: cc22041297e5fc153b5357e41f184c8000869e8de97252cc0291fd17 + Usage: + 1.0/1.0 CPU + 0B/953.67MiB memory + 0B/251.76MiB object_store_memory + Activity: + Resource: CPU currently in use. + Busy workers on node. + """ + node_id_to_usage: Dict[str, Dict[str, Tuple[float, float]]] = {} + node_id_to_type: Dict[str, str] = {} + node_id_to_idle_time: Dict[str, int] = {} + node_id_to_instance_id: Dict[str, str] = {} + node_id_to_activities: Dict[str, List[str]] = {} + + # Populate mappings for node types, idle times, instance ids, and activities + for node in chain(active_nodes, idle_nodes): + node_id_to_usage[node.node_id] = { + u.resource_name: (u.used, u.total) for u in node.resource_usage.usage + } + node_id_to_type[node.node_id] = node.ray_node_type_name + node_id_to_idle_time[node.node_id] = node.resource_usage.idle_time_ms + node_id_to_instance_id[node.node_id] = node.instance_id + node_id_to_activities[node.node_id] = node.node_activity + + node_usage_report_lines = [] + for node_id, usage in node_id_to_usage.items(): + node_usage_report_lines.append("") # Add a blank line between nodes + + node_type_line = f"Node: {node_id_to_instance_id[node_id]}" + if node_id in node_id_to_type: + node_type = node_id_to_type[node_id] + node_type_line += f" ({node_type})" + node_usage_report_lines.append(node_type_line) + node_usage_report_lines.append(f" Id: {node_id}") + + if node_id_to_idle_time.get(node_id, 0) > 0: + node_usage_report_lines.append( + f" Idle: {node_id_to_idle_time[node_id]} ms" + ) + + node_usage_report_lines.append(" Usage:") + for line in parse_usage(usage, verbose=True): + node_usage_report_lines.append(f" {line}") + + activities = node_id_to_activities.get(node_id, []) + node_usage_report_lines.append(" Activity:") + if activities is None or len(activities) == 0: + node_usage_report_lines.append(" (no activity)") + else: + for activity in activities: + node_usage_report_lines.append(f" {activity}") + + # Join the list into a single string with new lines + return "\n".join(node_usage_report_lines) + + @staticmethod + def _header_info(data: ClusterStatus, verbose: bool) -> (str, int): + # Get the request timestamp or default to the current time + time = ( + datetime.fromtimestamp(data.stats.request_ts_s) + if data.stats.request_ts_s + else datetime.now() + ) + + # Gather the time statistics + gcs_request_time = data.stats.gcs_request_time_s + non_terminated_nodes_time = data.stats.none_terminated_node_request_time_s + autoscaler_update_time = data.stats.autoscaler_iteration_time_s + + # Create the header with autoscaler status + header = "=" * 8 + f" Autoscaler status: {time} " + "=" * 8 + separator_len = len(header) + + # Add verbose details if required + if verbose: + details = [] + if gcs_request_time: + details.append(f"GCS request time: {gcs_request_time:3f}s") + if non_terminated_nodes_time: + details.append( + f"Node Provider non_terminated_nodes time: {non_terminated_nodes_time:3f}s" + ) + if autoscaler_update_time: + details.append( + f"Autoscaler iteration time: {autoscaler_update_time:3f}s" + ) + + if details: + header += "\n" + "\n".join(details) + "\n" + + return header, separator_len + + @staticmethod + def _available_node_report(data: ClusterStatus) -> str: + active_nodes = _count_by(data.active_nodes, "ray_node_type_name") + + # Build the available node report + if not active_nodes: + return " (no active nodes)" + return "\n".join( + f" {count} {node_type}" for node_type, count in active_nodes.items() + ) + + @staticmethod + def _idle_node_report(data: ClusterStatus) -> str: + idle_nodes = _count_by(data.idle_nodes, "ray_node_type_name") + + # Build the idle node report + if not idle_nodes: + return " (no idle nodes)" + return "\n".join( + f" {count} {node_type}" for node_type, count in idle_nodes.items() + ) + + @staticmethod + def _failed_node_report(data: ClusterStatus, verbose: bool) -> str: + failure_lines = [] + + # Process failed launches + if data.failed_launches: + sorted_failed_launches = sorted( + data.failed_launches, + key=lambda launch: launch.request_ts_s, + reverse=True, + ) + + for failed_launch in sorted_failed_launches: + node_type = failed_launch.ray_node_type_name + category = "LaunchFailed" + description = failed_launch.details + attempted_time = datetime.fromtimestamp(failed_launch.request_ts_s) + formatted_time = f"{attempted_time.hour:02d}:{attempted_time.minute:02d}:{attempted_time.second:02d}" + + line = f" {node_type}: {category} (latest_attempt: {formatted_time})" + if verbose: + line += f" - {description}" + + failure_lines.append(line) + + # Process failed nodes + for node in data.failed_nodes: + failure_lines.append( + f" {node.ray_node_type_name}: NodeTerminated (instance_id: {node.instance_id})" + ) + + # Limit the number of failures displayed + failure_lines = failure_lines[: constants.AUTOSCALER_MAX_FAILURES_DISPLAYED] + + # Build the failure report + failure_report = "Recent failures:\n" + failure_report += ( + "\n".join(failure_lines) if failure_lines else " (no failures)" + ) + + return failure_report + + @staticmethod + def _pending_node_report(data: ClusterStatus) -> str: + # Prepare pending launch lines + pending_lines = [ + f" {node_type}, {count} launching" + for node_type, count in _count_by( + data.pending_launches, "ray_node_type_name" + ).items() + ] + + # Prepare pending node lines + pending_lines.extend( + f" {ip}: {node_type}, {status.lower()}" + for ip, node_type, status in ( + (node.instance_id, node.ray_node_type_name, node.details) + for node in data.pending_nodes + ) + ) + + # Construct the pending report + if pending_lines: + return "\n".join(pending_lines) + return " (no pending nodes)" + + @staticmethod + def _constraint_report( + cluster_constraint_demand: List[ClusterConstraintDemand], + ) -> str: + """Returns a formatted string describing the resource constraints from request_resources(). + + Args: + data: ClusterStatus object containing resource demand information. + + Returns: + String containing the formatted constraints report, either listing each constraint + and count or indicating no constraints exist. + + Example: + >>> cluster_constraint_demand = [ + ... ClusterConstraintDemand(bundles_by_count=[ + ... ResourceRequestByCount(bundle={"CPU": 4}, count=2), + ... ResourceRequestByCount(bundle={"GPU": 1}, count=1) + ... ]) + ... ] + >>> ClusterStatusFormatter._constraint_report(cluster_constraint_demand) + " {'CPU': 4}: 2 from request_resources()\\n {'GPU': 1}: 1 from request_resources()" + """ + constraint_lines = [] + request_demand = [ + (bc.bundle, bc.count) + for constraint_demand in cluster_constraint_demand + for bc in constraint_demand.bundles_by_count + ] + for bundle, count in request_demand: + constraint_lines.append(f" {bundle}: {count} from request_resources()") + if constraint_lines: + return "\n".join(constraint_lines) + return " (none)" + + @staticmethod + def _demand_report(data: ClusterStatus) -> str: + # Process resource demands + resource_demands = [ + (bundle.bundle, bundle.count) + for demand in data.resource_demands.ray_task_actor_demand + for bundle in demand.bundles_by_count + ] + demand_lines = [] + if resource_demands: + demand_lines.extend(format_resource_demand_summary(resource_demands)) + + # Process placement group demands + pg_demand_strs = [ + f"{pg_demand.strategy}|{pg_demand.state}" + for pg_demand in data.resource_demands.placement_group_demand + ] + pg_demand_str_to_demand = { + f"{pg_demand.strategy}|{pg_demand.state}": pg_demand + for pg_demand in data.resource_demands.placement_group_demand + } + pg_freqs = Counter(pg_demand_strs) + + pg_demand = [ + ( + { + "strategy": pg_demand_str_to_demand[pg_str].strategy, + "bundles": [ + (bundle.bundle, bundle.count) + for bundle in pg_demand_str_to_demand[pg_str].bundles_by_count + ], + }, + freq, + ) + for pg_str, freq in pg_freqs.items() + ] + + for pg, count in pg_demand: + pg_str = format_pg(pg) + demand_lines.append(f" {pg_str}: {count}+ pending placement groups") + + # Generate demand report + if demand_lines: + return "\n".join(demand_lines) + return " (no resource demands)" + + @staticmethod + def _cluster_usage_report(data: ClusterStatus, verbose: bool) -> str: + # Build usage dictionary + usage = { + u.resource_name: (u.used, u.total) for u in data.cluster_resource_usage + } + + # Parse usage lines + usage_lines = parse_usage(usage, verbose) + + # Generate usage report + usage_report = [f" {line}" for line in usage_lines] + [""] + + return "\n".join(usage_report) + + +class ClusterStatusParser: + @classmethod + def from_get_cluster_status_reply( + cls, proto: GetClusterStatusReply, stats: Stats + ) -> ClusterStatus: + # parse nodes info + active_nodes, idle_nodes, failed_nodes = cls._parse_nodes( + proto.cluster_resource_state + ) + + # parse pending nodes info + pending_nodes = cls._parse_pending(proto.autoscaling_state) + + # parse launch requests + pending_launches, failed_launches = cls._parse_launch_requests( + proto.autoscaling_state + ) + + # parse cluster resource usage + cluster_resource_usage = cls._parse_cluster_resource_usage( + proto.cluster_resource_state + ) + + # parse resource demands + resource_demands = cls._parse_resource_demands(proto.cluster_resource_state) + + # parse stats + stats = cls._parse_stats(proto, stats) + + return ClusterStatus( + active_nodes=active_nodes, + idle_nodes=idle_nodes, + pending_launches=pending_launches, + failed_launches=failed_launches, + pending_nodes=pending_nodes, + failed_nodes=failed_nodes, + cluster_resource_usage=cluster_resource_usage, + resource_demands=resource_demands, + stats=stats, + ) + + @classmethod + def _parse_stats(cls, reply: GetClusterStatusReply, stats: Stats) -> Stats: + """ + Parse the stats from the get cluster status reply. + Args: + reply: the get cluster status reply + stats: the stats + Returns: + stats: the parsed stats + """ + stats = deepcopy(stats) + + stats.gcs_request_time_s = stats.gcs_request_time_s + # TODO(rickyx): Populate other autoscaler stats once available. + stats.autoscaler_version = str(reply.autoscaling_state.autoscaler_state_version) + stats.cluster_resource_state_version = str( + reply.cluster_resource_state.cluster_resource_state_version + ) + + return stats + + @classmethod + def _parse_resource_demands( + cls, state: ClusterResourceState + ) -> List[ResourceDemand]: + """ + Parse the resource demands from the cluster resource state. + Args: + state: the cluster resource state + Returns: + resource_demands: the resource demands + """ + task_actor_demand = [] + pg_demand = [] + constraint_demand = [] + + for request_count in state.pending_resource_requests: + # TODO(rickyx): constraints? + demand = RayTaskActorDemand( + bundles_by_count=[ + ResourceRequestByCount( + request_count.request.resources_bundle, request_count.count + ) + ], + ) + task_actor_demand.append(demand) + + for gang_request in state.pending_gang_resource_requests: + demand = PlacementGroupResourceDemand( + bundles_by_count=cls._aggregate_resource_requests_by_shape( + gang_request.requests + ), + details=gang_request.details, + ) + pg_demand.append(demand) + + for constraint_request in state.cluster_resource_constraints: + demand = ClusterConstraintDemand( + bundles_by_count=[ + ResourceRequestByCount( + bundle=dict(r.request.resources_bundle.items()), count=r.count + ) + for r in constraint_request.resource_requests + ] + ) + constraint_demand.append(demand) + + return ResourceDemandSummary( + ray_task_actor_demand=task_actor_demand, + placement_group_demand=pg_demand, + cluster_constraint_demand=constraint_demand, + ) + + @classmethod + def _aggregate_resource_requests_by_shape( + cls, + requests: List[ResourceRequest], + ) -> List[ResourceRequestByCount]: + """ + Aggregate resource requests by shape. + Args: + requests: the list of resource requests + Returns: + resource_requests_by_count: the aggregated resource requests by count + """ + + resource_requests_by_count = defaultdict(int) + for request in requests: + bundle = frozenset(request.resources_bundle.items()) + resource_requests_by_count[bundle] += 1 + + return [ + ResourceRequestByCount(dict(bundle), count) + for bundle, count in resource_requests_by_count.items() + ] + + @classmethod + def _parse_node_resource_usage( + cls, node_state: NodeState, usage: Dict[str, ResourceUsage] + ) -> Dict[str, ResourceUsage]: + """ + Parse the node resource usage from the node state. + Args: + node_state: the node state + usage: the usage dict to be updated. This is a dict of + {resource_name: ResourceUsage} + Returns: + usage: the updated usage dict + """ + # Tuple of {resource_name : (used, total)} + d = defaultdict(lambda: [0.0, 0.0]) + for resource_name, resource_total in node_state.total_resources.items(): + d[resource_name][1] += resource_total + # Will be subtracted from available later. + d[resource_name][0] += resource_total + + for ( + resource_name, + resource_available, + ) in node_state.available_resources.items(): + d[resource_name][0] -= resource_available + + # Merge with the passed in usage. + for k, (used, total) in d.items(): + usage[k].resource_name = k + usage[k].used += used + usage[k].total += total + + return usage + + @classmethod + def _parse_cluster_resource_usage( + cls, + state: ClusterResourceState, + ) -> List[ResourceUsage]: + """ + Parse the cluster resource usage from the cluster resource state. + Args: + state: the cluster resource state + Returns: + cluster_resource_usage: the cluster resource usage + """ + + cluster_resource_usage = defaultdict(ResourceUsage) + + for node_state in state.node_states: + if node_state.status != NodeStatus.DEAD: + cluster_resource_usage = cls._parse_node_resource_usage( + node_state, cluster_resource_usage + ) + + return list(cluster_resource_usage.values()) + + @classmethod + def _parse_nodes( + cls, + state: ClusterResourceState, + ) -> Tuple[List[NodeInfo], List[NodeInfo]]: + """ + Parse the node info from the cluster resource state. + Args: + state: the cluster resource state + Returns: + active_nodes: the list of non-idle nodes + idle_nodes: the list of idle nodes + dead_nodes: the list of dead nodes + """ + active_nodes = [] + dead_nodes = [] + idle_nodes = [] + for node_state in state.node_states: + # Basic node info. + node_id = binary_to_hex(node_state.node_id) + if len(node_state.ray_node_type_name) == 0: + # We don't have a node type name, but this is needed for showing + # healthy nodes. This happens when we don't use cluster launcher. + # but start ray manually. We will use node id as node type name. + ray_node_type_name = f"node_{node_id}" + else: + ray_node_type_name = node_state.ray_node_type_name + + # Parse the resource usage if it's not dead + node_resource_usage = None + failure_detail = None + if node_state.status == NodeStatus.DEAD: + # TODO(rickyx): Technically we could get a more verbose + # failure detail from GCS, but existing ray status treats + # all ray failures as raylet death. + failure_detail = NODE_DEATH_CAUSE_RAYLET_DIED + else: + usage = defaultdict(ResourceUsage) + usage = cls._parse_node_resource_usage(node_state, usage) + node_resource_usage = NodeUsage( + usage=list(usage.values()), + idle_time_ms=node_state.idle_duration_ms + if node_state.status == NodeStatus.IDLE + else 0, + ) + + node_info = NodeInfo( + instance_type_name=node_state.instance_type_name, + node_status=NodeStatus.Name(node_state.status), + node_id=binary_to_hex(node_state.node_id), + ip_address=node_state.node_ip_address, + ray_node_type_name=ray_node_type_name, + instance_id=node_state.instance_id, + resource_usage=node_resource_usage, + failure_detail=failure_detail, + node_activity=node_state.node_activity, + labels=dict(node_state.labels), + ) + + if node_state.status == NodeStatus.DEAD: + dead_nodes.append(node_info) + elif node_state.status == NodeStatus.IDLE: + idle_nodes.append(node_info) + else: + active_nodes.append(node_info) + + return active_nodes, idle_nodes, dead_nodes + + @classmethod + def _parse_launch_requests( + cls, state: AutoscalingState + ) -> Tuple[List[LaunchRequest], List[LaunchRequest]]: + """ + Parse the launch requests from the autoscaling state. + Args: + state: the autoscaling state, empty if there's no autoscaling state + being reported. + Returns: + pending_launches: the list of pending launches + failed_launches: the list of failed launches + """ + pending_launches = [] + for pending_request in state.pending_instance_requests: + launch = LaunchRequest( + instance_type_name=pending_request.instance_type_name, + ray_node_type_name=pending_request.ray_node_type_name, + count=pending_request.count, + state=LaunchRequest.Status.PENDING, + request_ts_s=pending_request.request_ts, + ) + + pending_launches.append(launch) + + failed_launches = [] + for failed_request in state.failed_instance_requests: + launch = LaunchRequest( + instance_type_name=failed_request.instance_type_name, + ray_node_type_name=failed_request.ray_node_type_name, + count=failed_request.count, + state=LaunchRequest.Status.FAILED, + request_ts_s=failed_request.start_ts, + details=failed_request.reason, + failed_ts_s=failed_request.failed_ts, + ) + + failed_launches.append(launch) + + return pending_launches, failed_launches + + @classmethod + def _parse_pending(cls, state: AutoscalingState) -> List[NodeInfo]: + """ + Parse the pending requests/nodes from the autoscaling state. + Args: + state: the autoscaling state, empty if there's no autoscaling state + being reported. + Returns: + pending_nodes: the list of pending nodes + """ + pending_nodes = [] + for pending_node in state.pending_instances: + pending_nodes.append( + NodeInfo( + instance_type_name=pending_node.instance_type_name, + ray_node_type_name=pending_node.ray_node_type_name, + details=pending_node.details, + instance_id=pending_node.instance_id, + ip_address=pending_node.ip_address, + ) + ) + + return pending_nodes + + +cached_is_autoscaler_v2 = None + + +def is_autoscaler_v2( + fetch_from_server: bool = False, gcs_client: Optional[GcsClient] = None +) -> bool: + """ + Check if the autoscaler is v2 from reading GCS internal KV. + + If the method is called multiple times, the result will be cached in the module. + + Args: + fetch_from_server: If True, fetch the value from the GCS server, otherwise + use the cached value. + gcs_client: The GCS client to use. If not provided, the default GCS + client will be used. + + Returns: + is_v2: True if the autoscaler is v2, False otherwise. + + Raises: + Exception: if GCS address could not be resolved (e.g. ray.init() not called) + """ + # If env var is set to enable autoscaler v2, we should always return True. + if ray._config.enable_autoscaler_v2() and not fetch_from_server: + # TODO(rickyx): Once we migrate completely to v2, we should remove this. + # While this short-circuit may allow client-server inconsistency + # (e.g. client running v1, while server running v2), it's currently + # not possible with existing use-cases. + return True + + global cached_is_autoscaler_v2 + if cached_is_autoscaler_v2 is not None and not fetch_from_server: + return cached_is_autoscaler_v2 + + if gcs_client is None: + gcs_client = internal_kv_get_gcs_client() + + assert gcs_client, ( + "GCS client is not available. Please initialize the global GCS client " + "first by calling ray.init() or explicitly calls to _initialize_internal_kv()." + ) + + # See src/ray/common/constants.h for the definition of this key. + cached_is_autoscaler_v2 = ( + gcs_client.internal_kv_get( + ray._raylet.GCS_AUTOSCALER_V2_ENABLED_KEY.encode(), + namespace=ray._raylet.GCS_AUTOSCALER_STATE_NAMESPACE.encode(), + ) + == b"1" + ) + + return cached_is_autoscaler_v2 + + +def is_head_node(node_state: NodeState) -> bool: + """ + Check if the node is a head node from the node state. + + Args: + node_state: the node state + Returns: + is_head: True if the node is a head node, False otherwise. + """ + # TODO: we should include this bit of information in the future. + # NOTE: we could use labels in the future to determine if it's a head node. + return "node:__internal_head__" in dict(node_state.total_resources) diff --git a/lib/python3.12/site-packages/ray/core/__init__.py b/lib/python3.12/site-packages/ray/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/core/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21763a3a781794517862670b5c4c7754ff86f6a3 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f0c4c2ed4e64292e167cf126315b86248617514 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c34270723e1afc6edf3c867d07049de475ccc9d Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/autoscaler_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b05a5d1fe00c8495db34fe3240a154f42e83df9a Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ffb5ebe7a916599444bef480613f0286a12042e Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/common_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2846b7ab95dd4adb764f1f57980fa1f705880785 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9baff828b8b731d2864f6028958a44b1d33bb735 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/core_worker_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ceb804d35000dbfd8c760a9462fc5ae0ea77591f Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39ad5fd501beb5f7385fd8e3dad57e8edfa5b621 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/dependency_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7686cc430a9e72da6c067ecb0714a70fcd08bd68 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0cbc05f0bbd35fe902b059c0bd79abbda548305c Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6d96440ad963899d5fe93d1110ec43229fa8709 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b73d5e2f1b94de362fc04b4d9d51e6918d581dc4 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_definition_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..056c613e2acebd425b3d8516fcf1ed9185f0ac0e Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0cbdc5555637fad52b04a46ac358d5c63e84b7f0 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_lifecycle_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4da383bba64ca566aeb9bbb93293475109575456 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29f488fa5e1deb329a67584ee66c6c3bec678e13 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_actor_task_definition_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..027bef3963bf1ffcda400aa6dd7be9742a69ad48 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecbb7f819bcaf6b758a66c206b2e7750f39d5179 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_base_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ed87751775d96ddd4d9676e7fb2788ec7853f0df Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96af3fcd96660c9018ed27b1c11afffc5b6110a8 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_definition_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a0e17a40419680249baa1197b9416e2878bd10d Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24aa15a10ffb15a31dc0703ba14c9065df5f2fe5 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_driver_job_lifecycle_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af4d76e42e4594b8a27603d517e39b5acba5c29a Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5cfff5548d04779aceb4fde0f0eff6efe33928d Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_event_aggregator_service_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7b5c3263a3cfc8a770f457e3744ff6c304eaa4f Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b37db31ce8bb00ecd75d99b142025e38b25f28aa Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_definition_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..373999dbb91e3be35b5eab12d177aaaf90a40271 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c26e70794abfea8298627aa6a5bbea02f991d514 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_node_lifecycle_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..740e76e2c10a383998e3f8bef7b057d81eb1abf9 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4e14a636d2394e9a850c1eda6f53a6cae834756 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_definition_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6c7f3a429cb47d8ec17d06cf6a5e719269a5c9f Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..908d12b6ce80489986f6dc5ead19cb542c651e87 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_lifecycle_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cf273fba71b404941b28b25386ae8330889e947 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eac39575b63feea48a752f6ffb329078ad781473 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/events_task_profile_events_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e1b4270f9140c98447d373d26c7d4373c21bcce Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d24b3cc8f13443066d5e25813a931ccde70b64bc Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_actor_data_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1b6a54147e8382906cf24f0e91645ea9a12d58e Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3081350a16c225419bcbecd28c6fcdd63b272b73 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_metadata_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..655f645bddb346aeea4b8f8cca91b1c4fe70358f Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1edcfe00bfe4a1d1c363642d504110135d5eb5d Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_dataset_operator_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..845736230f27d04f3197810a4066731d77a4bb2a Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9739eeea1ce9e94dc49fa33a04c74621ba9e53e Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_driver_job_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..32e79a768cae503d06779bf0887c981a569e8c7c Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1fd8e35a2cb791b8ec45d6f07b88d96c40c871d7 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0557d262cc9347a012cf63b5730178f5ca5cdb6 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c703b1c8e91bad3bd89e6786a98d933d138cde62 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_node_data_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffae45dd4656b792d358cbeddbd9921409d5fc58 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ef3286ac2d53dda49d2930df793a19ed9522b58 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_runtime_env_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33af69faa60f83bd877b0bc802c847959ecb4b42 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e7bf67c119b0e4f8a511806bbce27a59d095de00 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_submission_job_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a750d94afed20c4e359115abf5f9a01ea7550d88 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ab2ca6f6b37c1bc689b082328b1e240a69d4a16 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_task_event_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad1b8b2458dcc99021aec78725e7e7b2d0ff4ce6 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6d2e5148a868fed2ecdb971a9558e749e0cb671 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/export_train_state_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40b084d27a2d393e42359e46ec120d99e62634a0 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4923563484a284f5a9c2961825a397fcf0415e0a Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b6d1c82c8b491c4b9e2b6528ca1282cb11cc873 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9db38173e8dd234bdf526e6d74960dbf40bcadcb Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/gcs_service_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ccfd00f6339953145dc67162c0e68926d48d2ee Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31e7e760a74f84916e6d507f4903a54f8aa448b3 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/instance_manager_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0698fd1140980cb87801ec0bba6fd3e26bbc4457 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c08022a59b7fce6e46bf75ced1dffb3f4a045cb4 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/logging_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb281b714416e040913c60d0157acd16eab2d3eb Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc33c4a47f9043bae95a3abf8dd76aa371a20a41 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/metrics_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..089b4cd574b2d85b874b81df83fb21eccfcb4f2d Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a5269c26a606adc911ed6978968c3cfbf4bfd0b Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/node_manager_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3445bc4d48975422d7f7d79c18a953d146baf970 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffbe56784fc880e7b252a29aa20d88fd7eefe62b Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/profile_events_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b5b881856bfc87d7915cae5fe0a701cf46e27b8 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55954442fd1328e5241b1368f5282d3323b5b36b Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/pubsub_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9c58668d9dcf4cd681c16794863deaafcb87a93 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e8efa9b62509d09ce2595b97d0981e51249e68c Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/ray_client_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..854a4ba418da91bb7d46c0616a66c49084abf197 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6105d16e21aa33f5a94499f06f3cd7bdaf5bfef4 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/reporter_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e62487a8d708925ee9cac7cc7b903e64d1c7572 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ef4febde29b6149efc0c47684f96b6932efb15e Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/resource_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11e802d291847a91b8547307ef19669b53513530 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a22bc048c7baa9b8366b6540c9d75ae411bf7e2 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_agent_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..139f7f2fa4f0954734eaa0ca198489446d2f8165 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55a46cc7a79756e05680994d9ddcbc169874fda1 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_env_common_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4e67130ee9303b47943a8d3695e83e9cd350218 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0a5c06deda822e8f324f09701328ef6f2ce5ff8 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/runtime_environment_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7555a177bd14b2ada05b72ada4c0229e235058e2 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2_grpc.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2_grpc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94ca72859f2f23e7c7ca58420dc231be414572b6 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/generated/__pycache__/usage_pb2_grpc.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2.py b/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..3463719ff3979c9db50ed4a93d922f12f4f3dd5f --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2.py @@ -0,0 +1,429 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/autoscaler.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!src/ray/protobuf/autoscaler.proto\x12\x12ray.rpc.autoscaler\x1a\x1dsrc/ray/protobuf/common.proto\"X\n\x16\x41ntiAffinityConstraint\x12\x1d\n\nlabel_name\x18\x01 \x01(\tR\tlabelName\x12\x1f\n\x0blabel_value\x18\x02 \x01(\tR\nlabelValue\"T\n\x12\x41\x66\x66inityConstraint\x12\x1d\n\nlabel_name\x18\x01 \x01(\tR\tlabelName\x12\x1f\n\x0blabel_value\x18\x02 \x01(\tR\nlabelValue\"\xd3\x01\n\x13PlacementConstraint\x12T\n\ranti_affinity\x18\x01 \x01(\x0b\x32*.ray.rpc.autoscaler.AntiAffinityConstraintH\x00R\x0c\x61ntiAffinity\x88\x01\x01\x12G\n\x08\x61\x66\x66inity\x18\x02 \x01(\x0b\x32&.ray.rpc.autoscaler.AffinityConstraintH\x01R\x08\x61\x66\x66inity\x88\x01\x01\x42\x10\n\x0e_anti_affinityB\x0b\n\t_affinity\"\xd9\x02\n\x0fResourceRequest\x12\x63\n\x10resources_bundle\x18\x01 \x03(\x0b\x32\x38.ray.rpc.autoscaler.ResourceRequest.ResourcesBundleEntryR\x0fresourcesBundle\x12\\\n\x15placement_constraints\x18\x02 \x03(\x0b\x32\'.ray.rpc.autoscaler.PlacementConstraintR\x14placementConstraints\x12?\n\x0flabel_selectors\x18\x03 \x03(\x0b\x32\x16.ray.rpc.LabelSelectorR\x0elabelSelectors\x1a\x42\n\x14ResourcesBundleEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"m\n\x16ResourceRequestByCount\x12=\n\x07request\x18\x01 \x01(\x0b\x32#.ray.rpc.autoscaler.ResourceRequestR\x07request\x12\x14\n\x05\x63ount\x18\x02 \x01(\x03R\x05\x63ount\"b\n\x0e\x42undleSelector\x12P\n\x11resource_requests\x18\x01 \x03(\x0b\x32#.ray.rpc.autoscaler.ResourceRequestR\x10resourceRequests\"\xbf\x01\n\x13GangResourceRequest\x12?\n\x08requests\x18\x01 \x03(\x0b\x32#.ray.rpc.autoscaler.ResourceRequestR\x08requests\x12\x18\n\x07\x64\x65tails\x18\x02 \x01(\tR\x07\x64\x65tails\x12M\n\x10\x62undle_selectors\x18\x03 \x03(\x0b\x32\".ray.rpc.autoscaler.BundleSelectorR\x0f\x62undleSelectors\"t\n\x19\x43lusterResourceConstraint\x12W\n\x11resource_requests\x18\x01 \x03(\x0b\x32*.ray.rpc.autoscaler.ResourceRequestByCountR\x10resourceRequests\"\xe4\x07\n\tNodeState\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x1f\n\x0binstance_id\x18\x02 \x01(\tR\ninstanceId\x12+\n\x12ray_node_type_name\x18\x03 \x01(\tR\x0frayNodeTypeName\x12\x66\n\x13\x61vailable_resources\x18\x04 \x03(\x0b\x32\x35.ray.rpc.autoscaler.NodeState.AvailableResourcesEntryR\x12\x61vailableResources\x12Z\n\x0ftotal_resources\x18\x05 \x03(\x0b\x32\x31.ray.rpc.autoscaler.NodeState.TotalResourcesEntryR\x0etotalResources\x12W\n\x0e\x64ynamic_labels\x18\x06 \x03(\x0b\x32\x30.ray.rpc.autoscaler.NodeState.DynamicLabelsEntryR\rdynamicLabels\x12,\n\x12node_state_version\x18\x07 \x01(\x03R\x10nodeStateVersion\x12\x36\n\x06status\x18\x08 \x01(\x0e\x32\x1e.ray.rpc.autoscaler.NodeStatusR\x06status\x12(\n\x10idle_duration_ms\x18\t \x01(\x03R\x0eidleDurationMs\x12&\n\x0fnode_ip_address\x18\n \x01(\tR\rnodeIpAddress\x12,\n\x12instance_type_name\x18\x0b \x01(\tR\x10instanceTypeName\x12#\n\rnode_activity\x18\x0c \x03(\tR\x0cnodeActivity\x12\x41\n\x06labels\x18\r \x03(\x0b\x32).ray.rpc.autoscaler.NodeState.LabelsEntryR\x06labels\x1a\x45\n\x17\x41vailableResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x41\n\x13TotalResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a@\n\x12\x44ynamicLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"w\n\x1eGetClusterResourceStateRequest\x12U\n(last_seen_cluster_resource_state_version\x18\x01 \x01(\x03R#lastSeenClusterResourceStateVersion\"\xe0\x04\n\x14\x43lusterResourceState\x12\x43\n\x1e\x63luster_resource_state_version\x18\x01 \x01(\x03R\x1b\x63lusterResourceStateVersion\x12J\n\"last_seen_autoscaler_state_version\x18\x02 \x01(\x03R\x1elastSeenAutoscalerStateVersion\x12>\n\x0bnode_states\x18\x03 \x03(\x0b\x32\x1d.ray.rpc.autoscaler.NodeStateR\nnodeStates\x12\x66\n\x19pending_resource_requests\x18\x04 \x03(\x0b\x32*.ray.rpc.autoscaler.ResourceRequestByCountR\x17pendingResourceRequests\x12l\n\x1epending_gang_resource_requests\x18\x05 \x03(\x0b\x32\'.ray.rpc.autoscaler.GangResourceRequestR\x1bpendingGangResourceRequests\x12o\n\x1c\x63luster_resource_constraints\x18\x06 \x03(\x0b\x32-.ray.rpc.autoscaler.ClusterResourceConstraintR\x1a\x63lusterResourceConstraints\x12\x30\n\x14\x63luster_session_name\x18\x07 \x01(\tR\x12\x63lusterSessionName\"~\n\x1cGetClusterResourceStateReply\x12^\n\x16\x63luster_resource_state\x18\x01 \x01(\x0b\x32(.ray.rpc.autoscaler.ClusterResourceStateR\x14\x63lusterResourceState\"\xa8\x01\n\x16PendingInstanceRequest\x12,\n\x12instance_type_name\x18\x01 \x01(\tR\x10instanceTypeName\x12+\n\x12ray_node_type_name\x18\x02 \x01(\tR\x0frayNodeTypeName\x12\x14\n\x05\x63ount\x18\x03 \x01(\x05R\x05\x63ount\x12\x1d\n\nrequest_ts\x18\x04 \x01(\x03R\trequestTs\"\xd8\x01\n\x15\x46\x61iledInstanceRequest\x12,\n\x12instance_type_name\x18\x01 \x01(\tR\x10instanceTypeName\x12+\n\x12ray_node_type_name\x18\x02 \x01(\tR\x0frayNodeTypeName\x12\x14\n\x05\x63ount\x18\x03 \x01(\x05R\x05\x63ount\x12\x16\n\x06reason\x18\x04 \x01(\tR\x06reason\x12\x19\n\x08start_ts\x18\x05 \x01(\x03R\x07startTs\x12\x1b\n\tfailed_ts\x18\x06 \x01(\x03R\x08\x66\x61iledTs\"\xc6\x01\n\x0fPendingInstance\x12,\n\x12instance_type_name\x18\x01 \x01(\tR\x10instanceTypeName\x12+\n\x12ray_node_type_name\x18\x02 \x01(\tR\x0frayNodeTypeName\x12\x1f\n\x0binstance_id\x18\x03 \x01(\tR\ninstanceId\x12\x1d\n\nip_address\x18\x04 \x01(\tR\tipAddress\x12\x18\n\x07\x64\x65tails\x18\x05 \x01(\tR\x07\x64\x65tails\"\xa4\x06\n\x10\x41utoscalingState\x12U\n(last_seen_cluster_resource_state_version\x18\x01 \x01(\x03R#lastSeenClusterResourceStateVersion\x12\x38\n\x18\x61utoscaler_state_version\x18\x02 \x01(\x03R\x16\x61utoscalerStateVersion\x12\x66\n\x19pending_instance_requests\x18\x03 \x03(\x0b\x32*.ray.rpc.autoscaler.PendingInstanceRequestR\x17pendingInstanceRequests\x12\x65\n\x1cinfeasible_resource_requests\x18\x04 \x03(\x0b\x32#.ray.rpc.autoscaler.ResourceRequestR\x1ainfeasibleResourceRequests\x12r\n!infeasible_gang_resource_requests\x18\x05 \x03(\x0b\x32\'.ray.rpc.autoscaler.GangResourceRequestR\x1einfeasibleGangResourceRequests\x12\x84\x01\n\'infeasible_cluster_resource_constraints\x18\x06 \x03(\x0b\x32-.ray.rpc.autoscaler.ClusterResourceConstraintR$infeasibleClusterResourceConstraints\x12P\n\x11pending_instances\x18\x07 \x03(\x0b\x32#.ray.rpc.autoscaler.PendingInstanceR\x10pendingInstances\x12\x63\n\x18\x66\x61iled_instance_requests\x18\x08 \x03(\x0b\x32).ray.rpc.autoscaler.FailedInstanceRequestR\x16\x66\x61iledInstanceRequests\"r\n\x1dReportAutoscalingStateRequest\x12Q\n\x11\x61utoscaling_state\x18\x01 \x01(\x0b\x32$.ray.rpc.autoscaler.AutoscalingStateR\x10\x61utoscalingState\"\x1d\n\x1bReportAutoscalingStateReply\"\x98\x01\n\'RequestClusterResourceConstraintRequest\x12m\n\x1b\x63luster_resource_constraint\x18\x01 \x01(\x0b\x32-.ray.rpc.autoscaler.ClusterResourceConstraintR\x19\x63lusterResourceConstraint\"\'\n%RequestClusterResourceConstraintReply\"\x19\n\x17GetClusterStatusRequest\"\xca\x01\n\x15GetClusterStatusReply\x12Q\n\x11\x61utoscaling_state\x18\x01 \x01(\x0b\x32$.ray.rpc.autoscaler.AutoscalingStateR\x10\x61utoscalingState\x12^\n\x16\x63luster_resource_state\x18\x02 \x01(\x0b\x32(.ray.rpc.autoscaler.ClusterResourceStateR\x14\x63lusterResourceState\"\xc3\x01\n\x10\x44rainNodeRequest\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12;\n\x06reason\x18\x02 \x01(\x0e\x32#.ray.rpc.autoscaler.DrainNodeReasonR\x06reason\x12%\n\x0ereason_message\x18\x03 \x01(\tR\rreasonMessage\x12\x32\n\x15\x64\x65\x61\x64line_timestamp_ms\x18\x04 \x01(\x03R\x13\x64\x65\x61\x64lineTimestampMs\"k\n\x0e\x44rainNodeReply\x12\x1f\n\x0bis_accepted\x18\x01 \x01(\x08R\nisAccepted\x12\x38\n\x18rejection_reason_message\x18\x02 \x01(\tR\x16rejectionReasonMessage\"\xef\x01\n\x0fNodeGroupConfig\x12P\n\tresources\x18\x01 \x03(\x0b\x32\x32.ray.rpc.autoscaler.NodeGroupConfig.ResourcesEntryR\tresources\x12\x1b\n\tmin_count\x18\x02 \x01(\rR\x08minCount\x12\x1b\n\tmax_count\x18\x03 \x01(\x05R\x08maxCount\x12\x12\n\x04name\x18\x04 \x01(\tR\x04name\x1a<\n\x0eResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x04R\x05value:\x02\x38\x01\"\x98\x03\n\rClusterConfig\x12X\n\rmin_resources\x18\x01 \x03(\x0b\x32\x33.ray.rpc.autoscaler.ClusterConfig.MinResourcesEntryR\x0cminResources\x12X\n\rmax_resources\x18\x02 \x03(\x0b\x32\x33.ray.rpc.autoscaler.ClusterConfig.MaxResourcesEntryR\x0cmaxResources\x12Q\n\x12node_group_configs\x18\x03 \x03(\x0b\x32#.ray.rpc.autoscaler.NodeGroupConfigR\x10nodeGroupConfigs\x1a?\n\x11MinResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x04R\x05value:\x02\x38\x01\x1a?\n\x11MaxResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x04R\x05value:\x02\x38\x01\"f\n\x1aReportClusterConfigRequest\x12H\n\x0e\x63luster_config\x18\x01 \x01(\x0b\x32!.ray.rpc.autoscaler.ClusterConfigR\rclusterConfig\"\x1a\n\x18ReportClusterConfigReply*L\n\nNodeStatus\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\x08\n\x04\x44\x45\x41\x44\x10\x02\x12\x08\n\x04IDLE\x10\x03\x12\x0c\n\x08\x44RAINING\x10\x04*~\n\x0f\x44rainNodeReason\x12!\n\x1d\x44RAIN_NODE_REASON_UNSPECIFIED\x10\x00\x12&\n\"DRAIN_NODE_REASON_IDLE_TERMINATION\x10\x01\x12 \n\x1c\x44RAIN_NODE_REASON_PREEMPTION\x10\x02\x32\xec\x05\n\x16\x41utoscalerStateService\x12\x7f\n\x17GetClusterResourceState\x12\x32.ray.rpc.autoscaler.GetClusterResourceStateRequest\x1a\x30.ray.rpc.autoscaler.GetClusterResourceStateReply\x12|\n\x16ReportAutoscalingState\x12\x31.ray.rpc.autoscaler.ReportAutoscalingStateRequest\x1a/.ray.rpc.autoscaler.ReportAutoscalingStateReply\x12s\n\x13ReportClusterConfig\x12..ray.rpc.autoscaler.ReportClusterConfigRequest\x1a,.ray.rpc.autoscaler.ReportClusterConfigReply\x12\x9a\x01\n RequestClusterResourceConstraint\x12;.ray.rpc.autoscaler.RequestClusterResourceConstraintRequest\x1a\x39.ray.rpc.autoscaler.RequestClusterResourceConstraintReply\x12j\n\x10GetClusterStatus\x12+.ray.rpc.autoscaler.GetClusterStatusRequest\x1a).ray.rpc.autoscaler.GetClusterStatusReply\x12U\n\tDrainNode\x12$.ray.rpc.autoscaler.DrainNodeRequest\x1a\".ray.rpc.autoscaler.DrainNodeReplyb\x06proto3') + +_NODESTATUS = DESCRIPTOR.enum_types_by_name['NodeStatus'] +NodeStatus = enum_type_wrapper.EnumTypeWrapper(_NODESTATUS) +_DRAINNODEREASON = DESCRIPTOR.enum_types_by_name['DrainNodeReason'] +DrainNodeReason = enum_type_wrapper.EnumTypeWrapper(_DRAINNODEREASON) +UNSPECIFIED = 0 +RUNNING = 1 +DEAD = 2 +IDLE = 3 +DRAINING = 4 +DRAIN_NODE_REASON_UNSPECIFIED = 0 +DRAIN_NODE_REASON_IDLE_TERMINATION = 1 +DRAIN_NODE_REASON_PREEMPTION = 2 + + +_ANTIAFFINITYCONSTRAINT = DESCRIPTOR.message_types_by_name['AntiAffinityConstraint'] +_AFFINITYCONSTRAINT = DESCRIPTOR.message_types_by_name['AffinityConstraint'] +_PLACEMENTCONSTRAINT = DESCRIPTOR.message_types_by_name['PlacementConstraint'] +_RESOURCEREQUEST = DESCRIPTOR.message_types_by_name['ResourceRequest'] +_RESOURCEREQUEST_RESOURCESBUNDLEENTRY = _RESOURCEREQUEST.nested_types_by_name['ResourcesBundleEntry'] +_RESOURCEREQUESTBYCOUNT = DESCRIPTOR.message_types_by_name['ResourceRequestByCount'] +_BUNDLESELECTOR = DESCRIPTOR.message_types_by_name['BundleSelector'] +_GANGRESOURCEREQUEST = DESCRIPTOR.message_types_by_name['GangResourceRequest'] +_CLUSTERRESOURCECONSTRAINT = DESCRIPTOR.message_types_by_name['ClusterResourceConstraint'] +_NODESTATE = DESCRIPTOR.message_types_by_name['NodeState'] +_NODESTATE_AVAILABLERESOURCESENTRY = _NODESTATE.nested_types_by_name['AvailableResourcesEntry'] +_NODESTATE_TOTALRESOURCESENTRY = _NODESTATE.nested_types_by_name['TotalResourcesEntry'] +_NODESTATE_DYNAMICLABELSENTRY = _NODESTATE.nested_types_by_name['DynamicLabelsEntry'] +_NODESTATE_LABELSENTRY = _NODESTATE.nested_types_by_name['LabelsEntry'] +_GETCLUSTERRESOURCESTATEREQUEST = DESCRIPTOR.message_types_by_name['GetClusterResourceStateRequest'] +_CLUSTERRESOURCESTATE = DESCRIPTOR.message_types_by_name['ClusterResourceState'] +_GETCLUSTERRESOURCESTATEREPLY = DESCRIPTOR.message_types_by_name['GetClusterResourceStateReply'] +_PENDINGINSTANCEREQUEST = DESCRIPTOR.message_types_by_name['PendingInstanceRequest'] +_FAILEDINSTANCEREQUEST = DESCRIPTOR.message_types_by_name['FailedInstanceRequest'] +_PENDINGINSTANCE = DESCRIPTOR.message_types_by_name['PendingInstance'] +_AUTOSCALINGSTATE = DESCRIPTOR.message_types_by_name['AutoscalingState'] +_REPORTAUTOSCALINGSTATEREQUEST = DESCRIPTOR.message_types_by_name['ReportAutoscalingStateRequest'] +_REPORTAUTOSCALINGSTATEREPLY = DESCRIPTOR.message_types_by_name['ReportAutoscalingStateReply'] +_REQUESTCLUSTERRESOURCECONSTRAINTREQUEST = DESCRIPTOR.message_types_by_name['RequestClusterResourceConstraintRequest'] +_REQUESTCLUSTERRESOURCECONSTRAINTREPLY = DESCRIPTOR.message_types_by_name['RequestClusterResourceConstraintReply'] +_GETCLUSTERSTATUSREQUEST = DESCRIPTOR.message_types_by_name['GetClusterStatusRequest'] +_GETCLUSTERSTATUSREPLY = DESCRIPTOR.message_types_by_name['GetClusterStatusReply'] +_DRAINNODEREQUEST = DESCRIPTOR.message_types_by_name['DrainNodeRequest'] +_DRAINNODEREPLY = DESCRIPTOR.message_types_by_name['DrainNodeReply'] +_NODEGROUPCONFIG = DESCRIPTOR.message_types_by_name['NodeGroupConfig'] +_NODEGROUPCONFIG_RESOURCESENTRY = _NODEGROUPCONFIG.nested_types_by_name['ResourcesEntry'] +_CLUSTERCONFIG = DESCRIPTOR.message_types_by_name['ClusterConfig'] +_CLUSTERCONFIG_MINRESOURCESENTRY = _CLUSTERCONFIG.nested_types_by_name['MinResourcesEntry'] +_CLUSTERCONFIG_MAXRESOURCESENTRY = _CLUSTERCONFIG.nested_types_by_name['MaxResourcesEntry'] +_REPORTCLUSTERCONFIGREQUEST = DESCRIPTOR.message_types_by_name['ReportClusterConfigRequest'] +_REPORTCLUSTERCONFIGREPLY = DESCRIPTOR.message_types_by_name['ReportClusterConfigReply'] +AntiAffinityConstraint = _reflection.GeneratedProtocolMessageType('AntiAffinityConstraint', (_message.Message,), { + 'DESCRIPTOR' : _ANTIAFFINITYCONSTRAINT, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.AntiAffinityConstraint) + }) +_sym_db.RegisterMessage(AntiAffinityConstraint) + +AffinityConstraint = _reflection.GeneratedProtocolMessageType('AffinityConstraint', (_message.Message,), { + 'DESCRIPTOR' : _AFFINITYCONSTRAINT, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.AffinityConstraint) + }) +_sym_db.RegisterMessage(AffinityConstraint) + +PlacementConstraint = _reflection.GeneratedProtocolMessageType('PlacementConstraint', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTCONSTRAINT, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.PlacementConstraint) + }) +_sym_db.RegisterMessage(PlacementConstraint) + +ResourceRequest = _reflection.GeneratedProtocolMessageType('ResourceRequest', (_message.Message,), { + + 'ResourcesBundleEntry' : _reflection.GeneratedProtocolMessageType('ResourcesBundleEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEREQUEST_RESOURCESBUNDLEENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ResourceRequest.ResourcesBundleEntry) + }) + , + 'DESCRIPTOR' : _RESOURCEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ResourceRequest) + }) +_sym_db.RegisterMessage(ResourceRequest) +_sym_db.RegisterMessage(ResourceRequest.ResourcesBundleEntry) + +ResourceRequestByCount = _reflection.GeneratedProtocolMessageType('ResourceRequestByCount', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEREQUESTBYCOUNT, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ResourceRequestByCount) + }) +_sym_db.RegisterMessage(ResourceRequestByCount) + +BundleSelector = _reflection.GeneratedProtocolMessageType('BundleSelector', (_message.Message,), { + 'DESCRIPTOR' : _BUNDLESELECTOR, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.BundleSelector) + }) +_sym_db.RegisterMessage(BundleSelector) + +GangResourceRequest = _reflection.GeneratedProtocolMessageType('GangResourceRequest', (_message.Message,), { + 'DESCRIPTOR' : _GANGRESOURCEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.GangResourceRequest) + }) +_sym_db.RegisterMessage(GangResourceRequest) + +ClusterResourceConstraint = _reflection.GeneratedProtocolMessageType('ClusterResourceConstraint', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERRESOURCECONSTRAINT, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ClusterResourceConstraint) + }) +_sym_db.RegisterMessage(ClusterResourceConstraint) + +NodeState = _reflection.GeneratedProtocolMessageType('NodeState', (_message.Message,), { + + 'AvailableResourcesEntry' : _reflection.GeneratedProtocolMessageType('AvailableResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODESTATE_AVAILABLERESOURCESENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeState.AvailableResourcesEntry) + }) + , + + 'TotalResourcesEntry' : _reflection.GeneratedProtocolMessageType('TotalResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODESTATE_TOTALRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeState.TotalResourcesEntry) + }) + , + + 'DynamicLabelsEntry' : _reflection.GeneratedProtocolMessageType('DynamicLabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODESTATE_DYNAMICLABELSENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeState.DynamicLabelsEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODESTATE_LABELSENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeState.LabelsEntry) + }) + , + 'DESCRIPTOR' : _NODESTATE, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeState) + }) +_sym_db.RegisterMessage(NodeState) +_sym_db.RegisterMessage(NodeState.AvailableResourcesEntry) +_sym_db.RegisterMessage(NodeState.TotalResourcesEntry) +_sym_db.RegisterMessage(NodeState.DynamicLabelsEntry) +_sym_db.RegisterMessage(NodeState.LabelsEntry) + +GetClusterResourceStateRequest = _reflection.GeneratedProtocolMessageType('GetClusterResourceStateRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERRESOURCESTATEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.GetClusterResourceStateRequest) + }) +_sym_db.RegisterMessage(GetClusterResourceStateRequest) + +ClusterResourceState = _reflection.GeneratedProtocolMessageType('ClusterResourceState', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERRESOURCESTATE, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ClusterResourceState) + }) +_sym_db.RegisterMessage(ClusterResourceState) + +GetClusterResourceStateReply = _reflection.GeneratedProtocolMessageType('GetClusterResourceStateReply', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERRESOURCESTATEREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.GetClusterResourceStateReply) + }) +_sym_db.RegisterMessage(GetClusterResourceStateReply) + +PendingInstanceRequest = _reflection.GeneratedProtocolMessageType('PendingInstanceRequest', (_message.Message,), { + 'DESCRIPTOR' : _PENDINGINSTANCEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.PendingInstanceRequest) + }) +_sym_db.RegisterMessage(PendingInstanceRequest) + +FailedInstanceRequest = _reflection.GeneratedProtocolMessageType('FailedInstanceRequest', (_message.Message,), { + 'DESCRIPTOR' : _FAILEDINSTANCEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.FailedInstanceRequest) + }) +_sym_db.RegisterMessage(FailedInstanceRequest) + +PendingInstance = _reflection.GeneratedProtocolMessageType('PendingInstance', (_message.Message,), { + 'DESCRIPTOR' : _PENDINGINSTANCE, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.PendingInstance) + }) +_sym_db.RegisterMessage(PendingInstance) + +AutoscalingState = _reflection.GeneratedProtocolMessageType('AutoscalingState', (_message.Message,), { + 'DESCRIPTOR' : _AUTOSCALINGSTATE, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.AutoscalingState) + }) +_sym_db.RegisterMessage(AutoscalingState) + +ReportAutoscalingStateRequest = _reflection.GeneratedProtocolMessageType('ReportAutoscalingStateRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTAUTOSCALINGSTATEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ReportAutoscalingStateRequest) + }) +_sym_db.RegisterMessage(ReportAutoscalingStateRequest) + +ReportAutoscalingStateReply = _reflection.GeneratedProtocolMessageType('ReportAutoscalingStateReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTAUTOSCALINGSTATEREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ReportAutoscalingStateReply) + }) +_sym_db.RegisterMessage(ReportAutoscalingStateReply) + +RequestClusterResourceConstraintRequest = _reflection.GeneratedProtocolMessageType('RequestClusterResourceConstraintRequest', (_message.Message,), { + 'DESCRIPTOR' : _REQUESTCLUSTERRESOURCECONSTRAINTREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.RequestClusterResourceConstraintRequest) + }) +_sym_db.RegisterMessage(RequestClusterResourceConstraintRequest) + +RequestClusterResourceConstraintReply = _reflection.GeneratedProtocolMessageType('RequestClusterResourceConstraintReply', (_message.Message,), { + 'DESCRIPTOR' : _REQUESTCLUSTERRESOURCECONSTRAINTREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.RequestClusterResourceConstraintReply) + }) +_sym_db.RegisterMessage(RequestClusterResourceConstraintReply) + +GetClusterStatusRequest = _reflection.GeneratedProtocolMessageType('GetClusterStatusRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERSTATUSREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.GetClusterStatusRequest) + }) +_sym_db.RegisterMessage(GetClusterStatusRequest) + +GetClusterStatusReply = _reflection.GeneratedProtocolMessageType('GetClusterStatusReply', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERSTATUSREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.GetClusterStatusReply) + }) +_sym_db.RegisterMessage(GetClusterStatusReply) + +DrainNodeRequest = _reflection.GeneratedProtocolMessageType('DrainNodeRequest', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODEREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.DrainNodeRequest) + }) +_sym_db.RegisterMessage(DrainNodeRequest) + +DrainNodeReply = _reflection.GeneratedProtocolMessageType('DrainNodeReply', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODEREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.DrainNodeReply) + }) +_sym_db.RegisterMessage(DrainNodeReply) + +NodeGroupConfig = _reflection.GeneratedProtocolMessageType('NodeGroupConfig', (_message.Message,), { + + 'ResourcesEntry' : _reflection.GeneratedProtocolMessageType('ResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODEGROUPCONFIG_RESOURCESENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeGroupConfig.ResourcesEntry) + }) + , + 'DESCRIPTOR' : _NODEGROUPCONFIG, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.NodeGroupConfig) + }) +_sym_db.RegisterMessage(NodeGroupConfig) +_sym_db.RegisterMessage(NodeGroupConfig.ResourcesEntry) + +ClusterConfig = _reflection.GeneratedProtocolMessageType('ClusterConfig', (_message.Message,), { + + 'MinResourcesEntry' : _reflection.GeneratedProtocolMessageType('MinResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERCONFIG_MINRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ClusterConfig.MinResourcesEntry) + }) + , + + 'MaxResourcesEntry' : _reflection.GeneratedProtocolMessageType('MaxResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERCONFIG_MAXRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ClusterConfig.MaxResourcesEntry) + }) + , + 'DESCRIPTOR' : _CLUSTERCONFIG, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ClusterConfig) + }) +_sym_db.RegisterMessage(ClusterConfig) +_sym_db.RegisterMessage(ClusterConfig.MinResourcesEntry) +_sym_db.RegisterMessage(ClusterConfig.MaxResourcesEntry) + +ReportClusterConfigRequest = _reflection.GeneratedProtocolMessageType('ReportClusterConfigRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTCLUSTERCONFIGREQUEST, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ReportClusterConfigRequest) + }) +_sym_db.RegisterMessage(ReportClusterConfigRequest) + +ReportClusterConfigReply = _reflection.GeneratedProtocolMessageType('ReportClusterConfigReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTCLUSTERCONFIGREPLY, + '__module__' : 'src.ray.protobuf.autoscaler_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.ReportClusterConfigReply) + }) +_sym_db.RegisterMessage(ReportClusterConfigReply) + +_AUTOSCALERSTATESERVICE = DESCRIPTOR.services_by_name['AutoscalerStateService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _RESOURCEREQUEST_RESOURCESBUNDLEENTRY._options = None + _RESOURCEREQUEST_RESOURCESBUNDLEENTRY._serialized_options = b'8\001' + _NODESTATE_AVAILABLERESOURCESENTRY._options = None + _NODESTATE_AVAILABLERESOURCESENTRY._serialized_options = b'8\001' + _NODESTATE_TOTALRESOURCESENTRY._options = None + _NODESTATE_TOTALRESOURCESENTRY._serialized_options = b'8\001' + _NODESTATE_DYNAMICLABELSENTRY._options = None + _NODESTATE_DYNAMICLABELSENTRY._serialized_options = b'8\001' + _NODESTATE_LABELSENTRY._options = None + _NODESTATE_LABELSENTRY._serialized_options = b'8\001' + _NODEGROUPCONFIG_RESOURCESENTRY._options = None + _NODEGROUPCONFIG_RESOURCESENTRY._serialized_options = b'8\001' + _CLUSTERCONFIG_MINRESOURCESENTRY._options = None + _CLUSTERCONFIG_MINRESOURCESENTRY._serialized_options = b'8\001' + _CLUSTERCONFIG_MAXRESOURCESENTRY._options = None + _CLUSTERCONFIG_MAXRESOURCESENTRY._serialized_options = b'8\001' + _NODESTATUS._serialized_start=6273 + _NODESTATUS._serialized_end=6349 + _DRAINNODEREASON._serialized_start=6351 + _DRAINNODEREASON._serialized_end=6477 + _ANTIAFFINITYCONSTRAINT._serialized_start=88 + _ANTIAFFINITYCONSTRAINT._serialized_end=176 + _AFFINITYCONSTRAINT._serialized_start=178 + _AFFINITYCONSTRAINT._serialized_end=262 + _PLACEMENTCONSTRAINT._serialized_start=265 + _PLACEMENTCONSTRAINT._serialized_end=476 + _RESOURCEREQUEST._serialized_start=479 + _RESOURCEREQUEST._serialized_end=824 + _RESOURCEREQUEST_RESOURCESBUNDLEENTRY._serialized_start=758 + _RESOURCEREQUEST_RESOURCESBUNDLEENTRY._serialized_end=824 + _RESOURCEREQUESTBYCOUNT._serialized_start=826 + _RESOURCEREQUESTBYCOUNT._serialized_end=935 + _BUNDLESELECTOR._serialized_start=937 + _BUNDLESELECTOR._serialized_end=1035 + _GANGRESOURCEREQUEST._serialized_start=1038 + _GANGRESOURCEREQUEST._serialized_end=1229 + _CLUSTERRESOURCECONSTRAINT._serialized_start=1231 + _CLUSTERRESOURCECONSTRAINT._serialized_end=1347 + _NODESTATE._serialized_start=1350 + _NODESTATE._serialized_end=2346 + _NODESTATE_AVAILABLERESOURCESENTRY._serialized_start=2085 + _NODESTATE_AVAILABLERESOURCESENTRY._serialized_end=2154 + _NODESTATE_TOTALRESOURCESENTRY._serialized_start=2156 + _NODESTATE_TOTALRESOURCESENTRY._serialized_end=2221 + _NODESTATE_DYNAMICLABELSENTRY._serialized_start=2223 + _NODESTATE_DYNAMICLABELSENTRY._serialized_end=2287 + _NODESTATE_LABELSENTRY._serialized_start=2289 + _NODESTATE_LABELSENTRY._serialized_end=2346 + _GETCLUSTERRESOURCESTATEREQUEST._serialized_start=2348 + _GETCLUSTERRESOURCESTATEREQUEST._serialized_end=2467 + _CLUSTERRESOURCESTATE._serialized_start=2470 + _CLUSTERRESOURCESTATE._serialized_end=3078 + _GETCLUSTERRESOURCESTATEREPLY._serialized_start=3080 + _GETCLUSTERRESOURCESTATEREPLY._serialized_end=3206 + _PENDINGINSTANCEREQUEST._serialized_start=3209 + _PENDINGINSTANCEREQUEST._serialized_end=3377 + _FAILEDINSTANCEREQUEST._serialized_start=3380 + _FAILEDINSTANCEREQUEST._serialized_end=3596 + _PENDINGINSTANCE._serialized_start=3599 + _PENDINGINSTANCE._serialized_end=3797 + _AUTOSCALINGSTATE._serialized_start=3800 + _AUTOSCALINGSTATE._serialized_end=4604 + _REPORTAUTOSCALINGSTATEREQUEST._serialized_start=4606 + _REPORTAUTOSCALINGSTATEREQUEST._serialized_end=4720 + _REPORTAUTOSCALINGSTATEREPLY._serialized_start=4722 + _REPORTAUTOSCALINGSTATEREPLY._serialized_end=4751 + _REQUESTCLUSTERRESOURCECONSTRAINTREQUEST._serialized_start=4754 + _REQUESTCLUSTERRESOURCECONSTRAINTREQUEST._serialized_end=4906 + _REQUESTCLUSTERRESOURCECONSTRAINTREPLY._serialized_start=4908 + _REQUESTCLUSTERRESOURCECONSTRAINTREPLY._serialized_end=4947 + _GETCLUSTERSTATUSREQUEST._serialized_start=4949 + _GETCLUSTERSTATUSREQUEST._serialized_end=4974 + _GETCLUSTERSTATUSREPLY._serialized_start=4977 + _GETCLUSTERSTATUSREPLY._serialized_end=5179 + _DRAINNODEREQUEST._serialized_start=5182 + _DRAINNODEREQUEST._serialized_end=5377 + _DRAINNODEREPLY._serialized_start=5379 + _DRAINNODEREPLY._serialized_end=5486 + _NODEGROUPCONFIG._serialized_start=5489 + _NODEGROUPCONFIG._serialized_end=5728 + _NODEGROUPCONFIG_RESOURCESENTRY._serialized_start=5668 + _NODEGROUPCONFIG_RESOURCESENTRY._serialized_end=5728 + _CLUSTERCONFIG._serialized_start=5731 + _CLUSTERCONFIG._serialized_end=6139 + _CLUSTERCONFIG_MINRESOURCESENTRY._serialized_start=6011 + _CLUSTERCONFIG_MINRESOURCESENTRY._serialized_end=6074 + _CLUSTERCONFIG_MAXRESOURCESENTRY._serialized_start=6076 + _CLUSTERCONFIG_MAXRESOURCESENTRY._serialized_end=6139 + _REPORTCLUSTERCONFIGREQUEST._serialized_start=6141 + _REPORTCLUSTERCONFIGREQUEST._serialized_end=6243 + _REPORTCLUSTERCONFIGREPLY._serialized_start=6245 + _REPORTCLUSTERCONFIGREPLY._serialized_end=6271 + _AUTOSCALERSTATESERVICE._serialized_start=6480 + _AUTOSCALERSTATESERVICE._serialized_end=7228 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..60e23a686d0a25825fe89c77dc882c82af056d34 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/autoscaler_pb2_grpc.py @@ -0,0 +1,231 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import autoscaler_pb2 as src_dot_ray_dot_protobuf_dot_autoscaler__pb2 + + +class AutoscalerStateServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetClusterResourceState = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterResourceState', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.FromString, + ) + self.ReportAutoscalingState = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/ReportAutoscalingState', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.FromString, + ) + self.ReportClusterConfig = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/ReportClusterConfig', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigReply.FromString, + ) + self.RequestClusterResourceConstraint = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/RequestClusterResourceConstraint', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.FromString, + ) + self.GetClusterStatus = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterStatus', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.FromString, + ) + self.DrainNode = channel.unary_unary( + '/ray.rpc.autoscaler.AutoscalerStateService/DrainNode', + request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.FromString, + ) + + +class AutoscalerStateServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetClusterResourceState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportAutoscalingState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportClusterConfig(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RequestClusterResourceConstraint(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetClusterStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DrainNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_AutoscalerStateServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetClusterResourceState': grpc.unary_unary_rpc_method_handler( + servicer.GetClusterResourceState, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.SerializeToString, + ), + 'ReportAutoscalingState': grpc.unary_unary_rpc_method_handler( + servicer.ReportAutoscalingState, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.SerializeToString, + ), + 'ReportClusterConfig': grpc.unary_unary_rpc_method_handler( + servicer.ReportClusterConfig, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigReply.SerializeToString, + ), + 'RequestClusterResourceConstraint': grpc.unary_unary_rpc_method_handler( + servicer.RequestClusterResourceConstraint, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.SerializeToString, + ), + 'GetClusterStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetClusterStatus, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.SerializeToString, + ), + 'DrainNode': grpc.unary_unary_rpc_method_handler( + servicer.DrainNode, + request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.autoscaler.AutoscalerStateService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class AutoscalerStateService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetClusterResourceState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterResourceState', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportAutoscalingState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/ReportAutoscalingState', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportClusterConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/ReportClusterConfig', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportClusterConfigReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RequestClusterResourceConstraint(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/RequestClusterResourceConstraint', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetClusterStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterStatus', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DrainNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/DrainNode', + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/common_pb2.py b/lib/python3.12/site-packages/ray/core/generated/common_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..2569670f71cd25ebfe08ce65136a8165d18a53c9 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/common_pb2.py @@ -0,0 +1,932 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/common.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import runtime_environment_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_runtime__environment__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dsrc/ray/protobuf/common.proto\x12\x07ray.rpc\x1a\x31src/ray/protobuf/public/runtime_environment.proto\"!\n\x07LabelIn\x12\x16\n\x06values\x18\x01 \x03(\tR\x06values\"$\n\nLabelNotIn\x12\x16\n\x06values\x18\x01 \x03(\tR\x06values\"\r\n\x0bLabelExists\"\x13\n\x11LabelDoesNotExist\"\x93\x02\n\rLabelOperator\x12-\n\x08label_in\x18\x01 \x01(\x0b\x32\x10.ray.rpc.LabelInH\x00R\x07labelIn\x12\x37\n\x0clabel_not_in\x18\x02 \x01(\x0b\x32\x13.ray.rpc.LabelNotInH\x00R\nlabelNotIn\x12\x39\n\x0clabel_exists\x18\x03 \x01(\x0b\x32\x14.ray.rpc.LabelExistsH\x00R\x0blabelExists\x12M\n\x14label_does_not_exist\x18\x04 \x01(\x0b\x32\x1a.ray.rpc.LabelDoesNotExistH\x00R\x11labelDoesNotExistB\x10\n\x0elabel_operator\"\\\n\x14LabelMatchExpression\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x32\n\x08operator\x18\x02 \x01(\x0b\x32\x16.ray.rpc.LabelOperatorR\x08operator\"X\n\x15LabelMatchExpressions\x12?\n\x0b\x65xpressions\x18\x01 \x03(\x0b\x32\x1d.ray.rpc.LabelMatchExpressionR\x0b\x65xpressions\"\x85\x01\n\x1bNodeLabelSchedulingStrategy\x12\x32\n\x04hard\x18\x01 \x01(\x0b\x32\x1e.ray.rpc.LabelMatchExpressionsR\x04hard\x12\x32\n\x04soft\x18\x02 \x01(\x0b\x32\x1e.ray.rpc.LabelMatchExpressionsR\x04soft\"\xaf\x01\n\x1eNodeAffinitySchedulingStrategy\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x12\n\x04soft\x18\x02 \x01(\x08R\x04soft\x12\x30\n\x14spill_on_unavailable\x18\x03 \x01(\x08R\x12spillOnUnavailable\x12.\n\x13\x66\x61il_on_unavailable\x18\x04 \x01(\x08R\x11\x66\x61ilOnUnavailable\"\xdf\x01\n PlacementGroupSchedulingStrategy\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\x12?\n\x1cplacement_group_bundle_index\x18\x02 \x01(\x03R\x19placementGroupBundleIndex\x12L\n#placement_group_capture_child_tasks\x18\x03 \x01(\x08R\x1fplacementGroupCaptureChildTasks\"\x1b\n\x19\x44\x65\x66\x61ultSchedulingStrategy\"\x1a\n\x18SpreadSchedulingStrategy\"\xd3\x04\n\x12SchedulingStrategy\x12\x64\n\x1b\x64\x65\x66\x61ult_scheduling_strategy\x18\x01 \x01(\x0b\x32\".ray.rpc.DefaultSchedulingStrategyH\x00R\x19\x64\x65\x66\x61ultSchedulingStrategy\x12z\n#placement_group_scheduling_strategy\x18\x02 \x01(\x0b\x32).ray.rpc.PlacementGroupSchedulingStrategyH\x00R placementGroupSchedulingStrategy\x12\x61\n\x1aspread_scheduling_strategy\x18\x03 \x01(\x0b\x32!.ray.rpc.SpreadSchedulingStrategyH\x00R\x18spreadSchedulingStrategy\x12t\n!node_affinity_scheduling_strategy\x18\x04 \x01(\x0b\x32\'.ray.rpc.NodeAffinitySchedulingStrategyH\x00R\x1enodeAffinitySchedulingStrategy\x12k\n\x1enode_label_scheduling_strategy\x18\x05 \x01(\x0b\x32$.ray.rpc.NodeLabelSchedulingStrategyH\x00R\x1bnodeLabelSchedulingStrategyB\x15\n\x13scheduling_strategy\"r\n\x07\x41\x64\x64ress\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x1d\n\nip_address\x18\x02 \x01(\tR\tipAddress\x12\x12\n\x04port\x18\x03 \x01(\x05R\x04port\x12\x1b\n\tworker_id\x18\x04 \x01(\x0cR\x08workerId\"z\n\x16JavaFunctionDescriptor\x12\x1d\n\nclass_name\x18\x01 \x01(\tR\tclassName\x12#\n\rfunction_name\x18\x02 \x01(\tR\x0c\x66unctionName\x12\x1c\n\tsignature\x18\x03 \x01(\tR\tsignature\"\xa4\x01\n\x18PythonFunctionDescriptor\x12\x1f\n\x0bmodule_name\x18\x01 \x01(\tR\nmoduleName\x12\x1d\n\nclass_name\x18\x02 \x01(\tR\tclassName\x12#\n\rfunction_name\x18\x03 \x01(\tR\x0c\x66unctionName\x12#\n\rfunction_hash\x18\x04 \x01(\tR\x0c\x66unctionHash\"s\n\x15\x43ppFunctionDescriptor\x12#\n\rfunction_name\x18\x01 \x01(\tR\x0c\x66unctionName\x12\x16\n\x06\x63\x61ller\x18\x02 \x01(\tR\x06\x63\x61ller\x12\x1d\n\nclass_name\x18\x03 \x01(\tR\tclassName\"\xc5\x02\n\x12\x46unctionDescriptor\x12[\n\x18java_function_descriptor\x18\x01 \x01(\x0b\x32\x1f.ray.rpc.JavaFunctionDescriptorH\x00R\x16javaFunctionDescriptor\x12\x61\n\x1apython_function_descriptor\x18\x02 \x01(\x0b\x32!.ray.rpc.PythonFunctionDescriptorH\x00R\x18pythonFunctionDescriptor\x12X\n\x17\x63pp_function_descriptor\x18\x03 \x01(\x0b\x32\x1e.ray.rpc.CppFunctionDescriptorH\x00R\x15\x63ppFunctionDescriptorB\x15\n\x13\x66unction_descriptor\"\x9f\x01\n\x10\x43oncurrencyGroup\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\'\n\x0fmax_concurrency\x18\x02 \x01(\x05R\x0emaxConcurrency\x12N\n\x14\x66unction_descriptors\x18\x03 \x03(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\x13\x66unctionDescriptors\"c\n\rUserErrorInfo\x12%\n\x0e\x65xception_name\x18\x01 \x01(\tR\rexceptionName\x12+\n\x11\x65xception_message\x18\x02 \x01(\tR\x10\x65xceptionMessage\"\xf9\x02\n\x0cRayErrorInfo\x12\x44\n\x10\x61\x63tor_died_error\x18\x02 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseH\x00R\x0e\x61\x63torDiedError\x12\x66\n\x1eruntime_env_setup_failed_error\x18\x03 \x01(\x0b\x32 .ray.rpc.RuntimeEnvFailedContextH\x00R\x1aruntimeEnvSetupFailedError\x12Z\n\x17\x61\x63tor_unavailable_error\x18\x04 \x01(\x0b\x32 .ray.rpc.ActorUnavailableContextH\x00R\x15\x61\x63torUnavailableError\x12#\n\rerror_message\x18\x05 \x01(\tR\x0c\x65rrorMessage\x12\x31\n\nerror_type\x18\x0b \x01(\x0e\x32\x12.ray.rpc.ErrorTypeR\terrorTypeB\x07\n\x05\x65rror\"\xb0\x02\n\x17OutOfMemoryErrorContext\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12\x1b\n\ttask_name\x18\x02 \x01(\tR\x08taskName\x12&\n\x0fnode_ip_address\x18\x03 \x01(\tR\rnodeIpAddress\x12*\n\x11memory_used_bytes\x18\x04 \x01(\x04R\x0fmemoryUsedBytes\x12,\n\x12memory_total_bytes\x18\x05 \x01(\x04R\x10memoryTotalBytes\x12\x32\n\x15memory_usage_fraction\x18\x06 \x01(\x01R\x13memoryUsageFraction\x12)\n\x10memory_threshold\x18\x07 \x01(\x01R\x0fmemoryThreshold\"W\n\x14NodeDiedErrorContext\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12&\n\x0fnode_ip_address\x18\x02 \x01(\tR\rnodeIpAddress\"\xae\x01\n\x0cRayException\x12-\n\x08language\x18\x01 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12\x31\n\x14serialized_exception\x18\x02 \x01(\x0cR\x13serializedException\x12<\n\x1a\x66ormatted_exception_string\x18\x03 \x01(\tR\x18\x66ormattedExceptionString\"\xfa\x01\n\rNodeDeathInfo\x12\x35\n\x06reason\x18\x01 \x01(\x0e\x32\x1d.ray.rpc.NodeDeathInfo.ReasonR\x06reason\x12%\n\x0ereason_message\x18\x02 \x01(\tR\rreasonMessage\"\x8a\x01\n\x06Reason\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x18\n\x14\x45XPECTED_TERMINATION\x10\x01\x12\x1a\n\x16UNEXPECTED_TERMINATION\x10\x02\x12\x1e\n\x1a\x41UTOSCALER_DRAIN_PREEMPTED\x10\x03\x12\x19\n\x15\x41UTOSCALER_DRAIN_IDLE\x10\x04\"\xd2\x03\n\x0f\x41\x63torDeathCause\x12Z\n\x1d\x63reation_task_failure_context\x18\x01 \x01(\x0b\x32\x15.ray.rpc.RayExceptionH\x00R\x1a\x63reationTaskFailureContext\x12_\n\x1aruntime_env_failed_context\x18\x02 \x01(\x0b\x32 .ray.rpc.RuntimeEnvFailedContextH\x00R\x17runtimeEnvFailedContext\x12Y\n\x18\x61\x63tor_died_error_context\x18\x03 \x01(\x0b\x32\x1e.ray.rpc.ActorDiedErrorContextH\x00R\x15\x61\x63torDiedErrorContext\x12\x64\n\x1b\x61\x63tor_unschedulable_context\x18\x04 \x01(\x0b\x32\".ray.rpc.ActorUnschedulableContextH\x00R\x19\x61\x63torUnschedulableContext\x12\x36\n\x0boom_context\x18\x05 \x01(\x0b\x32\x13.ray.rpc.OomContextH\x00R\noomContextB\t\n\x07\x63ontext\">\n\x17RuntimeEnvFailedContext\x12#\n\rerror_message\x18\x01 \x01(\tR\x0c\x65rrorMessage\"@\n\x19\x41\x63torUnschedulableContext\x12#\n\rerror_message\x18\x01 \x01(\tR\x0c\x65rrorMessage\"\xe7\x04\n\x15\x41\x63torDiedErrorContext\x12#\n\rerror_message\x18\x01 \x01(\tR\x0c\x65rrorMessage\x12\x19\n\x08owner_id\x18\x02 \x01(\x0cR\x07ownerId\x12(\n\x10owner_ip_address\x18\x03 \x01(\tR\x0eownerIpAddress\x12&\n\x0fnode_ip_address\x18\x04 \x01(\tR\rnodeIpAddress\x12\x10\n\x03pid\x18\x05 \x01(\rR\x03pid\x12\x12\n\x04name\x18\x06 \x01(\tR\x04name\x12#\n\rray_namespace\x18\x07 \x01(\tR\x0crayNamespace\x12\x1d\n\nclass_name\x18\x08 \x01(\tR\tclassName\x12\x19\n\x08\x61\x63tor_id\x18\t \x01(\x0cR\x07\x61\x63torId\x12#\n\rnever_started\x18\n \x01(\x08R\x0cneverStarted\x12\x43\n\x0fnode_death_info\x18\x0b \x01(\x0b\x32\x16.ray.rpc.NodeDeathInfoH\x00R\rnodeDeathInfo\x88\x01\x01\x12=\n\x06reason\x18\x0c \x01(\x0e\x32%.ray.rpc.ActorDiedErrorContext.ReasonR\x06reason\"z\n\x06Reason\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0f\n\x0bWORKER_DIED\x10\x01\x12\x0e\n\nOWNER_DIED\x10\x02\x12\r\n\tNODE_DIED\x10\x03\x12\x0c\n\x08RAY_KILL\x10\x04\x12\x10\n\x0cOUT_OF_SCOPE\x10\x05\x12\x0f\n\x0bREF_DELETED\x10\x06\x42\x12\n\x10_node_death_info\"\\\n\nOomContext\x12#\n\rerror_message\x18\x01 \x01(\tR\x0c\x65rrorMessage\x12)\n\x10\x66\x61il_immediately\x18\x02 \x01(\x08R\x0f\x66\x61ilImmediately\"F\n\x17\x41\x63torUnavailableContext\x12\x1e\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cH\x00R\x07\x61\x63torId\x88\x01\x01\x42\x0b\n\t_actor_id\"\xb0\x04\n\tJobConfig\x12\x1f\n\x0bjvm_options\x18\x02 \x03(\tR\njvmOptions\x12(\n\x10\x63ode_search_path\x18\x03 \x03(\tR\x0e\x63odeSearchPath\x12\x41\n\x10runtime_env_info\x18\x04 \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvInfoR\x0eruntimeEnvInfo\x12#\n\rray_namespace\x18\x05 \x01(\tR\x0crayNamespace\x12<\n\x08metadata\x18\x06 \x03(\x0b\x32 .ray.rpc.JobConfig.MetadataEntryR\x08metadata\x12V\n\x16\x64\x65\x66\x61ult_actor_lifetime\x18\x07 \x01(\x0e\x32 .ray.rpc.JobConfig.ActorLifetimeR\x14\x64\x65\x66\x61ultActorLifetime\x12+\n\x12py_driver_sys_path\x18\x08 \x03(\tR\x0fpyDriverSysPath\x12?\n\x1cserialized_py_logging_config\x18\t \x01(\x0cR\x19serializedPyLoggingConfig\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"/\n\rActorLifetime\x12\x0c\n\x08\x44\x45TACHED\x10\x00\x12\x10\n\x0cNON_DETACHED\x10\x01\"g\n\x1eStreamingGeneratorReturnIdInfo\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12(\n\x10is_plasma_object\x18\x02 \x01(\x08R\x0eisPlasmaObject\"\xd6\n\n\tLeaseSpec\x12\x19\n\x08lease_id\x18\x01 \x01(\x0cR\x07leaseId\x12\x15\n\x06job_id\x18\x02 \x01(\x0cR\x05jobId\x12\x37\n\x0e\x63\x61ller_address\x18\x03 \x01(\x0b\x32\x10.ray.rpc.AddressR\rcallerAddress\x12%\n\x04type\x18\x04 \x01(\x0e\x32\x11.ray.rpc.TaskTypeR\x04type\x12\x19\n\x08\x61\x63tor_id\x18\x05 \x01(\x0cR\x07\x61\x63torId\x12*\n\x11is_detached_actor\x18\x06 \x01(\x08R\x0fisDetachedActor\x12\x33\n\x16root_detached_actor_id\x18\x07 \x01(\x0cR\x13rootDetachedActorId\x12,\n\x12max_actor_restarts\x18\x08 \x01(\x03R\x10maxActorRestarts\x12X\n\x12required_resources\x18\t \x03(\x0b\x32).ray.rpc.LeaseSpec.RequiredResourcesEntryR\x11requiredResources\x12t\n\x1crequired_placement_resources\x18\n \x03(\x0b\x32\x32.ray.rpc.LeaseSpec.RequiredPlacementResourcesEntryR\x1arequiredPlacementResources\x12L\n\x13scheduling_strategy\x18\x0b \x01(\x0b\x32\x1b.ray.rpc.SchedulingStrategyR\x12schedulingStrategy\x12=\n\x0elabel_selector\x18\x0c \x01(\x0b\x32\x16.ray.rpc.LabelSelectorR\rlabelSelector\x12\x14\n\x05\x64\x65pth\x18\r \x01(\x03R\x05\x64\x65pth\x12\x41\n\x10runtime_env_info\x18\x0e \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvInfoR\x0eruntimeEnvInfo\x12<\n\x0c\x64\x65pendencies\x18\x0f \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x0c\x64\x65pendencies\x12$\n\x0eparent_task_id\x18\x10 \x01(\x0cR\x0cparentTaskId\x12-\n\x08language\x18\x11 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12L\n\x13\x66unction_descriptor\x18\x12 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\x12\x66unctionDescriptor\x12\x34\n\x16\x64ynamic_worker_options\x18\x13 \x03(\tR\x14\x64ynamicWorkerOptions\x12\x1f\n\x0bmax_retries\x18\x14 \x01(\x05R\nmaxRetries\x12%\n\x0e\x61ttempt_number\x18\x15 \x01(\x04R\rattemptNumber\x12\x1b\n\ttask_name\x18\x16 \x01(\tR\x08taskName\x12\x46\n\x11\x66\x61llback_strategy\x18\x17 \x01(\x0b\x32\x19.ray.rpc.FallbackStrategyR\x10\x66\x61llbackStrategy\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1aM\n\x1fRequiredPlacementResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\xb9\x13\n\x08TaskSpec\x12%\n\x04type\x18\x01 \x01(\x0e\x32\x11.ray.rpc.TaskTypeR\x04type\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12-\n\x08language\x18\x03 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12L\n\x13\x66unction_descriptor\x18\x04 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\x12\x66unctionDescriptor\x12\x15\n\x06job_id\x18\x05 \x01(\x0cR\x05jobId\x12\x17\n\x07task_id\x18\x06 \x01(\x0cR\x06taskId\x12$\n\x0eparent_task_id\x18\x07 \x01(\x0cR\x0cparentTaskId\x12%\n\x0eparent_counter\x18\x08 \x01(\x04R\rparentCounter\x12\x1b\n\tcaller_id\x18\t \x01(\x0cR\x08\x63\x61llerId\x12\x37\n\x0e\x63\x61ller_address\x18\n \x01(\x0b\x32\x10.ray.rpc.AddressR\rcallerAddress\x12$\n\x04\x61rgs\x18\x0b \x03(\x0b\x32\x10.ray.rpc.TaskArgR\x04\x61rgs\x12\x1f\n\x0bnum_returns\x18\x0c \x01(\x04R\nnumReturns\x12W\n\x12required_resources\x18\r \x03(\x0b\x32(.ray.rpc.TaskSpec.RequiredResourcesEntryR\x11requiredResources\x12s\n\x1crequired_placement_resources\x18\x0e \x03(\x0b\x32\x31.ray.rpc.TaskSpec.RequiredPlacementResourcesEntryR\x1arequiredPlacementResources\x12W\n\x18\x61\x63tor_creation_task_spec\x18\x0f \x01(\x0b\x32\x1e.ray.rpc.ActorCreationTaskSpecR\x15\x61\x63torCreationTaskSpec\x12>\n\x0f\x61\x63tor_task_spec\x18\x10 \x01(\x0b\x32\x16.ray.rpc.ActorTaskSpecR\ractorTaskSpec\x12\x1f\n\x0bmax_retries\x18\x11 \x01(\x05R\nmaxRetries\x12/\n\x13\x64\x65\x62ugger_breakpoint\x18\x16 \x01(\x0cR\x12\x64\x65\x62uggerBreakpoint\x12\x41\n\x10runtime_env_info\x18\x17 \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvInfoR\x0eruntimeEnvInfo\x12\x34\n\x16\x63oncurrency_group_name\x18\x18 \x01(\tR\x14\x63oncurrencyGroupName\x12)\n\x10retry_exceptions\x18\x19 \x01(\x08R\x0fretryExceptions\x12O\n$serialized_retry_exception_allowlist\x18\x1a \x01(\x0cR!serializedRetryExceptionAllowlist\x12\x14\n\x05\x64\x65pth\x18\x1b \x01(\x03R\x05\x64\x65pth\x12L\n\x13scheduling_strategy\x18\x1c \x01(\x0b\x32\x1b.ray.rpc.SchedulingStrategyR\x12schedulingStrategy\x12%\n\x0e\x61ttempt_number\x18\x1d \x01(\x05R\rattemptNumber\x12\'\n\x0freturns_dynamic\x18\x1e \x01(\x08R\x0ereturnsDynamic\x12,\n\x12\x64ynamic_return_ids\x18\x1f \x03(\x0cR\x10\x64ynamicReturnIds\x12\x36\n\njob_config\x18 \x01(\x0b\x32\x12.ray.rpc.JobConfigH\x00R\tjobConfig\x88\x01\x01\x12*\n\x11submitter_task_id\x18! \x01(\x0cR\x0fsubmitterTaskId\x12/\n\x13streaming_generator\x18\" \x01(\x08R\x12streamingGenerator\x12K\n\"dependency_resolution_timestamp_ms\x18# \x01(\x03R\x1f\x64\x65pendencyResolutionTimestampMs\x12\x37\n\x18lease_grant_timestamp_ms\x18$ \x01(\x03R\x15leaseGrantTimestampMs\x12J\n\x1fnum_streaming_generator_returns\x18% \x01(\x04H\x01R\x1cnumStreamingGeneratorReturns\x88\x01\x01\x12K\n\"generator_backpressure_num_objects\x18& \x01(\x03R\x1fgeneratorBackpressureNumObjects\x12,\n\x12\x65nable_task_events\x18\' \x01(\x08R\x10\x65nableTaskEvents\x12\x33\n\x16root_detached_actor_id\x18( \x01(\x0cR\x13rootDetachedActorId\x12\x35\n\x06labels\x18) \x03(\x0b\x32\x1d.ray.rpc.TaskSpec.LabelsEntryR\x06labels\x12 \n\tcall_site\x18* \x01(\tH\x02R\x08\x63\x61llSite\x88\x01\x01\x12=\n\x0elabel_selector\x18+ \x01(\x0b\x32\x16.ray.rpc.LabelSelectorR\rlabelSelector\x12\x43\n\x10tensor_transport\x18, \x01(\x0e\x32\x18.ray.rpc.TensorTransportR\x0ftensorTransport\x12\x46\n\x11\x66\x61llback_strategy\x18- \x01(\x0b\x32\x19.ray.rpc.FallbackStrategyR\x10\x66\x61llbackStrategy\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1aM\n\x1fRequiredPlacementResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\r\n\x0b_job_configB\"\n _num_streaming_generator_returnsB\x0c\n\n_call_site\"\x88\x07\n\rTaskInfoEntry\x12%\n\x04type\x18\x01 \x01(\x0e\x32\x11.ray.rpc.TaskTypeR\x04type\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12-\n\x08language\x18\x03 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12+\n\x12\x66unc_or_class_name\x18\x04 \x01(\tR\x0f\x66uncOrClassName\x12>\n\x10scheduling_state\x18\x05 \x01(\x0e\x32\x13.ray.rpc.TaskStatusR\x0fschedulingState\x12\x15\n\x06job_id\x18\x06 \x01(\x0cR\x05jobId\x12\x17\n\x07task_id\x18\x07 \x01(\x0cR\x06taskId\x12$\n\x0eparent_task_id\x18\x08 \x01(\x0cR\x0cparentTaskId\x12\\\n\x12required_resources\x18\r \x03(\x0b\x32-.ray.rpc.TaskInfoEntry.RequiredResourcesEntryR\x11requiredResources\x12\x41\n\x10runtime_env_info\x18\x17 \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvInfoR\x0eruntimeEnvInfo\x12\x1c\n\x07node_id\x18\x18 \x01(\x0cH\x00R\x06nodeId\x88\x01\x01\x12\x1e\n\x08\x61\x63tor_id\x18\x19 \x01(\x0cH\x01R\x07\x61\x63torId\x88\x01\x01\x12\x31\n\x12placement_group_id\x18\x1a \x01(\x0cH\x02R\x10placementGroupId\x88\x01\x01\x12 \n\tcall_site\x18\x1b \x01(\tH\x03R\x08\x63\x61llSite\x88\x01\x01\x12P\n\x0elabel_selector\x18\x1c \x03(\x0b\x32).ray.rpc.TaskInfoEntry.LabelSelectorEntryR\rlabelSelector\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\n\n\x08_node_idB\x0b\n\t_actor_idB\x15\n\x13_placement_group_idB\x0c\n\n_call_site\"M\n\x0bTaskAttempt\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12%\n\x0e\x61ttempt_number\x18\x02 \x01(\x05R\rattemptNumber\"\xdf\x03\n\x06\x42undle\x12=\n\tbundle_id\x18\x01 \x01(\x0b\x32 .ray.rpc.Bundle.BundleIdentifierR\x08\x62undleId\x12I\n\x0eunit_resources\x18\x02 \x03(\x0b\x32\".ray.rpc.Bundle.UnitResourcesEntryR\runitResources\x12\x17\n\x07node_id\x18\x03 \x01(\x0cR\x06nodeId\x12I\n\x0elabel_selector\x18\x04 \x03(\x0b\x32\".ray.rpc.Bundle.LabelSelectorEntryR\rlabelSelector\x1a\x63\n\x10\x42undleIdentifier\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\x12!\n\x0c\x62undle_index\x18\x02 \x01(\x05R\x0b\x62undleIndex\x1a@\n\x12UnitResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xb1\x03\n\x12PlacementGroupSpec\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12)\n\x07\x62undles\x18\x03 \x03(\x0b\x32\x0f.ray.rpc.BundleR\x07\x62undles\x12\x36\n\x08strategy\x18\x04 \x01(\x0e\x32\x1a.ray.rpc.PlacementStrategyR\x08strategy\x12$\n\x0e\x63reator_job_id\x18\x05 \x01(\x0cR\x0c\x63reatorJobId\x12(\n\x10\x63reator_actor_id\x18\x06 \x01(\x0cR\x0e\x63reatorActorId\x12(\n\x10\x63reator_job_dead\x18\x07 \x01(\x08R\x0e\x63reatorJobDead\x12,\n\x12\x63reator_actor_dead\x18\x08 \x01(\x08R\x10\x63reatorActorDead\x12\x1f\n\x0bis_detached\x18\t \x01(\x08R\nisDetached\x12-\n\x13soft_target_node_id\x18\x0b \x01(\x0cR\x10softTargetNodeId\"\xe1\x01\n\x0fObjectReference\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12\x35\n\rowner_address\x18\x02 \x01(\x0b\x32\x10.ray.rpc.AddressR\x0cownerAddress\x12\x1b\n\tcall_site\x18\x03 \x01(\tR\x08\x63\x61llSite\x12H\n\x10tensor_transport\x18\x04 \x01(\x0e\x32\x18.ray.rpc.TensorTransportH\x00R\x0ftensorTransport\x88\x01\x01\x42\x13\n\x11_tensor_transport\"\xbf\x02\n\x14ObjectReferenceCount\x12\x36\n\treference\x18\x01 \x01(\x0b\x32\x18.ray.rpc.ObjectReferenceR\treference\x12\"\n\rhas_local_ref\x18\x02 \x01(\x08R\x0bhasLocalRef\x12.\n\tborrowers\x18\x03 \x03(\x0b\x32\x10.ray.rpc.AddressR\tborrowers\x12\x44\n\x11stored_in_objects\x18\x04 \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x0fstoredInObjects\x12\x39\n\x19\x63ontained_in_borrowed_ids\x18\x05 \x03(\x0cR\x16\x63ontainedInBorrowedIds\x12\x1a\n\x08\x63ontains\x18\x06 \x03(\x0cR\x08\x63ontains\"\xba\x02\n\x07TaskArg\x12\x37\n\nobject_ref\x18\x01 \x01(\x0b\x32\x18.ray.rpc.ObjectReferenceR\tobjectRef\x12\x12\n\x04\x64\x61ta\x18\x02 \x01(\x0cR\x04\x64\x61ta\x12\x1a\n\x08metadata\x18\x03 \x01(\x0cR\x08metadata\x12H\n\x13nested_inlined_refs\x18\x04 \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x11nestedInlinedRefs\x12\x1d\n\nis_inlined\x18\x05 \x01(\x08R\tisInlined\x12H\n\x10tensor_transport\x18\x06 \x01(\x0e\x32\x18.ray.rpc.TensorTransportH\x00R\x0ftensorTransport\x88\x01\x01\x42\x13\n\x11_tensor_transport\"\xd6\x01\n\x0cReturnObject\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12\x1b\n\tin_plasma\x18\x02 \x01(\x08R\x08inPlasma\x12\x12\n\x04\x64\x61ta\x18\x03 \x01(\x0cR\x04\x64\x61ta\x12\x1a\n\x08metadata\x18\x04 \x01(\x0cR\x08metadata\x12H\n\x13nested_inlined_refs\x18\x05 \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x11nestedInlinedRefs\x12\x12\n\x04size\x18\x06 \x01(\x03R\x04size\"\xf7\x04\n\x15\x41\x63torCreationTaskSpec\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12,\n\x12max_actor_restarts\x18\x02 \x01(\x03R\x10maxActorRestarts\x12(\n\x10max_task_retries\x18\x03 \x01(\x03R\x0emaxTaskRetries\x12\x34\n\x16\x64ynamic_worker_options\x18\x04 \x03(\tR\x14\x64ynamicWorkerOptions\x12\'\n\x0fmax_concurrency\x18\x05 \x01(\x05R\x0emaxConcurrency\x12\x1f\n\x0bis_detached\x18\x06 \x01(\x08R\nisDetached\x12\x12\n\x04name\x18\x07 \x01(\tR\x04name\x12#\n\rray_namespace\x18\x08 \x01(\tR\x0crayNamespace\x12\x1d\n\nis_asyncio\x18\t \x01(\x08R\tisAsyncio\x12%\n\x0e\x65xtension_data\x18\n \x01(\tR\rextensionData\x12\x36\n\x17serialized_actor_handle\x18\x0b \x01(\x0cR\x15serializedActorHandle\x12H\n\x12\x63oncurrency_groups\x18\x0c \x03(\x0b\x32\x19.ray.rpc.ConcurrencyGroupR\x11\x63oncurrencyGroups\x12>\n\x1c\x61llow_out_of_order_execution\x18\r \x01(\x08R\x18\x61llowOutOfOrderExecution\x12*\n\x11max_pending_calls\x18\x0e \x01(\x05R\x0fmaxPendingCalls\"\x97\x01\n\rActorTaskSpec\x12\x19\n\x08\x61\x63tor_id\x18\x02 \x01(\x0cR\x07\x61\x63torId\x12\x42\n\x1e\x61\x63tor_creation_dummy_object_id\x18\x04 \x01(\x0cR\x1a\x61\x63torCreationDummyObjectId\x12\'\n\x0fsequence_number\x18\x05 \x01(\x04R\x0esequenceNumber\"6\n\x04Task\x12.\n\ttask_spec\x18\x01 \x01(\x0b\x32\x11.ray.rpc.TaskSpecR\x08taskSpec\">\n\nResourceId\x12\x14\n\x05index\x18\x01 \x01(\x03R\x05index\x12\x1a\n\x08quantity\x18\x02 \x01(\x01R\x08quantity\"^\n\x10ResourceMapEntry\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x36\n\x0cresource_ids\x18\x02 \x03(\x0b\x32\x13.ray.rpc.ResourceIdR\x0bresourceIds\"\xf4\x03\n\x08ViewData\x12\x1b\n\tview_name\x18\x01 \x01(\tR\x08viewName\x12\x35\n\x08measures\x18\x02 \x03(\x0b\x32\x19.ray.rpc.ViewData.MeasureR\x08measures\x1a\x93\x03\n\x07Measure\x12\x12\n\x04tags\x18\x01 \x01(\tR\x04tags\x12\x1b\n\tint_value\x18\x02 \x01(\x03R\x08intValue\x12!\n\x0c\x64ouble_value\x18\x03 \x01(\x01R\x0b\x64oubleValue\x12)\n\x10\x64istribution_min\x18\x04 \x01(\x01R\x0f\x64istributionMin\x12+\n\x11\x64istribution_mean\x18\x05 \x01(\x01R\x10\x64istributionMean\x12)\n\x10\x64istribution_max\x18\x06 \x01(\x01R\x0f\x64istributionMax\x12-\n\x12\x64istribution_count\x18\x07 \x01(\x01R\x11\x64istributionCount\x12\x44\n\x1e\x64istribution_bucket_boundaries\x18\x08 \x03(\x01R\x1c\x64istributionBucketBoundaries\x12<\n\x1a\x64istribution_bucket_counts\x18\t \x03(\x01R\x18\x64istributionBucketCounts\"\x80\x03\n\rObjectRefInfo\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12\x1b\n\tcall_site\x18\x02 \x01(\tR\x08\x63\x61llSite\x12\x1f\n\x0bobject_size\x18\x03 \x01(\x03R\nobjectSize\x12&\n\x0flocal_ref_count\x18\x04 \x01(\x03R\rlocalRefCount\x12\x37\n\x18submitted_task_ref_count\x18\x05 \x01(\x03R\x15submittedTaskRefCount\x12,\n\x12\x63ontained_in_owned\x18\x06 \x03(\x0cR\x10\x63ontainedInOwned\x12(\n\x10pinned_in_memory\x18\x07 \x01(\x08R\x0epinnedInMemory\x12\x34\n\x0btask_status\x18\x08 \x01(\x0e\x32\x13.ray.rpc.TaskStatusR\ntaskStatus\x12%\n\x0e\x61ttempt_number\x18\t \x01(\x04R\rattemptNumber\"\xab\x01\n\x13ResourceAllocations\x12P\n\x0eresource_slots\x18\x01 \x03(\x0b\x32).ray.rpc.ResourceAllocations.ResourceSlotR\rresourceSlots\x1a\x42\n\x0cResourceSlot\x12\x12\n\x04slot\x18\x01 \x01(\x03R\x04slot\x12\x1e\n\nallocation\x18\x02 \x01(\x01R\nallocation\"\x8d\n\n\x0f\x43oreWorkerStats\x12*\n\x11num_pending_tasks\x18\x01 \x01(\x05R\x0fnumPendingTasks\x12\x36\n\x18num_object_refs_in_scope\x18\x02 \x01(\x05R\x14numObjectRefsInScope\x12\x1d\n\nip_address\x18\x03 \x01(\tR\tipAddress\x12\x12\n\x04port\x18\x04 \x01(\x03R\x04port\x12\x19\n\x08\x61\x63tor_id\x18\x05 \x01(\x0cR\x07\x61\x63torId\x12R\n\x0eused_resources\x18\x06 \x03(\x0b\x32+.ray.rpc.CoreWorkerStats.UsedResourcesEntryR\rusedResources\x12O\n\rwebui_display\x18\x07 \x03(\x0b\x32*.ray.rpc.CoreWorkerStats.WebuiDisplayEntryR\x0cwebuiDisplay\x12\"\n\rnum_in_plasma\x18\x08 \x01(\x05R\x0bnumInPlasma\x12*\n\x11num_local_objects\x18\t \x01(\x05R\x0fnumLocalObjects\x12\x37\n\x18used_object_store_memory\x18\n \x01(\x03R\x15usedObjectStoreMemory\x12*\n\x11task_queue_length\x18\x0b \x01(\x05R\x0ftaskQueueLength\x12,\n\x12num_executed_tasks\x18\x0c \x01(\x05R\x10numExecutedTasks\x12\x37\n\x0bobject_refs\x18\r \x03(\x0b\x32\x16.ray.rpc.ObjectRefInfoR\nobjectRefs\x12\x15\n\x06job_id\x18\x0e \x01(\x0cR\x05jobId\x12\x1b\n\tworker_id\x18\x0f \x01(\x0cR\x08workerId\x12-\n\x08language\x18\x10 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12\x10\n\x03pid\x18\x11 \x01(\rR\x03pid\x12\x34\n\x0bworker_type\x18\x12 \x01(\x0e\x32\x13.ray.rpc.WorkerTypeR\nworkerType\x12#\n\robjects_total\x18\x13 \x01(\x03R\x0cobjectsTotal\x12*\n\x11num_owned_objects\x18\x14 \x01(\x03R\x0fnumOwnedObjects\x12(\n\x10num_owned_actors\x18\x15 \x01(\x03R\x0enumOwnedActors\x12*\n\x11num_running_tasks\x18\x16 \x01(\x03R\x0fnumRunningTasks\x12I\n\"num_in_flight_arg_pinning_requests\x18\x17 \x01(\x03R\x1dnumInFlightArgPinningRequests\x12I\n\"num_of_failed_arg_pinning_requests\x18\x18 \x01(\x03R\x1dnumOfFailedArgPinningRequests\x1a^\n\x12UsedResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.ray.rpc.ResourceAllocationsR\x05value:\x02\x38\x01\x1a?\n\x11WebuiDisplayEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\'\n\x11NodeResourceUsage\x12\x12\n\x04json\x18\x01 \x01(\tR\x04json\"\x95\x01\n\x17LabelSelectorConstraint\x12\x1b\n\tlabel_key\x18\x01 \x01(\tR\x08labelKey\x12:\n\x08operator\x18\x02 \x01(\x0e\x32\x1e.ray.rpc.LabelSelectorOperatorR\x08operator\x12!\n\x0clabel_values\x18\x03 \x03(\tR\x0blabelValues\"^\n\rLabelSelector\x12M\n\x11label_constraints\x18\x01 \x03(\x0b\x32 .ray.rpc.LabelSelectorConstraintR\x10labelConstraints\"O\n\x0e\x46\x61llbackOption\x12=\n\x0elabel_selector\x18\x01 \x01(\x0b\x32\x16.ray.rpc.LabelSelectorR\rlabelSelector\"E\n\x10\x46\x61llbackStrategy\x12\x31\n\x07options\x18\x01 \x03(\x0b\x32\x17.ray.rpc.FallbackOptionR\x07options\"I\n\x0eNamedActorInfo\x12#\n\rray_namespace\x18\x01 \x01(\tR\x0crayNamespace\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\xdf\x01\n\x19LineageReconstructionTask\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12+\n\x06status\x18\x02 \x01(\x0e\x32\x13.ray.rpc.TaskStatusR\x06status\x12\x46\n\x06labels\x18\x03 \x03(\x0b\x32..ray.rpc.LineageReconstructionTask.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01*)\n\x08Language\x12\n\n\x06PYTHON\x10\x00\x12\x08\n\x04JAVA\x10\x01\x12\x07\n\x03\x43PP\x10\x02*J\n\nWorkerType\x12\n\n\x06WORKER\x10\x00\x12\n\n\x06\x44RIVER\x10\x01\x12\x10\n\x0cSPILL_WORKER\x10\x02\x12\x12\n\x0eRESTORE_WORKER\x10\x03*U\n\x08TaskType\x12\x0f\n\x0bNORMAL_TASK\x10\x00\x12\x17\n\x13\x41\x43TOR_CREATION_TASK\x10\x01\x12\x0e\n\nACTOR_TASK\x10\x02\x12\x0f\n\x0b\x44RIVER_TASK\x10\x03*\xf0\x05\n\tErrorType\x12\x0f\n\x0bWORKER_DIED\x10\x00\x12\x0e\n\nACTOR_DIED\x10\x01\x12\x1c\n\x18OBJECT_UNRECONSTRUCTABLE\x10\x02\x12\x1c\n\x18TASK_EXECUTION_EXCEPTION\x10\x03\x12\x14\n\x10OBJECT_IN_PLASMA\x10\x04\x12\x12\n\x0eTASK_CANCELLED\x10\x05\x12\x19\n\x15\x41\x43TOR_CREATION_FAILED\x10\x06\x12\x1c\n\x18RUNTIME_ENV_SETUP_FAILED\x10\x07\x12\x0f\n\x0bOBJECT_LOST\x10\x08\x12\x0e\n\nOWNER_DIED\x10\t\x12\x12\n\x0eOBJECT_DELETED\x10\n\x12 \n\x1c\x44\x45PENDENCY_RESOLUTION_FAILED\x10\x0b\x12\x32\n.OBJECT_UNRECONSTRUCTABLE_MAX_ATTEMPTS_EXCEEDED\x10\x0c\x12,\n(OBJECT_UNRECONSTRUCTABLE_LINEAGE_EVICTED\x10\r\x12\x1a\n\x16OBJECT_FETCH_TIMED_OUT\x10\x0e\x12\x15\n\x11LOCAL_RAYLET_DIED\x10\x0f\x12 \n\x1cTASK_PLACEMENT_GROUP_REMOVED\x10\x10\x12!\n\x1d\x41\x43TOR_PLACEMENT_GROUP_REMOVED\x10\x11\x12\x1c\n\x18TASK_UNSCHEDULABLE_ERROR\x10\x12\x12\x1d\n\x19\x41\x43TOR_UNSCHEDULABLE_ERROR\x10\x13\x12\x15\n\x11OUT_OF_DISK_ERROR\x10\x14\x12\x10\n\x0cOBJECT_FREED\x10\x15\x12\x11\n\rOUT_OF_MEMORY\x10\x16\x12\r\n\tNODE_DIED\x10\x17\x12\x1e\n\x1a\x45ND_OF_STREAMING_GENERATOR\x10\x18\x12\x15\n\x11\x41\x43TOR_UNAVAILABLE\x10\x19\x12\x33\n/GENERATOR_TASK_FAILED_FOR_OBJECT_RECONSTRUCTION\x10\x1a*A\n\x0fTensorTransport\x12\x10\n\x0cOBJECT_STORE\x10\x00\x12\x08\n\x04NCCL\x10\x01\x12\x08\n\x04GLOO\x10\x02\x12\x08\n\x04NIXL\x10\x03*\xe5\x02\n\nTaskStatus\x12\x07\n\x03NIL\x10\x00\x12\x16\n\x12PENDING_ARGS_AVAIL\x10\x01\x12\x1b\n\x17PENDING_NODE_ASSIGNMENT\x10\x02\x12\x1f\n\x1bPENDING_OBJ_STORE_MEM_AVAIL\x10\x03\x12\x16\n\x12PENDING_ARGS_FETCH\x10\x04\x12\x17\n\x13SUBMITTED_TO_WORKER\x10\x05\x12!\n\x1dPENDING_ACTOR_TASK_ARGS_FETCH\x10\x06\x12.\n*PENDING_ACTOR_TASK_ORDERING_OR_CONCURRENCY\x10\x07\x12\x0b\n\x07RUNNING\x10\x08\x12\x16\n\x12RUNNING_IN_RAY_GET\x10\t\x12\x17\n\x13RUNNING_IN_RAY_WAIT\x10\n\x12\x0c\n\x08\x46INISHED\x10\x0b\x12\n\n\x06\x46\x41ILED\x10\x0c\x12\x1c\n\x18GETTING_AND_PINNING_ARGS\x10\r*|\n\x0eWorkerExitType\x12\x10\n\x0cSYSTEM_ERROR\x10\x00\x12\x18\n\x14INTENDED_SYSTEM_EXIT\x10\x01\x12\x0e\n\nUSER_ERROR\x10\x02\x12\x16\n\x12INTENDED_USER_EXIT\x10\x03\x12\x16\n\x12NODE_OUT_OF_MEMORY\x10\x04*M\n\x11PlacementStrategy\x12\x08\n\x04PACK\x10\x00\x12\n\n\x06SPREAD\x10\x01\x12\x0f\n\x0bSTRICT_PACK\x10\x02\x12\x11\n\rSTRICT_SPREAD\x10\x03*i\n\x15LabelSelectorOperator\x12\x1e\n\x1aLABEL_OPERATOR_UNSPECIFIED\x10\x00\x12\x15\n\x11LABEL_OPERATOR_IN\x10\x01\x12\x19\n\x15LABEL_OPERATOR_NOT_IN\x10\x02\x42\x1a\n\x18io.ray.runtime.generatedb\x06proto3') + +_LANGUAGE = DESCRIPTOR.enum_types_by_name['Language'] +Language = enum_type_wrapper.EnumTypeWrapper(_LANGUAGE) +_WORKERTYPE = DESCRIPTOR.enum_types_by_name['WorkerType'] +WorkerType = enum_type_wrapper.EnumTypeWrapper(_WORKERTYPE) +_TASKTYPE = DESCRIPTOR.enum_types_by_name['TaskType'] +TaskType = enum_type_wrapper.EnumTypeWrapper(_TASKTYPE) +_ERRORTYPE = DESCRIPTOR.enum_types_by_name['ErrorType'] +ErrorType = enum_type_wrapper.EnumTypeWrapper(_ERRORTYPE) +_TENSORTRANSPORT = DESCRIPTOR.enum_types_by_name['TensorTransport'] +TensorTransport = enum_type_wrapper.EnumTypeWrapper(_TENSORTRANSPORT) +_TASKSTATUS = DESCRIPTOR.enum_types_by_name['TaskStatus'] +TaskStatus = enum_type_wrapper.EnumTypeWrapper(_TASKSTATUS) +_WORKEREXITTYPE = DESCRIPTOR.enum_types_by_name['WorkerExitType'] +WorkerExitType = enum_type_wrapper.EnumTypeWrapper(_WORKEREXITTYPE) +_PLACEMENTSTRATEGY = DESCRIPTOR.enum_types_by_name['PlacementStrategy'] +PlacementStrategy = enum_type_wrapper.EnumTypeWrapper(_PLACEMENTSTRATEGY) +_LABELSELECTOROPERATOR = DESCRIPTOR.enum_types_by_name['LabelSelectorOperator'] +LabelSelectorOperator = enum_type_wrapper.EnumTypeWrapper(_LABELSELECTOROPERATOR) +PYTHON = 0 +JAVA = 1 +CPP = 2 +WORKER = 0 +DRIVER = 1 +SPILL_WORKER = 2 +RESTORE_WORKER = 3 +NORMAL_TASK = 0 +ACTOR_CREATION_TASK = 1 +ACTOR_TASK = 2 +DRIVER_TASK = 3 +WORKER_DIED = 0 +ACTOR_DIED = 1 +OBJECT_UNRECONSTRUCTABLE = 2 +TASK_EXECUTION_EXCEPTION = 3 +OBJECT_IN_PLASMA = 4 +TASK_CANCELLED = 5 +ACTOR_CREATION_FAILED = 6 +RUNTIME_ENV_SETUP_FAILED = 7 +OBJECT_LOST = 8 +OWNER_DIED = 9 +OBJECT_DELETED = 10 +DEPENDENCY_RESOLUTION_FAILED = 11 +OBJECT_UNRECONSTRUCTABLE_MAX_ATTEMPTS_EXCEEDED = 12 +OBJECT_UNRECONSTRUCTABLE_LINEAGE_EVICTED = 13 +OBJECT_FETCH_TIMED_OUT = 14 +LOCAL_RAYLET_DIED = 15 +TASK_PLACEMENT_GROUP_REMOVED = 16 +ACTOR_PLACEMENT_GROUP_REMOVED = 17 +TASK_UNSCHEDULABLE_ERROR = 18 +ACTOR_UNSCHEDULABLE_ERROR = 19 +OUT_OF_DISK_ERROR = 20 +OBJECT_FREED = 21 +OUT_OF_MEMORY = 22 +NODE_DIED = 23 +END_OF_STREAMING_GENERATOR = 24 +ACTOR_UNAVAILABLE = 25 +GENERATOR_TASK_FAILED_FOR_OBJECT_RECONSTRUCTION = 26 +OBJECT_STORE = 0 +NCCL = 1 +GLOO = 2 +NIXL = 3 +NIL = 0 +PENDING_ARGS_AVAIL = 1 +PENDING_NODE_ASSIGNMENT = 2 +PENDING_OBJ_STORE_MEM_AVAIL = 3 +PENDING_ARGS_FETCH = 4 +SUBMITTED_TO_WORKER = 5 +PENDING_ACTOR_TASK_ARGS_FETCH = 6 +PENDING_ACTOR_TASK_ORDERING_OR_CONCURRENCY = 7 +RUNNING = 8 +RUNNING_IN_RAY_GET = 9 +RUNNING_IN_RAY_WAIT = 10 +FINISHED = 11 +FAILED = 12 +GETTING_AND_PINNING_ARGS = 13 +SYSTEM_ERROR = 0 +INTENDED_SYSTEM_EXIT = 1 +USER_ERROR = 2 +INTENDED_USER_EXIT = 3 +NODE_OUT_OF_MEMORY = 4 +PACK = 0 +SPREAD = 1 +STRICT_PACK = 2 +STRICT_SPREAD = 3 +LABEL_OPERATOR_UNSPECIFIED = 0 +LABEL_OPERATOR_IN = 1 +LABEL_OPERATOR_NOT_IN = 2 + + +_LABELIN = DESCRIPTOR.message_types_by_name['LabelIn'] +_LABELNOTIN = DESCRIPTOR.message_types_by_name['LabelNotIn'] +_LABELEXISTS = DESCRIPTOR.message_types_by_name['LabelExists'] +_LABELDOESNOTEXIST = DESCRIPTOR.message_types_by_name['LabelDoesNotExist'] +_LABELOPERATOR = DESCRIPTOR.message_types_by_name['LabelOperator'] +_LABELMATCHEXPRESSION = DESCRIPTOR.message_types_by_name['LabelMatchExpression'] +_LABELMATCHEXPRESSIONS = DESCRIPTOR.message_types_by_name['LabelMatchExpressions'] +_NODELABELSCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['NodeLabelSchedulingStrategy'] +_NODEAFFINITYSCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['NodeAffinitySchedulingStrategy'] +_PLACEMENTGROUPSCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['PlacementGroupSchedulingStrategy'] +_DEFAULTSCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['DefaultSchedulingStrategy'] +_SPREADSCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['SpreadSchedulingStrategy'] +_SCHEDULINGSTRATEGY = DESCRIPTOR.message_types_by_name['SchedulingStrategy'] +_ADDRESS = DESCRIPTOR.message_types_by_name['Address'] +_JAVAFUNCTIONDESCRIPTOR = DESCRIPTOR.message_types_by_name['JavaFunctionDescriptor'] +_PYTHONFUNCTIONDESCRIPTOR = DESCRIPTOR.message_types_by_name['PythonFunctionDescriptor'] +_CPPFUNCTIONDESCRIPTOR = DESCRIPTOR.message_types_by_name['CppFunctionDescriptor'] +_FUNCTIONDESCRIPTOR = DESCRIPTOR.message_types_by_name['FunctionDescriptor'] +_CONCURRENCYGROUP = DESCRIPTOR.message_types_by_name['ConcurrencyGroup'] +_USERERRORINFO = DESCRIPTOR.message_types_by_name['UserErrorInfo'] +_RAYERRORINFO = DESCRIPTOR.message_types_by_name['RayErrorInfo'] +_OUTOFMEMORYERRORCONTEXT = DESCRIPTOR.message_types_by_name['OutOfMemoryErrorContext'] +_NODEDIEDERRORCONTEXT = DESCRIPTOR.message_types_by_name['NodeDiedErrorContext'] +_RAYEXCEPTION = DESCRIPTOR.message_types_by_name['RayException'] +_NODEDEATHINFO = DESCRIPTOR.message_types_by_name['NodeDeathInfo'] +_ACTORDEATHCAUSE = DESCRIPTOR.message_types_by_name['ActorDeathCause'] +_RUNTIMEENVFAILEDCONTEXT = DESCRIPTOR.message_types_by_name['RuntimeEnvFailedContext'] +_ACTORUNSCHEDULABLECONTEXT = DESCRIPTOR.message_types_by_name['ActorUnschedulableContext'] +_ACTORDIEDERRORCONTEXT = DESCRIPTOR.message_types_by_name['ActorDiedErrorContext'] +_OOMCONTEXT = DESCRIPTOR.message_types_by_name['OomContext'] +_ACTORUNAVAILABLECONTEXT = DESCRIPTOR.message_types_by_name['ActorUnavailableContext'] +_JOBCONFIG = DESCRIPTOR.message_types_by_name['JobConfig'] +_JOBCONFIG_METADATAENTRY = _JOBCONFIG.nested_types_by_name['MetadataEntry'] +_STREAMINGGENERATORRETURNIDINFO = DESCRIPTOR.message_types_by_name['StreamingGeneratorReturnIdInfo'] +_LEASESPEC = DESCRIPTOR.message_types_by_name['LeaseSpec'] +_LEASESPEC_REQUIREDRESOURCESENTRY = _LEASESPEC.nested_types_by_name['RequiredResourcesEntry'] +_LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY = _LEASESPEC.nested_types_by_name['RequiredPlacementResourcesEntry'] +_TASKSPEC = DESCRIPTOR.message_types_by_name['TaskSpec'] +_TASKSPEC_REQUIREDRESOURCESENTRY = _TASKSPEC.nested_types_by_name['RequiredResourcesEntry'] +_TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY = _TASKSPEC.nested_types_by_name['RequiredPlacementResourcesEntry'] +_TASKSPEC_LABELSENTRY = _TASKSPEC.nested_types_by_name['LabelsEntry'] +_TASKINFOENTRY = DESCRIPTOR.message_types_by_name['TaskInfoEntry'] +_TASKINFOENTRY_REQUIREDRESOURCESENTRY = _TASKINFOENTRY.nested_types_by_name['RequiredResourcesEntry'] +_TASKINFOENTRY_LABELSELECTORENTRY = _TASKINFOENTRY.nested_types_by_name['LabelSelectorEntry'] +_TASKATTEMPT = DESCRIPTOR.message_types_by_name['TaskAttempt'] +_BUNDLE = DESCRIPTOR.message_types_by_name['Bundle'] +_BUNDLE_BUNDLEIDENTIFIER = _BUNDLE.nested_types_by_name['BundleIdentifier'] +_BUNDLE_UNITRESOURCESENTRY = _BUNDLE.nested_types_by_name['UnitResourcesEntry'] +_BUNDLE_LABELSELECTORENTRY = _BUNDLE.nested_types_by_name['LabelSelectorEntry'] +_PLACEMENTGROUPSPEC = DESCRIPTOR.message_types_by_name['PlacementGroupSpec'] +_OBJECTREFERENCE = DESCRIPTOR.message_types_by_name['ObjectReference'] +_OBJECTREFERENCECOUNT = DESCRIPTOR.message_types_by_name['ObjectReferenceCount'] +_TASKARG = DESCRIPTOR.message_types_by_name['TaskArg'] +_RETURNOBJECT = DESCRIPTOR.message_types_by_name['ReturnObject'] +_ACTORCREATIONTASKSPEC = DESCRIPTOR.message_types_by_name['ActorCreationTaskSpec'] +_ACTORTASKSPEC = DESCRIPTOR.message_types_by_name['ActorTaskSpec'] +_TASK = DESCRIPTOR.message_types_by_name['Task'] +_RESOURCEID = DESCRIPTOR.message_types_by_name['ResourceId'] +_RESOURCEMAPENTRY = DESCRIPTOR.message_types_by_name['ResourceMapEntry'] +_VIEWDATA = DESCRIPTOR.message_types_by_name['ViewData'] +_VIEWDATA_MEASURE = _VIEWDATA.nested_types_by_name['Measure'] +_OBJECTREFINFO = DESCRIPTOR.message_types_by_name['ObjectRefInfo'] +_RESOURCEALLOCATIONS = DESCRIPTOR.message_types_by_name['ResourceAllocations'] +_RESOURCEALLOCATIONS_RESOURCESLOT = _RESOURCEALLOCATIONS.nested_types_by_name['ResourceSlot'] +_COREWORKERSTATS = DESCRIPTOR.message_types_by_name['CoreWorkerStats'] +_COREWORKERSTATS_USEDRESOURCESENTRY = _COREWORKERSTATS.nested_types_by_name['UsedResourcesEntry'] +_COREWORKERSTATS_WEBUIDISPLAYENTRY = _COREWORKERSTATS.nested_types_by_name['WebuiDisplayEntry'] +_NODERESOURCEUSAGE = DESCRIPTOR.message_types_by_name['NodeResourceUsage'] +_LABELSELECTORCONSTRAINT = DESCRIPTOR.message_types_by_name['LabelSelectorConstraint'] +_LABELSELECTOR = DESCRIPTOR.message_types_by_name['LabelSelector'] +_FALLBACKOPTION = DESCRIPTOR.message_types_by_name['FallbackOption'] +_FALLBACKSTRATEGY = DESCRIPTOR.message_types_by_name['FallbackStrategy'] +_NAMEDACTORINFO = DESCRIPTOR.message_types_by_name['NamedActorInfo'] +_LINEAGERECONSTRUCTIONTASK = DESCRIPTOR.message_types_by_name['LineageReconstructionTask'] +_LINEAGERECONSTRUCTIONTASK_LABELSENTRY = _LINEAGERECONSTRUCTIONTASK.nested_types_by_name['LabelsEntry'] +_NODEDEATHINFO_REASON = _NODEDEATHINFO.enum_types_by_name['Reason'] +_ACTORDIEDERRORCONTEXT_REASON = _ACTORDIEDERRORCONTEXT.enum_types_by_name['Reason'] +_JOBCONFIG_ACTORLIFETIME = _JOBCONFIG.enum_types_by_name['ActorLifetime'] +LabelIn = _reflection.GeneratedProtocolMessageType('LabelIn', (_message.Message,), { + 'DESCRIPTOR' : _LABELIN, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelIn) + }) +_sym_db.RegisterMessage(LabelIn) + +LabelNotIn = _reflection.GeneratedProtocolMessageType('LabelNotIn', (_message.Message,), { + 'DESCRIPTOR' : _LABELNOTIN, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelNotIn) + }) +_sym_db.RegisterMessage(LabelNotIn) + +LabelExists = _reflection.GeneratedProtocolMessageType('LabelExists', (_message.Message,), { + 'DESCRIPTOR' : _LABELEXISTS, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelExists) + }) +_sym_db.RegisterMessage(LabelExists) + +LabelDoesNotExist = _reflection.GeneratedProtocolMessageType('LabelDoesNotExist', (_message.Message,), { + 'DESCRIPTOR' : _LABELDOESNOTEXIST, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelDoesNotExist) + }) +_sym_db.RegisterMessage(LabelDoesNotExist) + +LabelOperator = _reflection.GeneratedProtocolMessageType('LabelOperator', (_message.Message,), { + 'DESCRIPTOR' : _LABELOPERATOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelOperator) + }) +_sym_db.RegisterMessage(LabelOperator) + +LabelMatchExpression = _reflection.GeneratedProtocolMessageType('LabelMatchExpression', (_message.Message,), { + 'DESCRIPTOR' : _LABELMATCHEXPRESSION, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelMatchExpression) + }) +_sym_db.RegisterMessage(LabelMatchExpression) + +LabelMatchExpressions = _reflection.GeneratedProtocolMessageType('LabelMatchExpressions', (_message.Message,), { + 'DESCRIPTOR' : _LABELMATCHEXPRESSIONS, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelMatchExpressions) + }) +_sym_db.RegisterMessage(LabelMatchExpressions) + +NodeLabelSchedulingStrategy = _reflection.GeneratedProtocolMessageType('NodeLabelSchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _NODELABELSCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeLabelSchedulingStrategy) + }) +_sym_db.RegisterMessage(NodeLabelSchedulingStrategy) + +NodeAffinitySchedulingStrategy = _reflection.GeneratedProtocolMessageType('NodeAffinitySchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _NODEAFFINITYSCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeAffinitySchedulingStrategy) + }) +_sym_db.RegisterMessage(NodeAffinitySchedulingStrategy) + +PlacementGroupSchedulingStrategy = _reflection.GeneratedProtocolMessageType('PlacementGroupSchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTGROUPSCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlacementGroupSchedulingStrategy) + }) +_sym_db.RegisterMessage(PlacementGroupSchedulingStrategy) + +DefaultSchedulingStrategy = _reflection.GeneratedProtocolMessageType('DefaultSchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _DEFAULTSCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DefaultSchedulingStrategy) + }) +_sym_db.RegisterMessage(DefaultSchedulingStrategy) + +SpreadSchedulingStrategy = _reflection.GeneratedProtocolMessageType('SpreadSchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _SPREADSCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SpreadSchedulingStrategy) + }) +_sym_db.RegisterMessage(SpreadSchedulingStrategy) + +SchedulingStrategy = _reflection.GeneratedProtocolMessageType('SchedulingStrategy', (_message.Message,), { + 'DESCRIPTOR' : _SCHEDULINGSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SchedulingStrategy) + }) +_sym_db.RegisterMessage(SchedulingStrategy) + +Address = _reflection.GeneratedProtocolMessageType('Address', (_message.Message,), { + 'DESCRIPTOR' : _ADDRESS, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Address) + }) +_sym_db.RegisterMessage(Address) + +JavaFunctionDescriptor = _reflection.GeneratedProtocolMessageType('JavaFunctionDescriptor', (_message.Message,), { + 'DESCRIPTOR' : _JAVAFUNCTIONDESCRIPTOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JavaFunctionDescriptor) + }) +_sym_db.RegisterMessage(JavaFunctionDescriptor) + +PythonFunctionDescriptor = _reflection.GeneratedProtocolMessageType('PythonFunctionDescriptor', (_message.Message,), { + 'DESCRIPTOR' : _PYTHONFUNCTIONDESCRIPTOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PythonFunctionDescriptor) + }) +_sym_db.RegisterMessage(PythonFunctionDescriptor) + +CppFunctionDescriptor = _reflection.GeneratedProtocolMessageType('CppFunctionDescriptor', (_message.Message,), { + 'DESCRIPTOR' : _CPPFUNCTIONDESCRIPTOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CppFunctionDescriptor) + }) +_sym_db.RegisterMessage(CppFunctionDescriptor) + +FunctionDescriptor = _reflection.GeneratedProtocolMessageType('FunctionDescriptor', (_message.Message,), { + 'DESCRIPTOR' : _FUNCTIONDESCRIPTOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FunctionDescriptor) + }) +_sym_db.RegisterMessage(FunctionDescriptor) + +ConcurrencyGroup = _reflection.GeneratedProtocolMessageType('ConcurrencyGroup', (_message.Message,), { + 'DESCRIPTOR' : _CONCURRENCYGROUP, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ConcurrencyGroup) + }) +_sym_db.RegisterMessage(ConcurrencyGroup) + +UserErrorInfo = _reflection.GeneratedProtocolMessageType('UserErrorInfo', (_message.Message,), { + 'DESCRIPTOR' : _USERERRORINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UserErrorInfo) + }) +_sym_db.RegisterMessage(UserErrorInfo) + +RayErrorInfo = _reflection.GeneratedProtocolMessageType('RayErrorInfo', (_message.Message,), { + 'DESCRIPTOR' : _RAYERRORINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RayErrorInfo) + }) +_sym_db.RegisterMessage(RayErrorInfo) + +OutOfMemoryErrorContext = _reflection.GeneratedProtocolMessageType('OutOfMemoryErrorContext', (_message.Message,), { + 'DESCRIPTOR' : _OUTOFMEMORYERRORCONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.OutOfMemoryErrorContext) + }) +_sym_db.RegisterMessage(OutOfMemoryErrorContext) + +NodeDiedErrorContext = _reflection.GeneratedProtocolMessageType('NodeDiedErrorContext', (_message.Message,), { + 'DESCRIPTOR' : _NODEDIEDERRORCONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeDiedErrorContext) + }) +_sym_db.RegisterMessage(NodeDiedErrorContext) + +RayException = _reflection.GeneratedProtocolMessageType('RayException', (_message.Message,), { + 'DESCRIPTOR' : _RAYEXCEPTION, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RayException) + }) +_sym_db.RegisterMessage(RayException) + +NodeDeathInfo = _reflection.GeneratedProtocolMessageType('NodeDeathInfo', (_message.Message,), { + 'DESCRIPTOR' : _NODEDEATHINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeDeathInfo) + }) +_sym_db.RegisterMessage(NodeDeathInfo) + +ActorDeathCause = _reflection.GeneratedProtocolMessageType('ActorDeathCause', (_message.Message,), { + 'DESCRIPTOR' : _ACTORDEATHCAUSE, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorDeathCause) + }) +_sym_db.RegisterMessage(ActorDeathCause) + +RuntimeEnvFailedContext = _reflection.GeneratedProtocolMessageType('RuntimeEnvFailedContext', (_message.Message,), { + 'DESCRIPTOR' : _RUNTIMEENVFAILEDCONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RuntimeEnvFailedContext) + }) +_sym_db.RegisterMessage(RuntimeEnvFailedContext) + +ActorUnschedulableContext = _reflection.GeneratedProtocolMessageType('ActorUnschedulableContext', (_message.Message,), { + 'DESCRIPTOR' : _ACTORUNSCHEDULABLECONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorUnschedulableContext) + }) +_sym_db.RegisterMessage(ActorUnschedulableContext) + +ActorDiedErrorContext = _reflection.GeneratedProtocolMessageType('ActorDiedErrorContext', (_message.Message,), { + 'DESCRIPTOR' : _ACTORDIEDERRORCONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorDiedErrorContext) + }) +_sym_db.RegisterMessage(ActorDiedErrorContext) + +OomContext = _reflection.GeneratedProtocolMessageType('OomContext', (_message.Message,), { + 'DESCRIPTOR' : _OOMCONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.OomContext) + }) +_sym_db.RegisterMessage(OomContext) + +ActorUnavailableContext = _reflection.GeneratedProtocolMessageType('ActorUnavailableContext', (_message.Message,), { + 'DESCRIPTOR' : _ACTORUNAVAILABLECONTEXT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorUnavailableContext) + }) +_sym_db.RegisterMessage(ActorUnavailableContext) + +JobConfig = _reflection.GeneratedProtocolMessageType('JobConfig', (_message.Message,), { + + 'MetadataEntry' : _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), { + 'DESCRIPTOR' : _JOBCONFIG_METADATAENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobConfig.MetadataEntry) + }) + , + 'DESCRIPTOR' : _JOBCONFIG, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobConfig) + }) +_sym_db.RegisterMessage(JobConfig) +_sym_db.RegisterMessage(JobConfig.MetadataEntry) + +StreamingGeneratorReturnIdInfo = _reflection.GeneratedProtocolMessageType('StreamingGeneratorReturnIdInfo', (_message.Message,), { + 'DESCRIPTOR' : _STREAMINGGENERATORRETURNIDINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.StreamingGeneratorReturnIdInfo) + }) +_sym_db.RegisterMessage(StreamingGeneratorReturnIdInfo) + +LeaseSpec = _reflection.GeneratedProtocolMessageType('LeaseSpec', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _LEASESPEC_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LeaseSpec.RequiredResourcesEntry) + }) + , + + 'RequiredPlacementResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredPlacementResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LeaseSpec.RequiredPlacementResourcesEntry) + }) + , + 'DESCRIPTOR' : _LEASESPEC, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LeaseSpec) + }) +_sym_db.RegisterMessage(LeaseSpec) +_sym_db.RegisterMessage(LeaseSpec.RequiredResourcesEntry) +_sym_db.RegisterMessage(LeaseSpec.RequiredPlacementResourcesEntry) + +TaskSpec = _reflection.GeneratedProtocolMessageType('TaskSpec', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKSPEC_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskSpec.RequiredResourcesEntry) + }) + , + + 'RequiredPlacementResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredPlacementResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskSpec.RequiredPlacementResourcesEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKSPEC_LABELSENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskSpec.LabelsEntry) + }) + , + 'DESCRIPTOR' : _TASKSPEC, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskSpec) + }) +_sym_db.RegisterMessage(TaskSpec) +_sym_db.RegisterMessage(TaskSpec.RequiredResourcesEntry) +_sym_db.RegisterMessage(TaskSpec.RequiredPlacementResourcesEntry) +_sym_db.RegisterMessage(TaskSpec.LabelsEntry) + +TaskInfoEntry = _reflection.GeneratedProtocolMessageType('TaskInfoEntry', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKINFOENTRY_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskInfoEntry.RequiredResourcesEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKINFOENTRY_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskInfoEntry.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _TASKINFOENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskInfoEntry) + }) +_sym_db.RegisterMessage(TaskInfoEntry) +_sym_db.RegisterMessage(TaskInfoEntry.RequiredResourcesEntry) +_sym_db.RegisterMessage(TaskInfoEntry.LabelSelectorEntry) + +TaskAttempt = _reflection.GeneratedProtocolMessageType('TaskAttempt', (_message.Message,), { + 'DESCRIPTOR' : _TASKATTEMPT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskAttempt) + }) +_sym_db.RegisterMessage(TaskAttempt) + +Bundle = _reflection.GeneratedProtocolMessageType('Bundle', (_message.Message,), { + + 'BundleIdentifier' : _reflection.GeneratedProtocolMessageType('BundleIdentifier', (_message.Message,), { + 'DESCRIPTOR' : _BUNDLE_BUNDLEIDENTIFIER, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Bundle.BundleIdentifier) + }) + , + + 'UnitResourcesEntry' : _reflection.GeneratedProtocolMessageType('UnitResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _BUNDLE_UNITRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Bundle.UnitResourcesEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _BUNDLE_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Bundle.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _BUNDLE, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Bundle) + }) +_sym_db.RegisterMessage(Bundle) +_sym_db.RegisterMessage(Bundle.BundleIdentifier) +_sym_db.RegisterMessage(Bundle.UnitResourcesEntry) +_sym_db.RegisterMessage(Bundle.LabelSelectorEntry) + +PlacementGroupSpec = _reflection.GeneratedProtocolMessageType('PlacementGroupSpec', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTGROUPSPEC, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlacementGroupSpec) + }) +_sym_db.RegisterMessage(PlacementGroupSpec) + +ObjectReference = _reflection.GeneratedProtocolMessageType('ObjectReference', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTREFERENCE, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectReference) + }) +_sym_db.RegisterMessage(ObjectReference) + +ObjectReferenceCount = _reflection.GeneratedProtocolMessageType('ObjectReferenceCount', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTREFERENCECOUNT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectReferenceCount) + }) +_sym_db.RegisterMessage(ObjectReferenceCount) + +TaskArg = _reflection.GeneratedProtocolMessageType('TaskArg', (_message.Message,), { + 'DESCRIPTOR' : _TASKARG, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskArg) + }) +_sym_db.RegisterMessage(TaskArg) + +ReturnObject = _reflection.GeneratedProtocolMessageType('ReturnObject', (_message.Message,), { + 'DESCRIPTOR' : _RETURNOBJECT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReturnObject) + }) +_sym_db.RegisterMessage(ReturnObject) + +ActorCreationTaskSpec = _reflection.GeneratedProtocolMessageType('ActorCreationTaskSpec', (_message.Message,), { + 'DESCRIPTOR' : _ACTORCREATIONTASKSPEC, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorCreationTaskSpec) + }) +_sym_db.RegisterMessage(ActorCreationTaskSpec) + +ActorTaskSpec = _reflection.GeneratedProtocolMessageType('ActorTaskSpec', (_message.Message,), { + 'DESCRIPTOR' : _ACTORTASKSPEC, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorTaskSpec) + }) +_sym_db.RegisterMessage(ActorTaskSpec) + +Task = _reflection.GeneratedProtocolMessageType('Task', (_message.Message,), { + 'DESCRIPTOR' : _TASK, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Task) + }) +_sym_db.RegisterMessage(Task) + +ResourceId = _reflection.GeneratedProtocolMessageType('ResourceId', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEID, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceId) + }) +_sym_db.RegisterMessage(ResourceId) + +ResourceMapEntry = _reflection.GeneratedProtocolMessageType('ResourceMapEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEMAPENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceMapEntry) + }) +_sym_db.RegisterMessage(ResourceMapEntry) + +ViewData = _reflection.GeneratedProtocolMessageType('ViewData', (_message.Message,), { + + 'Measure' : _reflection.GeneratedProtocolMessageType('Measure', (_message.Message,), { + 'DESCRIPTOR' : _VIEWDATA_MEASURE, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ViewData.Measure) + }) + , + 'DESCRIPTOR' : _VIEWDATA, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ViewData) + }) +_sym_db.RegisterMessage(ViewData) +_sym_db.RegisterMessage(ViewData.Measure) + +ObjectRefInfo = _reflection.GeneratedProtocolMessageType('ObjectRefInfo', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTREFINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectRefInfo) + }) +_sym_db.RegisterMessage(ObjectRefInfo) + +ResourceAllocations = _reflection.GeneratedProtocolMessageType('ResourceAllocations', (_message.Message,), { + + 'ResourceSlot' : _reflection.GeneratedProtocolMessageType('ResourceSlot', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEALLOCATIONS_RESOURCESLOT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceAllocations.ResourceSlot) + }) + , + 'DESCRIPTOR' : _RESOURCEALLOCATIONS, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceAllocations) + }) +_sym_db.RegisterMessage(ResourceAllocations) +_sym_db.RegisterMessage(ResourceAllocations.ResourceSlot) + +CoreWorkerStats = _reflection.GeneratedProtocolMessageType('CoreWorkerStats', (_message.Message,), { + + 'UsedResourcesEntry' : _reflection.GeneratedProtocolMessageType('UsedResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _COREWORKERSTATS_USEDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CoreWorkerStats.UsedResourcesEntry) + }) + , + + 'WebuiDisplayEntry' : _reflection.GeneratedProtocolMessageType('WebuiDisplayEntry', (_message.Message,), { + 'DESCRIPTOR' : _COREWORKERSTATS_WEBUIDISPLAYENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CoreWorkerStats.WebuiDisplayEntry) + }) + , + 'DESCRIPTOR' : _COREWORKERSTATS, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CoreWorkerStats) + }) +_sym_db.RegisterMessage(CoreWorkerStats) +_sym_db.RegisterMessage(CoreWorkerStats.UsedResourcesEntry) +_sym_db.RegisterMessage(CoreWorkerStats.WebuiDisplayEntry) + +NodeResourceUsage = _reflection.GeneratedProtocolMessageType('NodeResourceUsage', (_message.Message,), { + 'DESCRIPTOR' : _NODERESOURCEUSAGE, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeResourceUsage) + }) +_sym_db.RegisterMessage(NodeResourceUsage) + +LabelSelectorConstraint = _reflection.GeneratedProtocolMessageType('LabelSelectorConstraint', (_message.Message,), { + 'DESCRIPTOR' : _LABELSELECTORCONSTRAINT, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelSelectorConstraint) + }) +_sym_db.RegisterMessage(LabelSelectorConstraint) + +LabelSelector = _reflection.GeneratedProtocolMessageType('LabelSelector', (_message.Message,), { + 'DESCRIPTOR' : _LABELSELECTOR, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LabelSelector) + }) +_sym_db.RegisterMessage(LabelSelector) + +FallbackOption = _reflection.GeneratedProtocolMessageType('FallbackOption', (_message.Message,), { + 'DESCRIPTOR' : _FALLBACKOPTION, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FallbackOption) + }) +_sym_db.RegisterMessage(FallbackOption) + +FallbackStrategy = _reflection.GeneratedProtocolMessageType('FallbackStrategy', (_message.Message,), { + 'DESCRIPTOR' : _FALLBACKSTRATEGY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FallbackStrategy) + }) +_sym_db.RegisterMessage(FallbackStrategy) + +NamedActorInfo = _reflection.GeneratedProtocolMessageType('NamedActorInfo', (_message.Message,), { + 'DESCRIPTOR' : _NAMEDACTORINFO, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NamedActorInfo) + }) +_sym_db.RegisterMessage(NamedActorInfo) + +LineageReconstructionTask = _reflection.GeneratedProtocolMessageType('LineageReconstructionTask', (_message.Message,), { + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _LINEAGERECONSTRUCTIONTASK_LABELSENTRY, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LineageReconstructionTask.LabelsEntry) + }) + , + 'DESCRIPTOR' : _LINEAGERECONSTRUCTIONTASK, + '__module__' : 'src.ray.protobuf.common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LineageReconstructionTask) + }) +_sym_db.RegisterMessage(LineageReconstructionTask) +_sym_db.RegisterMessage(LineageReconstructionTask.LabelsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\030io.ray.runtime.generated' + _JOBCONFIG_METADATAENTRY._options = None + _JOBCONFIG_METADATAENTRY._serialized_options = b'8\001' + _LEASESPEC_REQUIREDRESOURCESENTRY._options = None + _LEASESPEC_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY._options = None + _LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_options = b'8\001' + _TASKSPEC_REQUIREDRESOURCESENTRY._options = None + _TASKSPEC_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY._options = None + _TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_options = b'8\001' + _TASKSPEC_LABELSENTRY._options = None + _TASKSPEC_LABELSENTRY._serialized_options = b'8\001' + _TASKINFOENTRY_REQUIREDRESOURCESENTRY._options = None + _TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _TASKINFOENTRY_LABELSELECTORENTRY._options = None + _TASKINFOENTRY_LABELSELECTORENTRY._serialized_options = b'8\001' + _BUNDLE_UNITRESOURCESENTRY._options = None + _BUNDLE_UNITRESOURCESENTRY._serialized_options = b'8\001' + _BUNDLE_LABELSELECTORENTRY._options = None + _BUNDLE_LABELSELECTORENTRY._serialized_options = b'8\001' + _COREWORKERSTATS_USEDRESOURCESENTRY._options = None + _COREWORKERSTATS_USEDRESOURCESENTRY._serialized_options = b'8\001' + _COREWORKERSTATS_WEBUIDISPLAYENTRY._options = None + _COREWORKERSTATS_WEBUIDISPLAYENTRY._serialized_options = b'8\001' + _LINEAGERECONSTRUCTIONTASK_LABELSENTRY._options = None + _LINEAGERECONSTRUCTIONTASK_LABELSENTRY._serialized_options = b'8\001' + _LANGUAGE._serialized_start=17186 + _LANGUAGE._serialized_end=17227 + _WORKERTYPE._serialized_start=17229 + _WORKERTYPE._serialized_end=17303 + _TASKTYPE._serialized_start=17305 + _TASKTYPE._serialized_end=17390 + _ERRORTYPE._serialized_start=17393 + _ERRORTYPE._serialized_end=18145 + _TENSORTRANSPORT._serialized_start=18147 + _TENSORTRANSPORT._serialized_end=18212 + _TASKSTATUS._serialized_start=18215 + _TASKSTATUS._serialized_end=18572 + _WORKEREXITTYPE._serialized_start=18574 + _WORKEREXITTYPE._serialized_end=18698 + _PLACEMENTSTRATEGY._serialized_start=18700 + _PLACEMENTSTRATEGY._serialized_end=18777 + _LABELSELECTOROPERATOR._serialized_start=18779 + _LABELSELECTOROPERATOR._serialized_end=18884 + _LABELIN._serialized_start=93 + _LABELIN._serialized_end=126 + _LABELNOTIN._serialized_start=128 + _LABELNOTIN._serialized_end=164 + _LABELEXISTS._serialized_start=166 + _LABELEXISTS._serialized_end=179 + _LABELDOESNOTEXIST._serialized_start=181 + _LABELDOESNOTEXIST._serialized_end=200 + _LABELOPERATOR._serialized_start=203 + _LABELOPERATOR._serialized_end=478 + _LABELMATCHEXPRESSION._serialized_start=480 + _LABELMATCHEXPRESSION._serialized_end=572 + _LABELMATCHEXPRESSIONS._serialized_start=574 + _LABELMATCHEXPRESSIONS._serialized_end=662 + _NODELABELSCHEDULINGSTRATEGY._serialized_start=665 + _NODELABELSCHEDULINGSTRATEGY._serialized_end=798 + _NODEAFFINITYSCHEDULINGSTRATEGY._serialized_start=801 + _NODEAFFINITYSCHEDULINGSTRATEGY._serialized_end=976 + _PLACEMENTGROUPSCHEDULINGSTRATEGY._serialized_start=979 + _PLACEMENTGROUPSCHEDULINGSTRATEGY._serialized_end=1202 + _DEFAULTSCHEDULINGSTRATEGY._serialized_start=1204 + _DEFAULTSCHEDULINGSTRATEGY._serialized_end=1231 + _SPREADSCHEDULINGSTRATEGY._serialized_start=1233 + _SPREADSCHEDULINGSTRATEGY._serialized_end=1259 + _SCHEDULINGSTRATEGY._serialized_start=1262 + _SCHEDULINGSTRATEGY._serialized_end=1857 + _ADDRESS._serialized_start=1859 + _ADDRESS._serialized_end=1973 + _JAVAFUNCTIONDESCRIPTOR._serialized_start=1975 + _JAVAFUNCTIONDESCRIPTOR._serialized_end=2097 + _PYTHONFUNCTIONDESCRIPTOR._serialized_start=2100 + _PYTHONFUNCTIONDESCRIPTOR._serialized_end=2264 + _CPPFUNCTIONDESCRIPTOR._serialized_start=2266 + _CPPFUNCTIONDESCRIPTOR._serialized_end=2381 + _FUNCTIONDESCRIPTOR._serialized_start=2384 + _FUNCTIONDESCRIPTOR._serialized_end=2709 + _CONCURRENCYGROUP._serialized_start=2712 + _CONCURRENCYGROUP._serialized_end=2871 + _USERERRORINFO._serialized_start=2873 + _USERERRORINFO._serialized_end=2972 + _RAYERRORINFO._serialized_start=2975 + _RAYERRORINFO._serialized_end=3352 + _OUTOFMEMORYERRORCONTEXT._serialized_start=3355 + _OUTOFMEMORYERRORCONTEXT._serialized_end=3659 + _NODEDIEDERRORCONTEXT._serialized_start=3661 + _NODEDIEDERRORCONTEXT._serialized_end=3748 + _RAYEXCEPTION._serialized_start=3751 + _RAYEXCEPTION._serialized_end=3925 + _NODEDEATHINFO._serialized_start=3928 + _NODEDEATHINFO._serialized_end=4178 + _NODEDEATHINFO_REASON._serialized_start=4040 + _NODEDEATHINFO_REASON._serialized_end=4178 + _ACTORDEATHCAUSE._serialized_start=4181 + _ACTORDEATHCAUSE._serialized_end=4647 + _RUNTIMEENVFAILEDCONTEXT._serialized_start=4649 + _RUNTIMEENVFAILEDCONTEXT._serialized_end=4711 + _ACTORUNSCHEDULABLECONTEXT._serialized_start=4713 + _ACTORUNSCHEDULABLECONTEXT._serialized_end=4777 + _ACTORDIEDERRORCONTEXT._serialized_start=4780 + _ACTORDIEDERRORCONTEXT._serialized_end=5395 + _ACTORDIEDERRORCONTEXT_REASON._serialized_start=5253 + _ACTORDIEDERRORCONTEXT_REASON._serialized_end=5375 + _OOMCONTEXT._serialized_start=5397 + _OOMCONTEXT._serialized_end=5489 + _ACTORUNAVAILABLECONTEXT._serialized_start=5491 + _ACTORUNAVAILABLECONTEXT._serialized_end=5561 + _JOBCONFIG._serialized_start=5564 + _JOBCONFIG._serialized_end=6124 + _JOBCONFIG_METADATAENTRY._serialized_start=6016 + _JOBCONFIG_METADATAENTRY._serialized_end=6075 + _JOBCONFIG_ACTORLIFETIME._serialized_start=6077 + _JOBCONFIG_ACTORLIFETIME._serialized_end=6124 + _STREAMINGGENERATORRETURNIDINFO._serialized_start=6126 + _STREAMINGGENERATORRETURNIDINFO._serialized_end=6229 + _LEASESPEC._serialized_start=6232 + _LEASESPEC._serialized_end=7598 + _LEASESPEC_REQUIREDRESOURCESENTRY._serialized_start=7451 + _LEASESPEC_REQUIREDRESOURCESENTRY._serialized_end=7519 + _LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_start=7521 + _LEASESPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_end=7598 + _TASKSPEC._serialized_start=7601 + _TASKSPEC._serialized_end=10090 + _TASKSPEC_REQUIREDRESOURCESENTRY._serialized_start=7451 + _TASKSPEC_REQUIREDRESOURCESENTRY._serialized_end=7519 + _TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_start=7521 + _TASKSPEC_REQUIREDPLACEMENTRESOURCESENTRY._serialized_end=7598 + _TASKSPEC_LABELSENTRY._serialized_start=9968 + _TASKSPEC_LABELSENTRY._serialized_end=10025 + _TASKINFOENTRY._serialized_start=10093 + _TASKINFOENTRY._serialized_end=10997 + _TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_start=7451 + _TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_end=7519 + _TASKINFOENTRY_LABELSELECTORENTRY._serialized_start=10871 + _TASKINFOENTRY_LABELSELECTORENTRY._serialized_end=10935 + _TASKATTEMPT._serialized_start=10999 + _TASKATTEMPT._serialized_end=11076 + _BUNDLE._serialized_start=11079 + _BUNDLE._serialized_end=11558 + _BUNDLE_BUNDLEIDENTIFIER._serialized_start=11327 + _BUNDLE_BUNDLEIDENTIFIER._serialized_end=11426 + _BUNDLE_UNITRESOURCESENTRY._serialized_start=11428 + _BUNDLE_UNITRESOURCESENTRY._serialized_end=11492 + _BUNDLE_LABELSELECTORENTRY._serialized_start=10871 + _BUNDLE_LABELSELECTORENTRY._serialized_end=10935 + _PLACEMENTGROUPSPEC._serialized_start=11561 + _PLACEMENTGROUPSPEC._serialized_end=11994 + _OBJECTREFERENCE._serialized_start=11997 + _OBJECTREFERENCE._serialized_end=12222 + _OBJECTREFERENCECOUNT._serialized_start=12225 + _OBJECTREFERENCECOUNT._serialized_end=12544 + _TASKARG._serialized_start=12547 + _TASKARG._serialized_end=12861 + _RETURNOBJECT._serialized_start=12864 + _RETURNOBJECT._serialized_end=13078 + _ACTORCREATIONTASKSPEC._serialized_start=13081 + _ACTORCREATIONTASKSPEC._serialized_end=13712 + _ACTORTASKSPEC._serialized_start=13715 + _ACTORTASKSPEC._serialized_end=13866 + _TASK._serialized_start=13868 + _TASK._serialized_end=13922 + _RESOURCEID._serialized_start=13924 + _RESOURCEID._serialized_end=13986 + _RESOURCEMAPENTRY._serialized_start=13988 + _RESOURCEMAPENTRY._serialized_end=14082 + _VIEWDATA._serialized_start=14085 + _VIEWDATA._serialized_end=14585 + _VIEWDATA_MEASURE._serialized_start=14182 + _VIEWDATA_MEASURE._serialized_end=14585 + _OBJECTREFINFO._serialized_start=14588 + _OBJECTREFINFO._serialized_end=14972 + _RESOURCEALLOCATIONS._serialized_start=14975 + _RESOURCEALLOCATIONS._serialized_end=15146 + _RESOURCEALLOCATIONS_RESOURCESLOT._serialized_start=15080 + _RESOURCEALLOCATIONS_RESOURCESLOT._serialized_end=15146 + _COREWORKERSTATS._serialized_start=15149 + _COREWORKERSTATS._serialized_end=16442 + _COREWORKERSTATS_USEDRESOURCESENTRY._serialized_start=16283 + _COREWORKERSTATS_USEDRESOURCESENTRY._serialized_end=16377 + _COREWORKERSTATS_WEBUIDISPLAYENTRY._serialized_start=16379 + _COREWORKERSTATS_WEBUIDISPLAYENTRY._serialized_end=16442 + _NODERESOURCEUSAGE._serialized_start=16444 + _NODERESOURCEUSAGE._serialized_end=16483 + _LABELSELECTORCONSTRAINT._serialized_start=16486 + _LABELSELECTORCONSTRAINT._serialized_end=16635 + _LABELSELECTOR._serialized_start=16637 + _LABELSELECTOR._serialized_end=16731 + _FALLBACKOPTION._serialized_start=16733 + _FALLBACKOPTION._serialized_end=16812 + _FALLBACKSTRATEGY._serialized_start=16814 + _FALLBACKSTRATEGY._serialized_end=16883 + _NAMEDACTORINFO._serialized_start=16885 + _NAMEDACTORINFO._serialized_end=16958 + _LINEAGERECONSTRUCTIONTASK._serialized_start=16961 + _LINEAGERECONSTRUCTIONTASK._serialized_end=17184 + _LINEAGERECONSTRUCTIONTASK_LABELSENTRY._serialized_start=9968 + _LINEAGERECONSTRUCTIONTASK_LABELSENTRY._serialized_end=10025 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/common_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/common_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2.py b/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..07d2388dd1f16aca34deaf06f9cc742e0f788ce8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2.py @@ -0,0 +1,542 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/core_worker.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import pubsub_pb2 as src_dot_ray_dot_protobuf_dot_pubsub__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"src/ray/protobuf/core_worker.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a\x1dsrc/ray/protobuf/pubsub.proto\"0\n\x0f\x41\x63tiveObjectIDs\x12\x1d\n\nobject_ids\x18\x01 \x03(\x0cR\tobjectIds\"\xe4\x06\n\x0b\x41\x63torHandle\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x19\n\x08owner_id\x18\x02 \x01(\x0cR\x07ownerId\x12\x35\n\rowner_address\x18\x03 \x01(\x0b\x32\x10.ray.rpc.AddressR\x0cownerAddress\x12&\n\x0f\x63reation_job_id\x18\x04 \x01(\x0cR\rcreationJobId\x12\x38\n\x0e\x61\x63tor_language\x18\x05 \x01(\x0e\x32\x11.ray.rpc.LanguageR\ractorLanguage\x12q\n\'actor_creation_task_function_descriptor\x18\x06 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR#actorCreationTaskFunctionDescriptor\x12!\n\x0c\x61\x63tor_cursor\x18\x07 \x01(\x0cR\x0b\x61\x63torCursor\x12%\n\x0e\x65xtension_data\x18\x08 \x01(\x0cR\rextensionData\x12(\n\x10max_task_retries\x18\t \x01(\x03R\x0emaxTaskRetries\x12\x12\n\x04name\x18\n \x01(\tR\x04name\x12#\n\rray_namespace\x18\x0b \x01(\tR\x0crayNamespace\x12>\n\x1c\x61llow_out_of_order_execution\x18\x0c \x01(\x08R\x18\x61llowOutOfOrderExecution\x12*\n\x11max_pending_calls\x18\r \x01(\x05R\x0fmaxPendingCalls\x12,\n\x12\x65nable_task_events\x18\x0e \x01(\x08R\x10\x65nableTaskEvents\x12\x38\n\x06labels\x18\x0f \x03(\x0b\x32 .ray.rpc.ActorHandle.LabelsEntryR\x06labels\x12\x36\n\x17\x65nable_tensor_transport\x18\x10 \x01(\x08R\x15\x65nableTensorTransport\x12\x1f\n\x0bis_detached\x18\x11 \x01(\x08R\nisDetached\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x93\x02\n\x0fPushTaskRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12.\n\ttask_spec\x18\x02 \x01(\x0b\x32\x11.ray.rpc.TaskSpecR\x08taskSpec\x12\'\n\x0fsequence_number\x18\x03 \x01(\x03R\x0esequenceNumber\x12\x33\n\x16\x63lient_processed_up_to\x18\x04 \x01(\x03R\x13\x63lientProcessedUpTo\x12\x44\n\x10resource_mapping\x18\x05 \x03(\x0b\x32\x19.ray.rpc.ResourceMapEntryR\x0fresourceMapping\"\x87\x05\n\rPushTaskReply\x12<\n\x0ereturn_objects\x18\x01 \x03(\x0b\x32\x15.ray.rpc.ReturnObjectR\rreturnObjects\x12K\n\x16\x64ynamic_return_objects\x18\x02 \x03(\x0b\x32\x15.ray.rpc.ReturnObjectR\x14\x64ynamicReturnObjects\x12%\n\x0eworker_exiting\x18\x03 \x01(\x08R\rworkerExiting\x12\x42\n\rborrowed_refs\x18\x04 \x03(\x0b\x32\x1d.ray.rpc.ObjectReferenceCountR\x0c\x62orrowedRefs\x12,\n\x12is_retryable_error\x18\x05 \x01(\x08R\x10isRetryableError\x12\x30\n\x14is_application_error\x18\x06 \x01(\x08R\x12isApplicationError\x12?\n\x1cwas_cancelled_before_running\x18\x07 \x01(\x08R\x19wasCancelledBeforeRunning\x12+\n\x0f\x61\x63tor_repr_name\x18\x08 \x01(\tH\x00R\ractorReprName\x88\x01\x01\x12\x30\n\x14task_execution_error\x18\t \x01(\tR\x12taskExecutionError\x12l\n\x1estreaming_generator_return_ids\x18\n \x03(\x0b\x32\'.ray.rpc.StreamingGeneratorReturnIdInfoR\x1bstreamingGeneratorReturnIdsB\x12\n\x10_actor_repr_name\"a\n\x1f\x41\x63torCallArgWaitCompleteRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x10\n\x03tag\x18\x02 \x01(\x03R\x03tag\"\x1f\n\x1d\x41\x63torCallArgWaitCompleteReply\"]\n\x16GetObjectStatusRequest\x12&\n\x0fowner_worker_id\x18\x01 \x01(\x0cR\rownerWorkerId\x12\x1b\n\tobject_id\x18\x02 \x01(\x0cR\x08objectId\"\x85\x01\n\tRayObject\x12\x12\n\x04\x64\x61ta\x18\x01 \x01(\x0cR\x04\x64\x61ta\x12\x1a\n\x08metadata\x18\x02 \x01(\x0cR\x08metadata\x12H\n\x13nested_inlined_refs\x18\x03 \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x11nestedInlinedRefs\"\xfc\x01\n\x14GetObjectStatusReply\x12\x42\n\x06status\x18\x01 \x01(\x0e\x32*.ray.rpc.GetObjectStatusReply.ObjectStatusR\x06status\x12*\n\x06object\x18\x02 \x01(\x0b\x32\x12.ray.rpc.RayObjectR\x06object\x12\x19\n\x08node_ids\x18\x03 \x03(\x0cR\x07nodeIds\x12\x1f\n\x0bobject_size\x18\x04 \x01(\x04R\nobjectSize\"8\n\x0cObjectStatus\x12\x0b\n\x07\x43REATED\x10\x00\x12\x10\n\x0cOUT_OF_SCOPE\x10\x01\x12\t\n\x05\x46REED\x10\x02\"h\n\x1dWaitForActorRefDeletedRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x19\n\x08\x61\x63tor_id\x18\x02 \x01(\x0cR\x07\x61\x63torId\"\x1d\n\x1bWaitForActorRefDeletedReply\"\xc0\x01\n UpdateObjectLocationBatchRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x17\n\x07node_id\x18\x02 \x01(\x0cR\x06nodeId\x12U\n\x17object_location_updates\x18\x03 \x03(\x0b\x32\x1d.ray.rpc.ObjectLocationUpdateR\x15objectLocationUpdates\" \n\x1eUpdateObjectLocationBatchReply\"w\n\x1bObjectSpilledLocationUpdate\x12\x1f\n\x0bspilled_url\x18\x03 \x01(\tR\nspilledUrl\x12\x37\n\x18spilled_to_local_storage\x18\x04 \x01(\x08R\x15spilledToLocalStorage\"\xe6\x02\n\x14ObjectLocationUpdate\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12^\n\x16plasma_location_update\x18\x02 \x01(\x0e\x32#.ray.rpc.ObjectPlasmaLocationUpdateH\x00R\x14plasmaLocationUpdate\x88\x01\x01\x12\x61\n\x17spilled_location_update\x18\x03 \x01(\x0b\x32$.ray.rpc.ObjectSpilledLocationUpdateH\x01R\x15spilledLocationUpdate\x88\x01\x01\x12&\n\x0cgenerator_id\x18\x04 \x01(\x0cH\x02R\x0bgeneratorId\x88\x01\x01\x42\x19\n\x17_plasma_location_updateB\x1a\n\x18_spilled_location_updateB\x0f\n\r_generator_id\"m\n\x1eGetObjectLocationsOwnerRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x1d\n\nobject_ids\x18\x02 \x03(\x0cR\tobjectIds\"|\n\x1cGetObjectLocationsOwnerReply\x12\\\n\x15object_location_infos\x18\x01 \x03(\x0b\x32(.ray.rpc.WorkerObjectLocationsPubMessageR\x13objectLocationInfos\"\x98\x01\n\x10KillActorRequest\x12*\n\x11intended_actor_id\x18\x01 \x01(\x0cR\x0fintendedActorId\x12\x1d\n\nforce_kill\x18\x02 \x01(\x08R\tforceKill\x12\x39\n\x0b\x64\x65\x61th_cause\x18\x03 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseR\ndeathCause\"\x10\n\x0eKillActorReply\"\xa4\x01\n\x11\x43\x61ncelTaskRequest\x12(\n\x10intended_task_id\x18\x01 \x01(\x0cR\x0eintendedTaskId\x12\x1d\n\nforce_kill\x18\x02 \x01(\x08R\tforceKill\x12\x1c\n\trecursive\x18\x03 \x01(\x08R\trecursive\x12(\n\x10\x63\x61ller_worker_id\x18\x04 \x01(\x0cR\x0e\x63\x61llerWorkerId\"t\n\x0f\x43\x61ncelTaskReply\x12\x34\n\x16requested_task_running\x18\x01 \x01(\x08R\x14requestedTaskRunning\x12+\n\x11\x61ttempt_succeeded\x18\x02 \x01(\x08R\x10\x61ttemptSucceeded\"\x80\x01\n\x17\x43\x61ncelRemoteTaskRequest\x12(\n\x10remote_object_id\x18\x01 \x01(\x0cR\x0eremoteObjectId\x12\x1d\n\nforce_kill\x18\x02 \x01(\x08R\tforceKill\x12\x1c\n\trecursive\x18\x03 \x01(\x08R\trecursive\"\x17\n\x15\x43\x61ncelRemoteTaskReply\"\xca\x01\n\x19GetCoreWorkerStatsRequest\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12.\n\x13include_memory_info\x18\x02 \x01(\x08R\x11includeMemoryInfo\x12*\n\x11include_task_info\x18\x03 \x01(\x08R\x0fincludeTaskInfo\x12\x19\n\x05limit\x18\x04 \x01(\x03H\x00R\x05limit\x88\x01\x01\x42\x08\n\x06_limit\"\xf9\x01\n\x17GetCoreWorkerStatsReply\x12\x44\n\x11\x63ore_worker_stats\x18\x01 \x01(\x0b\x32\x18.ray.rpc.CoreWorkerStatsR\x0f\x63oreWorkerStats\x12M\n\x17owned_task_info_entries\x18\x02 \x03(\x0b\x32\x16.ray.rpc.TaskInfoEntryR\x14ownedTaskInfoEntries\x12(\n\x10running_task_ids\x18\x03 \x03(\x0cR\x0erunningTaskIds\x12\x1f\n\x0btasks_total\x18\x04 \x01(\x03R\ntasksTotal\"E\n\x0eLocalGCRequest\x12\x33\n\x16triggered_by_global_gc\x18\x01 \x01(\x08R\x13triggeredByGlobalGc\"\x0e\n\x0cLocalGCReply\"7\n\x18PlasmaObjectReadyRequest\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\"\x18\n\x16PlasmaObjectReadyReply\"T\n\x14\x44\x65leteObjectsRequest\x12\x1d\n\nobject_ids\x18\x01 \x03(\x0cR\tobjectIds\x12\x1d\n\nlocal_only\x18\x02 \x01(\x08R\tlocalOnly\"\x14\n\x12\x44\x65leteObjectsReply\"\xa6\x01\n\x13SpillObjectsRequest\x12I\n\x14object_refs_to_spill\x18\x01 \x03(\x0b\x32\x18.ray.rpc.ObjectReferenceR\x11objectRefsToSpill\x12\x44\n\x0e\x64\x65lete_request\x18\x02 \x01(\x0b\x32\x1d.ray.rpc.DeleteObjectsRequestR\rdeleteRequest\"C\n\x11SpillObjectsReply\x12.\n\x13spilled_objects_url\x18\x01 \x03(\tR\x11spilledObjectsUrl\"\x81\x01\n\x1cRestoreSpilledObjectsRequest\x12.\n\x13spilled_objects_url\x18\x01 \x03(\tR\x11spilledObjectsUrl\x12\x31\n\x15object_ids_to_restore\x18\x02 \x03(\x0cR\x12objectIdsToRestore\"N\n\x1aRestoreSpilledObjectsReply\x12\x30\n\x14\x62ytes_restored_total\x18\x01 \x01(\x03R\x12\x62ytesRestoredTotal\"M\n\x1b\x44\x65leteSpilledObjectsRequest\x12.\n\x13spilled_objects_url\x18\x01 \x03(\tR\x11spilledObjectsUrl\"\x1b\n\x19\x44\x65leteSpilledObjectsReply\",\n\x0b\x45xitRequest\x12\x1d\n\nforce_exit\x18\x01 \x01(\x08R\tforceExit\"%\n\tExitReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\"\xe4\x01\n\x18\x41ssignObjectOwnerRequest\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\x12\x1f\n\x0bobject_size\x18\x02 \x01(\x04R\nobjectSize\x12\x30\n\x14\x63ontained_object_ids\x18\x03 \x03(\x0cR\x12\x63ontainedObjectIds\x12;\n\x10\x62orrower_address\x18\x04 \x01(\x0b\x32\x10.ray.rpc.AddressR\x0f\x62orrowerAddress\x12\x1b\n\tcall_site\x18\x05 \x01(\tR\x08\x63\x61llSite\"\x18\n\x16\x41ssignObjectOwnerReply\"\x1f\n\x1dRayletNotifyGCSRestartRequest\"\x1d\n\x1bRayletNotifyGCSRestartReply\"\x18\n\x16NumPendingTasksRequest\"B\n\x14NumPendingTasksReply\x12*\n\x11num_pending_tasks\x18\x01 \x01(\x03R\x0fnumPendingTasks\"\x8c\x02\n!ReportGeneratorItemReturnsRequest\x12K\n\x16\x64ynamic_return_objects\x18\x01 \x03(\x0b\x32\x15.ray.rpc.ReturnObjectR\x14\x64ynamicReturnObjects\x12\x31\n\x0bworker_addr\x18\x02 \x01(\x0b\x32\x10.ray.rpc.AddressR\nworkerAddr\x12\x1d\n\nitem_index\x18\x03 \x01(\x03R\titemIndex\x12!\n\x0cgenerator_id\x18\x05 \x01(\x0cR\x0bgeneratorId\x12%\n\x0e\x61ttempt_number\x18\x06 \x01(\x04R\rattemptNumber\"\\\n\x1fReportGeneratorItemReturnsReply\x12\x39\n\x19total_num_object_consumed\x18\x01 \x01(\x03R\x16totalNumObjectConsumed\"\x99\x01\n\"RegisterMutableObjectReaderRequest\x12(\n\x10writer_object_id\x18\x01 \x01(\x0cR\x0ewriterObjectId\x12\x1f\n\x0bnum_readers\x18\x02 \x01(\x03R\nnumReaders\x12(\n\x10reader_object_id\x18\x03 \x01(\x0cR\x0ereaderObjectId\"\"\n RegisterMutableObjectReaderReply*4\n\x1aObjectPlasmaLocationUpdate\x12\t\n\x05\x41\x44\x44\x45\x44\x10\x00\x12\x0b\n\x07REMOVED\x10\x01\x32\xe5\x10\n\x11\x43oreWorkerService\x12\x66\n\x16RayletNotifyGCSRestart\x12&.ray.rpc.RayletNotifyGCSRestartRequest\x1a$.ray.rpc.RayletNotifyGCSRestartReply\x12<\n\x08PushTask\x12\x18.ray.rpc.PushTaskRequest\x1a\x16.ray.rpc.PushTaskReply\x12l\n\x18\x41\x63torCallArgWaitComplete\x12(.ray.rpc.ActorCallArgWaitCompleteRequest\x1a&.ray.rpc.ActorCallArgWaitCompleteReply\x12Q\n\x0fGetObjectStatus\x12\x1f.ray.rpc.GetObjectStatusRequest\x1a\x1d.ray.rpc.GetObjectStatusReply\x12\x66\n\x16WaitForActorRefDeleted\x12&.ray.rpc.WaitForActorRefDeletedRequest\x1a$.ray.rpc.WaitForActorRefDeletedReply\x12W\n\x11PubsubLongPolling\x12!.ray.rpc.PubsubLongPollingRequest\x1a\x1f.ray.rpc.PubsubLongPollingReply\x12r\n\x1aReportGeneratorItemReturns\x12*.ray.rpc.ReportGeneratorItemReturnsRequest\x1a(.ray.rpc.ReportGeneratorItemReturnsReply\x12Z\n\x12PubsubCommandBatch\x12\".ray.rpc.PubsubCommandBatchRequest\x1a .ray.rpc.PubsubCommandBatchReply\x12o\n\x19UpdateObjectLocationBatch\x12).ray.rpc.UpdateObjectLocationBatchRequest\x1a\'.ray.rpc.UpdateObjectLocationBatchReply\x12i\n\x17GetObjectLocationsOwner\x12\'.ray.rpc.GetObjectLocationsOwnerRequest\x1a%.ray.rpc.GetObjectLocationsOwnerReply\x12?\n\tKillActor\x12\x19.ray.rpc.KillActorRequest\x1a\x17.ray.rpc.KillActorReply\x12\x42\n\nCancelTask\x12\x1a.ray.rpc.CancelTaskRequest\x1a\x18.ray.rpc.CancelTaskReply\x12T\n\x10\x43\x61ncelRemoteTask\x12 .ray.rpc.CancelRemoteTaskRequest\x1a\x1e.ray.rpc.CancelRemoteTaskReply\x12Z\n\x12GetCoreWorkerStats\x12\".ray.rpc.GetCoreWorkerStatsRequest\x1a .ray.rpc.GetCoreWorkerStatsReply\x12\x39\n\x07LocalGC\x12\x17.ray.rpc.LocalGCRequest\x1a\x15.ray.rpc.LocalGCReply\x12K\n\rDeleteObjects\x12\x1d.ray.rpc.DeleteObjectsRequest\x1a\x1b.ray.rpc.DeleteObjectsReply\x12H\n\x0cSpillObjects\x12\x1c.ray.rpc.SpillObjectsRequest\x1a\x1a.ray.rpc.SpillObjectsReply\x12\x63\n\x15RestoreSpilledObjects\x12%.ray.rpc.RestoreSpilledObjectsRequest\x1a#.ray.rpc.RestoreSpilledObjectsReply\x12`\n\x14\x44\x65leteSpilledObjects\x12$.ray.rpc.DeleteSpilledObjectsRequest\x1a\".ray.rpc.DeleteSpilledObjectsReply\x12W\n\x11PlasmaObjectReady\x12!.ray.rpc.PlasmaObjectReadyRequest\x1a\x1f.ray.rpc.PlasmaObjectReadyReply\x12\x30\n\x04\x45xit\x12\x14.ray.rpc.ExitRequest\x1a\x12.ray.rpc.ExitReply\x12W\n\x11\x41ssignObjectOwner\x12!.ray.rpc.AssignObjectOwnerRequest\x1a\x1f.ray.rpc.AssignObjectOwnerReply\x12Q\n\x0fNumPendingTasks\x12\x1f.ray.rpc.NumPendingTasksRequest\x1a\x1d.ray.rpc.NumPendingTasksReply\x12u\n\x1bRegisterMutableObjectReader\x12+.ray.rpc.RegisterMutableObjectReaderRequest\x1a).ray.rpc.RegisterMutableObjectReaderReplyb\x06proto3') + +_OBJECTPLASMALOCATIONUPDATE = DESCRIPTOR.enum_types_by_name['ObjectPlasmaLocationUpdate'] +ObjectPlasmaLocationUpdate = enum_type_wrapper.EnumTypeWrapper(_OBJECTPLASMALOCATIONUPDATE) +ADDED = 0 +REMOVED = 1 + + +_ACTIVEOBJECTIDS = DESCRIPTOR.message_types_by_name['ActiveObjectIDs'] +_ACTORHANDLE = DESCRIPTOR.message_types_by_name['ActorHandle'] +_ACTORHANDLE_LABELSENTRY = _ACTORHANDLE.nested_types_by_name['LabelsEntry'] +_PUSHTASKREQUEST = DESCRIPTOR.message_types_by_name['PushTaskRequest'] +_PUSHTASKREPLY = DESCRIPTOR.message_types_by_name['PushTaskReply'] +_ACTORCALLARGWAITCOMPLETEREQUEST = DESCRIPTOR.message_types_by_name['ActorCallArgWaitCompleteRequest'] +_ACTORCALLARGWAITCOMPLETEREPLY = DESCRIPTOR.message_types_by_name['ActorCallArgWaitCompleteReply'] +_GETOBJECTSTATUSREQUEST = DESCRIPTOR.message_types_by_name['GetObjectStatusRequest'] +_RAYOBJECT = DESCRIPTOR.message_types_by_name['RayObject'] +_GETOBJECTSTATUSREPLY = DESCRIPTOR.message_types_by_name['GetObjectStatusReply'] +_WAITFORACTORREFDELETEDREQUEST = DESCRIPTOR.message_types_by_name['WaitForActorRefDeletedRequest'] +_WAITFORACTORREFDELETEDREPLY = DESCRIPTOR.message_types_by_name['WaitForActorRefDeletedReply'] +_UPDATEOBJECTLOCATIONBATCHREQUEST = DESCRIPTOR.message_types_by_name['UpdateObjectLocationBatchRequest'] +_UPDATEOBJECTLOCATIONBATCHREPLY = DESCRIPTOR.message_types_by_name['UpdateObjectLocationBatchReply'] +_OBJECTSPILLEDLOCATIONUPDATE = DESCRIPTOR.message_types_by_name['ObjectSpilledLocationUpdate'] +_OBJECTLOCATIONUPDATE = DESCRIPTOR.message_types_by_name['ObjectLocationUpdate'] +_GETOBJECTLOCATIONSOWNERREQUEST = DESCRIPTOR.message_types_by_name['GetObjectLocationsOwnerRequest'] +_GETOBJECTLOCATIONSOWNERREPLY = DESCRIPTOR.message_types_by_name['GetObjectLocationsOwnerReply'] +_KILLACTORREQUEST = DESCRIPTOR.message_types_by_name['KillActorRequest'] +_KILLACTORREPLY = DESCRIPTOR.message_types_by_name['KillActorReply'] +_CANCELTASKREQUEST = DESCRIPTOR.message_types_by_name['CancelTaskRequest'] +_CANCELTASKREPLY = DESCRIPTOR.message_types_by_name['CancelTaskReply'] +_CANCELREMOTETASKREQUEST = DESCRIPTOR.message_types_by_name['CancelRemoteTaskRequest'] +_CANCELREMOTETASKREPLY = DESCRIPTOR.message_types_by_name['CancelRemoteTaskReply'] +_GETCOREWORKERSTATSREQUEST = DESCRIPTOR.message_types_by_name['GetCoreWorkerStatsRequest'] +_GETCOREWORKERSTATSREPLY = DESCRIPTOR.message_types_by_name['GetCoreWorkerStatsReply'] +_LOCALGCREQUEST = DESCRIPTOR.message_types_by_name['LocalGCRequest'] +_LOCALGCREPLY = DESCRIPTOR.message_types_by_name['LocalGCReply'] +_PLASMAOBJECTREADYREQUEST = DESCRIPTOR.message_types_by_name['PlasmaObjectReadyRequest'] +_PLASMAOBJECTREADYREPLY = DESCRIPTOR.message_types_by_name['PlasmaObjectReadyReply'] +_DELETEOBJECTSREQUEST = DESCRIPTOR.message_types_by_name['DeleteObjectsRequest'] +_DELETEOBJECTSREPLY = DESCRIPTOR.message_types_by_name['DeleteObjectsReply'] +_SPILLOBJECTSREQUEST = DESCRIPTOR.message_types_by_name['SpillObjectsRequest'] +_SPILLOBJECTSREPLY = DESCRIPTOR.message_types_by_name['SpillObjectsReply'] +_RESTORESPILLEDOBJECTSREQUEST = DESCRIPTOR.message_types_by_name['RestoreSpilledObjectsRequest'] +_RESTORESPILLEDOBJECTSREPLY = DESCRIPTOR.message_types_by_name['RestoreSpilledObjectsReply'] +_DELETESPILLEDOBJECTSREQUEST = DESCRIPTOR.message_types_by_name['DeleteSpilledObjectsRequest'] +_DELETESPILLEDOBJECTSREPLY = DESCRIPTOR.message_types_by_name['DeleteSpilledObjectsReply'] +_EXITREQUEST = DESCRIPTOR.message_types_by_name['ExitRequest'] +_EXITREPLY = DESCRIPTOR.message_types_by_name['ExitReply'] +_ASSIGNOBJECTOWNERREQUEST = DESCRIPTOR.message_types_by_name['AssignObjectOwnerRequest'] +_ASSIGNOBJECTOWNERREPLY = DESCRIPTOR.message_types_by_name['AssignObjectOwnerReply'] +_RAYLETNOTIFYGCSRESTARTREQUEST = DESCRIPTOR.message_types_by_name['RayletNotifyGCSRestartRequest'] +_RAYLETNOTIFYGCSRESTARTREPLY = DESCRIPTOR.message_types_by_name['RayletNotifyGCSRestartReply'] +_NUMPENDINGTASKSREQUEST = DESCRIPTOR.message_types_by_name['NumPendingTasksRequest'] +_NUMPENDINGTASKSREPLY = DESCRIPTOR.message_types_by_name['NumPendingTasksReply'] +_REPORTGENERATORITEMRETURNSREQUEST = DESCRIPTOR.message_types_by_name['ReportGeneratorItemReturnsRequest'] +_REPORTGENERATORITEMRETURNSREPLY = DESCRIPTOR.message_types_by_name['ReportGeneratorItemReturnsReply'] +_REGISTERMUTABLEOBJECTREADERREQUEST = DESCRIPTOR.message_types_by_name['RegisterMutableObjectReaderRequest'] +_REGISTERMUTABLEOBJECTREADERREPLY = DESCRIPTOR.message_types_by_name['RegisterMutableObjectReaderReply'] +_GETOBJECTSTATUSREPLY_OBJECTSTATUS = _GETOBJECTSTATUSREPLY.enum_types_by_name['ObjectStatus'] +ActiveObjectIDs = _reflection.GeneratedProtocolMessageType('ActiveObjectIDs', (_message.Message,), { + 'DESCRIPTOR' : _ACTIVEOBJECTIDS, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActiveObjectIDs) + }) +_sym_db.RegisterMessage(ActiveObjectIDs) + +ActorHandle = _reflection.GeneratedProtocolMessageType('ActorHandle', (_message.Message,), { + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORHANDLE_LABELSENTRY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorHandle.LabelsEntry) + }) + , + 'DESCRIPTOR' : _ACTORHANDLE, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorHandle) + }) +_sym_db.RegisterMessage(ActorHandle) +_sym_db.RegisterMessage(ActorHandle.LabelsEntry) + +PushTaskRequest = _reflection.GeneratedProtocolMessageType('PushTaskRequest', (_message.Message,), { + 'DESCRIPTOR' : _PUSHTASKREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PushTaskRequest) + }) +_sym_db.RegisterMessage(PushTaskRequest) + +PushTaskReply = _reflection.GeneratedProtocolMessageType('PushTaskReply', (_message.Message,), { + 'DESCRIPTOR' : _PUSHTASKREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PushTaskReply) + }) +_sym_db.RegisterMessage(PushTaskReply) + +ActorCallArgWaitCompleteRequest = _reflection.GeneratedProtocolMessageType('ActorCallArgWaitCompleteRequest', (_message.Message,), { + 'DESCRIPTOR' : _ACTORCALLARGWAITCOMPLETEREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorCallArgWaitCompleteRequest) + }) +_sym_db.RegisterMessage(ActorCallArgWaitCompleteRequest) + +ActorCallArgWaitCompleteReply = _reflection.GeneratedProtocolMessageType('ActorCallArgWaitCompleteReply', (_message.Message,), { + 'DESCRIPTOR' : _ACTORCALLARGWAITCOMPLETEREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorCallArgWaitCompleteReply) + }) +_sym_db.RegisterMessage(ActorCallArgWaitCompleteReply) + +GetObjectStatusRequest = _reflection.GeneratedProtocolMessageType('GetObjectStatusRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTSTATUSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectStatusRequest) + }) +_sym_db.RegisterMessage(GetObjectStatusRequest) + +RayObject = _reflection.GeneratedProtocolMessageType('RayObject', (_message.Message,), { + 'DESCRIPTOR' : _RAYOBJECT, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RayObject) + }) +_sym_db.RegisterMessage(RayObject) + +GetObjectStatusReply = _reflection.GeneratedProtocolMessageType('GetObjectStatusReply', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTSTATUSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectStatusReply) + }) +_sym_db.RegisterMessage(GetObjectStatusReply) + +WaitForActorRefDeletedRequest = _reflection.GeneratedProtocolMessageType('WaitForActorRefDeletedRequest', (_message.Message,), { + 'DESCRIPTOR' : _WAITFORACTORREFDELETEDREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitForActorRefDeletedRequest) + }) +_sym_db.RegisterMessage(WaitForActorRefDeletedRequest) + +WaitForActorRefDeletedReply = _reflection.GeneratedProtocolMessageType('WaitForActorRefDeletedReply', (_message.Message,), { + 'DESCRIPTOR' : _WAITFORACTORREFDELETEDREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitForActorRefDeletedReply) + }) +_sym_db.RegisterMessage(WaitForActorRefDeletedReply) + +UpdateObjectLocationBatchRequest = _reflection.GeneratedProtocolMessageType('UpdateObjectLocationBatchRequest', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEOBJECTLOCATIONBATCHREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateObjectLocationBatchRequest) + }) +_sym_db.RegisterMessage(UpdateObjectLocationBatchRequest) + +UpdateObjectLocationBatchReply = _reflection.GeneratedProtocolMessageType('UpdateObjectLocationBatchReply', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEOBJECTLOCATIONBATCHREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateObjectLocationBatchReply) + }) +_sym_db.RegisterMessage(UpdateObjectLocationBatchReply) + +ObjectSpilledLocationUpdate = _reflection.GeneratedProtocolMessageType('ObjectSpilledLocationUpdate', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTSPILLEDLOCATIONUPDATE, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectSpilledLocationUpdate) + }) +_sym_db.RegisterMessage(ObjectSpilledLocationUpdate) + +ObjectLocationUpdate = _reflection.GeneratedProtocolMessageType('ObjectLocationUpdate', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTLOCATIONUPDATE, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectLocationUpdate) + }) +_sym_db.RegisterMessage(ObjectLocationUpdate) + +GetObjectLocationsOwnerRequest = _reflection.GeneratedProtocolMessageType('GetObjectLocationsOwnerRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTLOCATIONSOWNERREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectLocationsOwnerRequest) + }) +_sym_db.RegisterMessage(GetObjectLocationsOwnerRequest) + +GetObjectLocationsOwnerReply = _reflection.GeneratedProtocolMessageType('GetObjectLocationsOwnerReply', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTLOCATIONSOWNERREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectLocationsOwnerReply) + }) +_sym_db.RegisterMessage(GetObjectLocationsOwnerReply) + +KillActorRequest = _reflection.GeneratedProtocolMessageType('KillActorRequest', (_message.Message,), { + 'DESCRIPTOR' : _KILLACTORREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillActorRequest) + }) +_sym_db.RegisterMessage(KillActorRequest) + +KillActorReply = _reflection.GeneratedProtocolMessageType('KillActorReply', (_message.Message,), { + 'DESCRIPTOR' : _KILLACTORREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillActorReply) + }) +_sym_db.RegisterMessage(KillActorReply) + +CancelTaskRequest = _reflection.GeneratedProtocolMessageType('CancelTaskRequest', (_message.Message,), { + 'DESCRIPTOR' : _CANCELTASKREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelTaskRequest) + }) +_sym_db.RegisterMessage(CancelTaskRequest) + +CancelTaskReply = _reflection.GeneratedProtocolMessageType('CancelTaskReply', (_message.Message,), { + 'DESCRIPTOR' : _CANCELTASKREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelTaskReply) + }) +_sym_db.RegisterMessage(CancelTaskReply) + +CancelRemoteTaskRequest = _reflection.GeneratedProtocolMessageType('CancelRemoteTaskRequest', (_message.Message,), { + 'DESCRIPTOR' : _CANCELREMOTETASKREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelRemoteTaskRequest) + }) +_sym_db.RegisterMessage(CancelRemoteTaskRequest) + +CancelRemoteTaskReply = _reflection.GeneratedProtocolMessageType('CancelRemoteTaskReply', (_message.Message,), { + 'DESCRIPTOR' : _CANCELREMOTETASKREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelRemoteTaskReply) + }) +_sym_db.RegisterMessage(CancelRemoteTaskReply) + +GetCoreWorkerStatsRequest = _reflection.GeneratedProtocolMessageType('GetCoreWorkerStatsRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETCOREWORKERSTATSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetCoreWorkerStatsRequest) + }) +_sym_db.RegisterMessage(GetCoreWorkerStatsRequest) + +GetCoreWorkerStatsReply = _reflection.GeneratedProtocolMessageType('GetCoreWorkerStatsReply', (_message.Message,), { + 'DESCRIPTOR' : _GETCOREWORKERSTATSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetCoreWorkerStatsReply) + }) +_sym_db.RegisterMessage(GetCoreWorkerStatsReply) + +LocalGCRequest = _reflection.GeneratedProtocolMessageType('LocalGCRequest', (_message.Message,), { + 'DESCRIPTOR' : _LOCALGCREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LocalGCRequest) + }) +_sym_db.RegisterMessage(LocalGCRequest) + +LocalGCReply = _reflection.GeneratedProtocolMessageType('LocalGCReply', (_message.Message,), { + 'DESCRIPTOR' : _LOCALGCREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LocalGCReply) + }) +_sym_db.RegisterMessage(LocalGCReply) + +PlasmaObjectReadyRequest = _reflection.GeneratedProtocolMessageType('PlasmaObjectReadyRequest', (_message.Message,), { + 'DESCRIPTOR' : _PLASMAOBJECTREADYREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlasmaObjectReadyRequest) + }) +_sym_db.RegisterMessage(PlasmaObjectReadyRequest) + +PlasmaObjectReadyReply = _reflection.GeneratedProtocolMessageType('PlasmaObjectReadyReply', (_message.Message,), { + 'DESCRIPTOR' : _PLASMAOBJECTREADYREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlasmaObjectReadyReply) + }) +_sym_db.RegisterMessage(PlasmaObjectReadyReply) + +DeleteObjectsRequest = _reflection.GeneratedProtocolMessageType('DeleteObjectsRequest', (_message.Message,), { + 'DESCRIPTOR' : _DELETEOBJECTSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteObjectsRequest) + }) +_sym_db.RegisterMessage(DeleteObjectsRequest) + +DeleteObjectsReply = _reflection.GeneratedProtocolMessageType('DeleteObjectsReply', (_message.Message,), { + 'DESCRIPTOR' : _DELETEOBJECTSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteObjectsReply) + }) +_sym_db.RegisterMessage(DeleteObjectsReply) + +SpillObjectsRequest = _reflection.GeneratedProtocolMessageType('SpillObjectsRequest', (_message.Message,), { + 'DESCRIPTOR' : _SPILLOBJECTSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SpillObjectsRequest) + }) +_sym_db.RegisterMessage(SpillObjectsRequest) + +SpillObjectsReply = _reflection.GeneratedProtocolMessageType('SpillObjectsReply', (_message.Message,), { + 'DESCRIPTOR' : _SPILLOBJECTSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SpillObjectsReply) + }) +_sym_db.RegisterMessage(SpillObjectsReply) + +RestoreSpilledObjectsRequest = _reflection.GeneratedProtocolMessageType('RestoreSpilledObjectsRequest', (_message.Message,), { + 'DESCRIPTOR' : _RESTORESPILLEDOBJECTSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RestoreSpilledObjectsRequest) + }) +_sym_db.RegisterMessage(RestoreSpilledObjectsRequest) + +RestoreSpilledObjectsReply = _reflection.GeneratedProtocolMessageType('RestoreSpilledObjectsReply', (_message.Message,), { + 'DESCRIPTOR' : _RESTORESPILLEDOBJECTSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RestoreSpilledObjectsReply) + }) +_sym_db.RegisterMessage(RestoreSpilledObjectsReply) + +DeleteSpilledObjectsRequest = _reflection.GeneratedProtocolMessageType('DeleteSpilledObjectsRequest', (_message.Message,), { + 'DESCRIPTOR' : _DELETESPILLEDOBJECTSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteSpilledObjectsRequest) + }) +_sym_db.RegisterMessage(DeleteSpilledObjectsRequest) + +DeleteSpilledObjectsReply = _reflection.GeneratedProtocolMessageType('DeleteSpilledObjectsReply', (_message.Message,), { + 'DESCRIPTOR' : _DELETESPILLEDOBJECTSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteSpilledObjectsReply) + }) +_sym_db.RegisterMessage(DeleteSpilledObjectsReply) + +ExitRequest = _reflection.GeneratedProtocolMessageType('ExitRequest', (_message.Message,), { + 'DESCRIPTOR' : _EXITREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExitRequest) + }) +_sym_db.RegisterMessage(ExitRequest) + +ExitReply = _reflection.GeneratedProtocolMessageType('ExitReply', (_message.Message,), { + 'DESCRIPTOR' : _EXITREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExitReply) + }) +_sym_db.RegisterMessage(ExitReply) + +AssignObjectOwnerRequest = _reflection.GeneratedProtocolMessageType('AssignObjectOwnerRequest', (_message.Message,), { + 'DESCRIPTOR' : _ASSIGNOBJECTOWNERREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AssignObjectOwnerRequest) + }) +_sym_db.RegisterMessage(AssignObjectOwnerRequest) + +AssignObjectOwnerReply = _reflection.GeneratedProtocolMessageType('AssignObjectOwnerReply', (_message.Message,), { + 'DESCRIPTOR' : _ASSIGNOBJECTOWNERREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AssignObjectOwnerReply) + }) +_sym_db.RegisterMessage(AssignObjectOwnerReply) + +RayletNotifyGCSRestartRequest = _reflection.GeneratedProtocolMessageType('RayletNotifyGCSRestartRequest', (_message.Message,), { + 'DESCRIPTOR' : _RAYLETNOTIFYGCSRESTARTREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RayletNotifyGCSRestartRequest) + }) +_sym_db.RegisterMessage(RayletNotifyGCSRestartRequest) + +RayletNotifyGCSRestartReply = _reflection.GeneratedProtocolMessageType('RayletNotifyGCSRestartReply', (_message.Message,), { + 'DESCRIPTOR' : _RAYLETNOTIFYGCSRESTARTREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RayletNotifyGCSRestartReply) + }) +_sym_db.RegisterMessage(RayletNotifyGCSRestartReply) + +NumPendingTasksRequest = _reflection.GeneratedProtocolMessageType('NumPendingTasksRequest', (_message.Message,), { + 'DESCRIPTOR' : _NUMPENDINGTASKSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NumPendingTasksRequest) + }) +_sym_db.RegisterMessage(NumPendingTasksRequest) + +NumPendingTasksReply = _reflection.GeneratedProtocolMessageType('NumPendingTasksReply', (_message.Message,), { + 'DESCRIPTOR' : _NUMPENDINGTASKSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NumPendingTasksReply) + }) +_sym_db.RegisterMessage(NumPendingTasksReply) + +ReportGeneratorItemReturnsRequest = _reflection.GeneratedProtocolMessageType('ReportGeneratorItemReturnsRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTGENERATORITEMRETURNSREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportGeneratorItemReturnsRequest) + }) +_sym_db.RegisterMessage(ReportGeneratorItemReturnsRequest) + +ReportGeneratorItemReturnsReply = _reflection.GeneratedProtocolMessageType('ReportGeneratorItemReturnsReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTGENERATORITEMRETURNSREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportGeneratorItemReturnsReply) + }) +_sym_db.RegisterMessage(ReportGeneratorItemReturnsReply) + +RegisterMutableObjectReaderRequest = _reflection.GeneratedProtocolMessageType('RegisterMutableObjectReaderRequest', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERMUTABLEOBJECTREADERREQUEST, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterMutableObjectReaderRequest) + }) +_sym_db.RegisterMessage(RegisterMutableObjectReaderRequest) + +RegisterMutableObjectReaderReply = _reflection.GeneratedProtocolMessageType('RegisterMutableObjectReaderReply', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERMUTABLEOBJECTREADERREPLY, + '__module__' : 'src.ray.protobuf.core_worker_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterMutableObjectReaderReply) + }) +_sym_db.RegisterMessage(RegisterMutableObjectReaderReply) + +_COREWORKERSERVICE = DESCRIPTOR.services_by_name['CoreWorkerService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _ACTORHANDLE_LABELSENTRY._options = None + _ACTORHANDLE_LABELSENTRY._serialized_options = b'8\001' + _OBJECTPLASMALOCATIONUPDATE._serialized_start=6625 + _OBJECTPLASMALOCATIONUPDATE._serialized_end=6677 + _ACTIVEOBJECTIDS._serialized_start=109 + _ACTIVEOBJECTIDS._serialized_end=157 + _ACTORHANDLE._serialized_start=160 + _ACTORHANDLE._serialized_end=1028 + _ACTORHANDLE_LABELSENTRY._serialized_start=971 + _ACTORHANDLE_LABELSENTRY._serialized_end=1028 + _PUSHTASKREQUEST._serialized_start=1031 + _PUSHTASKREQUEST._serialized_end=1306 + _PUSHTASKREPLY._serialized_start=1309 + _PUSHTASKREPLY._serialized_end=1956 + _ACTORCALLARGWAITCOMPLETEREQUEST._serialized_start=1958 + _ACTORCALLARGWAITCOMPLETEREQUEST._serialized_end=2055 + _ACTORCALLARGWAITCOMPLETEREPLY._serialized_start=2057 + _ACTORCALLARGWAITCOMPLETEREPLY._serialized_end=2088 + _GETOBJECTSTATUSREQUEST._serialized_start=2090 + _GETOBJECTSTATUSREQUEST._serialized_end=2183 + _RAYOBJECT._serialized_start=2186 + _RAYOBJECT._serialized_end=2319 + _GETOBJECTSTATUSREPLY._serialized_start=2322 + _GETOBJECTSTATUSREPLY._serialized_end=2574 + _GETOBJECTSTATUSREPLY_OBJECTSTATUS._serialized_start=2518 + _GETOBJECTSTATUSREPLY_OBJECTSTATUS._serialized_end=2574 + _WAITFORACTORREFDELETEDREQUEST._serialized_start=2576 + _WAITFORACTORREFDELETEDREQUEST._serialized_end=2680 + _WAITFORACTORREFDELETEDREPLY._serialized_start=2682 + _WAITFORACTORREFDELETEDREPLY._serialized_end=2711 + _UPDATEOBJECTLOCATIONBATCHREQUEST._serialized_start=2714 + _UPDATEOBJECTLOCATIONBATCHREQUEST._serialized_end=2906 + _UPDATEOBJECTLOCATIONBATCHREPLY._serialized_start=2908 + _UPDATEOBJECTLOCATIONBATCHREPLY._serialized_end=2940 + _OBJECTSPILLEDLOCATIONUPDATE._serialized_start=2942 + _OBJECTSPILLEDLOCATIONUPDATE._serialized_end=3061 + _OBJECTLOCATIONUPDATE._serialized_start=3064 + _OBJECTLOCATIONUPDATE._serialized_end=3422 + _GETOBJECTLOCATIONSOWNERREQUEST._serialized_start=3424 + _GETOBJECTLOCATIONSOWNERREQUEST._serialized_end=3533 + _GETOBJECTLOCATIONSOWNERREPLY._serialized_start=3535 + _GETOBJECTLOCATIONSOWNERREPLY._serialized_end=3659 + _KILLACTORREQUEST._serialized_start=3662 + _KILLACTORREQUEST._serialized_end=3814 + _KILLACTORREPLY._serialized_start=3816 + _KILLACTORREPLY._serialized_end=3832 + _CANCELTASKREQUEST._serialized_start=3835 + _CANCELTASKREQUEST._serialized_end=3999 + _CANCELTASKREPLY._serialized_start=4001 + _CANCELTASKREPLY._serialized_end=4117 + _CANCELREMOTETASKREQUEST._serialized_start=4120 + _CANCELREMOTETASKREQUEST._serialized_end=4248 + _CANCELREMOTETASKREPLY._serialized_start=4250 + _CANCELREMOTETASKREPLY._serialized_end=4273 + _GETCOREWORKERSTATSREQUEST._serialized_start=4276 + _GETCOREWORKERSTATSREQUEST._serialized_end=4478 + _GETCOREWORKERSTATSREPLY._serialized_start=4481 + _GETCOREWORKERSTATSREPLY._serialized_end=4730 + _LOCALGCREQUEST._serialized_start=4732 + _LOCALGCREQUEST._serialized_end=4801 + _LOCALGCREPLY._serialized_start=4803 + _LOCALGCREPLY._serialized_end=4817 + _PLASMAOBJECTREADYREQUEST._serialized_start=4819 + _PLASMAOBJECTREADYREQUEST._serialized_end=4874 + _PLASMAOBJECTREADYREPLY._serialized_start=4876 + _PLASMAOBJECTREADYREPLY._serialized_end=4900 + _DELETEOBJECTSREQUEST._serialized_start=4902 + _DELETEOBJECTSREQUEST._serialized_end=4986 + _DELETEOBJECTSREPLY._serialized_start=4988 + _DELETEOBJECTSREPLY._serialized_end=5008 + _SPILLOBJECTSREQUEST._serialized_start=5011 + _SPILLOBJECTSREQUEST._serialized_end=5177 + _SPILLOBJECTSREPLY._serialized_start=5179 + _SPILLOBJECTSREPLY._serialized_end=5246 + _RESTORESPILLEDOBJECTSREQUEST._serialized_start=5249 + _RESTORESPILLEDOBJECTSREQUEST._serialized_end=5378 + _RESTORESPILLEDOBJECTSREPLY._serialized_start=5380 + _RESTORESPILLEDOBJECTSREPLY._serialized_end=5458 + _DELETESPILLEDOBJECTSREQUEST._serialized_start=5460 + _DELETESPILLEDOBJECTSREQUEST._serialized_end=5537 + _DELETESPILLEDOBJECTSREPLY._serialized_start=5539 + _DELETESPILLEDOBJECTSREPLY._serialized_end=5566 + _EXITREQUEST._serialized_start=5568 + _EXITREQUEST._serialized_end=5612 + _EXITREPLY._serialized_start=5614 + _EXITREPLY._serialized_end=5651 + _ASSIGNOBJECTOWNERREQUEST._serialized_start=5654 + _ASSIGNOBJECTOWNERREQUEST._serialized_end=5882 + _ASSIGNOBJECTOWNERREPLY._serialized_start=5884 + _ASSIGNOBJECTOWNERREPLY._serialized_end=5908 + _RAYLETNOTIFYGCSRESTARTREQUEST._serialized_start=5910 + _RAYLETNOTIFYGCSRESTARTREQUEST._serialized_end=5941 + _RAYLETNOTIFYGCSRESTARTREPLY._serialized_start=5943 + _RAYLETNOTIFYGCSRESTARTREPLY._serialized_end=5972 + _NUMPENDINGTASKSREQUEST._serialized_start=5974 + _NUMPENDINGTASKSREQUEST._serialized_end=5998 + _NUMPENDINGTASKSREPLY._serialized_start=6000 + _NUMPENDINGTASKSREPLY._serialized_end=6066 + _REPORTGENERATORITEMRETURNSREQUEST._serialized_start=6069 + _REPORTGENERATORITEMRETURNSREQUEST._serialized_end=6337 + _REPORTGENERATORITEMRETURNSREPLY._serialized_start=6339 + _REPORTGENERATORITEMRETURNSREPLY._serialized_end=6431 + _REGISTERMUTABLEOBJECTREADERREQUEST._serialized_start=6434 + _REGISTERMUTABLEOBJECTREADERREQUEST._serialized_end=6587 + _REGISTERMUTABLEOBJECTREADERREPLY._serialized_start=6589 + _REGISTERMUTABLEOBJECTREADERREPLY._serialized_end=6623 + _COREWORKERSERVICE._serialized_start=6680 + _COREWORKERSERVICE._serialized_end=8829 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..54769f953151f245047c51b27e7d89cdd3d773a0 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/core_worker_pb2_grpc.py @@ -0,0 +1,826 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import core_worker_pb2 as src_dot_ray_dot_protobuf_dot_core__worker__pb2 +from . import pubsub_pb2 as src_dot_ray_dot_protobuf_dot_pubsub__pb2 + + +class CoreWorkerServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.RayletNotifyGCSRestart = channel.unary_unary( + '/ray.rpc.CoreWorkerService/RayletNotifyGCSRestart', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartReply.FromString, + ) + self.PushTask = channel.unary_unary( + '/ray.rpc.CoreWorkerService/PushTask', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskReply.FromString, + ) + self.ActorCallArgWaitComplete = channel.unary_unary( + '/ray.rpc.CoreWorkerService/ActorCallArgWaitComplete', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteReply.FromString, + ) + self.GetObjectStatus = channel.unary_unary( + '/ray.rpc.CoreWorkerService/GetObjectStatus', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusReply.FromString, + ) + self.WaitForActorRefDeleted = channel.unary_unary( + '/ray.rpc.CoreWorkerService/WaitForActorRefDeleted', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedReply.FromString, + ) + self.PubsubLongPolling = channel.unary_unary( + '/ray.rpc.CoreWorkerService/PubsubLongPolling', + request_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.FromString, + ) + self.ReportGeneratorItemReturns = channel.unary_unary( + '/ray.rpc.CoreWorkerService/ReportGeneratorItemReturns', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsReply.FromString, + ) + self.PubsubCommandBatch = channel.unary_unary( + '/ray.rpc.CoreWorkerService/PubsubCommandBatch', + request_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.FromString, + ) + self.UpdateObjectLocationBatch = channel.unary_unary( + '/ray.rpc.CoreWorkerService/UpdateObjectLocationBatch', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchReply.FromString, + ) + self.GetObjectLocationsOwner = channel.unary_unary( + '/ray.rpc.CoreWorkerService/GetObjectLocationsOwner', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerReply.FromString, + ) + self.KillActor = channel.unary_unary( + '/ray.rpc.CoreWorkerService/KillActor', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorReply.FromString, + ) + self.CancelTask = channel.unary_unary( + '/ray.rpc.CoreWorkerService/CancelTask', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskReply.FromString, + ) + self.CancelRemoteTask = channel.unary_unary( + '/ray.rpc.CoreWorkerService/CancelRemoteTask', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskReply.FromString, + ) + self.GetCoreWorkerStats = channel.unary_unary( + '/ray.rpc.CoreWorkerService/GetCoreWorkerStats', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsReply.FromString, + ) + self.LocalGC = channel.unary_unary( + '/ray.rpc.CoreWorkerService/LocalGC', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCReply.FromString, + ) + self.DeleteObjects = channel.unary_unary( + '/ray.rpc.CoreWorkerService/DeleteObjects', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsReply.FromString, + ) + self.SpillObjects = channel.unary_unary( + '/ray.rpc.CoreWorkerService/SpillObjects', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsReply.FromString, + ) + self.RestoreSpilledObjects = channel.unary_unary( + '/ray.rpc.CoreWorkerService/RestoreSpilledObjects', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsReply.FromString, + ) + self.DeleteSpilledObjects = channel.unary_unary( + '/ray.rpc.CoreWorkerService/DeleteSpilledObjects', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsReply.FromString, + ) + self.PlasmaObjectReady = channel.unary_unary( + '/ray.rpc.CoreWorkerService/PlasmaObjectReady', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyReply.FromString, + ) + self.Exit = channel.unary_unary( + '/ray.rpc.CoreWorkerService/Exit', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitReply.FromString, + ) + self.AssignObjectOwner = channel.unary_unary( + '/ray.rpc.CoreWorkerService/AssignObjectOwner', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerReply.FromString, + ) + self.NumPendingTasks = channel.unary_unary( + '/ray.rpc.CoreWorkerService/NumPendingTasks', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksReply.FromString, + ) + self.RegisterMutableObjectReader = channel.unary_unary( + '/ray.rpc.CoreWorkerService/RegisterMutableObjectReader', + request_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderReply.FromString, + ) + + +class CoreWorkerServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def RayletNotifyGCSRestart(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PushTask(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ActorCallArgWaitComplete(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetObjectStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WaitForActorRefDeleted(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PubsubLongPolling(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportGeneratorItemReturns(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PubsubCommandBatch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateObjectLocationBatch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetObjectLocationsOwner(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KillActor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CancelTask(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CancelRemoteTask(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCoreWorkerStats(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LocalGC(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteObjects(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SpillObjects(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RestoreSpilledObjects(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteSpilledObjects(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PlasmaObjectReady(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Exit(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AssignObjectOwner(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def NumPendingTasks(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterMutableObjectReader(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_CoreWorkerServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'RayletNotifyGCSRestart': grpc.unary_unary_rpc_method_handler( + servicer.RayletNotifyGCSRestart, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartReply.SerializeToString, + ), + 'PushTask': grpc.unary_unary_rpc_method_handler( + servicer.PushTask, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskReply.SerializeToString, + ), + 'ActorCallArgWaitComplete': grpc.unary_unary_rpc_method_handler( + servicer.ActorCallArgWaitComplete, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteReply.SerializeToString, + ), + 'GetObjectStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetObjectStatus, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusReply.SerializeToString, + ), + 'WaitForActorRefDeleted': grpc.unary_unary_rpc_method_handler( + servicer.WaitForActorRefDeleted, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedReply.SerializeToString, + ), + 'PubsubLongPolling': grpc.unary_unary_rpc_method_handler( + servicer.PubsubLongPolling, + request_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.SerializeToString, + ), + 'ReportGeneratorItemReturns': grpc.unary_unary_rpc_method_handler( + servicer.ReportGeneratorItemReturns, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsReply.SerializeToString, + ), + 'PubsubCommandBatch': grpc.unary_unary_rpc_method_handler( + servicer.PubsubCommandBatch, + request_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.SerializeToString, + ), + 'UpdateObjectLocationBatch': grpc.unary_unary_rpc_method_handler( + servicer.UpdateObjectLocationBatch, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchReply.SerializeToString, + ), + 'GetObjectLocationsOwner': grpc.unary_unary_rpc_method_handler( + servicer.GetObjectLocationsOwner, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerReply.SerializeToString, + ), + 'KillActor': grpc.unary_unary_rpc_method_handler( + servicer.KillActor, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorReply.SerializeToString, + ), + 'CancelTask': grpc.unary_unary_rpc_method_handler( + servicer.CancelTask, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskReply.SerializeToString, + ), + 'CancelRemoteTask': grpc.unary_unary_rpc_method_handler( + servicer.CancelRemoteTask, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskReply.SerializeToString, + ), + 'GetCoreWorkerStats': grpc.unary_unary_rpc_method_handler( + servicer.GetCoreWorkerStats, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsReply.SerializeToString, + ), + 'LocalGC': grpc.unary_unary_rpc_method_handler( + servicer.LocalGC, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCReply.SerializeToString, + ), + 'DeleteObjects': grpc.unary_unary_rpc_method_handler( + servicer.DeleteObjects, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsReply.SerializeToString, + ), + 'SpillObjects': grpc.unary_unary_rpc_method_handler( + servicer.SpillObjects, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsReply.SerializeToString, + ), + 'RestoreSpilledObjects': grpc.unary_unary_rpc_method_handler( + servicer.RestoreSpilledObjects, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsReply.SerializeToString, + ), + 'DeleteSpilledObjects': grpc.unary_unary_rpc_method_handler( + servicer.DeleteSpilledObjects, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsReply.SerializeToString, + ), + 'PlasmaObjectReady': grpc.unary_unary_rpc_method_handler( + servicer.PlasmaObjectReady, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyReply.SerializeToString, + ), + 'Exit': grpc.unary_unary_rpc_method_handler( + servicer.Exit, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitReply.SerializeToString, + ), + 'AssignObjectOwner': grpc.unary_unary_rpc_method_handler( + servicer.AssignObjectOwner, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerReply.SerializeToString, + ), + 'NumPendingTasks': grpc.unary_unary_rpc_method_handler( + servicer.NumPendingTasks, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksReply.SerializeToString, + ), + 'RegisterMutableObjectReader': grpc.unary_unary_rpc_method_handler( + servicer.RegisterMutableObjectReader, + request_deserializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.CoreWorkerService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class CoreWorkerService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def RayletNotifyGCSRestart(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/RayletNotifyGCSRestart', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RayletNotifyGCSRestartReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PushTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/PushTask', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.PushTaskReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ActorCallArgWaitComplete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/ActorCallArgWaitComplete', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ActorCallArgWaitCompleteReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetObjectStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/GetObjectStatus', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectStatusReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WaitForActorRefDeleted(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/WaitForActorRefDeleted', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.WaitForActorRefDeletedReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PubsubLongPolling(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/PubsubLongPolling', + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportGeneratorItemReturns(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/ReportGeneratorItemReturns', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ReportGeneratorItemReturnsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PubsubCommandBatch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/PubsubCommandBatch', + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateObjectLocationBatch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/UpdateObjectLocationBatch', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.UpdateObjectLocationBatchReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetObjectLocationsOwner(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/GetObjectLocationsOwner', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetObjectLocationsOwnerReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KillActor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/KillActor', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.KillActorReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CancelTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/CancelTask', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelTaskReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CancelRemoteTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/CancelRemoteTask', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.CancelRemoteTaskReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCoreWorkerStats(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/GetCoreWorkerStats', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.GetCoreWorkerStatsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LocalGC(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/LocalGC', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.LocalGCReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteObjects(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/DeleteObjects', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteObjectsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SpillObjects(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/SpillObjects', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.SpillObjectsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RestoreSpilledObjects(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/RestoreSpilledObjects', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RestoreSpilledObjectsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteSpilledObjects(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/DeleteSpilledObjects', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.DeleteSpilledObjectsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PlasmaObjectReady(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/PlasmaObjectReady', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.PlasmaObjectReadyReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Exit(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/Exit', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.ExitReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AssignObjectOwner(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/AssignObjectOwner', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.AssignObjectOwnerReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def NumPendingTasks(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/NumPendingTasks', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.NumPendingTasksReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RegisterMutableObjectReader(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.CoreWorkerService/RegisterMutableObjectReader', + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_core__worker__pb2.RegisterMutableObjectReaderReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/dependency_pb2.py b/lib/python3.12/site-packages/ray/core/generated/dependency_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..d917db33407d07f471f5069879183fb6471dab31 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/dependency_pb2.py @@ -0,0 +1,34 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/dependency.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!src/ray/protobuf/dependency.proto\x12\x07ray.rpc\"\"\n\x0ePythonFunction\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03keyb\x06proto3') + + + +_PYTHONFUNCTION = DESCRIPTOR.message_types_by_name['PythonFunction'] +PythonFunction = _reflection.GeneratedProtocolMessageType('PythonFunction', (_message.Message,), { + 'DESCRIPTOR' : _PYTHONFUNCTION, + '__module__' : 'src.ray.protobuf.dependency_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PythonFunction) + }) +_sym_db.RegisterMessage(PythonFunction) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _PYTHONFUNCTION._serialized_start=46 + _PYTHONFUNCTION._serialized_end=80 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/dependency_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/dependency_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/dependency_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..0228d9760b5e43d1271e48b1d5b8f34774714614 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/event_pb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1csrc/ray/protobuf/event.proto\x12\x07ray.rpc\"\xf1\x04\n\x05\x45vent\x12\x19\n\x08\x65vent_id\x18\x01 \x01(\tR\x07\x65ventId\x12:\n\x0bsource_type\x18\x02 \x01(\x0e\x32\x19.ray.rpc.Event.SourceTypeR\nsourceType\x12\'\n\x0fsource_hostname\x18\x03 \x01(\tR\x0esourceHostname\x12\x1d\n\nsource_pid\x18\x04 \x01(\x05R\tsourcePid\x12\x33\n\x08severity\x18\x05 \x01(\x0e\x32\x17.ray.rpc.Event.SeverityR\x08severity\x12\x14\n\x05label\x18\x06 \x01(\tR\x05label\x12\x18\n\x07message\x18\x07 \x01(\tR\x07message\x12\x1c\n\ttimestamp\x18\x08 \x01(\x03R\ttimestamp\x12\x45\n\rcustom_fields\x18\t \x03(\x0b\x32 .ray.rpc.Event.CustomFieldsEntryR\x0c\x63ustomFields\x1a?\n\x11\x43ustomFieldsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"o\n\nSourceType\x12\n\n\x06\x43OMMON\x10\x00\x12\x0f\n\x0b\x43ORE_WORKER\x10\x01\x12\x07\n\x03GCS\x10\x02\x12\n\n\x06RAYLET\x10\x03\x12\x15\n\x11\x43LUSTER_LIFECYCLE\x10\x04\x12\x0e\n\nAUTOSCALER\x10\x05\x12\x08\n\x04JOBS\x10\x06\"M\n\x08Severity\x12\x08\n\x04INFO\x10\x00\x12\x0b\n\x07WARNING\x10\x01\x12\t\n\x05\x45RROR\x10\x02\x12\t\n\x05\x46\x41TAL\x10\x03\x12\t\n\x05\x44\x45\x42UG\x10\x04\x12\t\n\x05TRACE\x10\x05\x62\x06proto3') + + + +_EVENT = DESCRIPTOR.message_types_by_name['Event'] +_EVENT_CUSTOMFIELDSENTRY = _EVENT.nested_types_by_name['CustomFieldsEntry'] +_EVENT_SOURCETYPE = _EVENT.enum_types_by_name['SourceType'] +_EVENT_SEVERITY = _EVENT.enum_types_by_name['Severity'] +Event = _reflection.GeneratedProtocolMessageType('Event', (_message.Message,), { + + 'CustomFieldsEntry' : _reflection.GeneratedProtocolMessageType('CustomFieldsEntry', (_message.Message,), { + 'DESCRIPTOR' : _EVENT_CUSTOMFIELDSENTRY, + '__module__' : 'src.ray.protobuf.event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Event.CustomFieldsEntry) + }) + , + 'DESCRIPTOR' : _EVENT, + '__module__' : 'src.ray.protobuf.event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Event) + }) +_sym_db.RegisterMessage(Event) +_sym_db.RegisterMessage(Event.CustomFieldsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EVENT_CUSTOMFIELDSENTRY._options = None + _EVENT_CUSTOMFIELDSENTRY._serialized_options = b'8\001' + _EVENT._serialized_start=42 + _EVENT._serialized_end=667 + _EVENT_CUSTOMFIELDSENTRY._serialized_start=412 + _EVENT_CUSTOMFIELDSENTRY._serialized_end=475 + _EVENT_SOURCETYPE._serialized_start=477 + _EVENT_SOURCETYPE._serialized_end=588 + _EVENT_SEVERITY._serialized_start=590 + _EVENT_SEVERITY._serialized_end=667 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..882113f6787cb289585b8462e606e51be579d242 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_actor_definition_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n;src/ray/protobuf/public/events_actor_definition_event.proto\x12\x0eray.rpc.events\"\xf9\x04\n\x14\x41\x63torDefinitionEvent\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x15\n\x06job_id\x18\x02 \x01(\x0cR\x05jobId\x12\x1f\n\x0bis_detached\x18\x03 \x01(\x08R\nisDetached\x12\x12\n\x04name\x18\x04 \x01(\tR\x04name\x12#\n\rray_namespace\x18\x05 \x01(\tR\x0crayNamespace\x12\x34\n\x16serialized_runtime_env\x18\x06 \x01(\tR\x14serializedRuntimeEnv\x12\x1d\n\nclass_name\x18\x07 \x01(\tR\tclassName\x12j\n\x12required_resources\x18\x08 \x03(\x0b\x32;.ray.rpc.events.ActorDefinitionEvent.RequiredResourcesEntryR\x11requiredResources\x12,\n\x12placement_group_id\x18\t \x01(\x0cR\x10placementGroupId\x12^\n\x0elabel_selector\x18\x0b \x03(\x0b\x32\x37.ray.rpc.events.ActorDefinitionEvent.LabelSelectorEntryR\rlabelSelector\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x62\x06proto3') + + + +_ACTORDEFINITIONEVENT = DESCRIPTOR.message_types_by_name['ActorDefinitionEvent'] +_ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY = _ACTORDEFINITIONEVENT.nested_types_by_name['RequiredResourcesEntry'] +_ACTORDEFINITIONEVENT_LABELSELECTORENTRY = _ACTORDEFINITIONEVENT.nested_types_by_name['LabelSelectorEntry'] +ActorDefinitionEvent = _reflection.GeneratedProtocolMessageType('ActorDefinitionEvent', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.public.events_actor_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorDefinitionEvent.RequiredResourcesEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORDEFINITIONEVENT_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.public.events_actor_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorDefinitionEvent.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _ACTORDEFINITIONEVENT, + '__module__' : 'src.ray.protobuf.public.events_actor_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorDefinitionEvent) + }) +_sym_db.RegisterMessage(ActorDefinitionEvent) +_sym_db.RegisterMessage(ActorDefinitionEvent.RequiredResourcesEntry) +_sym_db.RegisterMessage(ActorDefinitionEvent.LabelSelectorEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY._options = None + _ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _ACTORDEFINITIONEVENT_LABELSELECTORENTRY._options = None + _ACTORDEFINITIONEVENT_LABELSELECTORENTRY._serialized_options = b'8\001' + _ACTORDEFINITIONEVENT._serialized_start=80 + _ACTORDEFINITIONEVENT._serialized_end=713 + _ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_start=579 + _ACTORDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_end=647 + _ACTORDEFINITIONEVENT_LABELSELECTORENTRY._serialized_start=649 + _ACTORDEFINITIONEVENT_LABELSELECTORENTRY._serialized_end=713 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_definition_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..3028c4a3313280d47ff069e00ba6e46a6a9b4772 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_actor_lifecycle_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n:src/ray/protobuf/public/events_actor_lifecycle_event.proto\x12\x0eray.rpc.events\x1a\x1dsrc/ray/protobuf/common.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xf0\x03\n\x13\x41\x63torLifecycleEvent\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12`\n\x11state_transitions\x18\x02 \x03(\x0b\x32\x33.ray.rpc.events.ActorLifecycleEvent.StateTransitionR\x10stateTransitions\x1a\xfd\x01\n\x0fStateTransition\x12?\n\x05state\x18\x01 \x01(\x0e\x32).ray.rpc.events.ActorLifecycleEvent.StateR\x05state\x12\x38\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12\x17\n\x07node_id\x18\x03 \x01(\x0cR\x06nodeId\x12\x1b\n\tworker_id\x18\x04 \x01(\x0cR\x08workerId\x12\x39\n\x0b\x64\x65\x61th_cause\x18\x06 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseR\ndeathCause\"\\\n\x05State\x12\x18\n\x14\x44\x45PENDENCIES_UNREADY\x10\x00\x12\x14\n\x10PENDING_CREATION\x10\x01\x12\t\n\x05\x41LIVE\x10\x02\x12\x0e\n\nRESTARTING\x10\x03\x12\x08\n\x04\x44\x45\x41\x44\x10\x04\x62\x06proto3') + + + +_ACTORLIFECYCLEEVENT = DESCRIPTOR.message_types_by_name['ActorLifecycleEvent'] +_ACTORLIFECYCLEEVENT_STATETRANSITION = _ACTORLIFECYCLEEVENT.nested_types_by_name['StateTransition'] +_ACTORLIFECYCLEEVENT_STATE = _ACTORLIFECYCLEEVENT.enum_types_by_name['State'] +ActorLifecycleEvent = _reflection.GeneratedProtocolMessageType('ActorLifecycleEvent', (_message.Message,), { + + 'StateTransition' : _reflection.GeneratedProtocolMessageType('StateTransition', (_message.Message,), { + 'DESCRIPTOR' : _ACTORLIFECYCLEEVENT_STATETRANSITION, + '__module__' : 'src.ray.protobuf.public.events_actor_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorLifecycleEvent.StateTransition) + }) + , + 'DESCRIPTOR' : _ACTORLIFECYCLEEVENT, + '__module__' : 'src.ray.protobuf.public.events_actor_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorLifecycleEvent) + }) +_sym_db.RegisterMessage(ActorLifecycleEvent) +_sym_db.RegisterMessage(ActorLifecycleEvent.StateTransition) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _ACTORLIFECYCLEEVENT._serialized_start=143 + _ACTORLIFECYCLEEVENT._serialized_end=639 + _ACTORLIFECYCLEEVENT_STATETRANSITION._serialized_start=292 + _ACTORLIFECYCLEEVENT_STATETRANSITION._serialized_end=545 + _ACTORLIFECYCLEEVENT_STATE._serialized_start=547 + _ACTORLIFECYCLEEVENT_STATE._serialized_end=639 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_lifecycle_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..caf33bb14258f1f5e81c35e8abd5b106c6b38eba --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_actor_task_definition_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import runtime_environment_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_runtime__environment__pb2 +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n@src/ray/protobuf/public/events_actor_task_definition_event.proto\x12\x0eray.rpc.events\x1a\x31src/ray/protobuf/public/runtime_environment.proto\x1a\x1dsrc/ray/protobuf/common.proto\"\xfd\x05\n\x18\x41\x63torTaskDefinitionEvent\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12!\n\x0ctask_attempt\x18\x02 \x01(\x05R\x0btaskAttempt\x12-\n\x08language\x18\x03 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12:\n\nactor_func\x18\x04 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\tactorFunc\x12&\n\x0f\x61\x63tor_task_name\x18\x05 \x01(\tR\ractorTaskName\x12n\n\x12required_resources\x18\x06 \x03(\x0b\x32?.ray.rpc.events.ActorTaskDefinitionEvent.RequiredResourcesEntryR\x11requiredResources\x12\x15\n\x06job_id\x18\x08 \x01(\x0cR\x05jobId\x12\x19\n\x08\x61\x63tor_id\x18\t \x01(\x0cR\x07\x61\x63torId\x12$\n\x0eparent_task_id\x18\n \x01(\x0cR\x0cparentTaskId\x12,\n\x12placement_group_id\x18\x0b \x01(\x0cR\x10placementGroupId\x12M\n\x07ref_ids\x18\x0c \x03(\x0b\x32\x34.ray.rpc.events.ActorTaskDefinitionEvent.RefIdsEntryR\x06refIds\x12\x34\n\x16serialized_runtime_env\x18\r \x01(\tR\x14serializedRuntimeEnv\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bRefIdsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value:\x02\x38\x01J\x04\x08\x07\x10\x08R\x10runtime_env_infob\x06proto3') + + + +_ACTORTASKDEFINITIONEVENT = DESCRIPTOR.message_types_by_name['ActorTaskDefinitionEvent'] +_ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY = _ACTORTASKDEFINITIONEVENT.nested_types_by_name['RequiredResourcesEntry'] +_ACTORTASKDEFINITIONEVENT_REFIDSENTRY = _ACTORTASKDEFINITIONEVENT.nested_types_by_name['RefIdsEntry'] +ActorTaskDefinitionEvent = _reflection.GeneratedProtocolMessageType('ActorTaskDefinitionEvent', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.public.events_actor_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorTaskDefinitionEvent.RequiredResourcesEntry) + }) + , + + 'RefIdsEntry' : _reflection.GeneratedProtocolMessageType('RefIdsEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORTASKDEFINITIONEVENT_REFIDSENTRY, + '__module__' : 'src.ray.protobuf.public.events_actor_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorTaskDefinitionEvent.RefIdsEntry) + }) + , + 'DESCRIPTOR' : _ACTORTASKDEFINITIONEVENT, + '__module__' : 'src.ray.protobuf.public.events_actor_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.ActorTaskDefinitionEvent) + }) +_sym_db.RegisterMessage(ActorTaskDefinitionEvent) +_sym_db.RegisterMessage(ActorTaskDefinitionEvent.RequiredResourcesEntry) +_sym_db.RegisterMessage(ActorTaskDefinitionEvent.RefIdsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._options = None + _ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _ACTORTASKDEFINITIONEVENT_REFIDSENTRY._options = None + _ACTORTASKDEFINITIONEVENT_REFIDSENTRY._serialized_options = b'8\001' + _ACTORTASKDEFINITIONEVENT._serialized_start=167 + _ACTORTASKDEFINITIONEVENT._serialized_end=932 + _ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_start=781 + _ACTORTASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_end=849 + _ACTORTASKDEFINITIONEVENT_REFIDSENTRY._serialized_start=851 + _ACTORTASKDEFINITIONEVENT_REFIDSENTRY._serialized_end=908 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_actor_task_definition_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..bd2401d76c2c9d3f60084266b7b4e3dd70882930 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_base_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from . import events_task_profile_events_pb2 as src_dot_ray_dot_protobuf_dot_events__task__profile__events__pb2 +from . import events_actor_task_definition_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__actor__task__definition__event__pb2 +from . import events_task_definition_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__task__definition__event__pb2 +from . import events_task_lifecycle_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__task__lifecycle__event__pb2 +from . import events_driver_job_definition_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__driver__job__definition__event__pb2 +from . import events_driver_job_lifecycle_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__driver__job__lifecycle__event__pb2 +from . import events_actor_definition_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__actor__definition__event__pb2 +from . import events_actor_lifecycle_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__actor__lifecycle__event__pb2 +from . import events_node_definition_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__node__definition__event__pb2 +from . import events_node_lifecycle_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__node__lifecycle__event__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n/src/ray/protobuf/public/events_base_event.proto\x12\x0eray.rpc.events\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x31src/ray/protobuf/events_task_profile_events.proto\x1a@src/ray/protobuf/public/events_actor_task_definition_event.proto\x1a:src/ray/protobuf/public/events_task_definition_event.proto\x1a\x39src/ray/protobuf/public/events_task_lifecycle_event.proto\x1a@src/ray/protobuf/public/events_driver_job_definition_event.proto\x1a?src/ray/protobuf/public/events_driver_job_lifecycle_event.proto\x1a;src/ray/protobuf/public/events_actor_definition_event.proto\x1a:src/ray/protobuf/public/events_actor_lifecycle_event.proto\x1a:src/ray/protobuf/public/events_node_definition_event.proto\x1a\x39src/ray/protobuf/public/events_node_lifecycle_event.proto\"\xb9\x0e\n\x08RayEvent\x12\x19\n\x08\x65vent_id\x18\x01 \x01(\x0cR\x07\x65ventId\x12\x44\n\x0bsource_type\x18\x02 \x01(\x0e\x32#.ray.rpc.events.RayEvent.SourceTypeR\nsourceType\x12\x41\n\nevent_type\x18\x03 \x01(\x0e\x32\".ray.rpc.events.RayEvent.EventTypeR\teventType\x12\x38\n\ttimestamp\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12=\n\x08severity\x18\x05 \x01(\x0e\x32!.ray.rpc.events.RayEvent.SeverityR\x08severity\x12\x18\n\x07message\x18\x06 \x01(\tR\x07message\x12!\n\x0csession_name\x18\x07 \x01(\tR\x0bsessionName\x12W\n\x15task_definition_event\x18\x08 \x01(\x0b\x32#.ray.rpc.events.TaskDefinitionEventR\x13taskDefinitionEvent\x12T\n\x14task_lifecycle_event\x18\t \x01(\x0b\x32\".ray.rpc.events.TaskLifecycleEventR\x12taskLifecycleEvent\x12g\n\x1b\x61\x63tor_task_definition_event\x18\n \x01(\x0b\x32(.ray.rpc.events.ActorTaskDefinitionEventR\x18\x61\x63torTaskDefinitionEvent\x12Q\n\x13task_profile_events\x18\x0b \x01(\x0b\x32!.ray.rpc.events.TaskProfileEventsR\x11taskProfileEvents\x12g\n\x1b\x64river_job_definition_event\x18\x0c \x01(\x0b\x32(.ray.rpc.events.DriverJobDefinitionEventR\x18\x64riverJobDefinitionEvent\x12\x64\n\x1a\x64river_job_lifecycle_event\x18\r \x01(\x0b\x32\'.ray.rpc.events.DriverJobLifecycleEventR\x17\x64riverJobLifecycleEvent\x12W\n\x15node_definition_event\x18\x0e \x01(\x0b\x32#.ray.rpc.events.NodeDefinitionEventR\x13nodeDefinitionEvent\x12T\n\x14node_lifecycle_event\x18\x0f \x01(\x0b\x32\".ray.rpc.events.NodeLifecycleEventR\x12nodeLifecycleEvent\x12Z\n\x16\x61\x63tor_definition_event\x18\x10 \x01(\x0b\x32$.ray.rpc.events.ActorDefinitionEventR\x14\x61\x63torDefinitionEvent\x12W\n\x15\x61\x63tor_lifecycle_event\x18\x11 \x01(\x0b\x32#.ray.rpc.events.ActorLifecycleEventR\x13\x61\x63torLifecycleEvent\"\x80\x01\n\nSourceType\x12\x1b\n\x17SOURCE_TYPE_UNSPECIFIED\x10\x00\x12\x0f\n\x0b\x43ORE_WORKER\x10\x01\x12\x07\n\x03GCS\x10\x02\x12\n\n\x06RAYLET\x10\x03\x12\x15\n\x11\x43LUSTER_LIFECYCLE\x10\x04\x12\x0e\n\nAUTOSCALER\x10\x05\x12\x08\n\x04JOBS\x10\x06\"\xc2\x02\n\tEventType\x12\x1a\n\x16\x45VENT_TYPE_UNSPECIFIED\x10\x00\x12\x19\n\x15TASK_DEFINITION_EVENT\x10\x01\x12\x18\n\x14TASK_LIFECYCLE_EVENT\x10\x02\x12\x1f\n\x1b\x41\x43TOR_TASK_DEFINITION_EVENT\x10\x03\x12\x16\n\x12TASK_PROFILE_EVENT\x10\x04\x12\x1f\n\x1b\x44RIVER_JOB_DEFINITION_EVENT\x10\x05\x12\x1e\n\x1a\x44RIVER_JOB_LIFECYCLE_EVENT\x10\x06\x12\x19\n\x15NODE_DEFINITION_EVENT\x10\x07\x12\x18\n\x14NODE_LIFECYCLE_EVENT\x10\x08\x12\x1a\n\x16\x41\x43TOR_DEFINITION_EVENT\x10\t\x12\x19\n\x15\x41\x43TOR_LIFECYCLE_EVENT\x10\n\"m\n\x08Severity\x12\x1e\n\x1a\x45VENT_SEVERITY_UNSPECIFIED\x10\x00\x12\t\n\x05TRACE\x10\x01\x12\t\n\x05\x44\x45\x42UG\x10\x02\x12\x08\n\x04INFO\x10\x03\x12\x0b\n\x07WARNING\x10\x04\x12\t\n\x05\x45RROR\x10\x05\x12\t\n\x05\x46\x41TAL\x10\x06\x62\x06proto3') + + + +_RAYEVENT = DESCRIPTOR.message_types_by_name['RayEvent'] +_RAYEVENT_SOURCETYPE = _RAYEVENT.enum_types_by_name['SourceType'] +_RAYEVENT_EVENTTYPE = _RAYEVENT.enum_types_by_name['EventType'] +_RAYEVENT_SEVERITY = _RAYEVENT.enum_types_by_name['Severity'] +RayEvent = _reflection.GeneratedProtocolMessageType('RayEvent', (_message.Message,), { + 'DESCRIPTOR' : _RAYEVENT, + '__module__' : 'src.ray.protobuf.public.events_base_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.RayEvent) + }) +_sym_db.RegisterMessage(RayEvent) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _RAYEVENT._serialized_start=708 + _RAYEVENT._serialized_end=2557 + _RAYEVENT_SOURCETYPE._serialized_start=1993 + _RAYEVENT_SOURCETYPE._serialized_end=2121 + _RAYEVENT_EVENTTYPE._serialized_start=2124 + _RAYEVENT_EVENTTYPE._serialized_end=2446 + _RAYEVENT_SEVERITY._serialized_start=2448 + _RAYEVENT_SEVERITY._serialized_end=2557 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_base_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..5f6a92dcf42499313f9be746b742285837ac2ec9 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2.py @@ -0,0 +1,58 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_driver_job_definition_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n@src/ray/protobuf/public/events_driver_job_definition_event.proto\x12\x0eray.rpc.events\"\xb8\x03\n\x18\x44riverJobDefinitionEvent\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x1d\n\ndriver_pid\x18\x03 \x01(\x03R\tdriverPid\x12$\n\x0e\x64river_node_id\x18\x04 \x01(\x0cR\x0c\x64riverNodeId\x12\x1e\n\nentrypoint\x18\x05 \x01(\tR\nentrypoint\x12G\n\x06\x63onfig\x18\x06 \x01(\x0b\x32/.ray.rpc.events.DriverJobDefinitionEvent.ConfigR\x06\x63onfig\x1a\xd6\x01\n\x06\x43onfig\x12\x34\n\x16serialized_runtime_env\x18\x01 \x01(\tR\x14serializedRuntimeEnv\x12Y\n\x08metadata\x18\x02 \x03(\x0b\x32=.ray.rpc.events.DriverJobDefinitionEvent.Config.MetadataEntryR\x08metadata\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x62\x06proto3') + + + +_DRIVERJOBDEFINITIONEVENT = DESCRIPTOR.message_types_by_name['DriverJobDefinitionEvent'] +_DRIVERJOBDEFINITIONEVENT_CONFIG = _DRIVERJOBDEFINITIONEVENT.nested_types_by_name['Config'] +_DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY = _DRIVERJOBDEFINITIONEVENT_CONFIG.nested_types_by_name['MetadataEntry'] +DriverJobDefinitionEvent = _reflection.GeneratedProtocolMessageType('DriverJobDefinitionEvent', (_message.Message,), { + + 'Config' : _reflection.GeneratedProtocolMessageType('Config', (_message.Message,), { + + 'MetadataEntry' : _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), { + 'DESCRIPTOR' : _DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY, + '__module__' : 'src.ray.protobuf.public.events_driver_job_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.DriverJobDefinitionEvent.Config.MetadataEntry) + }) + , + 'DESCRIPTOR' : _DRIVERJOBDEFINITIONEVENT_CONFIG, + '__module__' : 'src.ray.protobuf.public.events_driver_job_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.DriverJobDefinitionEvent.Config) + }) + , + 'DESCRIPTOR' : _DRIVERJOBDEFINITIONEVENT, + '__module__' : 'src.ray.protobuf.public.events_driver_job_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.DriverJobDefinitionEvent) + }) +_sym_db.RegisterMessage(DriverJobDefinitionEvent) +_sym_db.RegisterMessage(DriverJobDefinitionEvent.Config) +_sym_db.RegisterMessage(DriverJobDefinitionEvent.Config.MetadataEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY._options = None + _DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY._serialized_options = b'8\001' + _DRIVERJOBDEFINITIONEVENT._serialized_start=85 + _DRIVERJOBDEFINITIONEVENT._serialized_end=525 + _DRIVERJOBDEFINITIONEVENT_CONFIG._serialized_start=311 + _DRIVERJOBDEFINITIONEVENT_CONFIG._serialized_end=525 + _DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY._serialized_start=466 + _DRIVERJOBDEFINITIONEVENT_CONFIG_METADATAENTRY._serialized_end=525 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_definition_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..fa1e273b56bf9b209d22b22ae1c9d0d34cf3e9ce --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_driver_job_lifecycle_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n?src/ray/protobuf/public/events_driver_job_lifecycle_event.proto\x12\x0eray.rpc.events\x1a\x1fgoogle/protobuf/timestamp.proto\"\xde\x02\n\x17\x44riverJobLifecycleEvent\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x64\n\x11state_transitions\x18\x02 \x03(\x0b\x32\x37.ray.rpc.events.DriverJobLifecycleEvent.StateTransitionR\x10stateTransitions\x1a\x90\x01\n\x0fStateTransition\x12\x43\n\x05state\x18\x01 \x01(\x0e\x32-.ray.rpc.events.DriverJobLifecycleEvent.StateR\x05state\x12\x38\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\"3\n\x05State\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0b\n\x07\x43REATED\x10\x01\x12\x0c\n\x08\x46INISHED\x10\x02\x62\x06proto3') + + + +_DRIVERJOBLIFECYCLEEVENT = DESCRIPTOR.message_types_by_name['DriverJobLifecycleEvent'] +_DRIVERJOBLIFECYCLEEVENT_STATETRANSITION = _DRIVERJOBLIFECYCLEEVENT.nested_types_by_name['StateTransition'] +_DRIVERJOBLIFECYCLEEVENT_STATE = _DRIVERJOBLIFECYCLEEVENT.enum_types_by_name['State'] +DriverJobLifecycleEvent = _reflection.GeneratedProtocolMessageType('DriverJobLifecycleEvent', (_message.Message,), { + + 'StateTransition' : _reflection.GeneratedProtocolMessageType('StateTransition', (_message.Message,), { + 'DESCRIPTOR' : _DRIVERJOBLIFECYCLEEVENT_STATETRANSITION, + '__module__' : 'src.ray.protobuf.public.events_driver_job_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.DriverJobLifecycleEvent.StateTransition) + }) + , + 'DESCRIPTOR' : _DRIVERJOBLIFECYCLEEVENT, + '__module__' : 'src.ray.protobuf.public.events_driver_job_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.DriverJobLifecycleEvent) + }) +_sym_db.RegisterMessage(DriverJobLifecycleEvent) +_sym_db.RegisterMessage(DriverJobLifecycleEvent.StateTransition) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _DRIVERJOBLIFECYCLEEVENT._serialized_start=117 + _DRIVERJOBLIFECYCLEEVENT._serialized_end=467 + _DRIVERJOBLIFECYCLEEVENT_STATETRANSITION._serialized_start=270 + _DRIVERJOBLIFECYCLEEVENT_STATETRANSITION._serialized_end=414 + _DRIVERJOBLIFECYCLEEVENT_STATE._serialized_start=416 + _DRIVERJOBLIFECYCLEEVENT_STATE._serialized_end=467 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_driver_job_lifecycle_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..533f8476e0f11430bd0f6e5800ab0c30cf97e840 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/events_event_aggregator_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import events_base_event_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_events__base__event__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n6src/ray/protobuf/events_event_aggregator_service.proto\x12\x0eray.rpc.events\x1a\x1dsrc/ray/protobuf/common.proto\x1a/src/ray/protobuf/public/events_base_event.proto\"^\n\x12TaskEventsMetadata\x12H\n\x15\x64ropped_task_attempts\x18\x02 \x03(\x0b\x32\x14.ray.rpc.TaskAttemptR\x13\x64roppedTaskAttempts\"\x97\x01\n\rRayEventsData\x12\x30\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x18.ray.rpc.events.RayEventR\x06\x65vents\x12T\n\x14task_events_metadata\x18\x02 \x01(\x0b\x32\".ray.rpc.events.TaskEventsMetadataR\x12taskEventsMetadata\"R\n\x10\x41\x64\x64\x45ventsRequest\x12>\n\x0b\x65vents_data\x18\x01 \x01(\x0b\x32\x1d.ray.rpc.events.RayEventsDataR\neventsData\"?\n\x0f\x41\x64\x64\x45ventsStatus\x12\x12\n\x04\x63ode\x18\x01 \x01(\x05R\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"I\n\x0e\x41\x64\x64\x45ventsReply\x12\x37\n\x06status\x18\x01 \x01(\x0b\x32\x1f.ray.rpc.events.AddEventsStatusR\x06status2g\n\x16\x45ventAggregatorService\x12M\n\tAddEvents\x12 .ray.rpc.events.AddEventsRequest\x1a\x1e.ray.rpc.events.AddEventsReplyb\x06proto3') + + + +_TASKEVENTSMETADATA = DESCRIPTOR.message_types_by_name['TaskEventsMetadata'] +_RAYEVENTSDATA = DESCRIPTOR.message_types_by_name['RayEventsData'] +_ADDEVENTSREQUEST = DESCRIPTOR.message_types_by_name['AddEventsRequest'] +_ADDEVENTSSTATUS = DESCRIPTOR.message_types_by_name['AddEventsStatus'] +_ADDEVENTSREPLY = DESCRIPTOR.message_types_by_name['AddEventsReply'] +TaskEventsMetadata = _reflection.GeneratedProtocolMessageType('TaskEventsMetadata', (_message.Message,), { + 'DESCRIPTOR' : _TASKEVENTSMETADATA, + '__module__' : 'src.ray.protobuf.events_event_aggregator_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskEventsMetadata) + }) +_sym_db.RegisterMessage(TaskEventsMetadata) + +RayEventsData = _reflection.GeneratedProtocolMessageType('RayEventsData', (_message.Message,), { + 'DESCRIPTOR' : _RAYEVENTSDATA, + '__module__' : 'src.ray.protobuf.events_event_aggregator_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.RayEventsData) + }) +_sym_db.RegisterMessage(RayEventsData) + +AddEventsRequest = _reflection.GeneratedProtocolMessageType('AddEventsRequest', (_message.Message,), { + 'DESCRIPTOR' : _ADDEVENTSREQUEST, + '__module__' : 'src.ray.protobuf.events_event_aggregator_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.AddEventsRequest) + }) +_sym_db.RegisterMessage(AddEventsRequest) + +AddEventsStatus = _reflection.GeneratedProtocolMessageType('AddEventsStatus', (_message.Message,), { + 'DESCRIPTOR' : _ADDEVENTSSTATUS, + '__module__' : 'src.ray.protobuf.events_event_aggregator_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.AddEventsStatus) + }) +_sym_db.RegisterMessage(AddEventsStatus) + +AddEventsReply = _reflection.GeneratedProtocolMessageType('AddEventsReply', (_message.Message,), { + 'DESCRIPTOR' : _ADDEVENTSREPLY, + '__module__' : 'src.ray.protobuf.events_event_aggregator_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.AddEventsReply) + }) +_sym_db.RegisterMessage(AddEventsReply) + +_EVENTAGGREGATORSERVICE = DESCRIPTOR.services_by_name['EventAggregatorService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TASKEVENTSMETADATA._serialized_start=154 + _TASKEVENTSMETADATA._serialized_end=248 + _RAYEVENTSDATA._serialized_start=251 + _RAYEVENTSDATA._serialized_end=402 + _ADDEVENTSREQUEST._serialized_start=404 + _ADDEVENTSREQUEST._serialized_end=486 + _ADDEVENTSSTATUS._serialized_start=488 + _ADDEVENTSSTATUS._serialized_end=551 + _ADDEVENTSREPLY._serialized_start=553 + _ADDEVENTSREPLY._serialized_end=626 + _EVENTAGGREGATORSERVICE._serialized_start=628 + _EVENTAGGREGATORSERVICE._serialized_end=731 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..185fe95c4204419863f643e339c305db26d24821 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_event_aggregator_service_pb2_grpc.py @@ -0,0 +1,66 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import events_event_aggregator_service_pb2 as src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2 + + +class EventAggregatorServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.AddEvents = channel.unary_unary( + '/ray.rpc.events.EventAggregatorService/AddEvents', + request_serializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.FromString, + ) + + +class EventAggregatorServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def AddEvents(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_EventAggregatorServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'AddEvents': grpc.unary_unary_rpc_method_handler( + servicer.AddEvents, + request_deserializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.events.EventAggregatorService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class EventAggregatorService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def AddEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.events.EventAggregatorService/AddEvents', + src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..7807e7edc2be8cbe5d38ec305fd8c3e06f7b67f7 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_node_definition_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n:src/ray/protobuf/public/events_node_definition_event.proto\x12\x0eray.rpc.events\x1a\x1fgoogle/protobuf/timestamp.proto\"\x9f\x02\n\x13NodeDefinitionEvent\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12&\n\x0fnode_ip_address\x18\x02 \x01(\tR\rnodeIpAddress\x12G\n\x06labels\x18\x03 \x03(\x0b\x32/.ray.rpc.events.NodeDefinitionEvent.LabelsEntryR\x06labels\x12\x43\n\x0fstart_timestamp\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0estartTimestamp\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x62\x06proto3') + + + +_NODEDEFINITIONEVENT = DESCRIPTOR.message_types_by_name['NodeDefinitionEvent'] +_NODEDEFINITIONEVENT_LABELSENTRY = _NODEDEFINITIONEVENT.nested_types_by_name['LabelsEntry'] +NodeDefinitionEvent = _reflection.GeneratedProtocolMessageType('NodeDefinitionEvent', (_message.Message,), { + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODEDEFINITIONEVENT_LABELSENTRY, + '__module__' : 'src.ray.protobuf.public.events_node_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeDefinitionEvent.LabelsEntry) + }) + , + 'DESCRIPTOR' : _NODEDEFINITIONEVENT, + '__module__' : 'src.ray.protobuf.public.events_node_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeDefinitionEvent) + }) +_sym_db.RegisterMessage(NodeDefinitionEvent) +_sym_db.RegisterMessage(NodeDefinitionEvent.LabelsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _NODEDEFINITIONEVENT_LABELSENTRY._options = None + _NODEDEFINITIONEVENT_LABELSENTRY._serialized_options = b'8\001' + _NODEDEFINITIONEVENT._serialized_start=112 + _NODEDEFINITIONEVENT._serialized_end=399 + _NODEDEFINITIONEVENT_LABELSENTRY._serialized_start=342 + _NODEDEFINITIONEVENT_LABELSENTRY._serialized_end=399 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_node_definition_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..db3aac608832ac8caeb83a850ad751c58f4d6078 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_node_lifecycle_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n9src/ray/protobuf/public/events_node_lifecycle_event.proto\x12\x0eray.rpc.events\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbf\x07\n\x12NodeLifecycleEvent\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12_\n\x11state_transitions\x18\x02 \x03(\x0b\x32\x32.ray.rpc.events.NodeLifecycleEvent.StateTransitionR\x10stateTransitions\x1a\x8c\x02\n\tDeathInfo\x12K\n\x06reason\x18\x01 \x01(\x0e\x32\x33.ray.rpc.events.NodeLifecycleEvent.DeathInfo.ReasonR\x06reason\x12%\n\x0ereason_message\x18\x02 \x01(\tR\rreasonMessage\"\x8a\x01\n\x06Reason\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x18\n\x14\x45XPECTED_TERMINATION\x10\x01\x12\x1a\n\x16UNEXPECTED_TERMINATION\x10\x02\x12\x1e\n\x1a\x41UTOSCALER_DRAIN_PREEMPTED\x10\x03\x12\x19\n\x15\x41UTOSCALER_DRAIN_IDLE\x10\x04\x1a\xd1\x03\n\x0fStateTransition\x12>\n\x05state\x18\x01 \x01(\x0e\x32(.ray.rpc.events.NodeLifecycleEvent.StateR\x05state\x12\x38\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12_\n\tresources\x18\x03 \x03(\x0b\x32\x41.ray.rpc.events.NodeLifecycleEvent.StateTransition.ResourcesEntryR\tresources\x12K\n\ndeath_info\x18\x04 \x01(\x0b\x32,.ray.rpc.events.NodeLifecycleEvent.DeathInfoR\tdeathInfo\x12X\n\x0f\x61live_sub_state\x18\x05 \x01(\x0e\x32\x30.ray.rpc.events.NodeLifecycleEvent.AliveSubStateR\raliveSubState\x1a<\n\x0eResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\x1c\n\x05State\x12\t\n\x05\x41LIVE\x10\x00\x12\x08\n\x04\x44\x45\x41\x44\x10\x01\".\n\rAliveSubState\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0c\n\x08\x44RAINING\x10\x01\x62\x06proto3') + + + +_NODELIFECYCLEEVENT = DESCRIPTOR.message_types_by_name['NodeLifecycleEvent'] +_NODELIFECYCLEEVENT_DEATHINFO = _NODELIFECYCLEEVENT.nested_types_by_name['DeathInfo'] +_NODELIFECYCLEEVENT_STATETRANSITION = _NODELIFECYCLEEVENT.nested_types_by_name['StateTransition'] +_NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY = _NODELIFECYCLEEVENT_STATETRANSITION.nested_types_by_name['ResourcesEntry'] +_NODELIFECYCLEEVENT_DEATHINFO_REASON = _NODELIFECYCLEEVENT_DEATHINFO.enum_types_by_name['Reason'] +_NODELIFECYCLEEVENT_STATE = _NODELIFECYCLEEVENT.enum_types_by_name['State'] +_NODELIFECYCLEEVENT_ALIVESUBSTATE = _NODELIFECYCLEEVENT.enum_types_by_name['AliveSubState'] +NodeLifecycleEvent = _reflection.GeneratedProtocolMessageType('NodeLifecycleEvent', (_message.Message,), { + + 'DeathInfo' : _reflection.GeneratedProtocolMessageType('DeathInfo', (_message.Message,), { + 'DESCRIPTOR' : _NODELIFECYCLEEVENT_DEATHINFO, + '__module__' : 'src.ray.protobuf.public.events_node_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeLifecycleEvent.DeathInfo) + }) + , + + 'StateTransition' : _reflection.GeneratedProtocolMessageType('StateTransition', (_message.Message,), { + + 'ResourcesEntry' : _reflection.GeneratedProtocolMessageType('ResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY, + '__module__' : 'src.ray.protobuf.public.events_node_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeLifecycleEvent.StateTransition.ResourcesEntry) + }) + , + 'DESCRIPTOR' : _NODELIFECYCLEEVENT_STATETRANSITION, + '__module__' : 'src.ray.protobuf.public.events_node_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeLifecycleEvent.StateTransition) + }) + , + 'DESCRIPTOR' : _NODELIFECYCLEEVENT, + '__module__' : 'src.ray.protobuf.public.events_node_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.NodeLifecycleEvent) + }) +_sym_db.RegisterMessage(NodeLifecycleEvent) +_sym_db.RegisterMessage(NodeLifecycleEvent.DeathInfo) +_sym_db.RegisterMessage(NodeLifecycleEvent.StateTransition) +_sym_db.RegisterMessage(NodeLifecycleEvent.StateTransition.ResourcesEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY._options = None + _NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY._serialized_options = b'8\001' + _NODELIFECYCLEEVENT._serialized_start=111 + _NODELIFECYCLEEVENT._serialized_end=1070 + _NODELIFECYCLEEVENT_DEATHINFO._serialized_start=256 + _NODELIFECYCLEEVENT_DEATHINFO._serialized_end=524 + _NODELIFECYCLEEVENT_DEATHINFO_REASON._serialized_start=386 + _NODELIFECYCLEEVENT_DEATHINFO_REASON._serialized_end=524 + _NODELIFECYCLEEVENT_STATETRANSITION._serialized_start=527 + _NODELIFECYCLEEVENT_STATETRANSITION._serialized_end=992 + _NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY._serialized_start=932 + _NODELIFECYCLEEVENT_STATETRANSITION_RESOURCESENTRY._serialized_end=992 + _NODELIFECYCLEEVENT_STATE._serialized_start=994 + _NODELIFECYCLEEVENT_STATE._serialized_end=1022 + _NODELIFECYCLEEVENT_ALIVESUBSTATE._serialized_start=1024 + _NODELIFECYCLEEVENT_ALIVESUBSTATE._serialized_end=1070 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_node_lifecycle_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..637541d614133af9352ae8d860ade8daf44718ab --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_task_definition_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import runtime_environment_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_runtime__environment__pb2 +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n:src/ray/protobuf/public/events_task_definition_event.proto\x12\x0eray.rpc.events\x1a\x31src/ray/protobuf/public/runtime_environment.proto\x1a\x1dsrc/ray/protobuf/common.proto\"\xf6\x05\n\x13TaskDefinitionEvent\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12!\n\x0ctask_attempt\x18\x02 \x01(\x05R\x0btaskAttempt\x12.\n\ttask_type\x18\x03 \x01(\x0e\x32\x11.ray.rpc.TaskTypeR\x08taskType\x12-\n\x08language\x18\x04 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12\x38\n\ttask_func\x18\x05 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\x08taskFunc\x12\x1b\n\ttask_name\x18\x06 \x01(\tR\x08taskName\x12i\n\x12required_resources\x18\x07 \x03(\x0b\x32:.ray.rpc.events.TaskDefinitionEvent.RequiredResourcesEntryR\x11requiredResources\x12\x15\n\x06job_id\x18\t \x01(\x0cR\x05jobId\x12$\n\x0eparent_task_id\x18\n \x01(\x0cR\x0cparentTaskId\x12,\n\x12placement_group_id\x18\x0b \x01(\x0cR\x10placementGroupId\x12H\n\x07ref_ids\x18\x0c \x03(\x0b\x32/.ray.rpc.events.TaskDefinitionEvent.RefIdsEntryR\x06refIds\x12\x34\n\x16serialized_runtime_env\x18\r \x01(\tR\x14serializedRuntimeEnv\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bRefIdsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value:\x02\x38\x01J\x04\x08\x08\x10\tR\x10runtime_env_infob\x06proto3') + + + +_TASKDEFINITIONEVENT = DESCRIPTOR.message_types_by_name['TaskDefinitionEvent'] +_TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY = _TASKDEFINITIONEVENT.nested_types_by_name['RequiredResourcesEntry'] +_TASKDEFINITIONEVENT_REFIDSENTRY = _TASKDEFINITIONEVENT.nested_types_by_name['RefIdsEntry'] +TaskDefinitionEvent = _reflection.GeneratedProtocolMessageType('TaskDefinitionEvent', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.public.events_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskDefinitionEvent.RequiredResourcesEntry) + }) + , + + 'RefIdsEntry' : _reflection.GeneratedProtocolMessageType('RefIdsEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKDEFINITIONEVENT_REFIDSENTRY, + '__module__' : 'src.ray.protobuf.public.events_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskDefinitionEvent.RefIdsEntry) + }) + , + 'DESCRIPTOR' : _TASKDEFINITIONEVENT, + '__module__' : 'src.ray.protobuf.public.events_task_definition_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskDefinitionEvent) + }) +_sym_db.RegisterMessage(TaskDefinitionEvent) +_sym_db.RegisterMessage(TaskDefinitionEvent.RequiredResourcesEntry) +_sym_db.RegisterMessage(TaskDefinitionEvent.RefIdsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._options = None + _TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _TASKDEFINITIONEVENT_REFIDSENTRY._options = None + _TASKDEFINITIONEVENT_REFIDSENTRY._serialized_options = b'8\001' + _TASKDEFINITIONEVENT._serialized_start=161 + _TASKDEFINITIONEVENT._serialized_end=919 + _TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_start=768 + _TASKDEFINITIONEVENT_REQUIREDRESOURCESENTRY._serialized_end=836 + _TASKDEFINITIONEVENT_REFIDSENTRY._serialized_start=838 + _TASKDEFINITIONEVENT_REFIDSENTRY._serialized_end=895 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_definition_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..4b6c39e163fdafc0b4e4e4ff522543d8cd7c94a9 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/events_task_lifecycle_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n9src/ray/protobuf/public/events_task_lifecycle_event.proto\x12\x0eray.rpc.events\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1dsrc/ray/protobuf/common.proto\"\xd2\x03\n\x12TaskLifecycleEvent\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12!\n\x0ctask_attempt\x18\x02 \x01(\x05R\x0btaskAttempt\x12_\n\x11state_transitions\x18\x03 \x03(\x0b\x32\x32.ray.rpc.events.TaskLifecycleEvent.StateTransitionR\x10stateTransitions\x12;\n\x0eray_error_info\x18\x04 \x01(\x0b\x32\x15.ray.rpc.RayErrorInfoR\x0crayErrorInfo\x12\x17\n\x07node_id\x18\x05 \x01(\x0cR\x06nodeId\x12\x1b\n\tworker_id\x18\x06 \x01(\x0cR\x08workerId\x12\x1d\n\nworker_pid\x18\x07 \x01(\x05R\tworkerPid\x12\x15\n\x06job_id\x18\x08 \x01(\x0cR\x05jobId\x1av\n\x0fStateTransition\x12)\n\x05state\x18\x01 \x01(\x0e\x32\x13.ray.rpc.TaskStatusR\x05state\x12\x38\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestampb\x06proto3') + + + +_TASKLIFECYCLEEVENT = DESCRIPTOR.message_types_by_name['TaskLifecycleEvent'] +_TASKLIFECYCLEEVENT_STATETRANSITION = _TASKLIFECYCLEEVENT.nested_types_by_name['StateTransition'] +TaskLifecycleEvent = _reflection.GeneratedProtocolMessageType('TaskLifecycleEvent', (_message.Message,), { + + 'StateTransition' : _reflection.GeneratedProtocolMessageType('StateTransition', (_message.Message,), { + 'DESCRIPTOR' : _TASKLIFECYCLEEVENT_STATETRANSITION, + '__module__' : 'src.ray.protobuf.public.events_task_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskLifecycleEvent.StateTransition) + }) + , + 'DESCRIPTOR' : _TASKLIFECYCLEEVENT, + '__module__' : 'src.ray.protobuf.public.events_task_lifecycle_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskLifecycleEvent) + }) +_sym_db.RegisterMessage(TaskLifecycleEvent) +_sym_db.RegisterMessage(TaskLifecycleEvent.StateTransition) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TASKLIFECYCLEEVENT._serialized_start=142 + _TASKLIFECYCLEEVENT._serialized_end=608 + _TASKLIFECYCLEEVENT_STATETRANSITION._serialized_start=490 + _TASKLIFECYCLEEVENT_STATETRANSITION._serialized_end=608 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_lifecycle_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2.py b/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..7425541ef2f6a769b93b8d74fe4683735993ac69 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/events_task_profile_events.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import profile_events_pb2 as src_dot_ray_dot_protobuf_dot_profile__events__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n1src/ray/protobuf/events_task_profile_events.proto\x12\x0eray.rpc.events\x1a%src/ray/protobuf/profile_events.proto\"\xa9\x01\n\x11TaskProfileEvents\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12%\n\x0e\x61ttempt_number\x18\x02 \x01(\x05R\rattemptNumber\x12\x15\n\x06job_id\x18\x03 \x01(\x0cR\x05jobId\x12=\n\x0eprofile_events\x18\x04 \x01(\x0b\x32\x16.ray.rpc.ProfileEventsR\rprofileEventsb\x06proto3') + + + +_TASKPROFILEEVENTS = DESCRIPTOR.message_types_by_name['TaskProfileEvents'] +TaskProfileEvents = _reflection.GeneratedProtocolMessageType('TaskProfileEvents', (_message.Message,), { + 'DESCRIPTOR' : _TASKPROFILEEVENTS, + '__module__' : 'src.ray.protobuf.events_task_profile_events_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.events.TaskProfileEvents) + }) +_sym_db.RegisterMessage(TaskProfileEvents) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TASKPROFILEEVENTS._serialized_start=109 + _TASKPROFILEEVENTS._serialized_end=278 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/events_task_profile_events_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..acdb1154a0f54b252c03d98569e7c86c70a5e3b1 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_actor_data.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n(src/ray/protobuf/export_actor_data.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\"\xa3\x08\n\x0f\x45xportActorData\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x15\n\x06job_id\x18\x02 \x01(\x0cR\x05jobId\x12\x39\n\x05state\x18\x03 \x01(\x0e\x32#.ray.rpc.ExportActorData.ActorStateR\x05state\x12\x1f\n\x0bis_detached\x18\x04 \x01(\x08R\nisDetached\x12\x12\n\x04name\x18\x05 \x01(\tR\x04name\x12\x10\n\x03pid\x18\x06 \x01(\rR\x03pid\x12#\n\rray_namespace\x18\x07 \x01(\tR\x0crayNamespace\x12\x34\n\x16serialized_runtime_env\x18\x08 \x01(\tR\x14serializedRuntimeEnv\x12\x1d\n\nclass_name\x18\t \x01(\tR\tclassName\x12\x39\n\x0b\x64\x65\x61th_cause\x18\n \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseR\ndeathCause\x12^\n\x12required_resources\x18\x0b \x03(\x0b\x32/.ray.rpc.ExportActorData.RequiredResourcesEntryR\x11requiredResources\x12\x1c\n\x07node_id\x18\x0c \x01(\x0cH\x00R\x06nodeId\x88\x01\x01\x12\x31\n\x12placement_group_id\x18\r \x01(\x0cH\x01R\x10placementGroupId\x88\x01\x01\x12\x1b\n\trepr_name\x18\x0e \x01(\tR\x08reprName\x12<\n\x06labels\x18\x0f \x03(\x0b\x32$.ray.rpc.ExportActorData.LabelsEntryR\x06labels\x12R\n\x0elabel_selector\x18\x10 \x03(\x0b\x32+.ray.rpc.ExportActorData.LabelSelectorEntryR\rlabelSelector\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"a\n\nActorState\x12\x18\n\x14\x44\x45PENDENCIES_UNREADY\x10\x00\x12\x14\n\x10PENDING_CREATION\x10\x01\x12\t\n\x05\x41LIVE\x10\x02\x12\x0e\n\nRESTARTING\x10\x03\x12\x08\n\x04\x44\x45\x41\x44\x10\x04\x42\n\n\x08_node_idB\x15\n\x13_placement_group_idb\x06proto3') + + + +_EXPORTACTORDATA = DESCRIPTOR.message_types_by_name['ExportActorData'] +_EXPORTACTORDATA_REQUIREDRESOURCESENTRY = _EXPORTACTORDATA.nested_types_by_name['RequiredResourcesEntry'] +_EXPORTACTORDATA_LABELSENTRY = _EXPORTACTORDATA.nested_types_by_name['LabelsEntry'] +_EXPORTACTORDATA_LABELSELECTORENTRY = _EXPORTACTORDATA.nested_types_by_name['LabelSelectorEntry'] +_EXPORTACTORDATA_ACTORSTATE = _EXPORTACTORDATA.enum_types_by_name['ActorState'] +ExportActorData = _reflection.GeneratedProtocolMessageType('ExportActorData', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTACTORDATA_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.export_actor_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportActorData.RequiredResourcesEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTACTORDATA_LABELSENTRY, + '__module__' : 'src.ray.protobuf.export_actor_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportActorData.LabelsEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTACTORDATA_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.export_actor_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportActorData.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _EXPORTACTORDATA, + '__module__' : 'src.ray.protobuf.export_actor_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportActorData) + }) +_sym_db.RegisterMessage(ExportActorData) +_sym_db.RegisterMessage(ExportActorData.RequiredResourcesEntry) +_sym_db.RegisterMessage(ExportActorData.LabelsEntry) +_sym_db.RegisterMessage(ExportActorData.LabelSelectorEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTACTORDATA_REQUIREDRESOURCESENTRY._options = None + _EXPORTACTORDATA_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _EXPORTACTORDATA_LABELSENTRY._options = None + _EXPORTACTORDATA_LABELSENTRY._serialized_options = b'8\001' + _EXPORTACTORDATA_LABELSELECTORENTRY._options = None + _EXPORTACTORDATA_LABELSELECTORENTRY._serialized_options = b'8\001' + _EXPORTACTORDATA._serialized_start=85 + _EXPORTACTORDATA._serialized_end=1144 + _EXPORTACTORDATA_REQUIREDRESOURCESENTRY._serialized_start=817 + _EXPORTACTORDATA_REQUIREDRESOURCESENTRY._serialized_end=885 + _EXPORTACTORDATA_LABELSENTRY._serialized_start=887 + _EXPORTACTORDATA_LABELSENTRY._serialized_end=944 + _EXPORTACTORDATA_LABELSELECTORENTRY._serialized_start=946 + _EXPORTACTORDATA_LABELSELECTORENTRY._serialized_end=1010 + _EXPORTACTORDATA_ACTORSTATE._serialized_start=1012 + _EXPORTACTORDATA_ACTORSTATE._serialized_end=1109 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_actor_data_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..047fb8f54b490bbc07330c4d93097a96668dcba3 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_dataset_metadata.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n.src/ray/protobuf/export_dataset_metadata.proto\x12\x07ray.rpc\x1a\x1cgoogle/protobuf/struct.proto\".\n\x08SubStage\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x0e\n\x02id\x18\x02 \x01(\tR\x02id\"\xb9\x03\n\x08Operator\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x0e\n\x02id\x18\x02 \x01(\tR\x02id\x12\x12\n\x04uuid\x18\x03 \x01(\tR\x04uuid\x12-\n\x12input_dependencies\x18\x04 \x03(\tR\x11inputDependencies\x12\x30\n\nsub_stages\x18\x05 \x03(\x0b\x32\x11.ray.rpc.SubStageR\tsubStages\x12+\n\x04\x61rgs\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x04\x61rgs\x12\x30\n\x14\x65xecution_start_time\x18\x07 \x01(\x01R\x12\x65xecutionStartTime\x12,\n\x12\x65xecution_end_time\x18\x08 \x01(\x01R\x10\x65xecutionEndTime\x12\x35\n\x05state\x18\t \x01(\x0e\x32\x1f.ray.rpc.Operator.OperatorStateR\x05state\"P\n\rOperatorState\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\x0c\n\x08\x46INISHED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\x0b\n\x07PENDING\x10\x04\";\n\x08Topology\x12/\n\toperators\x18\x01 \x03(\x0b\x32\x11.ray.rpc.OperatorR\toperators\"\xeb\x04\n\x15\x45xportDatasetMetadata\x12-\n\x08topology\x18\x01 \x01(\x0b\x32\x11.ray.rpc.TopologyR\x08topology\x12\x1d\n\ndataset_id\x18\x02 \x01(\tR\tdatasetId\x12\x15\n\x06job_id\x18\x03 \x01(\tR\x05jobId\x12\x1d\n\nstart_time\x18\x04 \x01(\x01R\tstartTime\x12:\n\x0c\x64\x61ta_context\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructR\x0b\x64\x61taContext\x12\x30\n\x14\x65xecution_start_time\x18\x06 \x01(\x01R\x12\x65xecutionStartTime\x12,\n\x12\x65xecution_end_time\x18\x07 \x01(\x01R\x10\x65xecutionEndTime\x12\x41\n\x05state\x18\x08 \x01(\x0e\x32+.ray.rpc.ExportDatasetMetadata.DatasetStateR\x05state\x12^\n\x0foperator_panels\x18\t \x03(\x0b\x32\x35.ray.rpc.ExportDatasetMetadata.DashboardPanelMetadataR\x0eoperatorPanels\x1a>\n\x16\x44\x61shboardPanelMetadata\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\"O\n\x0c\x44\x61tasetState\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\x0c\n\x08\x46INISHED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\x0b\n\x07PENDING\x10\x04\x42\x03\xf8\x01\x01\x62\x06proto3') + + + +_SUBSTAGE = DESCRIPTOR.message_types_by_name['SubStage'] +_OPERATOR = DESCRIPTOR.message_types_by_name['Operator'] +_TOPOLOGY = DESCRIPTOR.message_types_by_name['Topology'] +_EXPORTDATASETMETADATA = DESCRIPTOR.message_types_by_name['ExportDatasetMetadata'] +_EXPORTDATASETMETADATA_DASHBOARDPANELMETADATA = _EXPORTDATASETMETADATA.nested_types_by_name['DashboardPanelMetadata'] +_OPERATOR_OPERATORSTATE = _OPERATOR.enum_types_by_name['OperatorState'] +_EXPORTDATASETMETADATA_DATASETSTATE = _EXPORTDATASETMETADATA.enum_types_by_name['DatasetState'] +SubStage = _reflection.GeneratedProtocolMessageType('SubStage', (_message.Message,), { + 'DESCRIPTOR' : _SUBSTAGE, + '__module__' : 'src.ray.protobuf.export_dataset_metadata_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SubStage) + }) +_sym_db.RegisterMessage(SubStage) + +Operator = _reflection.GeneratedProtocolMessageType('Operator', (_message.Message,), { + 'DESCRIPTOR' : _OPERATOR, + '__module__' : 'src.ray.protobuf.export_dataset_metadata_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Operator) + }) +_sym_db.RegisterMessage(Operator) + +Topology = _reflection.GeneratedProtocolMessageType('Topology', (_message.Message,), { + 'DESCRIPTOR' : _TOPOLOGY, + '__module__' : 'src.ray.protobuf.export_dataset_metadata_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Topology) + }) +_sym_db.RegisterMessage(Topology) + +ExportDatasetMetadata = _reflection.GeneratedProtocolMessageType('ExportDatasetMetadata', (_message.Message,), { + + 'DashboardPanelMetadata' : _reflection.GeneratedProtocolMessageType('DashboardPanelMetadata', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTDATASETMETADATA_DASHBOARDPANELMETADATA, + '__module__' : 'src.ray.protobuf.export_dataset_metadata_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDatasetMetadata.DashboardPanelMetadata) + }) + , + 'DESCRIPTOR' : _EXPORTDATASETMETADATA, + '__module__' : 'src.ray.protobuf.export_dataset_metadata_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDatasetMetadata) + }) +_sym_db.RegisterMessage(ExportDatasetMetadata) +_sym_db.RegisterMessage(ExportDatasetMetadata.DashboardPanelMetadata) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\370\001\001' + _SUBSTAGE._serialized_start=89 + _SUBSTAGE._serialized_end=135 + _OPERATOR._serialized_start=138 + _OPERATOR._serialized_end=579 + _OPERATOR_OPERATORSTATE._serialized_start=499 + _OPERATOR_OPERATORSTATE._serialized_end=579 + _TOPOLOGY._serialized_start=581 + _TOPOLOGY._serialized_end=640 + _EXPORTDATASETMETADATA._serialized_start=643 + _EXPORTDATASETMETADATA._serialized_end=1262 + _EXPORTDATASETMETADATA_DASHBOARDPANELMETADATA._serialized_start=1119 + _EXPORTDATASETMETADATA_DASHBOARDPANELMETADATA._serialized_end=1181 + _EXPORTDATASETMETADATA_DATASETSTATE._serialized_start=1183 + _EXPORTDATASETMETADATA_DATASETSTATE._serialized_end=1262 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_dataset_metadata_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..c197e76492cd2b02e78b676755492358902b1477 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_dataset_operator_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n4src/ray/protobuf/export_dataset_operator_event.proto\x12\x07ray.rpc\"\x8a\x03\n\x1e\x45xportDatasetOperatorEventData\x12\x1d\n\ndataset_id\x18\x01 \x01(\tR\tdatasetId\x12\x1f\n\x0boperator_id\x18\x02 \x01(\tR\noperatorId\x12#\n\roperator_name\x18\x03 \x01(\tR\x0coperatorName\x12\x1d\n\nevent_time\x18\x04 \x01(\x01R\teventTime\x12_\n\nevent_type\x18\x05 \x01(\x0e\x32@.ray.rpc.ExportDatasetOperatorEventData.DatasetOperatorEventTypeR\teventType\x12\x18\n\x07message\x18\x06 \x01(\tR\x07message\"i\n\x18\x44\x61tasetOperatorEventType\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x1b\n\x17ISSUE_DETECTION_HANGING\x10\x01\x12\x1f\n\x1bISSUE_DETECTION_HIGH_MEMORY\x10\x02\x42\x03\xf8\x01\x01\x62\x06proto3') + + + +_EXPORTDATASETOPERATOREVENTDATA = DESCRIPTOR.message_types_by_name['ExportDatasetOperatorEventData'] +_EXPORTDATASETOPERATOREVENTDATA_DATASETOPERATOREVENTTYPE = _EXPORTDATASETOPERATOREVENTDATA.enum_types_by_name['DatasetOperatorEventType'] +ExportDatasetOperatorEventData = _reflection.GeneratedProtocolMessageType('ExportDatasetOperatorEventData', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTDATASETOPERATOREVENTDATA, + '__module__' : 'src.ray.protobuf.export_dataset_operator_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDatasetOperatorEventData) + }) +_sym_db.RegisterMessage(ExportDatasetOperatorEventData) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\370\001\001' + _EXPORTDATASETOPERATOREVENTDATA._serialized_start=66 + _EXPORTDATASETOPERATOREVENTDATA._serialized_end=460 + _EXPORTDATASETOPERATOREVENTDATA_DATASETOPERATOREVENTTYPE._serialized_start=355 + _EXPORTDATASETOPERATOREVENTDATA_DATASETOPERATOREVENTTYPE._serialized_end=460 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_dataset_operator_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..ae87707f2013bb2e211e02385d8cb2c45234121c --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_driver_job_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import export_runtime_env_pb2 as src_dot_ray_dot_protobuf_dot_export__runtime__env__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n.src/ray/protobuf/export_driver_job_event.proto\x12\x07ray.rpc\x1a)src/ray/protobuf/export_runtime_env.proto\"\x9f\x04\n\x18\x45xportDriverJobEventData\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x17\n\x07is_dead\x18\x02 \x01(\x08R\x06isDead\x12\x1d\n\ndriver_pid\x18\x03 \x01(\x03R\tdriverPid\x12\x43\n\x06\x63onfig\x18\x04 \x01(\x0b\x32+.ray.rpc.ExportDriverJobEventData.JobConfigR\x06\x63onfig\x12\x1d\n\nstart_time\x18\x05 \x01(\x04R\tstartTime\x12\x19\n\x08\x65nd_time\x18\x06 \x01(\x04R\x07\x65ndTime\x12\x1e\n\nentrypoint\x18\x07 \x01(\tR\nentrypoint\x12*\n\x11\x64river_ip_address\x18\x08 \x01(\tR\x0f\x64riverIpAddress\x1a\xe8\x01\n\tJobConfig\x12G\n\x10runtime_env_info\x18\x01 \x01(\x0b\x32\x1d.ray.rpc.ExportRuntimeEnvInfoR\x0eruntimeEnvInfo\x12U\n\x08metadata\x18\x02 \x03(\x0b\x32\x39.ray.rpc.ExportDriverJobEventData.JobConfig.MetadataEntryR\x08metadata\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x62\x06proto3') + + + +_EXPORTDRIVERJOBEVENTDATA = DESCRIPTOR.message_types_by_name['ExportDriverJobEventData'] +_EXPORTDRIVERJOBEVENTDATA_JOBCONFIG = _EXPORTDRIVERJOBEVENTDATA.nested_types_by_name['JobConfig'] +_EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY = _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG.nested_types_by_name['MetadataEntry'] +ExportDriverJobEventData = _reflection.GeneratedProtocolMessageType('ExportDriverJobEventData', (_message.Message,), { + + 'JobConfig' : _reflection.GeneratedProtocolMessageType('JobConfig', (_message.Message,), { + + 'MetadataEntry' : _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY, + '__module__' : 'src.ray.protobuf.export_driver_job_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDriverJobEventData.JobConfig.MetadataEntry) + }) + , + 'DESCRIPTOR' : _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG, + '__module__' : 'src.ray.protobuf.export_driver_job_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDriverJobEventData.JobConfig) + }) + , + 'DESCRIPTOR' : _EXPORTDRIVERJOBEVENTDATA, + '__module__' : 'src.ray.protobuf.export_driver_job_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportDriverJobEventData) + }) +_sym_db.RegisterMessage(ExportDriverJobEventData) +_sym_db.RegisterMessage(ExportDriverJobEventData.JobConfig) +_sym_db.RegisterMessage(ExportDriverJobEventData.JobConfig.MetadataEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY._options = None + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY._serialized_options = b'8\001' + _EXPORTDRIVERJOBEVENTDATA._serialized_start=103 + _EXPORTDRIVERJOBEVENTDATA._serialized_end=646 + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG._serialized_start=414 + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG._serialized_end=646 + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY._serialized_start=587 + _EXPORTDRIVERJOBEVENTDATA_JOBCONFIG_METADATAENTRY._serialized_end=646 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_driver_job_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..35f3986d2c62ed99df01b1f40c5cd16e9c69a3a8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_event_pb2.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import export_task_event_pb2 as src_dot_ray_dot_protobuf_dot_export__task__event__pb2 +from . import export_node_data_pb2 as src_dot_ray_dot_protobuf_dot_export__node__data__pb2 +from . import export_actor_data_pb2 as src_dot_ray_dot_protobuf_dot_export__actor__data__pb2 +from . import export_driver_job_event_pb2 as src_dot_ray_dot_protobuf_dot_export__driver__job__event__pb2 +from . import export_submission_job_event_pb2 as src_dot_ray_dot_protobuf_dot_export__submission__job__event__pb2 +from . import export_train_state_pb2 as src_dot_ray_dot_protobuf_dot_export__train__state__pb2 +from . import export_dataset_operator_event_pb2 as src_dot_ray_dot_protobuf_dot_export__dataset__operator__event__pb2 +from . import export_dataset_metadata_pb2 as src_dot_ray_dot_protobuf_dot_export__dataset__metadata__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#src/ray/protobuf/export_event.proto\x12\x07ray.rpc\x1a(src/ray/protobuf/export_task_event.proto\x1a\'src/ray/protobuf/export_node_data.proto\x1a(src/ray/protobuf/export_actor_data.proto\x1a.src/ray/protobuf/export_driver_job_event.proto\x1a\x32src/ray/protobuf/export_submission_job_event.proto\x1a)src/ray/protobuf/export_train_state.proto\x1a\x34src/ray/protobuf/export_dataset_operator_event.proto\x1a.src/ray/protobuf/export_dataset_metadata.proto\"\x83\t\n\x0b\x45xportEvent\x12\x19\n\x08\x65vent_id\x18\x01 \x01(\tR\x07\x65ventId\x12@\n\x0bsource_type\x18\x02 \x01(\x0e\x32\x1f.ray.rpc.ExportEvent.SourceTypeR\nsourceType\x12\x1c\n\ttimestamp\x18\x03 \x01(\x03R\ttimestamp\x12\x46\n\x0ftask_event_data\x18\x04 \x01(\x0b\x32\x1c.ray.rpc.ExportTaskEventDataH\x00R\rtaskEventData\x12\x41\n\x0fnode_event_data\x18\x05 \x01(\x0b\x32\x17.ray.rpc.ExportNodeDataH\x00R\rnodeEventData\x12\x44\n\x10\x61\x63tor_event_data\x18\x06 \x01(\x0b\x32\x18.ray.rpc.ExportActorDataH\x00R\x0e\x61\x63torEventData\x12V\n\x15\x64river_job_event_data\x18\x07 \x01(\x0b\x32!.ray.rpc.ExportDriverJobEventDataH\x00R\x12\x64riverJobEventData\x12\x62\n\x19submission_job_event_data\x18\x08 \x01(\x0b\x32%.ray.rpc.ExportSubmissionJobEventDataH\x00R\x16submissionJobEventData\x12S\n\x14train_run_event_data\x18\t \x01(\x0b\x32 .ray.rpc.ExportTrainRunEventDataH\x00R\x11trainRunEventData\x12i\n\x1ctrain_run_attempt_event_data\x18\n \x01(\x0b\x32\'.ray.rpc.ExportTrainRunAttemptEventDataH\x00R\x18trainRunAttemptEventData\x12K\n\x10\x64\x61taset_metadata\x18\x0b \x01(\x0b\x32\x1e.ray.rpc.ExportDatasetMetadataH\x00R\x0f\x64\x61tasetMetadata\x12h\n\x1b\x64\x61taset_operator_event_data\x18\x0c \x01(\x0b\x32\'.ray.rpc.ExportDatasetOperatorEventDataH\x00R\x18\x64\x61tasetOperatorEventData\"\xe6\x01\n\nSourceType\x12\x0f\n\x0b\x45XPORT_TASK\x10\x00\x12\x0f\n\x0b\x45XPORT_NODE\x10\x01\x12\x10\n\x0c\x45XPORT_ACTOR\x10\x02\x12\x15\n\x11\x45XPORT_DRIVER_JOB\x10\x03\x12\x19\n\x15\x45XPORT_SUBMISSION_JOB\x10\x04\x12\x14\n\x10\x45XPORT_TRAIN_RUN\x10\x05\x12\x1c\n\x18\x45XPORT_TRAIN_RUN_ATTEMPT\x10\x06\x12\x1b\n\x17\x45XPORT_DATASET_METADATA\x10\x07\x12!\n\x1d\x45XPORT_DATASET_OPERATOR_EVENT\x10\x08\x42\x0c\n\nevent_datab\x06proto3') + + + +_EXPORTEVENT = DESCRIPTOR.message_types_by_name['ExportEvent'] +_EXPORTEVENT_SOURCETYPE = _EXPORTEVENT.enum_types_by_name['SourceType'] +ExportEvent = _reflection.GeneratedProtocolMessageType('ExportEvent', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTEVENT, + '__module__' : 'src.ray.protobuf.export_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportEvent) + }) +_sym_db.RegisterMessage(ExportEvent) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTEVENT._serialized_start=419 + _EXPORTEVENT._serialized_end=1574 + _EXPORTEVENT_SOURCETYPE._serialized_start=1330 + _EXPORTEVENT_SOURCETYPE._serialized_end=1560 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..75d266a0571e3cb7fda02d85a0a42ab884952e80 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_node_data.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'src/ray/protobuf/export_node_data.proto\x12\x07ray.rpc\"\xa2\x07\n\x0e\x45xportNodeData\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x30\n\x14node_manager_address\x18\x02 \x01(\tR\x12nodeManagerAddress\x12:\n\x05state\x18\x03 \x01(\x0e\x32$.ray.rpc.ExportNodeData.GcsNodeStateR\x05state\x12T\n\x0fresources_total\x18\x04 \x03(\x0b\x32+.ray.rpc.ExportNodeData.ResourcesTotalEntryR\x0eresourcesTotal\x12\x1b\n\tnode_name\x18\x05 \x01(\tR\x08nodeName\x12\"\n\rstart_time_ms\x18\x06 \x01(\x04R\x0bstartTimeMs\x12\x1e\n\x0b\x65nd_time_ms\x18\x07 \x01(\x04R\tendTimeMs\x12 \n\x0cis_head_node\x18\x08 \x01(\x08R\nisHeadNode\x12;\n\x06labels\x18\t \x03(\x0b\x32#.ray.rpc.ExportNodeData.LabelsEntryR\x06labels\x12\x44\n\ndeath_info\x18\n \x01(\x0b\x32%.ray.rpc.ExportNodeData.NodeDeathInfoR\tdeathInfo\x1a\x89\x02\n\rNodeDeathInfo\x12\x44\n\x06reason\x18\x01 \x01(\x0e\x32,.ray.rpc.ExportNodeData.NodeDeathInfo.ReasonR\x06reason\x12%\n\x0ereason_message\x18\x02 \x01(\tR\rreasonMessage\"\x8a\x01\n\x06Reason\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x18\n\x14\x45XPECTED_TERMINATION\x10\x01\x12\x1a\n\x16UNEXPECTED_TERMINATION\x10\x02\x12\x1e\n\x1a\x41UTOSCALER_DRAIN_PREEMPTED\x10\x03\x12\x19\n\x15\x41UTOSCALER_DRAIN_IDLE\x10\x04\x1a\x41\n\x13ResourcesTotalEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"#\n\x0cGcsNodeState\x12\t\n\x05\x41LIVE\x10\x00\x12\x08\n\x04\x44\x45\x41\x44\x10\x01\x62\x06proto3') + + + +_EXPORTNODEDATA = DESCRIPTOR.message_types_by_name['ExportNodeData'] +_EXPORTNODEDATA_NODEDEATHINFO = _EXPORTNODEDATA.nested_types_by_name['NodeDeathInfo'] +_EXPORTNODEDATA_RESOURCESTOTALENTRY = _EXPORTNODEDATA.nested_types_by_name['ResourcesTotalEntry'] +_EXPORTNODEDATA_LABELSENTRY = _EXPORTNODEDATA.nested_types_by_name['LabelsEntry'] +_EXPORTNODEDATA_NODEDEATHINFO_REASON = _EXPORTNODEDATA_NODEDEATHINFO.enum_types_by_name['Reason'] +_EXPORTNODEDATA_GCSNODESTATE = _EXPORTNODEDATA.enum_types_by_name['GcsNodeState'] +ExportNodeData = _reflection.GeneratedProtocolMessageType('ExportNodeData', (_message.Message,), { + + 'NodeDeathInfo' : _reflection.GeneratedProtocolMessageType('NodeDeathInfo', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTNODEDATA_NODEDEATHINFO, + '__module__' : 'src.ray.protobuf.export_node_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportNodeData.NodeDeathInfo) + }) + , + + 'ResourcesTotalEntry' : _reflection.GeneratedProtocolMessageType('ResourcesTotalEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTNODEDATA_RESOURCESTOTALENTRY, + '__module__' : 'src.ray.protobuf.export_node_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportNodeData.ResourcesTotalEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTNODEDATA_LABELSENTRY, + '__module__' : 'src.ray.protobuf.export_node_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportNodeData.LabelsEntry) + }) + , + 'DESCRIPTOR' : _EXPORTNODEDATA, + '__module__' : 'src.ray.protobuf.export_node_data_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportNodeData) + }) +_sym_db.RegisterMessage(ExportNodeData) +_sym_db.RegisterMessage(ExportNodeData.NodeDeathInfo) +_sym_db.RegisterMessage(ExportNodeData.ResourcesTotalEntry) +_sym_db.RegisterMessage(ExportNodeData.LabelsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTNODEDATA_RESOURCESTOTALENTRY._options = None + _EXPORTNODEDATA_RESOURCESTOTALENTRY._serialized_options = b'8\001' + _EXPORTNODEDATA_LABELSENTRY._options = None + _EXPORTNODEDATA_LABELSENTRY._serialized_options = b'8\001' + _EXPORTNODEDATA._serialized_start=53 + _EXPORTNODEDATA._serialized_end=983 + _EXPORTNODEDATA_NODEDEATHINFO._serialized_start=555 + _EXPORTNODEDATA_NODEDEATHINFO._serialized_end=820 + _EXPORTNODEDATA_NODEDEATHINFO_REASON._serialized_start=682 + _EXPORTNODEDATA_NODEDEATHINFO_REASON._serialized_end=820 + _EXPORTNODEDATA_RESOURCESTOTALENTRY._serialized_start=822 + _EXPORTNODEDATA_RESOURCESTOTALENTRY._serialized_end=887 + _EXPORTNODEDATA_LABELSENTRY._serialized_start=889 + _EXPORTNODEDATA_LABELSENTRY._serialized_end=946 + _EXPORTNODEDATA_GCSNODESTATE._serialized_start=948 + _EXPORTNODEDATA_GCSNODESTATE._serialized_end=983 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_node_data_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..4e3219e7ad6424ec55bec5cc65768e260f2d3d85 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_runtime_env.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)src/ray/protobuf/export_runtime_env.proto\x12\x07ray.rpc\"\xd9\x03\n\x14\x45xportRuntimeEnvInfo\x12\x34\n\x16serialized_runtime_env\x18\x01 \x01(\tR\x14serializedRuntimeEnv\x12@\n\x04uris\x18\x02 \x01(\x0b\x32,.ray.rpc.ExportRuntimeEnvInfo.RuntimeEnvUrisR\x04uris\x12\\\n\x12runtime_env_config\x18\x03 \x01(\x0b\x32..ray.rpc.ExportRuntimeEnvInfo.RuntimeEnvConfigR\x10runtimeEnvConfig\x1a`\n\x0eRuntimeEnvUris\x12&\n\x0fworking_dir_uri\x18\x01 \x01(\tR\rworkingDirUri\x12&\n\x0fpy_modules_uris\x18\x02 \x03(\tR\rpyModulesUris\x1a\x88\x01\n\x10RuntimeEnvConfig\x12\x32\n\x15setup_timeout_seconds\x18\x01 \x01(\x05R\x13setupTimeoutSeconds\x12#\n\reager_install\x18\x02 \x01(\x08R\x0c\x65\x61gerInstall\x12\x1b\n\tlog_files\x18\x03 \x03(\tR\x08logFilesb\x06proto3') + + + +_EXPORTRUNTIMEENVINFO = DESCRIPTOR.message_types_by_name['ExportRuntimeEnvInfo'] +_EXPORTRUNTIMEENVINFO_RUNTIMEENVURIS = _EXPORTRUNTIMEENVINFO.nested_types_by_name['RuntimeEnvUris'] +_EXPORTRUNTIMEENVINFO_RUNTIMEENVCONFIG = _EXPORTRUNTIMEENVINFO.nested_types_by_name['RuntimeEnvConfig'] +ExportRuntimeEnvInfo = _reflection.GeneratedProtocolMessageType('ExportRuntimeEnvInfo', (_message.Message,), { + + 'RuntimeEnvUris' : _reflection.GeneratedProtocolMessageType('RuntimeEnvUris', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTRUNTIMEENVINFO_RUNTIMEENVURIS, + '__module__' : 'src.ray.protobuf.export_runtime_env_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportRuntimeEnvInfo.RuntimeEnvUris) + }) + , + + 'RuntimeEnvConfig' : _reflection.GeneratedProtocolMessageType('RuntimeEnvConfig', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTRUNTIMEENVINFO_RUNTIMEENVCONFIG, + '__module__' : 'src.ray.protobuf.export_runtime_env_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportRuntimeEnvInfo.RuntimeEnvConfig) + }) + , + 'DESCRIPTOR' : _EXPORTRUNTIMEENVINFO, + '__module__' : 'src.ray.protobuf.export_runtime_env_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportRuntimeEnvInfo) + }) +_sym_db.RegisterMessage(ExportRuntimeEnvInfo) +_sym_db.RegisterMessage(ExportRuntimeEnvInfo.RuntimeEnvUris) +_sym_db.RegisterMessage(ExportRuntimeEnvInfo.RuntimeEnvConfig) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTRUNTIMEENVINFO._serialized_start=55 + _EXPORTRUNTIMEENVINFO._serialized_end=528 + _EXPORTRUNTIMEENVINFO_RUNTIMEENVURIS._serialized_start=293 + _EXPORTRUNTIMEENVINFO_RUNTIMEENVURIS._serialized_end=389 + _EXPORTRUNTIMEENVINFO_RUNTIMEENVCONFIG._serialized_start=392 + _EXPORTRUNTIMEENVINFO_RUNTIMEENVCONFIG._serialized_end=528 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_runtime_env_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..82578eb607455bdb76b4d88623de3fd6a2f7f810 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_submission_job_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n2src/ray/protobuf/export_submission_job_event.proto\x12\x07ray.rpc\"\xf2\x06\n\x1c\x45xportSubmissionJobEventData\x12*\n\x11submission_job_id\x18\x01 \x01(\tR\x0fsubmissionJobId\x12G\n\x06status\x18\x02 \x01(\x0e\x32/.ray.rpc.ExportSubmissionJobEventData.JobStatusR\x06status\x12\x1e\n\nentrypoint\x18\x03 \x01(\tR\nentrypoint\x12\x1d\n\x07message\x18\x04 \x01(\tH\x00R\x07message\x88\x01\x01\x12\"\n\nerror_type\x18\x05 \x01(\tH\x01R\terrorType\x88\x01\x01\x12\"\n\nstart_time\x18\x06 \x01(\x04H\x02R\tstartTime\x88\x01\x01\x12\x1e\n\x08\x65nd_time\x18\x07 \x01(\x04H\x03R\x07\x65ndTime\x88\x01\x01\x12O\n\x08metadata\x18\x08 \x03(\x0b\x32\x33.ray.rpc.ExportSubmissionJobEventData.MetadataEntryR\x08metadata\x12-\n\x10runtime_env_json\x18\t \x01(\tH\x04R\x0eruntimeEnvJson\x88\x01\x01\x12>\n\x19\x64river_agent_http_address\x18\n \x01(\tH\x05R\x16\x64riverAgentHttpAddress\x88\x01\x01\x12)\n\x0e\x64river_node_id\x18\x0b \x01(\tH\x06R\x0c\x64riverNodeId\x88\x01\x01\x12-\n\x10\x64river_exit_code\x18\x0c \x01(\x05H\x07R\x0e\x64riverExitCode\x88\x01\x01\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"M\n\tJobStatus\x12\x0b\n\x07PENDING\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\x0b\n\x07STOPPED\x10\x02\x12\r\n\tSUCCEEDED\x10\x03\x12\n\n\x06\x46\x41ILED\x10\x04\x42\n\n\x08_messageB\r\n\x0b_error_typeB\r\n\x0b_start_timeB\x0b\n\t_end_timeB\x13\n\x11_runtime_env_jsonB\x1c\n\x1a_driver_agent_http_addressB\x11\n\x0f_driver_node_idB\x13\n\x11_driver_exit_codeb\x06proto3') + + + +_EXPORTSUBMISSIONJOBEVENTDATA = DESCRIPTOR.message_types_by_name['ExportSubmissionJobEventData'] +_EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY = _EXPORTSUBMISSIONJOBEVENTDATA.nested_types_by_name['MetadataEntry'] +_EXPORTSUBMISSIONJOBEVENTDATA_JOBSTATUS = _EXPORTSUBMISSIONJOBEVENTDATA.enum_types_by_name['JobStatus'] +ExportSubmissionJobEventData = _reflection.GeneratedProtocolMessageType('ExportSubmissionJobEventData', (_message.Message,), { + + 'MetadataEntry' : _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY, + '__module__' : 'src.ray.protobuf.export_submission_job_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportSubmissionJobEventData.MetadataEntry) + }) + , + 'DESCRIPTOR' : _EXPORTSUBMISSIONJOBEVENTDATA, + '__module__' : 'src.ray.protobuf.export_submission_job_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportSubmissionJobEventData) + }) +_sym_db.RegisterMessage(ExportSubmissionJobEventData) +_sym_db.RegisterMessage(ExportSubmissionJobEventData.MetadataEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY._options = None + _EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY._serialized_options = b'8\001' + _EXPORTSUBMISSIONJOBEVENTDATA._serialized_start=64 + _EXPORTSUBMISSIONJOBEVENTDATA._serialized_end=946 + _EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY._serialized_start=662 + _EXPORTSUBMISSIONJOBEVENTDATA_METADATAENTRY._serialized_end=721 + _EXPORTSUBMISSIONJOBEVENTDATA_JOBSTATUS._serialized_start=723 + _EXPORTSUBMISSIONJOBEVENTDATA_JOBSTATUS._serialized_end=800 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_submission_job_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..bb6fac4729b89a0a3fc3270e510c177daad14db6 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_task_event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import export_runtime_env_pb2 as src_dot_ray_dot_protobuf_dot_export__runtime__env__pb2 +from . import profile_events_pb2 as src_dot_ray_dot_protobuf_dot_profile__events__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n(src/ray/protobuf/export_task_event.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a)src/ray/protobuf/export_runtime_env.proto\x1a%src/ray/protobuf/profile_events.proto\"\x8d\x12\n\x13\x45xportTaskEventData\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12%\n\x0e\x61ttempt_number\x18\x02 \x01(\x05R\rattemptNumber\x12L\n\ttask_info\x18\x03 \x01(\x0b\x32*.ray.rpc.ExportTaskEventData.TaskInfoEntryH\x00R\x08taskInfo\x88\x01\x01\x12V\n\rstate_updates\x18\x04 \x01(\x0b\x32,.ray.rpc.ExportTaskEventData.TaskStateUpdateH\x01R\x0cstateUpdates\x88\x01\x01\x12\x42\n\x0eprofile_events\x18\x05 \x01(\x0b\x32\x16.ray.rpc.ProfileEventsH\x02R\rprofileEvents\x88\x01\x01\x12\x15\n\x06job_id\x18\x06 \x01(\x0cR\x05jobId\x1a\x66\n\x0cRayErrorInfo\x12#\n\rerror_message\x18\x01 \x01(\tR\x0c\x65rrorMessage\x12\x31\n\nerror_type\x18\x02 \x01(\x0e\x32\x12.ray.rpc.ErrorTypeR\terrorType\x1a\xd1\x02\n\x0bTaskLogInfo\x12$\n\x0bstdout_file\x18\x01 \x01(\tH\x00R\nstdoutFile\x88\x01\x01\x12$\n\x0bstderr_file\x18\x02 \x01(\tH\x01R\nstderrFile\x88\x01\x01\x12&\n\x0cstdout_start\x18\x03 \x01(\x05H\x02R\x0bstdoutStart\x88\x01\x01\x12\"\n\nstdout_end\x18\x04 \x01(\x05H\x03R\tstdoutEnd\x88\x01\x01\x12&\n\x0cstderr_start\x18\x05 \x01(\x05H\x04R\x0bstderrStart\x88\x01\x01\x12\"\n\nstderr_end\x18\x06 \x01(\x05H\x05R\tstderrEnd\x88\x01\x01\x42\x0e\n\x0c_stdout_fileB\x0e\n\x0c_stderr_fileB\x0f\n\r_stdout_startB\r\n\x0b_stdout_endB\x0f\n\r_stderr_startB\r\n\x0b_stderr_end\x1a\xc6\x04\n\x0fTaskStateUpdate\x12\x1c\n\x07node_id\x18\x01 \x01(\x0cH\x00R\x06nodeId\x88\x01\x01\x12 \n\tworker_id\x18\x02 \x01(\x0cH\x01R\x08workerId\x88\x01\x01\x12M\n\nerror_info\x18\x03 \x01(\x0b\x32).ray.rpc.ExportTaskEventData.RayErrorInfoH\x02R\terrorInfo\x88\x01\x01\x12Q\n\rtask_log_info\x18\x04 \x01(\x0b\x32(.ray.rpc.ExportTaskEventData.TaskLogInfoH\x03R\x0btaskLogInfo\x88\x01\x01\x12\"\n\nworker_pid\x18\x05 \x01(\x05H\x04R\tworkerPid\x88\x01\x01\x12\x31\n\x12is_debugger_paused\x18\x06 \x01(\x08H\x05R\x10isDebuggerPaused\x88\x01\x01\x12[\n\x0bstate_ts_ns\x18\x07 \x03(\x0b\x32;.ray.rpc.ExportTaskEventData.TaskStateUpdate.StateTsNsEntryR\tstateTsNs\x1a<\n\x0eStateTsNsEntry\x12\x10\n\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n\x05value\x18\x02 \x01(\x03R\x05value:\x02\x38\x01\x42\n\n\x08_node_idB\x0c\n\n_worker_idB\r\n\x0b_error_infoB\x10\n\x0e_task_log_infoB\r\n\x0b_worker_pidB\x15\n\x13_is_debugger_paused\x1a\xfc\x06\n\rTaskInfoEntry\x12%\n\x04type\x18\x01 \x01(\x0e\x32\x11.ray.rpc.TaskTypeR\x04type\x12-\n\x08language\x18\x02 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12+\n\x12\x66unc_or_class_name\x18\x03 \x01(\tR\x0f\x66uncOrClassName\x12\x17\n\x07task_id\x18\x04 \x01(\x0cR\x06taskId\x12$\n\x0eparent_task_id\x18\x05 \x01(\x0cR\x0cparentTaskId\x12p\n\x12required_resources\x18\x06 \x03(\x0b\x32\x41.ray.rpc.ExportTaskEventData.TaskInfoEntry.RequiredResourcesEntryR\x11requiredResources\x12G\n\x10runtime_env_info\x18\x07 \x01(\x0b\x32\x1d.ray.rpc.ExportRuntimeEnvInfoR\x0eruntimeEnvInfo\x12\x1e\n\x08\x61\x63tor_id\x18\x08 \x01(\x0cH\x00R\x07\x61\x63torId\x88\x01\x01\x12\x31\n\x12placement_group_id\x18\t \x01(\x0cH\x01R\x10placementGroupId\x88\x01\x01\x12N\n\x06labels\x18\n \x03(\x0b\x32\x36.ray.rpc.ExportTaskEventData.TaskInfoEntry.LabelsEntryR\x06labels\x12\x64\n\x0elabel_selector\x18\x0b \x03(\x0b\x32=.ray.rpc.ExportTaskEventData.TaskInfoEntry.LabelSelectorEntryR\rlabelSelector\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x0b\n\t_actor_idB\x15\n\x13_placement_group_idB\x0c\n\n_task_infoB\x10\n\x0e_state_updatesB\x11\n\x0f_profile_eventsb\x06proto3') + + + +_EXPORTTASKEVENTDATA = DESCRIPTOR.message_types_by_name['ExportTaskEventData'] +_EXPORTTASKEVENTDATA_RAYERRORINFO = _EXPORTTASKEVENTDATA.nested_types_by_name['RayErrorInfo'] +_EXPORTTASKEVENTDATA_TASKLOGINFO = _EXPORTTASKEVENTDATA.nested_types_by_name['TaskLogInfo'] +_EXPORTTASKEVENTDATA_TASKSTATEUPDATE = _EXPORTTASKEVENTDATA.nested_types_by_name['TaskStateUpdate'] +_EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY = _EXPORTTASKEVENTDATA_TASKSTATEUPDATE.nested_types_by_name['StateTsNsEntry'] +_EXPORTTASKEVENTDATA_TASKINFOENTRY = _EXPORTTASKEVENTDATA.nested_types_by_name['TaskInfoEntry'] +_EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY = _EXPORTTASKEVENTDATA_TASKINFOENTRY.nested_types_by_name['RequiredResourcesEntry'] +_EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY = _EXPORTTASKEVENTDATA_TASKINFOENTRY.nested_types_by_name['LabelsEntry'] +_EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY = _EXPORTTASKEVENTDATA_TASKINFOENTRY.nested_types_by_name['LabelSelectorEntry'] +ExportTaskEventData = _reflection.GeneratedProtocolMessageType('ExportTaskEventData', (_message.Message,), { + + 'RayErrorInfo' : _reflection.GeneratedProtocolMessageType('RayErrorInfo', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_RAYERRORINFO, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.RayErrorInfo) + }) + , + + 'TaskLogInfo' : _reflection.GeneratedProtocolMessageType('TaskLogInfo', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKLOGINFO, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskLogInfo) + }) + , + + 'TaskStateUpdate' : _reflection.GeneratedProtocolMessageType('TaskStateUpdate', (_message.Message,), { + + 'StateTsNsEntry' : _reflection.GeneratedProtocolMessageType('StateTsNsEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskStateUpdate.StateTsNsEntry) + }) + , + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKSTATEUPDATE, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskStateUpdate) + }) + , + + 'TaskInfoEntry' : _reflection.GeneratedProtocolMessageType('TaskInfoEntry', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskInfoEntry.RequiredResourcesEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskInfoEntry.LabelsEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskInfoEntry.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA_TASKINFOENTRY, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData.TaskInfoEntry) + }) + , + 'DESCRIPTOR' : _EXPORTTASKEVENTDATA, + '__module__' : 'src.ray.protobuf.export_task_event_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTaskEventData) + }) +_sym_db.RegisterMessage(ExportTaskEventData) +_sym_db.RegisterMessage(ExportTaskEventData.RayErrorInfo) +_sym_db.RegisterMessage(ExportTaskEventData.TaskLogInfo) +_sym_db.RegisterMessage(ExportTaskEventData.TaskStateUpdate) +_sym_db.RegisterMessage(ExportTaskEventData.TaskStateUpdate.StateTsNsEntry) +_sym_db.RegisterMessage(ExportTaskEventData.TaskInfoEntry) +_sym_db.RegisterMessage(ExportTaskEventData.TaskInfoEntry.RequiredResourcesEntry) +_sym_db.RegisterMessage(ExportTaskEventData.TaskInfoEntry.LabelsEntry) +_sym_db.RegisterMessage(ExportTaskEventData.TaskInfoEntry.LabelSelectorEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY._options = None + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY._serialized_options = b'8\001' + _EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY._options = None + _EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY._options = None + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY._serialized_options = b'8\001' + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY._options = None + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY._serialized_options = b'8\001' + _EXPORTTASKEVENTDATA._serialized_start=167 + _EXPORTTASKEVENTDATA._serialized_end=2484 + _EXPORTTASKEVENTDATA_RAYERRORINFO._serialized_start=511 + _EXPORTTASKEVENTDATA_RAYERRORINFO._serialized_end=613 + _EXPORTTASKEVENTDATA_TASKLOGINFO._serialized_start=616 + _EXPORTTASKEVENTDATA_TASKLOGINFO._serialized_end=953 + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE._serialized_start=956 + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE._serialized_end=1538 + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY._serialized_start=1381 + _EXPORTTASKEVENTDATA_TASKSTATEUPDATE_STATETSNSENTRY._serialized_end=1441 + _EXPORTTASKEVENTDATA_TASKINFOENTRY._serialized_start=1541 + _EXPORTTASKEVENTDATA_TASKINFOENTRY._serialized_end=2433 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_start=2204 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_REQUIREDRESOURCESENTRY._serialized_end=2272 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY._serialized_start=2274 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSENTRY._serialized_end=2331 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY._serialized_start=2333 + _EXPORTTASKEVENTDATA_TASKINFOENTRY_LABELSELECTORENTRY._serialized_end=2397 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_task_event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2.py b/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..16e701da78abf2328cf35475d781c9b5f197c687 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/export_train_state.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)src/ray/protobuf/export_train_state.proto\x12\x07ray.rpc\"\xb6\x07\n\x17\x45xportTrainRunEventData\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12\x0e\n\x02id\x18\x02 \x01(\tR\x02id\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x15\n\x06job_id\x18\x04 \x01(\x0cR\x05jobId\x12.\n\x13\x63ontroller_actor_id\x18\x05 \x01(\x0cR\x11\x63ontrollerActorId\x12\x42\n\x06status\x18\x06 \x01(\x0e\x32*.ray.rpc.ExportTrainRunEventData.RunStatusR\x06status\x12(\n\rstatus_detail\x18\x07 \x01(\tH\x00R\x0cstatusDetail\x88\x01\x01\x12\"\n\rstart_time_ns\x18\x08 \x01(\x04R\x0bstartTimeNs\x12#\n\x0b\x65nd_time_ns\x18\t \x01(\x04H\x01R\tendTimeNs\x88\x01\x01\x12<\n\x18\x63ontroller_log_file_path\x18\n \x01(\tH\x02R\x15\x63ontrollerLogFilePath\x88\x01\x01\x12*\n\x11ray_train_version\x18\x0b \x01(\rR\x0frayTrainVersion\x12\x61\n\x10train_run_panels\x18\x0c \x03(\x0b\x32\x37.ray.rpc.ExportTrainRunEventData.DashboardPanelMetadataR\x0etrainRunPanels\x12g\n\x13train_worker_panels\x18\r \x03(\x0b\x32\x37.ray.rpc.ExportTrainRunEventData.DashboardPanelMetadataR\x11trainWorkerPanels\x1a>\n\x16\x44\x61shboardPanelMetadata\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\"\x9c\x01\n\tRunStatus\x12\x1a\n\x16RUN_STATUS_UNSPECIFIED\x10\x00\x12\x10\n\x0cINITIALIZING\x10\x01\x12\x0e\n\nSCHEDULING\x10\x02\x12\x0b\n\x07RUNNING\x10\x03\x12\x0e\n\nRESTARTING\x10\x04\x12\x0c\n\x08RESIZING\x10\x05\x12\x0c\n\x08\x46INISHED\x10\x06\x12\x0b\n\x07\x45RRORED\x10\x07\x12\x0b\n\x07\x41\x42ORTED\x10\x08\x42\x10\n\x0e_status_detailB\x0e\n\x0c_end_time_nsB\x1b\n\x19_controller_log_file_path\"\xf8\n\n\x1e\x45xportTrainRunAttemptEventData\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12\x15\n\x06run_id\x18\x02 \x01(\tR\x05runId\x12\x1d\n\nattempt_id\x18\x03 \x01(\tR\tattemptId\x12P\n\x06status\x18\x04 \x01(\x0e\x32\x38.ray.rpc.ExportTrainRunAttemptEventData.RunAttemptStatusR\x06status\x12(\n\rstatus_detail\x18\x05 \x01(\tH\x00R\x0cstatusDetail\x88\x01\x01\x12\"\n\rstart_time_ns\x18\x06 \x01(\x04R\x0bstartTimeNs\x12#\n\x0b\x65nd_time_ns\x18\x07 \x01(\x04H\x01R\tendTimeNs\x88\x01\x01\x12T\n\tresources\x18\x08 \x03(\x0b\x32\x36.ray.rpc.ExportTrainRunAttemptEventData.TrainResourcesR\tresources\x12M\n\x07workers\x18\t \x03(\x0b\x32\x33.ray.rpc.ExportTrainRunAttemptEventData.TrainWorkerR\x07workers\x12*\n\x11ray_train_version\x18\n \x01(\rR\x0frayTrainVersion\x1a\xb3\x01\n\x0eTrainResources\x12\x63\n\tresources\x18\x01 \x03(\x0b\x32\x45.ray.rpc.ExportTrainRunAttemptEventData.TrainResources.ResourcesEntryR\tresources\x1a<\n\x0eResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\xce\x03\n\x0bTrainWorker\x12\x1d\n\nworld_rank\x18\x01 \x01(\x05R\tworldRank\x12\x1d\n\nlocal_rank\x18\x02 \x01(\x05R\tlocalRank\x12\x1b\n\tnode_rank\x18\x03 \x01(\x05R\x08nodeRank\x12\x19\n\x08\x61\x63tor_id\x18\x04 \x01(\x0cR\x07\x61\x63torId\x12\x17\n\x07node_id\x18\x05 \x01(\x0cR\x06nodeId\x12\x17\n\x07node_ip\x18\x06 \x01(\tR\x06nodeIp\x12\x10\n\x03pid\x18\x07 \x01(\x05R\x03pid\x12\x17\n\x07gpu_ids\x18\x08 \x03(\x05R\x06gpuIds\x12P\n\x06status\x18\t \x01(\x0e\x32\x33.ray.rpc.ExportTrainRunAttemptEventData.ActorStatusH\x00R\x06status\x88\x01\x01\x12T\n\tresources\x18\n \x01(\x0b\x32\x36.ray.rpc.ExportTrainRunAttemptEventData.TrainResourcesR\tresources\x12\'\n\rlog_file_path\x18\x0b \x01(\tH\x01R\x0blogFilePath\x88\x01\x01\x42\t\n\x07_statusB\x10\n\x0e_log_file_path\"x\n\x10RunAttemptStatus\x12\"\n\x1eRUN_ATTEMPT_STATUS_UNSPECIFIED\x10\x00\x12\x0b\n\x07PENDING\x10\x01\x12\x0b\n\x07RUNNING\x10\x02\x12\x0c\n\x08\x46INISHED\x10\x03\x12\x0b\n\x07\x45RRORED\x10\x04\x12\x0b\n\x07\x41\x42ORTED\x10\x05\"@\n\x0b\x41\x63torStatus\x12\x1c\n\x18\x41\x43TOR_STATUS_UNSPECIFIED\x10\x00\x12\t\n\x05\x41LIVE\x10\x01\x12\x08\n\x04\x44\x45\x41\x44\x10\x02\x42\x10\n\x0e_status_detailB\x0e\n\x0c_end_time_nsB\x03\xf8\x01\x01\x62\x06proto3') + + + +_EXPORTTRAINRUNEVENTDATA = DESCRIPTOR.message_types_by_name['ExportTrainRunEventData'] +_EXPORTTRAINRUNEVENTDATA_DASHBOARDPANELMETADATA = _EXPORTTRAINRUNEVENTDATA.nested_types_by_name['DashboardPanelMetadata'] +_EXPORTTRAINRUNATTEMPTEVENTDATA = DESCRIPTOR.message_types_by_name['ExportTrainRunAttemptEventData'] +_EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES = _EXPORTTRAINRUNATTEMPTEVENTDATA.nested_types_by_name['TrainResources'] +_EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY = _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES.nested_types_by_name['ResourcesEntry'] +_EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINWORKER = _EXPORTTRAINRUNATTEMPTEVENTDATA.nested_types_by_name['TrainWorker'] +_EXPORTTRAINRUNEVENTDATA_RUNSTATUS = _EXPORTTRAINRUNEVENTDATA.enum_types_by_name['RunStatus'] +_EXPORTTRAINRUNATTEMPTEVENTDATA_RUNATTEMPTSTATUS = _EXPORTTRAINRUNATTEMPTEVENTDATA.enum_types_by_name['RunAttemptStatus'] +_EXPORTTRAINRUNATTEMPTEVENTDATA_ACTORSTATUS = _EXPORTTRAINRUNATTEMPTEVENTDATA.enum_types_by_name['ActorStatus'] +ExportTrainRunEventData = _reflection.GeneratedProtocolMessageType('ExportTrainRunEventData', (_message.Message,), { + + 'DashboardPanelMetadata' : _reflection.GeneratedProtocolMessageType('DashboardPanelMetadata', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTRAINRUNEVENTDATA_DASHBOARDPANELMETADATA, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunEventData.DashboardPanelMetadata) + }) + , + 'DESCRIPTOR' : _EXPORTTRAINRUNEVENTDATA, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunEventData) + }) +_sym_db.RegisterMessage(ExportTrainRunEventData) +_sym_db.RegisterMessage(ExportTrainRunEventData.DashboardPanelMetadata) + +ExportTrainRunAttemptEventData = _reflection.GeneratedProtocolMessageType('ExportTrainRunAttemptEventData', (_message.Message,), { + + 'TrainResources' : _reflection.GeneratedProtocolMessageType('TrainResources', (_message.Message,), { + + 'ResourcesEntry' : _reflection.GeneratedProtocolMessageType('ResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunAttemptEventData.TrainResources.ResourcesEntry) + }) + , + 'DESCRIPTOR' : _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunAttemptEventData.TrainResources) + }) + , + + 'TrainWorker' : _reflection.GeneratedProtocolMessageType('TrainWorker', (_message.Message,), { + 'DESCRIPTOR' : _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINWORKER, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunAttemptEventData.TrainWorker) + }) + , + 'DESCRIPTOR' : _EXPORTTRAINRUNATTEMPTEVENTDATA, + '__module__' : 'src.ray.protobuf.export_train_state_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ExportTrainRunAttemptEventData) + }) +_sym_db.RegisterMessage(ExportTrainRunAttemptEventData) +_sym_db.RegisterMessage(ExportTrainRunAttemptEventData.TrainResources) +_sym_db.RegisterMessage(ExportTrainRunAttemptEventData.TrainResources.ResourcesEntry) +_sym_db.RegisterMessage(ExportTrainRunAttemptEventData.TrainWorker) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\370\001\001' + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY._options = None + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY._serialized_options = b'8\001' + _EXPORTTRAINRUNEVENTDATA._serialized_start=55 + _EXPORTTRAINRUNEVENTDATA._serialized_end=1005 + _EXPORTTRAINRUNEVENTDATA_DASHBOARDPANELMETADATA._serialized_start=721 + _EXPORTTRAINRUNEVENTDATA_DASHBOARDPANELMETADATA._serialized_end=783 + _EXPORTTRAINRUNEVENTDATA_RUNSTATUS._serialized_start=786 + _EXPORTTRAINRUNEVENTDATA_RUNSTATUS._serialized_end=942 + _EXPORTTRAINRUNATTEMPTEVENTDATA._serialized_start=1008 + _EXPORTTRAINRUNATTEMPTEVENTDATA._serialized_end=2408 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES._serialized_start=1542 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES._serialized_end=1721 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY._serialized_start=1661 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINRESOURCES_RESOURCESENTRY._serialized_end=1721 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINWORKER._serialized_start=1724 + _EXPORTTRAINRUNATTEMPTEVENTDATA_TRAINWORKER._serialized_end=2186 + _EXPORTTRAINRUNATTEMPTEVENTDATA_RUNATTEMPTSTATUS._serialized_start=2188 + _EXPORTTRAINRUNATTEMPTEVENTDATA_RUNATTEMPTSTATUS._serialized_end=2308 + _EXPORTTRAINRUNATTEMPTEVENTDATA_ACTORSTATUS._serialized_start=2310 + _EXPORTTRAINRUNATTEMPTEVENTDATA_ACTORSTATUS._serialized_end=2374 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/export_train_state_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/gcs_pb2.py b/lib/python3.12/site-packages/ray/core/generated/gcs_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..9156ac4aff499fdb48faef022b34163023fa8f9f --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/gcs_pb2.py @@ -0,0 +1,538 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/gcs.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import profile_events_pb2 as src_dot_ray_dot_protobuf_dot_profile__events__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1asrc/ray/protobuf/gcs.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a%src/ray/protobuf/profile_events.proto\"m\n\x08GcsEntry\x12\x37\n\x0b\x63hange_mode\x18\x01 \x01(\x0e\x32\x16.ray.rpc.GcsChangeModeR\nchangeMode\x12\x0e\n\x02id\x18\x02 \x01(\x0cR\x02id\x12\x18\n\x07\x65ntries\x18\x03 \x03(\x0cR\x07\x65ntries\"\xce\x0c\n\x0e\x41\x63torTableData\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x1b\n\tparent_id\x18\x02 \x01(\x0cR\x08parentId\x12\x15\n\x06job_id\x18\x04 \x01(\x0cR\x05jobId\x12\x38\n\x05state\x18\x06 \x01(\x0e\x32\".ray.rpc.ActorTableData.ActorStateR\x05state\x12!\n\x0cmax_restarts\x18\x07 \x01(\x03R\x0bmaxRestarts\x12!\n\x0cnum_restarts\x18\x08 \x01(\x03R\x0bnumRestarts\x12*\n\x07\x61\x64\x64ress\x18\t \x01(\x0b\x32\x10.ray.rpc.AddressR\x07\x61\x64\x64ress\x12\x35\n\rowner_address\x18\n \x01(\x0b\x32\x10.ray.rpc.AddressR\x0cownerAddress\x12\x1f\n\x0bis_detached\x18\x0b \x01(\x08R\nisDetached\x12\x12\n\x04name\x18\x0c \x01(\tR\x04name\x12\x1c\n\ttimestamp\x18\r \x01(\x01R\ttimestamp\x12\x44\n\x10resource_mapping\x18\x0f \x03(\x0b\x32\x19.ray.rpc.ResourceMapEntryR\x0fresourceMapping\x12\x10\n\x03pid\x18\x10 \x01(\rR\x03pid\x12L\n\x13\x66unction_descriptor\x18\x11 \x01(\x0b\x32\x1b.ray.rpc.FunctionDescriptorR\x12\x66unctionDescriptor\x12#\n\rray_namespace\x18\x13 \x01(\tR\x0crayNamespace\x12\x1d\n\nstart_time\x18\x14 \x01(\x04R\tstartTime\x12\x19\n\x08\x65nd_time\x18\x15 \x01(\x04R\x07\x65ndTime\x12\x34\n\x16serialized_runtime_env\x18\x16 \x01(\tR\x14serializedRuntimeEnv\x12\x1d\n\nclass_name\x18\x17 \x01(\tR\tclassName\x12\x39\n\x0b\x64\x65\x61th_cause\x18\x18 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseR\ndeathCause\x12]\n\x12required_resources\x18\x1c \x03(\x0b\x32..ray.rpc.ActorTableData.RequiredResourcesEntryR\x11requiredResources\x12\x1c\n\x07node_id\x18\x1d \x01(\x0cH\x00R\x06nodeId\x88\x01\x01\x12\x31\n\x12placement_group_id\x18\x1e \x01(\x0cH\x01R\x10placementGroupId\x88\x01\x01\x12\x1b\n\trepr_name\x18\x1f \x01(\tR\x08reprName\x12\x1c\n\tpreempted\x18 \x01(\x08R\tpreempted\x12Y\n*num_restarts_due_to_lineage_reconstruction\x18! \x01(\x04R%numRestartsDueToLineageReconstruction\x12 \n\tcall_site\x18\" \x01(\tH\x02R\x08\x63\x61llSite\x88\x01\x01\x12Q\n\x0elabel_selector\x18# \x03(\x0b\x32*.ray.rpc.ActorTableData.LabelSelectorEntryR\rlabelSelector\x12K\n#num_restarts_due_to_node_preemption\x18$ \x01(\x04R\x1enumRestartsDueToNodePreemption\x1a\x44\n\x16RequiredResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a@\n\x12LabelSelectorEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"a\n\nActorState\x12\x18\n\x14\x44\x45PENDENCIES_UNREADY\x10\x00\x12\x14\n\x10PENDING_CREATION\x10\x01\x12\t\n\x05\x41LIVE\x10\x02\x12\x0e\n\nRESTARTING\x10\x03\x12\x08\n\x04\x44\x45\x41\x44\x10\x04\x42\n\n\x08_node_idB\x15\n\x13_placement_group_idB\x0c\n\n_call_site\"~\n\x0e\x45rrorTableData\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x12\n\x04type\x18\x02 \x01(\tR\x04type\x12#\n\rerror_message\x18\x03 \x01(\tR\x0c\x65rrorMessage\x12\x1c\n\ttimestamp\x18\x04 \x01(\x01R\ttimestamp\"\xd1\x02\n\x0bTaskLogInfo\x12$\n\x0bstdout_file\x18\x01 \x01(\tH\x00R\nstdoutFile\x88\x01\x01\x12$\n\x0bstderr_file\x18\x02 \x01(\tH\x01R\nstderrFile\x88\x01\x01\x12&\n\x0cstdout_start\x18\x03 \x01(\x05H\x02R\x0bstdoutStart\x88\x01\x01\x12\"\n\nstdout_end\x18\x04 \x01(\x05H\x03R\tstdoutEnd\x88\x01\x01\x12&\n\x0cstderr_start\x18\x05 \x01(\x05H\x04R\x0bstderrStart\x88\x01\x01\x12\"\n\nstderr_end\x18\x06 \x01(\x05H\x05R\tstderrEnd\x88\x01\x01\x42\x0e\n\x0c_stdout_fileB\x0e\n\x0c_stderr_fileB\x0f\n\r_stdout_startB\r\n\x0b_stdout_endB\x0f\n\r_stderr_startB\r\n\x0b_stderr_end\"\xcb\x04\n\x0fTaskStateUpdate\x12\x1c\n\x07node_id\x18\x01 \x01(\x0cH\x00R\x06nodeId\x88\x01\x01\x12 \n\tworker_id\x18\x08 \x01(\x0cH\x01R\x08workerId\x88\x01\x01\x12\x39\n\nerror_info\x18\t \x01(\x0b\x32\x15.ray.rpc.RayErrorInfoH\x02R\terrorInfo\x88\x01\x01\x12=\n\rtask_log_info\x18\n \x01(\x0b\x32\x14.ray.rpc.TaskLogInfoH\x03R\x0btaskLogInfo\x88\x01\x01\x12+\n\x0f\x61\x63tor_repr_name\x18\x0b \x01(\tH\x04R\ractorReprName\x88\x01\x01\x12\"\n\nworker_pid\x18\x0c \x01(\x05H\x05R\tworkerPid\x88\x01\x01\x12\x31\n\x12is_debugger_paused\x18\r \x01(\x08H\x06R\x10isDebuggerPaused\x88\x01\x01\x12G\n\x0bstate_ts_ns\x18\x0e \x03(\x0b\x32\'.ray.rpc.TaskStateUpdate.StateTsNsEntryR\tstateTsNs\x1a<\n\x0eStateTsNsEntry\x12\x10\n\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n\x05value\x18\x02 \x01(\x03R\x05value:\x02\x38\x01\x42\n\n\x08_node_idB\x0c\n\n_worker_idB\r\n\x0b_error_infoB\x10\n\x0e_task_log_infoB\x12\n\x10_actor_repr_nameB\r\n\x0b_worker_pidB\x15\n\x13_is_debugger_paused\"\xd8\x02\n\nTaskEvents\x12\x17\n\x07task_id\x18\x01 \x01(\x0cR\x06taskId\x12%\n\x0e\x61ttempt_number\x18\x02 \x01(\x05R\rattemptNumber\x12\x38\n\ttask_info\x18\x03 \x01(\x0b\x32\x16.ray.rpc.TaskInfoEntryH\x00R\x08taskInfo\x88\x01\x01\x12\x42\n\rstate_updates\x18\x04 \x01(\x0b\x32\x18.ray.rpc.TaskStateUpdateH\x01R\x0cstateUpdates\x88\x01\x01\x12\x42\n\x0eprofile_events\x18\x05 \x01(\x0b\x32\x16.ray.rpc.ProfileEventsH\x02R\rprofileEvents\x88\x01\x01\x12\x15\n\x06job_id\x18\x06 \x01(\x0cR\x05jobIdB\x0c\n\n_task_infoB\x10\n\x0e_state_updatesB\x11\n\x0f_profile_events\"\xe8\x01\n\rTaskEventData\x12\x39\n\x0e\x65vents_by_task\x18\x01 \x03(\x0b\x32\x13.ray.rpc.TaskEventsR\x0c\x65ventsByTask\x12H\n\x15\x64ropped_task_attempts\x18\x02 \x03(\x0b\x32\x14.ray.rpc.TaskAttemptR\x13\x64roppedTaskAttempts\x12;\n\x1anum_profile_events_dropped\x18\x03 \x01(\x05R\x17numProfileEventsDropped\x12\x15\n\x06job_id\x18\x04 \x01(\x0cR\x05jobId\"\xda\x01\n\x12\x41vailableResources\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x64\n\x13resources_available\x18\x02 \x03(\x0b\x32\x33.ray.rpc.AvailableResources.ResourcesAvailableEntryR\x12resourcesAvailable\x1a\x45\n\x17ResourcesAvailableEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\xc2\x01\n\x0eTotalResources\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12T\n\x0fresources_total\x18\x02 \x03(\x0b\x32+.ray.rpc.TotalResources.ResourcesTotalEntryR\x0eresourcesTotal\x1a\x41\n\x13ResourcesTotalEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\xcc\x01\n\x0cNodeSnapshot\x12\x31\n\x05state\x18\x01 \x01(\x0e\x32\x1b.ray.rpc.NodeSnapshot.StateR\x05state\x12(\n\x10idle_duration_ms\x18\x02 \x01(\x03R\x0eidleDurationMs\x12#\n\rnode_activity\x18\x03 \x03(\tR\x0cnodeActivity\":\n\x05State\x12\r\n\tUNDEFINED\x10\x00\x12\x08\n\x04IDLE\x10\x01\x12\n\n\x06\x41\x43TIVE\x10\x02\x12\x0c\n\x08\x44RAINING\x10\x03\"\x8a\t\n\x0bGcsNodeInfo\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x30\n\x14node_manager_address\x18\x02 \x01(\tR\x12nodeManagerAddress\x12,\n\x12raylet_socket_name\x18\x03 \x01(\tR\x10rayletSocketName\x12\x37\n\x18object_store_socket_name\x18\x04 \x01(\tR\x15objectStoreSocketName\x12*\n\x11node_manager_port\x18\x05 \x01(\x05R\x0fnodeManagerPort\x12.\n\x13object_manager_port\x18\x06 \x01(\x05R\x11objectManagerPort\x12\x37\n\x05state\x18\x07 \x01(\x0e\x32!.ray.rpc.GcsNodeInfo.GcsNodeStateR\x05state\x12\x32\n\x15node_manager_hostname\x18\x08 \x01(\tR\x13nodeManagerHostname\x12.\n\x13metrics_export_port\x18\t \x01(\x05R\x11metricsExportPort\x12\x33\n\x16runtime_env_agent_port\x18\x1b \x01(\x05R\x13runtimeEnvAgentPort\x12Q\n\x0fresources_total\x18\x0b \x03(\x0b\x32(.ray.rpc.GcsNodeInfo.ResourcesTotalEntryR\x0eresourcesTotal\x12\x1b\n\tnode_name\x18\x0c \x01(\tR\x08nodeName\x12\x1f\n\x0binstance_id\x18\r \x01(\tR\ninstanceId\x12$\n\x0enode_type_name\x18\x0e \x01(\tR\x0cnodeTypeName\x12,\n\x12instance_type_name\x18\x0f \x01(\tR\x10instanceTypeName\x12\"\n\rstart_time_ms\x18\x17 \x01(\x04R\x0bstartTimeMs\x12\x1e\n\x0b\x65nd_time_ms\x18\x18 \x01(\x04R\tendTimeMs\x12 \n\x0cis_head_node\x18\x19 \x01(\x08R\nisHeadNode\x12\x38\n\x06labels\x18\x1a \x03(\x0b\x32 .ray.rpc.GcsNodeInfo.LabelsEntryR\x06labels\x12<\n\x0estate_snapshot\x18\x1c \x01(\x0b\x32\x15.ray.rpc.NodeSnapshotR\rstateSnapshot\x12\x35\n\ndeath_info\x18\x1d \x01(\x0b\x32\x16.ray.rpc.NodeDeathInfoR\tdeathInfo\x1a\x41\n\x13ResourcesTotalEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"#\n\x0cGcsNodeState\x12\t\n\x05\x41LIVE\x10\x00\x12\x08\n\x04\x44\x45\x41\x44\x10\x01\"\xb2\x02\n\x19GcsNodeAddressAndLiveness\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x30\n\x14node_manager_address\x18\x02 \x01(\tR\x12nodeManagerAddress\x12*\n\x11node_manager_port\x18\x03 \x01(\x05R\x0fnodeManagerPort\x12.\n\x13object_manager_port\x18\x04 \x01(\x05R\x11objectManagerPort\x12\x37\n\x05state\x18\x05 \x01(\x0e\x32!.ray.rpc.GcsNodeInfo.GcsNodeStateR\x05state\x12\x35\n\ndeath_info\x18\x06 \x01(\x0b\x32\x16.ray.rpc.NodeDeathInfoR\tdeathInfo\"\xb0\x08\n\x0bJobsAPIInfo\x12\x16\n\x06status\x18\x01 \x01(\tR\x06status\x12\x1e\n\nentrypoint\x18\x02 \x01(\tR\nentrypoint\x12\x1d\n\x07message\x18\x03 \x01(\tH\x00R\x07message\x88\x01\x01\x12\"\n\nerror_type\x18\x04 \x01(\tH\x01R\terrorType\x88\x01\x01\x12\"\n\nstart_time\x18\x05 \x01(\x04H\x02R\tstartTime\x88\x01\x01\x12\x1e\n\x08\x65nd_time\x18\x06 \x01(\x04H\x03R\x07\x65ndTime\x88\x01\x01\x12>\n\x08metadata\x18\x07 \x03(\x0b\x32\".ray.rpc.JobsAPIInfo.MetadataEntryR\x08metadata\x12-\n\x10runtime_env_json\x18\x08 \x01(\tH\x04R\x0eruntimeEnvJson\x88\x01\x01\x12\x33\n\x13\x65ntrypoint_num_cpus\x18\t \x01(\x01H\x05R\x11\x65ntrypointNumCpus\x88\x01\x01\x12\x33\n\x13\x65ntrypoint_num_gpus\x18\n \x01(\x01H\x06R\x11\x65ntrypointNumGpus\x88\x01\x01\x12`\n\x14\x65ntrypoint_resources\x18\x0b \x03(\x0b\x32-.ray.rpc.JobsAPIInfo.EntrypointResourcesEntryR\x13\x65ntrypointResources\x12>\n\x19\x64river_agent_http_address\x18\x0c \x01(\tH\x07R\x16\x64riverAgentHttpAddress\x88\x01\x01\x12)\n\x0e\x64river_node_id\x18\r \x01(\tH\x08R\x0c\x64riverNodeId\x88\x01\x01\x12-\n\x10\x64river_exit_code\x18\x0e \x01(\x05H\tR\x0e\x64riverExitCode\x88\x01\x01\x12\x30\n\x11\x65ntrypoint_memory\x18\x0f \x01(\x04H\nR\x10\x65ntrypointMemory\x88\x01\x01\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x46\n\x18\x45ntrypointResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x42\n\n\x08_messageB\r\n\x0b_error_typeB\r\n\x0b_start_timeB\x0b\n\t_end_timeB\x13\n\x11_runtime_env_jsonB\x16\n\x14_entrypoint_num_cpusB\x16\n\x14_entrypoint_num_gpusB\x1c\n\x1a_driver_agent_http_addressB\x11\n\x0f_driver_node_idB\x13\n\x11_driver_exit_codeB\x14\n\x12_entrypoint_memory\"\xd7\x06\n\x0fWorkerTableData\x12\x19\n\x08is_alive\x18\x01 \x01(\x08R\x07isAlive\x12\x37\n\x0eworker_address\x18\x02 \x01(\x0b\x32\x10.ray.rpc.AddressR\rworkerAddress\x12\x1c\n\ttimestamp\x18\x03 \x01(\x03R\ttimestamp\x12\x34\n\x0bworker_type\x18\x05 \x01(\x0e\x32\x13.ray.rpc.WorkerTypeR\nworkerType\x12I\n\x0bworker_info\x18\x06 \x03(\x0b\x32(.ray.rpc.WorkerTableData.WorkerInfoEntryR\nworkerInfo\x12M\n\x17\x63reation_task_exception\x18\x12 \x01(\x0b\x32\x15.ray.rpc.RayExceptionR\x15\x63reationTaskException\x12\x39\n\texit_type\x18\x13 \x01(\x0e\x32\x17.ray.rpc.WorkerExitTypeH\x00R\x08\x65xitType\x88\x01\x01\x12$\n\x0b\x65xit_detail\x18\x14 \x01(\tH\x01R\nexitDetail\x88\x01\x01\x12\x10\n\x03pid\x18\x15 \x01(\rR\x03pid\x12\"\n\rstart_time_ms\x18\x17 \x01(\x04R\x0bstartTimeMs\x12\x1e\n\x0b\x65nd_time_ms\x18\x18 \x01(\x04R\tendTimeMs\x12\x31\n\x15worker_launch_time_ms\x18\x19 \x01(\x04R\x12workerLaunchTimeMs\x12\x35\n\x17worker_launched_time_ms\x18\x1a \x01(\x04R\x14workerLaunchedTimeMs\x12(\n\rdebugger_port\x18\x1b \x01(\rH\x02R\x0c\x64\x65\x62uggerPort\x88\x01\x01\x12\x31\n\x12num_paused_threads\x18\x1c \x01(\rH\x03R\x10numPausedThreads\x88\x01\x01\x1a=\n\x0fWorkerInfoEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value:\x02\x38\x01\x42\x0c\n\n_exit_typeB\x0e\n\x0c_exit_detailB\x10\n\x0e_debugger_portB\x15\n\x13_num_paused_threads\"G\n\x0fWorkerDeltaData\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x1b\n\tworker_id\x18\x02 \x01(\x0cR\x08workerId\"3\n\rPubSubMessage\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02id\x12\x12\n\x04\x64\x61ta\x18\x02 \x01(\x0cR\x04\x64\x61ta\"\xe8\x02\n\x0eResourceDemand\x12\x38\n\x05shape\x18\x01 \x03(\x0b\x32\".ray.rpc.ResourceDemand.ShapeEntryR\x05shape\x12\x39\n\x19num_ready_requests_queued\x18\x02 \x01(\x04R\x16numReadyRequestsQueued\x12\x43\n\x1enum_infeasible_requests_queued\x18\x03 \x01(\x04R\x1bnumInfeasibleRequestsQueued\x12!\n\x0c\x62\x61\x63klog_size\x18\x04 \x01(\x03R\x0b\x62\x61\x63klogSize\x12?\n\x0flabel_selectors\x18\x05 \x03(\x0b\x32\x16.ray.rpc.LabelSelectorR\x0elabelSelectors\x1a\x38\n\nShapeEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"R\n\x0cResourceLoad\x12\x42\n\x10resource_demands\x18\x01 \x03(\x0b\x32\x17.ray.rpc.ResourceDemandR\x0fresourceDemands\"\xbc\n\n\rResourcesData\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12_\n\x13resources_available\x18\x02 \x03(\x0b\x32..ray.rpc.ResourcesData.ResourcesAvailableEntryR\x12resourcesAvailable\x12S\n\x0fresources_total\x18\x04 \x03(\x0b\x32*.ray.rpc.ResourcesData.ResourcesTotalEntryR\x0eresourcesTotal\x12M\n\rresource_load\x18\x05 \x03(\x0b\x32(.ray.rpc.ResourcesData.ResourceLoadEntryR\x0cresourceLoad\x12J\n\x16resource_load_by_shape\x18\x07 \x01(\x0b\x32\x15.ray.rpc.ResourceLoadR\x13resourceLoadByShape\x12\x30\n\x14node_manager_address\x18\t \x01(\tR\x12nodeManagerAddress\x12.\n\x13object_pulls_queued\x18\n \x01(\x08R\x11objectPullsQueued\x12\x63\n\x15resources_normal_task\x18\x0b \x03(\x0b\x32/.ray.rpc.ResourcesData.ResourcesNormalTaskEntryR\x13resourcesNormalTask\x12\x41\n\x1dresources_normal_task_changed\x18\x0c \x01(\x08R\x1aresourcesNormalTaskChanged\x12\x45\n\x1fresources_normal_task_timestamp\x18\r \x01(\x03R\x1cresourcesNormalTaskTimestamp\x12\x44\n\x1f\x63luster_full_of_actors_detected\x18\x0e \x01(\x08R\x1b\x63lusterFullOfActorsDetected\x12(\n\x10idle_duration_ms\x18\x0f \x01(\x03R\x0eidleDurationMs\x12\x1f\n\x0bis_draining\x18\x10 \x01(\x08R\nisDraining\x12\x43\n\x1e\x64raining_deadline_timestamp_ms\x18\x12 \x01(\x03R\x1b\x64rainingDeadlineTimestampMs\x12:\n\x06labels\x18\x13 \x03(\x0b\x32\".ray.rpc.ResourcesData.LabelsEntryR\x06labels\x1a\x45\n\x17ResourcesAvailableEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x41\n\x13ResourcesTotalEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a?\n\x11ResourceLoadEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x46\n\x18ResourcesNormalTaskEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01J\x04\x08\x03\x10\x04J\x04\x08\x08\x10\tJ\x04\x08\x11\x10\x12\"\xe1\x01\n\x16ResourceUsageBatchData\x12,\n\x05\x62\x61tch\x18\x01 \x03(\x0b\x32\x16.ray.rpc.ResourcesDataR\x05\x62\x61tch\x12J\n\x16resource_load_by_shape\x18\x02 \x01(\x0b\x32\x15.ray.rpc.ResourceLoadR\x13resourceLoadByShape\x12M\n\x14placement_group_load\x18\x03 \x01(\x0b\x32\x1b.ray.rpc.PlacementGroupLoadR\x12placementGroupLoad\"h\n\x12PlacementGroupLoad\x12R\n\x14placement_group_data\x18\x01 \x03(\x0b\x32 .ray.rpc.PlacementGroupTableDataR\x12placementGroupData\"\xdc\x04\n\x13PlacementGroupStats\x12?\n\x1c\x63reation_request_received_ns\x18\x02 \x01(\x03R\x19\x63reationRequestReceivedNs\x12;\n\x1ascheduling_started_time_ns\x18\x03 \x01(\x03R\x17schedulingStartedTimeNs\x12\x32\n\x15scheduling_latency_us\x18\x04 \x01(\x03R\x13schedulingLatencyUs\x12\x41\n\x1e\x65nd_to_end_creation_latency_us\x18\x05 \x01(\x03R\x19\x65ndToEndCreationLatencyUs\x12-\n\x12scheduling_attempt\x18\x06 \x01(\rR\x11schedulingAttempt\x12\x33\n\x16highest_retry_delay_ms\x18\x07 \x01(\x01R\x13highestRetryDelayMs\x12W\n\x10scheduling_state\x18\x08 \x01(\x0e\x32,.ray.rpc.PlacementGroupStats.SchedulingStateR\x0fschedulingState\"\x92\x01\n\x0fSchedulingState\x12\n\n\x06QUEUED\x10\x00\x12\x0b\n\x07REMOVED\x10\x01\x12\x16\n\x12SCHEDULING_STARTED\x10\x02\x12\x10\n\x0cNO_RESOURCES\x10\x03\x12\x0e\n\nINFEASIBLE\x10\x04\x12\x1e\n\x1a\x46\x41ILED_TO_COMMIT_RESOURCES\x10\x05\x12\x0c\n\x08\x46INISHED\x10\x06\"\xf7\x06\n\x17PlacementGroupTableData\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12)\n\x07\x62undles\x18\x03 \x03(\x0b\x32\x0f.ray.rpc.BundleR\x07\x62undles\x12\x36\n\x08strategy\x18\x04 \x01(\x0e\x32\x1a.ray.rpc.PlacementStrategyR\x08strategy\x12J\n\x05state\x18\x05 \x01(\x0e\x32\x34.ray.rpc.PlacementGroupTableData.PlacementGroupStateR\x05state\x12$\n\x0e\x63reator_job_id\x18\x06 \x01(\x0cR\x0c\x63reatorJobId\x12(\n\x10\x63reator_actor_id\x18\x07 \x01(\x0cR\x0e\x63reatorActorId\x12(\n\x10\x63reator_job_dead\x18\x08 \x01(\x08R\x0e\x63reatorJobDead\x12,\n\x12\x63reator_actor_dead\x18\t \x01(\x08R\x10\x63reatorActorDead\x12\x1f\n\x0bis_detached\x18\n \x01(\x08R\nisDetached\x12#\n\rray_namespace\x18\x0b \x01(\tR\x0crayNamespace\x12\x32\n\x05stats\x18\x0c \x01(\x0b\x32\x1c.ray.rpc.PlacementGroupStatsR\x05stats\x12-\n\x13soft_target_node_id\x18\x0e \x01(\x0cR\x10softTargetNodeId\x12P\n%placement_group_creation_timestamp_ms\x18\x0f \x01(\x03R!placementGroupCreationTimestampMs\x12j\n3placement_group_final_bundle_placement_timestamp_ms\x18\x10 \x01(\x03R-placementGroupFinalBundlePlacementTimestampMs\"\\\n\x13PlacementGroupState\x12\x0b\n\x07PENDING\x10\x00\x12\x0c\n\x08PREPARED\x10\x01\x12\x0b\n\x07\x43REATED\x10\x02\x12\x0b\n\x07REMOVED\x10\x03\x12\x10\n\x0cRESCHEDULING\x10\x04\"\xed\x03\n\x0cJobTableData\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x17\n\x07is_dead\x18\x02 \x01(\x08R\x06isDead\x12\x1c\n\ttimestamp\x18\x03 \x01(\x03R\ttimestamp\x12*\n\x11\x64river_ip_address\x18\x04 \x01(\tR\x0f\x64riverIpAddress\x12\x1d\n\ndriver_pid\x18\x05 \x01(\x03R\tdriverPid\x12*\n\x06\x63onfig\x18\x06 \x01(\x0b\x32\x12.ray.rpc.JobConfigR\x06\x63onfig\x12\x1d\n\nstart_time\x18\x07 \x01(\x04R\tstartTime\x12\x19\n\x08\x65nd_time\x18\x08 \x01(\x04R\x07\x65ndTime\x12\x1e\n\nentrypoint\x18\t \x01(\tR\nentrypoint\x12\x34\n\x08job_info\x18\n \x01(\x0b\x32\x14.ray.rpc.JobsAPIInfoH\x00R\x07jobInfo\x88\x01\x01\x12-\n\x10is_running_tasks\x18\x0b \x01(\x08H\x01R\x0eisRunningTasks\x88\x01\x01\x12\x37\n\x0e\x64river_address\x18\x0c \x01(\x0b\x32\x10.ray.rpc.AddressR\rdriverAddressB\x0b\n\t_job_infoB\x13\n\x11_is_running_tasks*\xc7\x02\n\x0bTablePrefix\x12\x14\n\x10TABLE_PREFIX_MIN\x10\x00\x12\n\n\x06UNUSED\x10\x01\x12\x08\n\x04TASK\x10\x02\x12\x0f\n\x0bRAYLET_TASK\x10\x03\x12\x08\n\x04NODE\x10\x04\x12\n\n\x06OBJECT\x10\x05\x12\t\n\x05\x41\x43TOR\x10\x06\x12\x0c\n\x08\x46UNCTION\x10\x07\x12\x17\n\x13TASK_RECONSTRUCTION\x10\x08\x12\x18\n\x14RESOURCE_USAGE_BATCH\x10\t\x12\x07\n\x03JOB\x10\n\x12\x0e\n\nTASK_LEASE\x10\x0c\x12\x11\n\rNODE_RESOURCE\x10\r\x12\x10\n\x0c\x44IRECT_ACTOR\x10\x0e\x12\x0b\n\x07WORKERS\x10\x0f\x12\x1c\n\x18PLACEMENT_GROUP_SCHEDULE\x10\x10\x12\x13\n\x0fPLACEMENT_GROUP\x10\x11\x12\x06\n\x02KV\x10\x12\x12\x13\n\x0f\x41\x43TOR_TASK_SPEC\x10\x13*\xbe\x02\n\x0bTablePubsub\x12\x14\n\x10TABLE_PUBSUB_MIN\x10\x00\x12\x0e\n\nNO_PUBLISH\x10\x01\x12\x0f\n\x0bTASK_PUBSUB\x10\x02\x12\x16\n\x12RAYLET_TASK_PUBSUB\x10\x03\x12\x0f\n\x0bNODE_PUBSUB\x10\x04\x12\x11\n\rOBJECT_PUBSUB\x10\x05\x12\x10\n\x0c\x41\x43TOR_PUBSUB\x10\x06\x12\x1f\n\x1bRESOURCE_USAGE_BATCH_PUBSUB\x10\x07\x12\x15\n\x11TASK_LEASE_PUBSUB\x10\x08\x12\x0e\n\nJOB_PUBSUB\x10\t\x12\x18\n\x14NODE_RESOURCE_PUBSUB\x10\n\x12\x17\n\x13\x44IRECT_ACTOR_PUBSUB\x10\x0b\x12\x19\n\x15WORKER_FAILURE_PUBSUB\x10\x0c\x12\x14\n\x10TABLE_PUBSUB_MAX\x10\r*.\n\rGcsChangeMode\x12\x11\n\rAPPEND_OR_ADD\x10\x00\x12\n\n\x06REMOVE\x10\x01\x42\x1a\n\x18io.ray.runtime.generatedb\x06proto3') + +_TABLEPREFIX = DESCRIPTOR.enum_types_by_name['TablePrefix'] +TablePrefix = enum_type_wrapper.EnumTypeWrapper(_TABLEPREFIX) +_TABLEPUBSUB = DESCRIPTOR.enum_types_by_name['TablePubsub'] +TablePubsub = enum_type_wrapper.EnumTypeWrapper(_TABLEPUBSUB) +_GCSCHANGEMODE = DESCRIPTOR.enum_types_by_name['GcsChangeMode'] +GcsChangeMode = enum_type_wrapper.EnumTypeWrapper(_GCSCHANGEMODE) +TABLE_PREFIX_MIN = 0 +UNUSED = 1 +TASK = 2 +RAYLET_TASK = 3 +NODE = 4 +OBJECT = 5 +ACTOR = 6 +FUNCTION = 7 +TASK_RECONSTRUCTION = 8 +RESOURCE_USAGE_BATCH = 9 +JOB = 10 +TASK_LEASE = 12 +NODE_RESOURCE = 13 +DIRECT_ACTOR = 14 +WORKERS = 15 +PLACEMENT_GROUP_SCHEDULE = 16 +PLACEMENT_GROUP = 17 +KV = 18 +ACTOR_TASK_SPEC = 19 +TABLE_PUBSUB_MIN = 0 +NO_PUBLISH = 1 +TASK_PUBSUB = 2 +RAYLET_TASK_PUBSUB = 3 +NODE_PUBSUB = 4 +OBJECT_PUBSUB = 5 +ACTOR_PUBSUB = 6 +RESOURCE_USAGE_BATCH_PUBSUB = 7 +TASK_LEASE_PUBSUB = 8 +JOB_PUBSUB = 9 +NODE_RESOURCE_PUBSUB = 10 +DIRECT_ACTOR_PUBSUB = 11 +WORKER_FAILURE_PUBSUB = 12 +TABLE_PUBSUB_MAX = 13 +APPEND_OR_ADD = 0 +REMOVE = 1 + + +_GCSENTRY = DESCRIPTOR.message_types_by_name['GcsEntry'] +_ACTORTABLEDATA = DESCRIPTOR.message_types_by_name['ActorTableData'] +_ACTORTABLEDATA_REQUIREDRESOURCESENTRY = _ACTORTABLEDATA.nested_types_by_name['RequiredResourcesEntry'] +_ACTORTABLEDATA_LABELSELECTORENTRY = _ACTORTABLEDATA.nested_types_by_name['LabelSelectorEntry'] +_ERRORTABLEDATA = DESCRIPTOR.message_types_by_name['ErrorTableData'] +_TASKLOGINFO = DESCRIPTOR.message_types_by_name['TaskLogInfo'] +_TASKSTATEUPDATE = DESCRIPTOR.message_types_by_name['TaskStateUpdate'] +_TASKSTATEUPDATE_STATETSNSENTRY = _TASKSTATEUPDATE.nested_types_by_name['StateTsNsEntry'] +_TASKEVENTS = DESCRIPTOR.message_types_by_name['TaskEvents'] +_TASKEVENTDATA = DESCRIPTOR.message_types_by_name['TaskEventData'] +_AVAILABLERESOURCES = DESCRIPTOR.message_types_by_name['AvailableResources'] +_AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY = _AVAILABLERESOURCES.nested_types_by_name['ResourcesAvailableEntry'] +_TOTALRESOURCES = DESCRIPTOR.message_types_by_name['TotalResources'] +_TOTALRESOURCES_RESOURCESTOTALENTRY = _TOTALRESOURCES.nested_types_by_name['ResourcesTotalEntry'] +_NODESNAPSHOT = DESCRIPTOR.message_types_by_name['NodeSnapshot'] +_GCSNODEINFO = DESCRIPTOR.message_types_by_name['GcsNodeInfo'] +_GCSNODEINFO_RESOURCESTOTALENTRY = _GCSNODEINFO.nested_types_by_name['ResourcesTotalEntry'] +_GCSNODEINFO_LABELSENTRY = _GCSNODEINFO.nested_types_by_name['LabelsEntry'] +_GCSNODEADDRESSANDLIVENESS = DESCRIPTOR.message_types_by_name['GcsNodeAddressAndLiveness'] +_JOBSAPIINFO = DESCRIPTOR.message_types_by_name['JobsAPIInfo'] +_JOBSAPIINFO_METADATAENTRY = _JOBSAPIINFO.nested_types_by_name['MetadataEntry'] +_JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY = _JOBSAPIINFO.nested_types_by_name['EntrypointResourcesEntry'] +_WORKERTABLEDATA = DESCRIPTOR.message_types_by_name['WorkerTableData'] +_WORKERTABLEDATA_WORKERINFOENTRY = _WORKERTABLEDATA.nested_types_by_name['WorkerInfoEntry'] +_WORKERDELTADATA = DESCRIPTOR.message_types_by_name['WorkerDeltaData'] +_PUBSUBMESSAGE = DESCRIPTOR.message_types_by_name['PubSubMessage'] +_RESOURCEDEMAND = DESCRIPTOR.message_types_by_name['ResourceDemand'] +_RESOURCEDEMAND_SHAPEENTRY = _RESOURCEDEMAND.nested_types_by_name['ShapeEntry'] +_RESOURCELOAD = DESCRIPTOR.message_types_by_name['ResourceLoad'] +_RESOURCESDATA = DESCRIPTOR.message_types_by_name['ResourcesData'] +_RESOURCESDATA_RESOURCESAVAILABLEENTRY = _RESOURCESDATA.nested_types_by_name['ResourcesAvailableEntry'] +_RESOURCESDATA_RESOURCESTOTALENTRY = _RESOURCESDATA.nested_types_by_name['ResourcesTotalEntry'] +_RESOURCESDATA_RESOURCELOADENTRY = _RESOURCESDATA.nested_types_by_name['ResourceLoadEntry'] +_RESOURCESDATA_RESOURCESNORMALTASKENTRY = _RESOURCESDATA.nested_types_by_name['ResourcesNormalTaskEntry'] +_RESOURCESDATA_LABELSENTRY = _RESOURCESDATA.nested_types_by_name['LabelsEntry'] +_RESOURCEUSAGEBATCHDATA = DESCRIPTOR.message_types_by_name['ResourceUsageBatchData'] +_PLACEMENTGROUPLOAD = DESCRIPTOR.message_types_by_name['PlacementGroupLoad'] +_PLACEMENTGROUPSTATS = DESCRIPTOR.message_types_by_name['PlacementGroupStats'] +_PLACEMENTGROUPTABLEDATA = DESCRIPTOR.message_types_by_name['PlacementGroupTableData'] +_JOBTABLEDATA = DESCRIPTOR.message_types_by_name['JobTableData'] +_ACTORTABLEDATA_ACTORSTATE = _ACTORTABLEDATA.enum_types_by_name['ActorState'] +_NODESNAPSHOT_STATE = _NODESNAPSHOT.enum_types_by_name['State'] +_GCSNODEINFO_GCSNODESTATE = _GCSNODEINFO.enum_types_by_name['GcsNodeState'] +_PLACEMENTGROUPSTATS_SCHEDULINGSTATE = _PLACEMENTGROUPSTATS.enum_types_by_name['SchedulingState'] +_PLACEMENTGROUPTABLEDATA_PLACEMENTGROUPSTATE = _PLACEMENTGROUPTABLEDATA.enum_types_by_name['PlacementGroupState'] +GcsEntry = _reflection.GeneratedProtocolMessageType('GcsEntry', (_message.Message,), { + 'DESCRIPTOR' : _GCSENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsEntry) + }) +_sym_db.RegisterMessage(GcsEntry) + +ActorTableData = _reflection.GeneratedProtocolMessageType('ActorTableData', (_message.Message,), { + + 'RequiredResourcesEntry' : _reflection.GeneratedProtocolMessageType('RequiredResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORTABLEDATA_REQUIREDRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorTableData.RequiredResourcesEntry) + }) + , + + 'LabelSelectorEntry' : _reflection.GeneratedProtocolMessageType('LabelSelectorEntry', (_message.Message,), { + 'DESCRIPTOR' : _ACTORTABLEDATA_LABELSELECTORENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorTableData.LabelSelectorEntry) + }) + , + 'DESCRIPTOR' : _ACTORTABLEDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ActorTableData) + }) +_sym_db.RegisterMessage(ActorTableData) +_sym_db.RegisterMessage(ActorTableData.RequiredResourcesEntry) +_sym_db.RegisterMessage(ActorTableData.LabelSelectorEntry) + +ErrorTableData = _reflection.GeneratedProtocolMessageType('ErrorTableData', (_message.Message,), { + 'DESCRIPTOR' : _ERRORTABLEDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ErrorTableData) + }) +_sym_db.RegisterMessage(ErrorTableData) + +TaskLogInfo = _reflection.GeneratedProtocolMessageType('TaskLogInfo', (_message.Message,), { + 'DESCRIPTOR' : _TASKLOGINFO, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskLogInfo) + }) +_sym_db.RegisterMessage(TaskLogInfo) + +TaskStateUpdate = _reflection.GeneratedProtocolMessageType('TaskStateUpdate', (_message.Message,), { + + 'StateTsNsEntry' : _reflection.GeneratedProtocolMessageType('StateTsNsEntry', (_message.Message,), { + 'DESCRIPTOR' : _TASKSTATEUPDATE_STATETSNSENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskStateUpdate.StateTsNsEntry) + }) + , + 'DESCRIPTOR' : _TASKSTATEUPDATE, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskStateUpdate) + }) +_sym_db.RegisterMessage(TaskStateUpdate) +_sym_db.RegisterMessage(TaskStateUpdate.StateTsNsEntry) + +TaskEvents = _reflection.GeneratedProtocolMessageType('TaskEvents', (_message.Message,), { + 'DESCRIPTOR' : _TASKEVENTS, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskEvents) + }) +_sym_db.RegisterMessage(TaskEvents) + +TaskEventData = _reflection.GeneratedProtocolMessageType('TaskEventData', (_message.Message,), { + 'DESCRIPTOR' : _TASKEVENTDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskEventData) + }) +_sym_db.RegisterMessage(TaskEventData) + +AvailableResources = _reflection.GeneratedProtocolMessageType('AvailableResources', (_message.Message,), { + + 'ResourcesAvailableEntry' : _reflection.GeneratedProtocolMessageType('ResourcesAvailableEntry', (_message.Message,), { + 'DESCRIPTOR' : _AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AvailableResources.ResourcesAvailableEntry) + }) + , + 'DESCRIPTOR' : _AVAILABLERESOURCES, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AvailableResources) + }) +_sym_db.RegisterMessage(AvailableResources) +_sym_db.RegisterMessage(AvailableResources.ResourcesAvailableEntry) + +TotalResources = _reflection.GeneratedProtocolMessageType('TotalResources', (_message.Message,), { + + 'ResourcesTotalEntry' : _reflection.GeneratedProtocolMessageType('ResourcesTotalEntry', (_message.Message,), { + 'DESCRIPTOR' : _TOTALRESOURCES_RESOURCESTOTALENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TotalResources.ResourcesTotalEntry) + }) + , + 'DESCRIPTOR' : _TOTALRESOURCES, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TotalResources) + }) +_sym_db.RegisterMessage(TotalResources) +_sym_db.RegisterMessage(TotalResources.ResourcesTotalEntry) + +NodeSnapshot = _reflection.GeneratedProtocolMessageType('NodeSnapshot', (_message.Message,), { + 'DESCRIPTOR' : _NODESNAPSHOT, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NodeSnapshot) + }) +_sym_db.RegisterMessage(NodeSnapshot) + +GcsNodeInfo = _reflection.GeneratedProtocolMessageType('GcsNodeInfo', (_message.Message,), { + + 'ResourcesTotalEntry' : _reflection.GeneratedProtocolMessageType('ResourcesTotalEntry', (_message.Message,), { + 'DESCRIPTOR' : _GCSNODEINFO_RESOURCESTOTALENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsNodeInfo.ResourcesTotalEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _GCSNODEINFO_LABELSENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsNodeInfo.LabelsEntry) + }) + , + 'DESCRIPTOR' : _GCSNODEINFO, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsNodeInfo) + }) +_sym_db.RegisterMessage(GcsNodeInfo) +_sym_db.RegisterMessage(GcsNodeInfo.ResourcesTotalEntry) +_sym_db.RegisterMessage(GcsNodeInfo.LabelsEntry) + +GcsNodeAddressAndLiveness = _reflection.GeneratedProtocolMessageType('GcsNodeAddressAndLiveness', (_message.Message,), { + 'DESCRIPTOR' : _GCSNODEADDRESSANDLIVENESS, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsNodeAddressAndLiveness) + }) +_sym_db.RegisterMessage(GcsNodeAddressAndLiveness) + +JobsAPIInfo = _reflection.GeneratedProtocolMessageType('JobsAPIInfo', (_message.Message,), { + + 'MetadataEntry' : _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), { + 'DESCRIPTOR' : _JOBSAPIINFO_METADATAENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobsAPIInfo.MetadataEntry) + }) + , + + 'EntrypointResourcesEntry' : _reflection.GeneratedProtocolMessageType('EntrypointResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobsAPIInfo.EntrypointResourcesEntry) + }) + , + 'DESCRIPTOR' : _JOBSAPIINFO, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobsAPIInfo) + }) +_sym_db.RegisterMessage(JobsAPIInfo) +_sym_db.RegisterMessage(JobsAPIInfo.MetadataEntry) +_sym_db.RegisterMessage(JobsAPIInfo.EntrypointResourcesEntry) + +WorkerTableData = _reflection.GeneratedProtocolMessageType('WorkerTableData', (_message.Message,), { + + 'WorkerInfoEntry' : _reflection.GeneratedProtocolMessageType('WorkerInfoEntry', (_message.Message,), { + 'DESCRIPTOR' : _WORKERTABLEDATA_WORKERINFOENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerTableData.WorkerInfoEntry) + }) + , + 'DESCRIPTOR' : _WORKERTABLEDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerTableData) + }) +_sym_db.RegisterMessage(WorkerTableData) +_sym_db.RegisterMessage(WorkerTableData.WorkerInfoEntry) + +WorkerDeltaData = _reflection.GeneratedProtocolMessageType('WorkerDeltaData', (_message.Message,), { + 'DESCRIPTOR' : _WORKERDELTADATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerDeltaData) + }) +_sym_db.RegisterMessage(WorkerDeltaData) + +PubSubMessage = _reflection.GeneratedProtocolMessageType('PubSubMessage', (_message.Message,), { + 'DESCRIPTOR' : _PUBSUBMESSAGE, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubSubMessage) + }) +_sym_db.RegisterMessage(PubSubMessage) + +ResourceDemand = _reflection.GeneratedProtocolMessageType('ResourceDemand', (_message.Message,), { + + 'ShapeEntry' : _reflection.GeneratedProtocolMessageType('ShapeEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEDEMAND_SHAPEENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceDemand.ShapeEntry) + }) + , + 'DESCRIPTOR' : _RESOURCEDEMAND, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceDemand) + }) +_sym_db.RegisterMessage(ResourceDemand) +_sym_db.RegisterMessage(ResourceDemand.ShapeEntry) + +ResourceLoad = _reflection.GeneratedProtocolMessageType('ResourceLoad', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCELOAD, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceLoad) + }) +_sym_db.RegisterMessage(ResourceLoad) + +ResourcesData = _reflection.GeneratedProtocolMessageType('ResourcesData', (_message.Message,), { + + 'ResourcesAvailableEntry' : _reflection.GeneratedProtocolMessageType('ResourcesAvailableEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCESDATA_RESOURCESAVAILABLEENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData.ResourcesAvailableEntry) + }) + , + + 'ResourcesTotalEntry' : _reflection.GeneratedProtocolMessageType('ResourcesTotalEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCESDATA_RESOURCESTOTALENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData.ResourcesTotalEntry) + }) + , + + 'ResourceLoadEntry' : _reflection.GeneratedProtocolMessageType('ResourceLoadEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCESDATA_RESOURCELOADENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData.ResourceLoadEntry) + }) + , + + 'ResourcesNormalTaskEntry' : _reflection.GeneratedProtocolMessageType('ResourcesNormalTaskEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCESDATA_RESOURCESNORMALTASKENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData.ResourcesNormalTaskEntry) + }) + , + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCESDATA_LABELSENTRY, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData.LabelsEntry) + }) + , + 'DESCRIPTOR' : _RESOURCESDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourcesData) + }) +_sym_db.RegisterMessage(ResourcesData) +_sym_db.RegisterMessage(ResourcesData.ResourcesAvailableEntry) +_sym_db.RegisterMessage(ResourcesData.ResourcesTotalEntry) +_sym_db.RegisterMessage(ResourcesData.ResourceLoadEntry) +_sym_db.RegisterMessage(ResourcesData.ResourcesNormalTaskEntry) +_sym_db.RegisterMessage(ResourcesData.LabelsEntry) + +ResourceUsageBatchData = _reflection.GeneratedProtocolMessageType('ResourceUsageBatchData', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCEUSAGEBATCHDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResourceUsageBatchData) + }) +_sym_db.RegisterMessage(ResourceUsageBatchData) + +PlacementGroupLoad = _reflection.GeneratedProtocolMessageType('PlacementGroupLoad', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTGROUPLOAD, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlacementGroupLoad) + }) +_sym_db.RegisterMessage(PlacementGroupLoad) + +PlacementGroupStats = _reflection.GeneratedProtocolMessageType('PlacementGroupStats', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTGROUPSTATS, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlacementGroupStats) + }) +_sym_db.RegisterMessage(PlacementGroupStats) + +PlacementGroupTableData = _reflection.GeneratedProtocolMessageType('PlacementGroupTableData', (_message.Message,), { + 'DESCRIPTOR' : _PLACEMENTGROUPTABLEDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PlacementGroupTableData) + }) +_sym_db.RegisterMessage(PlacementGroupTableData) + +JobTableData = _reflection.GeneratedProtocolMessageType('JobTableData', (_message.Message,), { + 'DESCRIPTOR' : _JOBTABLEDATA, + '__module__' : 'src.ray.protobuf.gcs_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.JobTableData) + }) +_sym_db.RegisterMessage(JobTableData) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\030io.ray.runtime.generated' + _ACTORTABLEDATA_REQUIREDRESOURCESENTRY._options = None + _ACTORTABLEDATA_REQUIREDRESOURCESENTRY._serialized_options = b'8\001' + _ACTORTABLEDATA_LABELSELECTORENTRY._options = None + _ACTORTABLEDATA_LABELSELECTORENTRY._serialized_options = b'8\001' + _TASKSTATEUPDATE_STATETSNSENTRY._options = None + _TASKSTATEUPDATE_STATETSNSENTRY._serialized_options = b'8\001' + _AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY._options = None + _AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY._serialized_options = b'8\001' + _TOTALRESOURCES_RESOURCESTOTALENTRY._options = None + _TOTALRESOURCES_RESOURCESTOTALENTRY._serialized_options = b'8\001' + _GCSNODEINFO_RESOURCESTOTALENTRY._options = None + _GCSNODEINFO_RESOURCESTOTALENTRY._serialized_options = b'8\001' + _GCSNODEINFO_LABELSENTRY._options = None + _GCSNODEINFO_LABELSENTRY._serialized_options = b'8\001' + _JOBSAPIINFO_METADATAENTRY._options = None + _JOBSAPIINFO_METADATAENTRY._serialized_options = b'8\001' + _JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY._options = None + _JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY._serialized_options = b'8\001' + _WORKERTABLEDATA_WORKERINFOENTRY._options = None + _WORKERTABLEDATA_WORKERINFOENTRY._serialized_options = b'8\001' + _RESOURCEDEMAND_SHAPEENTRY._options = None + _RESOURCEDEMAND_SHAPEENTRY._serialized_options = b'8\001' + _RESOURCESDATA_RESOURCESAVAILABLEENTRY._options = None + _RESOURCESDATA_RESOURCESAVAILABLEENTRY._serialized_options = b'8\001' + _RESOURCESDATA_RESOURCESTOTALENTRY._options = None + _RESOURCESDATA_RESOURCESTOTALENTRY._serialized_options = b'8\001' + _RESOURCESDATA_RESOURCELOADENTRY._options = None + _RESOURCESDATA_RESOURCELOADENTRY._serialized_options = b'8\001' + _RESOURCESDATA_RESOURCESNORMALTASKENTRY._options = None + _RESOURCESDATA_RESOURCESNORMALTASKENTRY._serialized_options = b'8\001' + _RESOURCESDATA_LABELSENTRY._options = None + _RESOURCESDATA_LABELSENTRY._serialized_options = b'8\001' + _TABLEPREFIX._serialized_start=11753 + _TABLEPREFIX._serialized_end=12080 + _TABLEPUBSUB._serialized_start=12083 + _TABLEPUBSUB._serialized_end=12401 + _GCSCHANGEMODE._serialized_start=12403 + _GCSCHANGEMODE._serialized_end=12449 + _GCSENTRY._serialized_start=109 + _GCSENTRY._serialized_end=218 + _ACTORTABLEDATA._serialized_start=221 + _ACTORTABLEDATA._serialized_end=1835 + _ACTORTABLEDATA_REQUIREDRESOURCESENTRY._serialized_start=1553 + _ACTORTABLEDATA_REQUIREDRESOURCESENTRY._serialized_end=1621 + _ACTORTABLEDATA_LABELSELECTORENTRY._serialized_start=1623 + _ACTORTABLEDATA_LABELSELECTORENTRY._serialized_end=1687 + _ACTORTABLEDATA_ACTORSTATE._serialized_start=1689 + _ACTORTABLEDATA_ACTORSTATE._serialized_end=1786 + _ERRORTABLEDATA._serialized_start=1837 + _ERRORTABLEDATA._serialized_end=1963 + _TASKLOGINFO._serialized_start=1966 + _TASKLOGINFO._serialized_end=2303 + _TASKSTATEUPDATE._serialized_start=2306 + _TASKSTATEUPDATE._serialized_end=2893 + _TASKSTATEUPDATE_STATETSNSENTRY._serialized_start=2716 + _TASKSTATEUPDATE_STATETSNSENTRY._serialized_end=2776 + _TASKEVENTS._serialized_start=2896 + _TASKEVENTS._serialized_end=3240 + _TASKEVENTDATA._serialized_start=3243 + _TASKEVENTDATA._serialized_end=3475 + _AVAILABLERESOURCES._serialized_start=3478 + _AVAILABLERESOURCES._serialized_end=3696 + _AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY._serialized_start=3627 + _AVAILABLERESOURCES_RESOURCESAVAILABLEENTRY._serialized_end=3696 + _TOTALRESOURCES._serialized_start=3699 + _TOTALRESOURCES._serialized_end=3893 + _TOTALRESOURCES_RESOURCESTOTALENTRY._serialized_start=3828 + _TOTALRESOURCES_RESOURCESTOTALENTRY._serialized_end=3893 + _NODESNAPSHOT._serialized_start=3896 + _NODESNAPSHOT._serialized_end=4100 + _NODESNAPSHOT_STATE._serialized_start=4042 + _NODESNAPSHOT_STATE._serialized_end=4100 + _GCSNODEINFO._serialized_start=4103 + _GCSNODEINFO._serialized_end=5265 + _GCSNODEINFO_RESOURCESTOTALENTRY._serialized_start=3828 + _GCSNODEINFO_RESOURCESTOTALENTRY._serialized_end=3893 + _GCSNODEINFO_LABELSENTRY._serialized_start=5171 + _GCSNODEINFO_LABELSENTRY._serialized_end=5228 + _GCSNODEINFO_GCSNODESTATE._serialized_start=5230 + _GCSNODEINFO_GCSNODESTATE._serialized_end=5265 + _GCSNODEADDRESSANDLIVENESS._serialized_start=5268 + _GCSNODEADDRESSANDLIVENESS._serialized_end=5574 + _JOBSAPIINFO._serialized_start=5577 + _JOBSAPIINFO._serialized_end=6649 + _JOBSAPIINFO_METADATAENTRY._serialized_start=6302 + _JOBSAPIINFO_METADATAENTRY._serialized_end=6361 + _JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY._serialized_start=6363 + _JOBSAPIINFO_ENTRYPOINTRESOURCESENTRY._serialized_end=6433 + _WORKERTABLEDATA._serialized_start=6652 + _WORKERTABLEDATA._serialized_end=7507 + _WORKERTABLEDATA_WORKERINFOENTRY._serialized_start=7375 + _WORKERTABLEDATA_WORKERINFOENTRY._serialized_end=7436 + _WORKERDELTADATA._serialized_start=7509 + _WORKERDELTADATA._serialized_end=7580 + _PUBSUBMESSAGE._serialized_start=7582 + _PUBSUBMESSAGE._serialized_end=7633 + _RESOURCEDEMAND._serialized_start=7636 + _RESOURCEDEMAND._serialized_end=7996 + _RESOURCEDEMAND_SHAPEENTRY._serialized_start=7940 + _RESOURCEDEMAND_SHAPEENTRY._serialized_end=7996 + _RESOURCELOAD._serialized_start=7998 + _RESOURCELOAD._serialized_end=8080 + _RESOURCESDATA._serialized_start=8083 + _RESOURCESDATA._serialized_end=9423 + _RESOURCESDATA_RESOURCESAVAILABLEENTRY._serialized_start=3627 + _RESOURCESDATA_RESOURCESAVAILABLEENTRY._serialized_end=3696 + _RESOURCESDATA_RESOURCESTOTALENTRY._serialized_start=3828 + _RESOURCESDATA_RESOURCESTOTALENTRY._serialized_end=3893 + _RESOURCESDATA_RESOURCELOADENTRY._serialized_start=9211 + _RESOURCESDATA_RESOURCELOADENTRY._serialized_end=9274 + _RESOURCESDATA_RESOURCESNORMALTASKENTRY._serialized_start=9276 + _RESOURCESDATA_RESOURCESNORMALTASKENTRY._serialized_end=9346 + _RESOURCESDATA_LABELSENTRY._serialized_start=5171 + _RESOURCESDATA_LABELSENTRY._serialized_end=5228 + _RESOURCEUSAGEBATCHDATA._serialized_start=9426 + _RESOURCEUSAGEBATCHDATA._serialized_end=9651 + _PLACEMENTGROUPLOAD._serialized_start=9653 + _PLACEMENTGROUPLOAD._serialized_end=9757 + _PLACEMENTGROUPSTATS._serialized_start=9760 + _PLACEMENTGROUPSTATS._serialized_end=10364 + _PLACEMENTGROUPSTATS_SCHEDULINGSTATE._serialized_start=10218 + _PLACEMENTGROUPSTATS_SCHEDULINGSTATE._serialized_end=10364 + _PLACEMENTGROUPTABLEDATA._serialized_start=10367 + _PLACEMENTGROUPTABLEDATA._serialized_end=11254 + _PLACEMENTGROUPTABLEDATA_PLACEMENTGROUPSTATE._serialized_start=11162 + _PLACEMENTGROUPTABLEDATA_PLACEMENTGROUPSTATE._serialized_end=11254 + _JOBTABLEDATA._serialized_start=11257 + _JOBTABLEDATA._serialized_end=11750 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/gcs_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/gcs_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/gcs_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2.py b/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..9b49d21ac0fa6ca3d6c9718173e580be8c03f60d --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2.py @@ -0,0 +1,1233 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/gcs_service.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import gcs_pb2 as src_dot_ray_dot_protobuf_dot_gcs__pb2 +from . import pubsub_pb2 as src_dot_ray_dot_protobuf_dot_pubsub__pb2 +from . import events_event_aggregator_service_pb2 as src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"src/ray/protobuf/gcs_service.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a\x1asrc/ray/protobuf/gcs.proto\x1a\x1dsrc/ray/protobuf/pubsub.proto\x1a\x36src/ray/protobuf/events_event_aggregator_service.proto\":\n\rAddJobRequest\x12)\n\x04\x64\x61ta\x18\x01 \x01(\x0b\x32\x15.ray.rpc.JobTableDataR\x04\x64\x61ta\"9\n\x0b\x41\x64\x64JobReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"/\n\x16MarkJobFinishedRequest\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\"B\n\x14MarkJobFinishedReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\xd9\x02\n\x14GetAllJobInfoRequest\x12\x19\n\x05limit\x18\x01 \x01(\x05H\x00R\x05limit\x88\x01\x01\x12\x34\n\x14job_or_submission_id\x18\x02 \x01(\tH\x01R\x11jobOrSubmissionId\x88\x01\x01\x12G\n\x1eskip_submission_job_info_field\x18\x03 \x01(\x08H\x02R\x1askipSubmissionJobInfoField\x88\x01\x01\x12\x41\n\x1bskip_is_running_tasks_field\x18\x04 \x01(\x08H\x03R\x17skipIsRunningTasksField\x88\x01\x01\x42\x08\n\x06_limitB\x17\n\x15_job_or_submission_idB!\n\x1f_skip_submission_job_info_fieldB\x1e\n\x1c_skip_is_running_tasks_field\"{\n\x12GetAllJobInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x39\n\rjob_info_list\x18\x02 \x03(\x0b\x32\x15.ray.rpc.JobTableDataR\x0bjobInfoList\"M\n\x15ReportJobErrorRequest\x12\x34\n\tjob_error\x18\x01 \x01(\x0b\x32\x17.ray.rpc.ErrorTableDataR\x08jobError\"A\n\x13ReportJobErrorReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x15\n\x13GetNextJobIDRequest\"V\n\x11GetNextJobIDReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x15\n\x06job_id\x18\x02 \x01(\x05R\x05jobId\"D\n\x13GetActorInfoRequest\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\x82\x01\n\x11GetActorInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x41\n\x10\x61\x63tor_table_data\x18\x02 \x01(\x0b\x32\x17.ray.rpc.ActorTableDataR\x0e\x61\x63torTableData\"S\n\x18GetNamedActorInfoRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12#\n\rray_namespace\x18\x02 \x01(\tR\x0crayNamespace\"\xb7\x01\n\x16GetNamedActorInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x41\n\x10\x61\x63tor_table_data\x18\x02 \x01(\x0b\x32\x17.ray.rpc.ActorTableDataR\x0e\x61\x63torTableData\x12.\n\ttask_spec\x18\x03 \x01(\x0b\x32\x11.ray.rpc.TaskSpecR\x08taskSpec\"d\n\x16ListNamedActorsRequest\x12%\n\x0e\x61ll_namespaces\x18\x01 \x01(\x08R\rallNamespaces\x12#\n\rray_namespace\x18\x02 \x01(\tR\x0crayNamespace\"\x87\x01\n\x14ListNamedActorsReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x43\n\x11named_actors_list\x18\x02 \x03(\x0b\x32\x17.ray.rpc.NamedActorInfoR\x0fnamedActorsList\"\xe0\x02\n\x16GetAllActorInfoRequest\x12$\n\x0eshow_dead_jobs\x18\x01 \x01(\x08R\x0cshowDeadJobs\x12\x19\n\x05limit\x18\x02 \x01(\x03H\x00R\x05limit\x88\x01\x01\x12\x46\n\x07\x66ilters\x18\x03 \x01(\x0b\x32\'.ray.rpc.GetAllActorInfoRequest.FiltersH\x01R\x07\x66ilters\x88\x01\x01\x1a\xa6\x01\n\x07\x46ilters\x12\x1e\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cH\x00R\x07\x61\x63torId\x88\x01\x01\x12\x1a\n\x06job_id\x18\x02 \x01(\x0cH\x01R\x05jobId\x88\x01\x01\x12=\n\x05state\x18\x03 \x01(\x0e\x32\".ray.rpc.ActorTableData.ActorStateH\x02R\x05state\x88\x01\x01\x42\x0b\n\t_actor_idB\t\n\x07_job_idB\x08\n\x06_stateB\x08\n\x06_limitB\n\n\x08_filters\"\xbe\x01\n\x14GetAllActorInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x41\n\x10\x61\x63tor_table_data\x18\x02 \x03(\x0b\x32\x17.ray.rpc.ActorTableDataR\x0e\x61\x63torTableData\x12\x14\n\x05total\x18\x03 \x01(\x03R\x05total\x12!\n\x0cnum_filtered\x18\x04 \x01(\x03R\x0bnumFiltered\"q\n\x16KillActorViaGcsRequest\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12\x1d\n\nforce_kill\x18\x02 \x01(\x08R\tforceKill\x12\x1d\n\nno_restart\x18\x03 \x01(\x08R\tnoRestart\"B\n\x14KillActorViaGcsReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x94\x01\n\x1cReportActorOutOfScopeRequest\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12Y\n*num_restarts_due_to_lineage_reconstruction\x18\x02 \x01(\x04R%numRestartsDueToLineageReconstruction\"H\n\x1aReportActorOutOfScopeReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x15\n\x13GetClusterIdRequest\"^\n\x11GetClusterIdReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x1d\n\ncluster_id\x18\x02 \x01(\x0cR\tclusterId\"H\n\x13RegisterNodeRequest\x12\x31\n\tnode_info\x18\x01 \x01(\x0b\x32\x14.ray.rpc.GcsNodeInfoR\x08nodeInfo\"?\n\x11RegisterNodeReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"p\n\x15UnregisterNodeRequest\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12>\n\x0fnode_death_info\x18\x02 \x01(\x0b\x32\x16.ray.rpc.NodeDeathInfoR\rnodeDeathInfo\"A\n\x13UnregisterNodeReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\xf2\x02\n\x15GetAllNodeInfoRequest\x12\x19\n\x05limit\x18\x01 \x01(\x03H\x00R\x05limit\x88\x01\x01\x12R\n\x0enode_selectors\x18\x02 \x03(\x0b\x32+.ray.rpc.GetAllNodeInfoRequest.NodeSelectorR\rnodeSelectors\x12I\n\x0cstate_filter\x18\x03 \x01(\x0e\x32!.ray.rpc.GcsNodeInfo.GcsNodeStateH\x01R\x0bstateFilter\x88\x01\x01\x1a\x83\x01\n\x0cNodeSelector\x12\x19\n\x07node_id\x18\x01 \x01(\x0cH\x00R\x06nodeId\x12\x1d\n\tnode_name\x18\x02 \x01(\tH\x00R\x08nodeName\x12(\n\x0fnode_ip_address\x18\x03 \x01(\tH\x00R\rnodeIpAddressB\x0f\n\rnode_selectorB\x08\n\x06_limitB\x0f\n\r_state_filter\"\xb6\x01\n\x13GetAllNodeInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12:\n\x0enode_info_list\x18\x02 \x03(\x0b\x32\x14.ray.rpc.GcsNodeInfoR\x0cnodeInfoList\x12\x14\n\x05total\x18\x03 \x01(\x03R\x05total\x12!\n\x0cnum_filtered\x18\x04 \x01(\x03R\x0bnumFiltered\"\xc1\x01\n#GetAllNodeAddressAndLivenessRequest\x12\x19\n\x08node_ids\x18\x01 \x03(\x0cR\x07nodeIds\x12\x19\n\x05limit\x18\x02 \x01(\x03H\x00R\x05limit\x88\x01\x01\x12I\n\x0cstate_filter\x18\x03 \x01(\x0e\x32!.ray.rpc.GcsNodeInfo.GcsNodeStateH\x01R\x0bstateFilter\x88\x01\x01\x42\x08\n\x06_limitB\x0f\n\r_state_filter\"\x99\x01\n!GetAllNodeAddressAndLivenessReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12H\n\x0enode_info_list\x18\x02 \x03(\x0b\x32\".ray.rpc.GcsNodeAddressAndLivenessR\x0cnodeInfoList\".\n\x11\x43heckAliveRequest\x12\x19\n\x08node_ids\x18\x01 \x03(\x0cR\x07nodeIds\"\x81\x01\n\x0f\x43heckAliveReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x1f\n\x0bray_version\x18\x02 \x01(\tR\nrayVersion\x12!\n\x0craylet_alive\x18\x03 \x03(\x08R\x0brayletAlive\"\x1a\n\x18GetInternalConfigRequest\"\\\n\x16GetInternalConfigReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x16\n\x06\x63onfig\x18\x02 \x01(\tR\x06\x63onfig\"B\n\x14\x44\x65leteResourcesReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"!\n\x1fGetAllAvailableResourcesRequest\"\x8f\x01\n\x1dGetAllAvailableResourcesReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x42\n\x0eresources_list\x18\x02 \x03(\x0b\x32\x1b.ray.rpc.AvailableResourcesR\rresourcesList\"\x1d\n\x1bGetAllTotalResourcesRequest\"\x87\x01\n\x19GetAllTotalResourcesReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12>\n\x0eresources_list\x18\x02 \x03(\x0b\x32\x17.ray.rpc.TotalResourcesR\rresourcesList\"]\n\x1aReportWorkerFailureRequest\x12?\n\x0eworker_failure\x18\x01 \x01(\x0b\x32\x18.ray.rpc.WorkerTableDataR\rworkerFailure\"F\n\x18ReportWorkerFailureReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"3\n\x14GetWorkerInfoRequest\x12\x1b\n\tworker_id\x18\x01 \x01(\x0cR\x08workerId\"\x86\x01\n\x12GetWorkerInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x44\n\x11worker_table_data\x18\x02 \x01(\x0b\x32\x18.ray.rpc.WorkerTableDataR\x0fworkerTableData\"\x9c\x02\n\x17GetAllWorkerInfoRequest\x12\x19\n\x05limit\x18\x01 \x01(\x03H\x00R\x05limit\x88\x01\x01\x12G\n\x07\x66ilters\x18\x02 \x01(\x0b\x32(.ray.rpc.GetAllWorkerInfoRequest.FiltersH\x01R\x07\x66ilters\x88\x01\x01\x1a\x86\x01\n\x07\x46ilters\x12\x35\n\x14\x65xist_paused_threads\x18\x01 \x01(\x08H\x00R\x12\x65xistPausedThreads\x88\x01\x01\x12\x1e\n\x08is_alive\x18\x02 \x01(\x08H\x01R\x07isAlive\x88\x01\x01\x42\x17\n\x15_exist_paused_threadsB\x0b\n\t_is_aliveB\x08\n\x06_limitB\n\n\x08_filters\"\xc2\x01\n\x15GetAllWorkerInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x44\n\x11worker_table_data\x18\x02 \x03(\x0b\x32\x18.ray.rpc.WorkerTableDataR\x0fworkerTableData\x12\x14\n\x05total\x18\x03 \x01(\x03R\x05total\x12!\n\x0cnum_filtered\x18\x04 \x01(\x03R\x0bnumFiltered\"Q\n\x14\x41\x64\x64WorkerInfoRequest\x12\x39\n\x0bworker_data\x18\x01 \x01(\x0b\x32\x18.ray.rpc.WorkerTableDataR\nworkerData\"@\n\x12\x41\x64\x64WorkerInfoReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"c\n\x1fUpdateWorkerDebuggerPortRequest\x12\x1b\n\tworker_id\x18\x01 \x01(\x0cR\x08workerId\x12#\n\rdebugger_port\x18\x02 \x01(\rR\x0c\x64\x65\x62uggerPort\"K\n\x1dUpdateWorkerDebuggerPortReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"{\n#UpdateWorkerNumPausedThreadsRequest\x12\x1b\n\tworker_id\x18\x01 \x01(\x0cR\x08workerId\x12\x37\n\x18num_paused_threads_delta\x18\x02 \x01(\x05R\x15numPausedThreadsDelta\"O\n!UpdateWorkerNumPausedThreadsReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"D\n\x12\x43reateActorRequest\x12.\n\ttask_spec\x18\x01 \x01(\x0b\x32\x11.ray.rpc.TaskSpecR\x08taskSpec\"\x89\x02\n\x10\x43reateActorReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x35\n\ractor_address\x18\x02 \x01(\x0b\x32\x10.ray.rpc.AddressR\x0c\x61\x63torAddress\x12\x42\n\rborrowed_refs\x18\x03 \x03(\x0b\x32\x1d.ray.rpc.ObjectReferenceCountR\x0c\x62orrowedRefs\x12>\n\x0b\x64\x65\x61th_cause\x18\x04 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseH\x00R\ndeathCause\x88\x01\x01\x42\x0e\n\x0c_death_cause\"F\n\x14RegisterActorRequest\x12.\n\ttask_spec\x18\x01 \x01(\x0b\x32\x11.ray.rpc.TaskSpecR\x08taskSpec\"@\n\x12RegisterActorReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\xa3\x01\n+RestartActorForLineageReconstructionRequest\x12\x19\n\x08\x61\x63tor_id\x18\x01 \x01(\x0cR\x07\x61\x63torId\x12Y\n*num_restarts_due_to_lineage_reconstruction\x18\x02 \x01(\x04R%numRestartsDueToLineageReconstruction\"W\n)RestartActorForLineageReconstructionReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"l\n\x1b\x43reatePlacementGroupRequest\x12M\n\x14placement_group_spec\x18\x01 \x01(\x0b\x32\x1b.ray.rpc.PlacementGroupSpecR\x12placementGroupSpec\"G\n\x19\x43reatePlacementGroupReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"K\n\x1bRemovePlacementGroupRequest\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\"G\n\x19RemovePlacementGroupReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"H\n\x18GetPlacementGroupRequest\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\"\xa3\x01\n\x16GetPlacementGroupReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12]\n\x1aplacement_group_table_data\x18\x02 \x01(\x0b\x32 .ray.rpc.PlacementGroupTableDataR\x17placementGroupTableData\"B\n\x1bGetAllPlacementGroupRequest\x12\x19\n\x05limit\x18\x01 \x01(\x03H\x00R\x05limit\x88\x01\x01\x42\x08\n\x06_limit\"\xbc\x01\n\x19GetAllPlacementGroupReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12]\n\x1aplacement_group_table_data\x18\x02 \x03(\x0b\x32 .ray.rpc.PlacementGroupTableDataR\x17placementGroupTableData\x12\x14\n\x05total\x18\x03 \x01(\x03R\x05total\"S\n#WaitPlacementGroupUntilReadyRequest\x12,\n\x12placement_group_id\x18\x01 \x01(\x0cR\x10placementGroupId\"O\n!WaitPlacementGroupUntilReadyReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"X\n\x1dGetNamedPlacementGroupRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12#\n\rray_namespace\x18\x02 \x01(\tR\x0crayNamespace\"\xa8\x01\n\x1bGetNamedPlacementGroupReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12]\n\x1aplacement_group_table_data\x18\x02 \x01(\x0b\x32 .ray.rpc.PlacementGroupTableDataR\x17placementGroupTableData\"(\n\rDrainNodeData\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\"R\n\x10\x44rainNodeRequest\x12>\n\x0f\x64rain_node_data\x18\x01 \x03(\x0b\x32\x16.ray.rpc.DrainNodeDataR\rdrainNodeData\"*\n\x0f\x44rainNodeStatus\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\"\x82\x01\n\x0e\x44rainNodeReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x44\n\x11\x64rain_node_status\x18\x02 \x03(\x0b\x32\x18.ray.rpc.DrainNodeStatusR\x0f\x64rainNodeStatus\"F\n\x14InternalKVGetRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x1c\n\tnamespace\x18\x02 \x01(\x0cR\tnamespace\"V\n\x12InternalKVGetReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value\"M\n\x19InternalKVMultiGetRequest\x12\x12\n\x04keys\x18\x01 \x03(\x0cR\x04keys\x12\x1c\n\tnamespace\x18\x02 \x01(\x0cR\tnamespace\"7\n\rMapFieldEntry\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value\"w\n\x17InternalKVMultiGetReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x30\n\x07results\x18\x02 \x03(\x0b\x32\x16.ray.rpc.MapFieldEntryR\x07results\"z\n\x14InternalKVPutRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value\x12\x1c\n\toverwrite\x18\x03 \x01(\x08R\toverwrite\x12\x1c\n\tnamespace\x18\x04 \x01(\x0cR\tnamespace\"V\n\x12InternalKVPutReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x14\n\x05\x61\x64\x64\x65\x64\x18\x02 \x01(\x08R\x05\x61\x64\x64\x65\x64\"j\n\x14InternalKVDelRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x1c\n\tnamespace\x18\x02 \x01(\x0cR\tnamespace\x12\"\n\rdel_by_prefix\x18\x03 \x01(\x08R\x0b\x64\x65lByPrefix\"a\n\x12InternalKVDelReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x1f\n\x0b\x64\x65leted_num\x18\x02 \x01(\x05R\ndeletedNum\"I\n\x17InternalKVExistsRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x1c\n\tnamespace\x18\x02 \x01(\x0cR\tnamespace\"[\n\x15InternalKVExistsReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x16\n\x06\x65xists\x18\x02 \x01(\x08R\x06\x65xists\"M\n\x15InternalKVKeysRequest\x12\x16\n\x06prefix\x18\x01 \x01(\x0cR\x06prefix\x12\x1c\n\tnamespace\x18\x02 \x01(\x0cR\tnamespace\"[\n\x13InternalKVKeysReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x18\n\x07results\x18\x02 \x03(\x0cR\x07results\"N\n\x17PinRuntimeEnvURIRequest\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12!\n\x0c\x65xpiration_s\x18\x02 \x01(\x05R\x0b\x65xpirationS\"C\n\x15PinRuntimeEnvURIReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"K\n\x11GcsPublishRequest\x12\x36\n\x0cpub_messages\x18\x01 \x03(\x0b\x32\x13.ray.rpc.PubMessageR\x0bpubMessages\"=\n\x0fGcsPublishReply\x12*\n\x06status\x18\x64 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x9d\x01\n\x18GcsSubscriberPollRequest\x12#\n\rsubscriber_id\x18\x01 \x01(\x0cR\x0csubscriberId\x12\x39\n\x19max_processed_sequence_id\x18\x02 \x01(\x03R\x16maxProcessedSequenceId\x12!\n\x0cpublisher_id\x18\x03 \x01(\x0cR\x0bpublisherId\"\x9f\x01\n\x16GcsSubscriberPollReply\x12\x36\n\x0cpub_messages\x18\x01 \x03(\x0b\x32\x13.ray.rpc.PubMessageR\x0bpubMessages\x12!\n\x0cpublisher_id\x18\x02 \x01(\x0cR\x0bpublisherId\x12*\n\x06status\x18\x64 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x92\x01\n GcsSubscriberCommandBatchRequest\x12#\n\rsubscriber_id\x18\x01 \x01(\x0cR\x0csubscriberId\x12,\n\x08\x63ommands\x18\x02 \x03(\x0b\x32\x10.ray.rpc.CommandR\x08\x63ommands\x12\x1b\n\tsender_id\x18\x03 \x01(\x0cR\x08senderId\"L\n\x1eGcsSubscriberCommandBatchReply\x12*\n\x06status\x18\x64 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\x1c\n\x1aGetAllResourceUsageRequest\"\xe9\x01\n\x18GetAllResourceUsageReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12O\n\x13resource_usage_data\x18\x02 \x01(\x0b\x32\x1f.ray.rpc.ResourceUsageBatchDataR\x11resourceUsageData\x12P\n&cluster_full_of_actors_detected_by_gcs\x18\x03 \x01(\x08R clusterFullOfActorsDetectedByGcs\"\x19\n\x17GetDrainingNodesRequest\"l\n\x0c\x44rainingNode\x12\x17\n\x07node_id\x18\x01 \x01(\x0cR\x06nodeId\x12\x43\n\x1e\x64raining_deadline_timestamp_ms\x18\x02 \x01(\x03R\x1b\x64rainingDeadlineTimestampMs\"\x81\x01\n\x15GetDrainingNodesReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12<\n\x0e\x64raining_nodes\x18\x02 \x03(\x0b\x32\x15.ray.rpc.DrainingNodeR\rdrainingNodes\"9\n\tGcsStatus\x12\x12\n\x04\x63ode\x18\x01 \x01(\x05R\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"E\n\x17\x41\x64\x64TaskEventDataRequest\x12*\n\x04\x64\x61ta\x18\x01 \x01(\x0b\x32\x16.ray.rpc.TaskEventDataR\x04\x64\x61ta\"C\n\x15\x41\x64\x64TaskEventDataReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\"\xfe\x08\n\x14GetTaskEventsRequest\x12\x19\n\x05limit\x18\x03 \x01(\x03H\x00R\x05limit\x88\x01\x01\x12\x44\n\x07\x66ilters\x18\x04 \x01(\x0b\x32%.ray.rpc.GetTaskEventsRequest.FiltersH\x01R\x07\x66ilters\x88\x01\x01\x1a\xee\x07\n\x07\x46ilters\x12R\n\x0bjob_filters\x18\x01 \x03(\x0b\x32\x31.ray.rpc.GetTaskEventsRequest.Filters.JobIdFilterR\njobFilters\x12U\n\x0ctask_filters\x18\x02 \x03(\x0b\x32\x32.ray.rpc.GetTaskEventsRequest.Filters.TaskIdFilterR\x0btaskFilters\x12X\n\ractor_filters\x18\x03 \x03(\x0b\x32\x33.ray.rpc.GetTaskEventsRequest.Filters.ActorIdFilterR\x0c\x61\x63torFilters\x12`\n\x11task_name_filters\x18\x04 \x03(\x0b\x32\x34.ray.rpc.GetTaskEventsRequest.Filters.TaskNameFilterR\x0ftaskNameFilters\x12*\n\x0e\x65xclude_driver\x18\x05 \x01(\x08H\x00R\rexcludeDriver\x88\x01\x01\x12V\n\rstate_filters\x18\x06 \x03(\x0b\x32\x31.ray.rpc.GetTaskEventsRequest.Filters.StateFilterR\x0cstateFilters\x1a\\\n\x0bJobIdFilter\x12\x36\n\tpredicate\x18\x01 \x01(\x0e\x32\x18.ray.rpc.FilterPredicateR\tpredicate\x12\x15\n\x06job_id\x18\x02 \x01(\x0cR\x05jobId\x1a_\n\x0cTaskIdFilter\x12\x36\n\tpredicate\x18\x01 \x01(\x0e\x32\x18.ray.rpc.FilterPredicateR\tpredicate\x12\x17\n\x07task_id\x18\x02 \x01(\x0cR\x06taskId\x1a\x62\n\rActorIdFilter\x12\x36\n\tpredicate\x18\x01 \x01(\x0e\x32\x18.ray.rpc.FilterPredicateR\tpredicate\x12\x19\n\x08\x61\x63tor_id\x18\x02 \x01(\x0cR\x07\x61\x63torId\x1a\x65\n\x0eTaskNameFilter\x12\x36\n\tpredicate\x18\x01 \x01(\x0e\x32\x18.ray.rpc.FilterPredicateR\tpredicate\x12\x1b\n\ttask_name\x18\x02 \x01(\tR\x08taskName\x1a[\n\x0bStateFilter\x12\x36\n\tpredicate\x18\x01 \x01(\x0e\x32\x18.ray.rpc.FilterPredicateR\tpredicate\x12\x14\n\x05state\x18\x02 \x01(\tR\x05stateB\x11\n\x0f_exclude_driverB\x08\n\x06_limitB\n\n\x08_filters\"\x83\x03\n\x12GetTaskEventsReply\x12*\n\x06status\x18\x01 \x01(\x0b\x32\x12.ray.rpc.GcsStatusR\x06status\x12\x39\n\x0e\x65vents_by_task\x18\x02 \x03(\x0b\x32\x13.ray.rpc.TaskEventsR\x0c\x65ventsByTask\x12\x44\n\x1fnum_profile_task_events_dropped\x18\x03 \x01(\x05R\x1bnumProfileTaskEventsDropped\x12\x42\n\x1enum_status_task_events_dropped\x18\x04 \x01(\x05R\x1anumStatusTaskEventsDropped\x12(\n\x10num_total_stored\x18\x05 \x01(\x03R\x0enumTotalStored\x12-\n\x13num_filtered_on_gcs\x18\x06 \x01(\x03R\x10numFilteredOnGcs\x12#\n\rnum_truncated\x18\x07 \x01(\x03R\x0cnumTruncated*C\n\x15GcsServiceFailureType\x12\x12\n\x0eRPC_DISCONNECT\x10\x00\x12\x16\n\x12GCS_SERVER_RESTART\x10\x01*+\n\x0f\x46ilterPredicate\x12\t\n\x05\x45QUAL\x10\x00\x12\r\n\tNOT_EQUAL\x10\x01\x32\x85\x03\n\x11JobInfoGcsService\x12\x36\n\x06\x41\x64\x64Job\x12\x16.ray.rpc.AddJobRequest\x1a\x14.ray.rpc.AddJobReply\x12Q\n\x0fMarkJobFinished\x12\x1f.ray.rpc.MarkJobFinishedRequest\x1a\x1d.ray.rpc.MarkJobFinishedReply\x12K\n\rGetAllJobInfo\x12\x1d.ray.rpc.GetAllJobInfoRequest\x1a\x1b.ray.rpc.GetAllJobInfoReply\x12N\n\x0eReportJobError\x12\x1e.ray.rpc.ReportJobErrorRequest\x1a\x1c.ray.rpc.ReportJobErrorReply\x12H\n\x0cGetNextJobID\x12\x1c.ray.rpc.GetNextJobIDRequest\x1a\x1a.ray.rpc.GetNextJobIDReply2\xbd\x06\n\x13\x41\x63torInfoGcsService\x12K\n\rRegisterActor\x12\x1d.ray.rpc.RegisterActorRequest\x1a\x1b.ray.rpc.RegisterActorReply\x12\x90\x01\n$RestartActorForLineageReconstruction\x12\x34.ray.rpc.RestartActorForLineageReconstructionRequest\x1a\x32.ray.rpc.RestartActorForLineageReconstructionReply\x12\x45\n\x0b\x43reateActor\x12\x1b.ray.rpc.CreateActorRequest\x1a\x19.ray.rpc.CreateActorReply\x12H\n\x0cGetActorInfo\x12\x1c.ray.rpc.GetActorInfoRequest\x1a\x1a.ray.rpc.GetActorInfoReply\x12W\n\x11GetNamedActorInfo\x12!.ray.rpc.GetNamedActorInfoRequest\x1a\x1f.ray.rpc.GetNamedActorInfoReply\x12Q\n\x0fListNamedActors\x12\x1f.ray.rpc.ListNamedActorsRequest\x1a\x1d.ray.rpc.ListNamedActorsReply\x12Q\n\x0fGetAllActorInfo\x12\x1f.ray.rpc.GetAllActorInfoRequest\x1a\x1d.ray.rpc.GetAllActorInfoReply\x12Q\n\x0fKillActorViaGcs\x12\x1f.ray.rpc.KillActorViaGcsRequest\x1a\x1d.ray.rpc.KillActorViaGcsReply\x12\x63\n\x15ReportActorOutOfScope\x12%.ray.rpc.ReportActorOutOfScopeRequest\x1a#.ray.rpc.ReportActorOutOfScopeReply2\xcd\x04\n\x14WorkerInfoGcsService\x12]\n\x13ReportWorkerFailure\x12#.ray.rpc.ReportWorkerFailureRequest\x1a!.ray.rpc.ReportWorkerFailureReply\x12K\n\rGetWorkerInfo\x12\x1d.ray.rpc.GetWorkerInfoRequest\x1a\x1b.ray.rpc.GetWorkerInfoReply\x12T\n\x10GetAllWorkerInfo\x12 .ray.rpc.GetAllWorkerInfoRequest\x1a\x1e.ray.rpc.GetAllWorkerInfoReply\x12K\n\rAddWorkerInfo\x12\x1d.ray.rpc.AddWorkerInfoRequest\x1a\x1b.ray.rpc.AddWorkerInfoReply\x12l\n\x18UpdateWorkerDebuggerPort\x12(.ray.rpc.UpdateWorkerDebuggerPortRequest\x1a&.ray.rpc.UpdateWorkerDebuggerPortReply\x12x\n\x1cUpdateWorkerNumPausedThreads\x12,.ray.rpc.UpdateWorkerNumPausedThreadsRequest\x1a*.ray.rpc.UpdateWorkerNumPausedThreadsReply2\xff\x04\n\x1cPlacementGroupInfoGcsService\x12`\n\x14\x43reatePlacementGroup\x12$.ray.rpc.CreatePlacementGroupRequest\x1a\".ray.rpc.CreatePlacementGroupReply\x12`\n\x14RemovePlacementGroup\x12$.ray.rpc.RemovePlacementGroupRequest\x1a\".ray.rpc.RemovePlacementGroupReply\x12W\n\x11GetPlacementGroup\x12!.ray.rpc.GetPlacementGroupRequest\x1a\x1f.ray.rpc.GetPlacementGroupReply\x12\x66\n\x16GetNamedPlacementGroup\x12&.ray.rpc.GetNamedPlacementGroupRequest\x1a$.ray.rpc.GetNamedPlacementGroupReply\x12`\n\x14GetAllPlacementGroup\x12$.ray.rpc.GetAllPlacementGroupRequest\x1a\".ray.rpc.GetAllPlacementGroupReply\x12x\n\x1cWaitPlacementGroupUntilReady\x12,.ray.rpc.WaitPlacementGroupUntilReadyRequest\x1a*.ray.rpc.WaitPlacementGroupUntilReadyReply2\xd8\x04\n\x14InternalKVGcsService\x12K\n\rInternalKVGet\x12\x1d.ray.rpc.InternalKVGetRequest\x1a\x1b.ray.rpc.InternalKVGetReply\x12Z\n\x12InternalKVMultiGet\x12\".ray.rpc.InternalKVMultiGetRequest\x1a .ray.rpc.InternalKVMultiGetReply\x12K\n\rInternalKVPut\x12\x1d.ray.rpc.InternalKVPutRequest\x1a\x1b.ray.rpc.InternalKVPutReply\x12K\n\rInternalKVDel\x12\x1d.ray.rpc.InternalKVDelRequest\x1a\x1b.ray.rpc.InternalKVDelReply\x12T\n\x10InternalKVExists\x12 .ray.rpc.InternalKVExistsRequest\x1a\x1e.ray.rpc.InternalKVExistsReply\x12N\n\x0eInternalKVKeys\x12\x1e.ray.rpc.InternalKVKeysRequest\x1a\x1c.ray.rpc.InternalKVKeysReply\x12W\n\x11GetInternalConfig\x12!.ray.rpc.GetInternalConfigRequest\x1a\x1f.ray.rpc.GetInternalConfigReply2l\n\x14RuntimeEnvGcsService\x12T\n\x10PinRuntimeEnvURI\x12 .ray.rpc.PinRuntimeEnvURIRequest\x1a\x1e.ray.rpc.PinRuntimeEnvURIReply2\xa8\x02\n\x18InternalPubSubGcsService\x12\x42\n\nGcsPublish\x12\x1a.ray.rpc.GcsPublishRequest\x1a\x18.ray.rpc.GcsPublishReply\x12W\n\x11GcsSubscriberPoll\x12!.ray.rpc.GcsSubscriberPollRequest\x1a\x1f.ray.rpc.GcsSubscriberPollReply\x12o\n\x19GcsSubscriberCommandBatch\x12).ray.rpc.GcsSubscriberCommandBatchRequest\x1a\'.ray.rpc.GcsSubscriberCommandBatchReply2\xa1\x03\n\x1aNodeResourceInfoGcsService\x12l\n\x18GetAllAvailableResources\x12(.ray.rpc.GetAllAvailableResourcesRequest\x1a&.ray.rpc.GetAllAvailableResourcesReply\x12`\n\x14GetAllTotalResources\x12$.ray.rpc.GetAllTotalResourcesRequest\x1a\".ray.rpc.GetAllTotalResourcesReply\x12]\n\x13GetAllResourceUsage\x12#.ray.rpc.GetAllResourceUsageRequest\x1a!.ray.rpc.GetAllResourceUsageReply\x12T\n\x10GetDrainingNodes\x12 .ray.rpc.GetDrainingNodesRequest\x1a\x1e.ray.rpc.GetDrainingNodesReply2\xc7\x04\n\x12NodeInfoGcsService\x12H\n\x0cGetClusterId\x12\x1c.ray.rpc.GetClusterIdRequest\x1a\x1a.ray.rpc.GetClusterIdReply\x12H\n\x0cRegisterNode\x12\x1c.ray.rpc.RegisterNodeRequest\x1a\x1a.ray.rpc.RegisterNodeReply\x12N\n\x0eUnregisterNode\x12\x1e.ray.rpc.UnregisterNodeRequest\x1a\x1c.ray.rpc.UnregisterNodeReply\x12?\n\tDrainNode\x12\x19.ray.rpc.DrainNodeRequest\x1a\x17.ray.rpc.DrainNodeReply\x12N\n\x0eGetAllNodeInfo\x12\x1e.ray.rpc.GetAllNodeInfoRequest\x1a\x1c.ray.rpc.GetAllNodeInfoReply\x12x\n\x1cGetAllNodeAddressAndLiveness\x12,.ray.rpc.GetAllNodeAddressAndLivenessRequest\x1a*.ray.rpc.GetAllNodeAddressAndLivenessReply\x12\x42\n\nCheckAlive\x12\x1a.ray.rpc.CheckAliveRequest\x1a\x18.ray.rpc.CheckAliveReply2\xb7\x01\n\x12TaskInfoGcsService\x12T\n\x10\x41\x64\x64TaskEventData\x12 .ray.rpc.AddTaskEventDataRequest\x1a\x1e.ray.rpc.AddTaskEventDataReply\x12K\n\rGetTaskEvents\x12\x1d.ray.rpc.GetTaskEventsRequest\x1a\x1b.ray.rpc.GetTaskEventsReply2i\n\x18RayEventExportGcsService\x12M\n\tAddEvents\x12 .ray.rpc.events.AddEventsRequest\x1a\x1e.ray.rpc.events.AddEventsReplyb\x06proto3') + +_GCSSERVICEFAILURETYPE = DESCRIPTOR.enum_types_by_name['GcsServiceFailureType'] +GcsServiceFailureType = enum_type_wrapper.EnumTypeWrapper(_GCSSERVICEFAILURETYPE) +_FILTERPREDICATE = DESCRIPTOR.enum_types_by_name['FilterPredicate'] +FilterPredicate = enum_type_wrapper.EnumTypeWrapper(_FILTERPREDICATE) +RPC_DISCONNECT = 0 +GCS_SERVER_RESTART = 1 +EQUAL = 0 +NOT_EQUAL = 1 + + +_ADDJOBREQUEST = DESCRIPTOR.message_types_by_name['AddJobRequest'] +_ADDJOBREPLY = DESCRIPTOR.message_types_by_name['AddJobReply'] +_MARKJOBFINISHEDREQUEST = DESCRIPTOR.message_types_by_name['MarkJobFinishedRequest'] +_MARKJOBFINISHEDREPLY = DESCRIPTOR.message_types_by_name['MarkJobFinishedReply'] +_GETALLJOBINFOREQUEST = DESCRIPTOR.message_types_by_name['GetAllJobInfoRequest'] +_GETALLJOBINFOREPLY = DESCRIPTOR.message_types_by_name['GetAllJobInfoReply'] +_REPORTJOBERRORREQUEST = DESCRIPTOR.message_types_by_name['ReportJobErrorRequest'] +_REPORTJOBERRORREPLY = DESCRIPTOR.message_types_by_name['ReportJobErrorReply'] +_GETNEXTJOBIDREQUEST = DESCRIPTOR.message_types_by_name['GetNextJobIDRequest'] +_GETNEXTJOBIDREPLY = DESCRIPTOR.message_types_by_name['GetNextJobIDReply'] +_GETACTORINFOREQUEST = DESCRIPTOR.message_types_by_name['GetActorInfoRequest'] +_GETACTORINFOREPLY = DESCRIPTOR.message_types_by_name['GetActorInfoReply'] +_GETNAMEDACTORINFOREQUEST = DESCRIPTOR.message_types_by_name['GetNamedActorInfoRequest'] +_GETNAMEDACTORINFOREPLY = DESCRIPTOR.message_types_by_name['GetNamedActorInfoReply'] +_LISTNAMEDACTORSREQUEST = DESCRIPTOR.message_types_by_name['ListNamedActorsRequest'] +_LISTNAMEDACTORSREPLY = DESCRIPTOR.message_types_by_name['ListNamedActorsReply'] +_GETALLACTORINFOREQUEST = DESCRIPTOR.message_types_by_name['GetAllActorInfoRequest'] +_GETALLACTORINFOREQUEST_FILTERS = _GETALLACTORINFOREQUEST.nested_types_by_name['Filters'] +_GETALLACTORINFOREPLY = DESCRIPTOR.message_types_by_name['GetAllActorInfoReply'] +_KILLACTORVIAGCSREQUEST = DESCRIPTOR.message_types_by_name['KillActorViaGcsRequest'] +_KILLACTORVIAGCSREPLY = DESCRIPTOR.message_types_by_name['KillActorViaGcsReply'] +_REPORTACTOROUTOFSCOPEREQUEST = DESCRIPTOR.message_types_by_name['ReportActorOutOfScopeRequest'] +_REPORTACTOROUTOFSCOPEREPLY = DESCRIPTOR.message_types_by_name['ReportActorOutOfScopeReply'] +_GETCLUSTERIDREQUEST = DESCRIPTOR.message_types_by_name['GetClusterIdRequest'] +_GETCLUSTERIDREPLY = DESCRIPTOR.message_types_by_name['GetClusterIdReply'] +_REGISTERNODEREQUEST = DESCRIPTOR.message_types_by_name['RegisterNodeRequest'] +_REGISTERNODEREPLY = DESCRIPTOR.message_types_by_name['RegisterNodeReply'] +_UNREGISTERNODEREQUEST = DESCRIPTOR.message_types_by_name['UnregisterNodeRequest'] +_UNREGISTERNODEREPLY = DESCRIPTOR.message_types_by_name['UnregisterNodeReply'] +_GETALLNODEINFOREQUEST = DESCRIPTOR.message_types_by_name['GetAllNodeInfoRequest'] +_GETALLNODEINFOREQUEST_NODESELECTOR = _GETALLNODEINFOREQUEST.nested_types_by_name['NodeSelector'] +_GETALLNODEINFOREPLY = DESCRIPTOR.message_types_by_name['GetAllNodeInfoReply'] +_GETALLNODEADDRESSANDLIVENESSREQUEST = DESCRIPTOR.message_types_by_name['GetAllNodeAddressAndLivenessRequest'] +_GETALLNODEADDRESSANDLIVENESSREPLY = DESCRIPTOR.message_types_by_name['GetAllNodeAddressAndLivenessReply'] +_CHECKALIVEREQUEST = DESCRIPTOR.message_types_by_name['CheckAliveRequest'] +_CHECKALIVEREPLY = DESCRIPTOR.message_types_by_name['CheckAliveReply'] +_GETINTERNALCONFIGREQUEST = DESCRIPTOR.message_types_by_name['GetInternalConfigRequest'] +_GETINTERNALCONFIGREPLY = DESCRIPTOR.message_types_by_name['GetInternalConfigReply'] +_DELETERESOURCESREPLY = DESCRIPTOR.message_types_by_name['DeleteResourcesReply'] +_GETALLAVAILABLERESOURCESREQUEST = DESCRIPTOR.message_types_by_name['GetAllAvailableResourcesRequest'] +_GETALLAVAILABLERESOURCESREPLY = DESCRIPTOR.message_types_by_name['GetAllAvailableResourcesReply'] +_GETALLTOTALRESOURCESREQUEST = DESCRIPTOR.message_types_by_name['GetAllTotalResourcesRequest'] +_GETALLTOTALRESOURCESREPLY = DESCRIPTOR.message_types_by_name['GetAllTotalResourcesReply'] +_REPORTWORKERFAILUREREQUEST = DESCRIPTOR.message_types_by_name['ReportWorkerFailureRequest'] +_REPORTWORKERFAILUREREPLY = DESCRIPTOR.message_types_by_name['ReportWorkerFailureReply'] +_GETWORKERINFOREQUEST = DESCRIPTOR.message_types_by_name['GetWorkerInfoRequest'] +_GETWORKERINFOREPLY = DESCRIPTOR.message_types_by_name['GetWorkerInfoReply'] +_GETALLWORKERINFOREQUEST = DESCRIPTOR.message_types_by_name['GetAllWorkerInfoRequest'] +_GETALLWORKERINFOREQUEST_FILTERS = _GETALLWORKERINFOREQUEST.nested_types_by_name['Filters'] +_GETALLWORKERINFOREPLY = DESCRIPTOR.message_types_by_name['GetAllWorkerInfoReply'] +_ADDWORKERINFOREQUEST = DESCRIPTOR.message_types_by_name['AddWorkerInfoRequest'] +_ADDWORKERINFOREPLY = DESCRIPTOR.message_types_by_name['AddWorkerInfoReply'] +_UPDATEWORKERDEBUGGERPORTREQUEST = DESCRIPTOR.message_types_by_name['UpdateWorkerDebuggerPortRequest'] +_UPDATEWORKERDEBUGGERPORTREPLY = DESCRIPTOR.message_types_by_name['UpdateWorkerDebuggerPortReply'] +_UPDATEWORKERNUMPAUSEDTHREADSREQUEST = DESCRIPTOR.message_types_by_name['UpdateWorkerNumPausedThreadsRequest'] +_UPDATEWORKERNUMPAUSEDTHREADSREPLY = DESCRIPTOR.message_types_by_name['UpdateWorkerNumPausedThreadsReply'] +_CREATEACTORREQUEST = DESCRIPTOR.message_types_by_name['CreateActorRequest'] +_CREATEACTORREPLY = DESCRIPTOR.message_types_by_name['CreateActorReply'] +_REGISTERACTORREQUEST = DESCRIPTOR.message_types_by_name['RegisterActorRequest'] +_REGISTERACTORREPLY = DESCRIPTOR.message_types_by_name['RegisterActorReply'] +_RESTARTACTORFORLINEAGERECONSTRUCTIONREQUEST = DESCRIPTOR.message_types_by_name['RestartActorForLineageReconstructionRequest'] +_RESTARTACTORFORLINEAGERECONSTRUCTIONREPLY = DESCRIPTOR.message_types_by_name['RestartActorForLineageReconstructionReply'] +_CREATEPLACEMENTGROUPREQUEST = DESCRIPTOR.message_types_by_name['CreatePlacementGroupRequest'] +_CREATEPLACEMENTGROUPREPLY = DESCRIPTOR.message_types_by_name['CreatePlacementGroupReply'] +_REMOVEPLACEMENTGROUPREQUEST = DESCRIPTOR.message_types_by_name['RemovePlacementGroupRequest'] +_REMOVEPLACEMENTGROUPREPLY = DESCRIPTOR.message_types_by_name['RemovePlacementGroupReply'] +_GETPLACEMENTGROUPREQUEST = DESCRIPTOR.message_types_by_name['GetPlacementGroupRequest'] +_GETPLACEMENTGROUPREPLY = DESCRIPTOR.message_types_by_name['GetPlacementGroupReply'] +_GETALLPLACEMENTGROUPREQUEST = DESCRIPTOR.message_types_by_name['GetAllPlacementGroupRequest'] +_GETALLPLACEMENTGROUPREPLY = DESCRIPTOR.message_types_by_name['GetAllPlacementGroupReply'] +_WAITPLACEMENTGROUPUNTILREADYREQUEST = DESCRIPTOR.message_types_by_name['WaitPlacementGroupUntilReadyRequest'] +_WAITPLACEMENTGROUPUNTILREADYREPLY = DESCRIPTOR.message_types_by_name['WaitPlacementGroupUntilReadyReply'] +_GETNAMEDPLACEMENTGROUPREQUEST = DESCRIPTOR.message_types_by_name['GetNamedPlacementGroupRequest'] +_GETNAMEDPLACEMENTGROUPREPLY = DESCRIPTOR.message_types_by_name['GetNamedPlacementGroupReply'] +_DRAINNODEDATA = DESCRIPTOR.message_types_by_name['DrainNodeData'] +_DRAINNODEREQUEST = DESCRIPTOR.message_types_by_name['DrainNodeRequest'] +_DRAINNODESTATUS = DESCRIPTOR.message_types_by_name['DrainNodeStatus'] +_DRAINNODEREPLY = DESCRIPTOR.message_types_by_name['DrainNodeReply'] +_INTERNALKVGETREQUEST = DESCRIPTOR.message_types_by_name['InternalKVGetRequest'] +_INTERNALKVGETREPLY = DESCRIPTOR.message_types_by_name['InternalKVGetReply'] +_INTERNALKVMULTIGETREQUEST = DESCRIPTOR.message_types_by_name['InternalKVMultiGetRequest'] +_MAPFIELDENTRY = DESCRIPTOR.message_types_by_name['MapFieldEntry'] +_INTERNALKVMULTIGETREPLY = DESCRIPTOR.message_types_by_name['InternalKVMultiGetReply'] +_INTERNALKVPUTREQUEST = DESCRIPTOR.message_types_by_name['InternalKVPutRequest'] +_INTERNALKVPUTREPLY = DESCRIPTOR.message_types_by_name['InternalKVPutReply'] +_INTERNALKVDELREQUEST = DESCRIPTOR.message_types_by_name['InternalKVDelRequest'] +_INTERNALKVDELREPLY = DESCRIPTOR.message_types_by_name['InternalKVDelReply'] +_INTERNALKVEXISTSREQUEST = DESCRIPTOR.message_types_by_name['InternalKVExistsRequest'] +_INTERNALKVEXISTSREPLY = DESCRIPTOR.message_types_by_name['InternalKVExistsReply'] +_INTERNALKVKEYSREQUEST = DESCRIPTOR.message_types_by_name['InternalKVKeysRequest'] +_INTERNALKVKEYSREPLY = DESCRIPTOR.message_types_by_name['InternalKVKeysReply'] +_PINRUNTIMEENVURIREQUEST = DESCRIPTOR.message_types_by_name['PinRuntimeEnvURIRequest'] +_PINRUNTIMEENVURIREPLY = DESCRIPTOR.message_types_by_name['PinRuntimeEnvURIReply'] +_GCSPUBLISHREQUEST = DESCRIPTOR.message_types_by_name['GcsPublishRequest'] +_GCSPUBLISHREPLY = DESCRIPTOR.message_types_by_name['GcsPublishReply'] +_GCSSUBSCRIBERPOLLREQUEST = DESCRIPTOR.message_types_by_name['GcsSubscriberPollRequest'] +_GCSSUBSCRIBERPOLLREPLY = DESCRIPTOR.message_types_by_name['GcsSubscriberPollReply'] +_GCSSUBSCRIBERCOMMANDBATCHREQUEST = DESCRIPTOR.message_types_by_name['GcsSubscriberCommandBatchRequest'] +_GCSSUBSCRIBERCOMMANDBATCHREPLY = DESCRIPTOR.message_types_by_name['GcsSubscriberCommandBatchReply'] +_GETALLRESOURCEUSAGEREQUEST = DESCRIPTOR.message_types_by_name['GetAllResourceUsageRequest'] +_GETALLRESOURCEUSAGEREPLY = DESCRIPTOR.message_types_by_name['GetAllResourceUsageReply'] +_GETDRAININGNODESREQUEST = DESCRIPTOR.message_types_by_name['GetDrainingNodesRequest'] +_DRAININGNODE = DESCRIPTOR.message_types_by_name['DrainingNode'] +_GETDRAININGNODESREPLY = DESCRIPTOR.message_types_by_name['GetDrainingNodesReply'] +_GCSSTATUS = DESCRIPTOR.message_types_by_name['GcsStatus'] +_ADDTASKEVENTDATAREQUEST = DESCRIPTOR.message_types_by_name['AddTaskEventDataRequest'] +_ADDTASKEVENTDATAREPLY = DESCRIPTOR.message_types_by_name['AddTaskEventDataReply'] +_GETTASKEVENTSREQUEST = DESCRIPTOR.message_types_by_name['GetTaskEventsRequest'] +_GETTASKEVENTSREQUEST_FILTERS = _GETTASKEVENTSREQUEST.nested_types_by_name['Filters'] +_GETTASKEVENTSREQUEST_FILTERS_JOBIDFILTER = _GETTASKEVENTSREQUEST_FILTERS.nested_types_by_name['JobIdFilter'] +_GETTASKEVENTSREQUEST_FILTERS_TASKIDFILTER = _GETTASKEVENTSREQUEST_FILTERS.nested_types_by_name['TaskIdFilter'] +_GETTASKEVENTSREQUEST_FILTERS_ACTORIDFILTER = _GETTASKEVENTSREQUEST_FILTERS.nested_types_by_name['ActorIdFilter'] +_GETTASKEVENTSREQUEST_FILTERS_TASKNAMEFILTER = _GETTASKEVENTSREQUEST_FILTERS.nested_types_by_name['TaskNameFilter'] +_GETTASKEVENTSREQUEST_FILTERS_STATEFILTER = _GETTASKEVENTSREQUEST_FILTERS.nested_types_by_name['StateFilter'] +_GETTASKEVENTSREPLY = DESCRIPTOR.message_types_by_name['GetTaskEventsReply'] +AddJobRequest = _reflection.GeneratedProtocolMessageType('AddJobRequest', (_message.Message,), { + 'DESCRIPTOR' : _ADDJOBREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddJobRequest) + }) +_sym_db.RegisterMessage(AddJobRequest) + +AddJobReply = _reflection.GeneratedProtocolMessageType('AddJobReply', (_message.Message,), { + 'DESCRIPTOR' : _ADDJOBREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddJobReply) + }) +_sym_db.RegisterMessage(AddJobReply) + +MarkJobFinishedRequest = _reflection.GeneratedProtocolMessageType('MarkJobFinishedRequest', (_message.Message,), { + 'DESCRIPTOR' : _MARKJOBFINISHEDREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.MarkJobFinishedRequest) + }) +_sym_db.RegisterMessage(MarkJobFinishedRequest) + +MarkJobFinishedReply = _reflection.GeneratedProtocolMessageType('MarkJobFinishedReply', (_message.Message,), { + 'DESCRIPTOR' : _MARKJOBFINISHEDREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.MarkJobFinishedReply) + }) +_sym_db.RegisterMessage(MarkJobFinishedReply) + +GetAllJobInfoRequest = _reflection.GeneratedProtocolMessageType('GetAllJobInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLJOBINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllJobInfoRequest) + }) +_sym_db.RegisterMessage(GetAllJobInfoRequest) + +GetAllJobInfoReply = _reflection.GeneratedProtocolMessageType('GetAllJobInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLJOBINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllJobInfoReply) + }) +_sym_db.RegisterMessage(GetAllJobInfoReply) + +ReportJobErrorRequest = _reflection.GeneratedProtocolMessageType('ReportJobErrorRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTJOBERRORREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportJobErrorRequest) + }) +_sym_db.RegisterMessage(ReportJobErrorRequest) + +ReportJobErrorReply = _reflection.GeneratedProtocolMessageType('ReportJobErrorReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTJOBERRORREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportJobErrorReply) + }) +_sym_db.RegisterMessage(ReportJobErrorReply) + +GetNextJobIDRequest = _reflection.GeneratedProtocolMessageType('GetNextJobIDRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETNEXTJOBIDREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNextJobIDRequest) + }) +_sym_db.RegisterMessage(GetNextJobIDRequest) + +GetNextJobIDReply = _reflection.GeneratedProtocolMessageType('GetNextJobIDReply', (_message.Message,), { + 'DESCRIPTOR' : _GETNEXTJOBIDREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNextJobIDReply) + }) +_sym_db.RegisterMessage(GetNextJobIDReply) + +GetActorInfoRequest = _reflection.GeneratedProtocolMessageType('GetActorInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETACTORINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetActorInfoRequest) + }) +_sym_db.RegisterMessage(GetActorInfoRequest) + +GetActorInfoReply = _reflection.GeneratedProtocolMessageType('GetActorInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETACTORINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetActorInfoReply) + }) +_sym_db.RegisterMessage(GetActorInfoReply) + +GetNamedActorInfoRequest = _reflection.GeneratedProtocolMessageType('GetNamedActorInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETNAMEDACTORINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNamedActorInfoRequest) + }) +_sym_db.RegisterMessage(GetNamedActorInfoRequest) + +GetNamedActorInfoReply = _reflection.GeneratedProtocolMessageType('GetNamedActorInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETNAMEDACTORINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNamedActorInfoReply) + }) +_sym_db.RegisterMessage(GetNamedActorInfoReply) + +ListNamedActorsRequest = _reflection.GeneratedProtocolMessageType('ListNamedActorsRequest', (_message.Message,), { + 'DESCRIPTOR' : _LISTNAMEDACTORSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ListNamedActorsRequest) + }) +_sym_db.RegisterMessage(ListNamedActorsRequest) + +ListNamedActorsReply = _reflection.GeneratedProtocolMessageType('ListNamedActorsReply', (_message.Message,), { + 'DESCRIPTOR' : _LISTNAMEDACTORSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ListNamedActorsReply) + }) +_sym_db.RegisterMessage(ListNamedActorsReply) + +GetAllActorInfoRequest = _reflection.GeneratedProtocolMessageType('GetAllActorInfoRequest', (_message.Message,), { + + 'Filters' : _reflection.GeneratedProtocolMessageType('Filters', (_message.Message,), { + 'DESCRIPTOR' : _GETALLACTORINFOREQUEST_FILTERS, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllActorInfoRequest.Filters) + }) + , + 'DESCRIPTOR' : _GETALLACTORINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllActorInfoRequest) + }) +_sym_db.RegisterMessage(GetAllActorInfoRequest) +_sym_db.RegisterMessage(GetAllActorInfoRequest.Filters) + +GetAllActorInfoReply = _reflection.GeneratedProtocolMessageType('GetAllActorInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLACTORINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllActorInfoReply) + }) +_sym_db.RegisterMessage(GetAllActorInfoReply) + +KillActorViaGcsRequest = _reflection.GeneratedProtocolMessageType('KillActorViaGcsRequest', (_message.Message,), { + 'DESCRIPTOR' : _KILLACTORVIAGCSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillActorViaGcsRequest) + }) +_sym_db.RegisterMessage(KillActorViaGcsRequest) + +KillActorViaGcsReply = _reflection.GeneratedProtocolMessageType('KillActorViaGcsReply', (_message.Message,), { + 'DESCRIPTOR' : _KILLACTORVIAGCSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillActorViaGcsReply) + }) +_sym_db.RegisterMessage(KillActorViaGcsReply) + +ReportActorOutOfScopeRequest = _reflection.GeneratedProtocolMessageType('ReportActorOutOfScopeRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTACTOROUTOFSCOPEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportActorOutOfScopeRequest) + }) +_sym_db.RegisterMessage(ReportActorOutOfScopeRequest) + +ReportActorOutOfScopeReply = _reflection.GeneratedProtocolMessageType('ReportActorOutOfScopeReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTACTOROUTOFSCOPEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportActorOutOfScopeReply) + }) +_sym_db.RegisterMessage(ReportActorOutOfScopeReply) + +GetClusterIdRequest = _reflection.GeneratedProtocolMessageType('GetClusterIdRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERIDREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetClusterIdRequest) + }) +_sym_db.RegisterMessage(GetClusterIdRequest) + +GetClusterIdReply = _reflection.GeneratedProtocolMessageType('GetClusterIdReply', (_message.Message,), { + 'DESCRIPTOR' : _GETCLUSTERIDREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetClusterIdReply) + }) +_sym_db.RegisterMessage(GetClusterIdReply) + +RegisterNodeRequest = _reflection.GeneratedProtocolMessageType('RegisterNodeRequest', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERNODEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterNodeRequest) + }) +_sym_db.RegisterMessage(RegisterNodeRequest) + +RegisterNodeReply = _reflection.GeneratedProtocolMessageType('RegisterNodeReply', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERNODEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterNodeReply) + }) +_sym_db.RegisterMessage(RegisterNodeReply) + +UnregisterNodeRequest = _reflection.GeneratedProtocolMessageType('UnregisterNodeRequest', (_message.Message,), { + 'DESCRIPTOR' : _UNREGISTERNODEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UnregisterNodeRequest) + }) +_sym_db.RegisterMessage(UnregisterNodeRequest) + +UnregisterNodeReply = _reflection.GeneratedProtocolMessageType('UnregisterNodeReply', (_message.Message,), { + 'DESCRIPTOR' : _UNREGISTERNODEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UnregisterNodeReply) + }) +_sym_db.RegisterMessage(UnregisterNodeReply) + +GetAllNodeInfoRequest = _reflection.GeneratedProtocolMessageType('GetAllNodeInfoRequest', (_message.Message,), { + + 'NodeSelector' : _reflection.GeneratedProtocolMessageType('NodeSelector', (_message.Message,), { + 'DESCRIPTOR' : _GETALLNODEINFOREQUEST_NODESELECTOR, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllNodeInfoRequest.NodeSelector) + }) + , + 'DESCRIPTOR' : _GETALLNODEINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllNodeInfoRequest) + }) +_sym_db.RegisterMessage(GetAllNodeInfoRequest) +_sym_db.RegisterMessage(GetAllNodeInfoRequest.NodeSelector) + +GetAllNodeInfoReply = _reflection.GeneratedProtocolMessageType('GetAllNodeInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLNODEINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllNodeInfoReply) + }) +_sym_db.RegisterMessage(GetAllNodeInfoReply) + +GetAllNodeAddressAndLivenessRequest = _reflection.GeneratedProtocolMessageType('GetAllNodeAddressAndLivenessRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLNODEADDRESSANDLIVENESSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllNodeAddressAndLivenessRequest) + }) +_sym_db.RegisterMessage(GetAllNodeAddressAndLivenessRequest) + +GetAllNodeAddressAndLivenessReply = _reflection.GeneratedProtocolMessageType('GetAllNodeAddressAndLivenessReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLNODEADDRESSANDLIVENESSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllNodeAddressAndLivenessReply) + }) +_sym_db.RegisterMessage(GetAllNodeAddressAndLivenessReply) + +CheckAliveRequest = _reflection.GeneratedProtocolMessageType('CheckAliveRequest', (_message.Message,), { + 'DESCRIPTOR' : _CHECKALIVEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CheckAliveRequest) + }) +_sym_db.RegisterMessage(CheckAliveRequest) + +CheckAliveReply = _reflection.GeneratedProtocolMessageType('CheckAliveReply', (_message.Message,), { + 'DESCRIPTOR' : _CHECKALIVEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CheckAliveReply) + }) +_sym_db.RegisterMessage(CheckAliveReply) + +GetInternalConfigRequest = _reflection.GeneratedProtocolMessageType('GetInternalConfigRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETINTERNALCONFIGREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetInternalConfigRequest) + }) +_sym_db.RegisterMessage(GetInternalConfigRequest) + +GetInternalConfigReply = _reflection.GeneratedProtocolMessageType('GetInternalConfigReply', (_message.Message,), { + 'DESCRIPTOR' : _GETINTERNALCONFIGREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetInternalConfigReply) + }) +_sym_db.RegisterMessage(GetInternalConfigReply) + +DeleteResourcesReply = _reflection.GeneratedProtocolMessageType('DeleteResourcesReply', (_message.Message,), { + 'DESCRIPTOR' : _DELETERESOURCESREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteResourcesReply) + }) +_sym_db.RegisterMessage(DeleteResourcesReply) + +GetAllAvailableResourcesRequest = _reflection.GeneratedProtocolMessageType('GetAllAvailableResourcesRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLAVAILABLERESOURCESREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllAvailableResourcesRequest) + }) +_sym_db.RegisterMessage(GetAllAvailableResourcesRequest) + +GetAllAvailableResourcesReply = _reflection.GeneratedProtocolMessageType('GetAllAvailableResourcesReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLAVAILABLERESOURCESREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllAvailableResourcesReply) + }) +_sym_db.RegisterMessage(GetAllAvailableResourcesReply) + +GetAllTotalResourcesRequest = _reflection.GeneratedProtocolMessageType('GetAllTotalResourcesRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLTOTALRESOURCESREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllTotalResourcesRequest) + }) +_sym_db.RegisterMessage(GetAllTotalResourcesRequest) + +GetAllTotalResourcesReply = _reflection.GeneratedProtocolMessageType('GetAllTotalResourcesReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLTOTALRESOURCESREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllTotalResourcesReply) + }) +_sym_db.RegisterMessage(GetAllTotalResourcesReply) + +ReportWorkerFailureRequest = _reflection.GeneratedProtocolMessageType('ReportWorkerFailureRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTWORKERFAILUREREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportWorkerFailureRequest) + }) +_sym_db.RegisterMessage(ReportWorkerFailureRequest) + +ReportWorkerFailureReply = _reflection.GeneratedProtocolMessageType('ReportWorkerFailureReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTWORKERFAILUREREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportWorkerFailureReply) + }) +_sym_db.RegisterMessage(ReportWorkerFailureReply) + +GetWorkerInfoRequest = _reflection.GeneratedProtocolMessageType('GetWorkerInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerInfoRequest) + }) +_sym_db.RegisterMessage(GetWorkerInfoRequest) + +GetWorkerInfoReply = _reflection.GeneratedProtocolMessageType('GetWorkerInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerInfoReply) + }) +_sym_db.RegisterMessage(GetWorkerInfoReply) + +GetAllWorkerInfoRequest = _reflection.GeneratedProtocolMessageType('GetAllWorkerInfoRequest', (_message.Message,), { + + 'Filters' : _reflection.GeneratedProtocolMessageType('Filters', (_message.Message,), { + 'DESCRIPTOR' : _GETALLWORKERINFOREQUEST_FILTERS, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllWorkerInfoRequest.Filters) + }) + , + 'DESCRIPTOR' : _GETALLWORKERINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllWorkerInfoRequest) + }) +_sym_db.RegisterMessage(GetAllWorkerInfoRequest) +_sym_db.RegisterMessage(GetAllWorkerInfoRequest.Filters) + +GetAllWorkerInfoReply = _reflection.GeneratedProtocolMessageType('GetAllWorkerInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLWORKERINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllWorkerInfoReply) + }) +_sym_db.RegisterMessage(GetAllWorkerInfoReply) + +AddWorkerInfoRequest = _reflection.GeneratedProtocolMessageType('AddWorkerInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _ADDWORKERINFOREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddWorkerInfoRequest) + }) +_sym_db.RegisterMessage(AddWorkerInfoRequest) + +AddWorkerInfoReply = _reflection.GeneratedProtocolMessageType('AddWorkerInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _ADDWORKERINFOREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddWorkerInfoReply) + }) +_sym_db.RegisterMessage(AddWorkerInfoReply) + +UpdateWorkerDebuggerPortRequest = _reflection.GeneratedProtocolMessageType('UpdateWorkerDebuggerPortRequest', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEWORKERDEBUGGERPORTREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateWorkerDebuggerPortRequest) + }) +_sym_db.RegisterMessage(UpdateWorkerDebuggerPortRequest) + +UpdateWorkerDebuggerPortReply = _reflection.GeneratedProtocolMessageType('UpdateWorkerDebuggerPortReply', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEWORKERDEBUGGERPORTREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateWorkerDebuggerPortReply) + }) +_sym_db.RegisterMessage(UpdateWorkerDebuggerPortReply) + +UpdateWorkerNumPausedThreadsRequest = _reflection.GeneratedProtocolMessageType('UpdateWorkerNumPausedThreadsRequest', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEWORKERNUMPAUSEDTHREADSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateWorkerNumPausedThreadsRequest) + }) +_sym_db.RegisterMessage(UpdateWorkerNumPausedThreadsRequest) + +UpdateWorkerNumPausedThreadsReply = _reflection.GeneratedProtocolMessageType('UpdateWorkerNumPausedThreadsReply', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEWORKERNUMPAUSEDTHREADSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UpdateWorkerNumPausedThreadsReply) + }) +_sym_db.RegisterMessage(UpdateWorkerNumPausedThreadsReply) + +CreateActorRequest = _reflection.GeneratedProtocolMessageType('CreateActorRequest', (_message.Message,), { + 'DESCRIPTOR' : _CREATEACTORREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CreateActorRequest) + }) +_sym_db.RegisterMessage(CreateActorRequest) + +CreateActorReply = _reflection.GeneratedProtocolMessageType('CreateActorReply', (_message.Message,), { + 'DESCRIPTOR' : _CREATEACTORREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CreateActorReply) + }) +_sym_db.RegisterMessage(CreateActorReply) + +RegisterActorRequest = _reflection.GeneratedProtocolMessageType('RegisterActorRequest', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERACTORREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterActorRequest) + }) +_sym_db.RegisterMessage(RegisterActorRequest) + +RegisterActorReply = _reflection.GeneratedProtocolMessageType('RegisterActorReply', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERACTORREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterActorReply) + }) +_sym_db.RegisterMessage(RegisterActorReply) + +RestartActorForLineageReconstructionRequest = _reflection.GeneratedProtocolMessageType('RestartActorForLineageReconstructionRequest', (_message.Message,), { + 'DESCRIPTOR' : _RESTARTACTORFORLINEAGERECONSTRUCTIONREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RestartActorForLineageReconstructionRequest) + }) +_sym_db.RegisterMessage(RestartActorForLineageReconstructionRequest) + +RestartActorForLineageReconstructionReply = _reflection.GeneratedProtocolMessageType('RestartActorForLineageReconstructionReply', (_message.Message,), { + 'DESCRIPTOR' : _RESTARTACTORFORLINEAGERECONSTRUCTIONREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RestartActorForLineageReconstructionReply) + }) +_sym_db.RegisterMessage(RestartActorForLineageReconstructionReply) + +CreatePlacementGroupRequest = _reflection.GeneratedProtocolMessageType('CreatePlacementGroupRequest', (_message.Message,), { + 'DESCRIPTOR' : _CREATEPLACEMENTGROUPREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CreatePlacementGroupRequest) + }) +_sym_db.RegisterMessage(CreatePlacementGroupRequest) + +CreatePlacementGroupReply = _reflection.GeneratedProtocolMessageType('CreatePlacementGroupReply', (_message.Message,), { + 'DESCRIPTOR' : _CREATEPLACEMENTGROUPREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CreatePlacementGroupReply) + }) +_sym_db.RegisterMessage(CreatePlacementGroupReply) + +RemovePlacementGroupRequest = _reflection.GeneratedProtocolMessageType('RemovePlacementGroupRequest', (_message.Message,), { + 'DESCRIPTOR' : _REMOVEPLACEMENTGROUPREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RemovePlacementGroupRequest) + }) +_sym_db.RegisterMessage(RemovePlacementGroupRequest) + +RemovePlacementGroupReply = _reflection.GeneratedProtocolMessageType('RemovePlacementGroupReply', (_message.Message,), { + 'DESCRIPTOR' : _REMOVEPLACEMENTGROUPREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RemovePlacementGroupReply) + }) +_sym_db.RegisterMessage(RemovePlacementGroupReply) + +GetPlacementGroupRequest = _reflection.GeneratedProtocolMessageType('GetPlacementGroupRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETPLACEMENTGROUPREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetPlacementGroupRequest) + }) +_sym_db.RegisterMessage(GetPlacementGroupRequest) + +GetPlacementGroupReply = _reflection.GeneratedProtocolMessageType('GetPlacementGroupReply', (_message.Message,), { + 'DESCRIPTOR' : _GETPLACEMENTGROUPREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetPlacementGroupReply) + }) +_sym_db.RegisterMessage(GetPlacementGroupReply) + +GetAllPlacementGroupRequest = _reflection.GeneratedProtocolMessageType('GetAllPlacementGroupRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLPLACEMENTGROUPREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllPlacementGroupRequest) + }) +_sym_db.RegisterMessage(GetAllPlacementGroupRequest) + +GetAllPlacementGroupReply = _reflection.GeneratedProtocolMessageType('GetAllPlacementGroupReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLPLACEMENTGROUPREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllPlacementGroupReply) + }) +_sym_db.RegisterMessage(GetAllPlacementGroupReply) + +WaitPlacementGroupUntilReadyRequest = _reflection.GeneratedProtocolMessageType('WaitPlacementGroupUntilReadyRequest', (_message.Message,), { + 'DESCRIPTOR' : _WAITPLACEMENTGROUPUNTILREADYREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitPlacementGroupUntilReadyRequest) + }) +_sym_db.RegisterMessage(WaitPlacementGroupUntilReadyRequest) + +WaitPlacementGroupUntilReadyReply = _reflection.GeneratedProtocolMessageType('WaitPlacementGroupUntilReadyReply', (_message.Message,), { + 'DESCRIPTOR' : _WAITPLACEMENTGROUPUNTILREADYREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitPlacementGroupUntilReadyReply) + }) +_sym_db.RegisterMessage(WaitPlacementGroupUntilReadyReply) + +GetNamedPlacementGroupRequest = _reflection.GeneratedProtocolMessageType('GetNamedPlacementGroupRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETNAMEDPLACEMENTGROUPREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNamedPlacementGroupRequest) + }) +_sym_db.RegisterMessage(GetNamedPlacementGroupRequest) + +GetNamedPlacementGroupReply = _reflection.GeneratedProtocolMessageType('GetNamedPlacementGroupReply', (_message.Message,), { + 'DESCRIPTOR' : _GETNAMEDPLACEMENTGROUPREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNamedPlacementGroupReply) + }) +_sym_db.RegisterMessage(GetNamedPlacementGroupReply) + +DrainNodeData = _reflection.GeneratedProtocolMessageType('DrainNodeData', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODEDATA, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainNodeData) + }) +_sym_db.RegisterMessage(DrainNodeData) + +DrainNodeRequest = _reflection.GeneratedProtocolMessageType('DrainNodeRequest', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainNodeRequest) + }) +_sym_db.RegisterMessage(DrainNodeRequest) + +DrainNodeStatus = _reflection.GeneratedProtocolMessageType('DrainNodeStatus', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODESTATUS, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainNodeStatus) + }) +_sym_db.RegisterMessage(DrainNodeStatus) + +DrainNodeReply = _reflection.GeneratedProtocolMessageType('DrainNodeReply', (_message.Message,), { + 'DESCRIPTOR' : _DRAINNODEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainNodeReply) + }) +_sym_db.RegisterMessage(DrainNodeReply) + +InternalKVGetRequest = _reflection.GeneratedProtocolMessageType('InternalKVGetRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVGETREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVGetRequest) + }) +_sym_db.RegisterMessage(InternalKVGetRequest) + +InternalKVGetReply = _reflection.GeneratedProtocolMessageType('InternalKVGetReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVGETREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVGetReply) + }) +_sym_db.RegisterMessage(InternalKVGetReply) + +InternalKVMultiGetRequest = _reflection.GeneratedProtocolMessageType('InternalKVMultiGetRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVMULTIGETREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVMultiGetRequest) + }) +_sym_db.RegisterMessage(InternalKVMultiGetRequest) + +MapFieldEntry = _reflection.GeneratedProtocolMessageType('MapFieldEntry', (_message.Message,), { + 'DESCRIPTOR' : _MAPFIELDENTRY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.MapFieldEntry) + }) +_sym_db.RegisterMessage(MapFieldEntry) + +InternalKVMultiGetReply = _reflection.GeneratedProtocolMessageType('InternalKVMultiGetReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVMULTIGETREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVMultiGetReply) + }) +_sym_db.RegisterMessage(InternalKVMultiGetReply) + +InternalKVPutRequest = _reflection.GeneratedProtocolMessageType('InternalKVPutRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVPUTREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVPutRequest) + }) +_sym_db.RegisterMessage(InternalKVPutRequest) + +InternalKVPutReply = _reflection.GeneratedProtocolMessageType('InternalKVPutReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVPUTREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVPutReply) + }) +_sym_db.RegisterMessage(InternalKVPutReply) + +InternalKVDelRequest = _reflection.GeneratedProtocolMessageType('InternalKVDelRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVDELREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVDelRequest) + }) +_sym_db.RegisterMessage(InternalKVDelRequest) + +InternalKVDelReply = _reflection.GeneratedProtocolMessageType('InternalKVDelReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVDELREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVDelReply) + }) +_sym_db.RegisterMessage(InternalKVDelReply) + +InternalKVExistsRequest = _reflection.GeneratedProtocolMessageType('InternalKVExistsRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVEXISTSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVExistsRequest) + }) +_sym_db.RegisterMessage(InternalKVExistsRequest) + +InternalKVExistsReply = _reflection.GeneratedProtocolMessageType('InternalKVExistsReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVEXISTSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVExistsReply) + }) +_sym_db.RegisterMessage(InternalKVExistsReply) + +InternalKVKeysRequest = _reflection.GeneratedProtocolMessageType('InternalKVKeysRequest', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVKEYSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVKeysRequest) + }) +_sym_db.RegisterMessage(InternalKVKeysRequest) + +InternalKVKeysReply = _reflection.GeneratedProtocolMessageType('InternalKVKeysReply', (_message.Message,), { + 'DESCRIPTOR' : _INTERNALKVKEYSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InternalKVKeysReply) + }) +_sym_db.RegisterMessage(InternalKVKeysReply) + +PinRuntimeEnvURIRequest = _reflection.GeneratedProtocolMessageType('PinRuntimeEnvURIRequest', (_message.Message,), { + 'DESCRIPTOR' : _PINRUNTIMEENVURIREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PinRuntimeEnvURIRequest) + }) +_sym_db.RegisterMessage(PinRuntimeEnvURIRequest) + +PinRuntimeEnvURIReply = _reflection.GeneratedProtocolMessageType('PinRuntimeEnvURIReply', (_message.Message,), { + 'DESCRIPTOR' : _PINRUNTIMEENVURIREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PinRuntimeEnvURIReply) + }) +_sym_db.RegisterMessage(PinRuntimeEnvURIReply) + +GcsPublishRequest = _reflection.GeneratedProtocolMessageType('GcsPublishRequest', (_message.Message,), { + 'DESCRIPTOR' : _GCSPUBLISHREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsPublishRequest) + }) +_sym_db.RegisterMessage(GcsPublishRequest) + +GcsPublishReply = _reflection.GeneratedProtocolMessageType('GcsPublishReply', (_message.Message,), { + 'DESCRIPTOR' : _GCSPUBLISHREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsPublishReply) + }) +_sym_db.RegisterMessage(GcsPublishReply) + +GcsSubscriberPollRequest = _reflection.GeneratedProtocolMessageType('GcsSubscriberPollRequest', (_message.Message,), { + 'DESCRIPTOR' : _GCSSUBSCRIBERPOLLREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsSubscriberPollRequest) + }) +_sym_db.RegisterMessage(GcsSubscriberPollRequest) + +GcsSubscriberPollReply = _reflection.GeneratedProtocolMessageType('GcsSubscriberPollReply', (_message.Message,), { + 'DESCRIPTOR' : _GCSSUBSCRIBERPOLLREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsSubscriberPollReply) + }) +_sym_db.RegisterMessage(GcsSubscriberPollReply) + +GcsSubscriberCommandBatchRequest = _reflection.GeneratedProtocolMessageType('GcsSubscriberCommandBatchRequest', (_message.Message,), { + 'DESCRIPTOR' : _GCSSUBSCRIBERCOMMANDBATCHREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsSubscriberCommandBatchRequest) + }) +_sym_db.RegisterMessage(GcsSubscriberCommandBatchRequest) + +GcsSubscriberCommandBatchReply = _reflection.GeneratedProtocolMessageType('GcsSubscriberCommandBatchReply', (_message.Message,), { + 'DESCRIPTOR' : _GCSSUBSCRIBERCOMMANDBATCHREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsSubscriberCommandBatchReply) + }) +_sym_db.RegisterMessage(GcsSubscriberCommandBatchReply) + +GetAllResourceUsageRequest = _reflection.GeneratedProtocolMessageType('GetAllResourceUsageRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETALLRESOURCEUSAGEREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllResourceUsageRequest) + }) +_sym_db.RegisterMessage(GetAllResourceUsageRequest) + +GetAllResourceUsageReply = _reflection.GeneratedProtocolMessageType('GetAllResourceUsageReply', (_message.Message,), { + 'DESCRIPTOR' : _GETALLRESOURCEUSAGEREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetAllResourceUsageReply) + }) +_sym_db.RegisterMessage(GetAllResourceUsageReply) + +GetDrainingNodesRequest = _reflection.GeneratedProtocolMessageType('GetDrainingNodesRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETDRAININGNODESREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetDrainingNodesRequest) + }) +_sym_db.RegisterMessage(GetDrainingNodesRequest) + +DrainingNode = _reflection.GeneratedProtocolMessageType('DrainingNode', (_message.Message,), { + 'DESCRIPTOR' : _DRAININGNODE, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainingNode) + }) +_sym_db.RegisterMessage(DrainingNode) + +GetDrainingNodesReply = _reflection.GeneratedProtocolMessageType('GetDrainingNodesReply', (_message.Message,), { + 'DESCRIPTOR' : _GETDRAININGNODESREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetDrainingNodesReply) + }) +_sym_db.RegisterMessage(GetDrainingNodesReply) + +GcsStatus = _reflection.GeneratedProtocolMessageType('GcsStatus', (_message.Message,), { + 'DESCRIPTOR' : _GCSSTATUS, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GcsStatus) + }) +_sym_db.RegisterMessage(GcsStatus) + +AddTaskEventDataRequest = _reflection.GeneratedProtocolMessageType('AddTaskEventDataRequest', (_message.Message,), { + 'DESCRIPTOR' : _ADDTASKEVENTDATAREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddTaskEventDataRequest) + }) +_sym_db.RegisterMessage(AddTaskEventDataRequest) + +AddTaskEventDataReply = _reflection.GeneratedProtocolMessageType('AddTaskEventDataReply', (_message.Message,), { + 'DESCRIPTOR' : _ADDTASKEVENTDATAREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AddTaskEventDataReply) + }) +_sym_db.RegisterMessage(AddTaskEventDataReply) + +GetTaskEventsRequest = _reflection.GeneratedProtocolMessageType('GetTaskEventsRequest', (_message.Message,), { + + 'Filters' : _reflection.GeneratedProtocolMessageType('Filters', (_message.Message,), { + + 'JobIdFilter' : _reflection.GeneratedProtocolMessageType('JobIdFilter', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS_JOBIDFILTER, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters.JobIdFilter) + }) + , + + 'TaskIdFilter' : _reflection.GeneratedProtocolMessageType('TaskIdFilter', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS_TASKIDFILTER, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters.TaskIdFilter) + }) + , + + 'ActorIdFilter' : _reflection.GeneratedProtocolMessageType('ActorIdFilter', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS_ACTORIDFILTER, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters.ActorIdFilter) + }) + , + + 'TaskNameFilter' : _reflection.GeneratedProtocolMessageType('TaskNameFilter', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS_TASKNAMEFILTER, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters.TaskNameFilter) + }) + , + + 'StateFilter' : _reflection.GeneratedProtocolMessageType('StateFilter', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS_STATEFILTER, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters.StateFilter) + }) + , + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST_FILTERS, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest.Filters) + }) + , + 'DESCRIPTOR' : _GETTASKEVENTSREQUEST, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsRequest) + }) +_sym_db.RegisterMessage(GetTaskEventsRequest) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters.JobIdFilter) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters.TaskIdFilter) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters.ActorIdFilter) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters.TaskNameFilter) +_sym_db.RegisterMessage(GetTaskEventsRequest.Filters.StateFilter) + +GetTaskEventsReply = _reflection.GeneratedProtocolMessageType('GetTaskEventsReply', (_message.Message,), { + 'DESCRIPTOR' : _GETTASKEVENTSREPLY, + '__module__' : 'src.ray.protobuf.gcs_service_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTaskEventsReply) + }) +_sym_db.RegisterMessage(GetTaskEventsReply) + +_JOBINFOGCSSERVICE = DESCRIPTOR.services_by_name['JobInfoGcsService'] +_ACTORINFOGCSSERVICE = DESCRIPTOR.services_by_name['ActorInfoGcsService'] +_WORKERINFOGCSSERVICE = DESCRIPTOR.services_by_name['WorkerInfoGcsService'] +_PLACEMENTGROUPINFOGCSSERVICE = DESCRIPTOR.services_by_name['PlacementGroupInfoGcsService'] +_INTERNALKVGCSSERVICE = DESCRIPTOR.services_by_name['InternalKVGcsService'] +_RUNTIMEENVGCSSERVICE = DESCRIPTOR.services_by_name['RuntimeEnvGcsService'] +_INTERNALPUBSUBGCSSERVICE = DESCRIPTOR.services_by_name['InternalPubSubGcsService'] +_NODERESOURCEINFOGCSSERVICE = DESCRIPTOR.services_by_name['NodeResourceInfoGcsService'] +_NODEINFOGCSSERVICE = DESCRIPTOR.services_by_name['NodeInfoGcsService'] +_TASKINFOGCSSERVICE = DESCRIPTOR.services_by_name['TaskInfoGcsService'] +_RAYEVENTEXPORTGCSSERVICE = DESCRIPTOR.services_by_name['RayEventExportGcsService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _GCSSERVICEFAILURETYPE._serialized_start=12856 + _GCSSERVICEFAILURETYPE._serialized_end=12923 + _FILTERPREDICATE._serialized_start=12925 + _FILTERPREDICATE._serialized_end=12968 + _ADDJOBREQUEST._serialized_start=193 + _ADDJOBREQUEST._serialized_end=251 + _ADDJOBREPLY._serialized_start=253 + _ADDJOBREPLY._serialized_end=310 + _MARKJOBFINISHEDREQUEST._serialized_start=312 + _MARKJOBFINISHEDREQUEST._serialized_end=359 + _MARKJOBFINISHEDREPLY._serialized_start=361 + _MARKJOBFINISHEDREPLY._serialized_end=427 + _GETALLJOBINFOREQUEST._serialized_start=430 + _GETALLJOBINFOREQUEST._serialized_end=775 + _GETALLJOBINFOREPLY._serialized_start=777 + _GETALLJOBINFOREPLY._serialized_end=900 + _REPORTJOBERRORREQUEST._serialized_start=902 + _REPORTJOBERRORREQUEST._serialized_end=979 + _REPORTJOBERRORREPLY._serialized_start=981 + _REPORTJOBERRORREPLY._serialized_end=1046 + _GETNEXTJOBIDREQUEST._serialized_start=1048 + _GETNEXTJOBIDREQUEST._serialized_end=1069 + _GETNEXTJOBIDREPLY._serialized_start=1071 + _GETNEXTJOBIDREPLY._serialized_end=1157 + _GETACTORINFOREQUEST._serialized_start=1159 + _GETACTORINFOREQUEST._serialized_end=1227 + _GETACTORINFOREPLY._serialized_start=1230 + _GETACTORINFOREPLY._serialized_end=1360 + _GETNAMEDACTORINFOREQUEST._serialized_start=1362 + _GETNAMEDACTORINFOREQUEST._serialized_end=1445 + _GETNAMEDACTORINFOREPLY._serialized_start=1448 + _GETNAMEDACTORINFOREPLY._serialized_end=1631 + _LISTNAMEDACTORSREQUEST._serialized_start=1633 + _LISTNAMEDACTORSREQUEST._serialized_end=1733 + _LISTNAMEDACTORSREPLY._serialized_start=1736 + _LISTNAMEDACTORSREPLY._serialized_end=1871 + _GETALLACTORINFOREQUEST._serialized_start=1874 + _GETALLACTORINFOREQUEST._serialized_end=2226 + _GETALLACTORINFOREQUEST_FILTERS._serialized_start=2038 + _GETALLACTORINFOREQUEST_FILTERS._serialized_end=2204 + _GETALLACTORINFOREPLY._serialized_start=2229 + _GETALLACTORINFOREPLY._serialized_end=2419 + _KILLACTORVIAGCSREQUEST._serialized_start=2421 + _KILLACTORVIAGCSREQUEST._serialized_end=2534 + _KILLACTORVIAGCSREPLY._serialized_start=2536 + _KILLACTORVIAGCSREPLY._serialized_end=2602 + _REPORTACTOROUTOFSCOPEREQUEST._serialized_start=2605 + _REPORTACTOROUTOFSCOPEREQUEST._serialized_end=2753 + _REPORTACTOROUTOFSCOPEREPLY._serialized_start=2755 + _REPORTACTOROUTOFSCOPEREPLY._serialized_end=2827 + _GETCLUSTERIDREQUEST._serialized_start=2829 + _GETCLUSTERIDREQUEST._serialized_end=2850 + _GETCLUSTERIDREPLY._serialized_start=2852 + _GETCLUSTERIDREPLY._serialized_end=2946 + _REGISTERNODEREQUEST._serialized_start=2948 + _REGISTERNODEREQUEST._serialized_end=3020 + _REGISTERNODEREPLY._serialized_start=3022 + _REGISTERNODEREPLY._serialized_end=3085 + _UNREGISTERNODEREQUEST._serialized_start=3087 + _UNREGISTERNODEREQUEST._serialized_end=3199 + _UNREGISTERNODEREPLY._serialized_start=3201 + _UNREGISTERNODEREPLY._serialized_end=3266 + _GETALLNODEINFOREQUEST._serialized_start=3269 + _GETALLNODEINFOREQUEST._serialized_end=3639 + _GETALLNODEINFOREQUEST_NODESELECTOR._serialized_start=3481 + _GETALLNODEINFOREQUEST_NODESELECTOR._serialized_end=3612 + _GETALLNODEINFOREPLY._serialized_start=3642 + _GETALLNODEINFOREPLY._serialized_end=3824 + _GETALLNODEADDRESSANDLIVENESSREQUEST._serialized_start=3827 + _GETALLNODEADDRESSANDLIVENESSREQUEST._serialized_end=4020 + _GETALLNODEADDRESSANDLIVENESSREPLY._serialized_start=4023 + _GETALLNODEADDRESSANDLIVENESSREPLY._serialized_end=4176 + _CHECKALIVEREQUEST._serialized_start=4178 + _CHECKALIVEREQUEST._serialized_end=4224 + _CHECKALIVEREPLY._serialized_start=4227 + _CHECKALIVEREPLY._serialized_end=4356 + _GETINTERNALCONFIGREQUEST._serialized_start=4358 + _GETINTERNALCONFIGREQUEST._serialized_end=4384 + _GETINTERNALCONFIGREPLY._serialized_start=4386 + _GETINTERNALCONFIGREPLY._serialized_end=4478 + _DELETERESOURCESREPLY._serialized_start=4480 + _DELETERESOURCESREPLY._serialized_end=4546 + _GETALLAVAILABLERESOURCESREQUEST._serialized_start=4548 + _GETALLAVAILABLERESOURCESREQUEST._serialized_end=4581 + _GETALLAVAILABLERESOURCESREPLY._serialized_start=4584 + _GETALLAVAILABLERESOURCESREPLY._serialized_end=4727 + _GETALLTOTALRESOURCESREQUEST._serialized_start=4729 + _GETALLTOTALRESOURCESREQUEST._serialized_end=4758 + _GETALLTOTALRESOURCESREPLY._serialized_start=4761 + _GETALLTOTALRESOURCESREPLY._serialized_end=4896 + _REPORTWORKERFAILUREREQUEST._serialized_start=4898 + _REPORTWORKERFAILUREREQUEST._serialized_end=4991 + _REPORTWORKERFAILUREREPLY._serialized_start=4993 + _REPORTWORKERFAILUREREPLY._serialized_end=5063 + _GETWORKERINFOREQUEST._serialized_start=5065 + _GETWORKERINFOREQUEST._serialized_end=5116 + _GETWORKERINFOREPLY._serialized_start=5119 + _GETWORKERINFOREPLY._serialized_end=5253 + _GETALLWORKERINFOREQUEST._serialized_start=5256 + _GETALLWORKERINFOREQUEST._serialized_end=5540 + _GETALLWORKERINFOREQUEST_FILTERS._serialized_start=5384 + _GETALLWORKERINFOREQUEST_FILTERS._serialized_end=5518 + _GETALLWORKERINFOREPLY._serialized_start=5543 + _GETALLWORKERINFOREPLY._serialized_end=5737 + _ADDWORKERINFOREQUEST._serialized_start=5739 + _ADDWORKERINFOREQUEST._serialized_end=5820 + _ADDWORKERINFOREPLY._serialized_start=5822 + _ADDWORKERINFOREPLY._serialized_end=5886 + _UPDATEWORKERDEBUGGERPORTREQUEST._serialized_start=5888 + _UPDATEWORKERDEBUGGERPORTREQUEST._serialized_end=5987 + _UPDATEWORKERDEBUGGERPORTREPLY._serialized_start=5989 + _UPDATEWORKERDEBUGGERPORTREPLY._serialized_end=6064 + _UPDATEWORKERNUMPAUSEDTHREADSREQUEST._serialized_start=6066 + _UPDATEWORKERNUMPAUSEDTHREADSREQUEST._serialized_end=6189 + _UPDATEWORKERNUMPAUSEDTHREADSREPLY._serialized_start=6191 + _UPDATEWORKERNUMPAUSEDTHREADSREPLY._serialized_end=6270 + _CREATEACTORREQUEST._serialized_start=6272 + _CREATEACTORREQUEST._serialized_end=6340 + _CREATEACTORREPLY._serialized_start=6343 + _CREATEACTORREPLY._serialized_end=6608 + _REGISTERACTORREQUEST._serialized_start=6610 + _REGISTERACTORREQUEST._serialized_end=6680 + _REGISTERACTORREPLY._serialized_start=6682 + _REGISTERACTORREPLY._serialized_end=6746 + _RESTARTACTORFORLINEAGERECONSTRUCTIONREQUEST._serialized_start=6749 + _RESTARTACTORFORLINEAGERECONSTRUCTIONREQUEST._serialized_end=6912 + _RESTARTACTORFORLINEAGERECONSTRUCTIONREPLY._serialized_start=6914 + _RESTARTACTORFORLINEAGERECONSTRUCTIONREPLY._serialized_end=7001 + _CREATEPLACEMENTGROUPREQUEST._serialized_start=7003 + _CREATEPLACEMENTGROUPREQUEST._serialized_end=7111 + _CREATEPLACEMENTGROUPREPLY._serialized_start=7113 + _CREATEPLACEMENTGROUPREPLY._serialized_end=7184 + _REMOVEPLACEMENTGROUPREQUEST._serialized_start=7186 + _REMOVEPLACEMENTGROUPREQUEST._serialized_end=7261 + _REMOVEPLACEMENTGROUPREPLY._serialized_start=7263 + _REMOVEPLACEMENTGROUPREPLY._serialized_end=7334 + _GETPLACEMENTGROUPREQUEST._serialized_start=7336 + _GETPLACEMENTGROUPREQUEST._serialized_end=7408 + _GETPLACEMENTGROUPREPLY._serialized_start=7411 + _GETPLACEMENTGROUPREPLY._serialized_end=7574 + _GETALLPLACEMENTGROUPREQUEST._serialized_start=7576 + _GETALLPLACEMENTGROUPREQUEST._serialized_end=7642 + _GETALLPLACEMENTGROUPREPLY._serialized_start=7645 + _GETALLPLACEMENTGROUPREPLY._serialized_end=7833 + _WAITPLACEMENTGROUPUNTILREADYREQUEST._serialized_start=7835 + _WAITPLACEMENTGROUPUNTILREADYREQUEST._serialized_end=7918 + _WAITPLACEMENTGROUPUNTILREADYREPLY._serialized_start=7920 + _WAITPLACEMENTGROUPUNTILREADYREPLY._serialized_end=7999 + _GETNAMEDPLACEMENTGROUPREQUEST._serialized_start=8001 + _GETNAMEDPLACEMENTGROUPREQUEST._serialized_end=8089 + _GETNAMEDPLACEMENTGROUPREPLY._serialized_start=8092 + _GETNAMEDPLACEMENTGROUPREPLY._serialized_end=8260 + _DRAINNODEDATA._serialized_start=8262 + _DRAINNODEDATA._serialized_end=8302 + _DRAINNODEREQUEST._serialized_start=8304 + _DRAINNODEREQUEST._serialized_end=8386 + _DRAINNODESTATUS._serialized_start=8388 + _DRAINNODESTATUS._serialized_end=8430 + _DRAINNODEREPLY._serialized_start=8433 + _DRAINNODEREPLY._serialized_end=8563 + _INTERNALKVGETREQUEST._serialized_start=8565 + _INTERNALKVGETREQUEST._serialized_end=8635 + _INTERNALKVGETREPLY._serialized_start=8637 + _INTERNALKVGETREPLY._serialized_end=8723 + _INTERNALKVMULTIGETREQUEST._serialized_start=8725 + _INTERNALKVMULTIGETREQUEST._serialized_end=8802 + _MAPFIELDENTRY._serialized_start=8804 + _MAPFIELDENTRY._serialized_end=8859 + _INTERNALKVMULTIGETREPLY._serialized_start=8861 + _INTERNALKVMULTIGETREPLY._serialized_end=8980 + _INTERNALKVPUTREQUEST._serialized_start=8982 + _INTERNALKVPUTREQUEST._serialized_end=9104 + _INTERNALKVPUTREPLY._serialized_start=9106 + _INTERNALKVPUTREPLY._serialized_end=9192 + _INTERNALKVDELREQUEST._serialized_start=9194 + _INTERNALKVDELREQUEST._serialized_end=9300 + _INTERNALKVDELREPLY._serialized_start=9302 + _INTERNALKVDELREPLY._serialized_end=9399 + _INTERNALKVEXISTSREQUEST._serialized_start=9401 + _INTERNALKVEXISTSREQUEST._serialized_end=9474 + _INTERNALKVEXISTSREPLY._serialized_start=9476 + _INTERNALKVEXISTSREPLY._serialized_end=9567 + _INTERNALKVKEYSREQUEST._serialized_start=9569 + _INTERNALKVKEYSREQUEST._serialized_end=9646 + _INTERNALKVKEYSREPLY._serialized_start=9648 + _INTERNALKVKEYSREPLY._serialized_end=9739 + _PINRUNTIMEENVURIREQUEST._serialized_start=9741 + _PINRUNTIMEENVURIREQUEST._serialized_end=9819 + _PINRUNTIMEENVURIREPLY._serialized_start=9821 + _PINRUNTIMEENVURIREPLY._serialized_end=9888 + _GCSPUBLISHREQUEST._serialized_start=9890 + _GCSPUBLISHREQUEST._serialized_end=9965 + _GCSPUBLISHREPLY._serialized_start=9967 + _GCSPUBLISHREPLY._serialized_end=10028 + _GCSSUBSCRIBERPOLLREQUEST._serialized_start=10031 + _GCSSUBSCRIBERPOLLREQUEST._serialized_end=10188 + _GCSSUBSCRIBERPOLLREPLY._serialized_start=10191 + _GCSSUBSCRIBERPOLLREPLY._serialized_end=10350 + _GCSSUBSCRIBERCOMMANDBATCHREQUEST._serialized_start=10353 + _GCSSUBSCRIBERCOMMANDBATCHREQUEST._serialized_end=10499 + _GCSSUBSCRIBERCOMMANDBATCHREPLY._serialized_start=10501 + _GCSSUBSCRIBERCOMMANDBATCHREPLY._serialized_end=10577 + _GETALLRESOURCEUSAGEREQUEST._serialized_start=10579 + _GETALLRESOURCEUSAGEREQUEST._serialized_end=10607 + _GETALLRESOURCEUSAGEREPLY._serialized_start=10610 + _GETALLRESOURCEUSAGEREPLY._serialized_end=10843 + _GETDRAININGNODESREQUEST._serialized_start=10845 + _GETDRAININGNODESREQUEST._serialized_end=10870 + _DRAININGNODE._serialized_start=10872 + _DRAININGNODE._serialized_end=10980 + _GETDRAININGNODESREPLY._serialized_start=10983 + _GETDRAININGNODESREPLY._serialized_end=11112 + _GCSSTATUS._serialized_start=11114 + _GCSSTATUS._serialized_end=11171 + _ADDTASKEVENTDATAREQUEST._serialized_start=11173 + _ADDTASKEVENTDATAREQUEST._serialized_end=11242 + _ADDTASKEVENTDATAREPLY._serialized_start=11244 + _ADDTASKEVENTDATAREPLY._serialized_end=11311 + _GETTASKEVENTSREQUEST._serialized_start=11314 + _GETTASKEVENTSREQUEST._serialized_end=12464 + _GETTASKEVENTSREQUEST_FILTERS._serialized_start=11436 + _GETTASKEVENTSREQUEST_FILTERS._serialized_end=12442 + _GETTASKEVENTSREQUEST_FILTERS_JOBIDFILTER._serialized_start=11938 + _GETTASKEVENTSREQUEST_FILTERS_JOBIDFILTER._serialized_end=12030 + _GETTASKEVENTSREQUEST_FILTERS_TASKIDFILTER._serialized_start=12032 + _GETTASKEVENTSREQUEST_FILTERS_TASKIDFILTER._serialized_end=12127 + _GETTASKEVENTSREQUEST_FILTERS_ACTORIDFILTER._serialized_start=12129 + _GETTASKEVENTSREQUEST_FILTERS_ACTORIDFILTER._serialized_end=12227 + _GETTASKEVENTSREQUEST_FILTERS_TASKNAMEFILTER._serialized_start=12229 + _GETTASKEVENTSREQUEST_FILTERS_TASKNAMEFILTER._serialized_end=12330 + _GETTASKEVENTSREQUEST_FILTERS_STATEFILTER._serialized_start=12332 + _GETTASKEVENTSREQUEST_FILTERS_STATEFILTER._serialized_end=12423 + _GETTASKEVENTSREPLY._serialized_start=12467 + _GETTASKEVENTSREPLY._serialized_end=12854 + _JOBINFOGCSSERVICE._serialized_start=12971 + _JOBINFOGCSSERVICE._serialized_end=13360 + _ACTORINFOGCSSERVICE._serialized_start=13363 + _ACTORINFOGCSSERVICE._serialized_end=14192 + _WORKERINFOGCSSERVICE._serialized_start=14195 + _WORKERINFOGCSSERVICE._serialized_end=14784 + _PLACEMENTGROUPINFOGCSSERVICE._serialized_start=14787 + _PLACEMENTGROUPINFOGCSSERVICE._serialized_end=15426 + _INTERNALKVGCSSERVICE._serialized_start=15429 + _INTERNALKVGCSSERVICE._serialized_end=16029 + _RUNTIMEENVGCSSERVICE._serialized_start=16031 + _RUNTIMEENVGCSSERVICE._serialized_end=16139 + _INTERNALPUBSUBGCSSERVICE._serialized_start=16142 + _INTERNALPUBSUBGCSSERVICE._serialized_end=16438 + _NODERESOURCEINFOGCSSERVICE._serialized_start=16441 + _NODERESOURCEINFOGCSSERVICE._serialized_end=16858 + _NODEINFOGCSSERVICE._serialized_start=16861 + _NODEINFOGCSSERVICE._serialized_end=17444 + _TASKINFOGCSSERVICE._serialized_start=17447 + _TASKINFOGCSSERVICE._serialized_end=17630 + _RAYEVENTEXPORTGCSSERVICE._serialized_start=17632 + _RAYEVENTEXPORTGCSSERVICE._serialized_end=17737 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..0458bc3fbf287218d4892021da831211ab047fbe --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/gcs_service_pb2_grpc.py @@ -0,0 +1,1997 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import events_event_aggregator_service_pb2 as src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2 +from . import gcs_service_pb2 as src_dot_ray_dot_protobuf_dot_gcs__service__pb2 + + +class JobInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.AddJob = channel.unary_unary( + '/ray.rpc.JobInfoGcsService/AddJob', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobReply.FromString, + ) + self.MarkJobFinished = channel.unary_unary( + '/ray.rpc.JobInfoGcsService/MarkJobFinished', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedReply.FromString, + ) + self.GetAllJobInfo = channel.unary_unary( + '/ray.rpc.JobInfoGcsService/GetAllJobInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoReply.FromString, + ) + self.ReportJobError = channel.unary_unary( + '/ray.rpc.JobInfoGcsService/ReportJobError', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorReply.FromString, + ) + self.GetNextJobID = channel.unary_unary( + '/ray.rpc.JobInfoGcsService/GetNextJobID', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDReply.FromString, + ) + + +class JobInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def AddJob(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def MarkJobFinished(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllJobInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportJobError(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetNextJobID(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_JobInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'AddJob': grpc.unary_unary_rpc_method_handler( + servicer.AddJob, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobReply.SerializeToString, + ), + 'MarkJobFinished': grpc.unary_unary_rpc_method_handler( + servicer.MarkJobFinished, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedReply.SerializeToString, + ), + 'GetAllJobInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetAllJobInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoReply.SerializeToString, + ), + 'ReportJobError': grpc.unary_unary_rpc_method_handler( + servicer.ReportJobError, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorReply.SerializeToString, + ), + 'GetNextJobID': grpc.unary_unary_rpc_method_handler( + servicer.GetNextJobID, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.JobInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class JobInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def AddJob(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.JobInfoGcsService/AddJob', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddJobReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def MarkJobFinished(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.JobInfoGcsService/MarkJobFinished', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.MarkJobFinishedReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllJobInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.JobInfoGcsService/GetAllJobInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllJobInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportJobError(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.JobInfoGcsService/ReportJobError', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportJobErrorReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetNextJobID(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.JobInfoGcsService/GetNextJobID', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNextJobIDReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class ActorInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.RegisterActor = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/RegisterActor', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorReply.FromString, + ) + self.RestartActorForLineageReconstruction = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/RestartActorForLineageReconstruction', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionReply.FromString, + ) + self.CreateActor = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/CreateActor', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorReply.FromString, + ) + self.GetActorInfo = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/GetActorInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoReply.FromString, + ) + self.GetNamedActorInfo = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/GetNamedActorInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoReply.FromString, + ) + self.ListNamedActors = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/ListNamedActors', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsReply.FromString, + ) + self.GetAllActorInfo = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/GetAllActorInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoReply.FromString, + ) + self.KillActorViaGcs = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/KillActorViaGcs', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsReply.FromString, + ) + self.ReportActorOutOfScope = channel.unary_unary( + '/ray.rpc.ActorInfoGcsService/ReportActorOutOfScope', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeReply.FromString, + ) + + +class ActorInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def RegisterActor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RestartActorForLineageReconstruction(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateActor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetActorInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetNamedActorInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListNamedActors(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllActorInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KillActorViaGcs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportActorOutOfScope(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ActorInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'RegisterActor': grpc.unary_unary_rpc_method_handler( + servicer.RegisterActor, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorReply.SerializeToString, + ), + 'RestartActorForLineageReconstruction': grpc.unary_unary_rpc_method_handler( + servicer.RestartActorForLineageReconstruction, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionReply.SerializeToString, + ), + 'CreateActor': grpc.unary_unary_rpc_method_handler( + servicer.CreateActor, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorReply.SerializeToString, + ), + 'GetActorInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetActorInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoReply.SerializeToString, + ), + 'GetNamedActorInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetNamedActorInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoReply.SerializeToString, + ), + 'ListNamedActors': grpc.unary_unary_rpc_method_handler( + servicer.ListNamedActors, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsReply.SerializeToString, + ), + 'GetAllActorInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetAllActorInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoReply.SerializeToString, + ), + 'KillActorViaGcs': grpc.unary_unary_rpc_method_handler( + servicer.KillActorViaGcs, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsReply.SerializeToString, + ), + 'ReportActorOutOfScope': grpc.unary_unary_rpc_method_handler( + servicer.ReportActorOutOfScope, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.ActorInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ActorInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def RegisterActor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/RegisterActor', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterActorReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RestartActorForLineageReconstruction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/RestartActorForLineageReconstruction', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RestartActorForLineageReconstructionReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateActor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/CreateActor', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreateActorReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetActorInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/GetActorInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetActorInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetNamedActorInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/GetNamedActorInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedActorInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListNamedActors(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/ListNamedActors', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ListNamedActorsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllActorInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/GetAllActorInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllActorInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KillActorViaGcs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/KillActorViaGcs', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.KillActorViaGcsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportActorOutOfScope(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ActorInfoGcsService/ReportActorOutOfScope', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportActorOutOfScopeReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class WorkerInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ReportWorkerFailure = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/ReportWorkerFailure', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureReply.FromString, + ) + self.GetWorkerInfo = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/GetWorkerInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoReply.FromString, + ) + self.GetAllWorkerInfo = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/GetAllWorkerInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoReply.FromString, + ) + self.AddWorkerInfo = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/AddWorkerInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoReply.FromString, + ) + self.UpdateWorkerDebuggerPort = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/UpdateWorkerDebuggerPort', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortReply.FromString, + ) + self.UpdateWorkerNumPausedThreads = channel.unary_unary( + '/ray.rpc.WorkerInfoGcsService/UpdateWorkerNumPausedThreads', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsReply.FromString, + ) + + +class WorkerInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def ReportWorkerFailure(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetWorkerInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllWorkerInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AddWorkerInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateWorkerDebuggerPort(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateWorkerNumPausedThreads(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_WorkerInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ReportWorkerFailure': grpc.unary_unary_rpc_method_handler( + servicer.ReportWorkerFailure, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureReply.SerializeToString, + ), + 'GetWorkerInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetWorkerInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoReply.SerializeToString, + ), + 'GetAllWorkerInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetAllWorkerInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoReply.SerializeToString, + ), + 'AddWorkerInfo': grpc.unary_unary_rpc_method_handler( + servicer.AddWorkerInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoReply.SerializeToString, + ), + 'UpdateWorkerDebuggerPort': grpc.unary_unary_rpc_method_handler( + servicer.UpdateWorkerDebuggerPort, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortReply.SerializeToString, + ), + 'UpdateWorkerNumPausedThreads': grpc.unary_unary_rpc_method_handler( + servicer.UpdateWorkerNumPausedThreads, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.WorkerInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class WorkerInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def ReportWorkerFailure(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/ReportWorkerFailure', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.ReportWorkerFailureReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetWorkerInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/GetWorkerInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetWorkerInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllWorkerInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/GetAllWorkerInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllWorkerInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AddWorkerInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/AddWorkerInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddWorkerInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateWorkerDebuggerPort(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/UpdateWorkerDebuggerPort', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerDebuggerPortReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateWorkerNumPausedThreads(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.WorkerInfoGcsService/UpdateWorkerNumPausedThreads', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UpdateWorkerNumPausedThreadsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class PlacementGroupInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreatePlacementGroup = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/CreatePlacementGroup', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupReply.FromString, + ) + self.RemovePlacementGroup = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/RemovePlacementGroup', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupReply.FromString, + ) + self.GetPlacementGroup = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/GetPlacementGroup', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupReply.FromString, + ) + self.GetNamedPlacementGroup = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/GetNamedPlacementGroup', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupReply.FromString, + ) + self.GetAllPlacementGroup = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/GetAllPlacementGroup', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupReply.FromString, + ) + self.WaitPlacementGroupUntilReady = channel.unary_unary( + '/ray.rpc.PlacementGroupInfoGcsService/WaitPlacementGroupUntilReady', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyReply.FromString, + ) + + +class PlacementGroupInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def CreatePlacementGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RemovePlacementGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPlacementGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetNamedPlacementGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllPlacementGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WaitPlacementGroupUntilReady(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_PlacementGroupInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreatePlacementGroup': grpc.unary_unary_rpc_method_handler( + servicer.CreatePlacementGroup, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupReply.SerializeToString, + ), + 'RemovePlacementGroup': grpc.unary_unary_rpc_method_handler( + servicer.RemovePlacementGroup, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupReply.SerializeToString, + ), + 'GetPlacementGroup': grpc.unary_unary_rpc_method_handler( + servicer.GetPlacementGroup, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupReply.SerializeToString, + ), + 'GetNamedPlacementGroup': grpc.unary_unary_rpc_method_handler( + servicer.GetNamedPlacementGroup, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupReply.SerializeToString, + ), + 'GetAllPlacementGroup': grpc.unary_unary_rpc_method_handler( + servicer.GetAllPlacementGroup, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupReply.SerializeToString, + ), + 'WaitPlacementGroupUntilReady': grpc.unary_unary_rpc_method_handler( + servicer.WaitPlacementGroupUntilReady, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.PlacementGroupInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class PlacementGroupInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def CreatePlacementGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/CreatePlacementGroup', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CreatePlacementGroupReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RemovePlacementGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/RemovePlacementGroup', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RemovePlacementGroupReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPlacementGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/GetPlacementGroup', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetPlacementGroupReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetNamedPlacementGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/GetNamedPlacementGroup', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetNamedPlacementGroupReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllPlacementGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/GetAllPlacementGroup', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllPlacementGroupReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WaitPlacementGroupUntilReady(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.PlacementGroupInfoGcsService/WaitPlacementGroupUntilReady', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.WaitPlacementGroupUntilReadyReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class InternalKVGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.InternalKVGet = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVGet', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetReply.FromString, + ) + self.InternalKVMultiGet = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVMultiGet', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetReply.FromString, + ) + self.InternalKVPut = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVPut', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutReply.FromString, + ) + self.InternalKVDel = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVDel', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelReply.FromString, + ) + self.InternalKVExists = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVExists', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsReply.FromString, + ) + self.InternalKVKeys = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/InternalKVKeys', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysReply.FromString, + ) + self.GetInternalConfig = channel.unary_unary( + '/ray.rpc.InternalKVGcsService/GetInternalConfig', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigReply.FromString, + ) + + +class InternalKVGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def InternalKVGet(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InternalKVMultiGet(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InternalKVPut(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InternalKVDel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InternalKVExists(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InternalKVKeys(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetInternalConfig(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_InternalKVGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'InternalKVGet': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVGet, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetReply.SerializeToString, + ), + 'InternalKVMultiGet': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVMultiGet, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetReply.SerializeToString, + ), + 'InternalKVPut': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVPut, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutReply.SerializeToString, + ), + 'InternalKVDel': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVDel, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelReply.SerializeToString, + ), + 'InternalKVExists': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVExists, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsReply.SerializeToString, + ), + 'InternalKVKeys': grpc.unary_unary_rpc_method_handler( + servicer.InternalKVKeys, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysReply.SerializeToString, + ), + 'GetInternalConfig': grpc.unary_unary_rpc_method_handler( + servicer.GetInternalConfig, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.InternalKVGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class InternalKVGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def InternalKVGet(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVGet', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVGetReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InternalKVMultiGet(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVMultiGet', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVMultiGetReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InternalKVPut(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVPut', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVPutReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InternalKVDel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVDel', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVDelReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InternalKVExists(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVExists', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVExistsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InternalKVKeys(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/InternalKVKeys', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.InternalKVKeysReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetInternalConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalKVGcsService/GetInternalConfig', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetInternalConfigReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class RuntimeEnvGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.PinRuntimeEnvURI = channel.unary_unary( + '/ray.rpc.RuntimeEnvGcsService/PinRuntimeEnvURI', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIReply.FromString, + ) + + +class RuntimeEnvGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def PinRuntimeEnvURI(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RuntimeEnvGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'PinRuntimeEnvURI': grpc.unary_unary_rpc_method_handler( + servicer.PinRuntimeEnvURI, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.RuntimeEnvGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RuntimeEnvGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def PinRuntimeEnvURI(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RuntimeEnvGcsService/PinRuntimeEnvURI', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.PinRuntimeEnvURIReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class InternalPubSubGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GcsPublish = channel.unary_unary( + '/ray.rpc.InternalPubSubGcsService/GcsPublish', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishReply.FromString, + ) + self.GcsSubscriberPoll = channel.unary_unary( + '/ray.rpc.InternalPubSubGcsService/GcsSubscriberPoll', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollReply.FromString, + ) + self.GcsSubscriberCommandBatch = channel.unary_unary( + '/ray.rpc.InternalPubSubGcsService/GcsSubscriberCommandBatch', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchReply.FromString, + ) + + +class InternalPubSubGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GcsPublish(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GcsSubscriberPoll(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GcsSubscriberCommandBatch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_InternalPubSubGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GcsPublish': grpc.unary_unary_rpc_method_handler( + servicer.GcsPublish, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishReply.SerializeToString, + ), + 'GcsSubscriberPoll': grpc.unary_unary_rpc_method_handler( + servicer.GcsSubscriberPoll, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollReply.SerializeToString, + ), + 'GcsSubscriberCommandBatch': grpc.unary_unary_rpc_method_handler( + servicer.GcsSubscriberCommandBatch, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.InternalPubSubGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class InternalPubSubGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GcsPublish(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalPubSubGcsService/GcsPublish', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsPublishReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GcsSubscriberPoll(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalPubSubGcsService/GcsSubscriberPoll', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberPollReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GcsSubscriberCommandBatch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.InternalPubSubGcsService/GcsSubscriberCommandBatch', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GcsSubscriberCommandBatchReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class NodeResourceInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetAllAvailableResources = channel.unary_unary( + '/ray.rpc.NodeResourceInfoGcsService/GetAllAvailableResources', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesReply.FromString, + ) + self.GetAllTotalResources = channel.unary_unary( + '/ray.rpc.NodeResourceInfoGcsService/GetAllTotalResources', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesReply.FromString, + ) + self.GetAllResourceUsage = channel.unary_unary( + '/ray.rpc.NodeResourceInfoGcsService/GetAllResourceUsage', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageReply.FromString, + ) + self.GetDrainingNodes = channel.unary_unary( + '/ray.rpc.NodeResourceInfoGcsService/GetDrainingNodes', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesReply.FromString, + ) + + +class NodeResourceInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetAllAvailableResources(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllTotalResources(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllResourceUsage(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDrainingNodes(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_NodeResourceInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetAllAvailableResources': grpc.unary_unary_rpc_method_handler( + servicer.GetAllAvailableResources, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesReply.SerializeToString, + ), + 'GetAllTotalResources': grpc.unary_unary_rpc_method_handler( + servicer.GetAllTotalResources, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesReply.SerializeToString, + ), + 'GetAllResourceUsage': grpc.unary_unary_rpc_method_handler( + servicer.GetAllResourceUsage, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageReply.SerializeToString, + ), + 'GetDrainingNodes': grpc.unary_unary_rpc_method_handler( + servicer.GetDrainingNodes, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.NodeResourceInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class NodeResourceInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetAllAvailableResources(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeResourceInfoGcsService/GetAllAvailableResources', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllAvailableResourcesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllTotalResources(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeResourceInfoGcsService/GetAllTotalResources', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllTotalResourcesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllResourceUsage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeResourceInfoGcsService/GetAllResourceUsage', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllResourceUsageReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetDrainingNodes(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeResourceInfoGcsService/GetDrainingNodes', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetDrainingNodesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class NodeInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetClusterId = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/GetClusterId', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdReply.FromString, + ) + self.RegisterNode = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/RegisterNode', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeReply.FromString, + ) + self.UnregisterNode = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/UnregisterNode', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeReply.FromString, + ) + self.DrainNode = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/DrainNode', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeReply.FromString, + ) + self.GetAllNodeInfo = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/GetAllNodeInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoReply.FromString, + ) + self.GetAllNodeAddressAndLiveness = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/GetAllNodeAddressAndLiveness', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessReply.FromString, + ) + self.CheckAlive = channel.unary_unary( + '/ray.rpc.NodeInfoGcsService/CheckAlive', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveReply.FromString, + ) + + +class NodeInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetClusterId(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UnregisterNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DrainNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllNodeInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetAllNodeAddressAndLiveness(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckAlive(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_NodeInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetClusterId': grpc.unary_unary_rpc_method_handler( + servicer.GetClusterId, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdReply.SerializeToString, + ), + 'RegisterNode': grpc.unary_unary_rpc_method_handler( + servicer.RegisterNode, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeReply.SerializeToString, + ), + 'UnregisterNode': grpc.unary_unary_rpc_method_handler( + servicer.UnregisterNode, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeReply.SerializeToString, + ), + 'DrainNode': grpc.unary_unary_rpc_method_handler( + servicer.DrainNode, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeReply.SerializeToString, + ), + 'GetAllNodeInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetAllNodeInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoReply.SerializeToString, + ), + 'GetAllNodeAddressAndLiveness': grpc.unary_unary_rpc_method_handler( + servicer.GetAllNodeAddressAndLiveness, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessReply.SerializeToString, + ), + 'CheckAlive': grpc.unary_unary_rpc_method_handler( + servicer.CheckAlive, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.NodeInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class NodeInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetClusterId(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/GetClusterId', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetClusterIdReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RegisterNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/RegisterNode', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.RegisterNodeReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UnregisterNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/UnregisterNode', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.UnregisterNodeReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DrainNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/DrainNode', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.DrainNodeReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllNodeInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/GetAllNodeInfo', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetAllNodeAddressAndLiveness(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/GetAllNodeAddressAndLiveness', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetAllNodeAddressAndLivenessReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckAlive(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeInfoGcsService/CheckAlive', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.CheckAliveReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class TaskInfoGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.AddTaskEventData = channel.unary_unary( + '/ray.rpc.TaskInfoGcsService/AddTaskEventData', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataReply.FromString, + ) + self.GetTaskEvents = channel.unary_unary( + '/ray.rpc.TaskInfoGcsService/GetTaskEvents', + request_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsReply.FromString, + ) + + +class TaskInfoGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def AddTaskEventData(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTaskEvents(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_TaskInfoGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'AddTaskEventData': grpc.unary_unary_rpc_method_handler( + servicer.AddTaskEventData, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataReply.SerializeToString, + ), + 'GetTaskEvents': grpc.unary_unary_rpc_method_handler( + servicer.GetTaskEvents, + request_deserializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.TaskInfoGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class TaskInfoGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def AddTaskEventData(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.TaskInfoGcsService/AddTaskEventData', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.AddTaskEventDataReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTaskEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.TaskInfoGcsService/GetTaskEvents', + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_gcs__service__pb2.GetTaskEventsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class RayEventExportGcsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.AddEvents = channel.unary_unary( + '/ray.rpc.RayEventExportGcsService/AddEvents', + request_serializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.FromString, + ) + + +class RayEventExportGcsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def AddEvents(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RayEventExportGcsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'AddEvents': grpc.unary_unary_rpc_method_handler( + servicer.AddEvents, + request_deserializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.RayEventExportGcsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RayEventExportGcsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def AddEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayEventExportGcsService/AddEvents', + src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_events__event__aggregator__service__pb2.AddEventsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2.py b/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..52c0e21bc1af8020e80dd334303cbbc89910ca6b --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2.py @@ -0,0 +1,174 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/instance_manager.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'src/ray/protobuf/instance_manager.proto\x12\x15ray.rpc.autoscaler.im\"Y\n\x06Status\x12\x35\n\x04\x63ode\x18\x01 \x01(\x0e\x32!.ray.rpc.autoscaler.im.StatusCodeR\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xd1\t\n\x08Instance\x12\x1f\n\x0binstance_id\x18\x01 \x01(\tR\ninstanceId\x12/\n\x11\x63loud_instance_id\x18\x02 \x01(\tH\x00R\x0f\x63loudInstanceId\x88\x01\x01\x12\x1c\n\x07node_id\x18\x03 \x01(\tH\x01R\x06nodeId\x88\x01\x01\x12\x46\n\x06status\x18\x04 \x01(\x0e\x32..ray.rpc.autoscaler.im.Instance.InstanceStatusR\x06status\x12#\n\rinstance_type\x18\x05 \x01(\tR\x0cinstanceType\x12\\\n\x0ftotal_resources\x18\x06 \x03(\x0b\x32\x33.ray.rpc.autoscaler.im.Instance.TotalResourcesEntryR\x0etotalResources\x12\x1f\n\x0binternal_ip\x18\x07 \x01(\tR\ninternalIp\x12\x1f\n\x0b\x65xternal_ip\x18\x08 \x01(\tR\nexternalIp\x12\x18\n\x07version\x18\t \x01(\x03R\x07version\x12T\n\x0estatus_history\x18\n \x03(\x0b\x32-.ray.rpc.autoscaler.im.Instance.StatusHistoryR\rstatusHistory\x12*\n\x11launch_request_id\x18\x0b \x01(\tR\x0flaunchRequestId\x12!\n\x0c\x65xit_details\x18\x0c \x01(\tR\x0b\x65xitDetails\x12,\n\x12launch_config_hash\x18\r \x01(\tR\x10launchConfigHash\x12<\n\tnode_kind\x18\x0e \x01(\x0e\x32\x1f.ray.rpc.autoscaler.im.NodeKindR\x08nodeKind\x1a\x41\n\x13TotalResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\xa5\x01\n\rStatusHistory\x12W\n\x0finstance_status\x18\x01 \x01(\x0e\x32..ray.rpc.autoscaler.im.Instance.InstanceStatusR\x0einstanceStatus\x12!\n\x0ctimestamp_ns\x18\x02 \x01(\x03R\x0btimestampNs\x12\x18\n\x07\x64\x65tails\x18\x03 \x01(\tR\x07\x64\x65tails\"\x8f\x02\n\x0eInstanceStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\n\n\x06QUEUED\x10\x01\x12\r\n\tREQUESTED\x10\x02\x12\r\n\tALLOCATED\x10\x03\x12\x12\n\x0eRAY_INSTALLING\x10\x04\x12\x0f\n\x0bRAY_RUNNING\x10\x05\x12\x16\n\x12RAY_STOP_REQUESTED\x10\x06\x12\x10\n\x0cRAY_STOPPING\x10\x07\x12\x0f\n\x0bRAY_STOPPED\x10\x08\x12\x0f\n\x0bTERMINATING\x10\t\x12\x0e\n\nTERMINATED\x10\n\x12\x15\n\x11\x41LLOCATION_FAILED\x10\x0b\x12\x16\n\x12RAY_INSTALL_FAILED\x10\x0c\x12\x16\n\x12TERMINATION_FAILED\x10\rB\x14\n\x12_cloud_instance_idB\n\n\x08_node_id\"\x91\x05\n\x13InstanceUpdateEvent\x12\x1f\n\x0binstance_id\x18\x01 \x01(\tR\ninstanceId\x12^\n\x13new_instance_status\x18\x02 \x01(\x0e\x32..ray.rpc.autoscaler.im.Instance.InstanceStatusR\x11newInstanceStatus\x12\x18\n\x07\x64\x65tails\x18\x03 \x01(\tR\x07\x64\x65tails\x12\x16\n\x06upsert\x18\x04 \x01(\x08R\x06upsert\x12(\n\rinstance_type\x18\x05 \x01(\tH\x00R\x0cinstanceType\x88\x01\x01\x12/\n\x11\x63loud_instance_id\x18\x06 \x01(\tH\x01R\x0f\x63loudInstanceId\x88\x01\x01\x12\x41\n\tnode_kind\x18\x07 \x01(\x0e\x32\x1f.ray.rpc.autoscaler.im.NodeKindH\x02R\x08nodeKind\x88\x01\x01\x12#\n\x0bray_node_id\x18\x08 \x01(\tH\x03R\trayNodeId\x88\x01\x01\x12/\n\x11launch_request_id\x18\t \x01(\tH\x04R\x0flaunchRequestId\x88\x01\x01\x12_\n\x13termination_request\x18\n \x01(\x0b\x32).ray.rpc.autoscaler.im.TerminationRequestH\x05R\x12terminationRequest\x88\x01\x01\x42\x10\n\x0e_instance_typeB\x14\n\x12_cloud_instance_idB\x0c\n\n_node_kindB\x0e\n\x0c_ray_node_idB\x14\n\x12_launch_request_idB\x16\n\x14_termination_request\"~\n\rLaunchRequest\x12#\n\rinstance_type\x18\x01 \x01(\tR\x0cinstanceType\x12\x14\n\x05\x63ount\x18\x02 \x01(\x05R\x05\x63ount\x12\x0e\n\x02id\x18\x03 \x01(\tR\x02id\x12\"\n\rrequest_ts_ms\x18\x04 \x01(\x03R\x0brequestTsMs\"\xf3\x04\n\x12TerminationRequest\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x1e\n\x0bray_node_id\x18\x02 \x01(\tR\trayNodeId\x12\x1f\n\x0binstance_id\x18\x03 \x01(\tR\ninstanceId\x12\x45\n\x05\x63\x61use\x18\x04 \x01(\x0e\x32/.ray.rpc.autoscaler.im.TerminationRequest.CauseR\x05\x63\x61use\x12#\n\rinstance_type\x18\x05 \x01(\tR\x0cinstanceType\x12-\n\x10idle_duration_ms\x18\x06 \x01(\x04H\x00R\x0eidleDurationMs\x88\x01\x01\x12\x37\n\x16max_num_nodes_per_type\x18\x07 \x01(\rH\x01R\x12maxNumNodesPerType\x88\x01\x01\x12\'\n\rmax_num_nodes\x18\x08 \x01(\rH\x02R\x0bmaxNumNodes\x88\x01\x01\x12\x18\n\x07\x64\x65tails\x18\t \x01(\tR\x07\x64\x65tails\x12W\n\x0finstance_status\x18\n \x01(\x0e\x32..ray.rpc.autoscaler.im.Instance.InstanceStatusR\x0einstanceStatus\"Z\n\x05\x43\x61use\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04IDLE\x10\x01\x12\x19\n\x15MAX_NUM_NODE_PER_TYPE\x10\x02\x12\x11\n\rMAX_NUM_NODES\x10\x03\x12\x0c\n\x08OUTDATED\x10\x04\x42\x13\n\x11_idle_duration_msB\x19\n\x17_max_num_nodes_per_typeB\x10\n\x0e_max_num_nodes\"\x94\x01\n!UpdateInstanceManagerStateRequest\x12)\n\x10\x65xpected_version\x18\x01 \x01(\x03R\x0f\x65xpectedVersion\x12\x44\n\x07updates\x18\x02 \x03(\x0b\x32*.ray.rpc.autoscaler.im.InstanceUpdateEventR\x07updates\"r\n\x1fUpdateInstanceManagerStateReply\x12\x35\n\x06status\x18\x01 \x01(\x0b\x32\x1d.ray.rpc.autoscaler.im.StatusR\x06status\x12\x18\n\x07version\x18\x02 \x01(\x03R\x07version\"o\n\x14InstanceManagerState\x12\x18\n\x07version\x18\x01 \x01(\x03R\x07version\x12=\n\tinstances\x18\x02 \x03(\x0b\x32\x1f.ray.rpc.autoscaler.im.InstanceR\tinstances\" \n\x1eGetInstanceManagerStateRequest\"\x98\x01\n\x1cGetInstanceManagerStateReply\x12\x35\n\x06status\x18\x01 \x01(\x0b\x32\x1d.ray.rpc.autoscaler.im.StatusR\x06status\x12\x41\n\x05state\x18\x02 \x01(\x0b\x32+.ray.rpc.autoscaler.im.InstanceManagerStateR\x05state*`\n\nStatusCode\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x06\n\x02OK\x10\x01\x12\x14\n\x10VERSION_MISMATCH\x10\x02\x12\x12\n\x0eUNKNOWN_ERRORS\x10\x03\x12\x0f\n\x0bUNAVAILABLE\x10\x04*/\n\x08NodeKind\x12\r\n\tUNMANAGED\x10\x00\x12\x08\n\x04HEAD\x10\x01\x12\n\n\x06WORKER\x10\x02\x32\xb1\x02\n\x16InstanceManagerService\x12\x85\x01\n\x17GetInstanceManagerState\x12\x35.ray.rpc.autoscaler.im.GetInstanceManagerStateRequest\x1a\x33.ray.rpc.autoscaler.im.GetInstanceManagerStateReply\x12\x8e\x01\n\x1aUpdateInstanceManagerState\x12\x38.ray.rpc.autoscaler.im.UpdateInstanceManagerStateRequest\x1a\x36.ray.rpc.autoscaler.im.UpdateInstanceManagerStateReplyb\x06proto3') + +_STATUSCODE = DESCRIPTOR.enum_types_by_name['StatusCode'] +StatusCode = enum_type_wrapper.EnumTypeWrapper(_STATUSCODE) +_NODEKIND = DESCRIPTOR.enum_types_by_name['NodeKind'] +NodeKind = enum_type_wrapper.EnumTypeWrapper(_NODEKIND) +UNSPECIFIED = 0 +OK = 1 +VERSION_MISMATCH = 2 +UNKNOWN_ERRORS = 3 +UNAVAILABLE = 4 +UNMANAGED = 0 +HEAD = 1 +WORKER = 2 + + +_STATUS = DESCRIPTOR.message_types_by_name['Status'] +_INSTANCE = DESCRIPTOR.message_types_by_name['Instance'] +_INSTANCE_TOTALRESOURCESENTRY = _INSTANCE.nested_types_by_name['TotalResourcesEntry'] +_INSTANCE_STATUSHISTORY = _INSTANCE.nested_types_by_name['StatusHistory'] +_INSTANCEUPDATEEVENT = DESCRIPTOR.message_types_by_name['InstanceUpdateEvent'] +_LAUNCHREQUEST = DESCRIPTOR.message_types_by_name['LaunchRequest'] +_TERMINATIONREQUEST = DESCRIPTOR.message_types_by_name['TerminationRequest'] +_UPDATEINSTANCEMANAGERSTATEREQUEST = DESCRIPTOR.message_types_by_name['UpdateInstanceManagerStateRequest'] +_UPDATEINSTANCEMANAGERSTATEREPLY = DESCRIPTOR.message_types_by_name['UpdateInstanceManagerStateReply'] +_INSTANCEMANAGERSTATE = DESCRIPTOR.message_types_by_name['InstanceManagerState'] +_GETINSTANCEMANAGERSTATEREQUEST = DESCRIPTOR.message_types_by_name['GetInstanceManagerStateRequest'] +_GETINSTANCEMANAGERSTATEREPLY = DESCRIPTOR.message_types_by_name['GetInstanceManagerStateReply'] +_INSTANCE_INSTANCESTATUS = _INSTANCE.enum_types_by_name['InstanceStatus'] +_TERMINATIONREQUEST_CAUSE = _TERMINATIONREQUEST.enum_types_by_name['Cause'] +Status = _reflection.GeneratedProtocolMessageType('Status', (_message.Message,), { + 'DESCRIPTOR' : _STATUS, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.Status) + }) +_sym_db.RegisterMessage(Status) + +Instance = _reflection.GeneratedProtocolMessageType('Instance', (_message.Message,), { + + 'TotalResourcesEntry' : _reflection.GeneratedProtocolMessageType('TotalResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _INSTANCE_TOTALRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.Instance.TotalResourcesEntry) + }) + , + + 'StatusHistory' : _reflection.GeneratedProtocolMessageType('StatusHistory', (_message.Message,), { + 'DESCRIPTOR' : _INSTANCE_STATUSHISTORY, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.Instance.StatusHistory) + }) + , + 'DESCRIPTOR' : _INSTANCE, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.Instance) + }) +_sym_db.RegisterMessage(Instance) +_sym_db.RegisterMessage(Instance.TotalResourcesEntry) +_sym_db.RegisterMessage(Instance.StatusHistory) + +InstanceUpdateEvent = _reflection.GeneratedProtocolMessageType('InstanceUpdateEvent', (_message.Message,), { + 'DESCRIPTOR' : _INSTANCEUPDATEEVENT, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.InstanceUpdateEvent) + }) +_sym_db.RegisterMessage(InstanceUpdateEvent) + +LaunchRequest = _reflection.GeneratedProtocolMessageType('LaunchRequest', (_message.Message,), { + 'DESCRIPTOR' : _LAUNCHREQUEST, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.LaunchRequest) + }) +_sym_db.RegisterMessage(LaunchRequest) + +TerminationRequest = _reflection.GeneratedProtocolMessageType('TerminationRequest', (_message.Message,), { + 'DESCRIPTOR' : _TERMINATIONREQUEST, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.TerminationRequest) + }) +_sym_db.RegisterMessage(TerminationRequest) + +UpdateInstanceManagerStateRequest = _reflection.GeneratedProtocolMessageType('UpdateInstanceManagerStateRequest', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEINSTANCEMANAGERSTATEREQUEST, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.UpdateInstanceManagerStateRequest) + }) +_sym_db.RegisterMessage(UpdateInstanceManagerStateRequest) + +UpdateInstanceManagerStateReply = _reflection.GeneratedProtocolMessageType('UpdateInstanceManagerStateReply', (_message.Message,), { + 'DESCRIPTOR' : _UPDATEINSTANCEMANAGERSTATEREPLY, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.UpdateInstanceManagerStateReply) + }) +_sym_db.RegisterMessage(UpdateInstanceManagerStateReply) + +InstanceManagerState = _reflection.GeneratedProtocolMessageType('InstanceManagerState', (_message.Message,), { + 'DESCRIPTOR' : _INSTANCEMANAGERSTATE, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.InstanceManagerState) + }) +_sym_db.RegisterMessage(InstanceManagerState) + +GetInstanceManagerStateRequest = _reflection.GeneratedProtocolMessageType('GetInstanceManagerStateRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETINSTANCEMANAGERSTATEREQUEST, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.GetInstanceManagerStateRequest) + }) +_sym_db.RegisterMessage(GetInstanceManagerStateRequest) + +GetInstanceManagerStateReply = _reflection.GeneratedProtocolMessageType('GetInstanceManagerStateReply', (_message.Message,), { + 'DESCRIPTOR' : _GETINSTANCEMANAGERSTATEREPLY, + '__module__' : 'src.ray.protobuf.instance_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.autoscaler.im.GetInstanceManagerStateReply) + }) +_sym_db.RegisterMessage(GetInstanceManagerStateReply) + +_INSTANCEMANAGERSERVICE = DESCRIPTOR.services_by_name['InstanceManagerService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _INSTANCE_TOTALRESOURCESENTRY._options = None + _INSTANCE_TOTALRESOURCESENTRY._serialized_options = b'8\001' + _STATUSCODE._serialized_start=3380 + _STATUSCODE._serialized_end=3476 + _NODEKIND._serialized_start=3478 + _NODEKIND._serialized_end=3525 + _STATUS._serialized_start=66 + _STATUS._serialized_end=155 + _INSTANCE._serialized_start=158 + _INSTANCE._serialized_end=1391 + _INSTANCE_TOTALRESOURCESENTRY._serialized_start=850 + _INSTANCE_TOTALRESOURCESENTRY._serialized_end=915 + _INSTANCE_STATUSHISTORY._serialized_start=918 + _INSTANCE_STATUSHISTORY._serialized_end=1083 + _INSTANCE_INSTANCESTATUS._serialized_start=1086 + _INSTANCE_INSTANCESTATUS._serialized_end=1357 + _INSTANCEUPDATEEVENT._serialized_start=1394 + _INSTANCEUPDATEEVENT._serialized_end=2051 + _LAUNCHREQUEST._serialized_start=2053 + _LAUNCHREQUEST._serialized_end=2179 + _TERMINATIONREQUEST._serialized_start=2182 + _TERMINATIONREQUEST._serialized_end=2809 + _TERMINATIONREQUEST_CAUSE._serialized_start=2653 + _TERMINATIONREQUEST_CAUSE._serialized_end=2743 + _UPDATEINSTANCEMANAGERSTATEREQUEST._serialized_start=2812 + _UPDATEINSTANCEMANAGERSTATEREQUEST._serialized_end=2960 + _UPDATEINSTANCEMANAGERSTATEREPLY._serialized_start=2962 + _UPDATEINSTANCEMANAGERSTATEREPLY._serialized_end=3076 + _INSTANCEMANAGERSTATE._serialized_start=3078 + _INSTANCEMANAGERSTATE._serialized_end=3189 + _GETINSTANCEMANAGERSTATEREQUEST._serialized_start=3191 + _GETINSTANCEMANAGERSTATEREQUEST._serialized_end=3223 + _GETINSTANCEMANAGERSTATEREPLY._serialized_start=3226 + _GETINSTANCEMANAGERSTATEREPLY._serialized_end=3378 + _INSTANCEMANAGERSERVICE._serialized_start=3528 + _INSTANCEMANAGERSERVICE._serialized_end=3833 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..bc62b0725139bae605e0ab983580f9e522def2ff --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/instance_manager_pb2_grpc.py @@ -0,0 +1,99 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import instance_manager_pb2 as src_dot_ray_dot_protobuf_dot_instance__manager__pb2 + + +class InstanceManagerServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetInstanceManagerState = channel.unary_unary( + '/ray.rpc.autoscaler.im.InstanceManagerService/GetInstanceManagerState', + request_serializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateReply.FromString, + ) + self.UpdateInstanceManagerState = channel.unary_unary( + '/ray.rpc.autoscaler.im.InstanceManagerService/UpdateInstanceManagerState', + request_serializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateReply.FromString, + ) + + +class InstanceManagerServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetInstanceManagerState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateInstanceManagerState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_InstanceManagerServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetInstanceManagerState': grpc.unary_unary_rpc_method_handler( + servicer.GetInstanceManagerState, + request_deserializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateReply.SerializeToString, + ), + 'UpdateInstanceManagerState': grpc.unary_unary_rpc_method_handler( + servicer.UpdateInstanceManagerState, + request_deserializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.autoscaler.im.InstanceManagerService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class InstanceManagerService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetInstanceManagerState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.im.InstanceManagerService/GetInstanceManagerState', + src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_instance__manager__pb2.GetInstanceManagerStateReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateInstanceManagerState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.im.InstanceManagerService/UpdateInstanceManagerState', + src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_instance__manager__pb2.UpdateInstanceManagerStateReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/logging_pb2.py b/lib/python3.12/site-packages/ray/core/generated/logging_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..fa08f08b1b54bd427256d588647917bb512e05b2 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/logging_pb2.py @@ -0,0 +1,34 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/logging.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1esrc/ray/protobuf/logging.proto\x12\x07ray.rpc\"\xb0\x01\n\x08LogBatch\x12\x0e\n\x02ip\x18\x01 \x01(\tR\x02ip\x12\x10\n\x03pid\x18\x02 \x01(\tR\x03pid\x12\x15\n\x06job_id\x18\x03 \x01(\tR\x05jobId\x12\x19\n\x08is_error\x18\x04 \x01(\x08R\x07isError\x12\x14\n\x05lines\x18\x05 \x03(\tR\x05lines\x12\x1d\n\nactor_name\x18\x06 \x01(\tR\tactorName\x12\x1b\n\ttask_name\x18\x07 \x01(\tR\x08taskNameb\x06proto3') + + + +_LOGBATCH = DESCRIPTOR.message_types_by_name['LogBatch'] +LogBatch = _reflection.GeneratedProtocolMessageType('LogBatch', (_message.Message,), { + 'DESCRIPTOR' : _LOGBATCH, + '__module__' : 'src.ray.protobuf.logging_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LogBatch) + }) +_sym_db.RegisterMessage(LogBatch) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _LOGBATCH._serialized_start=44 + _LOGBATCH._serialized_end=220 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/logging_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/logging_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/logging_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/metrics_pb2.py b/lib/python3.12/site-packages/ray/core/generated/metrics_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..1cc59ff7e5b24e4676a38bb1055bc5ad46a481af --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/metrics_pb2.py @@ -0,0 +1,190 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: opencensus/proto/metrics/v1/metrics.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 +from . import resource_pb2 as opencensus_dot_proto_dot_resource_dot_v1_dot_resource__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)opencensus/proto/metrics/v1/metrics.proto\x12\x1bopencensus.proto.metrics.v1\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a+opencensus/proto/resource/v1/resource.proto\"\xf1\x01\n\x06Metric\x12Z\n\x11metric_descriptor\x18\x01 \x01(\x0b\x32-.opencensus.proto.metrics.v1.MetricDescriptorR\x10metricDescriptor\x12G\n\ntimeseries\x18\x02 \x03(\x0b\x32\'.opencensus.proto.metrics.v1.TimeSeriesR\ntimeseries\x12\x42\n\x08resource\x18\x03 \x01(\x0b\x32&.opencensus.proto.resource.v1.ResourceR\x08resource\"\x96\x03\n\x10MetricDescriptor\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x12\n\x04unit\x18\x03 \x01(\tR\x04unit\x12\x46\n\x04type\x18\x04 \x01(\x0e\x32\x32.opencensus.proto.metrics.v1.MetricDescriptor.TypeR\x04type\x12\x44\n\nlabel_keys\x18\x05 \x03(\x0b\x32%.opencensus.proto.metrics.v1.LabelKeyR\tlabelKeys\"\xa9\x01\n\x04Type\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0f\n\x0bGAUGE_INT64\x10\x01\x12\x10\n\x0cGAUGE_DOUBLE\x10\x02\x12\x16\n\x12GAUGE_DISTRIBUTION\x10\x03\x12\x14\n\x10\x43UMULATIVE_INT64\x10\x04\x12\x15\n\x11\x43UMULATIVE_DOUBLE\x10\x05\x12\x1b\n\x17\x43UMULATIVE_DISTRIBUTION\x10\x06\x12\x0b\n\x07SUMMARY\x10\x07\">\n\x08LabelKey\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\"\xd9\x01\n\nTimeSeries\x12\x43\n\x0fstart_timestamp\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0estartTimestamp\x12J\n\x0clabel_values\x18\x02 \x03(\x0b\x32\'.opencensus.proto.metrics.v1.LabelValueR\x0blabelValues\x12:\n\x06points\x18\x03 \x03(\x0b\x32\".opencensus.proto.metrics.v1.PointR\x06points\"?\n\nLabelValue\x12\x14\n\x05value\x18\x01 \x01(\tR\x05value\x12\x1b\n\thas_value\x18\x02 \x01(\x08R\x08hasValue\"\xc5\x02\n\x05Point\x12\x38\n\ttimestamp\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12!\n\x0bint64_value\x18\x02 \x01(\x03H\x00R\nint64Value\x12#\n\x0c\x64ouble_value\x18\x03 \x01(\x01H\x00R\x0b\x64oubleValue\x12_\n\x12\x64istribution_value\x18\x04 \x01(\x0b\x32..opencensus.proto.metrics.v1.DistributionValueH\x00R\x11\x64istributionValue\x12P\n\rsummary_value\x18\x05 \x01(\x0b\x32).opencensus.proto.metrics.v1.SummaryValueH\x00R\x0csummaryValueB\x07\n\x05value\"\xcb\x06\n\x11\x44istributionValue\x12\x14\n\x05\x63ount\x18\x01 \x01(\x03R\x05\x63ount\x12\x10\n\x03sum\x18\x02 \x01(\x01R\x03sum\x12\x37\n\x18sum_of_squared_deviation\x18\x03 \x01(\x01R\x15sumOfSquaredDeviation\x12\x63\n\x0e\x62ucket_options\x18\x04 \x01(\x0b\x32<.opencensus.proto.metrics.v1.DistributionValue.BucketOptionsR\rbucketOptions\x12O\n\x07\x62uckets\x18\x05 \x03(\x0b\x32\x35.opencensus.proto.metrics.v1.DistributionValue.BucketR\x07\x62uckets\x1a\xa0\x01\n\rBucketOptions\x12\x63\n\x08\x65xplicit\x18\x01 \x01(\x0b\x32\x45.opencensus.proto.metrics.v1.DistributionValue.BucketOptions.ExplicitH\x00R\x08\x65xplicit\x1a\"\n\x08\x45xplicit\x12\x16\n\x06\x62ounds\x18\x01 \x03(\x01R\x06\x62oundsB\x06\n\x04type\x1as\n\x06\x42ucket\x12\x14\n\x05\x63ount\x18\x01 \x01(\x03R\x05\x63ount\x12S\n\x08\x65xemplar\x18\x02 \x01(\x0b\x32\x37.opencensus.proto.metrics.v1.DistributionValue.ExemplarR\x08\x65xemplar\x1a\x86\x02\n\x08\x45xemplar\x12\x14\n\x05value\x18\x01 \x01(\x01R\x05value\x12\x38\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12j\n\x0b\x61ttachments\x18\x03 \x03(\x0b\x32H.opencensus.proto.metrics.v1.DistributionValue.Exemplar.AttachmentsEntryR\x0b\x61ttachments\x1a>\n\x10\x41ttachmentsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xef\x03\n\x0cSummaryValue\x12\x31\n\x05\x63ount\x18\x01 \x01(\x0b\x32\x1b.google.protobuf.Int64ValueR\x05\x63ount\x12.\n\x03sum\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.DoubleValueR\x03sum\x12N\n\x08snapshot\x18\x03 \x01(\x0b\x32\x32.opencensus.proto.metrics.v1.SummaryValue.SnapshotR\x08snapshot\x1a\xab\x02\n\x08Snapshot\x12\x31\n\x05\x63ount\x18\x01 \x01(\x0b\x32\x1b.google.protobuf.Int64ValueR\x05\x63ount\x12.\n\x03sum\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.DoubleValueR\x03sum\x12q\n\x11percentile_values\x18\x03 \x03(\x0b\x32\x44.opencensus.proto.metrics.v1.SummaryValue.Snapshot.ValueAtPercentileR\x10percentileValues\x1aI\n\x11ValueAtPercentile\x12\x1e\n\npercentile\x18\x01 \x01(\x01R\npercentile\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05valueB\x94\x01\n\x1eio.opencensus.proto.metrics.v1B\x0cMetricsProtoP\x01ZDgithub.com/census-instrumentation/opencensus-proto/gen-go/metrics/v1\xea\x02\x1bOpenCensus.Proto.Metrics.V1b\x06proto3') + + + +_METRIC = DESCRIPTOR.message_types_by_name['Metric'] +_METRICDESCRIPTOR = DESCRIPTOR.message_types_by_name['MetricDescriptor'] +_LABELKEY = DESCRIPTOR.message_types_by_name['LabelKey'] +_TIMESERIES = DESCRIPTOR.message_types_by_name['TimeSeries'] +_LABELVALUE = DESCRIPTOR.message_types_by_name['LabelValue'] +_POINT = DESCRIPTOR.message_types_by_name['Point'] +_DISTRIBUTIONVALUE = DESCRIPTOR.message_types_by_name['DistributionValue'] +_DISTRIBUTIONVALUE_BUCKETOPTIONS = _DISTRIBUTIONVALUE.nested_types_by_name['BucketOptions'] +_DISTRIBUTIONVALUE_BUCKETOPTIONS_EXPLICIT = _DISTRIBUTIONVALUE_BUCKETOPTIONS.nested_types_by_name['Explicit'] +_DISTRIBUTIONVALUE_BUCKET = _DISTRIBUTIONVALUE.nested_types_by_name['Bucket'] +_DISTRIBUTIONVALUE_EXEMPLAR = _DISTRIBUTIONVALUE.nested_types_by_name['Exemplar'] +_DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY = _DISTRIBUTIONVALUE_EXEMPLAR.nested_types_by_name['AttachmentsEntry'] +_SUMMARYVALUE = DESCRIPTOR.message_types_by_name['SummaryValue'] +_SUMMARYVALUE_SNAPSHOT = _SUMMARYVALUE.nested_types_by_name['Snapshot'] +_SUMMARYVALUE_SNAPSHOT_VALUEATPERCENTILE = _SUMMARYVALUE_SNAPSHOT.nested_types_by_name['ValueAtPercentile'] +_METRICDESCRIPTOR_TYPE = _METRICDESCRIPTOR.enum_types_by_name['Type'] +Metric = _reflection.GeneratedProtocolMessageType('Metric', (_message.Message,), { + 'DESCRIPTOR' : _METRIC, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.Metric) + }) +_sym_db.RegisterMessage(Metric) + +MetricDescriptor = _reflection.GeneratedProtocolMessageType('MetricDescriptor', (_message.Message,), { + 'DESCRIPTOR' : _METRICDESCRIPTOR, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.MetricDescriptor) + }) +_sym_db.RegisterMessage(MetricDescriptor) + +LabelKey = _reflection.GeneratedProtocolMessageType('LabelKey', (_message.Message,), { + 'DESCRIPTOR' : _LABELKEY, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.LabelKey) + }) +_sym_db.RegisterMessage(LabelKey) + +TimeSeries = _reflection.GeneratedProtocolMessageType('TimeSeries', (_message.Message,), { + 'DESCRIPTOR' : _TIMESERIES, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.TimeSeries) + }) +_sym_db.RegisterMessage(TimeSeries) + +LabelValue = _reflection.GeneratedProtocolMessageType('LabelValue', (_message.Message,), { + 'DESCRIPTOR' : _LABELVALUE, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.LabelValue) + }) +_sym_db.RegisterMessage(LabelValue) + +Point = _reflection.GeneratedProtocolMessageType('Point', (_message.Message,), { + 'DESCRIPTOR' : _POINT, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.Point) + }) +_sym_db.RegisterMessage(Point) + +DistributionValue = _reflection.GeneratedProtocolMessageType('DistributionValue', (_message.Message,), { + + 'BucketOptions' : _reflection.GeneratedProtocolMessageType('BucketOptions', (_message.Message,), { + + 'Explicit' : _reflection.GeneratedProtocolMessageType('Explicit', (_message.Message,), { + 'DESCRIPTOR' : _DISTRIBUTIONVALUE_BUCKETOPTIONS_EXPLICIT, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue.BucketOptions.Explicit) + }) + , + 'DESCRIPTOR' : _DISTRIBUTIONVALUE_BUCKETOPTIONS, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue.BucketOptions) + }) + , + + 'Bucket' : _reflection.GeneratedProtocolMessageType('Bucket', (_message.Message,), { + 'DESCRIPTOR' : _DISTRIBUTIONVALUE_BUCKET, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue.Bucket) + }) + , + + 'Exemplar' : _reflection.GeneratedProtocolMessageType('Exemplar', (_message.Message,), { + + 'AttachmentsEntry' : _reflection.GeneratedProtocolMessageType('AttachmentsEntry', (_message.Message,), { + 'DESCRIPTOR' : _DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue.Exemplar.AttachmentsEntry) + }) + , + 'DESCRIPTOR' : _DISTRIBUTIONVALUE_EXEMPLAR, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue.Exemplar) + }) + , + 'DESCRIPTOR' : _DISTRIBUTIONVALUE, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.DistributionValue) + }) +_sym_db.RegisterMessage(DistributionValue) +_sym_db.RegisterMessage(DistributionValue.BucketOptions) +_sym_db.RegisterMessage(DistributionValue.BucketOptions.Explicit) +_sym_db.RegisterMessage(DistributionValue.Bucket) +_sym_db.RegisterMessage(DistributionValue.Exemplar) +_sym_db.RegisterMessage(DistributionValue.Exemplar.AttachmentsEntry) + +SummaryValue = _reflection.GeneratedProtocolMessageType('SummaryValue', (_message.Message,), { + + 'Snapshot' : _reflection.GeneratedProtocolMessageType('Snapshot', (_message.Message,), { + + 'ValueAtPercentile' : _reflection.GeneratedProtocolMessageType('ValueAtPercentile', (_message.Message,), { + 'DESCRIPTOR' : _SUMMARYVALUE_SNAPSHOT_VALUEATPERCENTILE, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.SummaryValue.Snapshot.ValueAtPercentile) + }) + , + 'DESCRIPTOR' : _SUMMARYVALUE_SNAPSHOT, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.SummaryValue.Snapshot) + }) + , + 'DESCRIPTOR' : _SUMMARYVALUE, + '__module__' : 'opencensus.proto.metrics.v1.metrics_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.metrics.v1.SummaryValue) + }) +_sym_db.RegisterMessage(SummaryValue) +_sym_db.RegisterMessage(SummaryValue.Snapshot) +_sym_db.RegisterMessage(SummaryValue.Snapshot.ValueAtPercentile) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\036io.opencensus.proto.metrics.v1B\014MetricsProtoP\001ZDgithub.com/census-instrumentation/opencensus-proto/gen-go/metrics/v1\352\002\033OpenCensus.Proto.Metrics.V1' + _DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY._options = None + _DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY._serialized_options = b'8\001' + _METRIC._serialized_start=185 + _METRIC._serialized_end=426 + _METRICDESCRIPTOR._serialized_start=429 + _METRICDESCRIPTOR._serialized_end=835 + _METRICDESCRIPTOR_TYPE._serialized_start=666 + _METRICDESCRIPTOR_TYPE._serialized_end=835 + _LABELKEY._serialized_start=837 + _LABELKEY._serialized_end=899 + _TIMESERIES._serialized_start=902 + _TIMESERIES._serialized_end=1119 + _LABELVALUE._serialized_start=1121 + _LABELVALUE._serialized_end=1184 + _POINT._serialized_start=1187 + _POINT._serialized_end=1512 + _DISTRIBUTIONVALUE._serialized_start=1515 + _DISTRIBUTIONVALUE._serialized_end=2358 + _DISTRIBUTIONVALUE_BUCKETOPTIONS._serialized_start=1816 + _DISTRIBUTIONVALUE_BUCKETOPTIONS._serialized_end=1976 + _DISTRIBUTIONVALUE_BUCKETOPTIONS_EXPLICIT._serialized_start=1934 + _DISTRIBUTIONVALUE_BUCKETOPTIONS_EXPLICIT._serialized_end=1968 + _DISTRIBUTIONVALUE_BUCKET._serialized_start=1978 + _DISTRIBUTIONVALUE_BUCKET._serialized_end=2093 + _DISTRIBUTIONVALUE_EXEMPLAR._serialized_start=2096 + _DISTRIBUTIONVALUE_EXEMPLAR._serialized_end=2358 + _DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY._serialized_start=2296 + _DISTRIBUTIONVALUE_EXEMPLAR_ATTACHMENTSENTRY._serialized_end=2358 + _SUMMARYVALUE._serialized_start=2361 + _SUMMARYVALUE._serialized_end=2856 + _SUMMARYVALUE_SNAPSHOT._serialized_start=2557 + _SUMMARYVALUE_SNAPSHOT._serialized_end=2856 + _SUMMARYVALUE_SNAPSHOT_VALUEATPERCENTILE._serialized_start=2783 + _SUMMARYVALUE_SNAPSHOT_VALUEATPERCENTILE._serialized_end=2856 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/metrics_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/metrics_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/metrics_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2.py b/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..0812d352b7df84780bf42ddc0b1e8eb87b670b6a --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2.py @@ -0,0 +1,664 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/node_manager.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import gcs_pb2 as src_dot_ray_dot_protobuf_dot_gcs__pb2 +from . import autoscaler_pb2 as src_dot_ray_dot_protobuf_dot_autoscaler__pb2 +from . import runtime_environment_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_runtime__environment__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#src/ray/protobuf/node_manager.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a\x1asrc/ray/protobuf/gcs.proto\x1a!src/ray/protobuf/autoscaler.proto\x1a\x31src/ray/protobuf/public/runtime_environment.proto\"k\n\x13WorkerBacklogReport\x12\x31\n\nlease_spec\x18\x01 \x01(\x0b\x32\x12.ray.rpc.LeaseSpecR\tleaseSpec\x12!\n\x0c\x62\x61\x63klog_size\x18\x02 \x01(\x03R\x0b\x62\x61\x63klogSize\"\x80\x01\n\x1aReportWorkerBacklogRequest\x12\x1b\n\tworker_id\x18\x01 \x01(\x0cR\x08workerId\x12\x45\n\x0f\x62\x61\x63klog_reports\x18\x02 \x03(\x0b\x32\x1c.ray.rpc.WorkerBacklogReportR\x0e\x62\x61\x63klogReports\"\x1a\n\x18ReportWorkerBacklogReply\"\xdb\x01\n\x19RequestWorkerLeaseRequest\x12\x31\n\nlease_spec\x18\x01 \x01(\x0b\x32\x12.ray.rpc.LeaseSpecR\tleaseSpec\x12!\n\x0c\x62\x61\x63klog_size\x18\x02 \x01(\x03R\x0b\x62\x61\x63klogSize\x12&\n\x0fgrant_or_reject\x18\x03 \x01(\x08R\rgrantOrReject\x12@\n\x1dis_selected_based_on_locality\x18\x04 \x01(\x08R\x19isSelectedBasedOnLocality\"\x81\x06\n\x17RequestWorkerLeaseReply\x12\x37\n\x0eworker_address\x18\x01 \x01(\x0b\x32\x10.ray.rpc.AddressR\rworkerAddress\x12G\n\x17retry_at_raylet_address\x18\x02 \x01(\x0b\x32\x10.ray.rpc.AddressR\x14retryAtRayletAddress\x12\x44\n\x10resource_mapping\x18\x03 \x03(\x0b\x32\x19.ray.rpc.ResourceMapEntryR\x0fresourceMapping\x12\x1a\n\x08\x63\x61nceled\x18\x04 \x01(\x08R\x08\x63\x61nceled\x12\x1d\n\nworker_pid\x18\x06 \x01(\rR\tworkerPid\x12\x1a\n\x08rejected\x18\x07 \x01(\x08R\x08rejected\x12=\n\x0eresources_data\x18\x08 \x01(\x0b\x32\x16.ray.rpc.ResourcesDataR\rresourcesData\x12Y\n\x0c\x66\x61ilure_type\x18\t \x01(\x0e\x32\x36.ray.rpc.RequestWorkerLeaseReply.SchedulingFailureTypeR\x0b\x66\x61ilureType\x12<\n\x1ascheduling_failure_message\x18\n \x01(\tR\x18schedulingFailureMessage\"\xee\x01\n\x15SchedulingFailureType\x12\x0e\n\nNOT_FAILED\x10\x00\x12\x15\n\x11SCHEDULING_FAILED\x10\x01\x12\x30\n,SCHEDULING_CANCELLED_PLACEMENT_GROUP_REMOVED\x10\x02\x12\x31\n-SCHEDULING_CANCELLED_RUNTIME_ENV_SETUP_FAILED\x10\x03\x12!\n\x1dSCHEDULING_CANCELLED_INTENDED\x10\x04\x12&\n\"SCHEDULING_CANCELLED_UNSCHEDULABLE\x10\x05\"\x8b\x02\n\x16PrestartWorkersRequest\x12-\n\x08language\x18\x01 \x01(\x0e\x32\x11.ray.rpc.LanguageR\x08language\x12\x1a\n\x06job_id\x18\x02 \x01(\x0cH\x00R\x05jobId\x88\x01\x01\x12\x41\n\x10runtime_env_info\x18\x03 \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvInfoR\x0eruntimeEnvInfo\x12\x37\n\x18keep_alive_duration_secs\x18\x04 \x01(\x04R\x15keepAliveDurationSecs\x12\x1f\n\x0bnum_workers\x18\x05 \x01(\x04R\nnumWorkersB\t\n\x07_job_id\"\x16\n\x14PrestartWorkersReply\"S\n\x1dPrepareBundleResourcesRequest\x12\x32\n\x0c\x62undle_specs\x18\x01 \x03(\x0b\x32\x0f.ray.rpc.BundleR\x0b\x62undleSpecs\"7\n\x1bPrepareBundleResourcesReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\"R\n\x1c\x43ommitBundleResourcesRequest\x12\x32\n\x0c\x62undle_specs\x18\x01 \x03(\x0b\x32\x0f.ray.rpc.BundleR\x0b\x62undleSpecs\"\x1c\n\x1a\x43ommitBundleResourcesReply\"P\n\x1c\x43\x61ncelResourceReserveRequest\x12\x30\n\x0b\x62undle_spec\x18\x01 \x01(\x0b\x32\x0f.ray.rpc.BundleR\nbundleSpec\"\x1c\n\x1a\x43\x61ncelResourceReserveReply\"\xbe\x01\n#ResizeLocalResourceInstancesRequest\x12Y\n\tresources\x18\x01 \x03(\x0b\x32;.ray.rpc.ResizeLocalResourceInstancesRequest.ResourcesEntryR\tresources\x1a<\n\x0eResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\xcf\x01\n!ResizeLocalResourceInstancesReply\x12g\n\x0ftotal_resources\x18\x01 \x03(\x0b\x32>.ray.rpc.ResizeLocalResourceInstancesReply.TotalResourcesEntryR\x0etotalResources\x1a\x41\n\x13TotalResourcesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"\xef\x01\n\x18ReturnWorkerLeaseRequest\x12\x1f\n\x0bworker_port\x18\x01 \x01(\x05R\nworkerPort\x12\x19\n\x08lease_id\x18\x02 \x01(\x0cR\x07leaseId\x12+\n\x11\x64isconnect_worker\x18\x03 \x01(\x08R\x10\x64isconnectWorker\x12%\n\x0eworker_exiting\x18\x04 \x01(\x08R\rworkerExiting\x12\x43\n\x1e\x64isconnect_worker_error_detail\x18\x05 \x01(\tR\x1b\x64isconnectWorkerErrorDetail\"\x18\n\x16ReturnWorkerLeaseReply\"M\n ReleaseUnusedActorWorkersRequest\x12)\n\x11worker_ids_in_use\x18\x01 \x03(\x0cR\x0eworkerIdsInUse\" \n\x1eReleaseUnusedActorWorkersReply\"3\n\x15ShutdownRayletRequest\x12\x1a\n\x08graceful\x18\x01 \x01(\x08R\x08graceful\"\x15\n\x13ShutdownRayletReply\"5\n\x18\x43\x61ncelWorkerLeaseRequest\x12\x19\n\x08lease_id\x18\x01 \x01(\x0cR\x07leaseId\"2\n\x16\x43\x61ncelWorkerLeaseReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\"\xa4\x01\n\x13PinObjectIDsRequest\x12\x35\n\rowner_address\x18\x01 \x01(\x0b\x32\x10.ray.rpc.AddressR\x0cownerAddress\x12\x1d\n\nobject_ids\x18\x02 \x03(\x0cR\tobjectIds\x12&\n\x0cgenerator_id\x18\x03 \x01(\x0cH\x00R\x0bgeneratorId\x88\x01\x01\x42\x0f\n\r_generator_id\"1\n\x11PinObjectIDsReply\x12\x1c\n\tsuccesses\x18\x01 \x03(\x08R\tsuccesses\"E\n\x13GetNodeStatsRequest\x12.\n\x13include_memory_info\x18\x01 \x01(\x08R\x11includeMemoryInfo\"\xcb\x06\n\x10ObjectStoreStats\x12+\n\x12spill_time_total_s\x18\x01 \x01(\x01R\x0fspillTimeTotalS\x12.\n\x13spilled_bytes_total\x18\x02 \x01(\x03R\x11spilledBytesTotal\x12\x32\n\x15spilled_objects_total\x18\x03 \x01(\x03R\x13spilledObjectsTotal\x12/\n\x14restore_time_total_s\x18\x04 \x01(\x01R\x11restoreTimeTotalS\x12\x30\n\x14restored_bytes_total\x18\x05 \x01(\x03R\x12restoredBytesTotal\x12\x34\n\x16restored_objects_total\x18\x06 \x01(\x03R\x14restoredObjectsTotal\x12\x35\n\x17object_store_bytes_used\x18\x07 \x01(\x03R\x14objectStoreBytesUsed\x12\x37\n\x18object_store_bytes_avail\x18\x08 \x01(\x03R\x15objectStoreBytesAvail\x12\x44\n\x1fobject_store_bytes_primary_copy\x18\t \x01(\x03R\x1bobjectStoreBytesPrimaryCopy\x12=\n\x1bobject_store_bytes_fallback\x18\n \x01(\x03R\x18objectStoreBytesFallback\x12*\n\x11num_local_objects\x18\x0b \x01(\x03R\x0fnumLocalObjects\x12.\n\x13object_pulls_queued\x18\x0c \x01(\x08R\x11objectPullsQueued\x12\x44\n\x1fnum_object_store_primary_copies\x18\r \x01(\x03R\x1bnumObjectStorePrimaryCopies\x12<\n\x1a\x63umulative_created_objects\x18\x0e \x01(\x03R\x18\x63umulativeCreatedObjects\x12\x38\n\x18\x63umulative_created_bytes\x18\x0f \x01(\x03R\x16\x63umulativeCreatedBytes\"\xb8\x01\n\x11GetNodeStatsReply\x12\x46\n\x12\x63ore_workers_stats\x18\x01 \x03(\x0b\x32\x18.ray.rpc.CoreWorkerStatsR\x10\x63oreWorkersStats\x12\x1f\n\x0bnum_workers\x18\x03 \x01(\rR\nnumWorkers\x12:\n\x0bstore_stats\x18\x06 \x01(\x0b\x32\x19.ray.rpc.ObjectStoreStatsR\nstoreStats\"\x11\n\x0fGlobalGCRequest\"\x0f\n\rGlobalGCReply\"O\n\x1d\x46ormatGlobalMemoryInfoRequest\x12.\n\x13include_memory_info\x18\x01 \x01(\x08R\x11includeMemoryInfo\"\x80\x01\n\x1b\x46ormatGlobalMemoryInfoReply\x12%\n\x0ememory_summary\x18\x01 \x01(\tR\rmemorySummary\x12:\n\x0bstore_stats\x18\x02 \x01(\x0b\x32\x19.ray.rpc.ObjectStoreStatsR\nstoreStats\"T\n\x1bReleaseUnusedBundlesRequest\x12\x35\n\x0e\x62undles_in_use\x18\x01 \x03(\x0b\x32\x0f.ray.rpc.BundleR\x0c\x62undlesInUse\"\x1b\n\x19ReleaseUnusedBundlesReply\"\x18\n\x16GetSystemConfigRequest\";\n\x14GetSystemConfigReply\x12#\n\rsystem_config\x18\x01 \x01(\tR\x0csystemConfig\"<\n\x15GetObjectsInfoRequest\x12\x19\n\x05limit\x18\x01 \x01(\x03H\x00R\x05limit\x88\x01\x01\x42\x08\n\x06_limit\"s\n\x13GetObjectsInfoReply\x12\x46\n\x12\x63ore_workers_stats\x18\x01 \x03(\x0b\x32\x18.ray.rpc.CoreWorkerStatsR\x10\x63oreWorkersStats\x12\x14\n\x05total\x18\x02 \x01(\x03R\x05total\"\x18\n\x16GetResourceLoadRequest\"L\n\x14GetResourceLoadReply\x12\x34\n\tresources\x18\x01 \x01(\x0b\x32\x16.ray.rpc.ResourcesDataR\tresources\"\xda\x02\n%CancelLeasesWithResourceShapesRequest\x12\x65\n\x0fresource_shapes\x18\x01 \x03(\x0b\x32<.ray.rpc.CancelLeasesWithResourceShapesRequest.ResourceShapeR\x0eresourceShapes\x1a\xc9\x01\n\rResourceShape\x12v\n\x0eresource_shape\x18\x01 \x03(\x0b\x32O.ray.rpc.CancelLeasesWithResourceShapesRequest.ResourceShape.ResourceShapeEntryR\rresourceShape\x1a@\n\x12ResourceShapeEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\"%\n#CancelLeasesWithResourceShapesReply\"\x19\n\x17NotifyGCSRestartRequest\"\x17\n\x15NotifyGCSRestartReply\"9\n\x1cGetWorkerFailureCauseRequest\x12\x19\n\x08lease_id\x18\x01 \x01(\x0cR\x07leaseId\"\xa3\x01\n\x1aGetWorkerFailureCauseReply\x12?\n\rfailure_cause\x18\x01 \x01(\x0b\x32\x15.ray.rpc.RayErrorInfoH\x00R\x0c\x66\x61ilureCause\x88\x01\x01\x12\x32\n\x15\x66\x61il_task_immediately\x18\x02 \x01(\x08R\x13\x66\x61ilTaskImmediatelyB\x10\n\x0e_failure_cause\"\xac\x01\n\x12\x44rainRayletRequest\x12;\n\x06reason\x18\x01 \x01(\x0e\x32#.ray.rpc.autoscaler.DrainNodeReasonR\x06reason\x12%\n\x0ereason_message\x18\x02 \x01(\tR\rreasonMessage\x12\x32\n\x15\x64\x65\x61\x64line_timestamp_ms\x18\x03 \x01(\x03R\x13\x64\x65\x61\x64lineTimestampMs\"m\n\x10\x44rainRayletReply\x12\x1f\n\x0bis_accepted\x18\x01 \x01(\x08R\nisAccepted\x12\x38\n\x18rejection_reason_message\x18\x02 \x01(\tR\x16rejectionReasonMessage\"\x93\x01\n\x1cRegisterMutableObjectRequest\x12(\n\x10writer_object_id\x18\x01 \x01(\x0cR\x0ewriterObjectId\x12\x1f\n\x0bnum_readers\x18\x02 \x01(\x03R\nnumReaders\x12(\n\x10reader_object_id\x18\x03 \x01(\x0cR\x0ereaderObjectId\"\x1c\n\x1aRegisterMutableObjectReply\"\x83\x02\n\x18PushMutableObjectRequest\x12(\n\x10writer_object_id\x18\x01 \x01(\x0cR\x0ewriterObjectId\x12&\n\x0ftotal_data_size\x18\x02 \x01(\x04R\rtotalDataSize\x12.\n\x13total_metadata_size\x18\x03 \x01(\x04R\x11totalMetadataSize\x12\x16\n\x06offset\x18\x04 \x01(\x04R\x06offset\x12\x1d\n\nchunk_size\x18\x05 \x01(\x04R\tchunkSize\x12\x12\n\x04\x64\x61ta\x18\x06 \x01(\x0cR\x04\x64\x61ta\x12\x1a\n\x08metadata\x18\x07 \x01(\x0cR\x08metadata\",\n\x16PushMutableObjectReply\x12\x12\n\x04\x64one\x18\x01 \x01(\x08R\x04\x64one\"7\n\x18IsLocalWorkerDeadRequest\x12\x1b\n\tworker_id\x18\x01 \x01(\x0cR\x08workerId\"1\n\x16IsLocalWorkerDeadReply\x12\x17\n\x07is_dead\x18\x01 \x01(\x08R\x06isDead\"\x16\n\x14GetWorkerPIDsRequest\"(\n\x12GetWorkerPIDsReply\x12\x12\n\x04pids\x18\x01 \x03(\x05R\x04pids\"\xba\x01\n\x15KillLocalActorRequest\x12*\n\x11intended_actor_id\x18\x01 \x01(\x0cR\x0fintendedActorId\x12\x1b\n\tworker_id\x18\x02 \x01(\x0cR\x08workerId\x12\x1d\n\nforce_kill\x18\x03 \x01(\x08R\tforceKill\x12\x39\n\x0b\x64\x65\x61th_cause\x18\x04 \x01(\x0b\x32\x18.ray.rpc.ActorDeathCauseR\ndeathCause\"\x15\n\x13KillLocalActorReply2\x89\x14\n\x12NodeManagerService\x12T\n\x10NotifyGCSRestart\x12 .ray.rpc.NotifyGCSRestartRequest\x1a\x1e.ray.rpc.NotifyGCSRestartReply\x12Q\n\x0fGetResourceLoad\x12\x1f.ray.rpc.GetResourceLoadRequest\x1a\x1d.ray.rpc.GetResourceLoadReply\x12~\n\x1e\x43\x61ncelLeasesWithResourceShapes\x12..ray.rpc.CancelLeasesWithResourceShapesRequest\x1a,.ray.rpc.CancelLeasesWithResourceShapesReply\x12Z\n\x12RequestWorkerLease\x12\".ray.rpc.RequestWorkerLeaseRequest\x1a .ray.rpc.RequestWorkerLeaseReply\x12Q\n\x0fPrestartWorkers\x12\x1f.ray.rpc.PrestartWorkersRequest\x1a\x1d.ray.rpc.PrestartWorkersReply\x12]\n\x13ReportWorkerBacklog\x12#.ray.rpc.ReportWorkerBacklogRequest\x1a!.ray.rpc.ReportWorkerBacklogReply\x12W\n\x11ReturnWorkerLease\x12!.ray.rpc.ReturnWorkerLeaseRequest\x1a\x1f.ray.rpc.ReturnWorkerLeaseReply\x12o\n\x19ReleaseUnusedActorWorkers\x12).ray.rpc.ReleaseUnusedActorWorkersRequest\x1a\'.ray.rpc.ReleaseUnusedActorWorkersReply\x12N\n\x0eShutdownRaylet\x12\x1e.ray.rpc.ShutdownRayletRequest\x1a\x1c.ray.rpc.ShutdownRayletReply\x12\x45\n\x0b\x44rainRaylet\x12\x1b.ray.rpc.DrainRayletRequest\x1a\x19.ray.rpc.DrainRayletReply\x12\x66\n\x16PrepareBundleResources\x12&.ray.rpc.PrepareBundleResourcesRequest\x1a$.ray.rpc.PrepareBundleResourcesReply\x12\x63\n\x15\x43ommitBundleResources\x12%.ray.rpc.CommitBundleResourcesRequest\x1a#.ray.rpc.CommitBundleResourcesReply\x12\x63\n\x15\x43\x61ncelResourceReserve\x12%.ray.rpc.CancelResourceReserveRequest\x1a#.ray.rpc.CancelResourceReserveReply\x12x\n\x1cResizeLocalResourceInstances\x12,.ray.rpc.ResizeLocalResourceInstancesRequest\x1a*.ray.rpc.ResizeLocalResourceInstancesReply\x12W\n\x11\x43\x61ncelWorkerLease\x12!.ray.rpc.CancelWorkerLeaseRequest\x1a\x1f.ray.rpc.CancelWorkerLeaseReply\x12H\n\x0cPinObjectIDs\x12\x1c.ray.rpc.PinObjectIDsRequest\x1a\x1a.ray.rpc.PinObjectIDsReply\x12H\n\x0cGetNodeStats\x12\x1c.ray.rpc.GetNodeStatsRequest\x1a\x1a.ray.rpc.GetNodeStatsReply\x12<\n\x08GlobalGC\x12\x18.ray.rpc.GlobalGCRequest\x1a\x16.ray.rpc.GlobalGCReply\x12\x66\n\x16\x46ormatGlobalMemoryInfo\x12&.ray.rpc.FormatGlobalMemoryInfoRequest\x1a$.ray.rpc.FormatGlobalMemoryInfoReply\x12`\n\x14ReleaseUnusedBundles\x12$.ray.rpc.ReleaseUnusedBundlesRequest\x1a\".ray.rpc.ReleaseUnusedBundlesReply\x12Q\n\x0fGetSystemConfig\x12\x1f.ray.rpc.GetSystemConfigRequest\x1a\x1d.ray.rpc.GetSystemConfigReply\x12N\n\x0eGetObjectsInfo\x12\x1e.ray.rpc.GetObjectsInfoRequest\x1a\x1c.ray.rpc.GetObjectsInfoReply\x12\x63\n\x15GetWorkerFailureCause\x12%.ray.rpc.GetWorkerFailureCauseRequest\x1a#.ray.rpc.GetWorkerFailureCauseReply\x12\x63\n\x15RegisterMutableObject\x12%.ray.rpc.RegisterMutableObjectRequest\x1a#.ray.rpc.RegisterMutableObjectReply\x12W\n\x11PushMutableObject\x12!.ray.rpc.PushMutableObjectRequest\x1a\x1f.ray.rpc.PushMutableObjectReply\x12W\n\x11IsLocalWorkerDead\x12!.ray.rpc.IsLocalWorkerDeadRequest\x1a\x1f.ray.rpc.IsLocalWorkerDeadReply\x12K\n\rGetWorkerPIDs\x12\x1d.ray.rpc.GetWorkerPIDsRequest\x1a\x1b.ray.rpc.GetWorkerPIDsReply\x12N\n\x0eKillLocalActor\x12\x1e.ray.rpc.KillLocalActorRequest\x1a\x1c.ray.rpc.KillLocalActorReplyb\x06proto3') + + + +_WORKERBACKLOGREPORT = DESCRIPTOR.message_types_by_name['WorkerBacklogReport'] +_REPORTWORKERBACKLOGREQUEST = DESCRIPTOR.message_types_by_name['ReportWorkerBacklogRequest'] +_REPORTWORKERBACKLOGREPLY = DESCRIPTOR.message_types_by_name['ReportWorkerBacklogReply'] +_REQUESTWORKERLEASEREQUEST = DESCRIPTOR.message_types_by_name['RequestWorkerLeaseRequest'] +_REQUESTWORKERLEASEREPLY = DESCRIPTOR.message_types_by_name['RequestWorkerLeaseReply'] +_PRESTARTWORKERSREQUEST = DESCRIPTOR.message_types_by_name['PrestartWorkersRequest'] +_PRESTARTWORKERSREPLY = DESCRIPTOR.message_types_by_name['PrestartWorkersReply'] +_PREPAREBUNDLERESOURCESREQUEST = DESCRIPTOR.message_types_by_name['PrepareBundleResourcesRequest'] +_PREPAREBUNDLERESOURCESREPLY = DESCRIPTOR.message_types_by_name['PrepareBundleResourcesReply'] +_COMMITBUNDLERESOURCESREQUEST = DESCRIPTOR.message_types_by_name['CommitBundleResourcesRequest'] +_COMMITBUNDLERESOURCESREPLY = DESCRIPTOR.message_types_by_name['CommitBundleResourcesReply'] +_CANCELRESOURCERESERVEREQUEST = DESCRIPTOR.message_types_by_name['CancelResourceReserveRequest'] +_CANCELRESOURCERESERVEREPLY = DESCRIPTOR.message_types_by_name['CancelResourceReserveReply'] +_RESIZELOCALRESOURCEINSTANCESREQUEST = DESCRIPTOR.message_types_by_name['ResizeLocalResourceInstancesRequest'] +_RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY = _RESIZELOCALRESOURCEINSTANCESREQUEST.nested_types_by_name['ResourcesEntry'] +_RESIZELOCALRESOURCEINSTANCESREPLY = DESCRIPTOR.message_types_by_name['ResizeLocalResourceInstancesReply'] +_RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY = _RESIZELOCALRESOURCEINSTANCESREPLY.nested_types_by_name['TotalResourcesEntry'] +_RETURNWORKERLEASEREQUEST = DESCRIPTOR.message_types_by_name['ReturnWorkerLeaseRequest'] +_RETURNWORKERLEASEREPLY = DESCRIPTOR.message_types_by_name['ReturnWorkerLeaseReply'] +_RELEASEUNUSEDACTORWORKERSREQUEST = DESCRIPTOR.message_types_by_name['ReleaseUnusedActorWorkersRequest'] +_RELEASEUNUSEDACTORWORKERSREPLY = DESCRIPTOR.message_types_by_name['ReleaseUnusedActorWorkersReply'] +_SHUTDOWNRAYLETREQUEST = DESCRIPTOR.message_types_by_name['ShutdownRayletRequest'] +_SHUTDOWNRAYLETREPLY = DESCRIPTOR.message_types_by_name['ShutdownRayletReply'] +_CANCELWORKERLEASEREQUEST = DESCRIPTOR.message_types_by_name['CancelWorkerLeaseRequest'] +_CANCELWORKERLEASEREPLY = DESCRIPTOR.message_types_by_name['CancelWorkerLeaseReply'] +_PINOBJECTIDSREQUEST = DESCRIPTOR.message_types_by_name['PinObjectIDsRequest'] +_PINOBJECTIDSREPLY = DESCRIPTOR.message_types_by_name['PinObjectIDsReply'] +_GETNODESTATSREQUEST = DESCRIPTOR.message_types_by_name['GetNodeStatsRequest'] +_OBJECTSTORESTATS = DESCRIPTOR.message_types_by_name['ObjectStoreStats'] +_GETNODESTATSREPLY = DESCRIPTOR.message_types_by_name['GetNodeStatsReply'] +_GLOBALGCREQUEST = DESCRIPTOR.message_types_by_name['GlobalGCRequest'] +_GLOBALGCREPLY = DESCRIPTOR.message_types_by_name['GlobalGCReply'] +_FORMATGLOBALMEMORYINFOREQUEST = DESCRIPTOR.message_types_by_name['FormatGlobalMemoryInfoRequest'] +_FORMATGLOBALMEMORYINFOREPLY = DESCRIPTOR.message_types_by_name['FormatGlobalMemoryInfoReply'] +_RELEASEUNUSEDBUNDLESREQUEST = DESCRIPTOR.message_types_by_name['ReleaseUnusedBundlesRequest'] +_RELEASEUNUSEDBUNDLESREPLY = DESCRIPTOR.message_types_by_name['ReleaseUnusedBundlesReply'] +_GETSYSTEMCONFIGREQUEST = DESCRIPTOR.message_types_by_name['GetSystemConfigRequest'] +_GETSYSTEMCONFIGREPLY = DESCRIPTOR.message_types_by_name['GetSystemConfigReply'] +_GETOBJECTSINFOREQUEST = DESCRIPTOR.message_types_by_name['GetObjectsInfoRequest'] +_GETOBJECTSINFOREPLY = DESCRIPTOR.message_types_by_name['GetObjectsInfoReply'] +_GETRESOURCELOADREQUEST = DESCRIPTOR.message_types_by_name['GetResourceLoadRequest'] +_GETRESOURCELOADREPLY = DESCRIPTOR.message_types_by_name['GetResourceLoadReply'] +_CANCELLEASESWITHRESOURCESHAPESREQUEST = DESCRIPTOR.message_types_by_name['CancelLeasesWithResourceShapesRequest'] +_CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE = _CANCELLEASESWITHRESOURCESHAPESREQUEST.nested_types_by_name['ResourceShape'] +_CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY = _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE.nested_types_by_name['ResourceShapeEntry'] +_CANCELLEASESWITHRESOURCESHAPESREPLY = DESCRIPTOR.message_types_by_name['CancelLeasesWithResourceShapesReply'] +_NOTIFYGCSRESTARTREQUEST = DESCRIPTOR.message_types_by_name['NotifyGCSRestartRequest'] +_NOTIFYGCSRESTARTREPLY = DESCRIPTOR.message_types_by_name['NotifyGCSRestartReply'] +_GETWORKERFAILURECAUSEREQUEST = DESCRIPTOR.message_types_by_name['GetWorkerFailureCauseRequest'] +_GETWORKERFAILURECAUSEREPLY = DESCRIPTOR.message_types_by_name['GetWorkerFailureCauseReply'] +_DRAINRAYLETREQUEST = DESCRIPTOR.message_types_by_name['DrainRayletRequest'] +_DRAINRAYLETREPLY = DESCRIPTOR.message_types_by_name['DrainRayletReply'] +_REGISTERMUTABLEOBJECTREQUEST = DESCRIPTOR.message_types_by_name['RegisterMutableObjectRequest'] +_REGISTERMUTABLEOBJECTREPLY = DESCRIPTOR.message_types_by_name['RegisterMutableObjectReply'] +_PUSHMUTABLEOBJECTREQUEST = DESCRIPTOR.message_types_by_name['PushMutableObjectRequest'] +_PUSHMUTABLEOBJECTREPLY = DESCRIPTOR.message_types_by_name['PushMutableObjectReply'] +_ISLOCALWORKERDEADREQUEST = DESCRIPTOR.message_types_by_name['IsLocalWorkerDeadRequest'] +_ISLOCALWORKERDEADREPLY = DESCRIPTOR.message_types_by_name['IsLocalWorkerDeadReply'] +_GETWORKERPIDSREQUEST = DESCRIPTOR.message_types_by_name['GetWorkerPIDsRequest'] +_GETWORKERPIDSREPLY = DESCRIPTOR.message_types_by_name['GetWorkerPIDsReply'] +_KILLLOCALACTORREQUEST = DESCRIPTOR.message_types_by_name['KillLocalActorRequest'] +_KILLLOCALACTORREPLY = DESCRIPTOR.message_types_by_name['KillLocalActorReply'] +_REQUESTWORKERLEASEREPLY_SCHEDULINGFAILURETYPE = _REQUESTWORKERLEASEREPLY.enum_types_by_name['SchedulingFailureType'] +WorkerBacklogReport = _reflection.GeneratedProtocolMessageType('WorkerBacklogReport', (_message.Message,), { + 'DESCRIPTOR' : _WORKERBACKLOGREPORT, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerBacklogReport) + }) +_sym_db.RegisterMessage(WorkerBacklogReport) + +ReportWorkerBacklogRequest = _reflection.GeneratedProtocolMessageType('ReportWorkerBacklogRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTWORKERBACKLOGREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportWorkerBacklogRequest) + }) +_sym_db.RegisterMessage(ReportWorkerBacklogRequest) + +ReportWorkerBacklogReply = _reflection.GeneratedProtocolMessageType('ReportWorkerBacklogReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTWORKERBACKLOGREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportWorkerBacklogReply) + }) +_sym_db.RegisterMessage(ReportWorkerBacklogReply) + +RequestWorkerLeaseRequest = _reflection.GeneratedProtocolMessageType('RequestWorkerLeaseRequest', (_message.Message,), { + 'DESCRIPTOR' : _REQUESTWORKERLEASEREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RequestWorkerLeaseRequest) + }) +_sym_db.RegisterMessage(RequestWorkerLeaseRequest) + +RequestWorkerLeaseReply = _reflection.GeneratedProtocolMessageType('RequestWorkerLeaseReply', (_message.Message,), { + 'DESCRIPTOR' : _REQUESTWORKERLEASEREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RequestWorkerLeaseReply) + }) +_sym_db.RegisterMessage(RequestWorkerLeaseReply) + +PrestartWorkersRequest = _reflection.GeneratedProtocolMessageType('PrestartWorkersRequest', (_message.Message,), { + 'DESCRIPTOR' : _PRESTARTWORKERSREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrestartWorkersRequest) + }) +_sym_db.RegisterMessage(PrestartWorkersRequest) + +PrestartWorkersReply = _reflection.GeneratedProtocolMessageType('PrestartWorkersReply', (_message.Message,), { + 'DESCRIPTOR' : _PRESTARTWORKERSREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrestartWorkersReply) + }) +_sym_db.RegisterMessage(PrestartWorkersReply) + +PrepareBundleResourcesRequest = _reflection.GeneratedProtocolMessageType('PrepareBundleResourcesRequest', (_message.Message,), { + 'DESCRIPTOR' : _PREPAREBUNDLERESOURCESREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrepareBundleResourcesRequest) + }) +_sym_db.RegisterMessage(PrepareBundleResourcesRequest) + +PrepareBundleResourcesReply = _reflection.GeneratedProtocolMessageType('PrepareBundleResourcesReply', (_message.Message,), { + 'DESCRIPTOR' : _PREPAREBUNDLERESOURCESREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrepareBundleResourcesReply) + }) +_sym_db.RegisterMessage(PrepareBundleResourcesReply) + +CommitBundleResourcesRequest = _reflection.GeneratedProtocolMessageType('CommitBundleResourcesRequest', (_message.Message,), { + 'DESCRIPTOR' : _COMMITBUNDLERESOURCESREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CommitBundleResourcesRequest) + }) +_sym_db.RegisterMessage(CommitBundleResourcesRequest) + +CommitBundleResourcesReply = _reflection.GeneratedProtocolMessageType('CommitBundleResourcesReply', (_message.Message,), { + 'DESCRIPTOR' : _COMMITBUNDLERESOURCESREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CommitBundleResourcesReply) + }) +_sym_db.RegisterMessage(CommitBundleResourcesReply) + +CancelResourceReserveRequest = _reflection.GeneratedProtocolMessageType('CancelResourceReserveRequest', (_message.Message,), { + 'DESCRIPTOR' : _CANCELRESOURCERESERVEREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelResourceReserveRequest) + }) +_sym_db.RegisterMessage(CancelResourceReserveRequest) + +CancelResourceReserveReply = _reflection.GeneratedProtocolMessageType('CancelResourceReserveReply', (_message.Message,), { + 'DESCRIPTOR' : _CANCELRESOURCERESERVEREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelResourceReserveReply) + }) +_sym_db.RegisterMessage(CancelResourceReserveReply) + +ResizeLocalResourceInstancesRequest = _reflection.GeneratedProtocolMessageType('ResizeLocalResourceInstancesRequest', (_message.Message,), { + + 'ResourcesEntry' : _reflection.GeneratedProtocolMessageType('ResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResizeLocalResourceInstancesRequest.ResourcesEntry) + }) + , + 'DESCRIPTOR' : _RESIZELOCALRESOURCEINSTANCESREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResizeLocalResourceInstancesRequest) + }) +_sym_db.RegisterMessage(ResizeLocalResourceInstancesRequest) +_sym_db.RegisterMessage(ResizeLocalResourceInstancesRequest.ResourcesEntry) + +ResizeLocalResourceInstancesReply = _reflection.GeneratedProtocolMessageType('ResizeLocalResourceInstancesReply', (_message.Message,), { + + 'TotalResourcesEntry' : _reflection.GeneratedProtocolMessageType('TotalResourcesEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResizeLocalResourceInstancesReply.TotalResourcesEntry) + }) + , + 'DESCRIPTOR' : _RESIZELOCALRESOURCEINSTANCESREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ResizeLocalResourceInstancesReply) + }) +_sym_db.RegisterMessage(ResizeLocalResourceInstancesReply) +_sym_db.RegisterMessage(ResizeLocalResourceInstancesReply.TotalResourcesEntry) + +ReturnWorkerLeaseRequest = _reflection.GeneratedProtocolMessageType('ReturnWorkerLeaseRequest', (_message.Message,), { + 'DESCRIPTOR' : _RETURNWORKERLEASEREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReturnWorkerLeaseRequest) + }) +_sym_db.RegisterMessage(ReturnWorkerLeaseRequest) + +ReturnWorkerLeaseReply = _reflection.GeneratedProtocolMessageType('ReturnWorkerLeaseReply', (_message.Message,), { + 'DESCRIPTOR' : _RETURNWORKERLEASEREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReturnWorkerLeaseReply) + }) +_sym_db.RegisterMessage(ReturnWorkerLeaseReply) + +ReleaseUnusedActorWorkersRequest = _reflection.GeneratedProtocolMessageType('ReleaseUnusedActorWorkersRequest', (_message.Message,), { + 'DESCRIPTOR' : _RELEASEUNUSEDACTORWORKERSREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseUnusedActorWorkersRequest) + }) +_sym_db.RegisterMessage(ReleaseUnusedActorWorkersRequest) + +ReleaseUnusedActorWorkersReply = _reflection.GeneratedProtocolMessageType('ReleaseUnusedActorWorkersReply', (_message.Message,), { + 'DESCRIPTOR' : _RELEASEUNUSEDACTORWORKERSREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseUnusedActorWorkersReply) + }) +_sym_db.RegisterMessage(ReleaseUnusedActorWorkersReply) + +ShutdownRayletRequest = _reflection.GeneratedProtocolMessageType('ShutdownRayletRequest', (_message.Message,), { + 'DESCRIPTOR' : _SHUTDOWNRAYLETREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ShutdownRayletRequest) + }) +_sym_db.RegisterMessage(ShutdownRayletRequest) + +ShutdownRayletReply = _reflection.GeneratedProtocolMessageType('ShutdownRayletReply', (_message.Message,), { + 'DESCRIPTOR' : _SHUTDOWNRAYLETREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ShutdownRayletReply) + }) +_sym_db.RegisterMessage(ShutdownRayletReply) + +CancelWorkerLeaseRequest = _reflection.GeneratedProtocolMessageType('CancelWorkerLeaseRequest', (_message.Message,), { + 'DESCRIPTOR' : _CANCELWORKERLEASEREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelWorkerLeaseRequest) + }) +_sym_db.RegisterMessage(CancelWorkerLeaseRequest) + +CancelWorkerLeaseReply = _reflection.GeneratedProtocolMessageType('CancelWorkerLeaseReply', (_message.Message,), { + 'DESCRIPTOR' : _CANCELWORKERLEASEREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelWorkerLeaseReply) + }) +_sym_db.RegisterMessage(CancelWorkerLeaseReply) + +PinObjectIDsRequest = _reflection.GeneratedProtocolMessageType('PinObjectIDsRequest', (_message.Message,), { + 'DESCRIPTOR' : _PINOBJECTIDSREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PinObjectIDsRequest) + }) +_sym_db.RegisterMessage(PinObjectIDsRequest) + +PinObjectIDsReply = _reflection.GeneratedProtocolMessageType('PinObjectIDsReply', (_message.Message,), { + 'DESCRIPTOR' : _PINOBJECTIDSREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PinObjectIDsReply) + }) +_sym_db.RegisterMessage(PinObjectIDsReply) + +GetNodeStatsRequest = _reflection.GeneratedProtocolMessageType('GetNodeStatsRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETNODESTATSREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNodeStatsRequest) + }) +_sym_db.RegisterMessage(GetNodeStatsRequest) + +ObjectStoreStats = _reflection.GeneratedProtocolMessageType('ObjectStoreStats', (_message.Message,), { + 'DESCRIPTOR' : _OBJECTSTORESTATS, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ObjectStoreStats) + }) +_sym_db.RegisterMessage(ObjectStoreStats) + +GetNodeStatsReply = _reflection.GeneratedProtocolMessageType('GetNodeStatsReply', (_message.Message,), { + 'DESCRIPTOR' : _GETNODESTATSREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetNodeStatsReply) + }) +_sym_db.RegisterMessage(GetNodeStatsReply) + +GlobalGCRequest = _reflection.GeneratedProtocolMessageType('GlobalGCRequest', (_message.Message,), { + 'DESCRIPTOR' : _GLOBALGCREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GlobalGCRequest) + }) +_sym_db.RegisterMessage(GlobalGCRequest) + +GlobalGCReply = _reflection.GeneratedProtocolMessageType('GlobalGCReply', (_message.Message,), { + 'DESCRIPTOR' : _GLOBALGCREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GlobalGCReply) + }) +_sym_db.RegisterMessage(GlobalGCReply) + +FormatGlobalMemoryInfoRequest = _reflection.GeneratedProtocolMessageType('FormatGlobalMemoryInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _FORMATGLOBALMEMORYINFOREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FormatGlobalMemoryInfoRequest) + }) +_sym_db.RegisterMessage(FormatGlobalMemoryInfoRequest) + +FormatGlobalMemoryInfoReply = _reflection.GeneratedProtocolMessageType('FormatGlobalMemoryInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _FORMATGLOBALMEMORYINFOREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FormatGlobalMemoryInfoReply) + }) +_sym_db.RegisterMessage(FormatGlobalMemoryInfoReply) + +ReleaseUnusedBundlesRequest = _reflection.GeneratedProtocolMessageType('ReleaseUnusedBundlesRequest', (_message.Message,), { + 'DESCRIPTOR' : _RELEASEUNUSEDBUNDLESREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseUnusedBundlesRequest) + }) +_sym_db.RegisterMessage(ReleaseUnusedBundlesRequest) + +ReleaseUnusedBundlesReply = _reflection.GeneratedProtocolMessageType('ReleaseUnusedBundlesReply', (_message.Message,), { + 'DESCRIPTOR' : _RELEASEUNUSEDBUNDLESREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseUnusedBundlesReply) + }) +_sym_db.RegisterMessage(ReleaseUnusedBundlesReply) + +GetSystemConfigRequest = _reflection.GeneratedProtocolMessageType('GetSystemConfigRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETSYSTEMCONFIGREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetSystemConfigRequest) + }) +_sym_db.RegisterMessage(GetSystemConfigRequest) + +GetSystemConfigReply = _reflection.GeneratedProtocolMessageType('GetSystemConfigReply', (_message.Message,), { + 'DESCRIPTOR' : _GETSYSTEMCONFIGREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetSystemConfigReply) + }) +_sym_db.RegisterMessage(GetSystemConfigReply) + +GetObjectsInfoRequest = _reflection.GeneratedProtocolMessageType('GetObjectsInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTSINFOREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectsInfoRequest) + }) +_sym_db.RegisterMessage(GetObjectsInfoRequest) + +GetObjectsInfoReply = _reflection.GeneratedProtocolMessageType('GetObjectsInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETOBJECTSINFOREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetObjectsInfoReply) + }) +_sym_db.RegisterMessage(GetObjectsInfoReply) + +GetResourceLoadRequest = _reflection.GeneratedProtocolMessageType('GetResourceLoadRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETRESOURCELOADREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetResourceLoadRequest) + }) +_sym_db.RegisterMessage(GetResourceLoadRequest) + +GetResourceLoadReply = _reflection.GeneratedProtocolMessageType('GetResourceLoadReply', (_message.Message,), { + 'DESCRIPTOR' : _GETRESOURCELOADREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetResourceLoadReply) + }) +_sym_db.RegisterMessage(GetResourceLoadReply) + +CancelLeasesWithResourceShapesRequest = _reflection.GeneratedProtocolMessageType('CancelLeasesWithResourceShapesRequest', (_message.Message,), { + + 'ResourceShape' : _reflection.GeneratedProtocolMessageType('ResourceShape', (_message.Message,), { + + 'ResourceShapeEntry' : _reflection.GeneratedProtocolMessageType('ResourceShapeEntry', (_message.Message,), { + 'DESCRIPTOR' : _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelLeasesWithResourceShapesRequest.ResourceShape.ResourceShapeEntry) + }) + , + 'DESCRIPTOR' : _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelLeasesWithResourceShapesRequest.ResourceShape) + }) + , + 'DESCRIPTOR' : _CANCELLEASESWITHRESOURCESHAPESREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelLeasesWithResourceShapesRequest) + }) +_sym_db.RegisterMessage(CancelLeasesWithResourceShapesRequest) +_sym_db.RegisterMessage(CancelLeasesWithResourceShapesRequest.ResourceShape) +_sym_db.RegisterMessage(CancelLeasesWithResourceShapesRequest.ResourceShape.ResourceShapeEntry) + +CancelLeasesWithResourceShapesReply = _reflection.GeneratedProtocolMessageType('CancelLeasesWithResourceShapesReply', (_message.Message,), { + 'DESCRIPTOR' : _CANCELLEASESWITHRESOURCESHAPESREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CancelLeasesWithResourceShapesReply) + }) +_sym_db.RegisterMessage(CancelLeasesWithResourceShapesReply) + +NotifyGCSRestartRequest = _reflection.GeneratedProtocolMessageType('NotifyGCSRestartRequest', (_message.Message,), { + 'DESCRIPTOR' : _NOTIFYGCSRESTARTREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NotifyGCSRestartRequest) + }) +_sym_db.RegisterMessage(NotifyGCSRestartRequest) + +NotifyGCSRestartReply = _reflection.GeneratedProtocolMessageType('NotifyGCSRestartReply', (_message.Message,), { + 'DESCRIPTOR' : _NOTIFYGCSRESTARTREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.NotifyGCSRestartReply) + }) +_sym_db.RegisterMessage(NotifyGCSRestartReply) + +GetWorkerFailureCauseRequest = _reflection.GeneratedProtocolMessageType('GetWorkerFailureCauseRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERFAILURECAUSEREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerFailureCauseRequest) + }) +_sym_db.RegisterMessage(GetWorkerFailureCauseRequest) + +GetWorkerFailureCauseReply = _reflection.GeneratedProtocolMessageType('GetWorkerFailureCauseReply', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERFAILURECAUSEREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerFailureCauseReply) + }) +_sym_db.RegisterMessage(GetWorkerFailureCauseReply) + +DrainRayletRequest = _reflection.GeneratedProtocolMessageType('DrainRayletRequest', (_message.Message,), { + 'DESCRIPTOR' : _DRAINRAYLETREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainRayletRequest) + }) +_sym_db.RegisterMessage(DrainRayletRequest) + +DrainRayletReply = _reflection.GeneratedProtocolMessageType('DrainRayletReply', (_message.Message,), { + 'DESCRIPTOR' : _DRAINRAYLETREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DrainRayletReply) + }) +_sym_db.RegisterMessage(DrainRayletReply) + +RegisterMutableObjectRequest = _reflection.GeneratedProtocolMessageType('RegisterMutableObjectRequest', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERMUTABLEOBJECTREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterMutableObjectRequest) + }) +_sym_db.RegisterMessage(RegisterMutableObjectRequest) + +RegisterMutableObjectReply = _reflection.GeneratedProtocolMessageType('RegisterMutableObjectReply', (_message.Message,), { + 'DESCRIPTOR' : _REGISTERMUTABLEOBJECTREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RegisterMutableObjectReply) + }) +_sym_db.RegisterMessage(RegisterMutableObjectReply) + +PushMutableObjectRequest = _reflection.GeneratedProtocolMessageType('PushMutableObjectRequest', (_message.Message,), { + 'DESCRIPTOR' : _PUSHMUTABLEOBJECTREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PushMutableObjectRequest) + }) +_sym_db.RegisterMessage(PushMutableObjectRequest) + +PushMutableObjectReply = _reflection.GeneratedProtocolMessageType('PushMutableObjectReply', (_message.Message,), { + 'DESCRIPTOR' : _PUSHMUTABLEOBJECTREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PushMutableObjectReply) + }) +_sym_db.RegisterMessage(PushMutableObjectReply) + +IsLocalWorkerDeadRequest = _reflection.GeneratedProtocolMessageType('IsLocalWorkerDeadRequest', (_message.Message,), { + 'DESCRIPTOR' : _ISLOCALWORKERDEADREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.IsLocalWorkerDeadRequest) + }) +_sym_db.RegisterMessage(IsLocalWorkerDeadRequest) + +IsLocalWorkerDeadReply = _reflection.GeneratedProtocolMessageType('IsLocalWorkerDeadReply', (_message.Message,), { + 'DESCRIPTOR' : _ISLOCALWORKERDEADREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.IsLocalWorkerDeadReply) + }) +_sym_db.RegisterMessage(IsLocalWorkerDeadReply) + +GetWorkerPIDsRequest = _reflection.GeneratedProtocolMessageType('GetWorkerPIDsRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERPIDSREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerPIDsRequest) + }) +_sym_db.RegisterMessage(GetWorkerPIDsRequest) + +GetWorkerPIDsReply = _reflection.GeneratedProtocolMessageType('GetWorkerPIDsReply', (_message.Message,), { + 'DESCRIPTOR' : _GETWORKERPIDSREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetWorkerPIDsReply) + }) +_sym_db.RegisterMessage(GetWorkerPIDsReply) + +KillLocalActorRequest = _reflection.GeneratedProtocolMessageType('KillLocalActorRequest', (_message.Message,), { + 'DESCRIPTOR' : _KILLLOCALACTORREQUEST, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillLocalActorRequest) + }) +_sym_db.RegisterMessage(KillLocalActorRequest) + +KillLocalActorReply = _reflection.GeneratedProtocolMessageType('KillLocalActorReply', (_message.Message,), { + 'DESCRIPTOR' : _KILLLOCALACTORREPLY, + '__module__' : 'src.ray.protobuf.node_manager_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KillLocalActorReply) + }) +_sym_db.RegisterMessage(KillLocalActorReply) + +_NODEMANAGERSERVICE = DESCRIPTOR.services_by_name['NodeManagerService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY._options = None + _RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY._serialized_options = b'8\001' + _RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY._options = None + _RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY._serialized_options = b'8\001' + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY._options = None + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY._serialized_options = b'8\001' + _WORKERBACKLOGREPORT._serialized_start=193 + _WORKERBACKLOGREPORT._serialized_end=300 + _REPORTWORKERBACKLOGREQUEST._serialized_start=303 + _REPORTWORKERBACKLOGREQUEST._serialized_end=431 + _REPORTWORKERBACKLOGREPLY._serialized_start=433 + _REPORTWORKERBACKLOGREPLY._serialized_end=459 + _REQUESTWORKERLEASEREQUEST._serialized_start=462 + _REQUESTWORKERLEASEREQUEST._serialized_end=681 + _REQUESTWORKERLEASEREPLY._serialized_start=684 + _REQUESTWORKERLEASEREPLY._serialized_end=1453 + _REQUESTWORKERLEASEREPLY_SCHEDULINGFAILURETYPE._serialized_start=1215 + _REQUESTWORKERLEASEREPLY_SCHEDULINGFAILURETYPE._serialized_end=1453 + _PRESTARTWORKERSREQUEST._serialized_start=1456 + _PRESTARTWORKERSREQUEST._serialized_end=1723 + _PRESTARTWORKERSREPLY._serialized_start=1725 + _PRESTARTWORKERSREPLY._serialized_end=1747 + _PREPAREBUNDLERESOURCESREQUEST._serialized_start=1749 + _PREPAREBUNDLERESOURCESREQUEST._serialized_end=1832 + _PREPAREBUNDLERESOURCESREPLY._serialized_start=1834 + _PREPAREBUNDLERESOURCESREPLY._serialized_end=1889 + _COMMITBUNDLERESOURCESREQUEST._serialized_start=1891 + _COMMITBUNDLERESOURCESREQUEST._serialized_end=1973 + _COMMITBUNDLERESOURCESREPLY._serialized_start=1975 + _COMMITBUNDLERESOURCESREPLY._serialized_end=2003 + _CANCELRESOURCERESERVEREQUEST._serialized_start=2005 + _CANCELRESOURCERESERVEREQUEST._serialized_end=2085 + _CANCELRESOURCERESERVEREPLY._serialized_start=2087 + _CANCELRESOURCERESERVEREPLY._serialized_end=2115 + _RESIZELOCALRESOURCEINSTANCESREQUEST._serialized_start=2118 + _RESIZELOCALRESOURCEINSTANCESREQUEST._serialized_end=2308 + _RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY._serialized_start=2248 + _RESIZELOCALRESOURCEINSTANCESREQUEST_RESOURCESENTRY._serialized_end=2308 + _RESIZELOCALRESOURCEINSTANCESREPLY._serialized_start=2311 + _RESIZELOCALRESOURCEINSTANCESREPLY._serialized_end=2518 + _RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY._serialized_start=2453 + _RESIZELOCALRESOURCEINSTANCESREPLY_TOTALRESOURCESENTRY._serialized_end=2518 + _RETURNWORKERLEASEREQUEST._serialized_start=2521 + _RETURNWORKERLEASEREQUEST._serialized_end=2760 + _RETURNWORKERLEASEREPLY._serialized_start=2762 + _RETURNWORKERLEASEREPLY._serialized_end=2786 + _RELEASEUNUSEDACTORWORKERSREQUEST._serialized_start=2788 + _RELEASEUNUSEDACTORWORKERSREQUEST._serialized_end=2865 + _RELEASEUNUSEDACTORWORKERSREPLY._serialized_start=2867 + _RELEASEUNUSEDACTORWORKERSREPLY._serialized_end=2899 + _SHUTDOWNRAYLETREQUEST._serialized_start=2901 + _SHUTDOWNRAYLETREQUEST._serialized_end=2952 + _SHUTDOWNRAYLETREPLY._serialized_start=2954 + _SHUTDOWNRAYLETREPLY._serialized_end=2975 + _CANCELWORKERLEASEREQUEST._serialized_start=2977 + _CANCELWORKERLEASEREQUEST._serialized_end=3030 + _CANCELWORKERLEASEREPLY._serialized_start=3032 + _CANCELWORKERLEASEREPLY._serialized_end=3082 + _PINOBJECTIDSREQUEST._serialized_start=3085 + _PINOBJECTIDSREQUEST._serialized_end=3249 + _PINOBJECTIDSREPLY._serialized_start=3251 + _PINOBJECTIDSREPLY._serialized_end=3300 + _GETNODESTATSREQUEST._serialized_start=3302 + _GETNODESTATSREQUEST._serialized_end=3371 + _OBJECTSTORESTATS._serialized_start=3374 + _OBJECTSTORESTATS._serialized_end=4217 + _GETNODESTATSREPLY._serialized_start=4220 + _GETNODESTATSREPLY._serialized_end=4404 + _GLOBALGCREQUEST._serialized_start=4406 + _GLOBALGCREQUEST._serialized_end=4423 + _GLOBALGCREPLY._serialized_start=4425 + _GLOBALGCREPLY._serialized_end=4440 + _FORMATGLOBALMEMORYINFOREQUEST._serialized_start=4442 + _FORMATGLOBALMEMORYINFOREQUEST._serialized_end=4521 + _FORMATGLOBALMEMORYINFOREPLY._serialized_start=4524 + _FORMATGLOBALMEMORYINFOREPLY._serialized_end=4652 + _RELEASEUNUSEDBUNDLESREQUEST._serialized_start=4654 + _RELEASEUNUSEDBUNDLESREQUEST._serialized_end=4738 + _RELEASEUNUSEDBUNDLESREPLY._serialized_start=4740 + _RELEASEUNUSEDBUNDLESREPLY._serialized_end=4767 + _GETSYSTEMCONFIGREQUEST._serialized_start=4769 + _GETSYSTEMCONFIGREQUEST._serialized_end=4793 + _GETSYSTEMCONFIGREPLY._serialized_start=4795 + _GETSYSTEMCONFIGREPLY._serialized_end=4854 + _GETOBJECTSINFOREQUEST._serialized_start=4856 + _GETOBJECTSINFOREQUEST._serialized_end=4916 + _GETOBJECTSINFOREPLY._serialized_start=4918 + _GETOBJECTSINFOREPLY._serialized_end=5033 + _GETRESOURCELOADREQUEST._serialized_start=5035 + _GETRESOURCELOADREQUEST._serialized_end=5059 + _GETRESOURCELOADREPLY._serialized_start=5061 + _GETRESOURCELOADREPLY._serialized_end=5137 + _CANCELLEASESWITHRESOURCESHAPESREQUEST._serialized_start=5140 + _CANCELLEASESWITHRESOURCESHAPESREQUEST._serialized_end=5486 + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE._serialized_start=5285 + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE._serialized_end=5486 + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY._serialized_start=5422 + _CANCELLEASESWITHRESOURCESHAPESREQUEST_RESOURCESHAPE_RESOURCESHAPEENTRY._serialized_end=5486 + _CANCELLEASESWITHRESOURCESHAPESREPLY._serialized_start=5488 + _CANCELLEASESWITHRESOURCESHAPESREPLY._serialized_end=5525 + _NOTIFYGCSRESTARTREQUEST._serialized_start=5527 + _NOTIFYGCSRESTARTREQUEST._serialized_end=5552 + _NOTIFYGCSRESTARTREPLY._serialized_start=5554 + _NOTIFYGCSRESTARTREPLY._serialized_end=5577 + _GETWORKERFAILURECAUSEREQUEST._serialized_start=5579 + _GETWORKERFAILURECAUSEREQUEST._serialized_end=5636 + _GETWORKERFAILURECAUSEREPLY._serialized_start=5639 + _GETWORKERFAILURECAUSEREPLY._serialized_end=5802 + _DRAINRAYLETREQUEST._serialized_start=5805 + _DRAINRAYLETREQUEST._serialized_end=5977 + _DRAINRAYLETREPLY._serialized_start=5979 + _DRAINRAYLETREPLY._serialized_end=6088 + _REGISTERMUTABLEOBJECTREQUEST._serialized_start=6091 + _REGISTERMUTABLEOBJECTREQUEST._serialized_end=6238 + _REGISTERMUTABLEOBJECTREPLY._serialized_start=6240 + _REGISTERMUTABLEOBJECTREPLY._serialized_end=6268 + _PUSHMUTABLEOBJECTREQUEST._serialized_start=6271 + _PUSHMUTABLEOBJECTREQUEST._serialized_end=6530 + _PUSHMUTABLEOBJECTREPLY._serialized_start=6532 + _PUSHMUTABLEOBJECTREPLY._serialized_end=6576 + _ISLOCALWORKERDEADREQUEST._serialized_start=6578 + _ISLOCALWORKERDEADREQUEST._serialized_end=6633 + _ISLOCALWORKERDEADREPLY._serialized_start=6635 + _ISLOCALWORKERDEADREPLY._serialized_end=6684 + _GETWORKERPIDSREQUEST._serialized_start=6686 + _GETWORKERPIDSREQUEST._serialized_end=6708 + _GETWORKERPIDSREPLY._serialized_start=6710 + _GETWORKERPIDSREPLY._serialized_end=6750 + _KILLLOCALACTORREQUEST._serialized_start=6753 + _KILLLOCALACTORREQUEST._serialized_end=6939 + _KILLLOCALACTORREPLY._serialized_start=6941 + _KILLLOCALACTORREPLY._serialized_end=6962 + _NODEMANAGERSERVICE._serialized_start=6965 + _NODEMANAGERSERVICE._serialized_end=9534 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..765a89b89f377d82e12c40e39cef54143b86b41a --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/node_manager_pb2_grpc.py @@ -0,0 +1,957 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import node_manager_pb2 as src_dot_ray_dot_protobuf_dot_node__manager__pb2 + + +class NodeManagerServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.NotifyGCSRestart = channel.unary_unary( + '/ray.rpc.NodeManagerService/NotifyGCSRestart', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartReply.FromString, + ) + self.GetResourceLoad = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetResourceLoad', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadReply.FromString, + ) + self.CancelLeasesWithResourceShapes = channel.unary_unary( + '/ray.rpc.NodeManagerService/CancelLeasesWithResourceShapes', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesReply.FromString, + ) + self.RequestWorkerLease = channel.unary_unary( + '/ray.rpc.NodeManagerService/RequestWorkerLease', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseReply.FromString, + ) + self.PrestartWorkers = channel.unary_unary( + '/ray.rpc.NodeManagerService/PrestartWorkers', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersReply.FromString, + ) + self.ReportWorkerBacklog = channel.unary_unary( + '/ray.rpc.NodeManagerService/ReportWorkerBacklog', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogReply.FromString, + ) + self.ReturnWorkerLease = channel.unary_unary( + '/ray.rpc.NodeManagerService/ReturnWorkerLease', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseReply.FromString, + ) + self.ReleaseUnusedActorWorkers = channel.unary_unary( + '/ray.rpc.NodeManagerService/ReleaseUnusedActorWorkers', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersReply.FromString, + ) + self.ShutdownRaylet = channel.unary_unary( + '/ray.rpc.NodeManagerService/ShutdownRaylet', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletReply.FromString, + ) + self.DrainRaylet = channel.unary_unary( + '/ray.rpc.NodeManagerService/DrainRaylet', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletReply.FromString, + ) + self.PrepareBundleResources = channel.unary_unary( + '/ray.rpc.NodeManagerService/PrepareBundleResources', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesReply.FromString, + ) + self.CommitBundleResources = channel.unary_unary( + '/ray.rpc.NodeManagerService/CommitBundleResources', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesReply.FromString, + ) + self.CancelResourceReserve = channel.unary_unary( + '/ray.rpc.NodeManagerService/CancelResourceReserve', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveReply.FromString, + ) + self.ResizeLocalResourceInstances = channel.unary_unary( + '/ray.rpc.NodeManagerService/ResizeLocalResourceInstances', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesReply.FromString, + ) + self.CancelWorkerLease = channel.unary_unary( + '/ray.rpc.NodeManagerService/CancelWorkerLease', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseReply.FromString, + ) + self.PinObjectIDs = channel.unary_unary( + '/ray.rpc.NodeManagerService/PinObjectIDs', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsReply.FromString, + ) + self.GetNodeStats = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetNodeStats', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsReply.FromString, + ) + self.GlobalGC = channel.unary_unary( + '/ray.rpc.NodeManagerService/GlobalGC', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCReply.FromString, + ) + self.FormatGlobalMemoryInfo = channel.unary_unary( + '/ray.rpc.NodeManagerService/FormatGlobalMemoryInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoReply.FromString, + ) + self.ReleaseUnusedBundles = channel.unary_unary( + '/ray.rpc.NodeManagerService/ReleaseUnusedBundles', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesReply.FromString, + ) + self.GetSystemConfig = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetSystemConfig', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigReply.FromString, + ) + self.GetObjectsInfo = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetObjectsInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoReply.FromString, + ) + self.GetWorkerFailureCause = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetWorkerFailureCause', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseReply.FromString, + ) + self.RegisterMutableObject = channel.unary_unary( + '/ray.rpc.NodeManagerService/RegisterMutableObject', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectReply.FromString, + ) + self.PushMutableObject = channel.unary_unary( + '/ray.rpc.NodeManagerService/PushMutableObject', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectReply.FromString, + ) + self.IsLocalWorkerDead = channel.unary_unary( + '/ray.rpc.NodeManagerService/IsLocalWorkerDead', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadReply.FromString, + ) + self.GetWorkerPIDs = channel.unary_unary( + '/ray.rpc.NodeManagerService/GetWorkerPIDs', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsReply.FromString, + ) + self.KillLocalActor = channel.unary_unary( + '/ray.rpc.NodeManagerService/KillLocalActor', + request_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorReply.FromString, + ) + + +class NodeManagerServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def NotifyGCSRestart(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetResourceLoad(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CancelLeasesWithResourceShapes(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RequestWorkerLease(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PrestartWorkers(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportWorkerBacklog(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReturnWorkerLease(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseUnusedActorWorkers(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShutdownRaylet(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DrainRaylet(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PrepareBundleResources(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CommitBundleResources(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CancelResourceReserve(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ResizeLocalResourceInstances(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CancelWorkerLease(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PinObjectIDs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetNodeStats(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GlobalGC(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FormatGlobalMemoryInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseUnusedBundles(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSystemConfig(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetObjectsInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetWorkerFailureCause(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterMutableObject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PushMutableObject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def IsLocalWorkerDead(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetWorkerPIDs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KillLocalActor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_NodeManagerServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'NotifyGCSRestart': grpc.unary_unary_rpc_method_handler( + servicer.NotifyGCSRestart, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartReply.SerializeToString, + ), + 'GetResourceLoad': grpc.unary_unary_rpc_method_handler( + servicer.GetResourceLoad, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadReply.SerializeToString, + ), + 'CancelLeasesWithResourceShapes': grpc.unary_unary_rpc_method_handler( + servicer.CancelLeasesWithResourceShapes, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesReply.SerializeToString, + ), + 'RequestWorkerLease': grpc.unary_unary_rpc_method_handler( + servicer.RequestWorkerLease, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseReply.SerializeToString, + ), + 'PrestartWorkers': grpc.unary_unary_rpc_method_handler( + servicer.PrestartWorkers, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersReply.SerializeToString, + ), + 'ReportWorkerBacklog': grpc.unary_unary_rpc_method_handler( + servicer.ReportWorkerBacklog, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogReply.SerializeToString, + ), + 'ReturnWorkerLease': grpc.unary_unary_rpc_method_handler( + servicer.ReturnWorkerLease, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseReply.SerializeToString, + ), + 'ReleaseUnusedActorWorkers': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseUnusedActorWorkers, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersReply.SerializeToString, + ), + 'ShutdownRaylet': grpc.unary_unary_rpc_method_handler( + servicer.ShutdownRaylet, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletReply.SerializeToString, + ), + 'DrainRaylet': grpc.unary_unary_rpc_method_handler( + servicer.DrainRaylet, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletReply.SerializeToString, + ), + 'PrepareBundleResources': grpc.unary_unary_rpc_method_handler( + servicer.PrepareBundleResources, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesReply.SerializeToString, + ), + 'CommitBundleResources': grpc.unary_unary_rpc_method_handler( + servicer.CommitBundleResources, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesReply.SerializeToString, + ), + 'CancelResourceReserve': grpc.unary_unary_rpc_method_handler( + servicer.CancelResourceReserve, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveReply.SerializeToString, + ), + 'ResizeLocalResourceInstances': grpc.unary_unary_rpc_method_handler( + servicer.ResizeLocalResourceInstances, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesReply.SerializeToString, + ), + 'CancelWorkerLease': grpc.unary_unary_rpc_method_handler( + servicer.CancelWorkerLease, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseReply.SerializeToString, + ), + 'PinObjectIDs': grpc.unary_unary_rpc_method_handler( + servicer.PinObjectIDs, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsReply.SerializeToString, + ), + 'GetNodeStats': grpc.unary_unary_rpc_method_handler( + servicer.GetNodeStats, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsReply.SerializeToString, + ), + 'GlobalGC': grpc.unary_unary_rpc_method_handler( + servicer.GlobalGC, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCReply.SerializeToString, + ), + 'FormatGlobalMemoryInfo': grpc.unary_unary_rpc_method_handler( + servicer.FormatGlobalMemoryInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoReply.SerializeToString, + ), + 'ReleaseUnusedBundles': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseUnusedBundles, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesReply.SerializeToString, + ), + 'GetSystemConfig': grpc.unary_unary_rpc_method_handler( + servicer.GetSystemConfig, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigReply.SerializeToString, + ), + 'GetObjectsInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetObjectsInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoReply.SerializeToString, + ), + 'GetWorkerFailureCause': grpc.unary_unary_rpc_method_handler( + servicer.GetWorkerFailureCause, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseReply.SerializeToString, + ), + 'RegisterMutableObject': grpc.unary_unary_rpc_method_handler( + servicer.RegisterMutableObject, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectReply.SerializeToString, + ), + 'PushMutableObject': grpc.unary_unary_rpc_method_handler( + servicer.PushMutableObject, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectReply.SerializeToString, + ), + 'IsLocalWorkerDead': grpc.unary_unary_rpc_method_handler( + servicer.IsLocalWorkerDead, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadReply.SerializeToString, + ), + 'GetWorkerPIDs': grpc.unary_unary_rpc_method_handler( + servicer.GetWorkerPIDs, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsReply.SerializeToString, + ), + 'KillLocalActor': grpc.unary_unary_rpc_method_handler( + servicer.KillLocalActor, + request_deserializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.NodeManagerService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class NodeManagerService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def NotifyGCSRestart(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/NotifyGCSRestart', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.NotifyGCSRestartReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetResourceLoad(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetResourceLoad', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetResourceLoadReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CancelLeasesWithResourceShapes(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/CancelLeasesWithResourceShapes', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelLeasesWithResourceShapesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RequestWorkerLease(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/RequestWorkerLease', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.RequestWorkerLeaseReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PrestartWorkers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/PrestartWorkers', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrestartWorkersReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportWorkerBacklog(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ReportWorkerBacklog', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReportWorkerBacklogReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReturnWorkerLease(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ReturnWorkerLease', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReturnWorkerLeaseReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseUnusedActorWorkers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ReleaseUnusedActorWorkers', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedActorWorkersReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShutdownRaylet(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ShutdownRaylet', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ShutdownRayletReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DrainRaylet(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/DrainRaylet', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.DrainRayletReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PrepareBundleResources(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/PrepareBundleResources', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PrepareBundleResourcesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CommitBundleResources(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/CommitBundleResources', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CommitBundleResourcesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CancelResourceReserve(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/CancelResourceReserve', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelResourceReserveReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ResizeLocalResourceInstances(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ResizeLocalResourceInstances', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ResizeLocalResourceInstancesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CancelWorkerLease(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/CancelWorkerLease', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.CancelWorkerLeaseReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PinObjectIDs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/PinObjectIDs', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PinObjectIDsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetNodeStats(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetNodeStats', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetNodeStatsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GlobalGC(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GlobalGC', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GlobalGCReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def FormatGlobalMemoryInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/FormatGlobalMemoryInfo', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.FormatGlobalMemoryInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseUnusedBundles(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/ReleaseUnusedBundles', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.ReleaseUnusedBundlesReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSystemConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetSystemConfig', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetSystemConfigReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetObjectsInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetObjectsInfo', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetObjectsInfoReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetWorkerFailureCause(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetWorkerFailureCause', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerFailureCauseReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RegisterMutableObject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/RegisterMutableObject', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.RegisterMutableObjectReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PushMutableObject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/PushMutableObject', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.PushMutableObjectReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def IsLocalWorkerDead(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/IsLocalWorkerDead', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.IsLocalWorkerDeadReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetWorkerPIDs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/GetWorkerPIDs', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.GetWorkerPIDsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KillLocalActor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.NodeManagerService/KillLocalActor', + src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_node__manager__pb2.KillLocalActorReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2.py b/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..0a503cd01fc6635fc5c8a7b48f53e94da3c90a07 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/profile_events.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%src/ray/protobuf/profile_events.proto\x12\x07ray.rpc\"\x9f\x01\n\x11ProfileEventEntry\x12\x1d\n\nstart_time\x18\x01 \x01(\x03R\tstartTime\x12\x19\n\x08\x65nd_time\x18\x02 \x01(\x03R\x07\x65ndTime\x12\"\n\nextra_data\x18\x03 \x01(\tH\x00R\textraData\x88\x01\x01\x12\x1d\n\nevent_name\x18\x04 \x01(\tR\teventNameB\r\n\x0b_extra_data\"\xb5\x01\n\rProfileEvents\x12%\n\x0e\x63omponent_type\x18\x01 \x01(\tR\rcomponentType\x12!\n\x0c\x63omponent_id\x18\x02 \x01(\x0cR\x0b\x63omponentId\x12&\n\x0fnode_ip_address\x18\x03 \x01(\tR\rnodeIpAddress\x12\x32\n\x06\x65vents\x18\x04 \x03(\x0b\x32\x1a.ray.rpc.ProfileEventEntryR\x06\x65ventsB\x1a\n\x18io.ray.runtime.generatedb\x06proto3') + + + +_PROFILEEVENTENTRY = DESCRIPTOR.message_types_by_name['ProfileEventEntry'] +_PROFILEEVENTS = DESCRIPTOR.message_types_by_name['ProfileEvents'] +ProfileEventEntry = _reflection.GeneratedProtocolMessageType('ProfileEventEntry', (_message.Message,), { + 'DESCRIPTOR' : _PROFILEEVENTENTRY, + '__module__' : 'src.ray.protobuf.profile_events_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ProfileEventEntry) + }) +_sym_db.RegisterMessage(ProfileEventEntry) + +ProfileEvents = _reflection.GeneratedProtocolMessageType('ProfileEvents', (_message.Message,), { + 'DESCRIPTOR' : _PROFILEEVENTS, + '__module__' : 'src.ray.protobuf.profile_events_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ProfileEvents) + }) +_sym_db.RegisterMessage(ProfileEvents) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\030io.ray.runtime.generated' + _PROFILEEVENTENTRY._serialized_start=51 + _PROFILEEVENTENTRY._serialized_end=210 + _PROFILEEVENTS._serialized_start=213 + _PROFILEEVENTS._serialized_end=394 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/profile_events_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2.py b/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..496b4cf53b8aed785dbad6ba1fb4822ab4aa0f72 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2.py @@ -0,0 +1,196 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/pubsub.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as src_dot_ray_dot_protobuf_dot_common__pb2 +from . import gcs_pb2 as src_dot_ray_dot_protobuf_dot_gcs__pb2 +from . import logging_pb2 as src_dot_ray_dot_protobuf_dot_logging__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dsrc/ray/protobuf/pubsub.proto\x12\x07ray.rpc\x1a\x1dsrc/ray/protobuf/common.proto\x1a\x1asrc/ray/protobuf/gcs.proto\x1a\x1esrc/ray/protobuf/logging.proto\"\xf6\x08\n\nPubMessage\x12\x37\n\x0c\x63hannel_type\x18\x01 \x01(\x0e\x32\x14.ray.rpc.ChannelTypeR\x0b\x63hannelType\x12\x15\n\x06key_id\x18\x02 \x01(\x0cR\x05keyId\x12k\n\x1eworker_object_eviction_message\x18\x03 \x01(\x0b\x32$.ray.rpc.WorkerObjectEvictionMessageH\x00R\x1bworkerObjectEvictionMessage\x12_\n\x1aworker_ref_removed_message\x18\x04 \x01(\x0b\x32 .ray.rpc.WorkerRefRemovedMessageH\x00R\x17workerRefRemovedMessage\x12q\n\x1fworker_object_locations_message\x18\x05 \x01(\x0b\x32(.ray.rpc.WorkerObjectLocationsPubMessageH\x00R\x1cworkerObjectLocationsMessage\x12\x42\n\x0f\x66\x61ilure_message\x18\x06 \x01(\x0b\x32\x17.ray.rpc.FailureMessageH\x00R\x0e\x66\x61ilureMessage\x12>\n\ractor_message\x18\x07 \x01(\x0b\x32\x17.ray.rpc.ActorTableDataH\x00R\x0c\x61\x63torMessage\x12\x38\n\x0bjob_message\x18\x08 \x01(\x0b\x32\x15.ray.rpc.JobTableDataH\x00R\njobMessage\x12\x42\n\x11node_info_message\x18\t \x01(\x0b\x32\x14.ray.rpc.GcsNodeInfoH\x00R\x0fnodeInfoMessage\x12L\n\x14worker_delta_message\x18\n \x01(\x0b\x32\x18.ray.rpc.WorkerDeltaDataH\x00R\x12workerDeltaMessage\x12G\n\x12\x65rror_info_message\x18\x0b \x01(\x0b\x32\x17.ray.rpc.ErrorTableDataH\x00R\x10\x65rrorInfoMessage\x12?\n\x11log_batch_message\x18\x0c \x01(\x0b\x32\x11.ray.rpc.LogBatchH\x00R\x0flogBatchMessage\x12[\n\x1bnode_resource_usage_message\x18\r \x01(\x0b\x32\x1a.ray.rpc.NodeResourceUsageH\x00R\x18nodeResourceUsageMessage\x12n\n!node_address_and_liveness_message\x18\x0e \x01(\x0b\x32\".ray.rpc.GcsNodeAddressAndLivenessH\x00R\x1dnodeAddressAndLivenessMessage\x12\x1f\n\x0bsequence_id\x18\x0f \x01(\x03R\nsequenceIdB\x0f\n\rinner_message\":\n\x1bWorkerObjectEvictionMessage\x12\x1b\n\tobject_id\x18\x01 \x01(\x0cR\x08objectId\"]\n\x17WorkerRefRemovedMessage\x12\x42\n\rborrowed_refs\x18\x01 \x03(\x0b\x32\x1d.ray.rpc.ObjectReferenceCountR\x0c\x62orrowedRefs\"\xb7\x02\n\x1fWorkerObjectLocationsPubMessage\x12\x19\n\x08node_ids\x18\x01 \x03(\x0cR\x07nodeIds\x12\x1f\n\x0bobject_size\x18\x02 \x01(\x04R\nobjectSize\x12\x1f\n\x0bspilled_url\x18\x03 \x01(\tR\nspilledUrl\x12&\n\x0fspilled_node_id\x18\x04 \x01(\x0cR\rspilledNodeId\x12&\n\x0fprimary_node_id\x18\x06 \x01(\x0cR\rprimaryNodeId\x12\x1f\n\x0bref_removed\x18\x07 \x01(\x08R\nrefRemoved\x12)\n\x10pending_creation\x18\x08 \x01(\x08R\x0fpendingCreation\x12\x1b\n\tdid_spill\x18\t \x01(\x08R\x08\x64idSpill\"\x10\n\x0e\x46\x61ilureMessage\"\x87\x02\n\x07\x43ommand\x12\x37\n\x0c\x63hannel_type\x18\x01 \x01(\x0e\x32\x14.ray.rpc.ChannelTypeR\x0b\x63hannelType\x12\x15\n\x06key_id\x18\x02 \x01(\x0cR\x05keyId\x12N\n\x13unsubscribe_message\x18\x03 \x01(\x0b\x32\x1b.ray.rpc.UnsubscribeMessageH\x00R\x12unsubscribeMessage\x12\x42\n\x11subscribe_message\x18\x04 \x01(\x0b\x32\x13.ray.rpc.SubMessageH\x00R\x10subscribeMessageB\x18\n\x16\x63ommand_message_one_of\"\x14\n\x12UnsubscribeMessage\"\xe9\x02\n\nSubMessage\x12n\n\x1eworker_object_eviction_message\x18\x01 \x01(\x0b\x32\'.ray.rpc.WorkerObjectEvictionSubMessageH\x00R\x1bworkerObjectEvictionMessage\x12\x62\n\x1aworker_ref_removed_message\x18\x02 \x01(\x0b\x32#.ray.rpc.WorkerRefRemovedSubMessageH\x00R\x17workerRefRemovedMessage\x12q\n\x1fworker_object_locations_message\x18\x03 \x01(\x0b\x32(.ray.rpc.WorkerObjectLocationsSubMessageH\x00R\x1cworkerObjectLocationsMessageB\x14\n\x12sub_message_one_of\"\xe5\x01\n\x1eWorkerObjectEvictionSubMessage\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x1b\n\tobject_id\x18\x02 \x01(\x0cR\x08objectId\x12?\n\x12subscriber_address\x18\x03 \x01(\x0b\x32\x10.ray.rpc.AddressR\x11subscriberAddress\x12&\n\x0cgenerator_id\x18\x04 \x01(\x0cH\x00R\x0bgeneratorId\x88\x01\x01\x42\x0f\n\r_generator_id\"\xdc\x01\n\x1aWorkerRefRemovedSubMessage\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x36\n\treference\x18\x02 \x01(\x0b\x32\x18.ray.rpc.ObjectReferenceR\treference\x12&\n\x0f\x63ontained_in_id\x18\x03 \x01(\x0cR\rcontainedInId\x12\x30\n\x14subscriber_worker_id\x18\x04 \x01(\x0cR\x12subscriberWorkerId\"l\n\x1fWorkerObjectLocationsSubMessage\x12,\n\x12intended_worker_id\x18\x01 \x01(\x0cR\x10intendedWorkerId\x12\x1b\n\tobject_id\x18\x02 \x01(\x0cR\x08objectId\"\x9d\x01\n\x18PubsubLongPollingRequest\x12#\n\rsubscriber_id\x18\x01 \x01(\x0cR\x0csubscriberId\x12\x39\n\x19max_processed_sequence_id\x18\x02 \x01(\x03R\x16maxProcessedSequenceId\x12!\n\x0cpublisher_id\x18\x03 \x01(\x0cR\x0bpublisherId\"s\n\x16PubsubLongPollingReply\x12\x36\n\x0cpub_messages\x18\x01 \x03(\x0b\x32\x13.ray.rpc.PubMessageR\x0bpubMessages\x12!\n\x0cpublisher_id\x18\x02 \x01(\x0cR\x0bpublisherId\"n\n\x19PubsubCommandBatchRequest\x12#\n\rsubscriber_id\x18\x01 \x01(\x0cR\x0csubscriberId\x12,\n\x08\x63ommands\x18\x02 \x03(\x0b\x32\x10.ray.rpc.CommandR\x08\x63ommands\"\x19\n\x17PubsubCommandBatchReply*\xd4\x02\n\x0b\x43hannelType\x12\x1a\n\x16WORKER_OBJECT_EVICTION\x10\x00\x12\x1e\n\x1aWORKER_REF_REMOVED_CHANNEL\x10\x01\x12#\n\x1fWORKER_OBJECT_LOCATIONS_CHANNEL\x10\x02\x12\x15\n\x11GCS_ACTOR_CHANNEL\x10\x03\x12\x13\n\x0fGCS_JOB_CHANNEL\x10\x04\x12\x19\n\x15GCS_NODE_INFO_CHANNEL\x10\x05\x12\x1c\n\x18GCS_WORKER_DELTA_CHANNEL\x10\x06\x12\x1a\n\x16RAY_ERROR_INFO_CHANNEL\x10\x07\x12\x13\n\x0fRAY_LOG_CHANNEL\x10\x08\x12#\n\x1fRAY_NODE_RESOURCE_USAGE_CHANNEL\x10\t\x12)\n%GCS_NODE_ADDRESS_AND_LIVENESS_CHANNEL\x10\n2\xc8\x01\n\x11SubscriberService\x12W\n\x11PubsubLongPolling\x12!.ray.rpc.PubsubLongPollingRequest\x1a\x1f.ray.rpc.PubsubLongPollingReply\x12Z\n\x12PubsubCommandBatch\x12\".ray.rpc.PubsubCommandBatchRequest\x1a .ray.rpc.PubsubCommandBatchReplyb\x06proto3') + +_CHANNELTYPE = DESCRIPTOR.enum_types_by_name['ChannelType'] +ChannelType = enum_type_wrapper.EnumTypeWrapper(_CHANNELTYPE) +WORKER_OBJECT_EVICTION = 0 +WORKER_REF_REMOVED_CHANNEL = 1 +WORKER_OBJECT_LOCATIONS_CHANNEL = 2 +GCS_ACTOR_CHANNEL = 3 +GCS_JOB_CHANNEL = 4 +GCS_NODE_INFO_CHANNEL = 5 +GCS_WORKER_DELTA_CHANNEL = 6 +RAY_ERROR_INFO_CHANNEL = 7 +RAY_LOG_CHANNEL = 8 +RAY_NODE_RESOURCE_USAGE_CHANNEL = 9 +GCS_NODE_ADDRESS_AND_LIVENESS_CHANNEL = 10 + + +_PUBMESSAGE = DESCRIPTOR.message_types_by_name['PubMessage'] +_WORKEROBJECTEVICTIONMESSAGE = DESCRIPTOR.message_types_by_name['WorkerObjectEvictionMessage'] +_WORKERREFREMOVEDMESSAGE = DESCRIPTOR.message_types_by_name['WorkerRefRemovedMessage'] +_WORKEROBJECTLOCATIONSPUBMESSAGE = DESCRIPTOR.message_types_by_name['WorkerObjectLocationsPubMessage'] +_FAILUREMESSAGE = DESCRIPTOR.message_types_by_name['FailureMessage'] +_COMMAND = DESCRIPTOR.message_types_by_name['Command'] +_UNSUBSCRIBEMESSAGE = DESCRIPTOR.message_types_by_name['UnsubscribeMessage'] +_SUBMESSAGE = DESCRIPTOR.message_types_by_name['SubMessage'] +_WORKEROBJECTEVICTIONSUBMESSAGE = DESCRIPTOR.message_types_by_name['WorkerObjectEvictionSubMessage'] +_WORKERREFREMOVEDSUBMESSAGE = DESCRIPTOR.message_types_by_name['WorkerRefRemovedSubMessage'] +_WORKEROBJECTLOCATIONSSUBMESSAGE = DESCRIPTOR.message_types_by_name['WorkerObjectLocationsSubMessage'] +_PUBSUBLONGPOLLINGREQUEST = DESCRIPTOR.message_types_by_name['PubsubLongPollingRequest'] +_PUBSUBLONGPOLLINGREPLY = DESCRIPTOR.message_types_by_name['PubsubLongPollingReply'] +_PUBSUBCOMMANDBATCHREQUEST = DESCRIPTOR.message_types_by_name['PubsubCommandBatchRequest'] +_PUBSUBCOMMANDBATCHREPLY = DESCRIPTOR.message_types_by_name['PubsubCommandBatchReply'] +PubMessage = _reflection.GeneratedProtocolMessageType('PubMessage', (_message.Message,), { + 'DESCRIPTOR' : _PUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubMessage) + }) +_sym_db.RegisterMessage(PubMessage) + +WorkerObjectEvictionMessage = _reflection.GeneratedProtocolMessageType('WorkerObjectEvictionMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKEROBJECTEVICTIONMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerObjectEvictionMessage) + }) +_sym_db.RegisterMessage(WorkerObjectEvictionMessage) + +WorkerRefRemovedMessage = _reflection.GeneratedProtocolMessageType('WorkerRefRemovedMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKERREFREMOVEDMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerRefRemovedMessage) + }) +_sym_db.RegisterMessage(WorkerRefRemovedMessage) + +WorkerObjectLocationsPubMessage = _reflection.GeneratedProtocolMessageType('WorkerObjectLocationsPubMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKEROBJECTLOCATIONSPUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerObjectLocationsPubMessage) + }) +_sym_db.RegisterMessage(WorkerObjectLocationsPubMessage) + +FailureMessage = _reflection.GeneratedProtocolMessageType('FailureMessage', (_message.Message,), { + 'DESCRIPTOR' : _FAILUREMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.FailureMessage) + }) +_sym_db.RegisterMessage(FailureMessage) + +Command = _reflection.GeneratedProtocolMessageType('Command', (_message.Message,), { + 'DESCRIPTOR' : _COMMAND, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Command) + }) +_sym_db.RegisterMessage(Command) + +UnsubscribeMessage = _reflection.GeneratedProtocolMessageType('UnsubscribeMessage', (_message.Message,), { + 'DESCRIPTOR' : _UNSUBSCRIBEMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.UnsubscribeMessage) + }) +_sym_db.RegisterMessage(UnsubscribeMessage) + +SubMessage = _reflection.GeneratedProtocolMessageType('SubMessage', (_message.Message,), { + 'DESCRIPTOR' : _SUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.SubMessage) + }) +_sym_db.RegisterMessage(SubMessage) + +WorkerObjectEvictionSubMessage = _reflection.GeneratedProtocolMessageType('WorkerObjectEvictionSubMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKEROBJECTEVICTIONSUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerObjectEvictionSubMessage) + }) +_sym_db.RegisterMessage(WorkerObjectEvictionSubMessage) + +WorkerRefRemovedSubMessage = _reflection.GeneratedProtocolMessageType('WorkerRefRemovedSubMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKERREFREMOVEDSUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerRefRemovedSubMessage) + }) +_sym_db.RegisterMessage(WorkerRefRemovedSubMessage) + +WorkerObjectLocationsSubMessage = _reflection.GeneratedProtocolMessageType('WorkerObjectLocationsSubMessage', (_message.Message,), { + 'DESCRIPTOR' : _WORKEROBJECTLOCATIONSSUBMESSAGE, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WorkerObjectLocationsSubMessage) + }) +_sym_db.RegisterMessage(WorkerObjectLocationsSubMessage) + +PubsubLongPollingRequest = _reflection.GeneratedProtocolMessageType('PubsubLongPollingRequest', (_message.Message,), { + 'DESCRIPTOR' : _PUBSUBLONGPOLLINGREQUEST, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubsubLongPollingRequest) + }) +_sym_db.RegisterMessage(PubsubLongPollingRequest) + +PubsubLongPollingReply = _reflection.GeneratedProtocolMessageType('PubsubLongPollingReply', (_message.Message,), { + 'DESCRIPTOR' : _PUBSUBLONGPOLLINGREPLY, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubsubLongPollingReply) + }) +_sym_db.RegisterMessage(PubsubLongPollingReply) + +PubsubCommandBatchRequest = _reflection.GeneratedProtocolMessageType('PubsubCommandBatchRequest', (_message.Message,), { + 'DESCRIPTOR' : _PUBSUBCOMMANDBATCHREQUEST, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubsubCommandBatchRequest) + }) +_sym_db.RegisterMessage(PubsubCommandBatchRequest) + +PubsubCommandBatchReply = _reflection.GeneratedProtocolMessageType('PubsubCommandBatchReply', (_message.Message,), { + 'DESCRIPTOR' : _PUBSUBCOMMANDBATCHREPLY, + '__module__' : 'src.ray.protobuf.pubsub_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PubsubCommandBatchReply) + }) +_sym_db.RegisterMessage(PubsubCommandBatchReply) + +_SUBSCRIBERSERVICE = DESCRIPTOR.services_by_name['SubscriberService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _CHANNELTYPE._serialized_start=3399 + _CHANNELTYPE._serialized_end=3739 + _PUBMESSAGE._serialized_start=134 + _PUBMESSAGE._serialized_end=1276 + _WORKEROBJECTEVICTIONMESSAGE._serialized_start=1278 + _WORKEROBJECTEVICTIONMESSAGE._serialized_end=1336 + _WORKERREFREMOVEDMESSAGE._serialized_start=1338 + _WORKERREFREMOVEDMESSAGE._serialized_end=1431 + _WORKEROBJECTLOCATIONSPUBMESSAGE._serialized_start=1434 + _WORKEROBJECTLOCATIONSPUBMESSAGE._serialized_end=1745 + _FAILUREMESSAGE._serialized_start=1747 + _FAILUREMESSAGE._serialized_end=1763 + _COMMAND._serialized_start=1766 + _COMMAND._serialized_end=2029 + _UNSUBSCRIBEMESSAGE._serialized_start=2031 + _UNSUBSCRIBEMESSAGE._serialized_end=2051 + _SUBMESSAGE._serialized_start=2054 + _SUBMESSAGE._serialized_end=2415 + _WORKEROBJECTEVICTIONSUBMESSAGE._serialized_start=2418 + _WORKEROBJECTEVICTIONSUBMESSAGE._serialized_end=2647 + _WORKERREFREMOVEDSUBMESSAGE._serialized_start=2650 + _WORKERREFREMOVEDSUBMESSAGE._serialized_end=2870 + _WORKEROBJECTLOCATIONSSUBMESSAGE._serialized_start=2872 + _WORKEROBJECTLOCATIONSSUBMESSAGE._serialized_end=2980 + _PUBSUBLONGPOLLINGREQUEST._serialized_start=2983 + _PUBSUBLONGPOLLINGREQUEST._serialized_end=3140 + _PUBSUBLONGPOLLINGREPLY._serialized_start=3142 + _PUBSUBLONGPOLLINGREPLY._serialized_end=3257 + _PUBSUBCOMMANDBATCHREQUEST._serialized_start=3259 + _PUBSUBCOMMANDBATCHREQUEST._serialized_end=3369 + _PUBSUBCOMMANDBATCHREPLY._serialized_start=3371 + _PUBSUBCOMMANDBATCHREPLY._serialized_end=3396 + _SUBSCRIBERSERVICE._serialized_start=3742 + _SUBSCRIBERSERVICE._serialized_end=3942 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..abd24b06031aaabeaf0aee17d426080c4a3c07a6 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/pubsub_pb2_grpc.py @@ -0,0 +1,99 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import pubsub_pb2 as src_dot_ray_dot_protobuf_dot_pubsub__pb2 + + +class SubscriberServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.PubsubLongPolling = channel.unary_unary( + '/ray.rpc.SubscriberService/PubsubLongPolling', + request_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.FromString, + ) + self.PubsubCommandBatch = channel.unary_unary( + '/ray.rpc.SubscriberService/PubsubCommandBatch', + request_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.FromString, + ) + + +class SubscriberServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def PubsubLongPolling(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PubsubCommandBatch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_SubscriberServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'PubsubLongPolling': grpc.unary_unary_rpc_method_handler( + servicer.PubsubLongPolling, + request_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.SerializeToString, + ), + 'PubsubCommandBatch': grpc.unary_unary_rpc_method_handler( + servicer.PubsubCommandBatch, + request_deserializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.SubscriberService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class SubscriberService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def PubsubLongPolling(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.SubscriberService/PubsubLongPolling', + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubLongPollingReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PubsubCommandBatch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.SubscriberService/PubsubCommandBatch', + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_pubsub__pb2.PubsubCommandBatchReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2.py b/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..8901b37f8e23438df7d9682c57cba537fb0b0c6b --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2.py @@ -0,0 +1,558 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/ray_client.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!src/ray/protobuf/ray_client.proto\x12\x07ray.rpc\"\xb5\x01\n\x03\x41rg\x12+\n\x05local\x18\x01 \x01(\x0e\x32\x15.ray.rpc.Arg.LocalityR\x05local\x12!\n\x0creference_id\x18\x02 \x01(\x0cR\x0breferenceId\x12\x12\n\x04\x64\x61ta\x18\x03 \x01(\x0cR\x04\x64\x61ta\x12!\n\x04type\x18\x04 \x01(\x0e\x32\r.ray.rpc.TypeR\x04type\"\'\n\x08Locality\x12\x0c\n\x08INTERNED\x10\x00\x12\r\n\tREFERENCE\x10\x01\"6\n\x0bTaskOptions\x12\'\n\x0fpickled_options\x18\x01 \x01(\x0cR\x0epickledOptions\"\xf4\x04\n\nClientTask\x12\x36\n\x04type\x18\x01 \x01(\x0e\x32\".ray.rpc.ClientTask.RemoteExecTypeR\x04type\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12\x1d\n\npayload_id\x18\x03 \x01(\x0cR\tpayloadId\x12 \n\x04\x61rgs\x18\x04 \x03(\x0b\x32\x0c.ray.rpc.ArgR\x04\x61rgs\x12\x37\n\x06kwargs\x18\x05 \x03(\x0b\x32\x1f.ray.rpc.ClientTask.KwargsEntryR\x06kwargs\x12\x1b\n\tclient_id\x18\x06 \x01(\tR\x08\x63lientId\x12.\n\x07options\x18\x07 \x01(\x0b\x32\x14.ray.rpc.TaskOptionsR\x07options\x12?\n\x10\x62\x61seline_options\x18\x08 \x01(\x0b\x32\x14.ray.rpc.TaskOptionsR\x0f\x62\x61selineOptions\x12\x1c\n\tnamespace\x18\t \x01(\tR\tnamespace\x12\x12\n\x04\x64\x61ta\x18\n \x01(\x0cR\x04\x64\x61ta\x12\x19\n\x08\x63hunk_id\x18\x0b \x01(\x05R\x07\x63hunkId\x12!\n\x0ctotal_chunks\x18\x0c \x01(\x05R\x0btotalChunks\x1aG\n\x0bKwargsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x0c.ray.rpc.ArgR\x05value:\x02\x38\x01\"Y\n\x0eRemoteExecType\x12\x0c\n\x08\x46UNCTION\x10\x00\x12\t\n\x05\x41\x43TOR\x10\x01\x12\n\n\x06METHOD\x10\x02\x12\x11\n\rSTATIC_METHOD\x10\x03\x12\x0f\n\x0bNAMED_ACTOR\x10\x04\"]\n\x10\x43lientTaskTicket\x12\x14\n\x05valid\x18\x01 \x01(\x08R\x05valid\x12\x1d\n\nreturn_ids\x18\x02 \x03(\x0cR\treturnIds\x12\x14\n\x05\x65rror\x18\x03 \x01(\x0cR\x05\x65rror\"\xbc\x01\n\nPutRequest\x12\x12\n\x04\x64\x61ta\x18\x01 \x01(\x0cR\x04\x64\x61ta\x12\"\n\rclient_ref_id\x18\x02 \x01(\x0cR\x0b\x63lientRefId\x12\x19\n\x08\x63hunk_id\x18\x03 \x01(\x05R\x07\x63hunkId\x12!\n\x0ctotal_chunks\x18\x04 \x01(\x05R\x0btotalChunks\x12\x1d\n\ntotal_size\x18\x05 \x01(\x03R\ttotalSize\x12\x19\n\x08owner_id\x18\x06 \x01(\x0cR\x07ownerId\"I\n\x0bPutResponse\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02id\x12\x14\n\x05valid\x18\x02 \x01(\x08R\x05valid\x12\x14\n\x05\x65rror\x18\x03 \x01(\x0cR\x05\x65rror\"\x82\x01\n\nGetRequest\x12\x10\n\x03ids\x18\x04 \x03(\x0cR\x03ids\x12\x18\n\x07timeout\x18\x02 \x01(\x02R\x07timeout\x12\"\n\x0c\x61synchronous\x18\x03 \x01(\x08R\x0c\x61synchronous\x12$\n\x0estart_chunk_id\x18\x05 \x01(\x05R\x0cstartChunkId\"\xaa\x01\n\x0bGetResponse\x12\x14\n\x05valid\x18\x01 \x01(\x08R\x05valid\x12\x12\n\x04\x64\x61ta\x18\x02 \x01(\x0cR\x04\x64\x61ta\x12\x14\n\x05\x65rror\x18\x03 \x01(\x0cR\x05\x65rror\x12\x19\n\x08\x63hunk_id\x18\x04 \x01(\x05R\x07\x63hunkId\x12!\n\x0ctotal_chunks\x18\x05 \x01(\x05R\x0btotalChunks\x12\x1d\n\ntotal_size\x18\x06 \x01(\x04R\ttotalSize\"\x84\x01\n\x0bWaitRequest\x12\x1d\n\nobject_ids\x18\x01 \x03(\x0cR\tobjectIds\x12\x1f\n\x0bnum_returns\x18\x02 \x01(\x03R\nnumReturns\x12\x18\n\x07timeout\x18\x03 \x01(\x01R\x07timeout\x12\x1b\n\tclient_id\x18\x04 \x01(\tR\x08\x63lientId\"\x80\x01\n\x0cWaitResponse\x12\x14\n\x05valid\x18\x01 \x01(\x08R\x05valid\x12(\n\x10ready_object_ids\x18\x02 \x03(\x0cR\x0ereadyObjectIds\x12\x30\n\x14remaining_object_ids\x18\x03 \x03(\x0cR\x12remainingObjectIds\"\xad\x01\n\x0f\x43lusterInfoType\"\x99\x01\n\x08TypeEnum\x12\x12\n\x0eIS_INITIALIZED\x10\x00\x12\t\n\x05NODES\x10\x01\x12\x15\n\x11\x43LUSTER_RESOURCES\x10\x02\x12\x17\n\x13\x41VAILABLE_RESOURCES\x10\x03\x12\x13\n\x0fRUNTIME_CONTEXT\x10\x04\x12\x0c\n\x08TIMELINE\x10\x05\x12\x08\n\x04PING\x10\x06\x12\x11\n\rDASHBOARD_URL\x10\x07\"K\n\x12\x43lusterInfoRequest\x12\x35\n\x04type\x18\x01 \x01(\x0e\x32!.ray.rpc.ClusterInfoType.TypeEnumR\x04type\"\x8e\x05\n\x13\x43lusterInfoResponse\x12\x35\n\x04type\x18\x01 \x01(\x0e\x32!.ray.rpc.ClusterInfoType.TypeEnumR\x04type\x12\x14\n\x04json\x18\x02 \x01(\tH\x00R\x04json\x12S\n\x0eresource_table\x18\x03 \x01(\x0b\x32*.ray.rpc.ClusterInfoResponse.ResourceTableH\x00R\rresourceTable\x12V\n\x0fruntime_context\x18\x04 \x01(\x0b\x32+.ray.rpc.ClusterInfoResponse.RuntimeContextH\x00R\x0eruntimeContext\x1a\x96\x01\n\rResourceTable\x12K\n\x05table\x18\x01 \x03(\x0b\x32\x35.ray.rpc.ClusterInfoResponse.ResourceTable.TableEntryR\x05table\x1a\x38\n\nTableEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x01R\x05value:\x02\x38\x01\x1a\xd2\x01\n\x0eRuntimeContext\x12\x15\n\x06job_id\x18\x01 \x01(\x0cR\x05jobId\x12\x17\n\x07node_id\x18\x02 \x01(\x0cR\x06nodeId\x12\x1c\n\tnamespace\x18\x03 \x01(\tR\tnamespace\x12\x1f\n\x0bruntime_env\x18\x04 \x01(\tR\nruntimeEnv\x12\x30\n\x14\x63\x61pture_client_tasks\x18\x05 \x01(\x08R\x12\x63\x61ptureClientTasks\x12\x1f\n\x0bgcs_address\x18\x06 \x01(\tR\ngcsAddressB\x0f\n\rresponse_type\"\xf1\x02\n\x10TerminateRequest\x12\x1b\n\tclient_id\x18\x01 \x01(\tR\x08\x63lientId\x12@\n\x05\x61\x63tor\x18\x02 \x01(\x0b\x32(.ray.rpc.TerminateRequest.ActorTerminateH\x00R\x05\x61\x63tor\x12P\n\x0btask_object\x18\x03 \x01(\x0b\x32-.ray.rpc.TerminateRequest.TaskObjectTerminateH\x00R\ntaskObject\x1a?\n\x0e\x41\x63torTerminate\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02id\x12\x1d\n\nno_restart\x18\x02 \x01(\x08R\tnoRestart\x1aY\n\x13TaskObjectTerminate\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02id\x12\x14\n\x05\x66orce\x18\x02 \x01(\x08R\x05\x66orce\x12\x1c\n\trecursive\x18\x03 \x01(\x08R\trecursiveB\x10\n\x0eterminate_type\"#\n\x11TerminateResponse\x12\x0e\n\x02ok\x18\x01 \x01(\x08R\x02ok\"T\n\x0fKVExistsRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12!\n\tnamespace\x18\x02 \x01(\x0cH\x00R\tnamespace\x88\x01\x01\x42\x0c\n\n_namespace\"*\n\x10KVExistsResponse\x12\x16\n\x06\x65xists\x18\x01 \x01(\x08R\x06\x65xists\"Q\n\x0cKVGetRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12!\n\tnamespace\x18\x02 \x01(\x0cH\x00R\tnamespace\x88\x01\x01\x42\x0c\n\n_namespace\"4\n\rKVGetResponse\x12\x19\n\x05value\x18\x01 \x01(\x0cH\x00R\x05value\x88\x01\x01\x42\x08\n\x06_value\"\x85\x01\n\x0cKVPutRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05value\x12\x1c\n\toverwrite\x18\x03 \x01(\x08R\toverwrite\x12!\n\tnamespace\x18\x04 \x01(\x0cH\x00R\tnamespace\x88\x01\x01\x42\x0c\n\n_namespace\"6\n\rKVPutResponse\x12%\n\x0e\x61lready_exists\x18\x01 \x01(\x08R\ralreadyExists\"u\n\x0cKVDelRequest\x12\x10\n\x03key\x18\x01 \x01(\x0cR\x03key\x12\"\n\rdel_by_prefix\x18\x02 \x01(\x08R\x0b\x64\x65lByPrefix\x12!\n\tnamespace\x18\x03 \x01(\x0cH\x00R\tnamespace\x88\x01\x01\x42\x0c\n\n_namespace\"0\n\rKVDelResponse\x12\x1f\n\x0b\x64\x65leted_num\x18\x01 \x01(\x05R\ndeletedNum\"X\n\rKVListRequest\x12\x16\n\x06prefix\x18\x01 \x01(\x0cR\x06prefix\x12!\n\tnamespace\x18\x02 \x01(\x0cH\x00R\tnamespace\x88\x01\x01\x42\x0c\n\n_namespace\"$\n\x0eKVListResponse\x12\x12\n\x04keys\x18\x01 \x03(\x0cR\x04keys\"T\n\x1d\x43lientPinRuntimeEnvURIRequest\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12!\n\x0c\x65xpiration_s\x18\x02 \x01(\x05R\x0b\x65xpirationS\" \n\x1e\x43lientPinRuntimeEnvURIResponse\"\x8a\x01\n\x0bInitRequest\x12\x1d\n\njob_config\x18\x01 \x01(\x0cR\tjobConfig\x12&\n\x0fray_init_kwargs\x18\x02 \x01(\tR\rrayInitKwargs\x12\x34\n\x16reconnect_grace_period\x18\x03 \x01(\x05R\x14reconnectGracePeriod\"0\n\x0cInitResponse\x12\x0e\n\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x10\n\x03msg\x18\x02 \x01(\tR\x03msg\"\x17\n\x15PrepRuntimeEnvRequest\"\x18\n\x16PrepRuntimeEnvResponse\"E\n\x1c\x43lientListNamedActorsRequest\x12%\n\x0e\x61ll_namespaces\x18\x01 \x01(\x08R\rallNamespaces\"@\n\x1d\x43lientListNamedActorsResponse\x12\x1f\n\x0b\x61\x63tors_json\x18\x01 \x01(\tR\nactorsJson\"\"\n\x0eReleaseRequest\x12\x10\n\x03ids\x18\x01 \x03(\x0cR\x03ids\"!\n\x0fReleaseResponse\x12\x0e\n\x02ok\x18\x02 \x03(\x08R\x02ok\"\x17\n\x15\x43onnectionInfoRequest\"\xa0\x01\n\x16\x43onnectionInfoResponse\x12\x1f\n\x0bnum_clients\x18\x01 \x01(\x05R\nnumClients\x12\x1f\n\x0bray_version\x18\x02 \x01(\tR\nrayVersion\x12\x1d\n\nray_commit\x18\x03 \x01(\tR\trayCommit\x12%\n\x0epython_version\x18\x04 \x01(\tR\rpythonVersion\"\x1a\n\x18\x43onnectionCleanupRequest\"\x1b\n\x19\x43onnectionCleanupResponse\"+\n\x12\x41\x63knowledgeRequest\x12\x15\n\x06req_id\x18\x01 \x01(\x05R\x05reqId\"\xc6\x05\n\x0b\x44\x61taRequest\x12\x15\n\x06req_id\x18\x01 \x01(\x05R\x05reqId\x12\'\n\x03get\x18\x02 \x01(\x0b\x32\x13.ray.rpc.GetRequestH\x00R\x03get\x12\'\n\x03put\x18\x03 \x01(\x0b\x32\x13.ray.rpc.PutRequestH\x00R\x03put\x12\x33\n\x07release\x18\x04 \x01(\x0b\x32\x17.ray.rpc.ReleaseRequestH\x00R\x07release\x12I\n\x0f\x63onnection_info\x18\x05 \x01(\x0b\x32\x1e.ray.rpc.ConnectionInfoRequestH\x00R\x0e\x63onnectionInfo\x12*\n\x04init\x18\x06 \x01(\x0b\x32\x14.ray.rpc.InitRequestH\x00R\x04init\x12J\n\x10prep_runtime_env\x18\x07 \x01(\x0b\x32\x1e.ray.rpc.PrepRuntimeEnvRequestH\x00R\x0eprepRuntimeEnv\x12R\n\x12\x63onnection_cleanup\x18\x08 \x01(\x0b\x32!.ray.rpc.ConnectionCleanupRequestH\x00R\x11\x63onnectionCleanup\x12?\n\x0b\x61\x63knowledge\x18\t \x01(\x0b\x32\x1b.ray.rpc.AcknowledgeRequestH\x00R\x0b\x61\x63knowledge\x12)\n\x04task\x18\n \x01(\x0b\x32\x13.ray.rpc.ClientTaskH\x00R\x04task\x12\x39\n\tterminate\x18\x0b \x01(\x0b\x32\x19.ray.rpc.TerminateRequestH\x00R\tterminate\x12S\n\x11list_named_actors\x18\x0c \x01(\x0b\x32%.ray.rpc.ClientListNamedActorsRequestH\x00R\x0flistNamedActorsB\x06\n\x04type\"\xb5\x05\n\x0c\x44\x61taResponse\x12\x15\n\x06req_id\x18\x01 \x01(\x05R\x05reqId\x12(\n\x03get\x18\x02 \x01(\x0b\x32\x14.ray.rpc.GetResponseH\x00R\x03get\x12(\n\x03put\x18\x03 \x01(\x0b\x32\x14.ray.rpc.PutResponseH\x00R\x03put\x12\x34\n\x07release\x18\x04 \x01(\x0b\x32\x18.ray.rpc.ReleaseResponseH\x00R\x07release\x12J\n\x0f\x63onnection_info\x18\x05 \x01(\x0b\x32\x1f.ray.rpc.ConnectionInfoResponseH\x00R\x0e\x63onnectionInfo\x12+\n\x04init\x18\x06 \x01(\x0b\x32\x15.ray.rpc.InitResponseH\x00R\x04init\x12K\n\x10prep_runtime_env\x18\x07 \x01(\x0b\x32\x1f.ray.rpc.PrepRuntimeEnvResponseH\x00R\x0eprepRuntimeEnv\x12S\n\x12\x63onnection_cleanup\x18\x08 \x01(\x0b\x32\".ray.rpc.ConnectionCleanupResponseH\x00R\x11\x63onnectionCleanup\x12<\n\x0btask_ticket\x18\n \x01(\x0b\x32\x19.ray.rpc.ClientTaskTicketH\x00R\ntaskTicket\x12:\n\tterminate\x18\x0b \x01(\x0b\x32\x1a.ray.rpc.TerminateResponseH\x00R\tterminate\x12T\n\x11list_named_actors\x18\x0c \x01(\x0b\x32&.ray.rpc.ClientListNamedActorsResponseH\x00R\x0flistNamedActorsB\x06\n\x04typeJ\x04\x08\t\x10\nR\x0b\x61\x63knowledge\"J\n\x12LogSettingsRequest\x12\x18\n\x07\x65nabled\x18\x01 \x01(\x08R\x07\x65nabled\x12\x1a\n\x08loglevel\x18\x02 \x01(\x05R\x08loglevel\"E\n\x07LogData\x12\x10\n\x03msg\x18\x01 \x01(\tR\x03msg\x12\x14\n\x05level\x18\x02 \x01(\x05R\x05level\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name*\x13\n\x04Type\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x32\x96\x08\n\x0cRayletDriver\x12\x35\n\x04Init\x12\x14.ray.rpc.InitRequest\x1a\x15.ray.rpc.InitResponse\"\x00\x12S\n\x0ePrepRuntimeEnv\x12\x1e.ray.rpc.PrepRuntimeEnvRequest\x1a\x1f.ray.rpc.PrepRuntimeEnvResponse\"\x00\x12:\n\tGetObject\x12\x13.ray.rpc.GetRequest\x1a\x14.ray.rpc.GetResponse\"\x00\x30\x01\x12\x38\n\tPutObject\x12\x13.ray.rpc.PutRequest\x1a\x14.ray.rpc.PutResponse\"\x00\x12;\n\nWaitObject\x12\x14.ray.rpc.WaitRequest\x1a\x15.ray.rpc.WaitResponse\"\x00\x12<\n\x08Schedule\x12\x13.ray.rpc.ClientTask\x1a\x19.ray.rpc.ClientTaskTicket\"\x00\x12\x44\n\tTerminate\x12\x19.ray.rpc.TerminateRequest\x1a\x1a.ray.rpc.TerminateResponse\"\x00\x12J\n\x0b\x43lusterInfo\x12\x1b.ray.rpc.ClusterInfoRequest\x1a\x1c.ray.rpc.ClusterInfoResponse\"\x00\x12\x38\n\x05KVGet\x12\x15.ray.rpc.KVGetRequest\x1a\x16.ray.rpc.KVGetResponse\"\x00\x12\x38\n\x05KVPut\x12\x15.ray.rpc.KVPutRequest\x1a\x16.ray.rpc.KVPutResponse\"\x00\x12\x38\n\x05KVDel\x12\x15.ray.rpc.KVDelRequest\x1a\x16.ray.rpc.KVDelResponse\"\x00\x12;\n\x06KVList\x12\x16.ray.rpc.KVListRequest\x1a\x17.ray.rpc.KVListResponse\"\x00\x12\x41\n\x08KVExists\x12\x18.ray.rpc.KVExistsRequest\x1a\x19.ray.rpc.KVExistsResponse\"\x00\x12\x62\n\x0fListNamedActors\x12%.ray.rpc.ClientListNamedActorsRequest\x1a&.ray.rpc.ClientListNamedActorsResponse\"\x00\x12\x65\n\x10PinRuntimeEnvURI\x12&.ray.rpc.ClientPinRuntimeEnvURIRequest\x1a\'.ray.rpc.ClientPinRuntimeEnvURIResponse\"\x00\x32S\n\x12RayletDataStreamer\x12=\n\x08\x44\x61tapath\x12\x14.ray.rpc.DataRequest\x1a\x15.ray.rpc.DataResponse\"\x00(\x01\x30\x01\x32U\n\x11RayletLogStreamer\x12@\n\tLogstream\x12\x1b.ray.rpc.LogSettingsRequest\x1a\x10.ray.rpc.LogData\"\x00(\x01\x30\x01\x62\x06proto3') + +_TYPE = DESCRIPTOR.enum_types_by_name['Type'] +Type = enum_type_wrapper.EnumTypeWrapper(_TYPE) +DEFAULT = 0 + + +_ARG = DESCRIPTOR.message_types_by_name['Arg'] +_TASKOPTIONS = DESCRIPTOR.message_types_by_name['TaskOptions'] +_CLIENTTASK = DESCRIPTOR.message_types_by_name['ClientTask'] +_CLIENTTASK_KWARGSENTRY = _CLIENTTASK.nested_types_by_name['KwargsEntry'] +_CLIENTTASKTICKET = DESCRIPTOR.message_types_by_name['ClientTaskTicket'] +_PUTREQUEST = DESCRIPTOR.message_types_by_name['PutRequest'] +_PUTRESPONSE = DESCRIPTOR.message_types_by_name['PutResponse'] +_GETREQUEST = DESCRIPTOR.message_types_by_name['GetRequest'] +_GETRESPONSE = DESCRIPTOR.message_types_by_name['GetResponse'] +_WAITREQUEST = DESCRIPTOR.message_types_by_name['WaitRequest'] +_WAITRESPONSE = DESCRIPTOR.message_types_by_name['WaitResponse'] +_CLUSTERINFOTYPE = DESCRIPTOR.message_types_by_name['ClusterInfoType'] +_CLUSTERINFOREQUEST = DESCRIPTOR.message_types_by_name['ClusterInfoRequest'] +_CLUSTERINFORESPONSE = DESCRIPTOR.message_types_by_name['ClusterInfoResponse'] +_CLUSTERINFORESPONSE_RESOURCETABLE = _CLUSTERINFORESPONSE.nested_types_by_name['ResourceTable'] +_CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY = _CLUSTERINFORESPONSE_RESOURCETABLE.nested_types_by_name['TableEntry'] +_CLUSTERINFORESPONSE_RUNTIMECONTEXT = _CLUSTERINFORESPONSE.nested_types_by_name['RuntimeContext'] +_TERMINATEREQUEST = DESCRIPTOR.message_types_by_name['TerminateRequest'] +_TERMINATEREQUEST_ACTORTERMINATE = _TERMINATEREQUEST.nested_types_by_name['ActorTerminate'] +_TERMINATEREQUEST_TASKOBJECTTERMINATE = _TERMINATEREQUEST.nested_types_by_name['TaskObjectTerminate'] +_TERMINATERESPONSE = DESCRIPTOR.message_types_by_name['TerminateResponse'] +_KVEXISTSREQUEST = DESCRIPTOR.message_types_by_name['KVExistsRequest'] +_KVEXISTSRESPONSE = DESCRIPTOR.message_types_by_name['KVExistsResponse'] +_KVGETREQUEST = DESCRIPTOR.message_types_by_name['KVGetRequest'] +_KVGETRESPONSE = DESCRIPTOR.message_types_by_name['KVGetResponse'] +_KVPUTREQUEST = DESCRIPTOR.message_types_by_name['KVPutRequest'] +_KVPUTRESPONSE = DESCRIPTOR.message_types_by_name['KVPutResponse'] +_KVDELREQUEST = DESCRIPTOR.message_types_by_name['KVDelRequest'] +_KVDELRESPONSE = DESCRIPTOR.message_types_by_name['KVDelResponse'] +_KVLISTREQUEST = DESCRIPTOR.message_types_by_name['KVListRequest'] +_KVLISTRESPONSE = DESCRIPTOR.message_types_by_name['KVListResponse'] +_CLIENTPINRUNTIMEENVURIREQUEST = DESCRIPTOR.message_types_by_name['ClientPinRuntimeEnvURIRequest'] +_CLIENTPINRUNTIMEENVURIRESPONSE = DESCRIPTOR.message_types_by_name['ClientPinRuntimeEnvURIResponse'] +_INITREQUEST = DESCRIPTOR.message_types_by_name['InitRequest'] +_INITRESPONSE = DESCRIPTOR.message_types_by_name['InitResponse'] +_PREPRUNTIMEENVREQUEST = DESCRIPTOR.message_types_by_name['PrepRuntimeEnvRequest'] +_PREPRUNTIMEENVRESPONSE = DESCRIPTOR.message_types_by_name['PrepRuntimeEnvResponse'] +_CLIENTLISTNAMEDACTORSREQUEST = DESCRIPTOR.message_types_by_name['ClientListNamedActorsRequest'] +_CLIENTLISTNAMEDACTORSRESPONSE = DESCRIPTOR.message_types_by_name['ClientListNamedActorsResponse'] +_RELEASEREQUEST = DESCRIPTOR.message_types_by_name['ReleaseRequest'] +_RELEASERESPONSE = DESCRIPTOR.message_types_by_name['ReleaseResponse'] +_CONNECTIONINFOREQUEST = DESCRIPTOR.message_types_by_name['ConnectionInfoRequest'] +_CONNECTIONINFORESPONSE = DESCRIPTOR.message_types_by_name['ConnectionInfoResponse'] +_CONNECTIONCLEANUPREQUEST = DESCRIPTOR.message_types_by_name['ConnectionCleanupRequest'] +_CONNECTIONCLEANUPRESPONSE = DESCRIPTOR.message_types_by_name['ConnectionCleanupResponse'] +_ACKNOWLEDGEREQUEST = DESCRIPTOR.message_types_by_name['AcknowledgeRequest'] +_DATAREQUEST = DESCRIPTOR.message_types_by_name['DataRequest'] +_DATARESPONSE = DESCRIPTOR.message_types_by_name['DataResponse'] +_LOGSETTINGSREQUEST = DESCRIPTOR.message_types_by_name['LogSettingsRequest'] +_LOGDATA = DESCRIPTOR.message_types_by_name['LogData'] +_ARG_LOCALITY = _ARG.enum_types_by_name['Locality'] +_CLIENTTASK_REMOTEEXECTYPE = _CLIENTTASK.enum_types_by_name['RemoteExecType'] +_CLUSTERINFOTYPE_TYPEENUM = _CLUSTERINFOTYPE.enum_types_by_name['TypeEnum'] +Arg = _reflection.GeneratedProtocolMessageType('Arg', (_message.Message,), { + 'DESCRIPTOR' : _ARG, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.Arg) + }) +_sym_db.RegisterMessage(Arg) + +TaskOptions = _reflection.GeneratedProtocolMessageType('TaskOptions', (_message.Message,), { + 'DESCRIPTOR' : _TASKOPTIONS, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TaskOptions) + }) +_sym_db.RegisterMessage(TaskOptions) + +ClientTask = _reflection.GeneratedProtocolMessageType('ClientTask', (_message.Message,), { + + 'KwargsEntry' : _reflection.GeneratedProtocolMessageType('KwargsEntry', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTTASK_KWARGSENTRY, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientTask.KwargsEntry) + }) + , + 'DESCRIPTOR' : _CLIENTTASK, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientTask) + }) +_sym_db.RegisterMessage(ClientTask) +_sym_db.RegisterMessage(ClientTask.KwargsEntry) + +ClientTaskTicket = _reflection.GeneratedProtocolMessageType('ClientTaskTicket', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTTASKTICKET, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientTaskTicket) + }) +_sym_db.RegisterMessage(ClientTaskTicket) + +PutRequest = _reflection.GeneratedProtocolMessageType('PutRequest', (_message.Message,), { + 'DESCRIPTOR' : _PUTREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PutRequest) + }) +_sym_db.RegisterMessage(PutRequest) + +PutResponse = _reflection.GeneratedProtocolMessageType('PutResponse', (_message.Message,), { + 'DESCRIPTOR' : _PUTRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PutResponse) + }) +_sym_db.RegisterMessage(PutResponse) + +GetRequest = _reflection.GeneratedProtocolMessageType('GetRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetRequest) + }) +_sym_db.RegisterMessage(GetRequest) + +GetResponse = _reflection.GeneratedProtocolMessageType('GetResponse', (_message.Message,), { + 'DESCRIPTOR' : _GETRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetResponse) + }) +_sym_db.RegisterMessage(GetResponse) + +WaitRequest = _reflection.GeneratedProtocolMessageType('WaitRequest', (_message.Message,), { + 'DESCRIPTOR' : _WAITREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitRequest) + }) +_sym_db.RegisterMessage(WaitRequest) + +WaitResponse = _reflection.GeneratedProtocolMessageType('WaitResponse', (_message.Message,), { + 'DESCRIPTOR' : _WAITRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.WaitResponse) + }) +_sym_db.RegisterMessage(WaitResponse) + +ClusterInfoType = _reflection.GeneratedProtocolMessageType('ClusterInfoType', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERINFOTYPE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoType) + }) +_sym_db.RegisterMessage(ClusterInfoType) + +ClusterInfoRequest = _reflection.GeneratedProtocolMessageType('ClusterInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERINFOREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoRequest) + }) +_sym_db.RegisterMessage(ClusterInfoRequest) + +ClusterInfoResponse = _reflection.GeneratedProtocolMessageType('ClusterInfoResponse', (_message.Message,), { + + 'ResourceTable' : _reflection.GeneratedProtocolMessageType('ResourceTable', (_message.Message,), { + + 'TableEntry' : _reflection.GeneratedProtocolMessageType('TableEntry', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoResponse.ResourceTable.TableEntry) + }) + , + 'DESCRIPTOR' : _CLUSTERINFORESPONSE_RESOURCETABLE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoResponse.ResourceTable) + }) + , + + 'RuntimeContext' : _reflection.GeneratedProtocolMessageType('RuntimeContext', (_message.Message,), { + 'DESCRIPTOR' : _CLUSTERINFORESPONSE_RUNTIMECONTEXT, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoResponse.RuntimeContext) + }) + , + 'DESCRIPTOR' : _CLUSTERINFORESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClusterInfoResponse) + }) +_sym_db.RegisterMessage(ClusterInfoResponse) +_sym_db.RegisterMessage(ClusterInfoResponse.ResourceTable) +_sym_db.RegisterMessage(ClusterInfoResponse.ResourceTable.TableEntry) +_sym_db.RegisterMessage(ClusterInfoResponse.RuntimeContext) + +TerminateRequest = _reflection.GeneratedProtocolMessageType('TerminateRequest', (_message.Message,), { + + 'ActorTerminate' : _reflection.GeneratedProtocolMessageType('ActorTerminate', (_message.Message,), { + 'DESCRIPTOR' : _TERMINATEREQUEST_ACTORTERMINATE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TerminateRequest.ActorTerminate) + }) + , + + 'TaskObjectTerminate' : _reflection.GeneratedProtocolMessageType('TaskObjectTerminate', (_message.Message,), { + 'DESCRIPTOR' : _TERMINATEREQUEST_TASKOBJECTTERMINATE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TerminateRequest.TaskObjectTerminate) + }) + , + 'DESCRIPTOR' : _TERMINATEREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TerminateRequest) + }) +_sym_db.RegisterMessage(TerminateRequest) +_sym_db.RegisterMessage(TerminateRequest.ActorTerminate) +_sym_db.RegisterMessage(TerminateRequest.TaskObjectTerminate) + +TerminateResponse = _reflection.GeneratedProtocolMessageType('TerminateResponse', (_message.Message,), { + 'DESCRIPTOR' : _TERMINATERESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.TerminateResponse) + }) +_sym_db.RegisterMessage(TerminateResponse) + +KVExistsRequest = _reflection.GeneratedProtocolMessageType('KVExistsRequest', (_message.Message,), { + 'DESCRIPTOR' : _KVEXISTSREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVExistsRequest) + }) +_sym_db.RegisterMessage(KVExistsRequest) + +KVExistsResponse = _reflection.GeneratedProtocolMessageType('KVExistsResponse', (_message.Message,), { + 'DESCRIPTOR' : _KVEXISTSRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVExistsResponse) + }) +_sym_db.RegisterMessage(KVExistsResponse) + +KVGetRequest = _reflection.GeneratedProtocolMessageType('KVGetRequest', (_message.Message,), { + 'DESCRIPTOR' : _KVGETREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVGetRequest) + }) +_sym_db.RegisterMessage(KVGetRequest) + +KVGetResponse = _reflection.GeneratedProtocolMessageType('KVGetResponse', (_message.Message,), { + 'DESCRIPTOR' : _KVGETRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVGetResponse) + }) +_sym_db.RegisterMessage(KVGetResponse) + +KVPutRequest = _reflection.GeneratedProtocolMessageType('KVPutRequest', (_message.Message,), { + 'DESCRIPTOR' : _KVPUTREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVPutRequest) + }) +_sym_db.RegisterMessage(KVPutRequest) + +KVPutResponse = _reflection.GeneratedProtocolMessageType('KVPutResponse', (_message.Message,), { + 'DESCRIPTOR' : _KVPUTRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVPutResponse) + }) +_sym_db.RegisterMessage(KVPutResponse) + +KVDelRequest = _reflection.GeneratedProtocolMessageType('KVDelRequest', (_message.Message,), { + 'DESCRIPTOR' : _KVDELREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVDelRequest) + }) +_sym_db.RegisterMessage(KVDelRequest) + +KVDelResponse = _reflection.GeneratedProtocolMessageType('KVDelResponse', (_message.Message,), { + 'DESCRIPTOR' : _KVDELRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVDelResponse) + }) +_sym_db.RegisterMessage(KVDelResponse) + +KVListRequest = _reflection.GeneratedProtocolMessageType('KVListRequest', (_message.Message,), { + 'DESCRIPTOR' : _KVLISTREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVListRequest) + }) +_sym_db.RegisterMessage(KVListRequest) + +KVListResponse = _reflection.GeneratedProtocolMessageType('KVListResponse', (_message.Message,), { + 'DESCRIPTOR' : _KVLISTRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.KVListResponse) + }) +_sym_db.RegisterMessage(KVListResponse) + +ClientPinRuntimeEnvURIRequest = _reflection.GeneratedProtocolMessageType('ClientPinRuntimeEnvURIRequest', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTPINRUNTIMEENVURIREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientPinRuntimeEnvURIRequest) + }) +_sym_db.RegisterMessage(ClientPinRuntimeEnvURIRequest) + +ClientPinRuntimeEnvURIResponse = _reflection.GeneratedProtocolMessageType('ClientPinRuntimeEnvURIResponse', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTPINRUNTIMEENVURIRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientPinRuntimeEnvURIResponse) + }) +_sym_db.RegisterMessage(ClientPinRuntimeEnvURIResponse) + +InitRequest = _reflection.GeneratedProtocolMessageType('InitRequest', (_message.Message,), { + 'DESCRIPTOR' : _INITREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InitRequest) + }) +_sym_db.RegisterMessage(InitRequest) + +InitResponse = _reflection.GeneratedProtocolMessageType('InitResponse', (_message.Message,), { + 'DESCRIPTOR' : _INITRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.InitResponse) + }) +_sym_db.RegisterMessage(InitResponse) + +PrepRuntimeEnvRequest = _reflection.GeneratedProtocolMessageType('PrepRuntimeEnvRequest', (_message.Message,), { + 'DESCRIPTOR' : _PREPRUNTIMEENVREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrepRuntimeEnvRequest) + }) +_sym_db.RegisterMessage(PrepRuntimeEnvRequest) + +PrepRuntimeEnvResponse = _reflection.GeneratedProtocolMessageType('PrepRuntimeEnvResponse', (_message.Message,), { + 'DESCRIPTOR' : _PREPRUNTIMEENVRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.PrepRuntimeEnvResponse) + }) +_sym_db.RegisterMessage(PrepRuntimeEnvResponse) + +ClientListNamedActorsRequest = _reflection.GeneratedProtocolMessageType('ClientListNamedActorsRequest', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTLISTNAMEDACTORSREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientListNamedActorsRequest) + }) +_sym_db.RegisterMessage(ClientListNamedActorsRequest) + +ClientListNamedActorsResponse = _reflection.GeneratedProtocolMessageType('ClientListNamedActorsResponse', (_message.Message,), { + 'DESCRIPTOR' : _CLIENTLISTNAMEDACTORSRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ClientListNamedActorsResponse) + }) +_sym_db.RegisterMessage(ClientListNamedActorsResponse) + +ReleaseRequest = _reflection.GeneratedProtocolMessageType('ReleaseRequest', (_message.Message,), { + 'DESCRIPTOR' : _RELEASEREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseRequest) + }) +_sym_db.RegisterMessage(ReleaseRequest) + +ReleaseResponse = _reflection.GeneratedProtocolMessageType('ReleaseResponse', (_message.Message,), { + 'DESCRIPTOR' : _RELEASERESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReleaseResponse) + }) +_sym_db.RegisterMessage(ReleaseResponse) + +ConnectionInfoRequest = _reflection.GeneratedProtocolMessageType('ConnectionInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _CONNECTIONINFOREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ConnectionInfoRequest) + }) +_sym_db.RegisterMessage(ConnectionInfoRequest) + +ConnectionInfoResponse = _reflection.GeneratedProtocolMessageType('ConnectionInfoResponse', (_message.Message,), { + 'DESCRIPTOR' : _CONNECTIONINFORESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ConnectionInfoResponse) + }) +_sym_db.RegisterMessage(ConnectionInfoResponse) + +ConnectionCleanupRequest = _reflection.GeneratedProtocolMessageType('ConnectionCleanupRequest', (_message.Message,), { + 'DESCRIPTOR' : _CONNECTIONCLEANUPREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ConnectionCleanupRequest) + }) +_sym_db.RegisterMessage(ConnectionCleanupRequest) + +ConnectionCleanupResponse = _reflection.GeneratedProtocolMessageType('ConnectionCleanupResponse', (_message.Message,), { + 'DESCRIPTOR' : _CONNECTIONCLEANUPRESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ConnectionCleanupResponse) + }) +_sym_db.RegisterMessage(ConnectionCleanupResponse) + +AcknowledgeRequest = _reflection.GeneratedProtocolMessageType('AcknowledgeRequest', (_message.Message,), { + 'DESCRIPTOR' : _ACKNOWLEDGEREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.AcknowledgeRequest) + }) +_sym_db.RegisterMessage(AcknowledgeRequest) + +DataRequest = _reflection.GeneratedProtocolMessageType('DataRequest', (_message.Message,), { + 'DESCRIPTOR' : _DATAREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DataRequest) + }) +_sym_db.RegisterMessage(DataRequest) + +DataResponse = _reflection.GeneratedProtocolMessageType('DataResponse', (_message.Message,), { + 'DESCRIPTOR' : _DATARESPONSE, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DataResponse) + }) +_sym_db.RegisterMessage(DataResponse) + +LogSettingsRequest = _reflection.GeneratedProtocolMessageType('LogSettingsRequest', (_message.Message,), { + 'DESCRIPTOR' : _LOGSETTINGSREQUEST, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LogSettingsRequest) + }) +_sym_db.RegisterMessage(LogSettingsRequest) + +LogData = _reflection.GeneratedProtocolMessageType('LogData', (_message.Message,), { + 'DESCRIPTOR' : _LOGDATA, + '__module__' : 'src.ray.protobuf.ray_client_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.LogData) + }) +_sym_db.RegisterMessage(LogData) + +_RAYLETDRIVER = DESCRIPTOR.services_by_name['RayletDriver'] +_RAYLETDATASTREAMER = DESCRIPTOR.services_by_name['RayletDataStreamer'] +_RAYLETLOGSTREAMER = DESCRIPTOR.services_by_name['RayletLogStreamer'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _CLIENTTASK_KWARGSENTRY._options = None + _CLIENTTASK_KWARGSENTRY._serialized_options = b'8\001' + _CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY._options = None + _CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY._serialized_options = b'8\001' + _TYPE._serialized_start=6341 + _TYPE._serialized_end=6360 + _ARG._serialized_start=47 + _ARG._serialized_end=228 + _ARG_LOCALITY._serialized_start=189 + _ARG_LOCALITY._serialized_end=228 + _TASKOPTIONS._serialized_start=230 + _TASKOPTIONS._serialized_end=284 + _CLIENTTASK._serialized_start=287 + _CLIENTTASK._serialized_end=915 + _CLIENTTASK_KWARGSENTRY._serialized_start=753 + _CLIENTTASK_KWARGSENTRY._serialized_end=824 + _CLIENTTASK_REMOTEEXECTYPE._serialized_start=826 + _CLIENTTASK_REMOTEEXECTYPE._serialized_end=915 + _CLIENTTASKTICKET._serialized_start=917 + _CLIENTTASKTICKET._serialized_end=1010 + _PUTREQUEST._serialized_start=1013 + _PUTREQUEST._serialized_end=1201 + _PUTRESPONSE._serialized_start=1203 + _PUTRESPONSE._serialized_end=1276 + _GETREQUEST._serialized_start=1279 + _GETREQUEST._serialized_end=1409 + _GETRESPONSE._serialized_start=1412 + _GETRESPONSE._serialized_end=1582 + _WAITREQUEST._serialized_start=1585 + _WAITREQUEST._serialized_end=1717 + _WAITRESPONSE._serialized_start=1720 + _WAITRESPONSE._serialized_end=1848 + _CLUSTERINFOTYPE._serialized_start=1851 + _CLUSTERINFOTYPE._serialized_end=2024 + _CLUSTERINFOTYPE_TYPEENUM._serialized_start=1871 + _CLUSTERINFOTYPE_TYPEENUM._serialized_end=2024 + _CLUSTERINFOREQUEST._serialized_start=2026 + _CLUSTERINFOREQUEST._serialized_end=2101 + _CLUSTERINFORESPONSE._serialized_start=2104 + _CLUSTERINFORESPONSE._serialized_end=2758 + _CLUSTERINFORESPONSE_RESOURCETABLE._serialized_start=2378 + _CLUSTERINFORESPONSE_RESOURCETABLE._serialized_end=2528 + _CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY._serialized_start=2472 + _CLUSTERINFORESPONSE_RESOURCETABLE_TABLEENTRY._serialized_end=2528 + _CLUSTERINFORESPONSE_RUNTIMECONTEXT._serialized_start=2531 + _CLUSTERINFORESPONSE_RUNTIMECONTEXT._serialized_end=2741 + _TERMINATEREQUEST._serialized_start=2761 + _TERMINATEREQUEST._serialized_end=3130 + _TERMINATEREQUEST_ACTORTERMINATE._serialized_start=2958 + _TERMINATEREQUEST_ACTORTERMINATE._serialized_end=3021 + _TERMINATEREQUEST_TASKOBJECTTERMINATE._serialized_start=3023 + _TERMINATEREQUEST_TASKOBJECTTERMINATE._serialized_end=3112 + _TERMINATERESPONSE._serialized_start=3132 + _TERMINATERESPONSE._serialized_end=3167 + _KVEXISTSREQUEST._serialized_start=3169 + _KVEXISTSREQUEST._serialized_end=3253 + _KVEXISTSRESPONSE._serialized_start=3255 + _KVEXISTSRESPONSE._serialized_end=3297 + _KVGETREQUEST._serialized_start=3299 + _KVGETREQUEST._serialized_end=3380 + _KVGETRESPONSE._serialized_start=3382 + _KVGETRESPONSE._serialized_end=3434 + _KVPUTREQUEST._serialized_start=3437 + _KVPUTREQUEST._serialized_end=3570 + _KVPUTRESPONSE._serialized_start=3572 + _KVPUTRESPONSE._serialized_end=3626 + _KVDELREQUEST._serialized_start=3628 + _KVDELREQUEST._serialized_end=3745 + _KVDELRESPONSE._serialized_start=3747 + _KVDELRESPONSE._serialized_end=3795 + _KVLISTREQUEST._serialized_start=3797 + _KVLISTREQUEST._serialized_end=3885 + _KVLISTRESPONSE._serialized_start=3887 + _KVLISTRESPONSE._serialized_end=3923 + _CLIENTPINRUNTIMEENVURIREQUEST._serialized_start=3925 + _CLIENTPINRUNTIMEENVURIREQUEST._serialized_end=4009 + _CLIENTPINRUNTIMEENVURIRESPONSE._serialized_start=4011 + _CLIENTPINRUNTIMEENVURIRESPONSE._serialized_end=4043 + _INITREQUEST._serialized_start=4046 + _INITREQUEST._serialized_end=4184 + _INITRESPONSE._serialized_start=4186 + _INITRESPONSE._serialized_end=4234 + _PREPRUNTIMEENVREQUEST._serialized_start=4236 + _PREPRUNTIMEENVREQUEST._serialized_end=4259 + _PREPRUNTIMEENVRESPONSE._serialized_start=4261 + _PREPRUNTIMEENVRESPONSE._serialized_end=4285 + _CLIENTLISTNAMEDACTORSREQUEST._serialized_start=4287 + _CLIENTLISTNAMEDACTORSREQUEST._serialized_end=4356 + _CLIENTLISTNAMEDACTORSRESPONSE._serialized_start=4358 + _CLIENTLISTNAMEDACTORSRESPONSE._serialized_end=4422 + _RELEASEREQUEST._serialized_start=4424 + _RELEASEREQUEST._serialized_end=4458 + _RELEASERESPONSE._serialized_start=4460 + _RELEASERESPONSE._serialized_end=4493 + _CONNECTIONINFOREQUEST._serialized_start=4495 + _CONNECTIONINFOREQUEST._serialized_end=4518 + _CONNECTIONINFORESPONSE._serialized_start=4521 + _CONNECTIONINFORESPONSE._serialized_end=4681 + _CONNECTIONCLEANUPREQUEST._serialized_start=4683 + _CONNECTIONCLEANUPREQUEST._serialized_end=4709 + _CONNECTIONCLEANUPRESPONSE._serialized_start=4711 + _CONNECTIONCLEANUPRESPONSE._serialized_end=4738 + _ACKNOWLEDGEREQUEST._serialized_start=4740 + _ACKNOWLEDGEREQUEST._serialized_end=4783 + _DATAREQUEST._serialized_start=4786 + _DATAREQUEST._serialized_end=5496 + _DATARESPONSE._serialized_start=5499 + _DATARESPONSE._serialized_end=6192 + _LOGSETTINGSREQUEST._serialized_start=6194 + _LOGSETTINGSREQUEST._serialized_end=6268 + _LOGDATA._serialized_start=6270 + _LOGDATA._serialized_end=6339 + _RAYLETDRIVER._serialized_start=6363 + _RAYLETDRIVER._serialized_end=7409 + _RAYLETDATASTREAMER._serialized_start=7411 + _RAYLETDATASTREAMER._serialized_end=7494 + _RAYLETLOGSTREAMER._serialized_start=7496 + _RAYLETLOGSTREAMER._serialized_end=7581 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..f5b943012c5e9b4a1d80057da89aa9ae3820cfcc --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/ray_client_pb2_grpc.py @@ -0,0 +1,650 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import ray_client_pb2 as src_dot_ray_dot_protobuf_dot_ray__client__pb2 + + +class RayletDriverStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Init = channel.unary_unary( + '/ray.rpc.RayletDriver/Init', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitResponse.FromString, + ) + self.PrepRuntimeEnv = channel.unary_unary( + '/ray.rpc.RayletDriver/PrepRuntimeEnv', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvResponse.FromString, + ) + self.GetObject = channel.unary_stream( + '/ray.rpc.RayletDriver/GetObject', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetResponse.FromString, + ) + self.PutObject = channel.unary_unary( + '/ray.rpc.RayletDriver/PutObject', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutResponse.FromString, + ) + self.WaitObject = channel.unary_unary( + '/ray.rpc.RayletDriver/WaitObject', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitResponse.FromString, + ) + self.Schedule = channel.unary_unary( + '/ray.rpc.RayletDriver/Schedule', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTask.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTaskTicket.FromString, + ) + self.Terminate = channel.unary_unary( + '/ray.rpc.RayletDriver/Terminate', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateResponse.FromString, + ) + self.ClusterInfo = channel.unary_unary( + '/ray.rpc.RayletDriver/ClusterInfo', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoResponse.FromString, + ) + self.KVGet = channel.unary_unary( + '/ray.rpc.RayletDriver/KVGet', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetResponse.FromString, + ) + self.KVPut = channel.unary_unary( + '/ray.rpc.RayletDriver/KVPut', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutResponse.FromString, + ) + self.KVDel = channel.unary_unary( + '/ray.rpc.RayletDriver/KVDel', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelResponse.FromString, + ) + self.KVList = channel.unary_unary( + '/ray.rpc.RayletDriver/KVList', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListResponse.FromString, + ) + self.KVExists = channel.unary_unary( + '/ray.rpc.RayletDriver/KVExists', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsResponse.FromString, + ) + self.ListNamedActors = channel.unary_unary( + '/ray.rpc.RayletDriver/ListNamedActors', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsResponse.FromString, + ) + self.PinRuntimeEnvURI = channel.unary_unary( + '/ray.rpc.RayletDriver/PinRuntimeEnvURI', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIResponse.FromString, + ) + + +class RayletDriverServicer(object): + """Missing associated documentation comment in .proto file.""" + + def Init(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PrepRuntimeEnv(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetObject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PutObject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WaitObject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Schedule(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Terminate(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ClusterInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KVGet(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KVPut(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KVDel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KVList(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def KVExists(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListNamedActors(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PinRuntimeEnvURI(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RayletDriverServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Init': grpc.unary_unary_rpc_method_handler( + servicer.Init, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitResponse.SerializeToString, + ), + 'PrepRuntimeEnv': grpc.unary_unary_rpc_method_handler( + servicer.PrepRuntimeEnv, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvResponse.SerializeToString, + ), + 'GetObject': grpc.unary_stream_rpc_method_handler( + servicer.GetObject, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetResponse.SerializeToString, + ), + 'PutObject': grpc.unary_unary_rpc_method_handler( + servicer.PutObject, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutResponse.SerializeToString, + ), + 'WaitObject': grpc.unary_unary_rpc_method_handler( + servicer.WaitObject, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitResponse.SerializeToString, + ), + 'Schedule': grpc.unary_unary_rpc_method_handler( + servicer.Schedule, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTask.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTaskTicket.SerializeToString, + ), + 'Terminate': grpc.unary_unary_rpc_method_handler( + servicer.Terminate, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateResponse.SerializeToString, + ), + 'ClusterInfo': grpc.unary_unary_rpc_method_handler( + servicer.ClusterInfo, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoResponse.SerializeToString, + ), + 'KVGet': grpc.unary_unary_rpc_method_handler( + servicer.KVGet, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetResponse.SerializeToString, + ), + 'KVPut': grpc.unary_unary_rpc_method_handler( + servicer.KVPut, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutResponse.SerializeToString, + ), + 'KVDel': grpc.unary_unary_rpc_method_handler( + servicer.KVDel, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelResponse.SerializeToString, + ), + 'KVList': grpc.unary_unary_rpc_method_handler( + servicer.KVList, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListResponse.SerializeToString, + ), + 'KVExists': grpc.unary_unary_rpc_method_handler( + servicer.KVExists, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsResponse.SerializeToString, + ), + 'ListNamedActors': grpc.unary_unary_rpc_method_handler( + servicer.ListNamedActors, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsResponse.SerializeToString, + ), + 'PinRuntimeEnvURI': grpc.unary_unary_rpc_method_handler( + servicer.PinRuntimeEnvURI, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.RayletDriver', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RayletDriver(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def Init(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/Init', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.InitResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PrepRuntimeEnv(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/PrepRuntimeEnv', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.PrepRuntimeEnvResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetObject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/ray.rpc.RayletDriver/GetObject', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.GetResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PutObject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/PutObject', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.PutResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WaitObject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/WaitObject', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.WaitResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Schedule(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/Schedule', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTask.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientTaskTicket.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Terminate(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/Terminate', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.TerminateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ClusterInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/ClusterInfo', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClusterInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KVGet(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/KVGet', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVGetResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KVPut(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/KVPut', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVPutResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KVDel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/KVDel', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVDelResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KVList(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/KVList', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVListResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def KVExists(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/KVExists', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.KVExistsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListNamedActors(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/ListNamedActors', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientListNamedActorsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PinRuntimeEnvURI(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.RayletDriver/PinRuntimeEnvURI', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.ClientPinRuntimeEnvURIResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class RayletDataStreamerStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Datapath = channel.stream_stream( + '/ray.rpc.RayletDataStreamer/Datapath', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataResponse.FromString, + ) + + +class RayletDataStreamerServicer(object): + """Missing associated documentation comment in .proto file.""" + + def Datapath(self, request_iterator, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RayletDataStreamerServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Datapath': grpc.stream_stream_rpc_method_handler( + servicer.Datapath, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.RayletDataStreamer', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RayletDataStreamer(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def Datapath(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream(request_iterator, target, '/ray.rpc.RayletDataStreamer/Datapath', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.DataResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class RayletLogStreamerStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Logstream = channel.stream_stream( + '/ray.rpc.RayletLogStreamer/Logstream', + request_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogSettingsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogData.FromString, + ) + + +class RayletLogStreamerServicer(object): + """Missing associated documentation comment in .proto file.""" + + def Logstream(self, request_iterator, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RayletLogStreamerServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Logstream': grpc.stream_stream_rpc_method_handler( + servicer.Logstream, + request_deserializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogSettingsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogData.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.RayletLogStreamer', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RayletLogStreamer(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def Logstream(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream(request_iterator, target, '/ray.rpc.RayletLogStreamer/Logstream', + src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogSettingsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_ray__client__pb2.LogData.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/reporter_pb2.py b/lib/python3.12/site-packages/ray/core/generated/reporter_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..6434bddff8f146d2809ac9f22319bba32b6e217d --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/reporter_pb2.py @@ -0,0 +1,191 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/reporter.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import metrics_pb2 as opencensus_dot_proto_dot_metrics_dot_v1_dot_metrics__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1fsrc/ray/protobuf/reporter.proto\x12\x07ray.rpc\x1a)opencensus/proto/metrics/v1/metrics.proto\"O\n\x13GetTracebackRequest\x12\x10\n\x03pid\x18\x01 \x01(\rR\x03pid\x12\x1b\n\x06native\x18\x02 \x01(\x08H\x00R\x06native\x88\x01\x01\x42\t\n\x07_native\"E\n\x11GetTracebackReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\x12\x16\n\x06output\x18\x02 \x01(\tR\x06output\"\xa5\x01\n\x13\x43puProfilingRequest\x12\x10\n\x03pid\x18\x01 \x01(\rR\x03pid\x12\x1b\n\x06\x66ormat\x18\x02 \x01(\tH\x00R\x06\x66ormat\x88\x01\x01\x12\x1f\n\x08\x64uration\x18\x03 \x01(\rH\x01R\x08\x64uration\x88\x01\x01\x12\x1b\n\x06native\x18\x04 \x01(\x08H\x02R\x06native\x88\x01\x01\x42\t\n\x07_formatB\x0b\n\t_durationB\t\n\x07_native\"E\n\x11\x43puProfilingReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\x12\x16\n\x06output\x18\x02 \x01(\tR\x06output\"f\n\x13GpuProfilingRequest\x12\x10\n\x03pid\x18\x01 \x01(\rR\x03pid\x12*\n\x0enum_iterations\x18\x02 \x01(\rH\x00R\rnumIterations\x88\x01\x01\x42\x11\n\x0f_num_iterations\"E\n\x11GpuProfilingReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\x12\x16\n\x06output\x18\x02 \x01(\tR\x06output\"\xa6\x02\n\x16MemoryProfilingRequest\x12\x10\n\x03pid\x18\x01 \x01(\rR\x03pid\x12\x1b\n\x06\x66ormat\x18\x02 \x01(\tH\x00R\x06\x66ormat\x88\x01\x01\x12\x1f\n\x08\x64uration\x18\x03 \x01(\rH\x01R\x08\x64uration\x88\x01\x01\x12\x1b\n\x06native\x18\x04 \x01(\x08H\x02R\x06native\x88\x01\x01\x12\x19\n\x05leaks\x18\x05 \x01(\x08H\x03R\x05leaks\x88\x01\x01\x12;\n\x17trace_python_allocators\x18\x06 \x01(\x08H\x04R\x15tracePythonAllocators\x88\x01\x01\x42\t\n\x07_formatB\x0b\n\t_durationB\t\n\x07_nativeB\x08\n\x06_leaksB\x1a\n\x18_trace_python_allocators\"s\n\x14MemoryProfilingReply\x12\x18\n\x07success\x18\x01 \x01(\x08R\x07success\x12\x16\n\x06output\x18\x02 \x01(\tR\x06output\x12\x1d\n\x07warning\x18\x03 \x01(\tH\x00R\x07warning\x88\x01\x01\x42\n\n\x08_warning\"t\n\x16ReportOCMetricsRequest\x12=\n\x07metrics\x18\x01 \x03(\x0b\x32#.opencensus.proto.metrics.v1.MetricR\x07metrics\x12\x1b\n\tworker_id\x18\x02 \x01(\x0cR\x08workerId\"\x16\n\x14ReportOCMetricsReply\"\x14\n\x12HealthCheckRequest\"\x12\n\x10HealthCheckReply\"\x94\x02\n\x10StreamLogRequest\x12\"\n\rlog_file_name\x18\x01 \x01(\tR\x0blogFileName\x12\x1d\n\nkeep_alive\x18\x02 \x01(\x08R\tkeepAlive\x12\x19\n\x05lines\x18\x03 \x01(\x05H\x00R\x05lines\x88\x01\x01\x12\x1f\n\x08interval\x18\x04 \x01(\x02H\x01R\x08interval\x88\x01\x01\x12&\n\x0cstart_offset\x18\x05 \x01(\x05H\x02R\x0bstartOffset\x88\x01\x01\x12\"\n\nend_offset\x18\x06 \x01(\x05H\x03R\tendOffset\x88\x01\x01\x42\x08\n\x06_linesB\x0b\n\t_intervalB\x0f\n\r_start_offsetB\r\n\x0b_end_offset\"$\n\x0eStreamLogReply\x12\x12\n\x04\x64\x61ta\x18\x01 \x01(\x0cR\x04\x64\x61ta\"2\n\x0fListLogsRequest\x12\x1f\n\x0bglob_filter\x18\x01 \x01(\tR\nglobFilter\",\n\rListLogsReply\x12\x1b\n\tlog_files\x18\x01 \x03(\tR\x08logFiles2\xdc\x03\n\x0fReporterService\x12Q\n\x0fReportOCMetrics\x12\x1f.ray.rpc.ReportOCMetricsRequest\x1a\x1d.ray.rpc.ReportOCMetricsReply\x12H\n\x0cGetTraceback\x12\x1c.ray.rpc.GetTracebackRequest\x1a\x1a.ray.rpc.GetTracebackReply\x12H\n\x0c\x43puProfiling\x12\x1c.ray.rpc.CpuProfilingRequest\x1a\x1a.ray.rpc.CpuProfilingReply\x12H\n\x0cGpuProfiling\x12\x1c.ray.rpc.GpuProfilingRequest\x1a\x1a.ray.rpc.GpuProfilingReply\x12Q\n\x0fMemoryProfiling\x12\x1f.ray.rpc.MemoryProfilingRequest\x1a\x1d.ray.rpc.MemoryProfilingReply\x12\x45\n\x0bHealthCheck\x12\x1b.ray.rpc.HealthCheckRequest\x1a\x19.ray.rpc.HealthCheckReply2\x8d\x01\n\nLogService\x12<\n\x08ListLogs\x12\x18.ray.rpc.ListLogsRequest\x1a\x16.ray.rpc.ListLogsReply\x12\x41\n\tStreamLog\x12\x19.ray.rpc.StreamLogRequest\x1a\x17.ray.rpc.StreamLogReply0\x01\x62\x06proto3') + + + +_GETTRACEBACKREQUEST = DESCRIPTOR.message_types_by_name['GetTracebackRequest'] +_GETTRACEBACKREPLY = DESCRIPTOR.message_types_by_name['GetTracebackReply'] +_CPUPROFILINGREQUEST = DESCRIPTOR.message_types_by_name['CpuProfilingRequest'] +_CPUPROFILINGREPLY = DESCRIPTOR.message_types_by_name['CpuProfilingReply'] +_GPUPROFILINGREQUEST = DESCRIPTOR.message_types_by_name['GpuProfilingRequest'] +_GPUPROFILINGREPLY = DESCRIPTOR.message_types_by_name['GpuProfilingReply'] +_MEMORYPROFILINGREQUEST = DESCRIPTOR.message_types_by_name['MemoryProfilingRequest'] +_MEMORYPROFILINGREPLY = DESCRIPTOR.message_types_by_name['MemoryProfilingReply'] +_REPORTOCMETRICSREQUEST = DESCRIPTOR.message_types_by_name['ReportOCMetricsRequest'] +_REPORTOCMETRICSREPLY = DESCRIPTOR.message_types_by_name['ReportOCMetricsReply'] +_HEALTHCHECKREQUEST = DESCRIPTOR.message_types_by_name['HealthCheckRequest'] +_HEALTHCHECKREPLY = DESCRIPTOR.message_types_by_name['HealthCheckReply'] +_STREAMLOGREQUEST = DESCRIPTOR.message_types_by_name['StreamLogRequest'] +_STREAMLOGREPLY = DESCRIPTOR.message_types_by_name['StreamLogReply'] +_LISTLOGSREQUEST = DESCRIPTOR.message_types_by_name['ListLogsRequest'] +_LISTLOGSREPLY = DESCRIPTOR.message_types_by_name['ListLogsReply'] +GetTracebackRequest = _reflection.GeneratedProtocolMessageType('GetTracebackRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETTRACEBACKREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTracebackRequest) + }) +_sym_db.RegisterMessage(GetTracebackRequest) + +GetTracebackReply = _reflection.GeneratedProtocolMessageType('GetTracebackReply', (_message.Message,), { + 'DESCRIPTOR' : _GETTRACEBACKREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetTracebackReply) + }) +_sym_db.RegisterMessage(GetTracebackReply) + +CpuProfilingRequest = _reflection.GeneratedProtocolMessageType('CpuProfilingRequest', (_message.Message,), { + 'DESCRIPTOR' : _CPUPROFILINGREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CpuProfilingRequest) + }) +_sym_db.RegisterMessage(CpuProfilingRequest) + +CpuProfilingReply = _reflection.GeneratedProtocolMessageType('CpuProfilingReply', (_message.Message,), { + 'DESCRIPTOR' : _CPUPROFILINGREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.CpuProfilingReply) + }) +_sym_db.RegisterMessage(CpuProfilingReply) + +GpuProfilingRequest = _reflection.GeneratedProtocolMessageType('GpuProfilingRequest', (_message.Message,), { + 'DESCRIPTOR' : _GPUPROFILINGREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GpuProfilingRequest) + }) +_sym_db.RegisterMessage(GpuProfilingRequest) + +GpuProfilingReply = _reflection.GeneratedProtocolMessageType('GpuProfilingReply', (_message.Message,), { + 'DESCRIPTOR' : _GPUPROFILINGREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GpuProfilingReply) + }) +_sym_db.RegisterMessage(GpuProfilingReply) + +MemoryProfilingRequest = _reflection.GeneratedProtocolMessageType('MemoryProfilingRequest', (_message.Message,), { + 'DESCRIPTOR' : _MEMORYPROFILINGREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.MemoryProfilingRequest) + }) +_sym_db.RegisterMessage(MemoryProfilingRequest) + +MemoryProfilingReply = _reflection.GeneratedProtocolMessageType('MemoryProfilingReply', (_message.Message,), { + 'DESCRIPTOR' : _MEMORYPROFILINGREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.MemoryProfilingReply) + }) +_sym_db.RegisterMessage(MemoryProfilingReply) + +ReportOCMetricsRequest = _reflection.GeneratedProtocolMessageType('ReportOCMetricsRequest', (_message.Message,), { + 'DESCRIPTOR' : _REPORTOCMETRICSREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportOCMetricsRequest) + }) +_sym_db.RegisterMessage(ReportOCMetricsRequest) + +ReportOCMetricsReply = _reflection.GeneratedProtocolMessageType('ReportOCMetricsReply', (_message.Message,), { + 'DESCRIPTOR' : _REPORTOCMETRICSREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ReportOCMetricsReply) + }) +_sym_db.RegisterMessage(ReportOCMetricsReply) + +HealthCheckRequest = _reflection.GeneratedProtocolMessageType('HealthCheckRequest', (_message.Message,), { + 'DESCRIPTOR' : _HEALTHCHECKREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.HealthCheckRequest) + }) +_sym_db.RegisterMessage(HealthCheckRequest) + +HealthCheckReply = _reflection.GeneratedProtocolMessageType('HealthCheckReply', (_message.Message,), { + 'DESCRIPTOR' : _HEALTHCHECKREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.HealthCheckReply) + }) +_sym_db.RegisterMessage(HealthCheckReply) + +StreamLogRequest = _reflection.GeneratedProtocolMessageType('StreamLogRequest', (_message.Message,), { + 'DESCRIPTOR' : _STREAMLOGREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.StreamLogRequest) + }) +_sym_db.RegisterMessage(StreamLogRequest) + +StreamLogReply = _reflection.GeneratedProtocolMessageType('StreamLogReply', (_message.Message,), { + 'DESCRIPTOR' : _STREAMLOGREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.StreamLogReply) + }) +_sym_db.RegisterMessage(StreamLogReply) + +ListLogsRequest = _reflection.GeneratedProtocolMessageType('ListLogsRequest', (_message.Message,), { + 'DESCRIPTOR' : _LISTLOGSREQUEST, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ListLogsRequest) + }) +_sym_db.RegisterMessage(ListLogsRequest) + +ListLogsReply = _reflection.GeneratedProtocolMessageType('ListLogsReply', (_message.Message,), { + 'DESCRIPTOR' : _LISTLOGSREPLY, + '__module__' : 'src.ray.protobuf.reporter_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.ListLogsReply) + }) +_sym_db.RegisterMessage(ListLogsReply) + +_REPORTERSERVICE = DESCRIPTOR.services_by_name['ReporterService'] +_LOGSERVICE = DESCRIPTOR.services_by_name['LogService'] +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _GETTRACEBACKREQUEST._serialized_start=87 + _GETTRACEBACKREQUEST._serialized_end=166 + _GETTRACEBACKREPLY._serialized_start=168 + _GETTRACEBACKREPLY._serialized_end=237 + _CPUPROFILINGREQUEST._serialized_start=240 + _CPUPROFILINGREQUEST._serialized_end=405 + _CPUPROFILINGREPLY._serialized_start=407 + _CPUPROFILINGREPLY._serialized_end=476 + _GPUPROFILINGREQUEST._serialized_start=478 + _GPUPROFILINGREQUEST._serialized_end=580 + _GPUPROFILINGREPLY._serialized_start=582 + _GPUPROFILINGREPLY._serialized_end=651 + _MEMORYPROFILINGREQUEST._serialized_start=654 + _MEMORYPROFILINGREQUEST._serialized_end=948 + _MEMORYPROFILINGREPLY._serialized_start=950 + _MEMORYPROFILINGREPLY._serialized_end=1065 + _REPORTOCMETRICSREQUEST._serialized_start=1067 + _REPORTOCMETRICSREQUEST._serialized_end=1183 + _REPORTOCMETRICSREPLY._serialized_start=1185 + _REPORTOCMETRICSREPLY._serialized_end=1207 + _HEALTHCHECKREQUEST._serialized_start=1209 + _HEALTHCHECKREQUEST._serialized_end=1229 + _HEALTHCHECKREPLY._serialized_start=1231 + _HEALTHCHECKREPLY._serialized_end=1249 + _STREAMLOGREQUEST._serialized_start=1252 + _STREAMLOGREQUEST._serialized_end=1528 + _STREAMLOGREPLY._serialized_start=1530 + _STREAMLOGREPLY._serialized_end=1566 + _LISTLOGSREQUEST._serialized_start=1568 + _LISTLOGSREQUEST._serialized_end=1618 + _LISTLOGSREPLY._serialized_start=1620 + _LISTLOGSREPLY._serialized_end=1664 + _REPORTERSERVICE._serialized_start=1667 + _REPORTERSERVICE._serialized_end=2143 + _LOGSERVICE._serialized_start=2146 + _LOGSERVICE._serialized_end=2287 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/reporter_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/reporter_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..d71192a5766a09accd1bd711075fd8ccc1b58053 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/reporter_pb2_grpc.py @@ -0,0 +1,325 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import reporter_pb2 as src_dot_ray_dot_protobuf_dot_reporter__pb2 + + +class ReporterServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ReportOCMetrics = channel.unary_unary( + '/ray.rpc.ReporterService/ReportOCMetrics', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsReply.FromString, + ) + self.GetTraceback = channel.unary_unary( + '/ray.rpc.ReporterService/GetTraceback', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackReply.FromString, + ) + self.CpuProfiling = channel.unary_unary( + '/ray.rpc.ReporterService/CpuProfiling', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingReply.FromString, + ) + self.GpuProfiling = channel.unary_unary( + '/ray.rpc.ReporterService/GpuProfiling', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingReply.FromString, + ) + self.MemoryProfiling = channel.unary_unary( + '/ray.rpc.ReporterService/MemoryProfiling', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingReply.FromString, + ) + self.HealthCheck = channel.unary_unary( + '/ray.rpc.ReporterService/HealthCheck', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckReply.FromString, + ) + + +class ReporterServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def ReportOCMetrics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTraceback(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CpuProfiling(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GpuProfiling(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def MemoryProfiling(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HealthCheck(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ReporterServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ReportOCMetrics': grpc.unary_unary_rpc_method_handler( + servicer.ReportOCMetrics, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsReply.SerializeToString, + ), + 'GetTraceback': grpc.unary_unary_rpc_method_handler( + servicer.GetTraceback, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackReply.SerializeToString, + ), + 'CpuProfiling': grpc.unary_unary_rpc_method_handler( + servicer.CpuProfiling, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingReply.SerializeToString, + ), + 'GpuProfiling': grpc.unary_unary_rpc_method_handler( + servicer.GpuProfiling, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingReply.SerializeToString, + ), + 'MemoryProfiling': grpc.unary_unary_rpc_method_handler( + servicer.MemoryProfiling, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingReply.SerializeToString, + ), + 'HealthCheck': grpc.unary_unary_rpc_method_handler( + servicer.HealthCheck, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.ReporterService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ReporterService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def ReportOCMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/ReportOCMetrics', + src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.ReportOCMetricsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTraceback(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/GetTraceback', + src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.GetTracebackReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CpuProfiling(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/CpuProfiling', + src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.CpuProfilingReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GpuProfiling(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/GpuProfiling', + src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.GpuProfilingReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def MemoryProfiling(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/MemoryProfiling', + src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.MemoryProfilingReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HealthCheck(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.ReporterService/HealthCheck', + src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.HealthCheckReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class LogServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ListLogs = channel.unary_unary( + '/ray.rpc.LogService/ListLogs', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsReply.FromString, + ) + self.StreamLog = channel.unary_stream( + '/ray.rpc.LogService/StreamLog', + request_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogRequest.SerializeToString, + response_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogReply.FromString, + ) + + +class LogServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def ListLogs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StreamLog(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_LogServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ListLogs': grpc.unary_unary_rpc_method_handler( + servicer.ListLogs, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsReply.SerializeToString, + ), + 'StreamLog': grpc.unary_stream_rpc_method_handler( + servicer.StreamLog, + request_deserializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogRequest.FromString, + response_serializer=src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogReply.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'ray.rpc.LogService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class LogService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def ListLogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/ray.rpc.LogService/ListLogs', + src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.ListLogsReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def StreamLog(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/ray.rpc.LogService/StreamLog', + src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogRequest.SerializeToString, + src_dot_ray_dot_protobuf_dot_reporter__pb2.StreamLogReply.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/lib/python3.12/site-packages/ray/core/generated/resource_pb2.py b/lib/python3.12/site-packages/ray/core/generated/resource_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..434c79158573f0853a3a4e8c51c3f74dd6797b0c --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/resource_pb2.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: opencensus/proto/resource/v1/resource.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+opencensus/proto/resource/v1/resource.proto\x12\x1copencensus.proto.resource.v1\"\xa5\x01\n\x08Resource\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12J\n\x06labels\x18\x02 \x03(\x0b\x32\x32.opencensus.proto.resource.v1.Resource.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x98\x01\n\x1fio.opencensus.proto.resource.v1B\rResourceProtoP\x01ZEgithub.com/census-instrumentation/opencensus-proto/gen-go/resource/v1\xea\x02\x1cOpenCensus.Proto.Resource.V1b\x06proto3') + + + +_RESOURCE = DESCRIPTOR.message_types_by_name['Resource'] +_RESOURCE_LABELSENTRY = _RESOURCE.nested_types_by_name['LabelsEntry'] +Resource = _reflection.GeneratedProtocolMessageType('Resource', (_message.Message,), { + + 'LabelsEntry' : _reflection.GeneratedProtocolMessageType('LabelsEntry', (_message.Message,), { + 'DESCRIPTOR' : _RESOURCE_LABELSENTRY, + '__module__' : 'opencensus.proto.resource.v1.resource_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.resource.v1.Resource.LabelsEntry) + }) + , + 'DESCRIPTOR' : _RESOURCE, + '__module__' : 'opencensus.proto.resource.v1.resource_pb2' + # @@protoc_insertion_point(class_scope:opencensus.proto.resource.v1.Resource) + }) +_sym_db.RegisterMessage(Resource) +_sym_db.RegisterMessage(Resource.LabelsEntry) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\037io.opencensus.proto.resource.v1B\rResourceProtoP\001ZEgithub.com/census-instrumentation/opencensus-proto/gen-go/resource/v1\352\002\034OpenCensus.Proto.Resource.V1' + _RESOURCE_LABELSENTRY._options = None + _RESOURCE_LABELSENTRY._serialized_options = b'8\001' + _RESOURCE._serialized_start=78 + _RESOURCE._serialized_end=243 + _RESOURCE_LABELSENTRY._serialized_start=186 + _RESOURCE_LABELSENTRY._serialized_end=243 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/resource_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/resource_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/resource_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2.py b/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..b4d4f3426d055bbd5b0646ad5ba8f99d913f920a --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2.py @@ -0,0 +1,93 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/runtime_env_agent.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import runtime_env_common_pb2 as src_dot_ray_dot_protobuf_dot_runtime__env__common__pb2 +from . import runtime_environment_pb2 as src_dot_ray_dot_protobuf_dot_public_dot_runtime__environment__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n(src/ray/protobuf/runtime_env_agent.proto\x12\x07ray.rpc\x1a)src/ray/protobuf/runtime_env_common.proto\x1a\x31src/ray/protobuf/public/runtime_environment.proto\"\xdb\x01\n\x1cGetOrCreateRuntimeEnvRequest\x12\x34\n\x16serialized_runtime_env\x18\x01 \x01(\tR\x14serializedRuntimeEnv\x12G\n\x12runtime_env_config\x18\x02 \x01(\x0b\x32\x19.ray.rpc.RuntimeEnvConfigR\x10runtimeEnvConfig\x12\x15\n\x06job_id\x18\x03 \x01(\x0cR\x05jobId\x12%\n\x0esource_process\x18\x04 \x01(\tR\rsourceProcess\"\xb7\x01\n\x1aGetOrCreateRuntimeEnvReply\x12/\n\x06status\x18\x01 \x01(\x0e\x32\x17.ray.rpc.AgentRpcStatusR\x06status\x12#\n\rerror_message\x18\x02 \x01(\tR\x0c\x65rrorMessage\x12\x43\n\x1eserialized_runtime_env_context\x18\x03 \x01(\tR\x1bserializedRuntimeEnvContext\"\x80\x01\n!DeleteRuntimeEnvIfPossibleRequest\x12\x34\n\x16serialized_runtime_env\x18\x01 \x01(\tR\x14serializedRuntimeEnv\x12%\n\x0esource_process\x18\x02 \x01(\tR\rsourceProcess\"w\n\x1f\x44\x65leteRuntimeEnvIfPossibleReply\x12/\n\x06status\x18\x01 \x01(\x0e\x32\x17.ray.rpc.AgentRpcStatusR\x06status\x12#\n\rerror_message\x18\x02 \x01(\tR\x0c\x65rrorMessage\"@\n\x19GetRuntimeEnvsInfoRequest\x12\x19\n\x05limit\x18\x01 \x01(\x03H\x00R\x05limit\x88\x01\x01\x42\x08\n\x06_limit\"w\n\x17GetRuntimeEnvsInfoReply\x12\x46\n\x12runtime_env_states\x18\x01 \x03(\x0b\x32\x18.ray.rpc.RuntimeEnvStateR\x10runtimeEnvStates\x12\x14\n\x05total\x18\x02 \x01(\x03R\x05total*F\n\x0e\x41gentRpcStatus\x12\x17\n\x13\x41GENT_RPC_STATUS_OK\x10\x00\x12\x1b\n\x17\x41GENT_RPC_STATUS_FAILED\x10\x01\x62\x06proto3') + +_AGENTRPCSTATUS = DESCRIPTOR.enum_types_by_name['AgentRpcStatus'] +AgentRpcStatus = enum_type_wrapper.EnumTypeWrapper(_AGENTRPCSTATUS) +AGENT_RPC_STATUS_OK = 0 +AGENT_RPC_STATUS_FAILED = 1 + + +_GETORCREATERUNTIMEENVREQUEST = DESCRIPTOR.message_types_by_name['GetOrCreateRuntimeEnvRequest'] +_GETORCREATERUNTIMEENVREPLY = DESCRIPTOR.message_types_by_name['GetOrCreateRuntimeEnvReply'] +_DELETERUNTIMEENVIFPOSSIBLEREQUEST = DESCRIPTOR.message_types_by_name['DeleteRuntimeEnvIfPossibleRequest'] +_DELETERUNTIMEENVIFPOSSIBLEREPLY = DESCRIPTOR.message_types_by_name['DeleteRuntimeEnvIfPossibleReply'] +_GETRUNTIMEENVSINFOREQUEST = DESCRIPTOR.message_types_by_name['GetRuntimeEnvsInfoRequest'] +_GETRUNTIMEENVSINFOREPLY = DESCRIPTOR.message_types_by_name['GetRuntimeEnvsInfoReply'] +GetOrCreateRuntimeEnvRequest = _reflection.GeneratedProtocolMessageType('GetOrCreateRuntimeEnvRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETORCREATERUNTIMEENVREQUEST, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetOrCreateRuntimeEnvRequest) + }) +_sym_db.RegisterMessage(GetOrCreateRuntimeEnvRequest) + +GetOrCreateRuntimeEnvReply = _reflection.GeneratedProtocolMessageType('GetOrCreateRuntimeEnvReply', (_message.Message,), { + 'DESCRIPTOR' : _GETORCREATERUNTIMEENVREPLY, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetOrCreateRuntimeEnvReply) + }) +_sym_db.RegisterMessage(GetOrCreateRuntimeEnvReply) + +DeleteRuntimeEnvIfPossibleRequest = _reflection.GeneratedProtocolMessageType('DeleteRuntimeEnvIfPossibleRequest', (_message.Message,), { + 'DESCRIPTOR' : _DELETERUNTIMEENVIFPOSSIBLEREQUEST, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteRuntimeEnvIfPossibleRequest) + }) +_sym_db.RegisterMessage(DeleteRuntimeEnvIfPossibleRequest) + +DeleteRuntimeEnvIfPossibleReply = _reflection.GeneratedProtocolMessageType('DeleteRuntimeEnvIfPossibleReply', (_message.Message,), { + 'DESCRIPTOR' : _DELETERUNTIMEENVIFPOSSIBLEREPLY, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.DeleteRuntimeEnvIfPossibleReply) + }) +_sym_db.RegisterMessage(DeleteRuntimeEnvIfPossibleReply) + +GetRuntimeEnvsInfoRequest = _reflection.GeneratedProtocolMessageType('GetRuntimeEnvsInfoRequest', (_message.Message,), { + 'DESCRIPTOR' : _GETRUNTIMEENVSINFOREQUEST, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetRuntimeEnvsInfoRequest) + }) +_sym_db.RegisterMessage(GetRuntimeEnvsInfoRequest) + +GetRuntimeEnvsInfoReply = _reflection.GeneratedProtocolMessageType('GetRuntimeEnvsInfoReply', (_message.Message,), { + 'DESCRIPTOR' : _GETRUNTIMEENVSINFOREPLY, + '__module__' : 'src.ray.protobuf.runtime_env_agent_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.GetRuntimeEnvsInfoReply) + }) +_sym_db.RegisterMessage(GetRuntimeEnvsInfoReply) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _AGENTRPCSTATUS._serialized_start=994 + _AGENTRPCSTATUS._serialized_end=1064 + _GETORCREATERUNTIMEENVREQUEST._serialized_start=148 + _GETORCREATERUNTIMEENVREQUEST._serialized_end=367 + _GETORCREATERUNTIMEENVREPLY._serialized_start=370 + _GETORCREATERUNTIMEENVREPLY._serialized_end=553 + _DELETERUNTIMEENVIFPOSSIBLEREQUEST._serialized_start=556 + _DELETERUNTIMEENVIFPOSSIBLEREQUEST._serialized_end=684 + _DELETERUNTIMEENVIFPOSSIBLEREPLY._serialized_start=686 + _DELETERUNTIMEENVIFPOSSIBLEREPLY._serialized_end=805 + _GETRUNTIMEENVSINFOREQUEST._serialized_start=807 + _GETRUNTIMEENVSINFOREQUEST._serialized_end=871 + _GETRUNTIMEENVSINFOREPLY._serialized_start=873 + _GETRUNTIMEENVSINFOREPLY._serialized_end=992 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_env_agent_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2.py b/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..a6f65f37a96157217621689a190b29c02907f86a --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/runtime_env_common.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)src/ray/protobuf/runtime_env_common.proto\x12\x07ray.rpc\"\xdf\x01\n\x0fRuntimeEnvState\x12\x1f\n\x0bruntime_env\x18\x01 \x01(\tR\nruntimeEnv\x12\x17\n\x07ref_cnt\x18\x02 \x01(\x03R\x06refCnt\x12\x1d\n\x07success\x18\x03 \x01(\x08H\x00R\x07success\x88\x01\x01\x12\x19\n\x05\x65rror\x18\x04 \x01(\tH\x01R\x05\x65rror\x88\x01\x01\x12-\n\x10\x63reation_time_ms\x18\x05 \x01(\x03H\x02R\x0e\x63reationTimeMs\x88\x01\x01\x42\n\n\x08_successB\x08\n\x06_errorB\x13\n\x11_creation_time_msB\x1a\n\x18io.ray.runtime.generatedb\x06proto3') + + + +_RUNTIMEENVSTATE = DESCRIPTOR.message_types_by_name['RuntimeEnvState'] +RuntimeEnvState = _reflection.GeneratedProtocolMessageType('RuntimeEnvState', (_message.Message,), { + 'DESCRIPTOR' : _RUNTIMEENVSTATE, + '__module__' : 'src.ray.protobuf.runtime_env_common_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RuntimeEnvState) + }) +_sym_db.RegisterMessage(RuntimeEnvState) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\030io.ray.runtime.generated' + _RUNTIMEENVSTATE._serialized_start=55 + _RUNTIMEENVSTATE._serialized_end=278 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_env_common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2.py b/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..b361386d342f8037c6dece52e77c60e07504918f --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/public/runtime_environment.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n1src/ray/protobuf/public/runtime_environment.proto\x12\x07ray.rpc\"`\n\x0eRuntimeEnvUris\x12&\n\x0fworking_dir_uri\x18\x01 \x01(\tR\rworkingDirUri\x12&\n\x0fpy_modules_uris\x18\x02 \x03(\tR\rpyModulesUris\"\x88\x01\n\x10RuntimeEnvConfig\x12\x32\n\x15setup_timeout_seconds\x18\x01 \x01(\x05R\x13setupTimeoutSeconds\x12#\n\reager_install\x18\x02 \x01(\x08R\x0c\x65\x61gerInstall\x12\x1b\n\tlog_files\x18\x03 \x03(\tR\x08logFiles\"\xbc\x01\n\x0eRuntimeEnvInfo\x12\x34\n\x16serialized_runtime_env\x18\x01 \x01(\tR\x14serializedRuntimeEnv\x12+\n\x04uris\x18\x02 \x01(\x0b\x32\x17.ray.rpc.RuntimeEnvUrisR\x04uris\x12G\n\x12runtime_env_config\x18\x03 \x01(\x0b\x32\x19.ray.rpc.RuntimeEnvConfigR\x10runtimeEnvConfigB\x1a\n\x18io.ray.runtime.generatedb\x06proto3') + + + +_RUNTIMEENVURIS = DESCRIPTOR.message_types_by_name['RuntimeEnvUris'] +_RUNTIMEENVCONFIG = DESCRIPTOR.message_types_by_name['RuntimeEnvConfig'] +_RUNTIMEENVINFO = DESCRIPTOR.message_types_by_name['RuntimeEnvInfo'] +RuntimeEnvUris = _reflection.GeneratedProtocolMessageType('RuntimeEnvUris', (_message.Message,), { + 'DESCRIPTOR' : _RUNTIMEENVURIS, + '__module__' : 'src.ray.protobuf.public.runtime_environment_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RuntimeEnvUris) + }) +_sym_db.RegisterMessage(RuntimeEnvUris) + +RuntimeEnvConfig = _reflection.GeneratedProtocolMessageType('RuntimeEnvConfig', (_message.Message,), { + 'DESCRIPTOR' : _RUNTIMEENVCONFIG, + '__module__' : 'src.ray.protobuf.public.runtime_environment_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RuntimeEnvConfig) + }) +_sym_db.RegisterMessage(RuntimeEnvConfig) + +RuntimeEnvInfo = _reflection.GeneratedProtocolMessageType('RuntimeEnvInfo', (_message.Message,), { + 'DESCRIPTOR' : _RUNTIMEENVINFO, + '__module__' : 'src.ray.protobuf.public.runtime_environment_pb2' + # @@protoc_insertion_point(class_scope:ray.rpc.RuntimeEnvInfo) + }) +_sym_db.RegisterMessage(RuntimeEnvInfo) + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\030io.ray.runtime.generated' + _RUNTIMEENVURIS._serialized_start=62 + _RUNTIMEENVURIS._serialized_end=158 + _RUNTIMEENVCONFIG._serialized_start=161 + _RUNTIMEENVCONFIG._serialized_end=297 + _RUNTIMEENVINFO._serialized_start=300 + _RUNTIMEENVINFO._serialized_end=488 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/runtime_environment_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/generated/usage_pb2.py b/lib/python3.12/site-packages/ray/core/generated/usage_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..e84ad9a0bff99f1ffd698628330bd25e25eda1a4 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/usage_pb2.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: src/ray/protobuf/usage.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1csrc/ray/protobuf/usage.proto\x12\tray.usage*\xec\x1b\n\x06TagKey\x12\n\n\x06_TEST1\x10\x00\x12\n\n\x06_TEST2\x10\x01\x12\x13\n\x0fRLLIB_FRAMEWORK\x10\x02\x12\x13\n\x0fRLLIB_ALGORITHM\x10\x03\x12\x15\n\x11RLLIB_NUM_WORKERS\x10\x04\x12\x15\n\x11SERVE_API_VERSION\x10\x05\x12\x19\n\x15SERVE_NUM_DEPLOYMENTS\x10\x06\x12\x0f\n\x0bGCS_STORAGE\x10\x07\x12\x1d\n\x19SERVE_NUM_GPU_DEPLOYMENTS\x10\x08\x12\x16\n\x12SERVE_FASTAPI_USED\x10\t\x12\x19\n\x15SERVE_DAG_DRIVER_USED\x10\n\x12\x1b\n\x17SERVE_HTTP_ADAPTER_USED\x10\x0b\x12\x1b\n\x17SERVE_GRPC_INGRESS_USED\x10\x0c\x12\x1a\n\x16SERVE_REST_API_VERSION\x10\r\x12\x12\n\x0eSERVE_NUM_APPS\x10\x0e\x12*\n&SERVE_NUM_REPLICAS_LIGHTWEIGHT_UPDATED\x10\x0f\x12)\n%SERVE_USER_CONFIG_LIGHTWEIGHT_UPDATED\x10\x10\x12\x30\n,SERVE_AUTOSCALING_CONFIG_LIGHTWEIGHT_UPDATED\x10\x11\x12#\n\x1fSERVE_RAY_SERVE_HANDLE_API_USED\x10\x12\x12(\n$SERVE_RAY_SERVE_SYNC_HANDLE_API_USED\x10\x13\x12$\n SERVE_DEPLOYMENT_HANDLE_API_USED\x10\x14\x12\x32\n.SERVE_DEPLOYMENT_HANDLE_TO_OBJECT_REF_API_USED\x10\x15\x12\x1e\n\x1aSERVE_MULTIPLEXED_API_USED\x10\x16\x12\x19\n\x15SERVE_HTTP_PROXY_USED\x10\x17\x12\x19\n\x15SERVE_GRPC_PROXY_USED\x10\x18\x12\x19\n\x15SERVE_STATUS_API_USED\x10\x19\x12!\n\x1dSERVE_GET_APP_HANDLE_API_USED\x10\x1a\x12(\n$SERVE_GET_DEPLOYMENT_HANDLE_API_USED\x10\x1b\x12(\n$SERVE_APP_CONTAINER_RUNTIME_ENV_USED\x10\x1c\x12/\n+SERVE_DEPLOYMENT_CONTAINER_RUNTIME_ENV_USED\x10\x1d\x12\x1e\n\x1aSERVE_NUM_NODE_COMPACTIONS\x10\x1e\x12 \n\x1cSERVE_AUTO_NUM_REPLICAS_USED\x10\x1f\x12$\n SERVE_CUSTOM_REQUEST_ROUTER_USED\x10 \x12+\n\'SERVE_NUM_REPLICAS_VIA_API_CALL_UPDATED\x10!\x12\x33\n/SERVE_NUM_REPLICAS_USING_ASYNCHRONOUS_INFERENCE\x10\"\x12(\n$SERVE_CUSTOM_AUTOSCALING_POLICY_USED\x10#\x12\x1e\n\x1a\x43ORE_STATE_API_LIST_ACTORS\x10\x64\x12\x1d\n\x19\x43ORE_STATE_API_LIST_TASKS\x10\x65\x12\x1c\n\x18\x43ORE_STATE_API_LIST_JOBS\x10\x66\x12\x1d\n\x19\x43ORE_STATE_API_LIST_NODES\x10g\x12(\n$CORE_STATE_API_LIST_PLACEMENT_GROUPS\x10h\x12\x1f\n\x1b\x43ORE_STATE_API_LIST_WORKERS\x10i\x12\x1f\n\x1b\x43ORE_STATE_API_LIST_OBJECTS\x10j\x12$\n CORE_STATE_API_LIST_RUNTIME_ENVS\x10k\x12&\n\"CORE_STATE_API_LIST_CLUSTER_EVENTS\x10l\x12\x1c\n\x18\x43ORE_STATE_API_LIST_LOGS\x10m\x12\x1a\n\x16\x43ORE_STATE_API_GET_LOG\x10n\x12\"\n\x1e\x43ORE_STATE_API_SUMMARIZE_TASKS\x10o\x12#\n\x1f\x43ORE_STATE_API_SUMMARIZE_ACTORS\x10p\x12$\n CORE_STATE_API_SUMMARIZE_OBJECTS\x10q\x12\x13\n\x0e\x44\x41SHBOARD_USED\x10\xc8\x01\x12)\n$DASHBOARD_METRICS_PROMETHEUS_ENABLED\x10\xc9\x01\x12&\n!DASHBOARD_METRICS_GRAFANA_ENABLED\x10\xca\x01\x12\x13\n\x0ePG_NUM_CREATED\x10\xac\x02\x12\x16\n\x11\x41\x43TOR_NUM_CREATED\x10\xad\x02\x12\x1e\n\x19WORKER_CRASH_SYSTEM_ERROR\x10\xae\x02\x12\x15\n\x10WORKER_CRASH_OOM\x10\xaf\x02\x12\x19\n\x14RAY_GET_TIMEOUT_ZERO\x10\xb0\x02\x12\x1d\n\x18NUM_ACTOR_CREATION_TASKS\x10\xb1\x02\x12\x14\n\x0fNUM_ACTOR_TASKS\x10\xb2\x02\x12\x15\n\x10NUM_NORMAL_TASKS\x10\xb3\x02\x12\x10\n\x0bNUM_DRIVERS\x10\xb4\x02\x12\"\n\x1d\x45XPERIMENTAL_STATE_API_IMPORT\x10\xb5\x02\x12\x17\n\x12\x41UTOSCALER_VERSION\x10\xb6\x02\x12\x15\n\x10\x44\x41TA_LOGICAL_OPS\x10\x90\x03\x12\x10\n\x0b\x41IR_TRAINER\x10\xf4\x03\x12\x12\n\rTUNE_SEARCHER\x10\xf5\x03\x12\x13\n\x0eTUNE_SCHEDULER\x10\xf6\x03\x12\x11\n\x0c\x41IR_ENV_VARS\x10\xf7\x03\x12%\n AIR_SETUP_WANDB_INTEGRATION_USED\x10\xf8\x03\x12&\n!AIR_SETUP_MLFLOW_INTEGRATION_USED\x10\xf9\x03\x12\x12\n\rAIR_CALLBACKS\x10\xfa\x03\x12\x1e\n\x19\x41IR_STORAGE_CONFIGURATION\x10\xfb\x03\x12\x13\n\x0e\x41IR_ENTRYPOINT\x10\xfc\x03\x12\x1b\n\x16TRAIN_TORCH_GET_DEVICE\x10\xfd\x03\x12\x1e\n\x19TRAIN_TORCH_PREPARE_MODEL\x10\xfe\x03\x12#\n\x1eTRAIN_TORCH_PREPARE_DATALOADER\x10\xff\x03\x12$\n\x1fTRAIN_LIGHTNING_PREPARE_TRAINER\x10\x80\x04\x12+\n&TRAIN_LIGHTNING_RAYTRAINREPORTCALLBACK\x10\x81\x04\x12#\n\x1eTRAIN_LIGHTNING_RAYDDPSTRATEGY\x10\x82\x04\x12$\n\x1fTRAIN_LIGHTNING_RAYFSDPSTRATEGY\x10\x83\x04\x12)\n$TRAIN_LIGHTNING_RAYDEEPSPEEDSTRATEGY\x10\x84\x04\x12,\n\'TRAIN_LIGHTNING_RAYLIGHTNINGENVIRONMENT\x10\x85\x04\x12\'\n\"TRAIN_TRANSFORMERS_PREPARE_TRAINER\x10\x86\x04\x12.\n)TRAIN_TRANSFORMERS_RAYTRAINREPORTCALLBACK\x10\x87\x04\x12\x1c\n\x17TRAIN_TORCH_GET_DEVICES\x10\x88\x04\x12\x12\n\rTRAIN_TRAINER\x10\x89\x04\x12$\n\x1fLLM_SERVE_SERVE_MULTIPLE_MODELS\x10\xd8\x04\x12\"\n\x1dLLM_SERVE_SERVE_MULTIPLE_APPS\x10\xd9\x04\x12\x1f\n\x1aLLM_SERVE_JSON_MODE_MODELS\x10\xda\x04\x12%\n LLM_SERVE_JSON_MODE_NUM_REPLICAS\x10\xdb\x04\x12\x1f\n\x1aLLM_SERVE_LORA_BASE_MODELS\x10\xdc\x04\x12(\n#LLM_SERVE_INITIAL_NUM_LORA_ADAPTERS\x10\xdd\x04\x12)\n$LLM_SERVE_AUTOSCALING_ENABLED_MODELS\x10\xde\x04\x12\'\n\"LLM_SERVE_AUTOSCALING_MIN_REPLICAS\x10\xdf\x04\x12\'\n\"LLM_SERVE_AUTOSCALING_MAX_REPLICAS\x10\xe0\x04\x12%\n LLM_SERVE_TENSOR_PARALLEL_DEGREE\x10\xe1\x04\x12\x1b\n\x16LLM_SERVE_NUM_REPLICAS\x10\xe2\x04\x12\x15\n\x10LLM_SERVE_MODELS\x10\xe3\x04\x12\x17\n\x12LLM_SERVE_GPU_TYPE\x10\xe4\x04\x12\x17\n\x12LLM_SERVE_NUM_GPUS\x10\xe5\x04\x12$\n\x1fLLM_BATCH_PROCESSOR_CONFIG_NAME\x10\xe6\x04\x12!\n\x1cLLM_BATCH_MODEL_ARCHITECTURE\x10\xe7\x04\x12\x13\n\x0eLLM_BATCH_SIZE\x10\xe8\x04\x12\x1f\n\x1aLLM_BATCH_ACCELERATOR_TYPE\x10\xe9\x04\x12\x1a\n\x15LLM_BATCH_CONCURRENCY\x10\xea\x04\x12\x18\n\x13LLM_BATCH_TASK_TYPE\x10\xeb\x04\x12%\n LLM_BATCH_PIPELINE_PARALLEL_SIZE\x10\xec\x04\x12#\n\x1eLLM_BATCH_TENSOR_PARALLEL_SIZE\x10\xed\x04\x12!\n\x1cLLM_BATCH_DATA_PARALLEL_SIZE\x10\xee\x04\x62\x06proto3') + +_TAGKEY = DESCRIPTOR.enum_types_by_name['TagKey'] +TagKey = enum_type_wrapper.EnumTypeWrapper(_TAGKEY) +_TEST1 = 0 +_TEST2 = 1 +RLLIB_FRAMEWORK = 2 +RLLIB_ALGORITHM = 3 +RLLIB_NUM_WORKERS = 4 +SERVE_API_VERSION = 5 +SERVE_NUM_DEPLOYMENTS = 6 +GCS_STORAGE = 7 +SERVE_NUM_GPU_DEPLOYMENTS = 8 +SERVE_FASTAPI_USED = 9 +SERVE_DAG_DRIVER_USED = 10 +SERVE_HTTP_ADAPTER_USED = 11 +SERVE_GRPC_INGRESS_USED = 12 +SERVE_REST_API_VERSION = 13 +SERVE_NUM_APPS = 14 +SERVE_NUM_REPLICAS_LIGHTWEIGHT_UPDATED = 15 +SERVE_USER_CONFIG_LIGHTWEIGHT_UPDATED = 16 +SERVE_AUTOSCALING_CONFIG_LIGHTWEIGHT_UPDATED = 17 +SERVE_RAY_SERVE_HANDLE_API_USED = 18 +SERVE_RAY_SERVE_SYNC_HANDLE_API_USED = 19 +SERVE_DEPLOYMENT_HANDLE_API_USED = 20 +SERVE_DEPLOYMENT_HANDLE_TO_OBJECT_REF_API_USED = 21 +SERVE_MULTIPLEXED_API_USED = 22 +SERVE_HTTP_PROXY_USED = 23 +SERVE_GRPC_PROXY_USED = 24 +SERVE_STATUS_API_USED = 25 +SERVE_GET_APP_HANDLE_API_USED = 26 +SERVE_GET_DEPLOYMENT_HANDLE_API_USED = 27 +SERVE_APP_CONTAINER_RUNTIME_ENV_USED = 28 +SERVE_DEPLOYMENT_CONTAINER_RUNTIME_ENV_USED = 29 +SERVE_NUM_NODE_COMPACTIONS = 30 +SERVE_AUTO_NUM_REPLICAS_USED = 31 +SERVE_CUSTOM_REQUEST_ROUTER_USED = 32 +SERVE_NUM_REPLICAS_VIA_API_CALL_UPDATED = 33 +SERVE_NUM_REPLICAS_USING_ASYNCHRONOUS_INFERENCE = 34 +SERVE_CUSTOM_AUTOSCALING_POLICY_USED = 35 +CORE_STATE_API_LIST_ACTORS = 100 +CORE_STATE_API_LIST_TASKS = 101 +CORE_STATE_API_LIST_JOBS = 102 +CORE_STATE_API_LIST_NODES = 103 +CORE_STATE_API_LIST_PLACEMENT_GROUPS = 104 +CORE_STATE_API_LIST_WORKERS = 105 +CORE_STATE_API_LIST_OBJECTS = 106 +CORE_STATE_API_LIST_RUNTIME_ENVS = 107 +CORE_STATE_API_LIST_CLUSTER_EVENTS = 108 +CORE_STATE_API_LIST_LOGS = 109 +CORE_STATE_API_GET_LOG = 110 +CORE_STATE_API_SUMMARIZE_TASKS = 111 +CORE_STATE_API_SUMMARIZE_ACTORS = 112 +CORE_STATE_API_SUMMARIZE_OBJECTS = 113 +DASHBOARD_USED = 200 +DASHBOARD_METRICS_PROMETHEUS_ENABLED = 201 +DASHBOARD_METRICS_GRAFANA_ENABLED = 202 +PG_NUM_CREATED = 300 +ACTOR_NUM_CREATED = 301 +WORKER_CRASH_SYSTEM_ERROR = 302 +WORKER_CRASH_OOM = 303 +RAY_GET_TIMEOUT_ZERO = 304 +NUM_ACTOR_CREATION_TASKS = 305 +NUM_ACTOR_TASKS = 306 +NUM_NORMAL_TASKS = 307 +NUM_DRIVERS = 308 +EXPERIMENTAL_STATE_API_IMPORT = 309 +AUTOSCALER_VERSION = 310 +DATA_LOGICAL_OPS = 400 +AIR_TRAINER = 500 +TUNE_SEARCHER = 501 +TUNE_SCHEDULER = 502 +AIR_ENV_VARS = 503 +AIR_SETUP_WANDB_INTEGRATION_USED = 504 +AIR_SETUP_MLFLOW_INTEGRATION_USED = 505 +AIR_CALLBACKS = 506 +AIR_STORAGE_CONFIGURATION = 507 +AIR_ENTRYPOINT = 508 +TRAIN_TORCH_GET_DEVICE = 509 +TRAIN_TORCH_PREPARE_MODEL = 510 +TRAIN_TORCH_PREPARE_DATALOADER = 511 +TRAIN_LIGHTNING_PREPARE_TRAINER = 512 +TRAIN_LIGHTNING_RAYTRAINREPORTCALLBACK = 513 +TRAIN_LIGHTNING_RAYDDPSTRATEGY = 514 +TRAIN_LIGHTNING_RAYFSDPSTRATEGY = 515 +TRAIN_LIGHTNING_RAYDEEPSPEEDSTRATEGY = 516 +TRAIN_LIGHTNING_RAYLIGHTNINGENVIRONMENT = 517 +TRAIN_TRANSFORMERS_PREPARE_TRAINER = 518 +TRAIN_TRANSFORMERS_RAYTRAINREPORTCALLBACK = 519 +TRAIN_TORCH_GET_DEVICES = 520 +TRAIN_TRAINER = 521 +LLM_SERVE_SERVE_MULTIPLE_MODELS = 600 +LLM_SERVE_SERVE_MULTIPLE_APPS = 601 +LLM_SERVE_JSON_MODE_MODELS = 602 +LLM_SERVE_JSON_MODE_NUM_REPLICAS = 603 +LLM_SERVE_LORA_BASE_MODELS = 604 +LLM_SERVE_INITIAL_NUM_LORA_ADAPTERS = 605 +LLM_SERVE_AUTOSCALING_ENABLED_MODELS = 606 +LLM_SERVE_AUTOSCALING_MIN_REPLICAS = 607 +LLM_SERVE_AUTOSCALING_MAX_REPLICAS = 608 +LLM_SERVE_TENSOR_PARALLEL_DEGREE = 609 +LLM_SERVE_NUM_REPLICAS = 610 +LLM_SERVE_MODELS = 611 +LLM_SERVE_GPU_TYPE = 612 +LLM_SERVE_NUM_GPUS = 613 +LLM_BATCH_PROCESSOR_CONFIG_NAME = 614 +LLM_BATCH_MODEL_ARCHITECTURE = 615 +LLM_BATCH_SIZE = 616 +LLM_BATCH_ACCELERATOR_TYPE = 617 +LLM_BATCH_CONCURRENCY = 618 +LLM_BATCH_TASK_TYPE = 619 +LLM_BATCH_PIPELINE_PARALLEL_SIZE = 620 +LLM_BATCH_TENSOR_PARALLEL_SIZE = 621 +LLM_BATCH_DATA_PARALLEL_SIZE = 622 + + +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TAGKEY._serialized_start=44 + _TAGKEY._serialized_end=3608 +# @@protoc_insertion_point(module_scope) diff --git a/lib/python3.12/site-packages/ray/core/generated/usage_pb2_grpc.py b/lib/python3.12/site-packages/ray/core/generated/usage_pb2_grpc.py new file mode 100644 index 0000000000000000000000000000000000000000..2daafffebfc817aefe8fcb96eaec25e65b3903e8 --- /dev/null +++ b/lib/python3.12/site-packages/ray/core/generated/usage_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/lib/python3.12/site-packages/ray/core/src/__init__.py b/lib/python3.12/site-packages/ray/core/src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/core/src/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/core/src/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2db2ab6ce67c63b0f913123a5607bac95789f940 Binary files /dev/null and b/lib/python3.12/site-packages/ray/core/src/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/core/src/ray/__init__.py b/lib/python3.12/site-packages/ray/core/src/ray/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/core/src/ray/raylet/__init__.py b/lib/python3.12/site-packages/ray/core/src/ray/raylet/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/includes/__init__.pxd b/lib/python3.12/site-packages/ray/includes/__init__.pxd new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/lib/python3.12/site-packages/ray/includes/array.pxd b/lib/python3.12/site-packages/ray/includes/array.pxd new file mode 100644 index 0000000000000000000000000000000000000000..a6ce5e135a7053045d2802b64f94e345ea5da2d0 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/array.pxd @@ -0,0 +1,6 @@ +from libc.stddef cimport size_t +from libcpp.string cimport string + +cdef extern from "" namespace "std": + cdef cppclass array_string_2 "std::array": + string& operator[](size_t) except + diff --git a/lib/python3.12/site-packages/ray/includes/common.pxd b/lib/python3.12/site-packages/ray/includes/common.pxd new file mode 100644 index 0000000000000000000000000000000000000000..0ee46ea06927768d73d8b5f3253c8220005caf7b --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/common.pxd @@ -0,0 +1,821 @@ +from libcpp cimport bool as c_bool +from libcpp.memory cimport shared_ptr, unique_ptr +from libcpp.string cimport string as c_string + +from libc.stdint cimport uint8_t, int32_t, uint64_t, int64_t, uint32_t +from libcpp.unordered_map cimport unordered_map +from libcpp.vector cimport vector as c_vector +from libcpp.pair cimport pair as c_pair +from ray.includes.optional cimport ( + optional, +) +from ray.includes.unique_ids cimport ( + CActorID, + CJobID, + CClusterID, + CWorkerID, + CObjectID, + CTaskID, + CPlacementGroupID, + CNodeID, +) +from ray.includes.function_descriptor cimport ( + CFunctionDescriptor, +) + + +cdef extern from * namespace "polyfill" nogil: + """ + namespace polyfill { + + template + inline typename std::remove_reference::type&& move(T& t) { + return std::move(t); + } + + template + inline typename std::remove_reference::type&& move(T&& t) { + return std::move(t); + } + + } // namespace polyfill + """ + cdef T move[T](T) + + +cdef extern from "ray/common/status.h" namespace "ray" nogil: + cdef enum class CStatusCode "ray::StatusCode": + pass + c_bool operator==(CStatusCode lhs, CStatusCode rhs) + + cdef cppclass CRayStatus "ray::Status": + CRayStatus() + CRayStatus(CStatusCode code, const c_string &msg) + CRayStatus(CStatusCode code, const c_string &msg, int rpc_code) + CRayStatus(const CRayStatus &s) + + @staticmethod + CRayStatus OK() + + @staticmethod + CRayStatus OutOfMemory(const c_string &msg) + + @staticmethod + CRayStatus KeyError(const c_string &msg) + + @staticmethod + CRayStatus Invalid(const c_string &msg) + + @staticmethod + CRayStatus IOError(const c_string &msg) + + @staticmethod + CRayStatus TypeError(const c_string &msg) + + @staticmethod + CRayStatus UnknownError(const c_string &msg) + + @staticmethod + CRayStatus NotImplemented(const c_string &msg) + + @staticmethod + CRayStatus ObjectStoreFull(const c_string &msg) + + @staticmethod + CRayStatus RedisError(const c_string &msg) + + @staticmethod + CRayStatus TimedOut(const c_string &msg) + + @staticmethod + CRayStatus InvalidArgument(const c_string &msg) + + @staticmethod + CRayStatus Interrupted(const c_string &msg) + + @staticmethod + CRayStatus IntentionalSystemExit(const c_string &msg) + + @staticmethod + CRayStatus UnexpectedSystemExit(const c_string &msg) + + @staticmethod + CRayStatus CreationTaskError(const c_string &msg) + + @staticmethod + CRayStatus NotFound() + + @staticmethod + CRayStatus ObjectRefEndOfStream() + + c_bool ok() + c_bool IsOutOfMemory() + c_bool IsKeyError() + c_bool IsInvalid() + c_bool IsIOError() + c_bool IsTypeError() + c_bool IsUnknownError() + c_bool IsNotImplemented() + c_bool IsObjectStoreFull() + c_bool IsAlreadyExists() + c_bool IsOutOfDisk() + c_bool IsRedisError() + c_bool IsTimedOut() + c_bool IsInvalidArgument() + c_bool IsInterrupted() + c_bool IsObjectNotFound() + c_bool IsNotFound() + c_bool IsObjectUnknownOwner() + c_bool IsRpcError() + c_bool IsOutOfResource() + c_bool IsObjectRefEndOfStream() + c_bool IsIntentionalSystemExit() + c_bool IsUnexpectedSystemExit() + c_bool IsChannelError() + c_bool IsChannelTimeoutError() + c_bool IsUnauthenticated() + + c_string ToString() + c_string CodeAsString() + CStatusCode code() + c_string message() + int rpc_code() + + # We can later add more of the common status factory methods as needed + cdef CRayStatus RayStatus_OK "Status::OK"() + cdef CRayStatus RayStatus_Invalid "Status::Invalid"() + cdef CRayStatus RayStatus_NotImplemented "Status::NotImplemented"() + +cdef extern from "ray/common/status_or.h" namespace "ray" nogil: + cdef cppclass CStatusOr "ray::StatusOr"[T]: + c_bool ok() + const CRayStatus &status() const + T &value() + +cdef extern from "ray/common/id.h" namespace "ray" nogil: + const CTaskID GenerateTaskId(const CJobID &job_id, + const CTaskID &parent_task_id, + int parent_task_counter) + + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef cppclass CLanguage "ray::Language": + pass + cdef cppclass CWorkerType "ray::core::WorkerType": + pass + cdef cppclass CWorkerExitType "ray::rpc::WorkerExitType": + pass + cdef cppclass CTaskType "ray::TaskType": + pass + cdef cppclass CTensorTransport "ray::rpc::TensorTransport": + pass + cdef cppclass CPlacementStrategy "ray::core::PlacementStrategy": + pass + cdef cppclass CDefaultSchedulingStrategy "ray::rpc::DefaultSchedulingStrategy": # noqa: E501 + CDefaultSchedulingStrategy() + cdef cppclass CSpreadSchedulingStrategy "ray::rpc::SpreadSchedulingStrategy": # noqa: E501 + CSpreadSchedulingStrategy() + cdef cppclass CPlacementGroupSchedulingStrategy "ray::rpc::PlacementGroupSchedulingStrategy": # noqa: E501 + CPlacementGroupSchedulingStrategy() + void set_placement_group_id(const c_string& placement_group_id) + void set_placement_group_bundle_index(int64_t placement_group_bundle_index) # noqa: E501 + void set_placement_group_capture_child_tasks(c_bool placement_group_capture_child_tasks) # noqa: E501 + cdef cppclass CNodeAffinitySchedulingStrategy "ray::rpc::NodeAffinitySchedulingStrategy": # noqa: E501 + CNodeAffinitySchedulingStrategy() + void set_node_id(const c_string& node_id) + void set_soft(c_bool soft) + void set_spill_on_unavailable(c_bool spill_on_unavailable) + void set_fail_on_unavailable(c_bool fail_on_unavailable) + cdef cppclass CSchedulingStrategy "ray::rpc::SchedulingStrategy": + CSchedulingStrategy() + void clear_scheduling_strategy() + CSpreadSchedulingStrategy* mutable_spread_scheduling_strategy() + CDefaultSchedulingStrategy* mutable_default_scheduling_strategy() + CPlacementGroupSchedulingStrategy* mutable_placement_group_scheduling_strategy() # noqa: E501 + CNodeAffinitySchedulingStrategy* mutable_node_affinity_scheduling_strategy() + CNodeLabelSchedulingStrategy* mutable_node_label_scheduling_strategy() + cdef cppclass CAddress "ray::rpc::Address": + CAddress() + const c_string &SerializeAsString() const + void ParseFromString(const c_string &serialized) + void CopyFrom(const CAddress& address) + const c_string &worker_id() + cdef cppclass CObjectReference "ray::rpc::ObjectReference": + CObjectReference() + CAddress owner_address() const + const c_string &object_id() const + const c_string &call_site() const + CTensorTransport tensor_transport() const + cdef cppclass CNodeLabelSchedulingStrategy "ray::rpc::NodeLabelSchedulingStrategy": # noqa: E501 + CNodeLabelSchedulingStrategy() + CLabelMatchExpressions* mutable_hard() + CLabelMatchExpressions* mutable_soft() + cdef cppclass CLabelMatchExpressions "ray::rpc::LabelMatchExpressions": # noqa: E501 + CLabelMatchExpressions() + CLabelMatchExpression* add_expressions() + cdef cppclass CLabelMatchExpression "ray::rpc::LabelMatchExpression": # noqa: E501 + CLabelMatchExpression() + void set_key(const c_string &key) + CLabelOperator* mutable_operator_() + cdef cppclass CLabelIn "ray::rpc::LabelIn": # noqa: E501 + CLabelIn() + void add_values(const c_string &value) + cdef cppclass CLabelNotIn "ray::rpc::LabelNotIn": # noqa: E501 + CLabelNotIn() + void add_values(const c_string &value) + cdef cppclass CLabelExists "ray::rpc::LabelExists": # noqa: E501 + CLabelExists() + cdef cppclass CLabelDoesNotExist "ray::rpc::LabelDoesNotExist": # noqa: E501 + CLabelDoesNotExist() + cdef cppclass CLabelNotIn "ray::rpc::LabelNotIn": # noqa: E501 + CLabelNotIn() + void add_values(const c_string &value) + cdef cppclass CLabelOperator "ray::rpc::LabelOperator": # noqa: E501 + CLabelOperator() + CLabelIn* mutable_label_in() + CLabelNotIn* mutable_label_not_in() + CLabelExists* mutable_label_exists() + CLabelDoesNotExist* mutable_label_does_not_exist() + cdef cppclass CLineageReconstructionTask "ray::rpc::LineageReconstructionTask": + CLineageReconstructionTask() + const c_string &SerializeAsString() const + +cdef extern from "ray/common/scheduling/label_selector.h" namespace "ray": + cdef cppclass CLabelSelector "ray::LabelSelector": + CLabelSelector() nogil except + + void AddConstraint(const c_string& key, const c_string& value) nogil except + + +cdef extern from "ray/common/scheduling/fallback_strategy.h" namespace "ray": + cdef cppclass CFallbackOption "ray::FallbackOption": + CLabelSelector label_selector + + CFallbackOption() nogil except + + CFallbackOption(CLabelSelector) nogil except + + +# This is a workaround for C++ enum class since Cython has no corresponding +# representation. +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef CLanguage LANGUAGE_PYTHON "ray::Language::PYTHON" + cdef CLanguage LANGUAGE_CPP "ray::Language::CPP" + cdef CLanguage LANGUAGE_JAVA "ray::Language::JAVA" + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef CWorkerType WORKER_TYPE_WORKER "ray::core::WorkerType::WORKER" + cdef CWorkerType WORKER_TYPE_DRIVER "ray::core::WorkerType::DRIVER" + cdef CWorkerType WORKER_TYPE_SPILL_WORKER "ray::core::WorkerType::SPILL_WORKER" # noqa: E501 + cdef CWorkerType WORKER_TYPE_RESTORE_WORKER "ray::core::WorkerType::RESTORE_WORKER" # noqa: E501 + cdef CWorkerType WORKER_TYPE_UTIL_WORKER "ray::core::WorkerType::UTIL_WORKER" # noqa: E501 + cdef CWorkerExitType WORKER_EXIT_TYPE_USER_ERROR "ray::rpc::WorkerExitType::USER_ERROR" # noqa: E501 + cdef CWorkerExitType WORKER_EXIT_TYPE_SYSTEM_ERROR "ray::rpc::WorkerExitType::SYSTEM_ERROR" # noqa: E501 + cdef CWorkerExitType WORKER_EXIT_TYPE_INTENTIONAL_SYSTEM_ERROR "ray::rpc::WorkerExitType::INTENDED_SYSTEM_EXIT" # noqa: E501 + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef CTaskType TASK_TYPE_NORMAL_TASK "ray::TaskType::NORMAL_TASK" + cdef CTaskType TASK_TYPE_ACTOR_CREATION_TASK "ray::TaskType::ACTOR_CREATION_TASK" # noqa: E501 + cdef CTaskType TASK_TYPE_ACTOR_TASK "ray::TaskType::ACTOR_TASK" + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef CTensorTransport TENSOR_TRANSPORT_OBJECT_STORE "ray::rpc::TensorTransport::OBJECT_STORE" + cdef CTensorTransport TENSOR_TRANSPORT_NCCL "ray::rpc::TensorTransport::NCCL" + cdef CTensorTransport TENSOR_TRANSPORT_GLOO "ray::rpc::TensorTransport::GLOO" + cdef CTensorTransport TENSOR_TRANSPORT_NIXL "ray::rpc::TensorTransport::NIXL" + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef CPlacementStrategy PLACEMENT_STRATEGY_PACK \ + "ray::core::PlacementStrategy::PACK" + cdef CPlacementStrategy PLACEMENT_STRATEGY_SPREAD \ + "ray::core::PlacementStrategy::SPREAD" + cdef CPlacementStrategy PLACEMENT_STRATEGY_STRICT_PACK \ + "ray::core::PlacementStrategy::STRICT_PACK" + cdef CPlacementStrategy PLACEMENT_STRATEGY_STRICT_SPREAD \ + "ray::core::PlacementStrategy::STRICT_SPREAD" + +cdef extern from "ray/common/buffer.h" namespace "ray" nogil: + cdef cppclass CBuffer "ray::Buffer": + uint8_t *Data() const + size_t Size() const + c_bool IsPlasmaBuffer() const + + cdef cppclass LocalMemoryBuffer(CBuffer): + LocalMemoryBuffer(uint8_t *data, size_t size, c_bool copy_data) + LocalMemoryBuffer(size_t size) + + cdef cppclass SharedMemoryBuffer(CBuffer): + SharedMemoryBuffer( + const shared_ptr[CBuffer] &buffer, + int64_t offset, + int64_t size) + c_bool IsPlasmaBuffer() const + +cdef extern from "ray/common/ray_object.h" nogil: + cdef cppclass CRayObject "ray::RayObject": + CRayObject(const shared_ptr[CBuffer] &data, + const shared_ptr[CBuffer] &metadata, + const c_vector[CObjectReference] &nested_refs) + c_bool HasData() const + c_bool HasMetadata() const + const size_t DataSize() const + const shared_ptr[CBuffer] &GetData() + const shared_ptr[CBuffer] &GetMetadata() const + c_bool IsInPlasmaError() const + CTensorTransport GetTensorTransport() const + +cdef extern from "ray/core_worker/common.h" nogil: + cdef cppclass CRayFunction "ray::core::RayFunction": + CRayFunction() + CRayFunction(CLanguage language, + const CFunctionDescriptor &function_descriptor) + CLanguage GetLanguage() + const CFunctionDescriptor GetFunctionDescriptor() + + cdef cppclass CTaskArg "ray::TaskArg": + pass + + cdef cppclass CTaskArgByReference "ray::TaskArgByReference": + CTaskArgByReference(const CObjectID &object_id, + const CAddress &owner_address, + const c_string &call_site, + const CTensorTransport &tensor_transport) + + cdef cppclass CTaskArgByValue "ray::TaskArgByValue": + CTaskArgByValue(const shared_ptr[CRayObject] &data) + + cdef cppclass CTaskOptions "ray::core::TaskOptions": + CTaskOptions() + CTaskOptions(c_string name, int num_returns, + unordered_map[c_string, double] &resources, + c_string concurrency_group_name, + int64_t generator_backpressure_num_objects) + CTaskOptions(c_string name, int num_returns, + unordered_map[c_string, double] &resources, + c_string concurrency_group_name, + int64_t generator_backpressure_num_objects, + c_string serialized_runtime_env) + CTaskOptions(c_string name, int num_returns, + unordered_map[c_string, double] &resources, + c_string concurrency_group_name, + int64_t generator_backpressure_num_objects, + c_string serialized_runtime_env, + c_bool enable_task_events, + const unordered_map[c_string, c_string] &labels, + CLabelSelector label_selector, + CTensorTransport tensor_transport, + c_vector[CFallbackOption] fallback_strategy) + + cdef cppclass CActorCreationOptions "ray::core::ActorCreationOptions": + CActorCreationOptions() + CActorCreationOptions( + int64_t max_restarts, + int64_t max_task_retries, + int32_t max_concurrency, + const unordered_map[c_string, double] &resources, + const unordered_map[c_string, double] &placement_resources, + const c_vector[c_string] &dynamic_worker_options, + optional[c_bool] is_detached, c_string &name, c_string &ray_namespace, + c_bool is_asyncio, + const CSchedulingStrategy &scheduling_strategy, + c_string serialized_runtime_env, + const c_vector[CConcurrencyGroup] &concurrency_groups, + c_bool allow_out_of_order_execution, + int32_t max_pending_calls, + c_bool enable_tensor_transport, + c_bool enable_task_events, + const unordered_map[c_string, c_string] &labels, + CLabelSelector label_selector, + c_vector[CFallbackOption] fallback_strategy) + + cdef cppclass CPlacementGroupCreationOptions \ + "ray::core::PlacementGroupCreationOptions": + CPlacementGroupCreationOptions() + CPlacementGroupCreationOptions( + const c_string &name, + CPlacementStrategy strategy, + const c_vector[unordered_map[c_string, double]] &bundles, + c_bool is_detached, + CNodeID soft_target_node_id, + const c_vector[unordered_map[c_string, c_string]] &bundle_label_selector, + ) + + cdef cppclass CObjectLocation "ray::core::ObjectLocation": + const CNodeID &GetPrimaryNodeID() const + const int64_t GetObjectSize() const + const c_vector[CNodeID] &GetNodeIDs() const + c_bool IsSpilled() const + const c_string &GetSpilledURL() const + const CNodeID &GetSpilledNodeID() const + const c_bool GetDidSpill() const + +cdef extern from "ray/common/python_callbacks.h" namespace "ray": + cdef cppclass MultiItemPyCallback[T]: + MultiItemPyCallback( + object (*)(CRayStatus, c_vector[T]) nogil, + void (object, object) nogil, + object) nogil + + cdef cppclass OptionalItemPyCallback[T]: + OptionalItemPyCallback( + object (*)(CRayStatus, optional[T]) nogil, + void (object, object) nogil, + object) nogil + + cdef cppclass StatusPyCallback: + StatusPyCallback( + object (*)(CRayStatus) nogil, + void (object, object) nogil, + object) nogil + +cdef extern from "ray/gcs_rpc_client/accessors/actor_info_accessor_interface.h" nogil: + cdef cppclass CActorInfoAccessorInterface "ray::gcs::ActorInfoAccessorInterface": + void AsyncGetAllByFilter( + const optional[CActorID] &actor_id, + const optional[CJobID] &job_id, + const optional[c_string] &actor_state_name, + const MultiItemPyCallback[CActorTableData] &callback, + int64_t timeout_ms) + + void AsyncKillActor(const CActorID &actor_id, + c_bool force_kill, + c_bool no_restart, + const StatusPyCallback &callback, + int64_t timeout_ms) + +cdef extern from "ray/gcs_rpc_client/accessor.h" nogil: + cdef cppclass CJobInfoAccessor "ray::gcs::JobInfoAccessor": + CRayStatus GetAll( + const optional[c_string] &job_or_submission_id, + c_bool skip_submission_job_info_field, + c_bool skip_is_running_tasks_field, + c_vector[CJobTableData] &result, + int64_t timeout_ms) + + void AsyncGetAll( + const optional[c_string] &job_or_submission_id, + c_bool skip_submission_job_info_field, + c_bool skip_is_running_tasks_field, + const MultiItemPyCallback[CJobTableData] &callback, + int64_t timeout_ms) + + cdef cppclass CNodeInfoAccessor "ray::gcs::NodeInfoAccessor": + CRayStatus CheckAlive( + const c_vector[CNodeID] &node_ids, + int64_t timeout_ms, + c_vector[c_bool] &result) + + void AsyncCheckAlive( + const c_vector[CNodeID] &node_ids, + int64_t timeout_ms, + const MultiItemPyCallback[c_bool] &callback) + + CRayStatus DrainNodes( + const c_vector[CNodeID] &node_ids, + int64_t timeout_ms, + c_vector[c_string] &drained_node_ids) + + CStatusOr[c_vector[CGcsNodeInfo]] GetAllNoCache( + int64_t timeout_ms, + optional[CGcsNodeState] state_filter, + optional[CNodeSelector] node_selector) + + void AsyncGetAll( + const MultiItemPyCallback[CGcsNodeInfo] &callback, + int64_t timeout_ms, + c_vector[CNodeID] node_ids) + + cdef cppclass CNodeResourceInfoAccessor "ray::gcs::NodeResourceInfoAccessor": + CRayStatus GetAllResourceUsage( + int64_t timeout_ms, + CGetAllResourceUsageReply &serialized_reply) + + cdef cppclass CInternalKVAccessor "ray::gcs::InternalKVAccessor": + CRayStatus Keys( + const c_string &ns, + const c_string &prefix, + int64_t timeout_ms, + c_vector[c_string] &value) + + CRayStatus Put( + const c_string &ns, + const c_string &key, + const c_string &value, + c_bool overwrite, + int64_t timeout_ms, + c_bool &added) + + CRayStatus Get( + const c_string &ns, + const c_string &key, + int64_t timeout_ms, + c_string &value) + + CRayStatus MultiGet( + const c_string &ns, + const c_vector[c_string] &keys, + int64_t timeout_ms, + unordered_map[c_string, c_string] &values) + + CRayStatus Del( + const c_string &ns, + const c_string &key, + c_bool del_by_prefix, + int64_t timeout_ms, + int& num_deleted) + + CRayStatus Exists( + const c_string &ns, + const c_string &key, + int64_t timeout_ms, + c_bool &exists) + + void AsyncInternalKVKeys( + const c_string &ns, + const c_string &prefix, + int64_t timeout_ms, + const OptionalItemPyCallback[c_vector[c_string]] &callback) + + void AsyncInternalKVGet( + const c_string &ns, + const c_string &key, + int64_t timeout_ms, + const OptionalItemPyCallback[c_string] &callback) + + void AsyncInternalKVMultiGet( + const c_string &ns, + const c_vector[c_string] &keys, + int64_t timeout_ms, + const OptionalItemPyCallback[unordered_map[c_string, c_string]] &callback) + + void AsyncInternalKVPut( + const c_string &ns, + const c_string &key, + const c_string &value, + c_bool overwrite, + int64_t timeout_ms, + const OptionalItemPyCallback[c_bool] &callback) + + void AsyncInternalKVExists( + const c_string &ns, + const c_string &key, + int64_t timeout_ms, + const OptionalItemPyCallback[c_bool] &callback) + + void AsyncInternalKVDel( + const c_string &ns, + const c_string &key, + c_bool del_by_prefix, + int64_t timeout_ms, + const OptionalItemPyCallback[int] &callback) + + cdef cppclass CRuntimeEnvAccessor "ray::gcs::RuntimeEnvAccessor": + CRayStatus PinRuntimeEnvUri( + const c_string &uri, + int expiration_s, + int64_t timeout_ms) + + cdef cppclass CAutoscalerStateAccessor "ray::gcs::AutoscalerStateAccessor": + + CRayStatus RequestClusterResourceConstraint( + int64_t timeout_ms, + const c_vector[unordered_map[c_string, double]] &bundles, + const c_vector[unordered_map[c_string, c_string]] &label_selectors, + const c_vector[int64_t] &count_array, + ) + + CRayStatus GetClusterResourceState( + int64_t timeout_ms, + c_string &serialized_reply + ) + + CRayStatus GetClusterStatus( + int64_t timeout_ms, + c_string &serialized_reply + ) + + void AsyncGetClusterStatus( + int64_t timeout_ms, + const OptionalItemPyCallback[CGetClusterStatusReply] &callback) + + CRayStatus ReportAutoscalingState( + int64_t timeout_ms, + const c_string &serialized_state + ) + + CRayStatus ReportClusterConfig( + int64_t timeout_ms, + const c_string &serialized_cluster_config + ) + + CRayStatus DrainNode( + const c_string &node_id, + int32_t reason, + const c_string &reason_message, + int64_t deadline_timestamp_ms, + int64_t timeout_ms, + c_bool &is_accepted, + c_string &rejection_reason_message + ) + + cdef cppclass CPublisherAccessor "ray::gcs::PublisherAccessor": + CRayStatus PublishError( + c_string key_id, + CErrorTableData data, + int64_t timeout_ms) + + CRayStatus PublishLogs( + c_string key_id, + CLogBatch data, + int64_t timeout_ms) + + void AsyncPublishNodeResourceUsage( + c_string key_id, + c_string node_resource_usage, + const StatusPyCallback &callback + ) + + +cdef extern from "ray/gcs_rpc_client/gcs_client.h" nogil: + cdef enum CGrpcStatusCode "grpc::StatusCode": + UNAVAILABLE "grpc::StatusCode::UNAVAILABLE", + UNKNOWN "grpc::StatusCode::UNKNOWN", + DEADLINE_EXCEEDED "grpc::StatusCode::DEADLINE_EXCEEDED", + RESOURCE_EXHAUSTED "grpc::StatusCode::RESOURCE_EXHAUSTED", + UNIMPLEMENTED "grpc::StatusCode::UNIMPLEMENTED", + + cdef cppclass CGcsClientOptions "ray::gcs::GcsClientOptions": + CGcsClientOptions( + c_string gcs_address, int port, CClusterID cluster_id, + c_bool allow_cluster_id_nil, c_bool fetch_cluster_id_if_nil) + + cdef cppclass CGcsClient "ray::gcs::GcsClient": + CGcsClient(CGcsClientOptions options) + + c_pair[c_string, int] GetGcsServerAddress() const + CClusterID GetClusterId() const + + CActorInfoAccessorInterface& Actors() + CJobInfoAccessor& Jobs() + CInternalKVAccessor& InternalKV() + CNodeInfoAccessor& Nodes() + CNodeResourceInfoAccessor& NodeResources() + CRuntimeEnvAccessor& RuntimeEnvs() + CAutoscalerStateAccessor& Autoscaler() + CPublisherAccessor& Publisher() + + cdef CRayStatus ConnectOnSingletonIoContext(CGcsClient &gcs_client, int timeout_ms) + +cdef extern from "ray/gcs_rpc_client/gcs_client.h" namespace "ray::gcs" nogil: + unordered_map[c_string, double] PythonGetResourcesTotal( + const CGcsNodeInfo& node_info) + +cdef extern from "ray/pubsub/python_gcs_subscriber.h" nogil: + cdef cppclass CPythonGcsSubscriber "ray::pubsub::PythonGcsSubscriber": + + CPythonGcsSubscriber( + const c_string& gcs_address, int gcs_port, CChannelType channel_type, + const c_string& subscriber_id, const c_string& worker_id) + + CRayStatus Subscribe() + + int64_t last_batch_size() + + CRayStatus PollError( + c_string* key_id, int64_t timeout_ms, CErrorTableData* data) + + CRayStatus PollLogs( + c_string* key_id, int64_t timeout_ms, CLogBatch* data) + + CRayStatus Close() + +cdef extern from "ray/pubsub/python_gcs_subscriber.h" namespace "ray::pubsub" nogil: + c_vector[c_string] PythonGetLogBatchLines(CLogBatch log_batch) + +cdef extern from "ray/gcs_rpc_client/gcs_client.h" namespace "ray::gcs" nogil: + unordered_map[c_string, c_string] PythonGetNodeLabels( + const CGcsNodeInfo& node_info) + +cdef extern from "src/ray/protobuf/gcs.pb.h" nogil: + cdef enum CChannelType "ray::rpc::ChannelType": + RAY_ERROR_INFO_CHANNEL "ray::rpc::ChannelType::RAY_ERROR_INFO_CHANNEL", + RAY_LOG_CHANNEL "ray::rpc::ChannelType::RAY_LOG_CHANNEL", + GCS_ACTOR_CHANNEL "ray::rpc::ChannelType::GCS_ACTOR_CHANNEL", + + cdef cppclass CJobConfig "ray::rpc::JobConfig": + c_string ray_namespace() const + const c_string &SerializeAsString() const + + cdef cppclass CNodeDeathInfo "ray::rpc::NodeDeathInfo": + int reason() const + c_string reason_message() const + + cdef cppclass CGcsNodeInfo "ray::rpc::GcsNodeInfo": + c_string node_id() const + c_string node_name() const + int state() const + c_string node_manager_address() const + c_string node_manager_hostname() const + int node_manager_port() const + int object_manager_port() const + c_string object_store_socket_name() const + c_string raylet_socket_name() const + int metrics_export_port() const + int runtime_env_agent_port() const + CNodeDeathInfo death_info() const + void ParseFromString(const c_string &serialized) + const c_string& SerializeAsString() const + + cdef enum CGcsNodeState "ray::rpc::GcsNodeInfo_GcsNodeState": + ALIVE "ray::rpc::GcsNodeInfo_GcsNodeState_ALIVE", + + cdef cppclass CNodeSelector "ray::rpc::GetAllNodeInfoRequest::NodeSelector": + pass + + cdef cppclass CJobTableData "ray::rpc::JobTableData": + c_string job_id() const + c_bool is_dead() const + CJobConfig config() const + const c_string &SerializeAsString() const + + cdef cppclass CGetAllResourceUsageReply "ray::rpc::GetAllResourceUsageReply": + const c_string& SerializeAsString() const + + cdef cppclass CPythonFunction "ray::rpc::PythonFunction": + void set_key(const c_string &key) + c_string key() const + + cdef cppclass CErrorTableData "ray::rpc::ErrorTableData": + c_string job_id() const + c_string type() const + c_string error_message() const + double timestamp() const + + void set_job_id(const c_string &job_id) + void set_type(const c_string &type) + void set_error_message(const c_string &error_message) + void set_timestamp(double timestamp) + + cdef cppclass CLogBatch "ray::rpc::LogBatch": + c_string ip() const + c_string pid() const + c_string job_id() const + c_bool is_error() const + c_string actor_name() const + c_string task_name() const + + void set_ip(const c_string &ip) + void set_pid(const c_string &pid) + void set_job_id(const c_string &job_id) + void set_is_error(c_bool is_error) + void add_lines(const c_string &line) + void set_actor_name(const c_string &actor_name) + void set_task_name(const c_string &task_name) + + cdef cppclass CActorTableData "ray::rpc::ActorTableData": + CAddress address() const + void ParseFromString(const c_string &serialized) + const c_string &SerializeAsString() const + +cdef extern from "src/ray/protobuf/autoscaler.pb.h" nogil: + cdef cppclass CGetClusterStatusReply "ray::rpc::autoscaler::GetClusterStatusReply": + c_string serialized_cluster_status() const + void ParseFromString(const c_string &serialized) + const c_string &SerializeAsString() const + +cdef extern from "ray/raylet_rpc_client/raylet_client_with_io_context.h" nogil: + cdef cppclass CRayletClientWithIoContext "ray::rpc::RayletClientWithIoContext": + CRayletClientWithIoContext(const c_string &ip_address, int port) + CRayStatus GetWorkerPIDs(const OptionalItemPyCallback[c_vector[int32_t]] &callback, + int64_t timeout_ms) + +cdef extern from "ray/common/task/task_spec.h" nogil: + cdef cppclass CConcurrencyGroup "ray::ConcurrencyGroup": + CConcurrencyGroup( + c_string name, + uint32_t max_concurrency, + c_vector[CFunctionDescriptor] c_fds) + CConcurrencyGroup() + c_string GetName() const + uint32_t GetMaxConcurrency() const + c_vector[CFunctionDescriptor] GetFunctionDescriptors() const + +cdef extern from "ray/common/constants.h" nogil: + cdef const char[] kWorkerSetupHookKeyName + cdef int kResourceUnitScaling + cdef const char[] kImplicitResourcePrefix + cdef int kStreamingGeneratorReturn + cdef const char[] kGcsAutoscalerStateNamespace + cdef const char[] kGcsAutoscalerV2EnabledKey + cdef const char[] kGcsAutoscalerClusterConfigKey + cdef const char[] kGcsPidKey + cdef const char[] kNodeTypeNameEnv + cdef const char[] kNodeMarketTypeEnv + cdef const char[] kNodeRegionEnv + cdef const char[] kNodeZoneEnv + cdef const char[] kLabelKeyNodeAcceleratorType + cdef const char[] kLabelKeyNodeMarketType + cdef const char[] kLabelKeyNodeRegion + cdef const char[] kLabelKeyNodeZone + cdef const char[] kLabelKeyNodeGroup + cdef const char[] kLabelKeyTpuTopology + cdef const char[] kLabelKeyTpuSliceName + cdef const char[] kLabelKeyTpuWorkerId + cdef const char[] kLabelKeyTpuPodType + cdef const char[] kRayInternalNamespacePrefix diff --git a/lib/python3.12/site-packages/ray/includes/function_descriptor.pxd b/lib/python3.12/site-packages/ray/includes/function_descriptor.pxd new file mode 100644 index 0000000000000000000000000000000000000000..5124405772b8ae0382625f95843943861be55bfb --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/function_descriptor.pxd @@ -0,0 +1,80 @@ +from libc.stdint cimport uint8_t, uint64_t +from libcpp cimport bool as c_bool +from libcpp.memory cimport unique_ptr, shared_ptr +from libcpp.string cimport string as c_string +from libcpp.unordered_map cimport unordered_map +from libcpp.vector cimport vector as c_vector + +from ray.includes.common cimport ( + CLanguage, +) +from ray.includes.unique_ids cimport ( + CActorID, + CJobID, + CObjectID, + CTaskID, +) + +cdef extern from "src/ray/protobuf/common.pb.h" nogil: + cdef cppclass CFunctionDescriptorType \ + "ray::FunctionDescriptorType": + pass + + cdef CFunctionDescriptorType EmptyFunctionDescriptorType \ + "ray::FunctionDescriptorType::FUNCTION_DESCRIPTOR_NOT_SET" + cdef CFunctionDescriptorType JavaFunctionDescriptorType \ + "ray::FunctionDescriptorType::kJavaFunctionDescriptor" + cdef CFunctionDescriptorType PythonFunctionDescriptorType \ + "ray::FunctionDescriptorType::kPythonFunctionDescriptor" + cdef CFunctionDescriptorType CppFunctionDescriptorType \ + "ray::FunctionDescriptorType::kCppFunctionDescriptor" + + +cdef extern from "ray/common/function_descriptor.h" nogil: + cdef cppclass CFunctionDescriptorInterface \ + "ray::FunctionDescriptorInterface": + CFunctionDescriptorType Type() + c_string ToString() + c_string Serialize() + + ctypedef shared_ptr[CFunctionDescriptorInterface] CFunctionDescriptor \ + "ray::FunctionDescriptor" + + cdef cppclass CFunctionDescriptorBuilder "ray::FunctionDescriptorBuilder": + @staticmethod + CFunctionDescriptor Empty() + + @staticmethod + CFunctionDescriptor BuildJava(const c_string &class_name, + const c_string &function_name, + const c_string &signature) + + @staticmethod + CFunctionDescriptor BuildPython(const c_string &module_name, + const c_string &class_name, + const c_string &function_name, + const c_string &function_source_hash) + + @staticmethod + CFunctionDescriptor BuildCpp(const c_string &function_name, + const c_string &caller, + const c_string &class_name) + + @staticmethod + CFunctionDescriptor Deserialize(const c_string &serialized_binary) + + cdef cppclass CJavaFunctionDescriptor "ray::JavaFunctionDescriptor": + c_string ClassName() + c_string FunctionName() + c_string Signature() + + cdef cppclass CPythonFunctionDescriptor "ray::PythonFunctionDescriptor": + c_string ModuleName() + c_string ClassName() + c_string FunctionName() + c_string FunctionHash() + + cdef cppclass CCppFunctionDescriptor "ray::CppFunctionDescriptor": + c_string FunctionName() + c_string Caller() + c_string ClassName() diff --git a/lib/python3.12/site-packages/ray/includes/global_state_accessor.pxd b/lib/python3.12/site-packages/ray/includes/global_state_accessor.pxd new file mode 100644 index 0000000000000000000000000000000000000000..d90a023e3ae277640853bfd0cdb0f1105ce4873b --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/global_state_accessor.pxd @@ -0,0 +1,141 @@ +from libcpp.string cimport string as c_string +from libcpp cimport bool as c_bool +from libcpp.vector cimport vector as c_vector +from libcpp.unordered_map cimport unordered_map +from libcpp.memory cimport unique_ptr +from libc.stdint cimport ( + int32_t as c_int32_t, + uint32_t as c_uint32_t, + int64_t as c_int64_t, +) +from ray.includes.unique_ids cimport ( + CActorID, + CJobID, + CNodeID, + CObjectID, + CWorkerID, + CPlacementGroupID, +) +from ray.includes.common cimport ( + CRayStatus, + CGcsClientOptions, +) +from ray.includes.optional cimport ( + optional +) + +cdef extern from "ray/gcs_rpc_client/global_state_accessor.h" nogil: + cdef cppclass CGlobalStateAccessor "ray::gcs::GlobalStateAccessor": + CGlobalStateAccessor(const CGcsClientOptions&) + c_bool Connect() + void Disconnect() + c_vector[c_string] GetAllJobInfo( + c_bool skip_submission_job_info_field, c_bool skip_is_running_tasks_field) + CJobID GetNextJobID() + c_vector[c_string] GetAllNodeInfo() + c_vector[c_string] GetAllAvailableResources() + c_vector[c_string] GetAllTotalResources() + unordered_map[CNodeID, c_int64_t] GetDrainingNodes() + unique_ptr[c_string] GetInternalKV( + const c_string &namespace, const c_string &key) + c_vector[c_string] GetAllTaskEvents() + unique_ptr[c_string] GetObjectInfo(const CObjectID &object_id) + unique_ptr[c_string] GetAllResourceUsage() + c_vector[c_string] GetAllActorInfo( + optional[CActorID], optional[CJobID], optional[c_string]) + unique_ptr[c_string] GetActorInfo(const CActorID &actor_id) + unique_ptr[c_string] GetWorkerInfo(const CWorkerID &worker_id) + c_vector[c_string] GetAllWorkerInfo() + c_bool AddWorkerInfo(const c_string &serialized_string) + c_bool UpdateWorkerDebuggerPort(const CWorkerID &worker_id, + const c_uint32_t debuger_port) + c_bool UpdateWorkerNumPausedThreads(const CWorkerID &worker_id, + const c_int32_t num_paused_threads_delta) + c_uint32_t GetWorkerDebuggerPort(const CWorkerID &worker_id) + unique_ptr[c_string] GetPlacementGroupInfo( + const CPlacementGroupID &placement_group_id) + unique_ptr[c_string] GetPlacementGroupByName( + const c_string &placement_group_name, + const c_string &ray_namespace, + ) + c_vector[c_string] GetAllPlacementGroupInfo() + c_string GetSystemConfig() + CRayStatus GetNodeToConnectForDriver( + const c_string &node_ip_address, + c_string *node_to_connect) + CRayStatus GetNode( + const c_string &node_id_hex_str, + c_string *node_info) + +cdef extern from * namespace "ray::gcs" nogil: + """ + #include + #include "ray/gcs/store_client_kv.h" + #include "ray/gcs/store_client/redis_store_client.h" + #include "ray/util/raii.h" + namespace ray { + namespace gcs { + + bool RedisGetKeySync(const std::string& host, + int32_t port, + const std::string& username, + const std::string& password, + bool use_ssl, + const std::string& config, + const std::string& key, + std::string* data) { + // Logging default value see class `RayLog`. + InitShutdownRAII ray_log_shutdown_raii(ray::RayLog::StartRayLog, + ray::RayLog::ShutDownRayLog, + "ray_init", + ray::RayLogLevel::WARNING, + /*log_filepath=*/"", + /*err_log_filepath=*/"", + /*log_rotation_max_size=*/1ULL << 29, + /*log_rotation_file_num=*/10); + + std::string config_list; + RAY_CHECK(absl::Base64Unescape(config, &config_list)); + RayConfig::instance().initialize(config_list); + + instrumented_io_context io_service{/*enable_lag_probe=*/false, /*running_on_single_thread=*/true}; + RedisClientOptions options{host, port, username, password, use_ssl}; + auto client = std::make_unique( + std::make_unique(io_service, options)); + + bool ret_val = false; + client->Get("session", key, {[&](std::optional result) { + if (result.has_value()) { + *data = result.value(); + ret_val = true; + } else { + RAY_LOG(INFO) << "Failed to retrieve the key " << key + << " from persistent storage."; + ret_val = false; + } + }, io_service}); + io_service.run_for(std::chrono::milliseconds(1000)); + + return ret_val; + } + + } + } + """ + c_bool RedisGetKeySync(const c_string& host, + c_int32_t port, + const c_string& username, + const c_string& password, + c_bool use_ssl, + const c_string& config, + const c_string& key, + c_string* data) + + +cdef extern from "ray/gcs/store_client/redis_store_client.h" namespace "ray::gcs" nogil: + c_bool RedisDelKeyPrefixSync(const c_string& host, + c_int32_t port, + const c_string& username, + const c_string& password, + c_bool use_ssl, + const c_string& key_prefix) diff --git a/lib/python3.12/site-packages/ray/includes/libcoreworker.pxd b/lib/python3.12/site-packages/ray/includes/libcoreworker.pxd new file mode 100644 index 0000000000000000000000000000000000000000..16aaa749ad28dee7e2700cc4402274327f87e026 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/libcoreworker.pxd @@ -0,0 +1,456 @@ +# cython: profile = False +# distutils: language = c++ +# cython: embedsignature = True + +from libc.stdint cimport int64_t, uint64_t +from libcpp cimport bool as c_bool +from libcpp.functional cimport function +from libcpp.memory cimport shared_ptr, unique_ptr +from libcpp.pair cimport pair as c_pair +from libcpp.string cimport string as c_string +from libcpp.unordered_map cimport unordered_map +from libcpp.utility cimport pair +from libcpp.vector cimport vector as c_vector + +from ray.includes.unique_ids cimport ( + CActorID, + CClusterID, + CNodeID, + CJobID, + CTaskID, + CObjectID, + CPlacementGroupID, + CWorkerID, + ObjectIDIndexType, +) + +from ray.includes.common cimport ( + CAddress, + CObjectReference, + CActorCreationOptions, + CBuffer, + CPlacementGroupCreationOptions, + CObjectLocation, + CObjectReference, + CRayFunction, + CRayObject, + CRayStatus, + CTaskArg, + CTaskOptions, + CTaskType, + CWorkerType, + CLanguage, + CGcsClientOptions, + LocalMemoryBuffer, + CJobConfig, + CConcurrencyGroup, + CSchedulingStrategy, + CWorkerExitType, + CLineageReconstructionTask, + CTensorTransport, +) +from ray.includes.function_descriptor cimport ( + CFunctionDescriptor, +) + +from ray.includes.optional cimport ( + optional, +) + +ctypedef unordered_map[c_string, c_vector[pair[int64_t, double]]] \ + ResourceMappingType + +ctypedef void (*ray_callback_function) \ + (shared_ptr[CRayObject] result_object, + CObjectID object_id, void* user_data) + +ctypedef void (*plasma_callback_function) \ + (CObjectID object_id, int64_t data_size, int64_t metadata_size) + +# NOTE: This ctypedef is needed, because Cython doesn't compile +# "pair[shared_ptr[const CActorHandle], CRayStatus]". +# This is a bug of cython: https://github.com/cython/cython/issues/3967. +ctypedef shared_ptr[const CActorHandle] ActorHandleSharedPtr + +cdef extern from "ray/core_worker/profile_event.h" nogil: + cdef cppclass CProfileEvent "ray::core::worker::ProfileEvent": + void SetExtraData(const c_string &extra_data) + +cdef extern from "ray/core_worker/task_execution/fiber.h" nogil: + cdef cppclass CFiberEvent "ray::core::FiberEvent": + CFiberEvent() + void Wait() + void Notify() + +cdef extern from "ray/core_worker/experimental_mutable_object_manager.h" nogil: + cdef cppclass CReaderRefInfo "ray::experimental::ReaderRefInfo": + CReaderRefInfo() + CObjectID reader_ref_id + CActorID owner_reader_actor_id + int64_t num_reader_actors + + +cdef extern from "ray/core_worker/context.h" nogil: + cdef cppclass CWorkerContext "ray::core::WorkerContext": + c_bool CurrentActorIsAsync() + void SetCurrentActorShouldExit() + c_bool GetCurrentActorShouldExit() + const c_string &GetCurrentSerializedRuntimeEnv() + int CurrentActorMaxConcurrency() + CActorID GetRootDetachedActorID() + +cdef extern from "ray/core_worker/generator_waiter.h" nogil: + cdef cppclass CGeneratorBackpressureWaiter "ray::core::GeneratorBackpressureWaiter": # noqa + CGeneratorBackpressureWaiter( + int64_t generator_backpressure_num_objects, + (CRayStatus() nogil) check_signals) + CRayStatus WaitAllObjectsReported() + +cdef extern from "ray/core_worker/core_worker.h" nogil: + cdef cppclass CActorHandle "ray::core::ActorHandle": + CActorID GetActorID() const + CJobID CreationJobID() const + CLanguage ActorLanguage() const + CFunctionDescriptor ActorCreationTaskFunctionDescriptor() const + c_string ExtensionData() const + int MaxPendingCalls() const + int MaxTaskRetries() const + c_bool EnableTaskEvents() const + c_bool AllowOutOfOrderExecution() const + c_bool EnableTensorTransport() const + + cdef cppclass CCoreWorker "ray::core::CoreWorker": + CWorkerType GetWorkerType() + CLanguage GetLanguage() + + c_vector[CObjectReference] SubmitTask( + const CRayFunction &function, + const c_vector[unique_ptr[CTaskArg]] &args, + const CTaskOptions &options, + int max_retries, + c_bool retry_exceptions, + const CSchedulingStrategy &scheduling_strategy, + c_string debugger_breakpoint, + c_string serialized_retry_exception_allowlist, + c_string call_site, + const CTaskID current_task_id) + CRayStatus CreateActor( + const CRayFunction &function, + const c_vector[unique_ptr[CTaskArg]] &args, + const CActorCreationOptions &options, + const c_string &extension_data, + c_string call_site, + CActorID *actor_id) + CRayStatus CreatePlacementGroup( + const CPlacementGroupCreationOptions &options, + CPlacementGroupID *placement_group_id) + CRayStatus RemovePlacementGroup( + const CPlacementGroupID &placement_group_id) + CRayStatus WaitPlacementGroupReady( + const CPlacementGroupID &placement_group_id, int64_t timeout_seconds) + CRayStatus SubmitActorTask( + const CActorID &actor_id, const CRayFunction &function, + const c_vector[unique_ptr[CTaskArg]] &args, + const CTaskOptions &options, + int max_retries, + c_bool retry_exceptions, + c_string serialized_retry_exception_allowlist, + c_string call_site, + c_vector[CObjectReference] &task_returns, + const CTaskID current_task_id) + CRayStatus KillActor( + const CActorID &actor_id, c_bool force_kill, + c_bool no_restart) + CRayStatus CancelTask(const CObjectID &object_id, c_bool force_kill, + c_bool recursive) + + unique_ptr[CProfileEvent] CreateProfileEvent( + const c_string &event_type) + CRayStatus AllocateReturnObject( + const CObjectID &object_id, + const size_t &data_size, + const shared_ptr[CBuffer] &metadata, + const c_vector[CObjectID] &contained_object_id, + const CAddress &caller_address, + int64_t *task_output_inlined_bytes, + shared_ptr[CRayObject] *return_object) + CRayStatus SealReturnObject( + const CObjectID &return_id, + const shared_ptr[CRayObject] &return_object, + const CObjectID &generator_id, + const CAddress &caller_address + ) + c_bool PinExistingReturnObject( + const CObjectID &return_id, + shared_ptr[CRayObject] *return_object, + const CObjectID &generator_id, + const CAddress &caller_address) + void AsyncDelObjectRefStream(const CObjectID &generator_id) + CRayStatus TryReadObjectRefStream( + const CObjectID &generator_id, + CObjectReference *object_ref_out) + c_bool StreamingGeneratorIsFinished(const CObjectID &generator_id) const + pair[CObjectReference, c_bool] PeekObjectRefStream( + const CObjectID &generator_id) + CObjectID AllocateDynamicReturnId( + const CAddress &owner_address, + const CTaskID &task_id, + optional[ObjectIDIndexType] put_index) + + CJobID GetCurrentJobId() + CTaskID GetCurrentTaskId() + const c_string GetCurrentTaskName() + const c_string GetCurrentTaskFunctionName() + void UpdateTaskIsDebuggerPaused( + const CTaskID &task_id, + const c_bool is_debugger_paused) + int64_t GetCurrentTaskAttemptNumber() + CNodeID GetCurrentNodeId() + int64_t GetTaskDepth() + c_bool GetCurrentTaskRetryExceptions() + CPlacementGroupID GetCurrentPlacementGroupId() const + CWorkerID GetWorkerID() + c_bool ShouldCaptureChildTasksInPlacementGroup() + CActorID GetActorId() const + const c_string GetActorName() + void SetActorReprName(const c_string &repr_name) + void SetWebuiDisplay(const c_string &key, const c_string &message) + const ResourceMappingType &GetResourceIDs() const + void RemoveActorHandleReference(const CActorID &actor_id) + optional[int] GetLocalActorState(const CActorID &actor_id) const + CActorID DeserializeAndRegisterActorHandle(const c_string &bytes, const + CObjectID &outer_object_id, + c_bool add_local_ref) + CRayStatus SerializeActorHandle(const CActorID &actor_id, c_string + *bytes, + CObjectID *c_actor_handle_id) + ActorHandleSharedPtr GetActorHandle(const CActorID &actor_id) const + pair[ActorHandleSharedPtr, CRayStatus] GetNamedActorHandle( + const c_string &name, const c_string &ray_namespace) + pair[c_vector[c_pair[c_string, c_string]], CRayStatus] ListNamedActors( + c_bool all_namespaces) + void AddLocalReference(const CObjectID &object_id) + void RemoveLocalReference(const CObjectID &object_id) + void PutObjectIntoPlasma(const CRayObject &object, + const CObjectID &object_id) + const CAddress &GetRpcAddress() const + CRayStatus GetOwnerAddress(const CObjectID &object_id, + CAddress *owner_address) const + c_vector[CObjectReference] GetObjectRefs( + const c_vector[CObjectID] &object_ids) const + + CRayStatus GetOwnershipInfo(const CObjectID &object_id, + CAddress *owner_address, + c_string *object_status) + void RegisterOwnershipInfoAndResolveFuture( + const CObjectID &object_id, + const CObjectID &outer_object_id, + const CAddress &owner_address, + const c_string &object_status) + + CRayStatus Put(const CRayObject &object, + const c_vector[CObjectID] &contained_object_ids, + CObjectID *object_id) + CRayStatus Put(const CRayObject &object, + const c_vector[CObjectID] &contained_object_ids, + const CObjectID &object_id) + CRayStatus CreateOwnedAndIncrementLocalRef( + c_bool is_mutable, + const shared_ptr[CBuffer] &metadata, + const size_t data_size, + const c_vector[CObjectID] &contained_object_ids, + CObjectID *object_id, shared_ptr[CBuffer] *data, + const unique_ptr[CAddress] &owner_address, + c_bool inline_small_object, + CTensorTransport tensor_transport) + CRayStatus CreateExisting(const shared_ptr[CBuffer] &metadata, + const size_t data_size, + const CObjectID &object_id, + const CAddress &owner_address, + shared_ptr[CBuffer] *data, + c_bool created_by_worker) + CRayStatus ExperimentalChannelWriteAcquire( + const CObjectID &object_id, + const shared_ptr[CBuffer] &metadata, + uint64_t data_size, + int64_t num_readers, + int64_t timeout_ms, + shared_ptr[CBuffer] *data) + CRayStatus ExperimentalChannelWriteRelease( + const CObjectID &object_id) + CRayStatus ExperimentalChannelSetError( + const CObjectID &object_id) + void ExperimentalRegisterMutableObjectWriter( + const CObjectID &writer_object_id, + const c_vector[CNodeID] &remote_reader_node_ids) + CRayStatus ExperimentalRegisterMutableObjectReader(const CObjectID &object_id) + CRayStatus ExperimentalRegisterMutableObjectReaderRemote( + const CObjectID &object_id, + const c_vector[CReaderRefInfo] &remote_reader_ref_info) + CRayStatus SealOwned(const CObjectID &object_id, c_bool pin_object, + const unique_ptr[CAddress] &owner_address) + CRayStatus SealExisting(const CObjectID &object_id, c_bool pin_object, + const CObjectID &generator_id, + const unique_ptr[CAddress] &owner_address) + CRayStatus Get(const c_vector[CObjectID] &ids, int64_t timeout_ms, + c_vector[shared_ptr[CRayObject]] results) + CRayStatus GetIfLocal( + const c_vector[CObjectID] &ids, + c_vector[shared_ptr[CRayObject]] *results) + CRayStatus Contains(const CObjectID &object_id, c_bool *has_object, + c_bool *is_in_plasma) + CRayStatus Wait(const c_vector[CObjectID] &object_ids, int num_objects, + int64_t timeout_ms, c_vector[c_bool] *results, + c_bool fetch_local) + CRayStatus Delete(const c_vector[CObjectID] &object_ids, + c_bool local_only) + CRayStatus GetLocalObjectLocations( + const c_vector[CObjectID] &object_ids, + c_vector[optional[CObjectLocation]] *results) + CRayStatus GetLocationFromOwner( + const c_vector[CObjectID] &object_ids, + int64_t timeout_ms, + c_vector[shared_ptr[CObjectLocation]] *results) + CRayStatus TriggerGlobalGC() + CRayStatus ReportGeneratorItemReturns( + const pair[CObjectID, shared_ptr[CRayObject]] &dynamic_return_object, + const CObjectID &generator_id, + const CAddress &caller_address, + int64_t item_index, + uint64_t attempt_number, + shared_ptr[CGeneratorBackpressureWaiter] waiter) + + # Param output contains the usage string if successful. + # Returns an error status if unable to communicate with the plasma store. + CRayStatus GetPlasmaUsage(c_string &output) + + int GetMemoryStoreSize() + + CWorkerContext &GetWorkerContext() + void YieldCurrentFiber(CFiberEvent &coroutine_done) + + unordered_map[CObjectID, pair[size_t, size_t]] GetAllReferenceCounts() + c_vector[CTaskID] GetPendingChildrenTasks(const CTaskID &task_id) const + + void GetAsync(const CObjectID &object_id, + ray_callback_function success_callback, + void* python_user_callback) + + CRayStatus PushError(const CJobID &job_id, const c_string &type, + const c_string &error_message, double timestamp) + CRayStatus SetResource(const c_string &resource_name, + const double capacity, + const CNodeID &client_Id) + + CJobConfig GetJobConfig() + + int64_t GetLocalMemoryStoreBytesUsed() const + + void RecordTaskLogStart( + const CTaskID &task_id, + int attempt_number, + const c_string& stdout_path, + const c_string& stderr_path, + int64_t stdout_start_offset, + int64_t stderr_start_offset) const + + void RecordTaskLogEnd( + const CTaskID &task_id, + int attempt_number, + int64_t stdout_end_offset, + int64_t stderr_end_offset) const + + void Exit(const CWorkerExitType exit_type, + const c_string &detail, + const shared_ptr[LocalMemoryBuffer] &creation_task_exception_pb_bytes) + + unordered_map[CLineageReconstructionTask, uint64_t] \ + GetLocalOngoingLineageReconstructionTasks() const + + cdef cppclass CCoreWorkerOptions "ray::core::CoreWorkerOptions": + CWorkerType worker_type + CLanguage language + c_string store_socket + c_string raylet_socket + CJobID job_id + CGcsClientOptions gcs_options + c_bool enable_logging + c_string log_dir + c_bool install_failure_signal_handler + c_bool interactive + c_string node_ip_address + int node_manager_port + c_string driver_name + (CRayStatus( + const CAddress &caller_address, + CTaskType task_type, + const c_string name, + const CRayFunction &ray_function, + const unordered_map[c_string, double] &resources, + const c_vector[shared_ptr[CRayObject]] &args, + const c_vector[CObjectReference] &arg_refs, + const c_string debugger_breakpoint, + const c_string serialized_retry_exception_allowlist, + c_vector[c_pair[CObjectID, shared_ptr[CRayObject]]] *returns, + c_vector[c_pair[CObjectID, shared_ptr[CRayObject]]] *dynamic_returns, + c_vector[c_pair[CObjectID, c_bool]] *streaming_generator_returns, + shared_ptr[LocalMemoryBuffer] + &creation_task_exception_pb_bytes, + c_bool *is_retryable_error, + c_string *application_error, + const c_vector[CConcurrencyGroup] &defined_concurrency_groups, + const c_string name_of_concurrency_group_to_execute, + c_bool is_reattempt, + c_bool is_streaming_generator, + c_bool should_retry_exceptions, + int64_t generator_backpressure_num_objects, + CTensorTransport tensor_transport + ) nogil) task_execution_callback + (void(const CObjectID &) nogil) free_actor_object_callback + (function[void()]() nogil) initialize_thread_callback + (CRayStatus() nogil) check_signals + (void(c_bool) nogil) gc_collect + (c_vector[c_string]( + const c_vector[CObjectReference] &) nogil) spill_objects + (int64_t( + const c_vector[CObjectReference] &, + const c_vector[c_string] &) nogil) restore_spilled_objects + (void( + const c_vector[c_string]&, + CWorkerType) nogil) delete_spilled_objects + (void( + const c_string&, + const c_vector[c_string]&) nogil) run_on_util_worker_handler + (void(const CRayObject&) nogil) unhandled_exception_handler + (c_bool(const CTaskID &c_task_id) nogil) cancel_async_actor_task + (void() noexcept nogil) actor_shutdown_callback + (void(c_string *stack_out) nogil) get_lang_stack + c_bool is_local_mode + int num_workers + (c_bool(const CTaskID &) nogil) kill_main + CCoreWorkerOptions() + c_string serialized_job_config + int metrics_agent_port + int runtime_env_hash + int startup_token + CClusterID cluster_id + c_string session_name + c_string entrypoint + int64_t worker_launch_time_ms + int64_t worker_launched_time_ms + c_string debug_source + + cdef cppclass CCoreWorkerProcess "ray::core::CoreWorkerProcess": + @staticmethod + void Initialize(const CCoreWorkerOptions &options) + # Only call this in CoreWorker.__cinit__, + # use CoreWorker.core_worker to access C++ CoreWorker. + + @staticmethod + CCoreWorker &GetCoreWorker() + + @staticmethod + void Shutdown() + + @staticmethod + void RunTaskExecutionLoop() diff --git a/lib/python3.12/site-packages/ray/includes/metric.pxd b/lib/python3.12/site-packages/ray/includes/metric.pxd new file mode 100644 index 0000000000000000000000000000000000000000..5135c56db421ddf61f410c0bdc6cda2733fb262c --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/metric.pxd @@ -0,0 +1,39 @@ +from libcpp.string cimport string as c_string +from libcpp.vector cimport vector as c_vector +from libcpp.pair cimport pair as c_pair + +cdef extern from "ray/stats/metric.h" nogil: + cdef cppclass CMetric "ray::stats::Metric": + CMetric(const c_string &name, + const c_string &description, + const c_string &unit, + const c_vector[c_string] &tag_keys) + c_string GetName() const + void Record(double value) + void RecordForCython(double value, + c_vector[c_pair[c_string, c_string]] tags) + + cdef cppclass CGauge "ray::stats::Gauge": + CGauge(const c_string &name, + const c_string &description, + const c_string &unit, + const c_vector[c_string] &tag_keys) + + cdef cppclass CCount "ray::stats::Count": + CCount(const c_string &name, + const c_string &description, + const c_string &unit, + const c_vector[c_string] &tag_keys) + + cdef cppclass CSum "ray::stats::Sum": + CSum(const c_string &name, + const c_string &description, + const c_string &unit, + const c_vector[c_string] &tag_keys) + + cdef cppclass CHistogram "ray::stats::Histogram": + CHistogram(const c_string &name, + const c_string &description, + const c_string &unit, + const c_vector[double] &boundaries, + const c_vector[c_string] &tag_keys) diff --git a/lib/python3.12/site-packages/ray/includes/network_util.pxd b/lib/python3.12/site-packages/ray/includes/network_util.pxd new file mode 100644 index 0000000000000000000000000000000000000000..569734cadc41d2672311f7196a7ee231723c8d0f --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/network_util.pxd @@ -0,0 +1,12 @@ +from libc.stddef cimport size_t +from libcpp.string cimport string +from libcpp cimport bool +from ray.includes.array cimport array_string_2 +from ray.includes.optional cimport optional + +cdef extern from "ray/util/network_util.h" namespace "ray": + string BuildAddress(const string &host, int port) + string BuildAddress(const string &host, const string &port) + optional[array_string_2] ParseAddress(const string &address) + string GetNodeIpAddressFromPerspective(const optional[string] &address) + bool IsIPv6(const string &host) diff --git a/lib/python3.12/site-packages/ray/includes/object_ref.pyi b/lib/python3.12/site-packages/ray/includes/object_ref.pyi new file mode 100644 index 0000000000000000000000000000000000000000..78a744e8a856b146a9423a1cd734036131ee2e45 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/object_ref.pyi @@ -0,0 +1,74 @@ +# source: object_ref.pxi +import asyncio +import concurrent.futures +from typing import Any, Awaitable, Callable, Generator, TypeVar, Union + +from ray.includes.unique_ids import BaseID, JobID, TaskID + +_T = TypeVar("_T") +def _set_future_helper( + result: _T, + *, + py_future: Union[asyncio.Future[_T], concurrent.futures.Future[_T]], +) -> None: ... + + +_OR = TypeVar("_OR", bound=ObjectRef) +class ObjectRef(BaseID, Awaitable[_T]): + + + def __init__( + self, id: bytes, owner_addr: str = "", call_site_data: str = "", + skip_adding_local_ref: bool = False, tensor_transport_val = 0) -> None: ... + + def __dealloc__(self) -> None: ... + + + def task_id(self) -> TaskID: ... + + def job_id(self) -> JobID: ... + + def owner_address(self) -> str: ... + + def call_site(self) -> str: ... + + @classmethod + def size(cls) -> int: ... + + def _set_id(self, id: bytes) -> None: ... + + @classmethod + def nil(cls: type[_OR]) -> _OR: ... + + @classmethod + def from_random(cls: type[_OR]) -> _OR: ... + + def future(self) -> concurrent.futures.Future[_T]: + """Wrap ObjectRef with a concurrent.futures.Future + + Note that the future cancellation will not cancel the correspoding + task when the ObjectRef representing return object of a task. + Additionally, future.running() will always be ``False`` even if the + underlying task is running. + """ + ... + + def __await__(self) -> Generator[Any, None, _T]: ... + + def as_future(self, _internal=False) -> asyncio.Future[_T]: + """Wrap ObjectRef with an asyncio.Future. + + Note that the future cancellation will not cancel the correspoding + task when the ObjectRef representing return object of a task. + """ + ... + + def _on_completed(self, py_callback: Callable[[_T], None]): + """Register a callback that will be called after Object is ready. + If the ObjectRef is already ready, the callback will be called soon. + The callback should take the result as the only argument. The result + can be an exception object in case of task error. + """ + ... + + def tensor_transport(self) -> int: ... diff --git a/lib/python3.12/site-packages/ray/includes/optional.pxd b/lib/python3.12/site-packages/ray/includes/optional.pxd new file mode 100644 index 0000000000000000000000000000000000000000..a3539824ae73a16df48b1203fbf8b877d00fad42 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/optional.pxd @@ -0,0 +1,36 @@ +# Currently Cython does not support std::optional. +# See: https://github.com/cython/cython/pull/3294 +from libcpp cimport bool + +cdef extern from "" namespace "std" nogil: + cdef cppclass nullopt_t: + nullopt_t() + + cdef nullopt_t nullopt + + cdef cppclass optional[T]: + ctypedef T value_type + optional() + optional(nullopt_t) + optional(optional&) except + + optional(T&) except + + bool has_value() + T& value() + T& value_or[U](U& default_value) + void swap(optional&) + void reset() + T& emplace(...) + T& operator*() + # T* operator->() # Not Supported + optional& operator=(optional&) + optional& operator=[U](U&) + bool operator bool() + bool operator!() + bool operator==[U](optional&, U&) + bool operator!=[U](optional&, U&) + bool operator<[U](optional&, U&) + bool operator>[U](optional&, U&) + bool operator<=[U](optional&, U&) + bool operator>=[U](optional&, U&) + + optional[T] make_optional[T](...) except + diff --git a/lib/python3.12/site-packages/ray/includes/ray_config.pxd b/lib/python3.12/site-packages/ray/includes/ray_config.pxd new file mode 100644 index 0000000000000000000000000000000000000000..729395a22ee38dd2db8c7a3f752fa38129fbba32 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/ray_config.pxd @@ -0,0 +1,90 @@ +from libcpp cimport bool as c_bool +from libc.stdint cimport int64_t, uint64_t, uint32_t +from libcpp.string cimport string as c_string +from libcpp.unordered_map cimport unordered_map + + +cdef extern from "ray/common/ray_config.h" nogil: + cdef cppclass RayConfig "RayConfig": + @staticmethod + RayConfig &instance() + + void initialize(const c_string& config_list) + + int64_t ray_cookie() const + + int64_t handler_warning_timeout_ms() const + + int64_t debug_dump_period_milliseconds() const + + int64_t object_timeout_milliseconds() const + + int64_t raylet_client_num_connect_attempts() const + + int64_t raylet_client_connect_timeout_milliseconds() const + + int64_t raylet_fetch_timeout_milliseconds() const + + int64_t kill_worker_timeout_milliseconds() const + + int64_t worker_register_timeout_seconds() const + + int64_t redis_db_connect_retries() + + int64_t redis_db_connect_wait_milliseconds() const + + int object_manager_pull_timeout_ms() const + + int object_manager_push_timeout_ms() const + + uint32_t maximum_gcs_deletion_batch_size() const + + int64_t max_direct_call_object_size() const + + int64_t task_rpc_inlined_bytes_limit() const + + uint64_t metrics_report_interval_ms() const + + c_bool enable_timeline() const + + uint32_t max_grpc_message_size() const + + c_bool record_ref_creation_sites() const + + c_string REDIS_CA_CERT() const + + c_string REDIS_CA_PATH() const + + c_string REDIS_CLIENT_CERT() const + + c_string REDIS_CLIENT_KEY() const + + c_string REDIS_SERVER_NAME() const + + int64_t health_check_initial_delay_ms() const + + int64_t health_check_period_ms() const + + int64_t health_check_timeout_ms() const + + int64_t health_check_failure_threshold() const + + int64_t grpc_client_keepalive_time_ms() const + + int64_t grpc_client_keepalive_timeout_ms() const + + c_bool enable_autoscaler_v2() const + + c_string predefined_unit_instance_resources() const + + c_string custom_unit_instance_resources() const + + int64_t nums_py_gcs_reconnect_retry() const + + int64_t py_gcs_connect_timeout_s() const + + int maximum_gcs_destroyed_actor_cached_count() const + + c_bool record_task_actor_creation_sites() const + + c_bool start_python_gc_manager_thread() const diff --git a/lib/python3.12/site-packages/ray/includes/rpc_token_authentication.pxd b/lib/python3.12/site-packages/ray/includes/rpc_token_authentication.pxd new file mode 100644 index 0000000000000000000000000000000000000000..65b76dfecc6d92af6e8e0d11e0a72a35dbef301e --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/rpc_token_authentication.pxd @@ -0,0 +1,37 @@ +from libcpp cimport bool as c_bool +from libcpp.string cimport string +from ray.includes.optional cimport optional + + +cdef extern from "ray/rpc/authentication/authentication_mode.h" namespace "ray::rpc" nogil: + cdef enum CAuthenticationMode "ray::rpc::AuthenticationMode": + DISABLED "ray::rpc::AuthenticationMode::DISABLED" + TOKEN "ray::rpc::AuthenticationMode::TOKEN" + K8S "ray::rpc::AuthenticationMode::K8S" + + CAuthenticationMode GetAuthenticationMode() + +cdef extern from "ray/rpc/authentication/authentication_token.h" namespace "ray::rpc" nogil: + cdef cppclass CAuthenticationToken "ray::rpc::AuthenticationToken": + CAuthenticationToken() + CAuthenticationToken(string value) + c_bool empty() + c_bool Equals(const CAuthenticationToken& other) + string ToAuthorizationHeaderValue() + string GetRawValue() + @staticmethod + CAuthenticationToken FromMetadata(string metadata_value) + +cdef extern from "ray/rpc/authentication/authentication_token_loader.h" namespace "ray::rpc" nogil: + cdef cppclass CAuthenticationTokenLoader "ray::rpc::AuthenticationTokenLoader": + @staticmethod + CAuthenticationTokenLoader& instance() + c_bool HasToken() + void ResetCache() + optional[CAuthenticationToken] GetToken() + +cdef extern from "ray/rpc/authentication/authentication_token_validator.h" namespace "ray::rpc" nogil: + cdef cppclass CAuthenticationTokenValidator "ray::rpc::AuthenticationTokenValidator": + @staticmethod + CAuthenticationTokenValidator& instance() + c_bool ValidateToken(const optional[CAuthenticationToken]& expected_token, const CAuthenticationToken& provided_token) diff --git a/lib/python3.12/site-packages/ray/includes/setproctitle.pxd b/lib/python3.12/site-packages/ray/includes/setproctitle.pxd new file mode 100644 index 0000000000000000000000000000000000000000..788b4a6265fa1a928a373c4e457fe2ec8ad02178 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/setproctitle.pxd @@ -0,0 +1,17 @@ +from libcpp.string cimport string as c_string + +cdef extern from *: + """ + extern "C" { + #include "ray/thirdparty/setproctitle/spt_setup.h" + } + """ + int spt_setup() + +cdef extern from *: + """ + extern "C" { + #include "ray/thirdparty/setproctitle/spt_status.h" + } + """ + void set_ps_display(const char *activity, bint force) diff --git a/lib/python3.12/site-packages/ray/includes/stream_redirection.pxd b/lib/python3.12/site-packages/ray/includes/stream_redirection.pxd new file mode 100644 index 0000000000000000000000000000000000000000..29b7b0c2c55cabf95652020dc833a44b213bd611 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/stream_redirection.pxd @@ -0,0 +1,16 @@ +from libcpp.string cimport string as c_string +from libc.stdint cimport uint64_t +from libcpp cimport bool as c_bool + +cdef extern from "ray/util/stream_redirection_options.h" nogil: + cdef cppclass CStreamRedirectionOptions "ray::StreamRedirectionOption": + CStreamRedirectionOptions() + c_string file_path + uint64_t rotation_max_size + uint64_t rotation_max_file_count + c_bool tee_to_stdout + c_bool tee_to_stderr + +cdef extern from "ray/util/stream_redirection.h" namespace "ray" nogil: + void RedirectStdoutOncePerProcess(const CStreamRedirectionOptions& opt) + void RedirectStderrOncePerProcess(const CStreamRedirectionOptions& opt) diff --git a/lib/python3.12/site-packages/ray/includes/unique_ids.pxd b/lib/python3.12/site-packages/ray/includes/unique_ids.pxd new file mode 100644 index 0000000000000000000000000000000000000000..fe93a83675b266d7cb4ed57677094d6e43f49a60 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/unique_ids.pxd @@ -0,0 +1,191 @@ +from libcpp cimport bool as c_bool +from libcpp.string cimport string as c_string +from libc.stdint cimport uint8_t, uint32_t, int64_t + +# Note: we removed the staticmethod declarations in +# https://github.com/ray-project/ray/pull/47984 due +# to a compiler bug in Cython 3.0.x -- we should see +# if we can bring them back in Cython 3.1.x if the +# bug is fixed. +cdef extern from "ray/common/id.h" namespace "ray" nogil: + cdef cppclass CBaseID[T]: + size_t Hash() const + c_bool IsNil() const + c_bool operator==(const CBaseID &rhs) const + c_bool operator!=(const CBaseID &rhs) const + const uint8_t *data() const + + c_string Binary() const + c_string Hex() const + + cdef cppclass CUniqueID "ray::UniqueID"(CBaseID[CUniqueID]): + CUniqueID() + + @staticmethod + size_t Size() + + @staticmethod + CUniqueID FromRandom() + + @staticmethod + CUniqueID FromBinary(const c_string &binary) + + @staticmethod + const CUniqueID Nil() + + cdef cppclass CActorClassID "ray::ActorClassID"(CBaseID[CActorClassID]): + + @staticmethod + CActorClassID FromHex(const c_string &hex_str) + + cdef cppclass CActorID "ray::ActorID"(CBaseID[CActorID]): + + @staticmethod + CActorID FromBinary(const c_string &binary) + + @staticmethod + CActorID FromHex(const c_string &hex_str) + + @staticmethod + const CActorID Nil() + + @staticmethod + size_t Size() + + @staticmethod + CActorID Of(CJobID job_id, CTaskID parent_task_id, + int64_t parent_task_counter) + + CJobID JobId() + + cdef cppclass CNodeID "ray::NodeID"(CBaseID[CNodeID]): + + @staticmethod + CNodeID FromHex(const c_string &hex_str) + + @staticmethod + const CNodeID Nil() + + cdef cppclass CConfigID "ray::ConfigID"(CBaseID[CConfigID]): + pass + + cdef cppclass CFunctionID "ray::FunctionID"(CBaseID[CFunctionID]): + + @staticmethod + CFunctionID FromHex(const c_string &hex_str) + + cdef cppclass CJobID "ray::JobID"(CBaseID[CJobID]): + + @staticmethod + CJobID FromBinary(const c_string &binary) + + @staticmethod + CJobID FromHex(const c_string &hex_str) + + @staticmethod + const CJobID Nil() + + @staticmethod + size_t Size() + + @staticmethod + CJobID FromInt(uint32_t value) + + uint32_t ToInt() + + cdef cppclass CTaskID "ray::TaskID"(CBaseID[CTaskID]): + + @staticmethod + CTaskID FromBinary(const c_string &binary) + + @staticmethod + CTaskID FromHex(const c_string &hex_str) + + @staticmethod + const CTaskID Nil() + + @staticmethod + size_t Size() + + @staticmethod + CTaskID ForDriverTask(const CJobID &job_id) + + @staticmethod + CTaskID FromRandom(const CJobID &job_id) + + @staticmethod + CTaskID ForActorCreationTask(CActorID actor_id) + + @staticmethod + CTaskID ForActorTask(CJobID job_id, CTaskID parent_task_id, + int64_t parent_task_counter, CActorID actor_id) + + @staticmethod + CTaskID ForNormalTask(CJobID job_id, CTaskID parent_task_id, + int64_t parent_task_counter) + + CActorID ActorId() const + + CJobID JobId() const + + cdef cppclass CObjectID" ray::ObjectID"(CBaseID[CObjectID]): + + @staticmethod + int64_t MaxObjectIndex() + + @staticmethod + CObjectID FromBinary(const c_string &binary) + + @staticmethod + CObjectID FromRandom() + + @staticmethod + const CObjectID Nil() + + @staticmethod + CObjectID FromIndex(const CTaskID &task_id, int64_t index) + + @staticmethod + size_t Size() + + c_bool is_put() + + int64_t ObjectIndex() const + + CTaskID TaskId() const + + cdef cppclass CClusterID "ray::ClusterID"(CBaseID[CClusterID]): + + @staticmethod + CClusterID FromHex(const c_string &hex_str) + + @staticmethod + CClusterID FromRandom() + + @staticmethod + const CClusterID Nil() + + cdef cppclass CWorkerID "ray::WorkerID"(CBaseID[CWorkerID]): + + @staticmethod + CWorkerID FromHex(const c_string &hex_str) + + cdef cppclass CPlacementGroupID "ray::PlacementGroupID" \ + (CBaseID[CPlacementGroupID]): + + @staticmethod + CPlacementGroupID FromBinary(const c_string &binary) + + @staticmethod + CPlacementGroupID FromHex(const c_string &hex_str) + + @staticmethod + const CPlacementGroupID Nil() + + @staticmethod + size_t Size() + + @staticmethod + CPlacementGroupID Of(CJobID job_id) + + ctypedef uint32_t ObjectIDIndexType diff --git a/lib/python3.12/site-packages/ray/includes/unique_ids.pyi b/lib/python3.12/site-packages/ray/includes/unique_ids.pyi new file mode 100644 index 0000000000000000000000000000000000000000..5f04389f1aed0c10a2c08b315af0d3bd46005f67 --- /dev/null +++ b/lib/python3.12/site-packages/ray/includes/unique_ids.pyi @@ -0,0 +1,146 @@ +from __future__ import annotations + +from typing import Tuple, TypeVar + +# backwards compatibility. Luckily circular references are fine in type stubs +from ray._raylet import ObjectRef + +ObjectID = ObjectRef + +# implementations are in unique_ids.pxi +def check_id(b: bytes, size: int = ...) -> None: ... + +_BID = TypeVar("_BID", bound=BaseID) +class BaseID: + + @classmethod + def from_binary(cls: type[_BID], id_bytes: bytes) -> _BID: ... + + @classmethod + def from_hex(cls: type[_BID], hex_id: str | bytes) -> _BID: ... + + def binary(self) -> bytes: ... + + @classmethod + def size(cls) -> int: ... + + def hex(self) -> str: ... + + def is_nil(self) -> bool: ... + + def __hash__(self) -> int: ... + + def __eq__(self, other: object) -> bool: ... + + def __ne__(self, other: object) -> bool: ... + + def __bytes__(self) -> bytes: ... + + def __hex__(self) -> str: ... + + def __repr__(self) -> str: ... + + def __str__(self) -> str: ... + + def __reduce__(self: _BID) -> Tuple[type[_BID], Tuple[bytes]]: ... + + def redis_shard_hash(self) -> int: ... + + +_UID = TypeVar("_UID", bound=UniqueID) +class UniqueID(BaseID): + + def __init__(self, id: bytes) -> None: ... + + @classmethod + def nil(cls: type[_UID]) -> _UID: ... + + @classmethod + def from_random(cls: type[_UID]) -> _UID: ... + + +_TID = TypeVar("_TID", bound=TaskID) +class TaskID(BaseID): + + def __init__(self, id: bytes) -> None: ... + + def actor_id(self) -> ActorID: ... + + def job_id(self) -> JobID: ... + + @classmethod + def nil(cls: type[_TID]) -> _TID: ... + + @classmethod + def for_fake_task(cls: type[_TID], job_id: JobID) -> _TID: ... + + @classmethod + def for_driver_task(cls: type[_TID], job_id: JobID) -> _TID: ... + + @classmethod + def for_actor_creation_task(cls: type[_TID], actor_id: ActorID) -> _TID: ... + + @classmethod + def for_actor_task(cls: type[_TID], job_id: JobID, parent_task_id: TaskID, + parent_task_counter: int, actor_id: ActorID) -> _TID: ... + + @classmethod + def for_normal_task(cls: type[_TID], job_id: JobID, parent_task_id: TaskID, parent_task_counter: int) -> _TID: ... + + +class NodeID(UniqueID): ... + +_JID = TypeVar("_JID", bound=JobID) +class JobID(BaseID): + + def __init__(self, id: bytes) -> None: ... + + @classmethod + def from_int(cls: type[_JID], value: int) -> _JID: ... + + @classmethod + def nil(cls: type[_JID]) -> _JID: ... + + def int(self) -> int: ... + + +class WorkerID(UniqueID): ... + +_AID = TypeVar("_AID", bound=ActorID) +class ActorID(BaseID): + + def __init__(self, id: bytes) -> None: ... + + @classmethod + def of(cls: type[_AID], job_id: JobID, parent_task_id: TaskID, parent_task_counter: int) -> _AID: ... + + @classmethod + def nil(cls: type[_AID]) -> _AID: ... + + @classmethod + def from_random(cls: type[_AID]) -> _AID: ... + + def _set_id(self, id: bytes) -> None: ... + + @property + def job_id(self) -> JobID: ... + + +class FunctionID(UniqueID): ... +class ActorClassID(UniqueID): ... +class ClusterID(UniqueID): ... + + +_PGID = TypeVar("_PGID", bound=PlacementGroupID) +class PlacementGroupID(BaseID): + + def __init__(self, id: bytes) -> None: ... + + @classmethod + def from_random(cls: type[_PGID]) -> _PGID: ... + + @classmethod + def of(cls: type[_PGID], job_id: JobID) -> _PGID: ... + + @classmethod + def nil(cls: type[_PGID]) -> _PGID: ... diff --git a/lib/python3.12/site-packages/ray/internal/__init__.py b/lib/python3.12/site-packages/ray/internal/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..36740dd1870a1e010cad2f438bb89ab1a0353047 --- /dev/null +++ b/lib/python3.12/site-packages/ray/internal/__init__.py @@ -0,0 +1,3 @@ +from ray._private.internal_api import free + +__all__ = ["free"] diff --git a/lib/python3.12/site-packages/ray/internal/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/internal/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5113555d74f926be5007155e3a45ca75077a51c7 Binary files /dev/null and b/lib/python3.12/site-packages/ray/internal/__pycache__/__init__.cpython-312.pyc differ diff --git a/lib/python3.12/site-packages/ray/workflow/__init__.py b/lib/python3.12/site-packages/ray/workflow/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aa16d0a14d1fc4ce52e97460db842873a986d81d --- /dev/null +++ b/lib/python3.12/site-packages/ray/workflow/__init__.py @@ -0,0 +1,4 @@ +raise RuntimeError( + "The experimental Ray Workflows library was deprecated in Ray 2.44 and has been " + "removed. The last Ray release containing ray.workflows is `ray==2.47`." +) diff --git a/lib/python3.12/site-packages/ray/workflow/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/ray/workflow/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd3cdb3311132afd9f13998394b5133076eb0930 Binary files /dev/null and b/lib/python3.12/site-packages/ray/workflow/__pycache__/__init__.cpython-312.pyc differ