11766007069

Committed 10 Nov 2024 02:32PM UTC coverage: 55.065% (+0.3%) from 54.79%

Build # 11766007069

Build Type

Pull #86

github

Committed by

web-flow

Commit Message

Merge a17bda499 into 6a43c847c

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

Run Details

403 of 891 branches covered (45.23%)

Branch coverage included in aggregate %.

22 of 36 new or added lines in 4 files covered. (61.11%)

41 existing lines in 1 file now uncovered.

1516 of 2594 relevant lines covered (58.44%)

0.58 hits per line

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

13.08

/tin/apps/submissions/tasks.py

from __future__ import annotations

import contextlib
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 = submission.wrapper_file_path

        args = get_assignment_sandbox_args(
            ["mkdir", "-p", "--", os.path.dirname(submission_wrapper_path)],
            network_access=False,
            whitelist=[os.path.dirname(os.path.dirname(submission_wrapper_path))],
        )

        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,
        )

        with open(submission_wrapper_path, "w", encoding="utf-8") as f_obj:
            f_obj.write(wrapper_text)
        os.chmod(submission_wrapper_path, 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,
            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, os.path.dirname(submission_wrapper_path)]
            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"}
        )

        with contextlib.suppress(FileNotFoundError):
            os.remove(submission_wrapper_path)

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

tjcsl / tin / 11766007069

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