fm-weck 1.4.7__py3-none-any.whl → 1.5.0__py3-none-any.whl

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

@@ -0,0 +1,28 @@
+# 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 pathlib import Path
+
+# replacement strings
+WINDOWS_LINE_ENDING = b"\r\n"
+UNIX_LINE_ENDING = b"\n"
+
+
+def copy_ensuring_unix_line_endings(src: Path, dst: Path) -> None:
+    with open(src, "rb") as src_file:
+        content = src_file.read()
+
+    # Windows ➡ Unix
+    content = content.replace(WINDOWS_LINE_ENDING, UNIX_LINE_ENDING)
+
+    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

fm_weck/grpc_service/fm_weck_client.py

@@ -0,0 +1,148 @@
+# 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 pathlib import Path
+from typing import Tuple
+
+import grpc
+
+from .proto.fm_weck_service_pb2 import (
+    CancelRunRequest,
+    ExpertRunRequest,
+    FileQuery,
+    Property,
+    RunID,
+    RunRequest,
+    ToolType,
+    WaitParameters,
+)
+from .proto.fm_weck_service_pb2_grpc import FmWeckRemoteStub
+
+
+def start_run(stub, tool, prop, c_program):
+    with open(tool[0], "rb") as tool_file, open(prop, "rb") as property_file:
+        tool_bin = tool_file.read()
+        prop_bin = property_file.read()
+
+    tool_data: ToolType = ToolType(tool_version=tool[1], tool_file={"name": "fm-tool.yml", "file": tool_bin})
+    prop_data: Property = Property(property_file={"name": "property.prp", "file": prop_bin})
+    run_info = RunRequest(tool=tool_data, property=prop_data, c_program=c_program, data_model="ILP32")
+    run_id = stub.startRun(run_info)
+
+    return run_id
+
+
+def start_expert_run(stub, tool, command):
+    with open(tool[0], "rb") as tool_file:
+        tool_bin = tool_file.read()
+
+    tool_data: ToolType = ToolType(tool_version=tool[1], tool_file={"name": "fm-tool.yml", "file": tool_bin})
+    expert_run_info = ExpertRunRequest(tool=tool_data, command=command)
+    run_id = stub.startExpertRun(expert_run_info)
+
+    return run_id
+
+
+def cancel_run(stub, run_id, confirmed=True):
+    if confirmed:
+        stub.cancelRun(CancelRunRequest(run_id=run_id, timeout=5, cleanup_on_success=True))
+
+
+def wait_on_run(stub, run_id, timelimit):
+    response = stub.waitOnRun(WaitParameters(run_id=run_id, timeout=timelimit))
+
+    if not response:
+        print("Server timed out or returned no files.")
+        exit(1)
+
+    if response.error:
+        print(response.error, ": Error occurred on the server side.")
+        exit(response.error)
+    elif response.timeout:
+        print("Run timed out.")
+        exit(1)
+
+    if not response.run_result.success:
+        print("There was an error running the tool.")
+        exit(1)
+
+    print()
+    print(response.run_result.output)
+    if response.run_result.filenames:
+        print("The run produced the following files:")
+        print(response.run_result.filenames)
+        print(
+            "\nFiles can be obtained by running:\nfm-weck query-files [-h] --host HOST [--timelimit TIMELIMIT]"
+            "[--output-path OUTPUT_PATH] RUN-ID [files ...]"
+        )
+    else:
+        print("The run produced no files.")
+    print()
+
+    return response
+
+
+def query_files(host: str, run_id: str, file_names: str, timelimit: int, output_path: Path):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = RunID(run_id=run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+        request = FileQuery(filenames=file_names, run_id=run_id)
+        responses = stub.queryFiles(request)
+
+        output_path = output_path / "fm_weck_server_files" / run_id.run_id
+        output_path.mkdir(exist_ok=True, parents=True)
+        for response in responses:
+            with open(output_path / response.name, "wb") as output_file:
+                output_file.write(response.file)
+
+
+def client_run(tool: Tuple[Path, str], host: str, prop: Path, files: list[Path], timelimit: int):
+    with open(files[0], "rb") as c_file:
+        c_program = c_file.read()
+
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = start_run(stub, tool, prop, c_program)
+        print("Run ID: ", run_id.run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+
+def client_expert_run(tool: Tuple[Path, str], host: str, command: list[str], timelimit: int):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = start_expert_run(stub, tool, command)
+        print("Run ID: ", run_id.run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+
+def client_get_run(host: str, run_id: str, timelimit: int):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = RunID(run_id=run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)

fm_weck/grpc_service/fm_weck_server.py

@@ -0,0 +1,175 @@
+# 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 concurrent import futures
+from pathlib import Path
+from typing import Generator
+
+import grpc
+
+from fm_weck.exceptions import failure_to_error_code
+
+from . import run_store as RunStore
+from .proto.fm_weck_service_pb2 import (
+    CancelRunRequest,
+    CancelRunResult,
+    CleanUpResponse,
+    ErrorCode,
+    ExpertRunRequest,
+    File,
+    FileQuery,
+    RunID,
+    RunRequest,
+    RunResult,
+    WaitParameters,
+    WaitRunResult,
+)
+from .proto.fm_weck_service_pb2_grpc import FmWeckRemoteServicer, add_FmWeckRemoteServicer_to_server
+from .request_handling import RunHandler, StillRunningError
+from .server_utils import (
+    logger,
+    read_file,
+)
+
+
+class FmWeckRemote(FmWeckRemoteServicer):
+    def startRun(self, request: RunRequest, context) -> RunID:
+        run_handler = RunHandler(request)
+        run_handler.start()
+
+        run_id = RunStore.add_run(run_handler)
+
+        return RunID(run_id=run_id)
+
+    def startExpertRun(self, request: ExpertRunRequest, context) -> RunID:
+        run_handler = RunHandler(request)
+        run_handler.start_expert(request.command)
+
+        run_id = RunStore.add_run(run_handler)
+
+        return RunID(run_id=run_id)
+
+    def cancelRun(self, request: CancelRunRequest, context) -> CancelRunResult:
+        run_handler = RunStore.get_run(request.run_id.run_id)
+
+        if not run_handler:
+            return CancelRunResult(error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        if run_handler.is_running():
+            run_handler.cancel_run()
+            # Wait a short amount of time. For most cases, the run should be canceled by now.
+            try:
+                run_handler.join(request.timeout)
+            except TimeoutError:
+                return CancelRunResult(timeout=True)
+
+        if request.cleanup_on_success:
+            run_handler.cleanup()
+
+        return CancelRunResult(run_result=self._run_result_from_handler(run_handler))
+
+    def waitOnRun(self, request: WaitParameters, context) -> WaitRunResult:
+        logger.info("waitOnRun called for run_id=%s, timeout=%s", request.run_id.run_id, request.timeout)
+        run_handler = RunStore.get_run(request.run_id.run_id)
+
+        if run_handler is None:
+            logger.info("waitOnRun: run not found (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        try:
+            run_handler.join(request.timeout)
+        except TimeoutError:
+            logger.info("waitOnRun: timeout (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(timeout=True)
+
+        if run_handler.ready() and not run_handler._success:
+            failure = run_handler.failure()
+            error_code = failure_to_error_code(failure) if failure else ErrorCode.EC_UNKNOWN_ERROR
+            logger.info("waitOnRun: failed (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(error=error_code)
+
+        logger.info("waitOnRun: success (run_id=%s)", request.run_id.run_id)
+        return WaitRunResult(run_result=self._run_result_from_handler(run_handler))
+
+    def queryFiles(self, query: FileQuery, context) -> Generator[File, None, None]:
+        run_handler = RunStore.get_run(query.run_id.run_id)
+        if run_handler is None:
+            return
+
+        filenames_to_consider = query.filenames or []
+        name_patterns_to_consider = query.name_patterns or []
+
+        for file_name in filenames_to_consider:
+            try:
+                file = run_handler.get_file(file_name)
+                yield self._file_from_path(file)
+            except FileNotFoundError:
+                continue
+
+        for name_pattern in name_patterns_to_consider:
+            for file in run_handler.glob(name_pattern):
+                yield self._file_from_path(file)
+
+        # The empty query returns all files.
+        if len(filenames_to_consider) == 0 and len(name_patterns_to_consider) == 0:
+            files_generator = self._all_files_from_path(run_handler._output_dir)
+            for file in files_generator:
+                yield file
+
+    def cleanupRun(self, request: RunID, context):
+        run_handler = RunStore.get_run(request.run_id)
+
+        if run_handler is None:
+            return CleanUpResponse(success=False, error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        try:
+            run_handler.cleanup()
+        except StillRunningError:
+            return CleanUpResponse(success=False, error=ErrorCode.EC_RUN_NOT_TERMINATED)
+
+        RunStore.remove_run(request.run_id)
+
+        return CleanUpResponse(success=True)
+
+    @staticmethod
+    def _file_from_path(file_path: str | Path) -> File:
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        return File(name=file_path.name, file=read_file(file_path))
+
+    @staticmethod
+    def _all_files_from_path(directory_path: str | Path):
+        if isinstance(directory_path, str):
+            directory_path = Path(directory_path)
+
+        for file_path in directory_path.rglob("*"):
+            if file_path.is_file():
+                yield FmWeckRemote._file_from_path(file_path)
+
+    @staticmethod
+    def _run_result_from_handler(run_handler: RunHandler) -> RunResult:
+        return RunResult(
+            run_id=RunID(run_id=run_handler.run_id),
+            success=run_handler.ready() and run_handler.successful(),
+            output=run_handler.output,
+            filenames=run_handler.output_files,
+        )
+
+
+def serve(ipaddr: str, port: str):
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    add_FmWeckRemoteServicer_to_server(FmWeckRemote(), server)
+    server.add_insecure_port(f"{ipaddr}:{port}")
+    server.start()
+    logger.info("Server started, listening on " + port)
+    try:
+        server.wait_for_termination()
+    except KeyboardInterrupt:
+        logger.info("Shutting down the server...")
+        server.stop(grace=0)
+        logger.info("Server successfully shut down.")

fm_weck/grpc_service/proto/fm_weck_service.proto

@@ -0,0 +1,139 @@
+// 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
+
+syntax = "proto3";
+
+// This service runs fm-weck remotely.
+
+service FmWeckRemote {
+    // Runs a verification task for a given C program.
+    rpc startRun(RunRequest) returns (RunID) {}
+
+    // Runs a tool in expert mode
+    rpc startExpertRun(ExpertRunRequest) returns (RunID) {}
+
+    // Cancels a previously started run.
+    rpc cancelRun(CancelRunRequest) returns (CancelRunResult) {}
+
+    // Cleans up files of a finished run.
+    rpc cleanupRun(RunID) returns (CleanUpResponse) {}
+
+    // Gets the result of a previously started run using its unique ID.
+    rpc waitOnRun(WaitParameters) returns (WaitRunResult) {}
+
+    // Query for a number of result files.
+    rpc queryFiles(FileQuery) returns (stream File) {}
+}
+
+message ToolType {
+  optional string tool_version = 1;
+  oneof tool_data {
+    File tool_file = 2;
+    string tool_id = 3;
+  }
+}
+
+message Property {
+  oneof property {
+    string property_id = 1;
+    File property_file = 2;
+  }
+}
+
+message RunRequest {
+  ToolType tool = 1;
+  Property property = 2;
+  bytes c_program = 4;
+  string data_model = 5;
+}
+
+message ExpertRunRequest{
+  ToolType tool = 1;
+  repeated string command = 2;
+  }
+
+message RunResult {
+  RunID run_id = 1;
+  // Whether the run was successful or terminated with an error
+  bool success = 2;
+  // The output produced by fm-weck
+  string output = 3;
+  // List of files produced by the run; may be empty
+  repeated string filenames = 4;
+}
+
+message WaitRunResult {
+  // Whether the request has timed out or not
+  oneof result {
+    bool timeout = 1;
+    ErrorCode error = 2;
+    RunResult run_result = 3;
+  }
+}
+
+message CancelRunRequest {
+  RunID run_id = 1;
+  // Timeout in seconds to wait for completion of the cancellation
+  uint32 timeout = 2;
+  // If true, the run is cleaned up on the server side
+  optional bool cleanup_on_success = 3;
+}
+
+message CancelRunResult {
+  oneof result {
+    // Whether the could be canceled completely
+    // or is still shutting down. 
+    // If True, then the run is canceled on the server side, but complete shutdown may take some time.
+    // Call waitOnRun if the termination must be confirmed.
+    bool timeout = 1;
+    ErrorCode error = 2;
+    RunResult run_result = 3;
+  }
+}
+
+enum ErrorCode {
+  // The run is not terminated yet
+  EC_RUN_NOT_TERMINATED = 0;
+  EC_RUN_NOT_FOUND = 1;
+  EC_RUN_CANCELLED = 2;
+  EC_RUN_FAILED = 3;
+  EC_UNKNOWN_ERROR = 4;
+}
+
+message CleanUpResponse {
+  // If cleanup was successful, this field is true
+  // Then no errors are reported.
+  bool success = 1;
+  // If success is false, this field contains the error code
+  optional ErrorCode error = 2;
+}
+
+message RunID {
+  string run_id = 1;
+}
+
+message WaitParameters {
+  //Timeout in seconds to wait for the run to finish
+  uint32 timeout = 1;
+  RunID run_id = 2;
+}
+
+message FileQuery {
+  // If the run_id does not exist, the server will return an empty stream.
+  RunID run_id = 3;
+  
+  // Non existent files are ignored.
+  repeated string filenames = 1;
+  repeated string name_patterns = 2;
+}
+
+message File {
+  string name = 1;
+  bytes file = 2;
+}
+
+message Empty {}

fm_weck/grpc_service/proto/fm_weck_service_pb2.py

@@ -0,0 +1,73 @@
+# 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
+
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: fm_weck_service.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'fm_weck_service.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66m_weck_service.proto\"r\n\x08ToolType\x12\x19\n\x0ctool_version\x18\x01 \x01(\tH\x01\x88\x01\x01\x12\x1a\n\ttool_file\x18\x02 \x01(\x0b\x32\x05.FileH\x00\x12\x11\n\x07tool_id\x18\x03 \x01(\tH\x00\x42\x0b\n\ttool_dataB\x0f\n\r_tool_version\"M\n\x08Property\x12\x15\n\x0bproperty_id\x18\x01 \x01(\tH\x00\x12\x1e\n\rproperty_file\x18\x02 \x01(\x0b\x32\x05.FileH\x00\x42\n\n\x08property\"i\n\nRunRequest\x12\x17\n\x04tool\x18\x01 \x01(\x0b\x32\t.ToolType\x12\x1b\n\x08property\x18\x02 \x01(\x0b\x32\t.Property\x12\x11\n\tc_program\x18\x04 \x01(\x0c\x12\x12\n\ndata_model\x18\x05 \x01(\t\"<\n\x10\x45xpertRunRequest\x12\x17\n\x04tool\x18\x01 \x01(\x0b\x32\t.ToolType\x12\x0f\n\x07\x63ommand\x18\x02 \x03(\t\"W\n\tRunResult\x12\x16\n\x06run_id\x18\x01 \x01(\x0b\x32\x06.RunID\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x0e\n\x06output\x18\x03 \x01(\t\x12\x11\n\tfilenames\x18\x04 \x03(\t\"k\n\rWaitRunResult\x12\x11\n\x07timeout\x18\x01 \x01(\x08H\x00\x12\x1b\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x12 \n\nrun_result\x18\x03 \x01(\x0b\x32\n.RunResultH\x00\x42\x08\n\x06result\"s\n\x10\x43\x61ncelRunRequest\x12\x16\n\x06run_id\x18\x01 \x01(\x0b\x32\x06.RunID\x12\x0f\n\x07timeout\x18\x02 \x01(\r\x12\x1f\n\x12\x63leanup_on_success\x18\x03 \x01(\x08H\x00\x88\x01\x01\x42\x15\n\x13_cleanup_on_success\"m\n\x0f\x43\x61ncelRunResult\x12\x11\n\x07timeout\x18\x01 \x01(\x08H\x00\x12\x1b\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x12 \n\nrun_result\x18\x03 \x01(\x0b\x32\n.RunResultH\x00\x42\x08\n\x06result\"L\n\x0f\x43leanUpResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x1e\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x88\x01\x01\x42\x08\n\x06_error\"\x17\n\x05RunID\x12\x0e\n\x06run_id\x18\x01 \x01(\t\"9\n\x0eWaitParameters\x12\x0f\n\x07timeout\x18\x01 \x01(\r\x12\x16\n\x06run_id\x18\x02 \x01(\x0b\x32\x06.RunID\"M\n\tFileQuery\x12\x16\n\x06run_id\x18\x03 \x01(\x0b\x32\x06.RunID\x12\x11\n\tfilenames\x18\x01 \x03(\t\x12\x15\n\rname_patterns\x18\x02 \x03(\t\"\"\n\x04\x46ile\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04\x66ile\x18\x02 \x01(\x0c\"\x07\n\x05\x45mpty*{\n\tErrorCode\x12\x19\n\x15\x45\x43_RUN_NOT_TERMINATED\x10\x00\x12\x14\n\x10\x45\x43_RUN_NOT_FOUND\x10\x01\x12\x14\n\x10\x45\x43_RUN_CANCELLED\x10\x02\x12\x11\n\rEC_RUN_FAILED\x10\x03\x12\x14\n\x10\x45\x43_UNKNOWN_ERROR\x10\x04\x32\x93\x02\n\x0c\x46mWeckRemote\x12!\n\x08startRun\x12\x0b.RunRequest\x1a\x06.RunID\"\x00\x12-\n\x0estartExpertRun\x12\x11.ExpertRunRequest\x1a\x06.RunID\"\x00\x12\x32\n\tcancelRun\x12\x11.CancelRunRequest\x1a\x10.CancelRunResult\"\x00\x12(\n\ncleanupRun\x12\x06.RunID\x1a\x10.CleanUpResponse\"\x00\x12.\n\twaitOnRun\x12\x0f.WaitParameters\x1a\x0e.WaitRunResult\"\x00\x12#\n\nqueryFiles\x12\n.FileQuery\x1a\x05.File\"\x00\x30\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'fm_weck_service_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ERRORCODE']._serialized_start=1101
+  _globals['_ERRORCODE']._serialized_end=1224
+  _globals['_TOOLTYPE']._serialized_start=25
+  _globals['_TOOLTYPE']._serialized_end=139
+  _globals['_PROPERTY']._serialized_start=141
+  _globals['_PROPERTY']._serialized_end=218
+  _globals['_RUNREQUEST']._serialized_start=220
+  _globals['_RUNREQUEST']._serialized_end=325
+  _globals['_EXPERTRUNREQUEST']._serialized_start=327
+  _globals['_EXPERTRUNREQUEST']._serialized_end=387
+  _globals['_RUNRESULT']._serialized_start=389
+  _globals['_RUNRESULT']._serialized_end=476
+  _globals['_WAITRUNRESULT']._serialized_start=478
+  _globals['_WAITRUNRESULT']._serialized_end=585
+  _globals['_CANCELRUNREQUEST']._serialized_start=587
+  _globals['_CANCELRUNREQUEST']._serialized_end=702
+  _globals['_CANCELRUNRESULT']._serialized_start=704
+  _globals['_CANCELRUNRESULT']._serialized_end=813
+  _globals['_CLEANUPRESPONSE']._serialized_start=815
+  _globals['_CLEANUPRESPONSE']._serialized_end=891
+  _globals['_RUNID']._serialized_start=893
+  _globals['_RUNID']._serialized_end=916
+  _globals['_WAITPARAMETERS']._serialized_start=918
+  _globals['_WAITPARAMETERS']._serialized_end=975
+  _globals['_FILEQUERY']._serialized_start=977
+  _globals['_FILEQUERY']._serialized_end=1054
+  _globals['_FILE']._serialized_start=1056
+  _globals['_FILE']._serialized_end=1090
+  _globals['_EMPTY']._serialized_start=1092
+  _globals['_EMPTY']._serialized_end=1099
+  _globals['_FMWECKREMOTE']._serialized_start=1227
+  _globals['_FMWECKREMOTE']._serialized_end=1502
+# @@protoc_insertion_point(module_scope)