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

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -9,17 +9,42 @@ import signal
 import subprocess
 import sys
 import tempfile
-from typing import Any, Dict, List, Optional
+import typing
+from typing import List, Optional, Tuple
 
 from rbx import utils
 from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.program import (
+    FileLike,
+    Program,
+    ProgramCode,
+    ProgramIO,
+    ProgramParams,
+    ProgramResult,
+)
 from rbx.grading.judge.sandbox import (
     SandboxBase,
+    SandboxLog,
     SandboxParams,
 )
 
 logger = logging.getLogger(__name__)
 
+TEE_CODE = R"""
+import sys
+c = sys.argv[1]
+new = True
+while True:
+    l = sys.stdin.read(1)
+    if l=='': break
+    sys.stdout.write(l)
+    sys.stdout.flush()
+    if new: sys.stderr.write(c)
+    sys.stderr.write(l)
+    sys.stderr.flush()
+    new = l=='\n'
+"""
+
 
 class StupidSandbox(SandboxBase):
     """A stupid sandbox implementation. It has very few features and
@@ -31,16 +56,12 @@ class StupidSandbox(SandboxBase):
     """
 
     exec_num: int
-    popen: Optional[subprocess.Popen]
-    returncode: Optional[int]
-    log: Optional[Dict[str, str]]
 
     def __init__(
         self,
         file_cacher: Optional[FileCacher] = None,
         name: Optional[str] = None,
         temp_dir: Optional[pathlib.Path] = None,
-        params: Optional[SandboxParams] = None,
     ):
         """Initialization.
 
@@ -49,7 +70,7 @@ class StupidSandbox(SandboxBase):
         """
         if not temp_dir:
             temp_dir = pathlib.Path(tempfile.gettempdir())
-        SandboxBase.__init__(self, file_cacher, name, temp_dir, params)
+        SandboxBase.__init__(self, file_cacher, name, temp_dir)
 
         # Make box directory
         self.initialize()
@@ -68,56 +89,6 @@ class StupidSandbox(SandboxBase):
         # Box parameters
         self.chdir = self._path
 
-    def get_timeit_executable(self) -> pathlib.Path:
-        with importlib.resources.as_file(
-            importlib.resources.files('rbx')
-            / 'grading'
-            / 'judge'
-            / 'sandboxes'
-            / 'timeit.py'
-        ) as file:
-            return file
-
-    def get_timeit_args(self) -> List[str]:
-        args = []
-        if self.params.timeout:
-            timeout_in_s = self.params.timeout / 1000
-            if self.params.extra_timeout:
-                timeout_in_s += self.params.extra_timeout / 1000
-            args.append(f'-t{timeout_in_s:.3f}')
-        if self.params.wallclock_timeout:
-            walltimeout_in_s = self.params.wallclock_timeout / 1000
-            args.append(f'-w{walltimeout_in_s:.3f}')
-        if self.params.address_space:
-            args.append(f'-m{self.params.address_space}')
-        if self.params.fsize:
-            args.append(f'-f{self.params.fsize}')
-        if self.chdir:
-            args.append(f'-c{self.chdir}')
-        if self.use_pgid() and self.params.pgid is not None:
-            args.append(f'-g{self.params.pgid}')
-
-        file_args = []
-        if self.params.stdin_file:
-            file_args.append(f'-i{self.params.stdin_file}')
-        if self.params.stdout_file:
-            file_args.append(f'-o{self.params.stdout_file}')
-        if self.params.stderr_file:
-            file_args.append(f'-e{self.params.stderr_file}')
-        if self.params.reverse_io:
-            file_args.reverse()
-        args.extend(file_args)
-
-        if self.params.timeit_dups:
-            for i, files in self.params.timeit_dups.items():
-                assert i.lower() in ['di', 'do', 'de']
-                for file in files:
-                    args.append(f'-{i}{file}')
-        if self.params.timeit_prefix:
-            args.append(f'-P{self.params.timeit_prefix}')
-
-        return args
-
     def get_root_path(self) -> pathlib.Path:
         """Return the toplevel path of the sandbox.
 
@@ -126,171 +97,153 @@ class StupidSandbox(SandboxBase):
         """
         return self._path
 
