fm-weck 1.4.7__py3-none-any.whl → 1.5.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.4.7"
+__version__ = "1.5.0"

fm_weck/capture.py

@@ -0,0 +1,31 @@
+# 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
+
+import io
+import os
+import sys
+from typing import Literal
+
+
+class Capture:
+    def __init__(self, target: io.TextIOBase, stream: Literal["stdout, stderr, stdin"] = "stdout"):
+        self.io_stream = getattr(sys, stream)
+        self._copy = os.dup(self.io_stream.fileno())
+        os.dup2(target.fileno(), self.io_stream.fileno())
+
+    def __del__(self):
+        # Ensure cleanup in case the context manager isn't used
+        self._cleanup()
+
+    def _cleanup(self):
+        os.dup2(self._copy, self.io_stream.fileno())
+
+    def __enter__(self):
+        return self  # Return the instance for use within the context
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._cleanup()  # Clean up resources upon leaving the context

fm_weck/cli.py

@@ -11,7 +11,6 @@ import logging
 import os
 from argparse import Namespace
 from dataclasses import dataclass
-from functools import cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
 
@@ -39,7 +38,7 @@ import contextlib
 from fm_weck import Config
 from fm_weck.cache_mgr import ask_and_clear, clear_cache
 from fm_weck.config import _SEARCH_ORDER
-from fm_weck.resources import iter_fm_data, iter_properties
+from fm_weck.resources import fm_tools_choice_map, iter_fm_data, property_choice_map
 
 from . import __version__
 from .exceptions import NoImageError
@@ -112,9 +111,9 @@ class ShellCompletion:
 def add_tool_arg(parser, nargs: str | None = "?"):
     parser.add_argument(
         "TOOL",
-        help="The tool to obtain the container from. Can be the form <tool>:<version>. "
+        help="The tool to obtain the container from. Can be in the form <tool>:<version>. "
         "The TOOL is either the name of a bundled tool (c.f. fm-weck --list) or "
-        "the path to a fm-tools yaml file.",
+        "the path to an fm-tools YAML file.",
         type=ToolQualifier,
         nargs=nargs,
     ).completer = ShellCompletion.tool_completer
@@ -131,6 +130,27 @@ def add_shared_args_for_run_modes(parser):
     add_tool_arg(parser, nargs=None)
 
 
+def add_shared_args_for_client(parser):
+    parser.add_argument(
+        "--host",
+        action="store",
+        dest="host",
+        type=str,
+        help=("Specifies the IP address and the port of the server."),
+        required=True,
+        default=None,
+    )
+
+    parser.add_argument(
+        "--timelimit",
+        action="store",
+        dest="timelimit",
+        type=str,
+        help=("Specifies the maximum amount of time to wait for the server to finish a run, in seconds."),
+        default=10,
+    )
+
+
 def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     parser = argparse.ArgumentParser(description="fm-weck")
 
@@ -192,9 +212,9 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         "--spec",
         action="store",
         help=(
-            "Property to that is forwarded to the fm-tool."
+            "Property that is forwarded to the fm-tool."
             " Either a path to a property file or a property name from SV-COMP or Test-Comp."
-            " Use fm-weck serve --list to see all properties that can be called by name."
+            " Use fm-weck serve --list to view all properties that can be called by name."
         ),
         required=False,
         default=None,
@@ -318,6 +338,98 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
     versions.set_defaults(main=main_versions)
 
