Move to subprocess (#52)

* Move to subprocess

* fix execution with oiejq

* Fix oiejq execution on Arch Linux

* Use with statements

* Add missing with statement

* Add a function for file diff

* Remove flush

Author: MasloMaslane

src/sinol_make/__init__.py

@@ -3,7 +3,7 @@
 
 from sinol_make import util
 
-__version__ = "1.2.1"
+__version__ = "1.2.2"
 
 def configure_parsers():
     parser = argparse.ArgumentParser(

src/sinol_make/commands/inwer/__init__.py

@@ -53,9 +53,10 @@ def verify_test(execution: InwerExecution) -> VerificationResult:
         output_dir = os.path.join(os.getcwd(), 'cache', 'executions', execution.test_name)
         os.makedirs(output_dir, exist_ok=True)
 
-        command = f'{execution.inwer_exe_path} < {execution.test_path}'
-        process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-        process.wait()
+        command = [execution.inwer_exe_path]
+        with open(execution.test_path, 'r') as test:
+            process = subprocess.Popen(command, stdin=test, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+            process.wait()
         exit_code = process.returncode
         out, _ = process.communicate()
 

src/sinol_make/commands/run/__init__.py

@@ -1,6 +1,7 @@
 # Modified version of https://sinol3.dasie.mimuw.edu.pl/oij/jury/package/-/blob/master/runner.py
 # Author of the original code: Bartosz Kostka <[email protected]>
 # Version 0.6 (2021-08-29)
+import subprocess
 
 from sinol_make.commands.run.structs import ExecutionResult, ResultChange, ValidationResult, ExecutionData
 from sinol_make.helpers.parsers import add_compilation_arguments
@@ -184,22 +185,34 @@ def compile(self, solution):
             return False
 
 
-    def execute_oiejq(self, command, result_file, output_file, answer_file, time_limit, memory_limit):
-        timeout_exit_code = os.system(command)
+    def execute_oiejq(self, command, input_file_path, answer_file_path,
+                      time_limit, memory_limit):
+        env = os.environ.copy()
+        env["MEM_LIMIT"] = f'{memory_limit}K'
+        env["MEASURE_MEM"] = "1"
+        with open(input_file_path, "r") as input_file:
+            process = subprocess.Popen(command, shell=True, stdin=input_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+            process.wait()
+        timeout_exit_code = process.returncode
+        lines = process.stderr.read().decode("utf-8").splitlines()
+        output = process.stdout.read().decode("utf-8").splitlines()
+
         result = ExecutionResult(None, None, None)
-        with open(result_file) as r:
-            for line in r:
-                line = line.strip()
-                if ": " in line:
-                    (key, value) = line.split(": ")[:2]
-                    if key == "Time":
-                        result.Time = self.parse_time(value)
-                    elif key == "Memory":
-                        result.Memory = self.parse_memory(value)
-                    else:
-                        setattr(result, key, value)
 
-        if timeout_exit_code == 35072:
+        for line in lines:
+            line = line.strip()
+            if ": " in line:
+                (key, value) = line.split(": ")[:2]
+                if key == "Time":
+                    result.Time = self.parse_time(value)
+                elif key == "Memory":
+                    result.Memory = self.parse_memory(value)
+                else:
+                    setattr(result, key, value)
+
+        # If timeout kills the process, the exit code should be 137.
+        # But on Arch Linux it returns the negative value of the signal that killed the process.
+        if timeout_exit_code == 137 or timeout_exit_code == -9:
             result.Status = "TL"
         elif getattr(result, "Time") is not None and result.Time > time_limit:
             result.Status = "TL"
@@ -212,20 +225,24 @@ def execute_oiejq(self, command, result_file, output_file, answer_file, time_lim
                 result.Status = "TL"
             elif result.Memory > memory_limit:
                 result.Status = "ML"
-            elif os.system("diff -q -Z %s %s >/dev/null"
-                           % (output_file, answer_file)):
+            elif not util.lines_diff(output, open(answer_file_path).readlines()):
                 result.Status = "WA"
         else:
             result.Status = result.Status[:2]
 
         return result
 
 
-    def execute_time(self, command, result_file, output_file, answer_file, time_limit, memory_limit):
-        timeout_exit_code = os.system(command)
+    def execute_time(self, command, result_file_path, input_file_path, answer_file_path,
+                     time_limit, memory_limit):
+        with open(input_file_path, "r") as input_file:
+            process = subprocess.Popen(command, stdin=input_file, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+            process.wait()
+        timeout_exit_code = process.returncode
+        output = process.stdout.read().decode("utf-8").splitlines()
 
         result = ExecutionResult(None, None, None)
-        lines = open(result_file).readlines()
+        lines = open(result_file_path).readlines()
         program_exit_code = None
         if len(lines) == 3:
             """
@@ -254,7 +271,7 @@ def execute_time(self, command, result_file, output_file, answer_file, time_limi
             result.Status = "TL"
         elif result.Memory > memory_limit:
             result.Status = "ML"
-        elif os.system("diff -q -Z %s %s >/dev/null" % (output_file, answer_file)):
+        elif not util.lines_diff(output, open(answer_file_path).readlines()):
             result.Status = "WA"
         else:
             result.Status = "OK"
@@ -269,17 +286,13 @@ def run_solution(self, data_for_execution: ExecutionData):
 
         (name, executable, test, time_limit, memory_limit, timetool_path) = data_for_execution
         file_no_ext = os.path.join(self.EXECUTIONS_DIR, name, self.extract_test_id(test))
-        output_file = file_no_ext + ".out"
         result_file = file_no_ext + ".res"
         hard_time_limit_in_s = math.ceil(2 * time_limit / 1000.0)
 
         if self.args.time_tool == 'oiejq':
-            command = "MEM_LIMIT=%sK MEASURE_MEM=true timeout -k %ds -s SIGKILL %ds %s %s <%s >%s 2>%s" \
-                      % (memory_limit, hard_time_limit_in_s,
-                         hard_time_limit_in_s, timetool_path,
-                         executable, test, output_file, result_file)
+            command = f'timeout -k {hard_time_limit_in_s}s -s SIGKILL {hard_time_limit_in_s}s "{timetool_path}" "{executable}"'
 
-            return self.execute_oiejq(command, result_file, output_file, self.get_output_file(test), time_limit, memory_limit)
+            return self.execute_oiejq(command, test, self.get_output_file(test), time_limit, memory_limit)
         elif self.args.time_tool == 'time':
             if sys.platform == 'darwin':
                 timeout_name = 'gtimeout'
@@ -290,9 +303,9 @@ def run_solution(self, data_for_execution: ExecutionData):
             elif sys.platform == 'win32' or sys.platform == 'cygwin':
                 raise Exception("Measuring time with GNU time on Windows is not supported.")
 
-            command = f'{timeout_name} -k {hard_time_limit_in_s}s {hard_time_limit_in_s}s ' \
-                      f'{time_name} -f "%U\\n%M\\n%x" -o {result_file} {executable} <{test} >{output_file} 2>/dev/null'
-            return self.execute_time(command, result_file, output_file, self.get_output_file(test), time_limit, memory_limit)
+            command = [f'{timeout_name}', '-k', f'{hard_time_limit_in_s}s', f'{hard_time_limit_in_s}s',
+                       f'{time_name}', '-f', '%U\\n%M\\n%x', '-o', result_file, executable]
+            return self.execute_time(command, result_file, test, self.get_output_file(test), time_limit, memory_limit)
 
 
     def update_group_status(self, group_status, new_status):

src/sinol_make/util.py

@@ -154,6 +154,29 @@ def save_config(config):
             yaml.dump(config, config_file)
 
 
+def lines_diff(lines1, lines2):
+    """
+    Function to compare two lists of lines.
+    Returns True if they are the same, False otherwise.
+    """
+    if len(lines1) != len(lines2):
+        return False
+
+    for i in range(len(lines1)):
+        if lines1[i].rstrip() != lines2[i].rstrip():
+            return False
+
+    return True
+
+
+def file_diff(file1, file2):
+    """
+    Function to compare two files.
+    Returns True if they are the same, False otherwise.
+    """
+    return lines_diff(open(file1).readlines(), open(file2).readlines())
+
+
 def color_red(text): return "\033[91m{}\033[00m".format(text)
 def color_green(text): return "\033[92m{}\033[00m".format(text)
 def color_yellow(text): return "\033[93m{}\033[00m".format(text)

tests/util.py

@@ -1,5 +1,6 @@
 import os
 import glob
+import subprocess
 
 from sinol_make.helpers import compile
 
@@ -53,7 +54,9 @@ def create_outs(package_path):
     assert compile.compile(solution, solution_executable)
     os.chdir(os.path.join(package_path, "in"))
     for file in glob.glob("*.in"):
-        os.system(f'{os.path.join(package_path, "cache", "executables", "solution.e")} < {file} > ../out/{file.replace(".in", ".out")}')
+        with open(file, "r") as in_file, open(os.path.join("../out", file.replace(".in", ".out")), "w") as out_file:
+            subprocess.Popen([os.path.join(package_path, "cache", "executables", "solution.e")],
+                             stdin=in_file, stdout=out_file).wait()
     os.chdir(package_path)