fm-weck 1.4.5__py3-none-any.whl → 1.4.6__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.5"
+__version__ = "1.4.6"

fm_weck/__main__.py

@@ -4,6 +4,7 @@
 # SPDX-FileCopyrightText: 2024 Dirk Beyer <https://www.sosy-lab.org>
 #
 # SPDX-License-Identifier: Apache-2.0
+# PYTHON_ARGCOMPLETE_OK
 
 import sys
 

fm_weck/cache_mgr.py

@@ -0,0 +1,47 @@
+# 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 logging
+import os
+import shutil
+
+logger = logging.getLogger(__name__)
+
+
+def ask_and_clear(cache_location: str):
+    response = (
+        input(f"The following cache location will be deleted: {cache_location}\nDo you want to proceed? (Y/n): ")
+        .strip()
+        .lower()
+    )
+
+    if response == "y":
+        clear_cache(cache_location)
+    elif response == "n":
+        return
+    else:
+        logger.error(f"Unknown command '{response}'\n")
+        ask_and_clear(cache_location)
+
+
+def clear_cache(cache_location: str):
+    if not cache_location:
+        logger.error("Cache location is unknown.")
+        return
+
+    if os.path.isdir(cache_location):
+        for item in os.listdir(cache_location):
+            item_path = os.path.join(cache_location, item)
+            try:
+                if os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+                else:
+                    os.remove(item_path)
+            except Exception as e:
+                logger.error(f"Error removing {item_path}: {e}")
+    else:
+        logger.error(f"The path {cache_location} is not a valid directory.")

fm_weck/cli.py

@@ -5,6 +5,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+
 import argparse
 import logging
 import os
@@ -31,7 +32,10 @@ except ImportError:
             return self.value
 
 
+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
 
@@ -61,6 +65,48 @@ class ToolQualifier:
             return
 
 
+class ShellCompletion:
+    @staticmethod
+    def properties_completer(prefix, parsed_args, **kwargs):
+        return list_known_properties()
+
+    @staticmethod
+    def versions_completer(prefix, parsed_args, **kwargs):
+        return list_known_tools()
+
+    @staticmethod
+    def tool_completer(prefix, parsed_args, **kwargs):
+        try:
+            import yaml
+        except ImportError:
+            logger.error("PyYAML is not installed. Cannot complete tool names.")
+            return []
+
+        tools_and_versions: dict[str, list] = {}
+
+        for tool_path in iter_fm_data():
+            with open(tool_path) as stream:
+                tool_data = yaml.safe_load(stream)
+
+                try:
+                    versions = [version_data["version"] for version_data in tool_data["versions"]]
+                except KeyError:
+                    continue
+                tools_and_versions[tool_data["name"]] = versions
+
+        tools_and_versions_list = [
+            f"{tool.lower()}:{version}" for tool, versions in tools_and_versions.items() for version in versions
+        ]
+
+        selected_tools = set([tool.split(":")[0] for tool in tools_and_versions_list if tool.startswith(prefix)])
+        if len(selected_tools) == 1:
+            # If exactly one tool has been selected, suggest versions
+            return [tool for tool in tools_and_versions_list if tool.startswith(prefix)]
+
+        # If no tool has been selected, suggest tool names
+        return selected_tools
+
+
 def add_tool_arg(parser, nargs="?"):
     parser.add_argument(
         "TOOL",
@@ -69,14 +115,15 @@ def add_tool_arg(parser, nargs="?"):
         "the path to a fm-tools yaml file.",
         type=ToolQualifier,
         nargs=nargs,
-    )
+    ).completer = ShellCompletion.tool_completer
 
 
 def add_shared_args_for_run_modes(parser):
     parser.add_argument(
-        "--skip-download",
+        "--offline",
         action="store_true",
-        help="Do not download the fm-tool, even if it is not available in the cache.",
+        help="Run the tools offline. The offline mode assumes that both the tool and its info-module are located "
+        "at the location specified by the config's 'cache_location' field.",
     )
 
     add_tool_arg(parser, nargs=None)
@@ -149,7 +196,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         ),
         required=False,
         default=None,
-    )
+    ).completer = ShellCompletion.properties_completer
 
     run.add_argument(
         "-d",
@@ -178,7 +225,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         "argument_list",
         metavar="args",
         nargs="*",
-        help="Additional arguments for the fm-tool." " To add them, separate them with '--' from the files.",
+        help="Additional arguments for the fm-tool. To add them, separate them with '--' from the files.",
     )
     run.set_defaults(main=main_run)
 
@@ -248,6 +295,32 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     runexec.add_argument("argument_list", metavar="args", nargs="*", help="Arguments for runexec.")
     runexec.set_defaults(main=main_runexec)
 