+    server = subparsers.add_parser("server", aliases=["s"], help="Run fm-weck remotely on a server.")
+    server.add_argument(
+        "--port",
+        action="store",
+        dest="port",
+        type=str,
+        help=("Specifies the port number on which the server will listen."),
+        required=True,
+        default=None,
+    )
+
+    server.add_argument(
+        "--listen",
+        action="store",
+        dest="ipaddr",
+        type=str,
+        help=("Specifies the IP address on which the server will listen."),
+        required=True,
+        default=None,
+    )
+    server.set_defaults(main=main_server)
+
+    client = subparsers.add_parser("remote-run", aliases=["rr"], help="Execute tasks remotely.")
+    client.add_argument(
+        "-p",
+        "--property",
+        "--spec",
+        action="store",
+        help=(
+            "Property that is forwarded to the fm-tool."
+            " Either a path to a property file or a property name from SV-COMP or Test-Comp."
+            " Use fm-weck serve --list to view all properties that can be called by name."
+        ),
+        required=True,
+        default=None,
+    )
+
+    add_shared_args_for_client(client)
+    add_tool_arg(client, nargs=None)
+    client.add_argument("files", metavar="FILES", nargs="+", help="Files to pass to the tool.")
+    client.set_defaults(main=main_client)
+
+    client_expert = subparsers.add_parser(
+        "remote-expert", aliases=["re"], help="Execute tasks remotely in expert mode."
+    )
+    add_shared_args_for_client(client_expert)
+    add_tool_arg(client_expert, nargs=None)
+    client_expert.add_argument("argument_list", metavar="args", nargs="*", help="Arguments for the fm-tool.")
+    client_expert.set_defaults(main=main_client_expert)
+
+    client_get_run = subparsers.add_parser(
+        "get-run", aliases=["gr"], help="Get the result for a remotely executed task."
+    )
+    add_shared_args_for_client(client_get_run)
+    client_get_run.add_argument("run_id", metavar="RUN-ID", nargs=1, help="The run ID for which to get the result.")
+    client_get_run.set_defaults(main=main_client_get_run)
+
+    client_query_files = subparsers.add_parser(
+        "query-files", aliases=["qf"], help="Get the resulting files for a remotely executed task."
+    )
+    client_query_files.add_argument("run_id", metavar="RUN-ID", nargs=1, help="The run ID for which to get the result.")
+    client_query_files.add_argument("file_names", metavar="files", nargs="*", help="Files to query for.")
+    add_shared_args_for_client(client_query_files)
+    client_query_files.add_argument(
+        "--output-path",
+        action="store",
+        dest="output_path",
+        type=Path,
+        help=(
+            "Specifies the location where the incoming files from the server will be stored, "
+            "relative to the current working directory."
+        ),
+        default=Path.cwd(),
+    )
+    client_query_files.set_defaults(main=main_client_query_files)
+
+    smoke_test = subparsers.add_parser("smoke-test", help="Run a smoke test on the tool.")
+    smoke_test.add_argument(
+        "TOOL",
+        help="The tool for which to run the smoke test.",
+        type=ToolQualifier,
+        nargs=1,
+    ).completer = ShellCompletion.versions_completer
+    smoke_test.add_argument(
+        "--gitlab-ci-mode",
+        action="store_true",
+        help="Run in GitLab CI mode: directly install required packages with apt instead of building/pulling images.",
+        required=False,
+        default=False,
+    )
+    smoke_test.set_defaults(main=main_smoke_test)
+
     with contextlib.suppress(ImportError):
         import argcomplete
 
@@ -341,22 +453,6 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     return help_callback, parser.parse_args(raw_args)
 
 
-@cache
-def fm_tools_choice_map():
-    ignore = {
-        "schema.yml",
-    }
-
-    actors = {actor_def.stem: actor_def for actor_def in iter_fm_data() if (actor_def.name not in ignore)}
-
-    return actors
-
-
-@cache
-def property_choice_map():
-    return {spec_path.stem: spec_path for spec_path in iter_properties() if spec_path.suffix != ".license"}
-
-
 def list_known_tools():
     return fm_tools_choice_map().keys()
 
@@ -380,6 +476,13 @@ def resolve_property(prop_name: str) -> Path:
     return property_choice_map()[prop_name]
 
 
+def resolve_property_for_server(prop_name: str) -> Union[Path, str]:
+    if (as_path := Path(prop_name)).exists() and as_path.is_file():
+        return as_path
+
+    return prop_name
+
+
 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)
@@ -470,12 +573,7 @@ def main_install(args: argparse.Namespace):
             logger.error("Unknown tool %s. Skipping installation...", tool)
             continue
 
-        install_fm_tool(
-            fm_tool=fm_data,
-            version=tool.version,
-            configuration=Config(),
-            install_path=args.destination
-        )
+        install_fm_tool(fm_tool=fm_data, version=tool.version, configuration=Config(), install_path=args.destination)
 
     return 0
 
@@ -524,6 +622,98 @@ def main_versions(args: argparse.Namespace):
     VersionListing(tool_paths).print_versions()
 
 
