cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r253:0654ec1bf773` public

parent | child

Description:

merge to master

Commit status:

[Not Reviewed]

References:

merge default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r253:0654ec1bf773 - Tue, 12 Jun 2018 13:11:37 - 6 files changed: 23 inserted, 12 deleted

grader-process-check.SAMPLE created 755 ¶ +9

@@ -0,0 +1,9
	1	+ #!/bin/bash
	2	+ count=`ps aux \| grep "algo_grader" \| grep "grader grading queue" \| wc -l`
	3	+ install_dir=/home/john/cafe_grader
	4	+ ruby_executable=/home/john/.rvm/wrappers/ruby-2.3.0/ruby
	5	+ if [ $count -lt 1 ]; then
	6	+ cd $judge_dir/judge
	7	+ $ruby_executable $install_dir/judge/scripts/grader grading queue > $install_dir/judge/grading.log &
	8	+ fi
	9	+

grader ¶ +2

               #!/usr/bin/env ruby
               def stop_grader(id)
                 if id==:all
                   File.open(File.dirname(__FILE__) + "/stop.all",'w').close
                 else
                   File.open(File.dirname(__FILE__) + "/stop.#{id}",'w').close
                 end
               end
               def check_stopfile
                 FileTest.exist?(File.dirname(__FILE__) + "/stop.all") or
                   FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
               end
               def clear_stopfile
                 if FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
                   File.delete(File.dirname(__FILE__) + "/stop.#{Process.pid}")
                 end
               end
               def config
                 Grader::Configuration.get_instance
               end
               def log_file_name
                 if !File.exists?(config.log_dir)
                   raise "Log directory does not exist: #{config.log_dir}"
                 end
                 config.log_dir +
                   "/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"
               end
               def log(str)
                 if config.talkative
                   puts str
                 end
                 if config.logging
                   fp = File.open(log_file_name,"a")
                   fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def display_manual
                 puts <<USAGE
               Grader.
               using: (1) grader
                      (2) grader environment [mode] [options]
                      (3) grader stop [all|pids-list]
                      (4) grader --help
               (1) call grader with environment = 'exam', mode = 'queue'
               (2) possible modes are: 'queue', 'test_request', 'prob', 'sub', 'contest', and 'autonew'
                 queue: repeatedly check the task queue and grade any available tasks
                 prob:  re-grade every user latest submission of the specific problem.
                        the problem name must be specified by the next argument.
                        additional options:
                           --all-sub      re-grade every submissions instead of just the latest submission of each user.
+            + 	    --only-error   re-grade only submissions that are "error during grading"
                 sub:   re-grader the specified submission.
                        The submission ID to be re-graded must be specified by the next argument.
                 options:
                   --err-log   log error to a file in the log dir
               (3) create stop-file to stop running grader in queue mode
               (4) You are here.
               USAGE
               end
               def process_options_and_stop_file
                 # The list of options are:
                 #   - stop [all|process ids]
                 #   -
                 # Process 'help' option
                 if (ARGV.length==1) and (/help/.match(ARGV[0]))
                   display_manual
                   exit(0)
                 end
                 # Process 'stop' option.
                 if (ARGV.length >= 1) and (ARGV[0]=='stop')
                   if ARGV.length==1
                     puts "you should specify pid-list or 'all'"
                     display_manual
                   elsif (ARGV.length==2) and (ARGV[1]=='all')
                     stop_grader(:all)
                     puts "A global stop file ('stop.all') created."
                     puts "You should remove it manually later."
                   else
                     (1..ARGV.length-1).each do |i|
                       stop_grader(ARGV[i])
                     end
                     puts "stop file(s) created"
                   end
                   exit(0)
                 end
                 # Check stop file.
                 if check_stopfile
                   puts "Stop file exists.  Terminated."
                   clear_stopfile
                   exit(0)
                 end
                 #default options
                 options = {
                   :mode => 'queue',
                   :environment => 'exam',
                   :dry_run => false,
                 }
                 # Process mode and environment option
                 if ARGV.length >= 1
                   options[:environment] = ARGV.shift
                   if ARGV.length >=1
                     options[:mode] = ARGV.shift
                   end
                 else
                   puts 'no argument specified, using default mode and environment.'
                 end
                 options[:dry_run] = (ARGV.delete('--dry') != nil)
                 if options[:dry_run] and (not ['prob','contest','autonew'].include? options[:mode])
                   puts "Dry run currently works only for 'prob' or 'contest' modes."
                   exit(0)
                 end
                 options[:report] = (ARGV.delete('--report') != nil)
                 if options[:report] and (not ['prob','contest','autonew'].include? options[:mode])
                   puts "Report currently works only for 'prob' or 'contest' modes."
                   exit(0)
                 end
                 options[:all_sub] = (ARGV.delete('--all-sub') != nil)
+            +   options[:only_err] = (ARGV.delete('--only-error') != nil)
                 options[:err_log] = (ARGV.delete('--err-log') != nil)
                 return options
               end
               class ResultCollector
                 def initialize
                   @results = {}
                   @problems = {}
                   @users = {}
                 end
                 def after_save_hook(submission, grading_result)
                 end
                 def save(submission, grading_result)
                   user = submission.user
                   problem = submission.problem
                   if not @problems.has_key? problem.id
                     @problems[problem.id] = problem
                   end
                   if not @users.has_key? user.id
                     @users[user.id] = user
                   end
                   @results[[user.id, problem.id]] = grading_result
                   after_save_hook(submission, grading_result)
                 end
                 def print_report_by_user
                   puts "---------------------"
                   puts "       REPORT"
                   puts "---------------------"
                   print "login,email"
                   @problems.each_value do |problem|
                     print ",#{problem.name}"
                   end
                   print "\n"
                   @users.each_value do |user|
                     print "#{user.login},#{user.email}"
                     @problems.each_value do |problem|
                       if @results.has_key? [user.id, problem.id]
                         print ",#{@results[[user.id,problem.id]][:points]}"
                       else
                         print ","
                       end
                     end
                     print "\n"
                   end
                 end
               end
               def grader_general_loop(engine, grader_proc, options)
                 runner = Grader::Runner.new(engine, grader_proc)
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     log "stopped (with stop file)"
                     break
                   end
                   task = yield(runner)
                   if task==nil
                     sleep(1)
                   end
                 end
               end
               def grader_queue_loop(grader_proc, options)
                 log "Grader: queue"
                 engine = Grader::Engine.new
                 grader_general_loop(engine, grader_proc, options) do |runner|
                   runner.grade_oldest_task
                 end
               end
               def grader_test_request_loop(grader_proc, options)
                 log "Grader: test_request"
                 engine = Grader::Engine.new(:room_maker => Grader::TestRequestRoomMaker.new,
                                             :reporter => Grader::TestRequestReporter.new)
                 grader_general_loop(engine, grader_proc, options) do |runner|
                   runner.grade_oldest_test_request
                 end
               end
               def grader_autonew_loop(grader_proc, options)
                 log "Grader: autonew"
                 if options[:report]
                   result_collector = ResultCollector.new
                 else
                   result_collector = nil
                 end
                 if options[:dry_run]
                   puts "Running in dry mode"
                 end
                 prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
                                                                :result_collector => result_collector)
                 engine = Grader::Engine.new(:reporter => prob_reporter)
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 latest_submitted_at = nil
                 graded_submission_ids = {}
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     log "stopped (with stop file)"
                     break
                   end
                   if latest_submitted_at==nil
                     submissions = Submission.all
                   else
                     submissions = Submission.all(:conditions => ["submitted_at >= :latest",
                                                                  {:latest => latest_submitted_at}])
                   end
                   graded_any = false
                   if submissions.length != 0
                     submissions.each do |submission|
                       if (submission.problem == nil) or (!submission.problem.available)
                         next
                       end
                       if ! graded_submission_ids[submission.id]
                         runner.grade_submission(submission)
                         graded_submission_ids[submission.id] = true
                         if (!latest_submitted_at or
                             latest_submitted_at < submission.submitted_at)
                           latest_submitted_at = submission.submitted_at
                         end
                         puts "graded: #{submission.id}"
                         puts "latest: #{latest_submitted_at}"
                         graded_any = true
                       end
                     end
                   end
                   if ! graded_any
                     sleep(1)
                   end
                 end
               end
               def grader_grade_problems(grader_proc, options)
                 if options[:report]
                   result_collector = ResultCollector.new
                 else
                   result_collector = nil
                 end
                 if options[:dry_run]
                   puts "Running in dry mode"
                 end
                 prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
                                                                :result_collector => result_collector)
                 engine = Grader::Engine.new(:reporter => prob_reporter)
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 ARGV.each do |prob_name|
                   prob = Problem.find_by_name(prob_name)
                   if prob==nil
                     puts "cannot find problem: #{prob_name}"
                   else
                     runner.grade_problem(prob,options)
                   end
                 end
                 if options[:report]
                   result_collector.print_report_by_user
                 end
               end
               def grader_grade_contests(grader_proc, options)
                 # always use dry run when grading during contest
                 dry_run = options[:dry_run] = true

lib/runner.rb ¶ +6 -2

               #
               # A runner drives the engine into various tasks.
               #
               module Grader
                 class Runner
                   def initialize(engine, grader_process=nil)
                     @engine = engine
                     @grader_process = grader_process
                   end
                   def grade_oldest_task
                     task = Task.get_inqueue_and_change_status(Task::STATUS_GRADING)
                     if task!=nil
                       @grader_process.report_active(task) if @grader_process!=nil
                       submission = Submission.find(task.submission_id)
                       @engine.grade(submission)
                       task.status_complete!
                       @grader_process.report_inactive(task) if @grader_process!=nil
                     end
                     return task
                   end
                   def grade_problem(problem, options={})
+            +       user_index = 0
+            +       user_count = User.count
                     User.find_each do |u|
-            -         puts "user: #{u.login}"
+            +         puts "user: #{u.login} (#{user_index}/#{user_count})"
+            +         user_index += 1
                       if options[:user_conditions]!=nil
                         con_proc = options[:user_conditions]
                         next if not con_proc.call(u)
                       end
                       if options[:all_sub]
                         Submission.where(user_id: u.id,problem_id: problem.id).find_each do |sub|
+            +             next if options[:only_err] and sub.grader_comment != 'error during grading'
                           @engine.grade(sub)
                         end
                       else
                         last_sub = Submission.find_last_by_user_and_problem(u.id,problem.id)
                         if last_sub!=nil
-            -             @engine.grade(last_sub)
+            +             @engine.grade(last_sub) unless options[:only_err] and last_sub.grader_comment != 'error during grading'
                         end
                       end
                     end
                   end
                   def grade_submission(submission)
                     puts "Submission: #{submission.id} by #{submission.try(:user).try(:full_name)}"
                     @engine.grade(submission)
                   end
                   def grade_oldest_test_request
                     test_request = TestRequest.get_inqueue_and_change_status(Task::STATUS_GRADING)
                     if test_request!=nil
                       @grader_process.report_active(test_request) if @grader_process!=nil
                       @engine.grade(test_request)
                       test_request.status_complete!
                       @grader_process.report_inactive(test_request) if @grader_process!=nil
                     end
                     return test_request
                   end
                 end
               end

lib/submission_helper.rb ¶ +3 -1

               module Grader
                 class SubmissionRoomMaker
                   def initialize
                     @config = Grader::Configuration.get_instance
                   end
                   def produce_grading_room(submission)
                     user = submission.user
                     problem = submission.problem
                     grading_room = "#{@config.user_result_dir}/" +
                       "#{user.login}/#{problem.name}/#{submission.id}"
                     FileUtils.mkdir_p(grading_room)
                     grading_room
                   end
                   def find_problem_home(submission)
                     problem = submission.problem
                     "#{@config.problems_dir}/#{problem.name}"
                   end
                   def save_source(submission,source_name)
                     dir = self.produce_grading_room(submission)
                     f = File.open("#{dir}/#{source_name}","w")
                     f.write(submission.source)
                     f.close
                   end
                   def clean_up(submission)
                   end
                 end
                 class SubmissionReporter
                   def initialize(options={})
                     options = {:dry_run => false, :result_collector => nil}.merge(options)
                     @config = Grader::Configuration.get_instance
                     @dry_run = options[:dry_run]
                     @result_collector = options[:result_collector]
                   end
                   def report(sub,test_result_dir)
                     result = read_result(test_result_dir)
                     if @result_collector
                       @result_collector.save(sub,
                                              result)
                     end
                     save_result(sub,result)
                   end
                   def report_error(sub,msg)
                     save_result(sub,{:points => 0,
                                   :comment => "Grading error: #{msg}" })
                   end
                   protected
                   def read_result(test_result_dir)
                     cmp_msg_fname = "#{test_result_dir}/compiler_message"
                     if FileTest.exist?(cmp_msg_fname)
                       cmp_file = File.open(cmp_msg_fname)
                       cmp_msg = cmp_file.read
                       cmp_file.close
                     else
                       cmp_msg = ""
                     end
                     result_fname = "#{test_result_dir}/result"
                     comment_fname = "#{test_result_dir}/comment"
                     runstat_fname = "#{test_result_dir}/run_stat"
                     if FileTest.exist?(result_fname)
                       comment = ""
                       begin
                         result_file = File.open(result_fname)
                         result = result_file.readline.to_i
                         result_file.close
                       rescue
                         result = 0
                         comment = "error reading result file."
                       end
                       begin
                         comment_file = File.open(comment_fname)
                         comment += comment_file.readline.chomp
                         comment_file.close
                       rescue
                         comment += ""
                       end
                       begin
                         runstat_file = File.open(runstat_fname)
                         max_runtime = runstat_file.readline.to_f
                         peak_memory = runstat_file.readline.to_i
                       rescue
                         max_runtime = -1
                         peak_memory = -1
                       end
                       return {points: result,
                         comment: comment,
                         cmp_msg: cmp_msg,
                         max_runtime: max_runtime,
                         peak_memory: peak_memory
                       }
                     else
                       if FileTest.exist?("#{test_result_dir}/a.out")
                         return {:points => 0,
                           :comment => 'error during grading',
                           :cmp_msg => cmp_msg}
                       else
                         return {:points => 0,
                           :comment => 'compilation error',
                           :cmp_msg => cmp_msg}
                       end
                     end
                   end
                   def save_result(submission,result)
                     problem = submission.problem
                     submission.graded_at = Time.now.gmtime
                     points = result[:points]
                     submission.points = points
                     comment = @config.report_comment(result[:comment])
                     submission.peak_memory = result[:peak_memory]
                     submission.max_runtime =  result[:max_runtime]
                     submission.effective_code_length =submission.source.length
                     #
                     # TODO: FIX THIS MESSAGE
                     #
                     if problem == nil
                       submission.grader_comment = 'PASSED: ' + comment + '(problem is nil)'
                     elsif points == problem.full_score
                       #submission.grader_comment = 'PASSED: ' + comment
                       submission.grader_comment = comment
                     elsif result[:comment].chomp =~ /^[\[\]P]+$/
                       submission.grader_comment = 'PASSED: ' + comment + '(inconsistent score)'
                     else
                       #submission.grader_comment = 'FAILED: ' + comment
                       submission.grader_comment = comment
                     end
-            -       submission.compiler_message = result[:cmp_msg] or ''
+            +       #very lazy trim the string
+            +       submission.compiler_message = result[:cmp_msg][0..60000] or ''
                     if not @dry_run
                       submission.save
                     end
                   end
                 end
               end

std-script/run ¶ +3 -3

               #!/usr/bin/env ruby
               require 'fileutils'
               def log(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
                   fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def extract_time(t)
                 #  puts "TIME: #{t}"
                 if (result=/^(.*)r(.*)u(.*)s/.match(t))
                   {:real => result[1], :user => result[2], :sys => result[3]}
                 else
                   #{:real => 0, :user => 0, :sys => 0}
                   #puts "ERROR READING RUNNING TIME: #{t}"
                   raise "Error reading running time: #{t}"
                 end
               end
               def compile_box(source,bin)
                 system("g++ #{source} -o #{bin}")
               end
               if ARGV.length < 2 || ARGV.length > 3
                 puts "Usage: run <language> <test-num> [<program-name>]"
                 exit(127)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length > 2
                 program_name = ARGV[2]
               else
                 program_name = "a.out"
               end
               problem_home = ENV['PROBLEM_HOME']
               source_name = ENV['SOURCE_NAME']
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               sandbox_dir = Dir.getwd
               if problem.well_formed? == false
                 log "The problem specification is not well formed."
                 exit(127)
               end
               # Check if the test number is okay.
               if test_num <= 0 || test_num > problem.num_tests
                 log "You have specified a wrong test number."
                 exit(127)
               end
               #####################################
               # Set the relavant file names here. #
               #####################################
               input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
               #####################################
               time_limit = problem.get_time_limit test_num
               mem_limit = problem.get_mem_limit(test_num) * 1024
               # Copy the input file.
               #`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
               # check if box is there, if not, compile it!
               if !File.exists?("#{problem_home}/script/box")
                 log "WARNING: Compiling box: to increase efficiency, it should be compile manually"
                 compile_box("#{problem_home}/script/box.cc",
                             "#{problem_home}/script/box")
               end
               # Hide PROBLEM_HOME
               ENV['PROBLEM_HOME'] = nil
               ENV['SOURCE_NAME'] = nil
               # Run the program.
               #run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
               #
               JAVA_OPTION = "-s set_robust_list -s futex -s clone -s getppid -s clone -s wait4 -p /usr/bin/ -p ./"
