11320121401

Committed 14 Oct 2024 02:45AM UTC coverage: 54.786% (-0.004%) from 54.79%

Build # 11320121401

Build Type

Pull #86

github

Committed by

web-flow

Commit Message

Merge 60da4a385 into 6a43c847c

Pull Request Pull Request #86: Improve instructions for dev env

Run Details

398 of 887 branches covered (44.87%)

Branch coverage included in aggregate %.

16 of 40 new or added lines in 4 files covered. (40.0%)

56 existing lines in 3 files now uncovered.

1508 of 2592 relevant lines covered (58.18%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.04

/tin/apps/submissions/tasks.py

from __future__ import annotations

import logging
import os
import re
import select
import signal
import subprocess
import sys
import time
import traceback
from decimal import Decimal
from pathlib import Path

import psutil
from asgiref.sync import async_to_sync
from celery import shared_task
from channels.layers import get_channel_layer
from django.conf import settings
from django.utils import timezone

from ... import sandboxing
from ...sandboxing import get_assignment_sandbox_args
from .models import Submission

logger = logging.getLogger(__name__)


def truncate_output(text, field_name):
    max_len = Submission._meta.get_field(field_name).max_length
    return ("..." + text[-max_len + 5 :]) if len(text) > max_len else text


@shared_task
def run_submission(submission_id):
    submission = Submission.objects.get(id=submission_id)

    try:
        grader_path = os.path.join(settings.MEDIA_ROOT, submission.assignment.grader_file.name)
        grader_log_path = os.path.join(
            settings.MEDIA_ROOT, submission.assignment.grader_log_filename
        )
        submission_path = submission.file_path

        submission_wrapper_path = Path(submission.wrapper_file_path)

        args = get_assignment_sandbox_args(
            ["mkdir", "-p", "--", str(submission_wrapper_path.parent)],
            network_access=False,
            whitelist=[str(submission_wrapper_path.parent.parent)],
        )

        try:
            subprocess.run(
                args,
                stdin=subprocess.DEVNULL,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.PIPE,
                text=True,
                check=True,
            )
        except FileNotFoundError as e:
            logger.error("Cannot run processes: %s", e)
            raise FileNotFoundError from e

        if submission.assignment.venv_fully_created:
            python_exe = os.path.join(submission.assignment.venv.path, "bin", "python")
        elif settings.DEBUG:
            python_exe = sys.executable
        else:  # pragma: no cover
            python_exe = "/usr/bin/python3.10"

        if settings.USE_SANDBOXING:
            wrapper_text = (
                Path(settings.BASE_DIR)
                .joinpath(
                    "sandboxing",
                    "wrappers",
                    "sandboxed",
                    f"{submission.assignment.language}.txt",
                )
                .read_text("utf-8")
            )

        elif submission.assignment.language == "P":
            wrapper_text = settings.DEBUG_GRADER_WRAPPER_SCRIPT.read_text("utf-8")
        else:
            raise NotImplementedError(
                f"Unsupported language {submission.assignment.language} in DEBUG"
            )

        wrapper_text = wrapper_text.format(
            has_network_access=bool(submission.assignment.has_network_access),
            venv_path=(
                submission.assignment.venv.path
                if submission.assignment.venv_fully_created
                else None
            ),
            submission_path=submission_path,
            python=python_exe,
        )

        submission_wrapper_path.write_text(wrapper_text, "utf-8")
        submission_wrapper_path.chmod(0o700)
    except OSError:
        submission.grader_output = (
            "An internal error occurred. Please try again.\n"
            "If the problem persists, contact your teacher."
        )
        submission.grader_errors = truncate_output(
            traceback.format_exc().replace("\0", ""), "grader_errors"
        )
        submission.complete = True
        submission.save()

        async_to_sync(get_channel_layer().group_send)(
            submission.channel_group_name, {"type": "submission.updated"}
        )
        return

    try:
        retcode = None
        killed = False

        output = ""
        errors = ""

        args = [
            python_exe,
            "-u",
            grader_path,
            str(submission_wrapper_path),
            submission_path,
            submission.student.username,
            grader_log_path,
        ]

        if settings.USE_SANDBOXING:
            whitelist = [os.path.dirname(grader_path)]
            read_only = [grader_path, submission_path, str(submission_wrapper_path.parent)]
            if submission.assignment.venv_fully_created:
                whitelist.append(submission.assignment.venv.path)
                read_only.append(submission.assignment.venv.path)

            args = sandboxing.get_assignment_sandbox_args(
                args,
                network_access=submission.assignment.grader_has_network_access,
                direct_network_access=False,
                whitelist=whitelist,
                read_only=read_only,
            )

        env = os.environ.copy()
        if submission.assignment.venv_fully_created:
            env.update(submission.assignment.venv.get_activation_env())

        with subprocess.Popen(  # pylint: disable=subprocess-popen-preexec-fn
            args,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stdin=subprocess.DEVNULL,
            bufsize=0,
            cwd=os.path.dirname(grader_path),
            preexec_fn=os.setpgrp,  # noqa: PLW1509
            env=env,
        ) as proc:
            start_time = time.time()

            submission.grader_pid = proc.pid
            submission.grader_start_time = timezone.localtime().timestamp()
            submission.save()

            timed_out = False

            while proc.poll() is None:
                submission.refresh_from_db()
                submission.assignment.refresh_from_db()
                if submission.assignment.enable_grader_timeout:
                    time_elapsed = time.time() - start_time
                    timeout = submission.assignment.grader_timeout - time_elapsed
                    if timeout <= 0:
                        timed_out = True
                        break

                    timeout = min(timeout, 15)
                else:
                    timeout = 15

                if submission.kill_requested:
                    break

                files_ready = select.select([proc.stdout, proc.stderr], [], [], timeout)[0]
                if proc.stdout in files_ready:
                    output += proc.stdout.read(8192).decode()

                if proc.stderr in files_ready:
                    errors += proc.stderr.read(8192).decode()

                submission.grader_output = truncate_output(
                    output.replace("\0", ""), "grader_output"
                )
                submission.grader_errors = truncate_output(
                    errors.replace("\0", ""), "grader_errors"
                )
                submission.save(update_fields=["grader_output", "grader_errors"])

                async_to_sync(get_channel_layer().group_send)(
                    submission.channel_group_name, {"type": "submission.updated"}
                )

            if proc.poll() is None:
                killed = True

                children = psutil.Process(proc.pid).children(recursive=True)
                try:
                    os.killpg(proc.pid, signal.SIGKILL)
                except ProcessLookupError:
                    # Shouldn't happen, but just in case
                    proc.kill()
                for child in children:
                    try:
                        child.kill()
                    except psutil.NoSuchProcess:
                        pass

            output += proc.stdout.read().decode()
            errors += proc.stderr.read().decode()

            if killed:
                msg = "[Grader timed out]" if timed_out else "[Grader killed]"

                if output and not output.endswith("\n"):
                    output += "\n"
                output += msg

                if errors and not errors.endswith("\n"):
                    errors += "\n"
                errors += msg
            else:
                retcode = proc.poll()
                if retcode != 0:
                    if output and not output.endswith("\n"):
                        output += "\n"
                    output += "[Grader error]"

                    if errors and not errors.endswith("\n"):
                        errors += "\n"
                    errors += f"[Grader exited with status {retcode}]"

            submission.grader_output = truncate_output(output.replace("\0", ""), "grader_output")
            submission.grader_errors = truncate_output(errors.replace("\0", ""), "grader_errors")
            submission.save()
    except Exception:  # pylint: disable=broad-except  # noqa: BLE001
        submission.grader_output = "[Internal error]"
        submission.grader_errors = truncate_output(
            traceback.format_exc().replace("\0", ""), "grader_errors"
        )
        submission.save()
    else:
        if output and not killed and retcode == 0:
            last_line = output.splitlines()[-1]
            match = re.search(r"^Score: ([\d.]+%?)$", last_line)
            if match is not None:
                score = match.group(1)
                if score.endswith("%"):
                    score = submission.assignment.points_possible * Decimal(score[:-1]) / 100
                else:
                    score = Decimal(score)
                if abs(score) < 1000:
                    submission.points_received = score
                    submission.has_been_graded = True
    finally:
        submission.complete = True
        submission.grader_pid = None
        submission.save()

        async_to_sync(get_channel_layer().group_send)(
            submission.channel_group_name, {"type": "submission.updated"}
        )

        submission_wrapper_path.unlink(missing_ok=True)

1	from __future__ import annotations	1✔
2
3	import logging	1✔
4	import os	1✔
5	import re	1✔
6	import select	1✔
7	import signal	1✔
8	import subprocess	1✔
9	import sys	1✔
10	import time	1✔
11	import traceback	1✔
12	from decimal import Decimal	1✔
13	from pathlib import Path	1✔
14
15	import psutil	1✔
16	from asgiref.sync import async_to_sync	1✔
17	from celery import shared_task	1✔
18	from channels.layers import get_channel_layer	1✔
19	from django.conf import settings	1✔
20	from django.utils import timezone	1✔
21
22	from ... import sandboxing	1✔
23	from ...sandboxing import get_assignment_sandbox_args	1✔
24	from .models import Submission	1✔
25
26	logger = logging.getLogger(__name__)	1✔
27
28
29	def truncate_output(text, field_name):	1✔
UNCOV 30	max_len = Submission._meta.get_field(field_name).max_length	×
31	return ("..." + text[-max_len + 5 :]) if len(text) > max_len else text	×
32
33
34	@shared_task	1✔
35	def run_submission(submission_id):	1✔
UNCOV 36	submission = Submission.objects.get(id=submission_id)	×
37
UNCOV 38	try:	×
39	grader_path = os.path.join(settings.MEDIA_ROOT, submission.assignment.grader_file.name)	×
40	grader_log_path = os.path.join(	×
41	settings.MEDIA_ROOT, submission.assignment.grader_log_filename
42	)
UNCOV 43	submission_path = submission.file_path	×
44
NEW UNCOV 45	submission_wrapper_path = Path(submission.wrapper_file_path)	×
46
UNCOV 47	args = get_assignment_sandbox_args(	×
48	["mkdir", "-p", "--", str(submission_wrapper_path.parent)],
49	network_access=False,
50	whitelist=[str(submission_wrapper_path.parent.parent)],
51	)
52
UNCOV 53	try:	×
54	subprocess.run(	×
55	args,
56	stdin=subprocess.DEVNULL,
57	stdout=subprocess.DEVNULL,
58	stderr=subprocess.PIPE,
59	text=True,
60	check=True,
61	)
UNCOV 62	except FileNotFoundError as e:	×
63	logger.error("Cannot run processes: %s", e)	×
64	raise FileNotFoundError from e	×
65
NEW UNCOV 66	if submission.assignment.venv_fully_created:	×
NEW 67	python_exe = os.path.join(submission.assignment.venv.path, "bin", "python")	×
NEW 68	elif settings.DEBUG:	×
NEW 69	python_exe = sys.executable	×
70	else: # pragma: no cover
71	python_exe = "/usr/bin/python3.10"
72
NEW 73	if settings.USE_SANDBOXING:	×
NEW 74	wrapper_text = (	×
75	Path(settings.BASE_DIR)
76	.joinpath(
77	"sandboxing",
78	"wrappers",
79	"sandboxed",
80	f"{submission.assignment.language}.txt",
81	)
82	.read_text("utf-8")
83	)
84
NEW 85	elif submission.assignment.language == "P":	×
NEW 86	wrapper_text = settings.DEBUG_GRADER_WRAPPER_SCRIPT.read_text("utf-8")	×
87	else:
NEW 88	raise NotImplementedError(	×
89	f"Unsupported language {submission.assignment.language} in DEBUG"
90	)
91
NEW UNCOV 92	wrapper_text = wrapper_text.format(	×
93	has_network_access=bool(submission.assignment.has_network_access),
94	venv_path=(
95	submission.assignment.venv.path
96	if submission.assignment.venv_fully_created
97	else None
98	),
99	submission_path=submission_path,
100	python=python_exe,
101	)
102
NEW 103	submission_wrapper_path.write_text(wrapper_text, "utf-8")	×
NEW 104	submission_wrapper_path.chmod(0o700)	×
105	except OSError:	×
UNCOV 106	submission.grader_output = (	×
107	"An internal error occurred. Please try again.\n"
108	"If the problem persists, contact your teacher."
109	)
UNCOV 110	submission.grader_errors = truncate_output(	×
111	traceback.format_exc().replace("\0", ""), "grader_errors"
112	)
113	submission.complete = True	×
UNCOV 114	submission.save()	×
115
116	async_to_sync(get_channel_layer().group_send)(	×
117	submission.channel_group_name, {"type": "submission.updated"}
118	)
119	return	×
120
UNCOV 121	try:	×
122	retcode = None	×
UNCOV 123	killed = False	×
124
125	output = ""	×
126	errors = ""	×
127
128	args = [	×
129	python_exe,
130	"-u",
131	grader_path,
132	str(submission_wrapper_path),
133	submission_path,
134	submission.student.username,
135	grader_log_path,
136	]
137
NEW UNCOV 138	if settings.USE_SANDBOXING:	×
UNCOV 139	whitelist = [os.path.dirname(grader_path)]	×
NEW UNCOV 140	read_only = [grader_path, submission_path, str(submission_wrapper_path.parent)]	×
141	if submission.assignment.venv_fully_created:	×
142	whitelist.append(submission.assignment.venv.path)	×
143	read_only.append(submission.assignment.venv.path)	×
144
145	args = sandboxing.get_assignment_sandbox_args(	×
146	args,
147	network_access=submission.assignment.grader_has_network_access,
148	direct_network_access=False,
149	whitelist=whitelist,
150	read_only=read_only,
151	)
152
NEW UNCOV 153	env = os.environ.copy()	×
UNCOV 154	if submission.assignment.venv_fully_created:	×
UNCOV 155	env.update(submission.assignment.venv.get_activation_env())	×
156
157	with subprocess.Popen( # pylint: disable=subprocess-popen-preexec-fn	×
158	args,
159	stdout=subprocess.PIPE,
160	stderr=subprocess.PIPE,
161	stdin=subprocess.DEVNULL,
162	bufsize=0,
163	cwd=os.path.dirname(grader_path),
164	preexec_fn=os.setpgrp, # noqa: PLW1509
165	env=env,
166	) as proc:
UNCOV 167	start_time = time.time()	×
168
UNCOV 169	submission.grader_pid = proc.pid	×
170	submission.grader_start_time = timezone.localtime().timestamp()	×
UNCOV 171	submission.save()	×
172
173	timed_out = False	×
174
UNCOV 175	while proc.poll() is None:	×
176	submission.refresh_from_db()	×
UNCOV 177	submission.assignment.refresh_from_db()	×
178	if submission.assignment.enable_grader_timeout:	×
179	time_elapsed = time.time() - start_time	×
180	timeout = submission.assignment.grader_timeout - time_elapsed	×
181	if timeout <= 0:	×
182	timed_out = True	×
183	break	×
184
185	timeout = min(timeout, 15)	×
186	else:
UNCOV 187	timeout = 15	×
188
UNCOV 189	if submission.kill_requested:	×
190	break	×
191
192	files_ready = select.select([proc.stdout, proc.stderr], [], [], timeout)[0]	×
193	if proc.stdout in files_ready:	×
UNCOV 194	output += proc.stdout.read(8192).decode()	×
195
196	if proc.stderr in files_ready:	×
197	errors += proc.stderr.read(8192).decode()	×
198
199	submission.grader_output = truncate_output(	×
200	output.replace("\0", ""), "grader_output"
201	)
202	submission.grader_errors = truncate_output(	×
203	errors.replace("\0", ""), "grader_errors"
204	)
205	submission.save(update_fields=["grader_output", "grader_errors"])	×
206
UNCOV 207	async_to_sync(get_channel_layer().group_send)(	×
208	submission.channel_group_name, {"type": "submission.updated"}
209	)
210
UNCOV 211	if proc.poll() is None:	×
UNCOV 212	killed = True	×
213
214	children = psutil.Process(proc.pid).children(recursive=True)	×
215	try:	×
UNCOV 216	os.killpg(proc.pid, signal.SIGKILL)	×
217	except ProcessLookupError:	×
218	# Shouldn't happen, but just in case
219	proc.kill()	×
220	for child in children:	×
UNCOV 221	try:	×
222	child.kill()	×
223	except psutil.NoSuchProcess:	×
224	pass	×
225
226	output += proc.stdout.read().decode()	×
227	errors += proc.stderr.read().decode()	×
228
229	if killed:	×
230	msg = "[Grader timed out]" if timed_out else "[Grader killed]"	×
231
232	if output and not output.endswith("\n"):	×
233	output += "\n"	×
UNCOV 234	output += msg	×
235
236	if errors and not errors.endswith("\n"):	×
237	errors += "\n"	×
UNCOV 238	errors += msg	×
239	else:
240	retcode = proc.poll()	×
241	if retcode != 0:	×
UNCOV 242	if output and not output.endswith("\n"):	×
243	output += "\n"	×
244	output += "[Grader error]"	×
245
246	if errors and not errors.endswith("\n"):	×
247	errors += "\n"	×
UNCOV 248	errors += f"[Grader exited with status {retcode}]"	×
249
250	submission.grader_output = truncate_output(output.replace("\0", ""), "grader_output")	×
251	submission.grader_errors = truncate_output(errors.replace("\0", ""), "grader_errors")	×
UNCOV 252	submission.save()	×
253	except Exception: # pylint: disable=broad-except # noqa: BLE001	×
254	submission.grader_output = "[Internal error]"	×
255	submission.grader_errors = truncate_output(	×
256	traceback.format_exc().replace("\0", ""), "grader_errors"
257	)
258	submission.save()	×
259	else:
UNCOV 260	if output and not killed and retcode == 0:	×
261	last_line = output.splitlines()[-1]	×
UNCOV 262	match = re.search(r"^Score: ([\d.]+%?)$", last_line)	×
263	if match is not None:	×
264	score = match.group(1)	×
265	if score.endswith("%"):	×
266	score = submission.assignment.points_possible * Decimal(score[:-1]) / 100	×
267	else:
268	score = Decimal(score)	×
269	if abs(score) < 1000:	×
UNCOV 270	submission.points_received = score	×
271	submission.has_been_graded = True	×
272	finally:
273	submission.complete = True	×
274	submission.grader_pid = None	×
UNCOV 275	submission.save()	×
276
277	async_to_sync(get_channel_layer().group_send)(	×
278	submission.channel_group_name, {"type": "submission.updated"}
279	)
280
NEW UNCOV 281	submission_wrapper_path.unlink(missing_ok=True)	×

tjcsl / tin / 11320121401

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous