fm-weck 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

fm_weck/__init__.py

@@ -8,4 +8,4 @@
 from .config import Config  # noqa: F401
 from .image_mgr import ImageMgr  # noqa: F401
 
-__version__ = "1.2.1"
+__version__ = "1.4.0"

fm_weck/cli.py

@@ -14,15 +14,29 @@ from functools import cache
 from pathlib import Path
 from typing import Any, Callable, Optional, Tuple, Union
 
-from fm_tools.benchexec_helper import DataModel
+try:
+    from fm_tools.benchexec_helper import DataModel
+except ImportError:
+    from enum import Enum
+
+    class DataModel(Enum):
+        """
+        Enum representing the data model of the tool.
+        """
+
+        LP64 = "LP64"
+        ILP32 = "ILP32"
+
+        def __str__(self):
+            return self.value
+
 
 from fm_weck import Config
 from fm_weck.config import _SEARCH_ORDER
 from fm_weck.resources import iter_fm_data, iter_properties
 
 from . import __version__
-from .engine import Engine, NoImageError
-from .serve import run_guided, run_manual, setup_fm_tool
+from .exceptions import NoImageError
 
 logger = logging.getLogger(__name__)
 
@@ -84,12 +98,22 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         default=None,
     )
 
+    loglevels_lower = ["debug", "info", "warning", "error", "critical"]
+    loglevels = loglevels_lower + [level.upper() for level in loglevels_lower]
     parser.add_argument(
         "--loglevel",
-        choices=["debug", "info", "warning", "error", "critical"],
+        choices=loglevels,
+        metavar="LEVEL",
+        action="store",
+        default=None,
+        help="Set the log level. Valid values are: " + ", ".join(loglevels_lower),
+    )
+
+    parser.add_argument(
+        "--logfile",
         action="store",
+        help="Path to the log file.",
         default=None,
-        help="Set the log level.",
     )
 
     parser.add_argument(
@@ -100,6 +124,14 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         default=False,
     )
 
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Just print the command that would be executed.",
+        required=False,
+        default=False,
+    )
+
     subparsers = parser.add_subparsers()
 
     run = subparsers.add_parser("run", aliases=["r"], help="Run a verifier inside a container.")
@@ -173,6 +205,42 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     add_tool_arg(install, nargs="+")
     install.set_defaults(main=main_install)
 
+    runexec = subparsers.add_parser("runexec", help="Run runexec on a command inside a container.")
+    runexec.add_argument(
+        "--image",
+        dest="use_image",
+        action="store",
+        default=None,
+        type=str,
+        help=(
+            "The image that shall be used for the container."
+            " The image is treated as 'full_container_image', i.e., fm-weck will not attempt to install any packages"
+            " inside of the image"
+        ),
+    )
+
+    runexec.add_argument(
+        "--benchexec-path",
+        action="store",
+        dest="benchexec_package",
+        type=Path,
+        help=("The path to the benchexec .whl or .egg file. If not given, fm-weck will use its own benchexec package."),
+        default=None,
+    )
+
+    # Arguments passed though to the container manager (i.e., docker or podman)
+    runexec.add_argument(
+        "--container-long-opt",
+        dest="container_long_opts",
+        help="Arguments passed as long options (prepending --) directly to the container manager "
+        "(e.g., docker or podman). Each usage passes additional arguments to the container manager.",
+        action="append",
+        nargs="+",
+    )
+
+    runexec.add_argument("argument_list", metavar="args", nargs="*", help="Arguments for runexec.")
+    runexec.set_defaults(main=main_runexec)
+
     def help_callback():
         parser.print_help()
 
@@ -230,14 +298,19 @@ def resolve_property(prop_name: str) -> Path:
     return property_choice_map()[prop_name]
 
 
-def set_log_level(loglevel: Optional[str], config: dict[str, Any]):
+def set_log_options(loglevel: Optional[str], logfile: Optional[str], config: dict[str, Any]):
     level = "WARNING"
     level = loglevel.upper() if loglevel else config.get("logging", {}).get("level", level)
-    logging.basicConfig(level=level)
+    if logfile:
+        logging.basicConfig(level=level, filename=logfile)
+    else:
+        logging.basicConfig(level=level)
     logging.getLogger("httpcore").setLevel("WARNING")
 
 
 def main_run(args: argparse.Namespace):
+    from .serve import run_guided
+
     if not args.TOOL:
         logger.error("No fm-tool given. Aborting...")
         return 1
@@ -265,7 +338,21 @@ def main_run(args: argparse.Namespace):
     )
 
 