-            - RUBY_OPTION   = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -p #{sandbox_dir}/ -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat -s pipe"
+            + RUBY_OPTION   = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -p #{sandbox_dir}/ -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat -s pipe -s getrandom"
               PYTHON_OPTION = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /usr/bin/ -p /lib64/ -p /dev/urandom -p /usr/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -p /proc/sys/crypto/fips_enabled -p /proc/self/status -p /proc/mounts -p /var/lib/dpkg/status -s statfs -s set_robust_list -s openat -s sysinfo -s recvmsg -s connect -s socket -s sendto -s futex -s sigaltstack -s getrandom -E PYTHONNOUSERSITE=yes"
               PHP_OPTION = "-p /usr/lib64/ -p/lib64/ -p /usr/bin/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p /usr/share/ -s setfsuid -s setfsgid -s openat -s set_robust_list -s futex -s clone -s socket -s connect"
               HASKELL_OPTION = "-s set_robust_list -s clock_gettime -s sysinfo -s timer_create -s timer_settime -s futex -s timer_delete"
               case language
                 when "java"
                   # for java, extract the classname
                   # wne have to add additional systemcall and we don't check the mem limit (dunno how to fix...)
                   classname = 'DUMMY'
                   File.open(program_name,"r").each do |line|
                     classname = line
                   end
                   #for java, we cannot really check the memory limit...
                   run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java -A -Xmx#{mem_limit}k -A #{classname} "
                 when "ruby"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{RUBY_OPTION} -i #{input_file_name} -o output.txt /usr/bin/ruby #{program_name} "
                 when "python"
