Replace old client with new storage api

src/ert/services/ert_client.py

@@ -16,7 +16,7 @@
 import numpy.typing as npt
 import pandas as pd
 
-from .shared_client import Methods, SharedClient
+from .shared_client import ErtClientConnectionInfo, Methods, SharedClient
 
 DEFAULT_TIMEOUT = 120
 DEFAULT_CACHE_SIZE = 256
@@ -124,6 +124,10 @@ def get_client(
     def client(self) -> SharedClient:
         return self._client
 
+    @property
+    def conn_info(self) -> ErtClientConnectionInfo:
+        return self._client.conn_info
+
     def clear_cache(self) -> None:
         with self._cache_lock:
             self._cache.clear()

src/everest/bin/everest_script.py

@@ -16,7 +16,7 @@
 
 from _ert.threading import ErtThread
 from ert.config import QueueSystem
-from ert.services import create_ertserver_client
+from ert.services.ert_client import ErtClient
 from ert.storage.local_experiment import ExperimentState
 from ert.trace import trace
 from ert.utils import makedirs_if_needed
@@ -164,8 +164,9 @@
 async def run_everest(options: argparse.Namespace) -> None:
 
     try:
-        create_ertserver_client(
-            Path(ServerConfig.get_session_dir(options.config.output_dir)), timeout=1
+        ErtClient.for_project(
+            Path(ServerConfig.get_session_dir(options.config.output_dir)),
+            connect_timeout=1,
         )
         server_running = True
     except TimeoutError:
@@ -227,7 +228,7 @@
     print("Waiting for server ...")
     logger.debug("Waiting for response from everserver")
     wait_start_time: float = time.monotonic()
-    client = create_ertserver_client(
+    client = ErtClient.for_project(
         Path(ServerConfig.get_session_dir(options.config.output_dir))
     )
     wait_for_server(client, timeout=600)

src/everest/bin/kill_script.py

@@ -12,7 +12,7 @@
 from pathlib import Path
 from typing import Any
 
-from ert.services import create_ertserver_client
+from ert.services.ert_client import ErtClient
 from everest.bin.utils import setup_logging
 from everest.config import EverestConfig, ServerConfig
 from everest.detached import stop_server, wait_for_server_to_stop
@@ -74,8 +74,9 @@
 
 def kill_everest(options: argparse.Namespace) -> None:
     try:
-        client = create_ertserver_client(
-            Path(ServerConfig.get_session_dir(options.config.output_dir)), timeout=1
+        client = ErtClient.for_project(
+            Path(ServerConfig.get_session_dir(options.config.output_dir)),
+            connect_timeout=1,
         )
         server_context = ServerConfig.get_server_context_from_conn_info(
             client.conn_info

src/everest/bin/monitor_script.py

@@ -7,7 +7,7 @@
 from pathlib import Path
 from textwrap import dedent
 
-from ert.services import create_ertserver_client
+from ert.services.ert_client import ErtClient
 from ert.storage import ErtStorageException, ExperimentState
 from everest.config import EverestConfig, ServerConfig
 from everest.detached.client import get_experiments
@@ -78,31 +78,25 @@
 def monitor_everest(options: argparse.Namespace) -> None:
     config: EverestConfig = options.config
     try:  # ruff: ignore[too-many-statements-in-try-clause]
-        with create_ertserver_client(
-            Path(ServerConfig.get_session_dir(config.output_dir)), timeout=1
-        ) as client:
-            server_context = ServerConfig.get_server_context_from_conn_info(
-                client.conn_info
-            )
-            experiment_id = get_experiments(server_context)[-1]
-            run_detached_monitor(
-                server_context=server_context, experiment_id=experiment_id
-            )
-
-            try:
-                experiment_status = get_experiment_status(str(config.storage_dir))
-                if (
-                    experiment_status
-                    and experiment_status.status == ExperimentState.failed
-                ):
-                    raise SystemExit(experiment_status.message or "Optimization failed")
-                if experiment_status:
-                    print(
-                        experiment_status.message
-                        or "Optimization completed successfully"
-                    )
-            except ErtStorageException as err:
-                print(f"Error reading experiment status: {err}")
+        client = ErtClient.for_project(
+            Path(ServerConfig.get_session_dir(config.output_dir)), connect_timeout=1
+        )
+        server_context = ServerConfig.get_server_context_from_conn_info(
+            client.conn_info
+        )
+        experiment_id = get_experiments(server_context)[-1]
+        run_detached_monitor(server_context=server_context, experiment_id=experiment_id)
+
+        try:
+            experiment_status = get_experiment_status(str(config.storage_dir))
+            if experiment_status and experiment_status.status == ExperimentState.failed:
+                raise SystemExit(experiment_status.message or "Optimization failed")
+            if experiment_status:
+                print(
+                    experiment_status.message or "Optimization completed successfully"
+                )
+        except ErtStorageException as err:
+            print(f"Error reading experiment status: {err}")
 
     except TimeoutError:
         try:  # ruff: ignore[too-many-statements-in-try-clause]

src/everest/bin/utils.py

@@ -24,7 +24,7 @@
 from ert.ensemble_evaluator.event import EndEvent
 from ert.logging import LOGGING_CONFIG
 from ert.plugins.plugin_manager import ErtPluginManager
-from ert.services import create_ertserver_client
+from ert.services.ert_client import ErtClient
 from ert.storage import (
     ExperimentStatus,
     open_storage,
@@ -106,7 +106,7 @@
             "The optimization will be stopped and the program will exit..."
         )
         try:
-            client = create_ertserver_client(
+            client = ErtClient.for_project(
                 Path(ServerConfig.get_session_dir(options.config.output_dir))
             )
             server_context = ServerConfig.get_server_context_from_conn_info(

src/everest/detached/client.py

@@ -18,7 +18,7 @@
 from ert.scheduler import create_driver
 from ert.scheduler.driver import Driver, FailedSubmit
 from ert.scheduler.event import StartedEvent
-from ert.services.shared_client import Client
+from ert.services.ert_client import ErtClient
 from ert.trace import get_traceparent
 from everest.config import EverestConfig, ServerConfig
 from everest.strings import (
@@ -142,7 +142,7 @@ def extract_errors_from_file(path: str) -> list[str]:
     return re.findall(r"(Error \w+.*)", Path(path).read_text(encoding="utf-8"))
 
 
-def wait_for_server(client: Client, timeout: float) -> None:
+def wait_for_server(api: ErtClient, timeout: float) -> None:
     """
     Waits until the everest server has started. Polls
     for server availability until timeout (measured in seconds).
@@ -156,7 +156,7 @@ def wait_for_server(client: Client, timeout: float) -> None:
     wait_start_time: float = time.monotonic()
     while time.monotonic() - wait_start_time <= timeout:
         if server_is_running(
-            *ServerConfig.get_server_context_from_conn_info(client.conn_info)
+            *ServerConfig.get_server_context_from_conn_info(api.conn_info)
         ):
             return
         until_timeout = max(0, timeout - (time.monotonic() - wait_start_time))

src/everest/detached/everserver.py

@@ -13,7 +13,7 @@
 
 from ert.logging import LOGGING_CONFIG
 from ert.plugins.plugin_manager import ErtPluginManager
-from ert.services import ErtServerController, ErtServerExit, create_ertserver_client
+from ert.services import ErtClient, ErtServerController, ErtServerExit
 from ert.storage import ExperimentStatus
 from ert.storage.local_experiment import ExperimentState
 from ert.trace import tracer
@@ -23,7 +23,6 @@
 from everest.strings import (
     DEFAULT_LOGGING_FORMAT,
     OPTIMIZATION_LOG_DIR,
-    EverEndpoints,
 )
 from everest.util import version_info
 
@@ -149,26 +148,21 @@ def main() -> None:
                 timeout=240, project=Path(server_path), logging_config=log_file.name
             ) as server:
                 server.fetch_connection_info()
-                with create_ertserver_client(Path(server_path)) as client:
-                    done = False
-                    while not done:
-                        experiment_ids = get_experiments(
-                            ServerConfig.get_server_context_from_conn_info(
-                                client.conn_info
-                            )
-                        )
-                        active = [
-                            ExperimentStatus(
-                                **client.get(
-                                    f"/experiment_server/{EverEndpoints.STATUS}/{experiment_id}",
-                                    auth=server.fetch_auth(),
-                                ).json()
-                            ).status
-                            in {ExperimentState.pending, ExperimentState.running}
-                            for experiment_id in experiment_ids
-                        ]
-                        done = experiment_ids and not any(active)
-                        time.sleep(0.5)
+                client = ErtClient.for_project(Path(server_path))
+                done = False
+                while not done:
+                    experiment_ids = get_experiments(
+                        ServerConfig.get_server_context_from_conn_info(client.conn_info)
+                    )
+                    active = [
+                        ExperimentStatus(
+                            **client.experiment_status(experiment_id)
+                        ).status
+                        in {ExperimentState.pending, ExperimentState.running}
+                        for experiment_id in experiment_ids
+                    ]
+                    done = experiment_ids and not any(active)
+                    time.sleep(0.5)
         except ErtServerExit:
             # Server exit, happens on normal shutdown and keyboard interrupt
             logging.getLogger(__name__).info("Everserver stopped by user")

src/everest/gui/main_window.py

@@ -14,7 +14,7 @@
 from ert.gui.experiments import RunDialog
 from ert.gui.experiments.experiment_client import ExperimentClient
 from ert.plugins import ErtPluginManager
-from ert.services import create_ertserver_client
+from ert.services.ert_client import ErtClient
 from everest.config import ServerConfig
 from everest.detached import get_experiments, wait_for_server
 
@@ -43,21 +43,21 @@
         self.setCentralWidget(self.central_widget)
 
     def run(self) -> None:
-        storage_client = create_ertserver_client(
+        client = ErtClient.for_project(
             Path(ServerConfig.get_session_dir(self.output_dir))
         )
-        wait_for_server(storage_client, 60)
+        wait_for_server(client, 60)
 
         server_context = ServerConfig.get_server_context_from_conn_info(
-            storage_client.conn_info
+            client.conn_info
         )
         url, cert, auth = server_context
 
         ssl_context = ssl.create_default_context()
         ssl_context.load_verify_locations(cafile=cert)
         username, password = auth
 
-        client = ExperimentClient(
+        exp_client = ExperimentClient(
             experiment_id=get_experiments(server_context)[-1],
             url=url,
             cert_file=cert,
@@ -66,12 +66,12 @@
             ssl_context=ssl_context,
         )
 
-        config = client.config
+        config = exp_client.config
         title = Path(config["config_path"]).name
         self.setWindowTitle(f"EVEREST - {title}")
 
-        run_model_api = client.create_run_model_api()
-        event_queue, event_monitor_thread = client.setup_event_queue_from_ws_endpoint(
+        run_model_api = exp_client.create_run_model_api()
+        event_queue, event_monitor_thread = exp_client.setup_event_queue_from_ws_endpoint(
             refresh_interval=0.02, open_timeout=40, websocket_recv_timeout=1.0
         )
 

tests/ert/ui_tests/gui/conftest.py

@@ -51,6 +51,7 @@ def setup_svg_search_path():
 @pytest.fixture(autouse=True)
 def reset_ert_api_client():
     # The client is process-wide and bound to one project, but each test has its own.
+    SharedClient.close_client()
     yield
     SharedClient.close_client()
 

tests/everest/conftest.py

@@ -18,6 +18,7 @@
 from ert.run_models import StatusEvents
 from ert.run_models.event import status_event_from_json, status_event_to_json
 from ert.run_models.everest_run_model import EverestRunModel
+from ert.services import SharedClient
 from everest.config import (
     EverestConfig,
 )
@@ -26,6 +27,15 @@
 from tests.everest.utils import MIN_CONFIG, get_optimal_result, relpath
 
 
+@pytest.fixture(autouse=True)
+def reset_ert_api_client():
+    # The client is process-wide and bound to one project, but each test has its own.
+    # Background threads may rebind it after teardown, so reset on the way in too.
+    SharedClient.close_client()
+    yield
+    SharedClient.close_client()
+
+
 @pytest.fixture
 def min_config():
     return yaml.safe_load(MIN_CONFIG)