+def main_runexec(args: argparse.Namespace):
+    from .runexec_mode import run_runexec
+
+    run_runexec(
+        benchexec_package=args.benchexec_package,
+        use_image=args.use_image,
+        configuration=Config(),
+        extra_container_args=args.container_long_opts or [],
+        command=args.argument_list,
+    )
+
+
 def main_manual(args: argparse.Namespace):
+    from .serve import run_manual
+
     if not args.TOOL:
         logger.error("No fm-tool given. Aborting...")
         return 1
@@ -285,6 +372,8 @@ def main_manual(args: argparse.Namespace):
 
 
 def main_install(args: argparse.Namespace):
+    from .serve import setup_fm_tool
+
     for tool in args.TOOL:
         try:
             fm_data = resolve_tool(tool)
@@ -300,6 +389,8 @@ def main_install(args: argparse.Namespace):
 
 
 def main_shell(args: argparse.Namespace):
+    from .engine import Engine
+
     if not args.TOOL:
         engine = Engine.from_config(Config())
     else:
@@ -335,7 +426,7 @@ Please specify an image in the fm-tool yml file or add a configuration.
 
 To add a configuration you can do the following (on POSIX Terminals):
 
-printf '[defaults]\\nimage = "<your_image>"' > .weck
+printf '[defaults]\\nimage = "<your_image>"' > .fm-weck
 
 Replace <your_image> with the image you want to use.
         """
@@ -350,7 +441,7 @@ To specify an image add
 [defaults]
 image = "your_image"
 
-to your .weck file.
+to your .fm-weck file.
     """
 
     logger.error(text, tool, config)
@@ -359,7 +450,9 @@ to your .weck file.
 def cli(raw_args: list[str]):
     help_callback, args = parse(raw_args)
     configuration = Config().load(args.config)
-    set_log_level(args.loglevel, configuration)
+    set_log_options(args.loglevel, args.logfile, configuration)
+    if args.dry_run:
+        Config().set_dry_run(True)
 
     if args.list:
         print("List of fm-tools callable by name:")
@@ -370,7 +463,7 @@ def cli(raw_args: list[str]):
             print(f"  - {prop}")
         return
 
-    if not hasattr(args, "TOOL"):
+    if not hasattr(args, "main"):
         return help_callback()
 
     try:

fm_weck/config.py

@@ -5,16 +5,32 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import importlib.resources as pkg_resources
+import logging
 import os
 import shutil
+import stat
+import sys
 from functools import cache
 from pathlib import Path
 from typing import Any, Callable, Iterable, Optional, Tuple, TypeVar
 
-import yaml
-from fm_tools.fmdata import FmData
+try:
+    from fm_tools.fmdata import FmData
+except ImportError:
+
+    class FmData:
+        def __init__(self, data, version):
+            raise ImportError("fm_tools is not imported.")
+
+        def get_actor_name(self):
+            raise ImportError("fm_tools is not imported.")
 
-from fm_weck.resources import RUN_WITH_OVERLAY
+        def get_version(self):
+            raise ImportError("fm_tools is not imported.")
+
+
+from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
 
 try:
     import tomllib as toml
