Merge pull request #1398 from haddocking/1390-when-using-modegrid-make-sure-the-cns-binary-is-the-linux-one

force download of cns linux binary if `arch!="x86_64-linux"`

Author: rvhonorato

integration_tests/__init__.py

@@ -1,9 +1,11 @@
 import os
+import platform
 from pathlib import Path
 
-from haddock.libs.libgrid import ping_dirac
 import pytest
 
+from haddock.libs.libgrid import ping_dirac
+
 if "CNS_EXEC" in os.environ:
     CNS_EXEC = os.environ["CNS_EXEC"]
 else:
@@ -29,3 +31,11 @@
 
 has_mpi = pytest.mark.skipif(not MPI_ENABLED, reason="MPI is not enabled")
 has_grid = pytest.mark.skipif(not ping_dirac(), reason="Dirac not reachable")
+is_linux_x86_64 = pytest.mark.skipif(
+    platform.system().lower() != "linux" or platform.machine().lower() != "x86_64",
+    reason="Only runs on x86_64 Linux systems",
+)
+is_not_linux_x86_64 = pytest.mark.skipif(
+    platform.system().lower() == "linux" and platform.machine().lower() == "x86_64",
+    reason="Only runs on non-x86_64-linux systems",
+)

integration_tests/test_libutil.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+import pytest
+
+from haddock.libs.libutil import get_cns_executable
+
+from . import is_linux_x86_64, is_not_linux_x86_64
+
+
+def test_finds_default_cns_executable():
+    """Test that the function finds CNS in the default location."""
+    cns_exec, cns_exec_linux = get_cns_executable()
+
+    assert cns_exec.exists(), f"CNS executable not found at {cns_exec}"
+    assert isinstance(cns_exec, Path)
+    assert isinstance(cns_exec_linux, Path)
+
+
+def test_cns_executable_is_file():
+    """Test that the CNS executable is actually a file."""
+    cns_exec, _ = get_cns_executable()
+
+    assert cns_exec.is_file(), f"{cns_exec} is not a file"
+
+
+@is_linux_x86_64
+def test_linux_x86_64_returns_same_executable():
+    """On x86_64 Linux, both executables should be the same."""
+    cns_exec, cns_exec_linux = get_cns_executable()
+
+    assert cns_exec == cns_exec_linux
+
+
+@is_not_linux_x86_64
+def test_non_linux_looks_for_linux_variant():
+    """On non-Linux systems, should look for _linux variant."""
+    cns_exec, cns_exec_linux = get_cns_executable()
+
+    assert cns_exec != cns_exec_linux
+    assert cns_exec_linux.name == f"{cns_exec.name}_linux"
+
+
+def test_returns_tuple_of_paths():
+    """Test that function returns a tuple of two Path objects."""
+    result = get_cns_executable()
+
+    assert isinstance(result, tuple)
+    assert len(result) == 2
+    assert all(isinstance(p, Path) for p in result)

setup.py

@@ -131,6 +131,16 @@ def download_binaries(self):
                 print(msg)
                 sys.exit(1)
 
+            if arch != "x86_64-linux" and filename.name == "cns":
+                # Force the download of the linux binary, this is needed for GRID executions
+                download_path = Path(target_bin_dir, "cns_linux")
+                status, msg = self.download_file(
+                    binary_dict["x86_64-linux"], download_path
+                )
+                if not status:
+                    print(msg)
+                    sys.exit(1)
+
             if "".join(filename.suffixes) == ".tar.gz":
                 try:
                     with tarfile.open(download_path, "r:gz") as tar:

src/haddock/core/defaults.py

@@ -1,28 +1,15 @@
 """All default parameters used by the framework."""
 
-import os
 import string
-import sys
 from importlib.resources import files
 from pathlib import Path
 
 import yaml
 
-import haddock
-from haddock import core_path, log
-
-
-cns_exec = Path(files(haddock).joinpath("bin/cns"))  # type: ignore
-if not cns_exec.exists():
-    log.warning("CNS executable not found at %s", cns_exec)
-    _cns_exec = os.environ.get("CNS_EXEC")
-    if _cns_exec is None:
-        log.error(
-            "Please define the location the CNS binary by setting a CNS_EXEC system variable"
-        )
-        sys.exit(1)
-    else:
-        cns_exec = Path(_cns_exec)
+from haddock import core_path
+from haddock.libs.libutil import get_cns_executable
+
+cns_exec, cns_exec_linux = get_cns_executable()
 
 CONTACT_FCC_EXEC = Path(files("haddock").joinpath("bin/contact_fcc"))  # type: ignore
 FAST_RMSDMATRIX_EXEC = Path(files("haddock").joinpath("bin/fast-rmsdmatrix"))  # type: ignore

