Merge pull request #178 from boschresearch/174-odb-version-mismatch

Check for version mismatch between odbclient and odbserver

Author: johannes-mueller

tools/odbclient/README.md

@@ -77,5 +77,23 @@ So far only names made of `ascii` strings are supported.  That means that
 instance names, node that names and the like containing non-ascii characters
 like German umlauts will not work.
 
+
+## Development
+
+Due to the server client architechture running the unit tests is not completely
+trivial. Here are some instructions on how to get them running.
+
+### Setting up the environments
+
+As of now, we are assuming that conda is used to setup the server
+environments. Probably we will change for `uv` in the future.
+
+We provide a bash script in `tests/create_server_envs.sh` that you can run from
+within the root folder of `odbclient` (the folder this `README.md` resides
+in). Then it should generate all the necessary environments. You will have to
+run the script again, if there has been a release update in between.
+
+The script is not well tested. So please be prepared for some manual steps.
+
 ___
 [1]: https://pylife.readthedocs.io/en/latest/tools/odbclient/odbclient.html

tools/odbclient/src/odbclient/__init__.py

@@ -23,7 +23,7 @@
 
 try:
     # Change here if project is renamed and does not equal the package name
-    dist_name = __name__
+    dist_name = "pylife-odbclient"
     __version__ = version(dist_name)
 except PackageNotFoundError:  # pragma: no cover
     __version__ = "unknown"

tools/odbclient/src/odbclient/odbclient.py

@@ -31,6 +31,8 @@
 import numpy as np
 import pandas as pd
 
+import odbclient
+
 
 class OdbServerError(Exception):
     """Raised when the ODB Server launch fails."""
@@ -148,7 +150,13 @@ def __init__(self, odb_file, abaqus_bin=None, python_env_path=None):
         if lock_file_exists:
             self._gulp_lock_file_warning()
 
-        self._wait_for_server_ready_sign()
+        server_version, server_python_version = self._wait_for_server_ready_sign()
+        _raise_if_version_mismatch(server_version)
+        if server_python_version == "2":
+            self._parse_response = self._parse_response_py2
+        else:
+            self._parse_response = self._parse_response_py3
+
 
     def _gulp_lock_file_warning(self):
         self._proc.stdout.readline()
@@ -158,6 +166,8 @@ def _wait_for_server_ready_sign(self):
         def wait_for_input(stdout, queue):
             sign = stdout.read(5)
             queue.put(sign)
+            version_sign = stdout.readline()
+            queue.put(version_sign)
 
         queue = QU.Queue()
         thread = THR.Thread(target=wait_for_input, args=(self._proc.stdout, queue))
@@ -173,6 +183,12 @@ def wait_for_input(stdout, queue):
             else:
                 if sign != b'ready':
                     raise OdbServerError("Expected ready sign from server, received %s" % sign)
+
+                try:
+                    sign = queue.get_nowait()
+                    return _ascii(_decode, sign).strip().split()
+                except QU.Empty:
+                    return "unannounced", "2"
                 return
 
     def instance_names(self):
@@ -203,8 +219,11 @@ def node_coordinates(self, instance_name, nset_name=''):
         """
         self._fail_if_instance_invalid(instance_name)
         index, node_data = self._query('get_nodes', (instance_name, nset_name))
-        return pd.DataFrame(data=node_data, columns=['x', 'y', 'z'],
-                            index=pd.Index(index, name='node_id', dtype=np.int64))
+        return pd.DataFrame(
+            data=node_data,
+            columns=['x', 'y', 'z'],
+            index=pd.Index(index, name='node_id', dtype=np.int64),
+        )
 
     def element_connectivity(self, instance_name, elset_name=''):
         """Query the element connectivity of an instance.