+def main_server(args: argparse.Namespace):
+    from .grpc_service import serve
+
+    serve(ipaddr=args.ipaddr, port=args.port)
+
+
+def main_client(args: argparse.Namespace):
+    from .grpc_service import client_run
+
+    tool = resolve_tool(args.TOOL)
+    property = resolve_property(args.property)
+    timelimit, _ = check_client_options(args.timelimit)
+
+    client_run((tool, args.TOOL.version), args.host, property, args.files, timelimit)
+
+
+def main_client_expert(args: argparse.Namespace):
+    from .grpc_service import client_expert_run
+
+    tool = resolve_tool(args.TOOL)
+    command = args.argument_list
+    client_expert_run((tool, args.TOOL.version), args.host, command, args.timelimit)
+
+
+def main_client_get_run(args: argparse.Namespace):
+    from .grpc_service import client_get_run
+
+    timelimit, _ = check_client_options(args.timelimit)
+    client_get_run(args.host, args.run_id[0], timelimit)
+
+
+def main_client_query_files(args: argparse.Namespace):
+    from .grpc_service import query_files
+
+    timelimit, _ = check_client_options(args.timelimit)
+    file_names = args.file_names
+
+    query_files(args.host, args.run_id[0], file_names, timelimit, args.output_path)
+
+
+def check_client_options(timelimit_arg, output_path=None):
+    try:
+        timelimit = int(timelimit_arg)
+    except ValueError:
+        logger.error("Invalid timelimit value: %s. It must be an integer.", timelimit_arg)
+        exit(1)
+
+    if output_path:
+        output_path = Path.cwd() / Path(output_path)
+        if not output_path.exists():
+            try:
+                output_path.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                logger.error("Failed to create output path %s: %s", output_path, e)
+                exit(1)
+
+    return timelimit, output_path
+
+
+def main_smoke_test(args: argparse.Namespace):
+    from .serve import setup_fm_tool
+    from .smoke_test_mode import run_smoke_test, run_smoke_test_gitlab_ci
+
+    try:
+        tool = resolve_tool(args.TOOL[0])
+    except KeyError:
+        logger.error("Unknown tool: %s", args.TOOL[0].tool)
+        return 1
+
+    fm_data, shelve_space = setup_fm_tool(
+        fm_tool=tool,
+        version=args.TOOL[0].version,
+        configuration=Config(),
+    )
+
+    if args.gitlab_ci_mode:
+        from subprocess import CalledProcessError
+
+        try:
+            run_smoke_test_gitlab_ci(fm_data, shelve_space)
+        except CalledProcessError as e:
+            return e.returncode
+
+        return 0
+
+    try:
+        run_smoke_test(fm_data, shelve_space, Config())
+    except ValueError as e:
+        logger.error(e)
+        return 1
+
+
 def log_no_image_error(tool, config):
     order = []
     for path in _SEARCH_ORDER:

fm_weck/config.py

@@ -8,7 +8,6 @@
 import importlib.resources as pkg_resources
 import logging
 import os
-import shutil
 import stat
 import sys
 from functools import cache
@@ -40,6 +39,8 @@ except ImportError:
 
 from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
 
+from .file_util import copy_ensuring_unix_line_endings
+
 try:
     import tomllib as toml
 except ImportError:
@@ -206,7 +207,7 @@ class Config(object):
             # Try to copy from package resources
             try:
                 with pkg_resources.path("fm_weck.resources", target_name) as source_path:
-                    shutil.copy(source_path, target)
+                    copy_ensuring_unix_line_endings(source_path, target)
             except FileNotFoundError:
                 logging.error(f"Resource {target_name} not found in package.")
                 return None
@@ -214,7 +215,7 @@ class Config(object):
             # 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)
+                    copy_ensuring_unix_line_endings(source_path, target)
                 else:
                     logging.debug(f"Using existing {target_name} script")
                     return target

fm_weck/engine.py

@@ -7,16 +7,23 @@
 
 import io
 import logging
+import os
+import platform
+import shlex
 import shutil
 import signal
 import subprocess
 import sys
+import threading
 from abc import ABC, abstractmethod
 from functools import cached_property, singledispatchmethod
 from pathlib import Path
 from tempfile import mkdtemp
+from threading import Thread
 from typing import TYPE_CHECKING, Callable, Iterable, List, Optional, Union
 
+from fm_weck.capture import Capture
+from fm_weck.file_util import ensure_linux_style
 from fm_weck.run_result import RunResult
 
 try:
@@ -55,8 +62,11 @@ class Engine(ABC):
     print_output_to_stdout: bool = True
     add_benchexec_capabilities: bool = False
     add_mounting_capabilities: bool = True
