fm-weck 1.4.8__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.8"
+__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)
@@ -519,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/engine.py

@@ -7,17 +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:
@@ -56,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()
@@ -77,11 +86,13 @@ class Engine(ABC):
     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", []) + [
@@ -120,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",
@@ -184,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."""
 
@@ -204,7 +242,7 @@ class Engine(ABC):
                     return p
             mapped = _map_path(Path(p))
             if Path(p) == mapped:
-                return Path(p).as_posix()
+                return ensure_linux_style(p)
             else:
                 return Path(mapped).as_posix()
 
@@ -234,6 +272,8 @@ class Engine(ABC):
             return Docker
         if engine == "podman":
             return Podman
+        if engine == "runexec" or engine == "benchexec":
+            return Runexec
 
         raise ValueError(f"Unknown engine {engine}")
 
@@ -360,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)))
 
@@ -378,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:
@@ -391,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())
@@ -405,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:
@@ -506,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)

fm_weck/exceptions.py

@@ -5,6 +5,64 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
+import subprocess
+import traceback
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
 
 class NoImageError(Exception):
     pass
+
+
+class RunFailedError(Exception):
+    def __init__(self, exit_code, command, output=None):
+        super().__init__(f"Run failed with exit code {exit_code}: {output}")
+        self.exit_code = exit_code
+        self.command = command
+        self.output = output
+
+
+@dataclass
+class Failure:
+    kind: str  # e.g., "IMAGE_NOT_FOUND", "CALLED_PROCESS_ERROR", "EXCEPTION"
+    message: str  # short, user-facing
+    detail: Optional[str] = None  # optional verbose info (stderr/traceback)
+
+
+def failure_from_exception(e: BaseException) -> Failure:
+    # Special cases first
+    if isinstance(e, NoImageError):
+        failure = Failure("IMAGE_NOT_FOUND", str(e))
+    elif isinstance(e, RunFailedError):
+        failure = Failure("RUN_FAILED", f"Run failed with exit code {e.exit_code}", detail=e.output)
+    elif isinstance(e, subprocess.CalledProcessError):
+        # Try to surface stderr/stdout
+        stderr = e.stderr if hasattr(e, "stderr") else None
+        stdout = e.stdout if hasattr(e, "stdout") else None
+        text = stderr or stdout or str(e)
+        failure = Failure("CALLED_PROCESS_ERROR", f"Tool failed with exit code {e.returncode}", detail=text)
+    else:
+        # Generic fallback
+        failure = Failure("EXCEPTION", str(e), detail="".join(traceback.format_exception(type(e), e, e.__traceback__)))
+
+    logger.error(f"[failure] kind={failure.kind}: {failure.message}")
+    return failure
+
+
+def failure_to_error_code(failure: "Failure"):
+    from fm_weck.grpc_service.proto.fm_weck_service_pb2 import ErrorCode
+
+    FAILURE_KIND_TO_ERROR_CODE = {
+        "RUN_NOT_TERMINATED": ErrorCode.EC_RUN_NOT_TERMINATED,
+        "RUN_NOT_FOUND": ErrorCode.EC_RUN_NOT_FOUND,
+        "RUN_CANCELLED": ErrorCode.EC_RUN_CANCELLED,
+        "RUN_FAILED": ErrorCode.EC_RUN_FAILED,
+        "CALLED_PROCESS_ERROR": ErrorCode.EC_RUN_FAILED,
+        "IMAGE_NOT_FOUND": ErrorCode.EC_RUN_FAILED,
+        "EXCEPTION": ErrorCode.EC_UNKNOWN_ERROR,
+    }
+    return FAILURE_KIND_TO_ERROR_CODE.get(failure.kind, ErrorCode.EC_RUN_FAILED)

fm_weck/file_util.py

@@ -21,3 +21,8 @@ def copy_ensuring_unix_line_endings(src: Path, dst: Path) -> None:
 
     with open(dst, "wb") as dst_file:
         dst_file.write(content)
+
+
+def ensure_linux_style(path: str) -> str:
+    """Ensure that the given path uses Linux-style forward slashes."""
+    return path.replace("\\", "/")

fm_weck/grpc_service/__init__.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
+
+from .fm_weck_client import client_expert_run, client_get_run, client_run, query_files  # noqa: F401
+from .fm_weck_server import serve  # noqa: F401