fm-weck 1.4.8__py3-none-any.whl → 1.5.1__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.1"

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,107 @@ 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,
+    ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
+
+    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.add_argument(
+        "--competition-year",
+        action="store",
+        type=int,
+        help="Automatically select the tool version used in the specified competition year (e.g., 2025). "
+        "Searches for SV-COMP or Test-Comp participation in that year.",
+        required=False,
+        default=None,
+    )
+    smoke_test.set_defaults(main=main_smoke_test)
+
     with contextlib.suppress(ImportError):
         import argcomplete
 
@@ -341,22 +462,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 +485,48 @@ 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 get_version_for_competition_year(tool_path: Path, year: int) -> Optional[str]:
+    """
+    Find the tool version used in a competition for the given year.
+    Searches for SV-COMP or Test-Comp participation entries.
+
+    Args:
+        tool_path: Path to the tool's YAML file
+        year: Competition year (e.g., 2025)
+
+    Returns:
+        Version string if found, None otherwise
+    """
+    import yaml
+
+    if not tool_path.exists() or not tool_path.is_file():
+        return None
+
+    with tool_path.open("r") as f:
+        data = yaml.safe_load(f)
+
+    competition_participations = data.get("competition_participations", [])
+
+    # Search for competition entries matching the year
+    for participation in competition_participations:
+        competition = participation.get("competition", "")
+        # Match "SV-COMP 2025", "Test-Comp 2025", etc.
+        if f"{year}" in competition and ("SV-COMP" in competition or "Test-Comp" in competition):
+            version = participation.get("tool_version")
+            if version:
+                logger.info("Found version '%s' for %s in %s", version, tool_path.stem, competition)
+                return version
+
+    return None
+
+
 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 +666,116 @@ 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)
+    except KeyError:
+        logger.error("Unknown tool: %s", args.TOOL.tool)
+        return 1
+
+    # Handle --competition-year flag
+    version = args.TOOL.version
+    if args.competition_year:
+        if version:
+            logger.warning(
+                "Both explicit version '%s' and --competition-year %d specified. "
+                "Using competition year to determine version.",
+                version,
+                args.competition_year,
+            )
+        competition_version = get_version_for_competition_year(tool, args.competition_year)
+        if competition_version:
+            logger.info("Using version '%s' for competition year %d", competition_version, args.competition_year)
+            version = competition_version
+        else:
+            logger.error("No competition participation found for year %d in tool %s", args.competition_year, tool.stem)
+            return 1
+
+    fm_data, shelve_space = setup_fm_tool(
+        fm_tool=tool,
+        version=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)