Remove the everserver status file (#12115)

Author: frode-aarstad

src/ert/dark_storage/endpoints/experiment_server.py

@@ -297,6 +297,7 @@ def __init__(
 
     async def run(self) -> None:
         status_queue: SimpleQueue[StatusEvents] = SimpleQueue()
+        run_model: EverestRunModel | None = None
         try:
             with ErtPluginContext() as runtime_plugins:
                 run_model = EverestRunModel.create(
@@ -356,6 +357,9 @@ async def run(self) -> None:
                 status=ExperimentState.failed,
             )
         finally:
+            if run_model and run_model._experiment:
+                run_model._experiment.status = shared_data.status
+
             logging.getLogger(EXPERIMENT_SERVER).info(
                 f"ExperimentRunner done. Items left in queue: {status_queue.qsize()}"
             )

src/everest/bin/monitor_script.py

@@ -7,8 +7,8 @@
 from pathlib import Path
 
 from ert.services import StorageService
+from ert.storage import ExperimentState
 from everest.config import EverestConfig, ServerConfig
-from everest.detached import ExperimentState
 from everest.everest_storage import EverestStorage
 
 from .utils import (

src/everest/config/server_config.py

@@ -18,7 +18,6 @@
     CERTIFICATE_DIR,
     DETACHED_NODE_DIR,
     HOSTFILE_NAME,
-    SERVER_STATUS,
     SESSION_DIR,
 )
 from .simulator_config import check_removed_config
@@ -130,11 +129,6 @@ def get_session_dir(output_dir: str) -> str:
         certificates and host information"""
         return os.path.join(ServerConfig.get_detached_node_dir(output_dir), SESSION_DIR)
 
-    @staticmethod
-    def get_everserver_status_path(output_dir: str) -> str:
-        """Returns path to the everest server status file"""
-        return os.path.join(ServerConfig.get_session_dir(output_dir), SERVER_STATUS)
-
     @staticmethod
     def get_certificate_dir(output_dir: str) -> str:
         """Return the path to certificate folder"""

src/everest/detached/__init__.py

@@ -4,28 +4,22 @@
 
 from .client import (
     PROXY,
-    ExperimentState,
-    everserver_status,
     server_is_running,
     start_experiment,
     start_monitor,
     start_server,
     stop_server,
-    update_everserver_status,
     wait_for_server,
     wait_for_server_to_stop,
 )
 
 __all__ = [
     "PROXY",
-    "ExperimentState",
-    "everserver_status",
     "server_is_running",
     "start_experiment",
     "start_monitor",
     "start_server",
     "stop_server",
-    "update_everserver_status",
     "wait_for_server",
     "wait_for_server_to_stop",
 ]

src/everest/detached/client.py

@@ -1,7 +1,5 @@
 import asyncio
-import json
 import logging
-import os
 import re
 import ssl
 import time
@@ -21,7 +19,6 @@
 from ert.scheduler import create_driver
 from ert.scheduler.driver import Driver, FailedSubmit
 from ert.scheduler.event import StartedEvent
-from ert.storage import ExperimentState
 from ert.trace import get_traceparent
 from everest.config import EverestConfig, ServerConfig
 from everest.strings import (
@@ -261,40 +258,3 @@ def start_monitor(
 
     except Exception:
         logger.exception(traceback.format_exc())
-
-
-def update_everserver_status(
-    everserver_status_path: str, status: ExperimentState, message: str | None = None
-) -> None:
-    """Update the everest server status with new status information"""
-    new_status = {"status": status, "message": message}
-    path = everserver_status_path
-    if not os.path.exists(os.path.dirname(path)):
-        os.makedirs(os.path.dirname(path))
-        Path(path).write_text(json.dumps(new_status), encoding="utf-8")
-    elif os.path.exists(path):
-        server_status = everserver_status(path)
-        if server_status["message"] is not None:
-            if message is not None:
-                new_status["message"] = "{}\n{}".format(
-                    server_status["message"], message
-                )
-            else:
-                new_status["message"] = server_status["message"]
-        Path(path).write_text(json.dumps(new_status), encoding="utf-8")
-
-
-def everserver_status(everserver_status_path: str) -> dict[str, Any]:
-    """Returns a dictionary representing the everest server status. If the
-    status file is not found we assume the server has never ran before, and will
-    return a status of ServerStatus.never_run
-
-    Example: {
-                'status': ServerStatus.completed
-                'message': None
-             }
-    """
-    if os.path.exists(everserver_status_path):
-        return json.loads(Path(everserver_status_path).read_text(encoding="utf-8"))
-    else:
-        return {"status": ExperimentState.never_run, "message": None}

src/everest/detached/everserver.py

@@ -4,7 +4,6 @@
 import os
 import pathlib
 import time
-import traceback
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Any
@@ -16,13 +15,9 @@
 from ert.services import StorageService
 from ert.services._base_service import BaseServiceExit
 from ert.storage import ExperimentStatus
+from ert.storage.local_experiment import ExperimentState
 from ert.trace import tracer
 from everest.config import ServerConfig
-from everest.detached import (
-    ExperimentState,
-    everserver_status,
-    update_everserver_status,
-)
 from everest.strings import (
     DEFAULT_LOGGING_FORMAT,
     EVEREST,
@@ -142,8 +137,6 @@ def main() -> None:
 
     output_dir = options.output_dir
 
-    status_path = ServerConfig.get_everserver_status_path(output_dir)
-
     ctx = (
         TraceContextTextMapPropagator().extract(
             carrier={"traceparent": options.traceparent}
@@ -165,7 +158,6 @@ def main() -> None:
             )
 
             logging.getLogger(EVERSERVER).info("Everserver starting ...")
-            update_everserver_status(status_path, ExperimentState.pending)
             logger.info(version_info())
             logger.info(f"Output directory: {output_dir}")
             # Starting the server
@@ -175,8 +167,7 @@ def main() -> None:
                 timeout=240, project=server_path, logging_config=log_file.name
             ) as server:
                 server.fetch_conn_info()
-                with StorageService.session(project=server_path) as client:
-                    update_everserver_status(status_path, ExperimentState.running)
+                with StorageService.session(project=Path(server_path)) as client:
                     done = False
                     while not done:
                         response = client.get(
@@ -188,33 +179,10 @@ def main() -> None:
                             ExperimentState.running,
                         }
                         time.sleep(0.5)
-                    if status.status == ExperimentState.completed:
-                        update_everserver_status(
-                            status_path,
-                            ExperimentState.completed,
-                            message=status.message,
-                        )
-                    elif status.status == ExperimentState.stopped:
-                        update_everserver_status(
-                            status_path,
-                            ExperimentState.stopped,
-                            message=status.message,
-                        )
-                    elif status.status == ExperimentState.failed:
-                        update_everserver_status(
-                            status_path, ExperimentState.failed, message=status.message
-                        )
         except BaseServiceExit:
             # Server exit, happens on normal shutdown and keyboard interrupt
-            server_status = everserver_status(status_path)
-            if server_status["status"] == ExperimentState.running:
-                update_everserver_status(status_path, ExperimentState.stopped)
+            logging.getLogger(EVERSERVER).info("Everserver stopped by user")
         except Exception as e:
-            update_everserver_status(
-                status_path,
-                ExperimentState.failed,
-                message=traceback.format_exc(),
-            )
             logging.getLogger(EVERSERVER).exception(e)
 
 

src/everest/strings.py

@@ -23,7 +23,6 @@
 OPT_FAILURE_ALL_REALIZATIONS = "Optimization failed: all realizations failed."
 
 SESSION_DIR = ".session"
-SERVER_STATUS = "status"
 SIMULATION = "simulation"
 SIMULATOR_START = "start"
 SIMULATOR_UPDATE = "update"

tests/everest/entry_points/test_everest_entry.py

@@ -8,15 +8,11 @@
 import everest
 from ert.config import QueueSystem
 from ert.run_models.everest_run_model import ExperimentStatus
+from ert.storage import ExperimentState
 from everest.bin.everest_script import everest_entry
 from everest.bin.kill_script import kill_entry
 from everest.bin.monitor_script import monitor_entry
-from everest.config import EverestConfig, ServerConfig
-from everest.detached import (
-    ExperimentState,
-    everserver_status,
-    update_everserver_status,
-)
+from everest.config import EverestConfig
 from tests.everest.utils import capture_streams
 
 CONFIG_FILE_MINIMAL = "config_minimal.yml"
@@ -26,13 +22,6 @@ def raise_system_error(*args, **kwargs):
     raise SystemError("Reality was ripped to shreds!")
 
 
-def run_detached_monitor_mock(status=ExperimentState.completed, error=None, **kwargs):
-    path = os.path.join(
-        os.getcwd(), "everest_output/detached_node_output/.session/status"
-    )
-    update_everserver_status(path, status, message=error)
-
-
 @patch("everest.bin.everest_script.run_detached_monitor")
 @patch("everest.bin.everest_script.wait_for_server")
 @patch("everest.bin.everest_script.start_server")
@@ -281,7 +270,7 @@ def test_everest_entry_detached_running_monitor(
 def test_everest_entry_monitor_already_run(
     session_mock,
     get_server_context_from_conn_info_mock,
-    everserver_status_mock,
+    get_experiment_status_mock,
     start_monitor_mock,
     change_to_tmpdir,
 ):
@@ -293,7 +282,7 @@ def test_everest_entry_monitor_already_run(
         monitor_entry(["config.yml"])
     assert "Optimization already completed." in out.getvalue()
     start_monitor_mock.assert_not_called()
-    everserver_status_mock.assert_called()
+    get_experiment_status_mock.assert_called()
     session_mock.assert_called_once()
     get_server_context_from_conn_info_mock.assert_not_called()
 
@@ -352,66 +341,6 @@ def test_exception_raised_when_server_run_fails_monitor(
         monitor_entry(["config.yml"])
 
 
-@patch(
-    "everest.bin.everest_script.run_detached_monitor",
-    side_effect=run_detached_monitor_mock,
-)
-@patch("everest.bin.everest_script.wait_for_server")
-@patch("everest.bin.everest_script.start_server")
-@patch("everest.bin.everest_script.start_experiment")
-@patch(
-    "ert.services.StorageService.session",
-    side_effect=[TimeoutError(), MagicMock()],
-)
-@patch("everest.config.ServerConfig.get_server_context_from_conn_info")
-def test_complete_status_for_normal_run(
-    get_server_context_from_conn_info_mock,
-    session_mock,
-    start_experiment_mock,
-    start_server_mock,
-    wait_for_server_mock,
-    start_monitor_mock,
-    change_to_tmpdir,
-):
-    Path("config.yml").touch()
-    config = EverestConfig.with_defaults(config_path="./config.yml")
-    config.dump("config.yml")
-
-    everest_entry(["config.yml", "--skip-prompt"])
-    status_path = ServerConfig.get_everserver_status_path(config.output_dir)
-    status = everserver_status(status_path)
-    expected_status = ExperimentState.completed
-    expected_error = None
-
-    assert expected_status == status["status"]
-    assert expected_error == status["message"]
-
-
-@patch(
-    "everest.bin.monitor_script.run_detached_monitor",
-    side_effect=run_detached_monitor_mock,
-)
-@patch("ert.services.StorageService.session")
-@patch("everest.config.ServerConfig.get_server_context_from_conn_info")
-def test_complete_status_for_normal_run_monitor(
-    get_server_context_from_conn_info_mock,
-    session_mock,
-    start_monitor_mock,
-    change_to_tmpdir,
-):
-    Path("config.yml").touch()
-    config = EverestConfig.with_defaults(config_path="./config.yml")
-    config.dump("config.yml")
-    monitor_entry(["config.yml"])
-    status_path = ServerConfig.get_everserver_status_path(config.output_dir)
-    status = everserver_status(status_path)
-    expected_status = ExperimentState.completed
-    expected_error = None
-
-    assert expected_status == status["status"]
-    assert expected_error == status["message"]
-
-
 class ServerStatus:
     pass