src/haddock/libs/libgrid.py

@@ -17,7 +17,7 @@
 from typing import Optional, Tuple, Union
 
 from haddock import log
-from haddock.core.defaults import cns_exec as CNS_EXEC
+from haddock.core.defaults import cns_exec_linux as CNS_EXEC
 from haddock.libs.libsubprocess import CNSJob
 from haddock.libs.libutil import parse_ncores
 

src/haddock/libs/libutil.py

@@ -1,15 +1,19 @@
 """General utilities."""
+
 import collections.abc
 import contextlib
 import os
+import platform
 import re
 import shutil
 import subprocess
 import sys
 from copy import deepcopy
 from functools import partial
+from importlib.resources import files
 from pathlib import Path
 
+import haddock
 from haddock import EmptyPath, log
 from haddock.core.exceptions import SetupError
 from haddock.core.typing import (
@@ -30,7 +34,6 @@
 )
 from haddock.gear.greetings import get_goodbye_help
 
-
 check_subprocess = partial(
     subprocess.run,
     shell=True,
@@ -62,7 +65,7 @@ def make_list_if_string(item: Union[str, list[str]]) -> list[str]:
 
 
 def transform_to_list(
-    item: Union[Iterable[AnyT], AnyT]
+    item: Union[Iterable[AnyT], AnyT],
 ) -> Union[list[AnyT], tuple[AnyT, ...]]:
     """
     Put `item` into a list if not a list already.
@@ -130,7 +133,7 @@ def remove_dict_keys(d: ParamMap, keys: Container[str]) -> ParamDict:
 
 def cpu_count() -> int:
     """Count number of available CPU for the process.
-    
+
     User suggestion, by https://github.com/EricDeveaud
 
     Note: pid 0 == current process
@@ -142,9 +145,10 @@ def cpu_count() -> int:
     process_ncores : int
         Number of cores allocated to the process pid.
     """
+
     def _cpu_count() -> int:
         """Detect number of cores available.
-        
+
         Returns
         -------
         ncores : int
@@ -159,7 +163,7 @@ def _cpu_count() -> int:
                 ncores = int(_process_ncores)
         except AttributeError:
             # If unsucessful, return the number cores detected in the machine
-            # Note: this can happen on MacOS, where the os.sched_getaffinity 
+            # Note: this can happen on MacOS, where the os.sched_getaffinity
             # may not be defined/exist.
             ncores = int(os.cpu_count())
         return ncores
@@ -422,3 +426,56 @@ def recursive_convert_paths_to_strings(params: ParamMapT) -> ParamMapT:
             params[param] = value
 
     return params
+
+
+def get_cns_executable() -> tuple[Path, Path]:
+    """
+    Locate CNS executable and its Linux variant for grid execution.
+
+    Returns:
+        Tuple of (cns_exec, cns_exec_linux) paths
+
+    Raises:
+        SystemExit: If CNS executable cannot be found
+    """
+    # Try default location first
+    cns_exec = Path(files(haddock).joinpath("bin/cns"))  # type: ignore
+
+    if not cns_exec.exists():
+        log.error("CNS executable not found at %s", cns_exec)
+
+        # Fall back to environment variable
+        cns_exec_env = os.environ.get("CNS_EXEC")
+        if cns_exec_env is None:
+            log.error(
+                "Please define the CNS binary location by setting the CNS_EXEC "
+                "environment variable"
+            )
+            sys.exit(1)
+
+        cns_exec = Path(cns_exec_env)
+        if not cns_exec.exists():
+            log.error("CNS executable not found at %s", cns_exec)
+            sys.exit(1)
+
+    # Determine Linux-specific executable for grid usage
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    current_arch = f"{machine}-{system}"
+
+    if current_arch == "x86_64-linux":
+        cns_exec_linux = cns_exec
+    else:
+        # Look for Linux binary variant
+        cns_exec_linux = cns_exec.with_name(f"{cns_exec.name}_linux")
+
+        if not cns_exec_linux.exists():
+            log.warning(
+                "Current architecture is %s, but grid execution requires "
+                "an x86_64-linux binary",
+                current_arch,
+            )
+            log.warning("Linux CNS binary not found at %s", cns_exec_linux)
+            log.warning("GRID mode will not be available")
+
+    return cns_exec, cns_exec_linux