+    _use_overlay: bool = False
+    overlay_tool_dir: Optional[str] = None
     image: Optional[str] = None
     dry_run: bool = False
+    work_dir: Optional[Path] = Path(CWD_MOUNT_LOCATION)
 
     def __init__(self, image: Union[str, FmImageConfig]):
         self._tmp_output_dir = Path(mkdtemp("fm_weck_output")).resolve()
@@ -73,14 +83,16 @@ class Engine(ABC):
         if self._tmp_output_dir.exists():
             shutil.rmtree(self._tmp_output_dir)
 
-    def get_workdir(self):
-        return Path(CWD_MOUNT_LOCATION)
+    def get_workdir(self) -> str:
+        return Path(CWD_MOUNT_LOCATION).as_posix()
 
-    def set_output_log(self, output_log: Path):
-        self.log_file = output_log
+    def set_log_file(self, log_file: Path):
+        self.log_file = log_file
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
 
-    def set_output_files_dir(self, output_log: Path):
-        self.output_dir = output_log
+    def set_output_dir(self, output_dir: Path):
+        self.output_dir = output_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
 
     def mount(self, source: str, target: str):
         self.extra_args["mounts"] = self.extra_args.get("mounts", []) + [
@@ -119,6 +131,10 @@ class Engine(ABC):
     def add_environment(self):
         return sum([["-e", f"{key}={value}"] for key, value in self.env.items()], [])
 
+    def use_overlay(self, overlay_dir: str):
+        self._use_overlay = True
+        self.overlay_tool_dir = overlay_dir
+
     def setup_command(self):
         return [
             "--security-opt",
@@ -126,7 +142,7 @@ class Engine(ABC):
             "--entrypoint",
             '[""]',
             "-v",
-            f"{Path.cwd().absolute()}:{CWD_MOUNT_LOCATION}",
+            f"{Path.cwd().absolute()}:{self.get_workdir()}",
             "-v",
             f"{Config().cache_location}:{CACHE_MOUNT_LOCATION}",
             "-v",
@@ -183,9 +199,32 @@ class Engine(ABC):
                 base.append(value)
 
         _command = self._prep_command(command)
+
+        if self._use_overlay:
+            _command = (f"{CACHE_MOUNT_LOCATION}/.scripts/run_with_overlay.sh", self.overlay_tool_dir, *_command)
+
         return base + [self.image, *_command]
 
-    def _prep_command(self, command: Iterable[str]) -> tuple[str | Path, ...]:
+    def assemble_smoke_test_command(self, command: tuple[str, ...]):
+        base = self.base_command()
+        if self.add_benchexec_capabilities:
+            base += self.benchexec_capabilities()
+
+        if self.add_mounting_capabilities:
+            base += self.mounting_capabilities()
+
+        if self.interactive:
+            base += self.interactive_command()
+
+        for value in self.extra_args.values():
+            if isinstance(value, list) and not isinstance(value, str):
+                base += value
+            else:
+                base.append(value)
+
+        return base + command
+
+    def _prep_command(self, command: tuple[str, ...]) -> tuple[str, ...]:
         """We want to map absolute paths of the current working directory to the
         working directory of the container."""
 
@@ -203,9 +242,9 @@ class Engine(ABC):
                     return p
             mapped = _map_path(Path(p))
             if Path(p) == mapped:
-                return p
+                return ensure_linux_style(p)
             else:
-                return mapped
+                return Path(mapped).as_posix()
 
         return tuple(map(_map_path, command))
 
@@ -227,12 +266,14 @@ class Engine(ABC):
 
     @staticmethod
     def _base_engine_class(config: Config):
-        engine = config.defaults().get("engine", "podman").lower()
+        engine = "docker" if platform.system() != "Linux" else config.defaults().get("engine", "podman").lower()
 
         if engine == "docker":
             return Docker
         if engine == "podman":
             return Podman
+        if engine == "runexec" or engine == "benchexec":
+            return Runexec
 
         raise ValueError(f"Unknown engine {engine}")
 
@@ -359,9 +400,13 @@ class Engine(ABC):
                 logging.info("Received signal %s. Terminating container process.", signal_received)
                 process.send_signal(signal.SIGTERM)
 
+        def register_signal(signum, handler) -> None:
+            if threading.current_thread() is threading.main_thread():
+                signal.signal(signum, handler)
+
         # Register signal handler
-        signal.signal(signal.SIGINT, terminate_process_group)
-        signal.signal(signal.SIGTERM, terminate_process_group)
+        register_signal(signal.SIGINT, terminate_process_group)
+        register_signal(signal.SIGTERM, terminate_process_group)
 
         logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
 
@@ -377,11 +422,14 @@ class Engine(ABC):
                 if self.print_output_to_stdout:
                     sys.stdout.write(line)
 
+        file_handle = None
         if self.log_file is None:
-            run_and_poll(full_stdout.write)  # type: ignore
+            polling_thread = Thread(target=run_and_poll, args=(full_stdout.write,))
         else:
-            with self.log_file.open("w") as log:
-                run_and_poll(log.write)  # type: ignore
+            file_handle = self.log_file.open("w")
+            polling_thread = Thread(target=run_and_poll, args=(file_handle.write,))
+
+        polling_thread.start()
 
         assert process is not None, "Process should be defined at this point."
         try:
@@ -390,6 +438,10 @@ class Engine(ABC):
             process.terminate()
             process.wait()
 
+        polling_thread.join()
+        if file_handle is not None:
+            file_handle.close()
+
         if self.log_file is not None:
             with self.log_file.open("r") as log:
                 return RunResult(command, process.returncode, log.read())
@@ -404,7 +456,7 @@ class Engine(ABC):
         logger.debug("Running: %s", command)
         if self.dry_run:
             print("Command to be executed:")
-            print(" ".join(map(str, command)))
+            print(shlex.join(command))
             return RunResult(command, 0, "Dry run: no command executed.")
 
         if self.interactive or not self.handle_io:
@@ -505,3 +557,84 @@ class Docker(Engine):
             "label=disable",
             "-v /sys/fs/cgroup:/sys/fs/cgroup",
         ]
+
+
+class Runexec(Engine):
+    def __init__(self, image: Union[str, FmImageConfig]):
+        super().__init__("unused")
+        self._engine = "runexec"
+
+    def image_from(self, containerfile: Path):
+        logging.info("Engine 'runexec' does not support building images. Continuing without image.")
+        raise NotImplementedError("runexec does not support building images.")
+
+    def benchexec_capabilities(self):
+        return []
+
+    def base_command(self):
+        return ["runexec"]
+
+    def setup_command(self):
+        return []
+
+    def _get_dir_modes(self):
+        from benchexec.container import DIR_HIDDEN, DIR_OVERLAY, DIR_READ_ONLY
+
+        dir_modes = {
+            "/": DIR_READ_ONLY,
+            "/home": DIR_HIDDEN,
+            os.getcwd(): DIR_OVERLAY,
+        }
+
+        if not Config().cache_location.resolve().is_relative_to(Path.cwd().resolve()):
+            dir_modes[str(Config().cache_location.resolve())] = DIR_OVERLAY
+
+        return dir_modes
+
+    def run(self, *command, timeout_sec: Optional[float] = None) -> RunResult:
+        import threading
+        from tempfile import TemporaryFile
+
+        from benchexec.containerexecutor import ContainerExecutor
+
+        executor = ContainerExecutor(
+            network_access=True, container_system_config=False, cgroup_access=True, dir_modes=self._get_dir_modes()
+        )
+
+        def signal_handler_kill(signum, frame):
+            executor.stop()
+
+        signal.signal(signal.SIGTERM, signal_handler_kill)
+        signal.signal(signal.SIGQUIT, signal_handler_kill)
+        signal.signal(signal.SIGINT, signal_handler_kill)
+
+        working_dir = Config().cache_location / self.overlay_tool_dir if self.overlay_tool_dir else Path.cwd()
+
+        log_creator = TemporaryFile
+        if self.log_file:
+            log_creator = self.log_file.open
+
+        log_str = ""
+
+        def stop_executor_after_timeout():
+            # If timeout is None, this waits indefinitely
+            threading.Event().wait(timeout_sec)
+            executor.stop()
+
+        eventual_stopping_thread = threading.Thread(target=stop_executor_after_timeout, daemon=True)
+
+        with log_creator("w+") as log, Capture(log), Capture(log, "stderr"):
+            eventual_stopping_thread.start()
+            exit_code = executor.execute_run(
+                args=command,
+                output_dir=self.output_dir,
+                workingDir=str(working_dir.absolute()),
+            )
+
+            log.seek(0)
+            log_str = log.read()
+
+        if self.print_output_to_stdout:
+            print(log_str)
+
+        return RunResult(command, exit_code.raw, log_str)