-    def get_execution_time(self) -> Optional[float]:
-        """Return the time spent in the sandbox.
-
-        return (float): time spent in the sandbox.
-
-        """
-        if self.log is None:
-            return None
-        return float(self.log['time'])
-
-    def get_execution_wall_clock_time(self) -> Optional[float]:
-        """Return the total time from the start of the sandbox to the
-        conclusion of the task.
-
-        return (float): total time the sandbox was alive.
-
-        """
-        if self.log is None:
-            return None
-        return float(self.log['time-wall'])
-
     def use_soft_timeout(self) -> bool:
         return True
 
-    def use_pgid(self) -> bool:
-        return True
-
-    def get_memory_used(self) -> Optional[int]:
-        """Return the memory used by the sandbox.
-
-        return (int): memory used by the sandbox (in bytes).
-
-        """
-        if self.log is None:
-            return None
-        return int(self.log['mem']) * 1024
-
-    def get_killing_signal(self) -> int:
-        """Return the signal that killed the sandboxed process.
-
-        return (int): offending signal, or 0.
+    def _get_exit_status(self, result: ProgramResult) -> str:
+        if ProgramCode.TE in result.program_codes:
+            return SandboxBase.EXIT_TERMINATED
+        if ProgramCode.WT in result.program_codes:
+            return SandboxBase.EXIT_TIMEOUT_WALL
+        if ProgramCode.TO in result.program_codes:
+            return SandboxBase.EXIT_TIMEOUT
+        if ProgramCode.OL in result.program_codes:
+            return SandboxBase.EXIT_OUTPUT_LIMIT_EXCEEDED
+        if ProgramCode.ML in result.program_codes:
+            return SandboxBase.EXIT_MEMORY_LIMIT_EXCEEDED
+        if ProgramCode.SG in result.program_codes:
+            return SandboxBase.EXIT_SIGNAL
+        if ProgramCode.RE in result.program_codes:
+            return SandboxBase.EXIT_NONZERO_RETURN
+        return SandboxBase.EXIT_OK
+
+    def _get_io(self, params: SandboxParams, pipe_io: bool = False) -> ProgramIO:
+        io = ProgramIO()
+        if params.stdin_file and not pipe_io:
+            io.input = self.relative_path(params.stdin_file)
+        if params.stdout_file and not pipe_io:
+            io.output = self.relative_path(params.stdout_file)
+        if params.stderr_file:
+            io.stderr = self.relative_path(params.stderr_file)
+        return io
+
+    def _get_program_params(self, params: SandboxParams) -> ProgramParams:
+        return ProgramParams(
+            chdir=self.chdir,
+            time_limit=params.timeout / 1000 if params.timeout else None,
+            wall_time_limit=params.wallclock_timeout / 1000
+            if params.wallclock_timeout
+            else None,
+            memory_limit=params.address_space,
+            fs_limit=params.fsize,
+            env=params.set_env,
+            io=self._get_io(params),
+        )
 
-        """
-        assert self.log is not None
-        if 'exit-sig' not in self.log:
-            return 0
-        return int(self.log['exit-sig'])
+    def _get_tee_program_params(self, io: ProgramIO, pgid: int) -> ProgramParams:
+        return ProgramParams(
+            chdir=self.chdir,
+            time_limit=None,
+            wall_time_limit=None,
+            memory_limit=None,
+            io=io,
+            pgid=pgid,
+        )
 
