def test_dataclient_server_drop(ray_start_regular_shared):
from ray.util.client import ray as ray_client
ray_client._inside_client_test = True
@ray_client.remote
def f(x):
time.sleep(4)
return x
def stop_server(server):
time.sleep(2)
server.stop(0)
server = ray_client_server.serve("localhost:50051")
ray_client.connect("localhost:50051")
thread = threading.Thread(target=stop_server, args=(server, ))
thread.start()
x = f.remote(2)
with pytest.raises(ConnectionError):
_ = ray_client.get(x)
thread.join()
ray_client.disconnect()
ray_client._inside_client_test = False
# Wait for f(x) to finish before ray.shutdown() in the fixture
time.sleep(3)
def ray_start_client_server_pair(metadata=None):
ray._inside_client_test = True
server = ray_client_server.serve("localhost:50051")
ray.connect("localhost:50051", metadata=metadata)
try:
yield ray, server
finally:
ray._inside_client_test = False
ray.disconnect()
server.stop(0)
def ray_start_client_server_pair(metadata=None, ray_connect_handler=None, **kwargs):
ray._inside_client_test = True
server = ray_client_server.serve(
"127.0.0.1:50051", ray_connect_handler=ray_connect_handler
)
ray.connect("127.0.0.1:50051", metadata=metadata, **kwargs)
try:
yield ray, server
finally:
ray._inside_client_test = False
ray.disconnect()
server.stop(0)
def ray_start_cluster_client_server_pair(address):
ray._inside_client_test = True
def ray_connect_handler(job_config=None):
real_ray.init(address=address)
server = ray_client_server.serve("localhost:50051",
ray_connect_handler=ray_connect_handler)
ray.connect("localhost:50051")
try:
yield ray, server
finally:
ray._inside_client_test = False
ray.disconnect()
server.stop(0)
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_startup_retry(ray_start_regular_shared):
from ray.util.client import ray as ray_client
ray_client._inside_client_test = True
with pytest.raises(ConnectionError):
ray_client.connect("localhost:50051", connection_retries=1)
def run_client():
ray_client.connect("localhost:50051")
ray_client.disconnect()
thread = threading.Thread(target=run_client, daemon=True)
thread.start()
time.sleep(3)
server = ray_client_server.serve("localhost:50051")
thread.join()
server.stop(0)
ray_client._inside_client_test = False
def ray_start_client_server_pair(metadata=None,
ray_connect_handler=None,
**kwargs):
ray._inside_client_test = True
with disable_client_hook():
assert not ray.is_initialized()
server = ray_client_server.serve("127.0.0.1:50051",
ray_connect_handler=ray_connect_handler)
ray.connect("127.0.0.1:50051", metadata=metadata, **kwargs)
try:
yield ray, server
finally:
ray._inside_client_test = False
ray.disconnect()
server.stop(0)
del server
start = time.monotonic()
with disable_client_hook():
while ray.is_initialized():
time.sleep(1)
if time.monotonic() - start > 30:
raise RuntimeError("Failed to terminate Ray")
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)
def run_client():
ray_client.connect("localhost:50051")
ray_client.disconnect()
from ray.util.client import ray
from ray.tune import tune
ray.connect("localhost:50051")
tune.run("PG", config={"env": "CartPole-v0"})