-            -     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[128 * 1024,mem_limit].max} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python3 #{program_name} "
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[512 * 1024,mem_limit].max} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python3 #{program_name} "
                 when "haskell"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{[512 * 1024,mem_limit].max} #{HASKELL_OPTION} -i #{input_file_name} -o output.txt #{program_name} "
                 when "php"
-            -     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[128 * 1024,mem_limit].max} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php -A -d -A memory_limit=#{mem_limit}k -A #{program_name} "
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[512 * 1024,mem_limit].max} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php -A -d -A memory_limit=#{mem_limit}k -A #{program_name} "
                 else # for c++, pascal, we do the normal checking
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} "
               end
               log "Running test #{test_num}..."
               log run_command
               log
               system(run_command,err: 'run_result')
               # Restore PROBLEM_HOME
               ENV['PROBLEM_HOME'] = problem_home
               # Create the result file.
               result_file = File.new("result", "w")
               comment_file = File.new("comment", "w")
               # Check if the program actually produced any output.
               run_result_file = File.new("run_result", "r")
               run_result = run_result_file.readlines
               run_result_file.close
               run_stat = run_result[run_result.length-1]
               running_time = extract_time(run_stat)
               report = lambda{ |status, points, comment|
                 result_file.write status.strip
                 result_file.write "\n"
                 result_file.write points.to_s.strip
                 result_file.write "\n"
                 result_file.write run_stat.strip
                 result_file.write "\n"
                 result_file.close
                 FileUtils.rm "run_result"
                 # `rm output.txt`   --- keep the output
                 comment_file.write comment
                 # added for debuggin --- jittat
                 comment_file.write "--run-result--\n"
                 run_result.each do |l|
                   comment_file.write l
                 end
                 comment_file.close
                 log "Done!"
                 exit(0)
               }
               if run_result[0][0,2] != "OK"
                 log "There was a runtime error."
                 report.call(run_result[0], 0, "No comment.\n")
               end
               if running_time[:user].to_f > time_limit
                 log "Time limit exceeded."
                 report.call("Time limit exceeded", 0, "No comment.\n")
               end
               # Run 'check' to evaluate the output.
               #puts "There was no runtime error. Proceed to checking the output."
               check_command = "#{problem_home}/script/check #{language} #{test_num}"
               log "Checking the output..."
               log check_command
               if not system(check_command)
                 log "Problem with check script"
                 report.call("Incorrect",0,"Check script error.\n")
                 exit(127)
               end
               check_file = File.new("check_result", "r")
               check_file_lines = check_file.readlines
               report.call(check_file_lines[0], check_file_lines[1], "No comment.\n")

grader-process-check removed ¶ -6

deleted file

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r253:0654ec1bf773 - Tue, 12 Jun 2018 13:11:37 - 6 files changed: 23 inserted, 12 deleted

Sign in to your account

Commit r253:0654ec1bf773 public

Author

r253:0654ec1bf773 - Tue, 12 Jun 2018 13:11:37 - 6 files changed: 23 inserted, 12 deleted

Commit `r253:0654ec1bf773` public