@@ -22,10 +38,10 @@ except ImportError:
     import tomli as toml
 
 _SEARCH_ORDER: tuple[Path, ...] = (
-    Path.cwd() / ".weck",
-    Path.home() / ".weck",
-    Path.home() / ".config" / "weck",
-    Path.home() / ".config" / "weck" / "config.toml",
+    Path.cwd() / ".fm-weck",
+    Path.home() / ".fm-weck",
+    Path.home() / ".config" / "fm-weck",
+    Path.home() / ".config" / "fm-weck" / "config.toml",
 )
 BASE_CONFIG = """
 [logging]
@@ -51,6 +67,7 @@ class Config(object):
         if cls._instance is None:
             cls._instance = super(Config, cls).__new__(cls)
             cls._instance._config = None
+            cls._instance._dry_run = False
         return cls._instance
 
     def load(self, config: Optional[Path] = None) -> dict[str, Any]:
@@ -88,6 +105,15 @@ class Config(object):
 
         return default
 
+    def set_dry_run(self, dry_run: bool) -> None:
+        self._dry_run = dry_run
+
+    def is_dry_run(self) -> bool:
+        return self._dry_run
+
+    def set_default_image(self, image: str) -> None:
+        self._config["defaults"]["image"] = image
+
     def defaults(self) -> dict[str, Any]:
         return self.get("defaults", {})
 
@@ -114,11 +140,11 @@ class Config(object):
     @property
     @_handle_relative_paths
     def cache_location(self) -> Path:
-        cache = Path.home() / ".cache" / "weck_cache"
+        cache = Path.home() / ".cache" / "fm-weck_cache"
         xdg_cache_home = os.environ.get("XDG_CACHE_HOME")
 
         if xdg_cache_home:
-            cache = Path(xdg_cache_home) / "weck_cache"
+            cache = Path(xdg_cache_home) / "fm-weck_cache"
 
         return Path(self.defaults().get("cache_location", cache.resolve()))
 
@@ -144,19 +170,63 @@ class Config(object):
         property_name = path.name
         return shelve / property_name
 
-    def make_script_available(self) -> Path:
-        script_dir = self.cache_location / ".scripts"
-        run_script = script_dir / "run_with_overlay.sh"
-        if run_script.exists() and run_script.is_file():
-            return run_script
+    def get_shelve_path_for_benchexec(self) -> Path:
+        shelve = self.cache_location / ".lib" / "benchexec.whl"
+        shelve.parent.mkdir(parents=True, exist_ok=True)
+        return shelve
 
-        script_dir.mkdir(parents=True, exist_ok=True)
-        shutil.copy(RUN_WITH_OVERLAY, run_script)
-        return run_script
+    @staticmethod
+    def _system_is_not_posix():
+        return not (sys.platform.startswith("linux") or sys.platform == "darwin")
+
+    def make_runexec_script_available(self) -> Path:
+        return self.make_script_available(RUNEXEC_SCRIPT)
+
+    def make_script_available(self, target_name: str = RUN_WITH_OVERLAY) -> Path:
+        script_dir = self.cache_location / ".scripts"
+        target = script_dir / target_name
+
+        if not (target.exists() and target.is_file()):
+            script_dir.mkdir(parents=True, exist_ok=True)
+
+            # Try to copy from package resources
+            try:
+                with pkg_resources.path("fm_weck.resources", target_name) as source_path:
+                    shutil.copy(source_path, target)
+            except FileNotFoundError:
+                logging.error(f"Resource {target_name} not found in package.")
+                return None
+        else:
+            # Compare modification time if the file exists
+            with pkg_resources.path("fm_weck.resources", target_name) as source_path:
+                if source_path.stat().st_mtime > target.stat().st_mtime:
+                    shutil.copy(source_path, target)
+                else:
+                    logging.debug(f"Using existing {target_name} script")
+                    return target
+
+        if Config._system_is_not_posix():
+            return target
+
+        try:
+            # Get the current file permissions
+            current_permissions = os.stat(target).st_mode
+
+            # Add the executable bit for the owner, group, and others
+            os.chmod(target, current_permissions | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        except OSError as e:
+            logging.error(
+                f"Failed to set executable bit: {e}. "
+                "This may lead to permission errors when running the script in the container."
+            )
+
+        return target
 
 
 @cache
 def parse_fm_data(fm_data: Path, version: Optional[str]) -> FmData:
+    import yaml
+
     if not fm_data.exists() or not fm_data.is_file():
         raise FileNotFoundError(f"fm data file {fm_data} does not exist")
 

fm_weck/engine.py

@@ -7,6 +7,7 @@
 
 import logging
 import shutil
+import signal
 import subprocess
 from abc import ABC, abstractmethod
 from functools import cached_property, singledispatchmethod
@@ -14,38 +15,55 @@ from pathlib import Path
 from tempfile import mkdtemp
 from typing import List, Optional, Union
 
-from fm_tools.fmdata import FmData, FmImageConfig
+try:
+    from fm_tools.fmdata import FmData, FmImageConfig
+except ImportError:
+    # Mock the FmData and FmImageConfig class for type checking
+    class FmData:
+        def get_images(self):
+            pass
+
+    class FmImageConfig:
+        pass
+
 
 from fm_weck.config import Config, parse_fm_data
+from fm_weck.exceptions import NoImageError
 from fm_weck.image_mgr import ImageMgr
 
 logger = logging.getLogger(__name__)
 
 
-class NoImageError(Exception):
-    pass
+CWD_MOUNT_LOCATION = "/home/cwd"
+CACHE_MOUNT_LOCATION = "/home/fm-weck_cache"
+OUTPUT_MOUNT_LOCATION = "/home/output"
+
+RESERVED_LOCATIONS = frozenset([CACHE_MOUNT_LOCATION, CWD_MOUNT_LOCATION, OUTPUT_MOUNT_LOCATION])
 
 
 class Engine(ABC):
     interactive: bool = False
     add_benchexec_capabilities: bool = False
     image: Optional[str] = None
+    dry_run: bool = False
 
     def __init__(self, image: Union[str, FmImageConfig]):
+        self._tmp_output_dir = Path(mkdtemp("fm_weck_output")).resolve()
         self.image = self._initialize_image(image)
         self.extra_args = {}
         self._engine = None
-        self._tmp_output_dir = Path(mkdtemp("fm_weck_output")).resolve()
 
         self.output_dir = Path.cwd() / "output"
         self.log_file = None
 
+        self.env = {}
+
     def __del__(self):
         if self._tmp_output_dir.exists():
             shutil.rmtree(self._tmp_output_dir)
 
     def get_workdir(self):
-        return Path("/home/cwd")
+        return Path(CWD_MOUNT_LOCATION)
 
     def set_output_log(self, output_log: Path):
         self.log_file = output_log
@@ -59,6 +77,24 @@ class Engine(ABC):
             f"{source}:{target}",
         ]
 
+    def add_container_long_opt(self, arg: list[str]):
+        """
+        Add a long option to the container command.
+        If the first element of the list does not start with "--", it will be prepended.
+        Example:
+        add_container_long_opt(["--option", "value"]) -> --option value
+        add_container_long_opt(["option", "value"]) -> --option value
+        """
+
+        if not arg:
+            raise ValueError("Argument must not be empty.")
+
+        base = arg[0]
+        if not base.startswith("--"):
+            base = f"--{base}"
+
+        self.extra_args["container_args"] = self.extra_args.get("container_args", []) + [base] + arg[1:]
+
     @abstractmethod
     def benchexec_capabilities(self):
         raise NotImplementedError
@@ -69,6 +105,9 @@ class Engine(ABC):
     def interactive_command(self):
         return ["-it"]
 
+    def add_environment(self):
+        return sum([["-e", f"{key}={value}"] for key, value in self.env.items()], [])
+
     def setup_command(self):
         return [
             "--entrypoint",
@@ -76,11 +115,11 @@ class Engine(ABC):
             "--cap-add",
             "SYS_ADMIN",
             "-v",
-            f"{Path.cwd().absolute()}:/home/cwd",
+            f"{Path.cwd().absolute()}:{CWD_MOUNT_LOCATION}",
             "-v",
-            f"{Config().cache_location}:/home/weck_cache",
+            f"{Config().cache_location}:{CACHE_MOUNT_LOCATION}",
             "-v",
-            f"{self._tmp_output_dir}:/home/output",
+            f"{self._tmp_output_dir}:{OUTPUT_MOUNT_LOCATION}",
             "--workdir",
             str(self.get_workdir()),
             "--rm",
@@ -101,6 +140,7 @@ class Engine(ABC):
             base += self.benchexec_capabilities()
 
         base += self.setup_command()
+        base += self.add_environment()
 
         if self.interactive:
             base += self.interactive_command()
@@ -127,7 +167,7 @@ class Engine(ABC):
                     return self.get_workdir() / relative
                 elif p.is_relative_to(Config().cache_location):
                     relative = p.relative_to(Config().cache_location)
-                    return Path("/home/weck_cache") / relative
+                    return Path(CACHE_MOUNT_LOCATION) / relative
                 else:
                     return p
             mapped = _map_path(Path(p))
@@ -156,7 +196,7 @@ class Engine(ABC):
 
     @staticmethod
     def _base_engine_class(config: Config):
-        engine = config.defaults().get("engine", "").lower()
+        engine = config.defaults().get("engine", "podman").lower()
 
         if engine == "docker":
             return Docker
@@ -204,6 +244,9 @@ class Engine(ABC):
                 continue
             engine.mount(src, target)
 
+        if config.is_dry_run():
+            engine.dry_run = True
+
         return engine
 
     @abstractmethod
@@ -247,22 +290,39 @@ class Engine(ABC):
             return tag
 
     def _run_process(self, command: tuple[str, ...] | list[str]):
+        process = None  # To make sure process is defined if a signal is caught early
+
+        def terminate_process_group(signal_received, frame):
+            if process:
+                logging.info("Received signal %s. Terminating container process.", signal_received)
+                process.send_signal(signal.SIGTERM)
+
+        # Register signal handler
+        signal.signal(signal.SIGINT, terminate_process_group)
+        signal.signal(signal.SIGTERM, terminate_process_group)
+
+        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
         if self.log_file is None:
             process = subprocess.Popen(command)
-            process.wait()
-            return
+        else:
+            self.log_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.log_file.open("wb") as f:
+                process = subprocess.Popen(command, stdout=f, stderr=f)
 
-        self.log_file.parent.mkdir(parents=True, exist_ok=True)
-        with self.log_file.open("wb") as f:
-            process = subprocess.Popen(command, stdout=f, stderr=f)
-            process.wait()
+        assert process is not None, "Process should be defined at this point."
+        process.wait()
 
     def run(self, *command: str) -> None:
         if self.image is None:
             raise NoImageError("No image set for engine.")
 
         command = self.assemble_command(command)
-        logger.info("Running: %s", command)
+        logger.debug("Running: %s", command)
+        if self.dry_run:
+            print("Command to be executed:")
+            print(" ".join(map(str, command)))
+            return
+
         self._run_process(command)
         self._move_output()
 
@@ -284,12 +344,15 @@ class Podman(Engine):
         return [
             "--annotation",
             "run.oci.keep_original_groups=1",
+            #  "--cgroups=split",
+            "--security-opt",
+            "unmask=/sys/fs/cgroup",
             "--security-opt",
             "unmask=/proc/*",
             "--security-opt",
             "seccomp=unconfined",
             "-v",
-            "/sys/fs/cgroup:/sys/fs/cgroup",
+            "/sys/fs/cgroup:/sys/fs/cgroup:rw",
         ]
 
 
@@ -336,11 +399,11 @@ class Docker(Engine):
             "--cap-add",
             "SYS_ADMIN",
             "-v",
-            f"{Path.cwd().absolute()}:/home/cwd",
+            f"{Path.cwd().absolute()}:{CWD_MOUNT_LOCATION}",
             "-v",
-            f"{Config().cache_location}:/home/weck_cache",
+            f"{Config().cache_location}:{CACHE_MOUNT_LOCATION}",
             "-v",
-            f"{self._tmp_output_dir}:/home/output",
+            f"{self._tmp_output_dir}:{OUTPUT_MOUNT_LOCATION}",
             "--workdir",
             str(self.get_workdir()),
             "--rm",

fm_weck/exceptions.py

@@ -0,0 +1,9 @@
+# This file is part of fm-weck: executing fm-tools in containerized environments.
+# https://gitlab.com/sosy-lab/software/fm-weck
+#
+# SPDX-FileCopyrightText: 2024 Dirk Beyer <https://www.sosy-lab.org>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+class NoImageError(Exception):
+    pass

fm_weck/image_mgr.py

@@ -9,10 +9,16 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from fm_tools.fmdata import FmImageConfig
-from yaspin import yaspin
+try:
+    from fm_tools.fmdata import FmImageConfig
+except ImportError:
 
-from fm_weck import Config
+    class FmImageConfig:
+        def __init__(self, full_images, base_images, required_packages):
+            raise ImportError("fm_tools is not imported.")
+
+
+from fm_weck.exceptions import NoImageError
 
 if TYPE_CHECKING:
     from fm_weck.engine import Engine
@@ -30,7 +36,6 @@ class ImageMgr(object):
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super(ImageMgr, cls).__new__(cls)
-            cls._instance.image_db = Config().get("images", {}).get("database", None) or ":memory:"
         return cls._instance
 
     def prepare_image(self, engine: "Engine", image: FmImageConfig) -> str:
@@ -40,12 +45,16 @@ class ImageMgr(object):
         if image.base_images and not image.required_packages:
             return image.base_images[0]
 
+        if not image.base_images:
+            raise NoImageError("No base image specified")
+
         logging.info(
             "Building image from from base image %s with packages %s", image.base_images[0], image.required_packages
         )
         image_cmd = engine.image_from(CONTAINERFILE)
         image_cmd.base_image(image.base_images[0])
         image_cmd.packages(image.required_packages)
+        from yaspin import yaspin
 
         with yaspin(text="Building image", color="cyan") as spinner:
             tag = image_cmd.build()

fm_weck/resources/BenchExec-3.25-py3-none-any.whl.license

@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: The BenchExec authors <https://github.com/sosy-lab/benchexec>
+
+SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause AND CC-BY-4.0 AND MIT AND ISC AND LicenseRef-BSD-3-Clause-CMU

fm_weck/resources/__init__.py

@@ -15,7 +15,9 @@ CONTAINERFILE = resource_dir / "Containerfile"
 # to the wheel file under fm_weck/resources/fm_tools
 FM_DATA_LOCATION = resource_dir / "fm_tools"
 PROPERTY_LOCATION = resource_dir / "properties"
-RUN_WITH_OVERLAY = resource_dir / "run_with_overlay.sh"
+RUN_WITH_OVERLAY = "run_with_overlay.sh"
+BENCHEXEC_WHL = resource_dir / "BenchExec-3.25-py3-none-any.whl"
+RUNEXEC_SCRIPT = "runexec"
 
 
 def iter_fm_data():