rbx.cp 0.13.4__py3-none-any.whl → 0.13.5__py3-none-any.whl

rbx/grading/caching.py

@@ -88,15 +88,26 @@ def _check_digests(artifacts_list: List[GradingArtifacts]):
             produced.add(id(output.digest))
 
 
-def _build_digest_list(artifacts_list: List[GradingArtifacts]) -> List[DigestHolder]:
-    digests = []
+def _build_artifact_with_digest_list(
+    artifacts_list: List[GradingArtifacts],
+) -> List[GradingFileOutput]:
+    outputs = []
     for artifacts in artifacts_list:
         for output in artifacts.outputs:
             if output.hash and output.digest is None:
                 output.digest = DigestHolder()
             if output.digest is None:
                 continue
-            digests.append(output.digest)
+            outputs.append(output)
+    return outputs
+
+
+def _build_digest_list(artifacts_list: List[GradingArtifacts]) -> List[DigestHolder]:
+    outputs = _build_artifact_with_digest_list(artifacts_list)
+    digests = []
+    for output in outputs:
+        assert output.digest is not None
+        digests.append(output.digest)
     return digests
 
 
@@ -115,27 +126,44 @@ def _build_fingerprint_list(
     return fingerprints
 
 
-def _maybe_check_integrity(output: GradingFileOutput):
+def _maybe_check_integrity(output: GradingFileOutput, integrity_digest: str):
     if not grading_context.should_check_integrity():
         return
-    if output.dest is None or not output.dest.is_symlink():
+    if not output.hash:
+        return
+    if output.dest is None or not output.dest.is_symlink() or not output.dest.is_file():
+        # Only makes sense if the file EXISTS and IS A SYMLINK pointing to an
+        # EXISTING storage file.
+        # If the storage file ceases to exist, we can simply evict from the cache.
         return
-    if output.digest is None or output.digest.value is None:
+    if output.digest is None:
         return
     with output.dest.open('rb') as f:
-        fingerprint = digest_cooperatively(f)
-    if fingerprint != output.digest.value:
+        output_digest = digest_cooperatively(f)
+    if output_digest != integrity_digest:
         raise ValueError(
             f'Cache was tampered with, file {output.dest} has changed since it was cached.\nPlease run `rbx clean` to reset the cache.'
         )
 
 
-def _build_output_fingerprint_list(artifacts_list: List[GradingArtifacts]) -> List[str]:
+def _check_digest_list_integrity(
+    artifacts_list: List[GradingArtifacts], integrity_digests: List[Optional[str]]
+):
+    outputs = _build_artifact_with_digest_list(artifacts_list)
+    assert len(outputs) == len(integrity_digests)
+    for output, integrity_digest in zip(outputs, integrity_digests):
+        assert output.digest is not None
+        if integrity_digest is None:
+            continue
+        _maybe_check_integrity(output, integrity_digest)
+
+
+def _build_output_fingerprint_list(
+    artifacts_list: List[GradingArtifacts],
+) -> List[str]:
     fingerprints = []
     for artifacts in artifacts_list:
         for output in artifacts.outputs:
-            if output.hash:
-                _maybe_check_integrity(output)
             if output.dest is None or output.intermediate or output.hash:
                 continue
             if not output.dest.is_file():
@@ -160,7 +188,10 @@ def _build_cache_fingerprint(
 ) -> CacheFingerprint:
     digests = [digest.value for digest in _build_digest_list(artifacts_list)]
     fingerprints = _build_fingerprint_list(artifacts_list, cacher)
-    output_fingerprints = _build_output_fingerprint_list(artifacts_list)
+    output_fingerprints = _build_output_fingerprint_list(
+        artifacts_list,
+    )
+
     logs = _build_logs_list(artifacts_list)
     return CacheFingerprint(
         digests=digests,
@@ -389,7 +420,10 @@ class DependencyCache:
         if fingerprint is None:
             return False
 
-        reference_fingerprint = _build_cache_fingerprint(artifact_list, self.cacher)
+        reference_fingerprint = _build_cache_fingerprint(
+            artifact_list,
+            self.cacher,
+        )
 
         if not _fingerprints_match(fingerprint, reference_fingerprint):
             self._evict_from_cache(key)
@@ -399,6 +433,11 @@ class DependencyCache:
             self._evict_from_cache(key)
             return False
 
+        # Check whether existing storage files were not tampered with.
+        _check_digest_list_integrity(
+            artifact_list,
+            fingerprint.digests,
+        )
         reference_digests = _build_digest_list(artifact_list)
 
         # Apply digest changes.
@@ -422,6 +461,10 @@ class DependencyCache:
         for logs, reference_logs in zip(fingerprint.logs, reference_fingerprint.logs):
             if logs.run is not None:
                 reference_logs.run = logs.run.model_copy(deep=True)
+            if logs.interactor_run is not None:
+                reference_logs.interactor_run = logs.interactor_run.model_copy(
+                    deep=True
+                )
             if logs.preprocess is not None:
                 reference_logs.preprocess = [
                     log.model_copy(deep=True) for log in logs.preprocess
@@ -448,4 +491,11 @@ class DependencyCache:
         if not are_artifacts_ok(artifact_list, self.cacher):
             return
 
-        self._store_in_cache(key, _build_cache_fingerprint(artifact_list, self.cacher))
+        reference_fingerprint = _build_cache_fingerprint(
+            artifact_list,
+            self.cacher,
+        )
+        self._store_in_cache(
+            key,
+            reference_fingerprint,
+        )

rbx/grading/judge/program.py

@@ -0,0 +1,268 @@
+import dataclasses
+import os
+import pathlib
+import resource
+import subprocess
+import sys
+import threading
+import typing
+from enum import Enum
+from time import monotonic
+from typing import IO, Any, Dict, List, Optional, Union
+
+import psutil
+
+from rbx.utils import PathOrStr
+
+FileLike = Union[PathOrStr, IO[bytes], int]
+
+
+def _maybe_close_files(files):
+    for fobj in files:
+        if isinstance(fobj, int):
+            continue
+        fobj.close()
+
+
+def _is_pathlike(obj: Any) -> bool:
+    return isinstance(obj, str) or isinstance(obj, pathlib.Path)
+
+
+@dataclasses.dataclass
+class ProgramIO:
+    input: FileLike = subprocess.PIPE
+    output: FileLike = subprocess.PIPE
+    stderr: FileLike = subprocess.PIPE
+
+    def get_file_objects(self):
+        if isinstance(self.input, int):
+            input_fobj = self.input
+        elif _is_pathlike(self.input):
+            input_fobj = pathlib.Path(typing.cast(str, self.input)).open('r')
+        else:
+            input_fobj = typing.cast(IO[bytes], self.input)
+        if isinstance(self.output, int):
+            output_fobj = self.output
+        elif _is_pathlike(self.output):
+            output_path = pathlib.Path(typing.cast(str, self.output))
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_fobj = output_path.open('w')
+        else:
+            output_fobj = typing.cast(IO[bytes], self.output)
+        if isinstance(self.stderr, int):
+            stderr_fobj = self.stderr
+        elif _is_pathlike(self.stderr):
+            stderr_path = pathlib.Path(typing.cast(str, self.stderr))
+            stderr_path.parent.mkdir(parents=True, exist_ok=True)
+            stderr_fobj = stderr_path.open('w')
+        else:
+            stderr_fobj = typing.cast(IO[bytes], self.stderr)
+        return input_fobj, output_fobj, stderr_fobj
+
+
+@dataclasses.dataclass
+class ProgramPipes:
+    input: Optional[IO[bytes]] = None
+    output: Optional[IO[bytes]] = None
+    stderr: Optional[IO[bytes]] = None
+
+
+@dataclasses.dataclass
+class ProgramParams:
+    io: ProgramIO = dataclasses.field(default_factory=ProgramIO)
+    chdir: Optional[pathlib.Path] = None
+    time_limit: Optional[float] = None  # seconds
+    wall_time_limit: Optional[float] = None  # seconds
+    memory_limit: Optional[int] = None  # megabytes
+    fs_limit: Optional[int] = None  # kilobytes
+    env: Dict[str, str] = dataclasses.field(default_factory=dict)
+    pgid: Optional[int] = None
+
+
+def get_preexec_fn(params: ProgramParams):
+    def preexec_fn():
+        os.setpgid(0, params.pgid or 0)
+        if params.time_limit is not None:
+            time_limit_in_ms = int(params.time_limit * 1000)
+            rlimit_cpu = int((time_limit_in_ms + 999) // 1000)
+            resource.setrlimit(resource.RLIMIT_CPU, (rlimit_cpu, rlimit_cpu + 1))
+        if params.fs_limit is not None:
+            fs_limit = params.fs_limit * 1024  # in bytes
+            resource.setrlimit(resource.RLIMIT_FSIZE, (fs_limit + 1, fs_limit * 2))
+
+    return preexec_fn
+
+
+def get_memory_usage(ru: resource.struct_rusage) -> int:
+    if sys.platform == 'darwin':
+        return ru.ru_maxrss // 1024 + ru.ru_ixrss
+    return ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss
+
+
+def get_cpu_time(ru: resource.struct_rusage) -> float:
+    return ru.ru_utime + ru.ru_stime
+
+
+def get_file_sizes(io: ProgramIO):
+    return _get_file_size(io.output) + _get_file_size(io.stderr)
+
+
+def _get_file_size(filename: Optional[FileLike]) -> int:
+    if filename is None or not _is_pathlike(filename):
+        return 0
+    path = pathlib.Path(typing.cast(str, filename))
+    if not path.is_file():
+        return 0
+    return path.stat().st_size
+
+
+class ProgramCode(Enum):
+    RE = 'RE'
+    SG = 'SG'
+    TO = 'TO'
+    WT = 'WT'
+    ML = 'ML'
+    OL = 'OL'
+    TE = 'TE'
+
+
+@dataclasses.dataclass
+class ProgramResult:
+    exitcode: int
+    wall_time: float
+    cpu_time: float
+    memory_used: int
+    file_sizes: int
+    program_codes: List[ProgramCode]
+    killing_signal: Optional[int] = None
+    alarm_msg: Optional[str] = None
+
+
+class Program:
+    def __init__(self, command: List[str], params: ProgramParams):
+        self.command = command
+        self.params = params
+        self.popen: Optional[subprocess.Popen] = None
+        self._files = []
+
+        self._stop_wall_handler = threading.Event()
+        self._stop_alarm_handler = threading.Event()
+        self._alarm_msg = ''
+
+        self._run()
+
+    @property
+    def pipes(self) -> ProgramPipes:
+        assert self.popen is not None
+        return ProgramPipes(
+            input=self.popen.stdin,
+            output=self.popen.stdout,
+            stderr=self.popen.stderr,
+        )
+
+    @property
+    def pid(self) -> int:
+        assert self.popen is not None
+        return self.popen.pid
+
+    def _kill_process(self):
+        if self.popen is not None:
+            self.popen.kill()
+
+    def _handle_wall(self):
+        if self._stop_wall_handler.wait(self.params.wall_time_limit):
+            return
+        self._stop_alarm_handler.set()
+        self._alarm_msg = 'wall timelimit'
+        self._kill_process()
+
+    def _handle_alarm(self):
+        if self._stop_alarm_handler.wait(0.3):
+            return
+        try:
+            process = psutil.Process(self.pid)
+            if self.params.time_limit is not None:
+                times = process.cpu_times()
+                cpu_time = times.user + times.system
+                if cpu_time > self.params.time_limit:
+                    self._alarm_msg = 'timelimit'
+                    self._kill_process()
+            if self.params.memory_limit is not None:
+                memory_info = process.memory_info()
+                memory_used = memory_info.rss
+                if memory_used > self.params.memory_limit * 1024 * 1024:
+                    self._alarm_msg = 'memorylimit'
+                    self._kill_process()
+            self._stop_alarm_handler.clear()
+            self._handle_alarm()
+        except psutil.NoSuchProcess:
+            return
+
+    def _run(self):
+        self._files = self.params.io.get_file_objects()
+        self.popen = subprocess.Popen(
+            self.command,
+            stdin=self._files[0],
+            stdout=self._files[1],
+            stderr=self._files[2],
+            cwd=self.params.chdir,
+            env={**os.environ, **self.params.env},
+            preexec_fn=get_preexec_fn(self.params),
+            close_fds=True,
+        )
+        self.start_time = monotonic()
+
+        threading.Thread(target=self._handle_wall, daemon=True).start()
+        threading.Thread(target=self._handle_alarm, daemon=True).start()
+
+    def process_exit(self, exitstatus, ru) -> ProgramResult:
+        wall_time = monotonic() - self.start_time
+        cpu_time = get_cpu_time(ru)
+        memory_used = get_memory_usage(ru)
+        file_sizes = get_file_sizes(self.params.io)
+        exitcode = os.waitstatus_to_exitcode(exitstatus)
+        killing_signal = None
+        program_codes = []
+
+        if exitcode < 0:
+            killing_signal = -exitcode
+            program_codes.append(ProgramCode.SG)
+        if exitcode > 0:
+            program_codes.append(ProgramCode.RE)
+        if self.params.time_limit is not None and (
+            cpu_time > self.params.time_limit or -exitcode == 24
+        ):
+            program_codes.append(ProgramCode.TO)
+        if (
+            self.params.wall_time_limit is not None
+            and wall_time > self.params.wall_time_limit
+        ):
+            program_codes.append(ProgramCode.WT)
+            program_codes.append(ProgramCode.TO)
+        if (
+            self.params.memory_limit is not None
+            and memory_used > self.params.memory_limit * 1024 * 1024
+            or self._alarm_msg == 'memorylimit'
+        ):
+            program_codes.append(ProgramCode.ML)
+        if (
+            self.params.fs_limit is not None
+            and file_sizes > self.params.fs_limit * 1024
+        ):
+            program_codes.append(ProgramCode.OL)
+
+        return ProgramResult(
+            exitcode=exitcode,
+            wall_time=wall_time,
+            cpu_time=cpu_time,
+            memory_used=memory_used,
+            file_sizes=file_sizes,
+            program_codes=program_codes,
+            killing_signal=killing_signal,
+            alarm_msg=self._alarm_msg or None,
+        )
+
+    def wait(self):
+        assert self.popen is not None
+        _, exitstatus, ru = os.wait4(self.pid, 0)
+        return self.process_exit(exitstatus, ru)

rbx/grading/judge/sandbox.py

@@ -3,16 +3,16 @@ import asyncio
 import collections
 import dataclasses
 import io
+import json
 import logging
 import os
 import pathlib
 import select
-import signal
 import stat
 import subprocess
 import sys
 import typing
-from typing import IO, Any, Dict, List, Optional
+from typing import IO, Any, Dict, List, Optional, Tuple
 
 import pydantic
 
@@ -210,6 +210,22 @@ class SandboxParams(pydantic.BaseModel):
         self.dirs.append(DirectoryMount(src, dest, options))
 
 
+class SandboxLog(pydantic.BaseModel):
+    """A log of the sandbox."""
+
+    params: SandboxParams
+    execution_time: float  # seconds
+    memory_used: int  # bytes
+    exitcode: int
+    exitstatus: str
+    killing_signal: Optional[int] = None
+    exit_index: int = 0
+    other_logs: Dict[str, Any] = pydantic.Field(default_factory=dict)
+
+    def dump_other_logs(self) -> str:
+        return json.dumps(self.other_logs)
+
+
 class SandboxBase(abc.ABC):
     """A base class for all sandboxes, meant to contain common
     resources.
@@ -229,16 +245,12 @@ class SandboxBase(abc.ABC):
     file_cacher: cacher.FileCacher
     name: str
     temp_dir: Optional[pathlib.Path]
-    cmd_file: pathlib.Path
-
-    params: SandboxParams
 
     def __init__(
         self,
         file_cacher: Optional[cacher.FileCacher] = None,
         name: Optional[str] = None,
         temp_dir: Optional[pathlib.Path] = None,
-        params: Optional[SandboxParams] = None,
     ):
         """Initialization.
 
@@ -253,56 +265,7 @@ class SandboxBase(abc.ABC):
         self.file_cacher = file_cacher or cacher.FileCacher(storage.NullStorage())
         self.name = name if name is not None else 'unnamed'
         self.temp_dir = temp_dir
-
-        self.cmd_file = pathlib.PosixPath('commands.log')
-
-        self.params = params or SandboxParams()
-        self.pid = None
-        self.pid_event = Event_ts()
-
-        # Set common environment variables.
-        # Specifically needed by Python, that searches the home for
-        # packages.
-        self.params.set_env['HOME'] = './'
-
-    def set_params(self, params: SandboxParams):
-        """Set the parameters of the sandbox.
-
-        params (SandboxParams): the parameters to set.
-
-        """
-        self.params = params
-
-    def set_multiprocess(self, multiprocess: bool):
-        """Set the sandbox to (dis-)allow multiple threads and processes.
-
-        multiprocess (bool): whether to allow multiple thread/processes or not.
-
-        """
-        if multiprocess:
-            # Max processes is set to 1000 to limit the effect of fork bombs.
-            self.params.max_processes = 1000
-        else:
-            self.params.max_processes = 1
-
-    def get_stats(self) -> str:
-        """Return a human-readable string representing execution time
-        and memory usage.
-
-        return (string): human-readable stats.
-
-        """
-        execution_time = self.get_execution_time()
-        if execution_time is not None:
-            time_str = f'{execution_time:.3f} sec'
-        else:
-            time_str = '(time unknown)'
-        memory_used = self.get_memory_used()
-        if memory_used is not None:
-            mem_str = f'{memory_used / (1024 * 1024):.2f} MB'
-        else:
-            mem_str = '(memory usage unknown)'
-        return f'[{time_str} - {mem_str}]'
+        self.cmd_file = pathlib.PosixPath('__commands__.log')
 
     @abc.abstractmethod
     def get_root_path(self) -> pathlib.Path:
@@ -313,101 +276,6 @@ class SandboxBase(abc.ABC):
         """
         pass
 
-    @abc.abstractmethod
-    def get_execution_time(self) -> Optional[float]:
-        """Return the time spent in the sandbox.
-
-        return (float): time spent in the sandbox.
-
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_memory_used(self) -> Optional[int]:
-        """Return the memory used by the sandbox.
-
-        return (int): memory used by the sandbox (in bytes).
-
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_killing_signal(self) -> int:
-        """Return the signal that killed the sandboxed process.
-
-        return (int): offending signal, or 0.
-
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_exit_status(self) -> str:
-        """Get information about how the sandbox terminated.
-
-        return (string): the main reason why the sandbox terminated.
-
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_exit_code(self) -> int:
-        """Return the exit code of the sandboxed process.
-
-        return (int): exitcode, or 0.
-
-        """
-        pass
-
-    def set_pid(self, pid: int):
-        """Set the PID of the sandboxed process.
-
-        pid (int): the PID of the sandboxed process.
-
-        """
-        self.pid = pid
-        self.pid_event.set()
-
-    async def get_pid(self) -> int:
-        """Return the PID of the sandboxed process.
-
-        Blocks until the PID is set.
-
-        return (int): the PID of the sandboxed process.
-
-        """
-        await self.pid_event.wait()
-        assert self.pid is not None
-        return self.pid
-
-    def clear_pid(self):
-        """Clear the PID of the sandboxed process."""
-        self.pid_event.clear()
-        self.pid = None
-
-    def use_pgid(self) -> bool:
-        """Whether the sandbox supports process groups."""
-        return False
-
-    @abc.abstractmethod
-    def get_detailed_logs(self) -> str:
-        """Return the detailed logs of the sandbox.
-
-        return (string): the detailed logs of the sandbox.
-
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_human_exit_description(self) -> str:
-        """Get the status of the sandbox and return a human-readable
-        string describing it.
-
-        return (string): human-readable explaination of why the
-                         sandbox terminated.
-
-        """
-        pass
-
     def use_soft_timeout(self) -> bool:
         return False
 
@@ -702,52 +570,24 @@ class SandboxBase(abc.ABC):
         ]
 
     @abc.abstractmethod
-    def execute_without_std(
+    def run(
         self,
         command: List[str],
-    ) -> bool:
-        """Execute the given command in the sandbox using
-        subprocess.Popen and discarding standard input, output and
-        error. More specifically, the standard input gets closed just
-        after the execution has started; standard output and error are
-        read until the end, in a way that prevents the execution from
-        being blocked because of insufficient buffering.
-
-        command ([string]): executable filename and arguments of the
-            command.
-        wait (bool): True if this call is blocking, False otherwise
-
-        return (bool|Popen): if the call is blocking, then return True
-            if the sandbox didn't report errors (caused by the sandbox
-            itself), False otherwise; if the call is not blocking,
-            return the Popen object from subprocess.
-
-        """
+        params: SandboxParams,
+    ) -> SandboxLog:
         pass
 
     @abc.abstractmethod
-    def hydrate_logs(self):
-        """Fetch the results of the execution and hydrate logs.
-
-        This method should be called after the execution has
-        terminated, to hydrate logs and stuff.
-        """
+    def run_communication(
+        self,
+        command: List[str],
+        params: SandboxParams,
+        interactor_command: List[str],
+        interactor_params: SandboxParams,
+        merged_capture: Optional[pathlib.Path] = None,
+    ) -> Tuple[SandboxLog, SandboxLog]:
         pass
 
-    def translate_box_exitcode(self, exitcode: int) -> bool:
-        """Translate the sandbox exit code to a boolean sandbox success.
-
-        _ (int): the exit code of the sandbox.
-
-        return (bool): False if the sandbox had an error, True if it
-            terminated correctly (regardless of what the internal process
-            did).
-
-        """
-        # SIGTERM can be safely ignored, just in case it leaks away from
-        # the sandbox.
-        return exitcode == 0 or exitcode == -signal.SIGTERM
-
     @abc.abstractmethod
     def initialize(self):
         """Initialize the sandbox.
@@ -779,9 +619,6 @@ class SandboxBase(abc.ABC):
         """
         pass
 
-    def debug_message(self) -> Any:
-        return 'N/A'
-
 
 class Truncator(io.RawIOBase):
     """Wrap a file-like object to simulate truncation.