From aa6dd0d91f341748923338e6c63d1feca8f3a104 Mon Sep 17 00:00:00 2001 From: Bart Schilperoort Date: Thu, 4 Jan 2024 15:00:40 +0100 Subject: [PATCH] Add support for dockerized model. --- PyStemmusScope/bmi.py | 110 +++++++++++++++++------------- PyStemmusScope/docker_process.py | 112 +++++++++++++++++++++++++++++++ PyStemmusScope/local_process.py | 80 ++++++++++++++++++++++ docs/notebooks/BMI_demo.ipynb | 66 +++++++++++------- 4 files changed, 297 insertions(+), 71 deletions(-) create mode 100644 PyStemmusScope/docker_process.py create mode 100644 PyStemmusScope/local_process.py diff --git a/PyStemmusScope/bmi.py b/PyStemmusScope/bmi.py index 51f293c1..283d55de 100644 --- a/PyStemmusScope/bmi.py +++ b/PyStemmusScope/bmi.py @@ -1,9 +1,7 @@ """BMI wrapper for the STEMMUS_SCOPE model.""" -import os -import subprocess import sys from pathlib import Path -from typing import Dict +from typing import Dict, Literal, Protocol from typing import Tuple from typing import Union import h5py @@ -126,23 +124,61 @@ def set_variable( return state -def is_alive(process: Union[subprocess.Popen, None]) -> subprocess.Popen: - """Return process if the process is alive, raise an exception if it is not.""" - if process is None: - msg = "Model process does not seem to be open." - raise ConnectionError(msg) - if process.poll() is not None: - msg = f"Model terminated with return code {process.poll()}" - raise ConnectionError(msg) - return process +def get_run_mode(config: dict) -> str: + """Get the run mode (docker or EXE) from the config file. + + Args: + config: Config dictionary + + Returns: + Run mode (either "exe" or "docker"). + """ + if "ExeFilePath" in config: + return "exe" + else: + return "docker" -def wait_for_model(process: subprocess.Popen, phrase=b"Select run mode:") -> None: - """Wait for model to be ready for interaction.""" - output = b"" - while is_alive(process) and phrase not in output: - assert process.stdout is not None # required for type narrowing. - output += bytes(process.stdout.read(1)) +class StemmusScopeProcess(Protocol): + """Protocol for communicating with the model process.""" + def __init__(self, cfg_file: str) -> None: + """Initialize the process class (e.g. create the container).""" + ... + + def is_alive(self) -> bool: + """Return if the process is alive.""" + ... + + def initialize(self) -> None: + """Initialize the model and wait for it to be ready.""" + ... + + def update(self) -> None: + """Update the model and wait for it to be ready.""" + ... + + def finalize(self) -> None: + """Finalize the model.""" + ... + + +def load_process(mode: Literal["exe", "docker"]) -> type[StemmusScopeProcess]: + """Load the right STEMMUS_SCOPE process.""" + if mode == "docker": + try: + from PyStemmusScope.docker_process import StemmusScopeDocker as Process + except ImportError as err: + msg = ( + "The docker python package is not available." + " Please install before continuing." + ) + raise ImportError(msg) from err + elif mode == "exe": + from PyStemmusScope.local_process import LocalStemmusScope as Process + else: + msg = "Unknown mode." + raise ValueError(msg) + return Process class StemmusScopeBmi(InapplicableBmiMethods, Bmi): @@ -153,7 +189,8 @@ class StemmusScopeBmi(InapplicableBmiMethods, Bmi): state: Union[h5py.File, None] = None state_file: Union[Path, None] = None - matlab_process: Union[subprocess.Popen, None] = None + _run_mode: Union[str, None] = None + _process: Union[type[StemmusScopeProcess], None] = None def initialize(self, config_file: str) -> None: """Perform startup tasks for the model. @@ -163,40 +200,19 @@ def initialize(self, config_file: str) -> None: """ self.config_file = config_file self.config = read_config(config_file) - self.exe_file = self.config["ExeFilePath"] - self.state_file = Path(self.config["OutputPath"]) / "STEMMUS_SCOPE_state.mat" - - args = [self.exe_file, self.config_file, "interactive"] - - # set matlab log dirc - os.environ["MATLAB_LOG_DIR"] = str(self.config["InputPath"]) - self.matlab_process = subprocess.Popen( - args, - stdin=subprocess.PIPE, - stdout=subprocess.PIPE, - bufsize=0, - ) + self._run_mode = get_run_mode(self.config) + self.state_file = Path(self.config["OutputPath"]) / "STEMMUS_SCOPE_state.mat" - wait_for_model(self.matlab_process) - self.matlab_process = is_alive(self.matlab_process) - self.matlab_process.stdin.write(b"initialize\n") # type: ignore - wait_for_model(self.matlab_process) - self.state = load_state(self.config) + self._process = load_process(self._run_mode)(cfg_file=config_file) + self._process.initialize() def update(self) -> None: """Advance the model state by one time step.""" if self.state is not None: self.state = self.state.close() # Close file to allow matlab to write - if self.matlab_process is None: - msg = "Run initialize before trying to update the model." - raise AttributeError(msg) - - self.matlab_process = is_alive(self.matlab_process) - self.matlab_process.stdin.write(b"update\n") # type: ignore - wait_for_model(self.matlab_process) - + self._process.update() self.state = load_state(self.config) def update_until(self, time: float) -> None: @@ -210,9 +226,7 @@ def update_until(self, time: float) -> None: def finalize(self) -> None: """Finalize the STEMMUS_SCOPE model.""" - self.matlab_process = is_alive(self.matlab_process) - self.matlab_process.stdin.write(b"finalize\n") # type: ignore - wait_for_model(self.matlab_process, phrase=b"Finished clean up.") + self._process.finalize() def get_component_name(self) -> str: """Name of the component. diff --git a/PyStemmusScope/docker_process.py b/PyStemmusScope/docker_process.py new file mode 100644 index 00000000..6ba691cb --- /dev/null +++ b/PyStemmusScope/docker_process.py @@ -0,0 +1,112 @@ +"""The Docker STEMMUS_SCOPE model process wrapper.""" +from PyStemmusScope.config_io import read_config +from pathlib import Path +import os +import docker + + +def make_docker_vols_binds(cfg_file: str) -> tuple[list[str], list[str]]: + """Make docker volume mounting configs. + + Args: + cfg_file: Location of the config file + + Returns: + volumes, binds + """ + cfg = read_config(cfg_file) + + volumes = [cfg["OutputPath"], cfg["InputPath"]] + binds = [ + f"{cfg['OutputPath']}:{cfg['OutputPath']}:rw", + f"{cfg['InputPath']}:{cfg['InputPath']}:ro", + ] + + if ( + not Path(cfg_file).parent.is_relative_to(cfg["InputPath"]) or + not Path(cfg_file).parent.is_relative_to(cfg["OutputPath"]) + ): + cfg_folder = str(Path(cfg_file).parent) + volumes.append(cfg_folder) + binds.append(f"{cfg_folder}:{cfg_folder}:ro") + + return volumes, binds + + +class StemmusScopeDocker: + """Communicate with a STEMMUS_SCOPE Docker container.""" + # The image is hard coded here to ensure compatiblity: + image = "ghcr.io/ecoextreml/stemmus_scope:1.5.0" + + _process_ready_phrase = b"Select BMI mode:" + + def __init__(self, cfg_file: str): + """Create the Docker container..""" + self.cfg_file = cfg_file + + self.client = docker.APIClient() + + vols, binds = make_docker_vols_binds(cfg_file) + self.container_id = self.client.create_container( + self.image, + stdin_open=True, + tty=True, + detach=True, + volumes=vols, + host_config=self.client.create_host_config(binds=binds) + ) + + self.running = False + + def wait_for_model(self): + """Wait for the model to be ready to receive (more) commands.""" + output = b"" + + while self._process_ready_phrase not in output: + data = self.socket.read(1) + if data is None: + msg = "Could not read data from socket. Docker container might be dead." + raise ConnectionError(msg) + else: + output += bytes(data) + + def is_alive(self): + """Return if the process is alive.""" + return self.running + + def initialize(self): + """Initialize the model and wait for it to be ready.""" + if self.is_alive(): + self.client.stop(self.container_id) + + self.client.start(self.container_id) + self.socket = self.client.attach_socket( + self.container_id, {'stdin': 1, 'stdout': 1, 'stream':1} + ) + self.wait_for_model() + os.write( + self.socket.fileno(), + bytes(f'initialize "{self.cfg_file}"\n', encoding="utf-8") + ) + self.wait_for_model() + + self.running = True + + def update(self): + """Update the model and wait for it to be ready.""" + if self.is_alive(): + os.write( + self.socket.fileno(), + b'update\n' + ) + self.wait_for_model() + else: + msg = "Docker container is not alive. Please restart the model." + raise ConnectionError(msg) + + def finalize(self): + """Finalize the model.""" + if self.is_alive(): + os.write(self.socket.fileno(),b'finalize\n') + else: + pass diff --git a/PyStemmusScope/local_process.py b/PyStemmusScope/local_process.py new file mode 100644 index 00000000..c05d429f --- /dev/null +++ b/PyStemmusScope/local_process.py @@ -0,0 +1,80 @@ +"""The local STEMMUS_SCOPE model process wrapper.""" +import subprocess +from typing import Union +from PyStemmusScope.config_io import read_config +import os + + +def is_alive(process: Union[subprocess.Popen, None]) -> subprocess.Popen: + """Return process if the process is alive, raise an exception if it is not.""" + if process is None: + msg = "Model process does not seem to be open." + raise ConnectionError(msg) + if process.poll() is not None: + msg = f"Model terminated with return code {process.poll()}" + raise ConnectionError(msg) + return process + + +def wait_for_model(process: subprocess.Popen, phrase=b"Select BMI mode:") -> None: + """Wait for model to be ready for interaction.""" + output = b"" + while is_alive(process) and phrase not in output: + assert process.stdout is not None # required for type narrowing. + output += bytes(process.stdout.read(1)) + + +class LocalStemmusScope: + """Communicate with the local STEMMUS_SCOPE executable file.""" + def __init__(self, cfg_file: str) -> None: + """Initialize the process.""" + self.cfg_file = cfg_file + config = read_config(cfg_file) + + exe_file = config["ExeFilePath"] + args = [exe_file, cfg_file, "bmi"] + + os.environ["MATLAB_LOG_DIR"] = str(config["InputPath"]) + + self.matlab_process = subprocess.Popen( + args, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + bufsize=0, + ) + + wait_for_model(self.matlab_process) + + def is_alive(self) -> bool: + """Return if the process is alive.""" + try: + is_alive(self.matlab_process) + return True + except ConnectionError: + return False + + def initialize(self) -> None: + """Initialize the model and wait for it to be ready.""" + self.matlab_process = is_alive(self.matlab_process) + self.matlab_process.stdin.write( + bytes(f'initialize "{self.cfg_file}"\n', encoding="utf-8") # type: ignore + ) + wait_for_model(self.matlab_process) + + + def update(self) -> None: + """Update the model and wait for it to be ready.""" + if self.matlab_process is None: + msg = "Run initialize before trying to update the model." + raise AttributeError(msg) + + self.matlab_process = is_alive(self.matlab_process) + self.matlab_process.stdin.write(b"update\n") # type: ignore + wait_for_model(self.matlab_process) + + + def finalize(self) -> None: + """Finalize the model.""" + self.matlab_process = is_alive(self.matlab_process) + self.matlab_process.stdin.write(b"finalize\n") # type: ignore + wait_for_model(self.matlab_process, phrase=b"Finished clean up.") diff --git a/docs/notebooks/BMI_demo.ipynb b/docs/notebooks/BMI_demo.ipynb index e9c0fc68..393d93a4 100644 --- a/docs/notebooks/BMI_demo.ipynb +++ b/docs/notebooks/BMI_demo.ipynb @@ -5,8 +5,10 @@ "metadata": {}, "source": [ "# STEMMUS_SCOPE BMI demonstration\n", + "We have to choose how we want to run the BMI. We can do this either using a local executable file, or with a Docker container.\n", "\n", - "We first have to add the matlab runtime compiler locations to PATH:" + "How to run the model is define in the configuration file.\n", + "If it has an entry \"ExeFilePath\" it will use the local executable. If this is missing, it wil try to use Docker (if docker-py is available). " ] }, { @@ -15,21 +17,15 @@ "metadata": {}, "outputs": [], "source": [ - "import os\n", - "os.environ['LD_LIBRARY_PATH'] = (\n", - " \"/home/bart/matlab_runtime/R2023a/runtime/glnxa64:\"\n", - " \"/home/bart/matlab_runtime/R2023a/bin/glnxa64:\"\n", - " \"/home/bart/matlab_runtime/R2023a/sys/os/glnxa64:\"\n", - " \"/home/bart/matlab_runtime/R2023a/extern/bin/glnxa64:\"\n", - " \"/home/bart/matlab_runtime/R2023a/sys/opengl/lib/glnxa64\"\n", - ")" + "#cfg_file = \"/home/bart/tmp/stemmus_scope/config_docker.txt\"\n", + "cfg_file = \"/home/bart/tmp/stemmus_scope/config_exe.txt\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we can initialize the model with a prepared configuration file:" + "If we are using the local executable file we first have to add the matlab runtime compiler locations to PATH:" ] }, { @@ -37,6 +33,30 @@ "execution_count": 2, "metadata": {}, "outputs": [], + "source": [ + "if \"exe.txt\" in cfg_file:\n", + " import os\n", + " os.environ['LD_LIBRARY_PATH'] = (\n", + " \"/home/bart/matlab_runtime/R2023a/runtime/glnxa64:\"\n", + " \"/home/bart/matlab_runtime/R2023a/bin/glnxa64:\"\n", + " \"/home/bart/matlab_runtime/R2023a/sys/os/glnxa64:\"\n", + " \"/home/bart/matlab_runtime/R2023a/extern/bin/glnxa64:\"\n", + " \"/home/bart/matlab_runtime/R2023a/sys/opengl/lib/glnxa64\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can initialize the model with a prepared configuration file:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "from PyStemmusScope.bmi import StemmusScopeBmi\n", "from cftime import num2pydate\n", @@ -46,7 +66,7 @@ "\n", "model = StemmusScopeBmi()\n", "\n", - "model.initialize(\"/home/bart/tmp/stemmus_scope/input/ZA-Kru_2023-11-16-0728/ZA-Kru_2023-11-16-0728_config.txt\")" + "model.initialize(cfg_file)" ] }, { @@ -58,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -102,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -137,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -146,7 +166,7 @@ "array([22.74423625])" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -167,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -201,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -234,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -251,22 +271,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -288,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [