rbx.cp 0.5.0__py3-none-any.whl

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import importlib
+import importlib.resources
+import logging
+import pathlib
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+from typing import Any, Dict, List, Optional
+
+from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.sandbox import (
+    SandboxBase,
+    SandboxParams,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StupidSandbox(SandboxBase):
+    """A stupid sandbox implementation. It has very few features and
+    is not secure against things like box escaping and fork
+    bombs. Yet, it is very portable and has no dependencies, so it's
+    very useful for testing. Using in real contests is strongly
+    discouraged.
+
+    """
+
+    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.
+
+        For arguments documentation, see SandboxBase.__init__.
+
+        """
+        if not temp_dir:
+            temp_dir = pathlib.Path(tempfile.gettempdir())
+        SandboxBase.__init__(self, file_cacher, name, temp_dir, params)
+
+        # Make box directory
+        self._path = pathlib.Path(
+            tempfile.mkdtemp(dir=str(self.temp_dir), prefix='rbx-%s-' % (self.name))
+        )
+        self.initialize()
+
+        self.exec_num = -1
+        self.popen = None
+        self.log = None
+        self.returncode = None
+
+        logger.debug("Sandbox in `%s' created, using stupid box.", self._path)
+
+        # Box parameters
+        self.chdir = self._path
+
+    def initialize(self):
+        self._path.mkdir(parents=True, exist_ok=True)
+
+    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.stdin_file:
+            args.append(f'-i{self.params.stdin_file}')
+        if self.params.stdout_file:
+            args.append(f'-o{self.params.stdout_file}')
+        if self.params.stderr_file:
+            args.append(f'-e{self.params.stderr_file}')
+        if self.params.fsize:
+            args.append(f'-f{self.params.fsize}')
+        if self.chdir:
+            args.append(f'-c{self.chdir}')
+        return args
+
+    def get_root_path(self) -> pathlib.Path:
+        """Return the toplevel path of the sandbox.
+
+        return (Path): the root path.
+
+        """
+        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 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.
+
+        """
+        assert self.log is not None
+        if 'exit-sig' not in self.log:
+            return 0
+        return int(self.log['exit-sig'])
+
+    def get_status_list(self) -> List[str]:
+        """Reads the sandbox log file, and set and return the status
+        of the sandbox.
+
+        return (list): list of statuses of the sandbox.
+
+        """
+        assert self.log is not None
+        if 'status' in self.log:
+            return self.log['status'].split(',')
+        return []
+
+    # 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.
+
+        return (string): the main reason why the sandbox terminated.
+
+        """
+        if self.returncode != 0:
+            return self.EXIT_SANDBOX_ERROR
+        status_list = self.get_status_list()
+        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.
+
+        """
+        assert self.log is not None
+        return int(self.log['exit-code'])
+
+    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.
+
+        """
+        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(
+        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
+
+        """
+
+        self.exec_num += 1
+
+        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)
+
+        real_command = (
+            [
+                sys.executable,
+                str(self.get_timeit_executable().resolve()),
+                str(self.relative_path(self.get_current_log_name()).resolve()),
+            ]
+            + self.get_timeit_args()
+            + command
+        )
+        self.returncode = subprocess.call(
+            real_command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        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.
+        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()}'
+
+    def cleanup(self, delete=False):
+        """See Sandbox.cleanup()."""
+        # This sandbox doesn't have any cleanup, but we might want to delete.
+        if delete:
+            logger.debug('Deleting sandbox in %s.', self._path)
+            shutil.rmtree(str(self._path))

rbx/grading/judge/sandboxes/timeit.py