@@ -447,6 +466,7 @@ def history_region_description(self, step_name, history_region_name):
          """Query the description of a history Regions of a given step.
 
          Parameters
+
          ----------
          step_name : string
              The name of the step
@@ -491,11 +511,21 @@ def _send_command(self, command, args=None):
         pickle.dump((command, args), self._proc.stdin, protocol=2)
         self._proc.stdin.flush()
 
-    def _parse_response(self):
-        expected_size,  = struct.unpack("Q", self._proc.stdout.read(8))
-        pickle_data = self._proc.stdout.read(expected_size)
+    def _parse_response_py2(self):
+        pickle_data = b''
+        while True:
+            line = self._proc.stdout.readline().rstrip() + b'\n'
+            pickle_data += line
+            if line == b'.\n':
+                break
         return pickle.loads(pickle_data, encoding='bytes')
 
+    def _parse_response_py3(self):
+        msg = self._proc.stdout.read(8)
+        expected_size,  = struct.unpack("Q", msg)
+        pickle_data = self._proc.stdout.read(expected_size)
+        return pickle.loads(pickle_data)
+
     def __del__(self):
         if self._proc is not None:
             self._send_command('QUIT')
@@ -536,6 +566,7 @@ def _decode(arg):
         return [_decode(element) for element in arg]
     return arg
 
+
 def _guess_abaqus_bin():
     if sys.platform == 'win32':
         return _guess_abaqus_bin_windows()
@@ -582,9 +613,25 @@ def _determine_server_python_version(abaqus_bin):
     return version_string[:version_string.rfind(".")]
 
 
-
 def _guess_python_env_path(python_env_path):
     cand = python_env_path or os.path.join(os.environ['HOME'], '.conda', 'envs', 'odbserver')
     if os.path.exists(cand):
         return cand
     return None
+
+
+def _raise_if_version_mismatch(server_version):
+    def strip_version(version):
+        pos = version.find(".post")
+        if pos == -1:
+            return version
+        return version[:pos]
+
+    server_version = strip_version(server_version)
+    client_version = strip_version(odbclient.__version__)
+
+    if client_version != server_version:
+        raise RuntimeError(
+            "Version mismatch: "
+            f"odbserver version {server_version} != odbclient version {client_version}"
+        )

tools/odbclient/tests/create_server_envs.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+
+if [ "$(uname)" == "Linux" ]; then
+    CONDABASE=`conda info --base`
+    CONDA_SH=${CONDABASE}"/etc/profile.d/conda.sh"
+    source $CONDA_SH
+else
+    eval "$('/c/Program Files/Anaconda3/Scripts/conda.exe' 'shell.bash' 'hook')"
+fi
+
+conda create -n odbserver-2022 python=2.7 --yes
+conda activate odbserver-2022
+pip install -e ../odbserver
+
+conda create -n odbserver-2023 python=2.7 --yes
+conda activate odbserver-2023
+pip install -e ../odbserver
+
+conda create -n odbserver-2024 python=3.10 --yes
+conda activate odbserver-2024
+pip install -e ../odbserver
+
+conda create -n odbserver-2022-version-mismatch python=2.7 --yes
+conda activate odbserver-2022-version-mismatch
+pip install pylife-odbserver
+
+conda create -n odbserver-2023-version-mismatch python=2.7 --yes
+conda activate odbserver-2023-version-mismatch
+pip install pylife-odbserver
+
+conda create -n odbserver-2024-version-mismatch python=3.10 --yes
+conda activate odbserver-2024-version-mismatch
+pip install pylife-odbserver==2.2.0a6

tools/odbclient/tests/test_odbclient.py

@@ -25,7 +25,11 @@
 import pytest
 import json
 import shutil
+
+import subprocess
+
 from pathlib import Path
+import pylife
 
 import numpy as np
 import pandas as pd
@@ -34,6 +38,7 @@
 
 from odbclient.odbclient import OdbServerError
 
+
 @pytest.fixture
 def datapath():
     base = os.path.dirname(__file__)
@@ -44,11 +49,16 @@ def join_path(filename):
     return join_path
 
 
-@pytest.fixture(params=["2022", "2023", "2024"])
+@pytest.fixture(params=["2022", "2023", "2024"], scope="session")
 def abaqus_version(request):
     return request.param
 
 
+@pytest.fixture(scope="session")
+def pyenvs(abaqus_version):
+    return os.path.join(Path.home(), ".conda", "envs", f"odbserver-{abaqus_version}")
+
+
 @pytest.fixture
 def abaqus_bin(abaqus_version):
     if sys.platform == 'win32':
@@ -57,12 +67,16 @@ def abaqus_bin(abaqus_version):
 
 
 @pytest.fixture
-def client(datapath, abaqus_version, abaqus_bin):
-    python_path = os.path.join(Path.home(), ".conda", "envs", f"odbserver-{abaqus_version}")
+def client(datapath, pyenvs, abaqus_version, abaqus_bin):
+    python_path = pyenvs
     odb_file = datapath(f"beam_3d_hex_quad-{abaqus_version}.odb")
     return odbclient.OdbClient(odb_file, abaqus_bin=abaqus_bin, python_env_path=python_path)
 
 
+def test_odbclient_version():
+    assert odbclient.__version__ == pylife.__version__
+
+
 def test_not_existing_odbserver_env():
     with pytest.raises(OSError, match="No odbserver environment found."):
         odbclient.OdbClient('foo.odb', python_env_path='/foo/bar/env')
@@ -73,6 +87,15 @@ def test_not_existing_abaqus_path():
         odbclient.OdbClient('foo.odb', abaqus_bin='/foo/bar/abaqus')
 
 
+
+def test_version_mismatch(datapath, abaqus_version, abaqus_bin):
+    python_path = os.path.join(Path.home(), ".conda", "envs", f"odbserver-{abaqus_version}-version-mismatch")
+    odb_file = datapath(f"beam_3d_hex_quad-{abaqus_version}.odb")
+    with pytest.raises(RuntimeError, match="Version mismatch"):
+        odbclient.OdbClient(odb_file, abaqus_bin=abaqus_bin, python_env_path=python_path)
+
+
+
 def test_odbclient_instances(client):
     np.testing.assert_array_equal(client.instance_names(), ['PART-1-1'])
 
@@ -84,7 +107,10 @@ def test_odbclient_invalid_instance(client):
 
 def test_odbclient_node_coordinates(client, datapath):
     expected = pd.read_csv(datapath('node_coordinates.csv'), index_col='node_id')
-    pd.testing.assert_frame_equal(client.node_coordinates('PART-1-1'), expected)
+    result = client.node_coordinates('PART-1-1')
+    print("comparing")
+    pd.testing.assert_frame_equal(result, expected)
+    print("test finished")
 
 
 def test_odbclient_node_ids(client):

tools/odbserver/odbserver/__init__.py

@@ -1,6 +1,6 @@
 import pkg_resources
 
 try:
-    __version__ = pkg_resources.get_distribution(__name__).version
+    __version__ = pkg_resources.get_distribution("pylife-odbserver").version
 except:
     __version__ = 'unknown'

tools/odbserver/odbserver/__main__.py

@@ -27,6 +27,7 @@
 import numpy as np
 
 from .interface import OdbInterface
+import odbserver
 
 class OdbServer:
 
@@ -124,12 +125,24 @@ def history_info(self, args):
         _send_response(self._odb.history_info())
 
 
-def _send_response(pickle_data, numpy_arrays=None):
-    stdout = sys.stdout if sys.version_info.major == 2 else sys.stdout.buffer
+def _send_response_py2(pickle_data, numpy_arrays=None):
+    numpy_arrays = numpy_arrays or []
+    s = pickle.dumps((len(numpy_arrays), pickle_data))
+    sys.stdout.write(s + '\n')
+    sys.stdout.flush()
+    for nparr in numpy_arrays:
+        np.lib.format.write_array(sys.stdout, nparr)
+
+
+def _send_response_py3(pickle_data, numpy_arrays=None):
+    stdout = os.fdopen(sys.stdout.fileno(), 'wb', closefd=False)
     numpy_arrays = numpy_arrays or []
 
-    message = pickle.dumps((len(numpy_arrays), pickle_data), protocol=2)
-    data_size_8_bytes = struct.pack("Q", len(message))
+    message = pickle.dumps((len(numpy_arrays), pickle_data))
+
+    data_size = len(message)
+
+    data_size_8_bytes = struct.pack("Q", data_size)
 
     stdout.write(data_size_8_bytes)
     stdout.write(message)
@@ -138,6 +151,13 @@ def _send_response(pickle_data, numpy_arrays=None):
         np.lib.format.write_array(sys.stdout, nparr)
 
 
+if sys.version_info.major == 2:
+    _send_response = _send_response_py2
+else:
+    _send_response = _send_response_py3
+
+
+
 def main():
 
     def decode_strings_if_not_on_python_2(parameters):
@@ -164,7 +184,8 @@ def pickle_load_3():
         print(str(e), file=sys.stderr)
         sys.exit(1)
 
-    sys.stdout.write('ready')
+    ready_message = "ready %s %s\n" % (odbserver.__version__, sys.version_info.major)
+    sys.stdout.write(ready_message)
     sys.stdout.flush()
 
     command = ''
@@ -176,10 +197,9 @@ def pickle_load_3():
         if command == 'QUIT':
             break
 
-        func = server.command_dict.get(command)
-        if func is not None:
-            func(parameters)
-            sys.stdout.flush()
+        func = server.command_dict.get(command, )
+        func(parameters)
+        sys.stdout.flush()
 
 
 if __name__ == "__main__":

tools/odbserver/setup.py

@@ -19,6 +19,7 @@ def setup_package():
     scm_version_setup = {
         "root": "../..",
         "relative_to": __file__,
+        "version_scheme": "no-guess-dev",
     }
     if os.environ.get("CI") == "true":
         scm_version_setup.update({"local_scheme": "no-local-version"})