-    def get_status_list(self) -> List[str]:
-        """Reads the sandbox log file, and set and return the status
-        of the sandbox.
+    def _get_sandbox_log(
+        self, result: ProgramResult, params: SandboxParams
+    ) -> SandboxLog:
+        return SandboxLog(
+            params=params.model_copy(deep=True),
+            execution_time=result.wall_time,
+            memory_used=result.memory_used,
+            exitcode=result.exitcode,
+            exitstatus=self._get_exit_status(result),
+            killing_signal=result.killing_signal,
+            other_logs={
+                'program_codes': [code.value for code in result.program_codes],
+                'alarm_msg': result.alarm_msg,
+            },
+        )
 
-        return (list): list of statuses of the sandbox.
+    def _needs_teeing(
+        self,
+        params: SandboxParams,
+        interactor_params: SandboxParams,
+        merged_capture: Optional[pathlib.Path] = None,
+    ) -> bool:
+        return (
+            params.stdout_file is not None
+            or interactor_params.stdout_file is not None
+            or merged_capture is not None
+        )
 
-        """
-        assert self.log is not None
-        if 'status' in self.log:
-            return self.log['status'].split(',')
-        return []
+    def _get_tee_executable(self) -> pathlib.Path:
+        with importlib.resources.as_file(
+            importlib.resources.files('rbx')
+            / 'grading'
+            / 'judge'
+            / 'sandboxes'
+            / 'tee.py'
+        ) as file:
+            return file
 
-    # This sandbox only discriminates between processes terminating
-    # properly or being killed with a signal; all other exceptional
-    # conditions (RAM or CPU limitations, ...) result in some signal
-    # being delivered to the process
-    def get_exit_status(self) -> str:
-        """Get information about how the sandbox terminated.
+    def _get_tee_command(self, char: str, extra: Optional[str] = None) -> List[str]:
+        return [
+            sys.executable,
+            str(utils.abspath(self._get_tee_executable())),
+            char,
+            extra or '/dev/null',
+        ]
 
-        return (string): the main reason why the sandbox terminated.
+    def _get_tee_program(
+        self,
+        char: str,
+        stdin: FileLike,
+        stdout: FileLike,
+        pgid: int,
+        capture: Optional[pathlib.Path] = None,
+        merged_capture: Optional[pathlib.Path] = None,
+    ) -> Program:
+        io = ProgramIO(input=stdin, output=stdout, stderr=subprocess.DEVNULL)
+        if merged_capture:
+            io.stderr = self.relative_path(merged_capture).open('ab')
+        return Program(
+            self._get_tee_command(
+                char, str(self.relative_path(capture)) if capture else None
+            ),
+            self._get_tee_program_params(io, pgid),
+        )
 
-        """
-        if self.returncode is not None and not self.translate_box_exitcode(
-            self.returncode
-        ):
-            return self.EXIT_SANDBOX_ERROR
-        status_list = self.get_status_list()
-        if 'TE' in status_list:
-            return self.EXIT_TERMINATED
-        if 'WT' in status_list:
-            return self.EXIT_TIMEOUT_WALL
-        if 'TO' in status_list:
-            return self.EXIT_TIMEOUT
-        if 'OL' in status_list:
-            return self.EXIT_OUTPUT_LIMIT_EXCEEDED
-        if 'ML' in status_list:
-            return self.EXIT_MEMORY_LIMIT_EXCEEDED
-        if 'SG' in status_list:
-            return self.EXIT_SIGNAL
-        if 'RE' in status_list:
-            return self.EXIT_NONZERO_RETURN
-        return self.EXIT_OK
-
-    def get_exit_code(self) -> int:
-        """Return the exit code of the sandboxed process.
-
-        return (float): exitcode, or 0.
+    def _get_pathlike_stdout(self, io: ProgramIO) -> Optional[pathlib.Path]:
+        if isinstance(io.output, str) or isinstance(io.output, pathlib.Path):
+            return pathlib.Path(io.output)
+        return None
 
-        """
-        assert self.log is not None
-        return int(self.log['exit-code'])
+    def run(self, command: List[str], params: SandboxParams) -> SandboxLog:
+        self.exec_num += 1
 
-    def get_detailed_logs(self) -> str:
-        return str(self.log)
+        logger.debug(
+            "Executing program in sandbox with command: `%s'.", ' '.join(command)
+        )
+        with open(
+            self.relative_path(self.cmd_file), 'at', encoding='utf-8'
+        ) as commands:
+            commands.write('%s\n' % command)
 