@@ -0,0 +1,217 @@
+import dataclasses
+import os
+import pathlib
+import resource
+import signal
+import stat
+import sys
+from math import ceil
+from time import monotonic
+from typing import List, Optional
+
+
+@dataclasses.dataclass()
+class Options:
+    output_file: str
+    argv: List[str]
+    chdir: Optional[str] = None
+    stdin_file: Optional[str] = None
+    stdout_file: Optional[str] = None
+    stderr_file: Optional[str] = None
+    time_limit: Optional[float] = None
+    wall_time_limit: Optional[float] = None  # seconds
+    memory_limit: Optional[int] = None  # kb, but passed in args as mb
+    fs_limit: Optional[int] = None  # kb
+
+
+def exit_with(code: int):
+    sys.exit(code)
+
+
+def parse_opts() -> Options:
+    options = Options(output_file=sys.argv[1], argv=[])
+    num_opts = 0
+    while num_opts + 2 < len(sys.argv) and sys.argv[num_opts + 2].startswith('-'):
+        # Process option
+        opt = sys.argv[num_opts + 2]
+        if opt.startswith('-t'):
+            options.time_limit = float(opt[2:])
+        elif opt.startswith('-w'):
+            options.wall_time_limit = float(opt[2:])
+        elif opt.startswith('-m'):
+            options.memory_limit = int(opt[2:]) * 1024
+        elif opt.startswith('-i'):
+            options.stdin_file = opt[2:]
+        elif opt.startswith('-o'):
+            options.stdout_file = opt[2:]
+        elif opt.startswith('-e'):
+            options.stderr_file = opt[2:]
+        elif opt.startswith('-c'):
+            options.chdir = opt[2:]
+        elif opt.startswith('-f'):
+            options.fs_limit = int(opt[2:])
+        else:
+            raise Exception(f'Invalid option {opt}')
+        num_opts += 1
+    options.argv = sys.argv[num_opts + 2 :]
+    return options
+
+
+def get_memory_usage(ru: resource.struct_rusage) -> int:
+    used = ceil((ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) / 1024)
+    return used
+
+
+def get_cpu_time(ru: resource.struct_rusage) -> float:
+    return ru.ru_utime + ru.ru_stime
+
+
+def _get_file_size(filename: Optional[str]) -> int:
+    if filename is None:
+        return 0
+    path = pathlib.Path(filename)
+    if not path.is_file():
+        return 0
+    return path.stat().st_size
+
+
+def get_file_sizes(options: Options):
+    return _get_file_size(options.stdout_file) + _get_file_size(options.stderr_file)
+
+
+def set_rlimits(options: Options):
+    if options.time_limit is not None:
+        time_limit_in_ms = int(options.time_limit * 1000)
+        rlimit_cpu = int((time_limit_in_ms + 999) // 1000)
+        resource.setrlimit(resource.RLIMIT_CPU, (rlimit_cpu, rlimit_cpu + 1))
+    if options.fs_limit is not None:
+        fs_limit = options.fs_limit * 1024  # in bytes
+        resource.setrlimit(resource.RLIMIT_FSIZE, (fs_limit + 1, fs_limit * 2))
+
+
+def redirect_fds(options: Options):
+    files = [options.stdin_file, options.stdout_file, options.stderr_file]
+
+    for i, file in enumerate(files):
+        if file is None:
+            continue
+        open_args = [
+            os.O_WRONLY | os.O_TRUNC | os.O_CREAT,
+            stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR,
+        ]
+        if i == 0:
+            # stdin
+            open_args = [os.O_RDONLY]
+        fd = os.open(
+            file,
+            *open_args,
+        )
+        os.dup2(fd, i)
+        os.close(fd)
+
+
+def wait_and_finish(
+    pid: int,
+    options: Options,
+    start_time: float,
+    alarm_msg: Optional[List[Optional[str]]] = None,
+):
+    _, exitstatus, ru = os.wait4(pid, 0)
+    wall_time = monotonic() - start_time
+    cpu_time = get_cpu_time(ru)
+    memory_used = get_memory_usage(ru)
+    file_sizes = get_file_sizes(options)
+
+    entries = []
+    exitcode = os.waitstatus_to_exitcode(exitstatus)
+    entries.append(f'exit-code: {exitcode}')
+    if exitcode < 0:
+        entries.append(f'exit-sig: {-exitcode}')
+
+    status = set()
+    if exitcode > 0:
+        status.add('RE')
+    if exitcode < 0:
+        status.add('SG')
+    if options.time_limit is not None and (
+        cpu_time > options.time_limit or -exitcode == 24
+    ):
+        status.add('TO')
+        cpu_time = max(cpu_time, options.time_limit)
+    if options.wall_time_limit is not None and wall_time > options.wall_time_limit:
+        status.add('WT')
+        status.add('TO')
+    if options.memory_limit is not None and memory_used > options.memory_limit:
+        status.add('ML')
+    if options.fs_limit is not None and file_sizes > options.fs_limit * 1024:
+        status.add('OL')
+
+    if status:
+        status_str = ','.join(status)
+        entries.append(f'status: {status_str}')
+
+    if alarm_msg:
+        alarm_str = ','.join(msg for msg in alarm_msg if msg is not None)
+        if alarm_str:
+            entries.append(f'alarm-msg: {alarm_str}')
+
+    entries.append(f'time: {cpu_time:.3f}')
+    entries.append(f'time-wall: {wall_time:.3f}')
+    entries.append(f'mem: {memory_used}')
+    entries.append(f'file: {file_sizes}')
+
+    output_file = pathlib.Path(sys.argv[1])
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    output_file.write_text('\n'.join(entries) + '\n')
+
+
+def main():
+    options = parse_opts()
+
+    start_time = monotonic()
+    sub_pid = os.fork()
+    if sub_pid == 0:
+        if options.chdir is not None:
+            os.chdir(options.chdir)
+        set_rlimits(options)
+        redirect_fds(options)
+        os.execvp(options.argv[0], options.argv)
+
+    alarm_msg: List[Optional[str]] = [None]
+
+    def handle_alarm(*args, **kwargs):
+        nonlocal alarm_msg
+        wall_time = monotonic() - start_time
+        if options.wall_time_limit is not None and wall_time > options.wall_time_limit:
+            alarm_msg[0] = 'wall timelimit'
+            os.kill(sub_pid, 9)
+            return
+        ru = resource.getrusage(resource.RUSAGE_CHILDREN)
+        if options.time_limit is not None:
+            cpu_time = get_cpu_time(ru)
+            if cpu_time > options.time_limit:
+                alarm_msg[0] = 'timelimit'
+                os.kill(sub_pid, 9)
+                return
+        if options.memory_limit is not None:
+            memory_used = get_memory_usage(ru)
+            if memory_used > options.memory_limit:
+                alarm_msg[0] = 'memorylimit'
+                os.kill(sub_pid, 9)
+                return
+
+        signal.alarm(1)
+
+    signal.alarm(1)
+    signal.signal(signal.SIGALRM, handle_alarm)
+    wait_and_finish(sub_pid, options, start_time, alarm_msg=alarm_msg)
+
+    # Cancel alarm before exiting to avoid surprises.
+    signal.alarm(0)
+
+    # Exit gracefully.
+    sys.exit()
+
+
+if __name__ == '__main__':
+    main()