+    clear_cache = subparsers.add_parser("clear-cache", help="Clear the cache directory.")
+    clear_cache.add_argument(
+        "--yes",
+        "-y",
+        "-Y",
+        action="store_true",
+        help="Add automatic approval for clearing the cache.",
+        required=False,
+        default=False,
+    )
+    clear_cache.set_defaults(main=main_clear_cache)
+
+    versions = subparsers.add_parser("versions", help="Show the versions of the chosen tool(s).")
+    versions.add_argument(
+        "TOOL",
+        help="The tool(s) for which to print the versions.",
+        type=ToolQualifier,
+        nargs="+",
+    ).completer = ShellCompletion.versions_completer
+    versions.set_defaults(main=main_versions)
+
+    with contextlib.suppress(ImportError):
+        import argcomplete
+
+        argcomplete.autocomplete(parser)
+
     def help_callback():
         parser.print_help()
 
@@ -333,22 +406,25 @@ def main_run(args: argparse.Namespace):
         logger.error("Unknown property %s", args.property)
         return 1
 
-    return run_guided(
+    result = run_guided(
         fm_tool=fm_data,
         version=args.TOOL.version,
         configuration=Config(),
         prop=property_path,
+        witness=Path(args.witness) if args.witness else None,
         program_files=args.files,
         additional_args=args.argument_list,
         data_model=args.data_model,
-        skip_download=args.skip_download,
+        offline_mode=args.offline,
     )
 
+    return result.exit_code
+
 
 def main_runexec(args: argparse.Namespace):
     from .runexec_mode import run_runexec
 
-    return run_runexec(
+    result = run_runexec(
         benchexec_package=args.benchexec_package,
         use_image=args.use_image,
         configuration=Config(),
@@ -356,6 +432,8 @@ def main_runexec(args: argparse.Namespace):
         command=args.argument_list,
     )
 
+    return result.exit_code
+
 
 def main_manual(args: argparse.Namespace):
     from .serve import run_manual
@@ -369,14 +447,16 @@ def main_manual(args: argparse.Namespace):
         logger.error("Unknown tool %s", args.TOOL)
         return 1
 
-    return run_manual(
+    result = run_manual(
         fm_tool=fm_data,
         version=args.TOOL.version,
         configuration=Config(),
         command=args.argument_list,
-        skip_download=args.skip_download,
+        offline_mode=args.offline,
     )
 
+    return result.exit_code
+
 
 def main_install(args: argparse.Namespace):
     from .serve import setup_fm_tool
@@ -413,7 +493,35 @@ def main_shell(args: argparse.Namespace):
             return 1
         engine = Engine.from_config(fm_data, args.TOOL.version, Config())
     engine.interactive = True
-    return engine.run(args.entry)
+    result = engine.run(args.entry)
+    return result.exit_code
+
+
+def main_clear_cache(args: argparse.Namespace):
+    if args.yes:
+        clear_cache(Config().get("defaults").get("cache_location"))
+    else:
+        ask_and_clear(Config().get("defaults").get("cache_location"))
+    return
+
+
+def main_versions(args: argparse.Namespace):
+    from .version_listing import VersionListing
+
+    tools = args.TOOL
+    tool_paths = []
+    if not args.TOOL:
+        logger.error("No fm-tool given. Aborting...")
+        return 1
+
+    for tool in tools:
+        try:
+            tool_paths.append(resolve_tool(tool))
+        except KeyError:
+            logger.error("Unknown tool %s", tool)
+            return 1
+
+    VersionListing(tool_paths).print_versions()
 
 
 def log_no_image_error(tool, config):
@@ -462,6 +570,7 @@ to your .fm-weck file.
 def cli(raw_args: list[str]):
     help_callback, args = parse(raw_args)
     configuration = Config().load(args.config)
+
     set_log_options(args.loglevel, args.logfile, configuration)
     if args.dry_run:
         Config().set_dry_run(True)

fm_weck/engine.py

@@ -5,15 +5,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import io
 import logging
 import shutil
 import signal
 import subprocess
+import sys
 from abc import ABC, abstractmethod
 from functools import cached_property, singledispatchmethod
 from pathlib import Path
 from tempfile import mkdtemp
-from typing import List, Optional, Union
+from typing import Callable, List, Optional, Union
+
+from fm_weck.run_result import RunResult
 
 try:
     from fm_tools.fmdata import FmData, FmImageConfig
@@ -33,7 +37,6 @@ from fm_weck.image_mgr import ImageMgr
 
 logger = logging.getLogger(__name__)
 
-
 CWD_MOUNT_LOCATION = "/home/cwd"
 CACHE_MOUNT_LOCATION = "/home/fm-weck_cache"
 OUTPUT_MOUNT_LOCATION = "/home/output"
@@ -43,6 +46,8 @@ RESERVED_LOCATIONS = frozenset([CACHE_MOUNT_LOCATION, CWD_MOUNT_LOCATION, OUTPUT
 
 class Engine(ABC):
     interactive: bool = False
+    handle_io: bool = True
+    print_output_to_stdout: bool = True
     add_benchexec_capabilities: bool = False
     add_mounting_capabilities: bool = True
     image: Optional[str] = None
@@ -111,6 +116,8 @@ class Engine(ABC):
 
     def setup_command(self):
         return [
+            "--security-opt",
+            "label=disable",
             "--entrypoint",
             '[""]',
             "-v",
@@ -137,7 +144,18 @@ class Engine(ABC):
             if file.is_file():
                 shutil.copy(file, self.output_dir / file.name)
             elif file.is_dir():
-                shutil.copytree(file, self.output_dir, dirs_exist_ok=True)
+                try:
+                    # This may fail if there are some permission errors,
+                    # but we don't want to stop the whole process in case this happens.
+                    # One such example is UAutomizer's output which contains
+                    # some config files produced by Java.
+                    shutil.copytree(
+                        file,
+                        self.output_dir,
+                        dirs_exist_ok=True,
+                    )
+                except shutil.Error as e:
+                    logger.warning(f"Error while copying the output {file} directory: {e}")
 
     def assemble_command(self, command: tuple[str, ...]) -> list[str]:
         base = self.base_command()
@@ -258,7 +276,8 @@ class Engine(ABC):
         return engine
 
     @abstractmethod
-    def image_from(self, containerfile: Path) -> "BuildCommand": ...
+    def image_from(self, containerfile: Path) -> "BuildCommand":
+        pass
 
     class BuildCommand(ABC):
         build_args: List[str] = []
@@ -289,15 +308,43 @@ class Engine(ABC):
 
             logging.debug("Running command: %s", cmd)
 
-            ret = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            ret = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
             tag = ret.stdout.decode().splitlines()[-1].strip()
             logger.info("Built image %s", tag)
             logger.debug("Output of build image was:\n%s", ret.stdout.decode())
+            logger.debug("Error of build image was:\n%s", ret.stderr.decode())
+            if ret.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    ret.returncode, cmd, output=ret.stdout.decode(), stderr=ret.stderr.decode()
+                )
 
             return tag
 
-    def _run_process(self, command: tuple[str, ...] | list[str]):
+    def _run_process_without_attaching_io(
+        self, command: tuple[str, ...] | list[str], timeout_sec: Optional[float] = None
+    ) -> RunResult:
+        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)))
+        process = subprocess.Popen(command)
+
+        try:
+            process.wait(timeout=timeout_sec)
+        except subprocess.TimeoutExpired:
+            process.terminate()
+            process.wait()
+
+        return RunResult(command, process.returncode, io.StringIO())
+
+    def _run_process(self, command: tuple[str, ...] | list[str], timeout_sec: Optional[float] = None) -> RunResult:
         process = None  # To make sure process is defined if a signal is caught early
 
         def terminate_process_group(signal_received, frame):
@@ -310,18 +357,37 @@ class Engine(ABC):
         signal.signal(signal.SIGTERM, terminate_process_group)
 
         logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
+
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        full_stdout = io.StringIO()
+
+        def run_and_poll(writer: Callable[[str], None]):
+            while process.poll() is None:
+                line = process.stdout.readline().decode("utf-8")
+                writer(line)
+                if self.print_output_to_stdout:
+                    sys.stdout.write(line)
+
         if self.log_file is None:
-            process = subprocess.Popen(command)
+            run_and_poll(full_stdout.write)
         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)
+            with self.log_file.open("w") as log:
+                run_and_poll(log.write)
 
         assert process is not None, "Process should be defined at this point."
-        process.wait()
-        return process.returncode
+        try:
+            process.wait(timeout=timeout_sec)
+        except subprocess.TimeoutExpired:
+            process.terminate()
+            process.wait()
 
-    def run(self, *command: str) -> int:
+        if self.log_file is not None:
+            with self.log_file.open("r") as log:
+                return RunResult(command, process.returncode, log.read())
+
+        return RunResult(command, process.returncode, full_stdout.read())
+
+    def run(self, *command: str, timeout_sec: Optional[float] = None) -> RunResult:
         if self.image is None:
             raise NoImageError("No image set for engine.")
 
@@ -330,11 +396,14 @@ class Engine(ABC):
         if self.dry_run:
             print("Command to be executed:")
             print(" ".join(map(str, command)))
-            return 0
+            return 0, ""
+
+        if self.interactive or not self.handle_io:
+            return self._run_process_without_attaching_io(command, timeout_sec=timeout_sec)
 
-        return_code = self._run_process(command)
+        result = self._run_process(command, timeout_sec=timeout_sec)
         self._move_output()
-        return return_code
+        return result
 
 
 class Podman(Engine):

fm_weck/exceptions.py

@@ -5,5 +5,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+
 class NoImageError(Exception):
     pass

fm_weck/resources/__init__.py

@@ -16,7 +16,7 @@ CONTAINERFILE = resource_dir / "Containerfile"
 FM_DATA_LOCATION = resource_dir / "fm_tools"
 PROPERTY_LOCATION = resource_dir / "properties"
 RUN_WITH_OVERLAY = "run_with_overlay.sh"
-BENCHEXEC_WHL = resource_dir / "BenchExec-3.25-py3-none-any.whl"
+BENCHEXEC_WHL = resource_dir / "BenchExec-3.27-py3-none-any.whl"
 RUNEXEC_SCRIPT = "runexec"
 
 

fm_weck/resources/fm_tools/2ls.yml

@@ -1,5 +1,13 @@
 id: 2ls
 name: 2LS
+description: |
+  2LS ("tools") is a verification tool for C programs, built upon the CPROVER framework. 
+  It allows one to verify user-specified assertions, undefined behaviour, memory leaks, 
+  and termination properties. The analysis is performed by translating the verification 
+  task into a second-order logic formula over bitvector, array, and floating-point
+  arithmetic theories. The formula is solved by a modular combination of algorithms 
+  involving unfolding and template-based invariant synthesis with the help of
+  incremental SAT solving.
 input_languages:
   - C
 project_url: https://github.com/diffblue/2ls
@@ -69,21 +77,38 @@ techniques:
   - Shape Analysis
   - Bit-Precise Analysis
   - Ranking Functions
+  - Template-Based Predicate Inference
 
 frameworks_solvers:
   - CProver
   - MiniSAT
+  - Glucose
 
 literature:
   - doi: 10.1007/978-3-662-48288-9_9
     title: "Safety Verification and Refutation by k-Invariants and k-Induction"
     year: 2015
-  - doi: 10.1007/978-3-031-30820-8_31
-    title: "2ls: Arrays and Loop Unwinding (Competition Contribution)"
-    year: 2023
+  - doi: 10.1007/978-3-662-49674-9_56
+    title: "2LS for Program Analysis (Competition Contribution)"
+    year: 2016
+  - doi: 10.1145/3121136
+    title: Bit-Precise Procedure-Modular Termination Analysis
+    year: 2018
+  - doi: 10.1007/978-3-319-89963-3_24
+    title: "2LS: Memory Safety and Non-termination - (Competition Contribution)"
+    year: 2018
+  - doi: 10.23919/FMCAD.2018.8603009
+    title: Template-Based Verification of Heap-Manipulating Programs
+    year: 2019
   - doi: 10.1007/978-3-030-45237-7_22
-    title: "2ls: Heap Analysis and Memory Safety (Competition Contribution)"
+    title: "2LS: Heap Analysis and Memory Safety (Competition Contribution)"
     year: 2020
-  - doi: 10.1007/978-3-662-49674-9_56
-    title: "2ls for Program Analysis (Competition Contribution)"
-    year: 2016
+  - doi: 10.1007/978-3-031-30820-8_31
+    title: "2LS: Arrays and Loop Unwinding (Competition Contribution)"
+    year: 2023
+  - doi: 10.48550/arXiv.2302.02380
+    title: "2LS for Program Analysis"
+    year: 2023
+  - doi: 10.1007/978-3-031-56222-8_12
+    title: Template-Based Verification of Array-Manipulating Programs
+    year: 2024

fm_weck/resources/fm_tools/aise.yml

@@ -1,5 +1,8 @@
 id: aise
 name: aise
+description: |
+  AISE is a software verifer that verifes C programs with respect to reachability properties. 
+  The key idea of AISE is to synergize symbolic execution (SE) and abstract interpretation (AI).
 input_languages:
   - C
 project_url: https://github.com/zbchen/aise-verifier
@@ -50,7 +53,9 @@ competition_participations:
 techniques:
   - Symbolic Execution
 
-frameworks_solvers: []
+frameworks_solvers:
+  - CVC
+  - Z3
 
 literature:
   - doi: 10.1007/978-3-031-57256-2_19