def connect(conn_str: str,
secure: bool = False,
metadata: List[Tuple[str, str]] = None,
connection_retries: int = 3,
job_config: JobConfig = None,
namespace: str = None,
*,
ignore_version: bool = False) -> Dict[str, Any]:
if ray.is_connected():
raise RuntimeError("Ray Client is already connected. "
"Maybe you called ray.util.connect twice by "
"accident?")
# Enable the same hooks that RAY_CLIENT_MODE does, as
# calling ray.util.connect() is specifically for using client mode.
_set_client_hook_status(True)
_explicitly_enable_client_mode()
# TODO(barakmich): https://github.com/ray-project/ray/issues/13274
# for supporting things like cert_path, ca_path, etc and creating
# the correct metadata
return ray.connect(conn_str,
job_config=job_config,
secure=secure,
metadata=metadata,
connection_retries=connection_retries,
namespace=namespace,
ignore_version=ignore_version)
def connect(
conn_str: str,
secure: bool = False,
metadata: List[Tuple[str, str]] = None,
connection_retries: int = 3,
job_config: JobConfig = None,
namespace: str = None,
*,
ignore_version: bool = False,
_credentials: Optional[grpc.ChannelCredentials] = None,
ray_init_kwargs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
if ray.is_connected():
raise RuntimeError("Ray Client is already connected. Maybe you called "
'ray.init("ray://<address>") twice by accident?')
# Enable the same hooks that RAY_CLIENT_MODE does, as calling
# ray.init("ray://<address>") is specifically for using client mode.
_set_client_hook_status(True)
_explicitly_enable_client_mode()
# TODO(barakmich): https://github.com/ray-project/ray/issues/13274
# for supporting things like cert_path, ca_path, etc and creating
# the correct metadata
conn = ray.connect(
conn_str,
job_config=job_config,
secure=secure,
metadata=metadata,
connection_retries=connection_retries,
namespace=namespace,
ignore_version=ignore_version,
_credentials=_credentials,
ray_init_kwargs=ray_init_kwargs,
)
return conn
def test_pretask_posttask_shared_state_multi_client(ray_start_regular_shared):
"""
Repeat the last test with Ray client.
"""
class PretaskPosttaskCallback(RayDaskCallback):
def __init__(self, suffix):
self.suffix = suffix
def _ray_pretask(self, key, object_refs):
return key + self.suffix
def _ray_posttask(self, key, result, pre_state):
assert pre_state == key + self.suffix
class PretaskOnlyCallback(RayDaskCallback):
def _ray_pretask(self, key, object_refs):
return "baz"
class PosttaskOnlyCallback(RayDaskCallback):
def _ray_posttask(self, key, result, pre_state):
assert pre_state is None
cb1 = PretaskPosttaskCallback("foo")
cb2 = PretaskOnlyCallback()
cb3 = PosttaskOnlyCallback()
cb4 = PretaskPosttaskCallback("bar")
with ray_start_client_server():
_explicitly_enable_client_mode()
with cb1, cb2, cb3, cb4:
z = add(2, 3)
result = z.compute(scheduler=ray_dask_get)
assert result == 5
def test_rllib_integration(ray_start_regular_shared):
with ray_start_client_server():
# Confirming the behavior of this context manager.
# (Client mode hook not yet enabled.)
assert not client_mode_should_convert()
# Need to enable this for client APIs to be used.
_explicitly_enable_client_mode()
# Confirming mode hook is enabled.
assert client_mode_should_convert()
rock_paper_scissors_multiagent.main()
def test_client_gpu_ids(call_ray_stop_only):
import ray
ray.init(num_cpus=2)
_explicitly_enable_client_mode()
# No client connection.
with pytest.raises(Exception) as e:
ray.get_gpu_ids()
assert str(e.value) == "Ray Client is not connected."\
" Please connect by calling `ray.connect`."
with ray_start_client_server():
# Now have a client connection.
assert ray.get_gpu_ids() == []
async def test_serve_handle(ray_start_regular_shared):
with ray_start_client_server() as ray:
from ray import serve
_explicitly_enable_client_mode()
serve.start()
@serve.deployment
def hello():
return "hello"
hello.deploy()
handle = hello.get_handle()
assert ray.get(handle.remote()) == "hello"
assert await handle.remote() == "hello"
def connect(conn_str: str,
secure: bool = False,
metadata: List[Tuple[str, str]] = None) -> None:
if ray.is_connected():
raise RuntimeError("Ray Client is already connected. "
"Maybe you called ray.util.connect twice by "
"accident?")
# Enable the same hooks that RAY_CLIENT_MODE does, as
# calling ray.util.connect() is specifically for using client mode.
_enable_client_hook(True)
_explicitly_enable_client_mode()
# TODO(barakmich): https://github.com/ray-project/ray/issues/13274
# for supporting things like cert_path, ca_path, etc and creating
# the correct metadata
return ray.connect(conn_str, secure=secure, metadata=metadata)
async def test_serve_handle(ray_start_regular_shared):
with ray_start_client_server() as ray:
from ray import serve
_explicitly_enable_client_mode()
serve.start(detached=True)
def hello(request):
return "hello"
serve.create_backend("my_backend", hello, config={"num_replicas": 1})
serve.create_endpoint("my_endpoint",
backend="my_backend",
route="/hello")
handle = serve.get_handle("my_endpoint")
assert ray.get(handle.remote()) == "hello"
assert await handle.remote() == "hello"
def connect(
self,
conn_str: str,
job_config: JobConfig = None,
secure: bool = False,
metadata: List[Tuple[str, str]] = None,
connection_retries: int = 3,
namespace: str = None,
*,
ignore_version: bool = False,
_credentials: Optional[grpc.ChannelCredentials] = None,
ray_init_kwargs: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Connect the Ray Client to a server.
Args:
conn_str: Connection string, in the form "[host]:port"
job_config: The job config of the server.
secure: Whether to use a TLS secured gRPC channel
metadata: gRPC metadata to send on connect
connection_retries: number of connection attempts to make
ignore_version: whether to ignore Python or Ray version mismatches.
This should only be used for debugging purposes.
Returns:
Dictionary of connection info, e.g., {"num_clients": 1}.
"""
# Delay imports until connect to avoid circular imports.
from ray.util.client.worker import Worker
if self.client_worker is not None:
if self._connected_with_init:
return
raise Exception("ray.init() called, but ray client is already connected")
if not self._inside_client_test:
# If we're calling a client connect specifically and we're not
# currently in client mode, ensure we are.
_explicitly_enable_client_mode()
if namespace is not None:
job_config = job_config or JobConfig()
job_config.set_ray_namespace(namespace)
logging_level = ray_constants.LOGGER_LEVEL
logging_format = ray_constants.LOGGER_FORMAT
if ray_init_kwargs is not None:
if ray_init_kwargs.get("logging_level") is not None:
logging_level = ray_init_kwargs["logging_level"]
if ray_init_kwargs.get("logging_format") is not None:
logging_format = ray_init_kwargs["logging_format"]
setup_logger(logging_level, logging_format)
try:
self.client_worker = Worker(
conn_str,
secure=secure,
_credentials=_credentials,
metadata=metadata,
connection_retries=connection_retries,
)
self.api.worker = self.client_worker
self.client_worker._server_init(job_config, ray_init_kwargs)
conn_info = self.client_worker.connection_info()
self._check_versions(conn_info, ignore_version)
self._register_serializers()
return conn_info
except Exception:
self.disconnect()
raise
def connect(self,
conn_str: str,
job_config: JobConfig = None,
secure: bool = False,
metadata: List[Tuple[str, str]] = None,
connection_retries: int = 3,
namespace: str = None,
*,
ignore_version: bool = False,
_credentials: Optional[grpc.ChannelCredentials] = None,
ray_init_kwargs: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
"""Connect the Ray Client to a server.
Args:
conn_str: Connection string, in the form "[host]:port"
job_config: The job config of the server.
secure: Whether to use a TLS secured gRPC channel
metadata: gRPC metadata to send on connect
connection_retries: number of connection attempts to make
ignore_version: whether to ignore Python or Ray version mismatches.
This should only be used for debugging purposes.
Returns:
Dictionary of connection info, e.g., {"num_clients": 1}.
"""
# Delay imports until connect to avoid circular imports.
from ray.util.client.worker import Worker
if self.client_worker is not None:
if self._connected_with_init:
return
raise Exception(
"ray.init() called, but ray client is already connected")
if not self._inside_client_test:
# If we're calling a client connect specifically and we're not
# currently in client mode, ensure we are.
_explicitly_enable_client_mode()
if namespace is not None:
job_config = job_config or JobConfig()
job_config.set_ray_namespace(namespace)
if job_config is not None:
runtime_env = json.loads(job_config.get_serialized_runtime_env())
if runtime_env.get("pip") or runtime_env.get("conda"):
logger.warning("The 'pip' or 'conda' field was specified in "
"the runtime env, so it may take some time to "
"install the environment before Ray connects.")
try:
self.client_worker = Worker(
conn_str,
secure=secure,
_credentials=_credentials,
metadata=metadata,
connection_retries=connection_retries)
self.api.worker = self.client_worker
self.client_worker._server_init(job_config, ray_init_kwargs)
conn_info = self.client_worker.connection_info()
self._check_versions(conn_info, ignore_version)
self._register_serializers()
return conn_info
except Exception:
self.disconnect()
raise