-    def get_human_exit_description(self) -> str:
-        """Get the status of the sandbox and return a human-readable
-        string describing it.
+        program = Program(command, self._get_program_params(params))
+        result = program.wait()
 
-        return (string): human-readable explaination of why the
-                         sandbox terminated.
+        return self._get_sandbox_log(result, params)
 
-        """
-        status = self.get_exit_status()
-        if status == self.EXIT_OK:
-            return (
-                'Execution successfully finished (with exit code %d)'
-                % self.get_exit_code()
-            )
-        elif status == self.EXIT_SANDBOX_ERROR:
-            return 'Execution failed because of sandbox error'
-        elif status == self.EXIT_TIMEOUT:
-            return 'Execution timed out'
-        elif status == self.EXIT_TIMEOUT_WALL:
-            return 'Execution timed out (wall clock limit exceeded)'
-        elif status == self.EXIT_SIGNAL:
-            return 'Execution killed with signal %s' % self.get_killing_signal()
-        elif status == self.EXIT_NONZERO_RETURN:
-            return 'Execution failed because the return code was nonzero'
-        elif status == self.EXIT_OUTPUT_LIMIT_EXCEEDED:
-            return 'Execution exceeded output limit'
-        return ''
-
-    def get_current_log_name(self) -> pathlib.Path:
-        return pathlib.Path(f'logs.{self.exec_num}')
-
-    def hydrate_logs(self):
-        self.log = None
-        if not self.relative_path(self.get_current_log_name()).is_file():
-            return
-        self.log = {}
-        raw_log = self.get_file_to_string(self.get_current_log_name(), maxlen=None)
-        for line in raw_log.splitlines():
-            items = line.split(':', 1)
-            if len(items) != 2:
-                continue
-            key, value = items
-            self.log[key] = value.strip()
-
-    def execute_without_std(
+    def run_communication(
         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.
-
-        return (bool): True if the sandbox didn't report errors
-            (caused by the sandbox itself), False otherwise
-
-        """
+        params: SandboxParams,
+        interactor_command: List[str],
+        interactor_params: SandboxParams,
+        merged_capture: Optional[pathlib.Path] = None,
+    ) -> Tuple[SandboxLog, SandboxLog]:
         self.exec_num += 1
 
         logger.debug(
@@ -301,43 +254,84 @@ class StupidSandbox(SandboxBase):
         ) as commands:
             commands.write('%s\n' % command)
 
-        real_command = (
-            [
-                sys.executable,
-                str(utils.abspath(self.get_timeit_executable())),
-                str(utils.abspath(self.relative_path(self.get_current_log_name()))),
-            ]
-            + self.get_timeit_args()
-            + command
+        interactor_program_params = self._get_program_params(interactor_params)
+        interactor_program_params.io = self._get_io(interactor_params, pipe_io=True)
+        interactor = Program(
+            interactor_command,
+            interactor_program_params,
         )
-
-        self.clear_pid()
-        with subprocess.Popen(
-            real_command,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            env={**os.environ, **self.params.set_env},
-        ) as p:
-            self.set_pid(p.pid)
-            try:
-                self.returncode = p.wait()
-            except Exception:
-                p.kill()
-                raise
-        self.hydrate_logs()
-        return self.translate_box_exitcode(self.returncode)
-
-    def translate_box_exitcode(self, exitcode: int) -> bool:
-        # SIGALRM can be safely ignored, just in case it leaks away. SIGTERM also.
-        if self.log is None:
-            return False
-        if 'TE' in self.get_status_list():
-            return True
-        return super().translate_box_exitcode(exitcode) or -exitcode == signal.SIGALRM
-
-    def debug_message(self) -> Any:
-        return f'returncode = {self.returncode}\nlogs = {self.log}\ntimeit_args = {self.get_timeit_args()}'
+        assert interactor.pipes.output is not None
+        assert interactor.pipes.input is not None
+        solution_input_pipe = interactor.pipes.output
+        solution_output_pipe = interactor.pipes.input
+
+        group_id = os.getpgid(interactor.pid)
+        should_tee = self._needs_teeing(params, interactor_params, merged_capture)
+
+        if should_tee:
+            if merged_capture:
+                self.create_file_from_string(merged_capture, '<\n>\n', override=True)
+
+            solution_tee = self._get_tee_program(
+                '>',
+                stdin=subprocess.PIPE,
+                stdout=interactor.pipes.input,
+                capture=self._get_pathlike_stdout(self._get_io(params)),
+                merged_capture=merged_capture,
+                pgid=group_id,
+            )
+            interactor_tee = self._get_tee_program(
+                '<',
+                stdin=interactor.pipes.output,
+                stdout=subprocess.PIPE,
+                capture=self._get_pathlike_stdout(self._get_io(interactor_params)),
+                merged_capture=merged_capture,
+                pgid=group_id,
+            )
+            assert solution_tee.pipes.input is not None
+            assert interactor_tee.pipes.output is not None
+            solution_input_pipe = interactor_tee.pipes.output
+            solution_output_pipe = solution_tee.pipes.input
+
+        program_params = self._get_program_params(params)
+        program_params.io = self._get_io(params, pipe_io=True)
+        program_params.io.input = solution_input_pipe
+        program_params.io.output = solution_output_pipe
+        program_params.pgid = group_id
+        program = Program(command, program_params)
+
+        results: List[Optional[SandboxLog]] = [None, None]
+
+        for idx in range(4 if should_tee else 2):
+            pid, status, ru = os.wait4(-group_id, 0)
+
+            if pid == interactor.pid:
+                program_result = interactor.process_exit(status, ru)
+                results[1] = self._get_sandbox_log(program_result, interactor_params)
+                results[1].exit_index = idx
+
+                interactor.pipes.output.close()
+                if should_tee:
+                    assert interactor_tee.pipes.output is not None
+                    interactor_tee.pipes.output.close()
+
+                if idx == 0 and program_result.exitcode != 0:
+                    os.killpg(group_id, signal.SIGKILL)
+            elif pid == program.pid:
+                program_result = program.process_exit(status, ru)
+                results[0] = self._get_sandbox_log(program_result, params)
+                results[0].exit_index = idx
+
+                interactor.pipes.input.close()
+                if should_tee:
+                    assert solution_tee.pipes.input is not None
+                    solution_tee.pipes.input.close()
+            elif should_tee and (pid in (solution_tee.pid, interactor_tee.pid)):
+                pass
+            else:
+                raise RuntimeError(f'Unknown pid: {pid}')
+
+        return typing.cast(Tuple[SandboxLog, SandboxLog], tuple(results))
 
     def cleanup(self, delete=False):
         """See Sandbox.cleanup()."""

rbx/grading/judge/sandboxes/tee.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""
+Forked from https://github.com/RagnarGrootKoerkamp/BAPCtools/blob/master/bin/interactive.py
+
+Takes a character and a file name as arguments.
+
+Reads from stdin, and writes to stdout and stderr, with the given character prepended to
+every line read from stdin.
+"""
+
+import sys
+
+c = sys.argv[1]
+extra = sys.argv[2]
+
+new = True
+
+with open(extra, 'w') as f:
+    while True:
+        rd = sys.stdin.read(1)
+        if rd == '':
+            break
+        sys.stdout.write(rd)
+        sys.stdout.flush()
+        if new:
+            sys.stderr.write(c)
+        sys.stderr.write(rd)
+        sys.stderr.flush()
+
+        f.write(rd)
+        new = rd == '\n'

rbx/grading/judge/storage.py

@@ -277,8 +277,14 @@ class FilesystemStorage(Storage):
             return None
 
         # Create a temporary file in the same directory
+        # Use only the basename for the suffix to avoid issues with subdirectories
+        filename_basename = pathlib.Path(filename).name
         temp_file = tempfile.NamedTemporaryFile(
-            'wb', delete=False, prefix='.tmp.', suffix=filename, dir=self.path
+            'wb',
+            delete=False,
+            prefix='.tmp.',
+            suffix=f'.{filename_basename}',
+            dir=self.path,
         )
         metadata: Dict[str, Optional[BaseModel]] = {'compression': None}
         if self.compress or grading_context.should_compress():