cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r3:4a517b89268a` public

parent | child

Description:

fix bugs: paths, check compilation error, all_tests.cfg.erb git-svn-id: http://theory.cpe.ku.ac.th/grader/cli/trunk/scripts@15 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r3:4a517b89268a - Thu, 17 Jan 2008 14:02:35 - 4 files changed: 24 inserted, 18 deleted

all_tests.cfg.erb created 755 ¶ +13

@@ -0,0 +1,13
	1	+ problem do
	2	+ num_tests <%= num_testcases %>
	3	+ full_score <%= num_testcases*10 %>
	4	+ time_limit_each <%= options[:time_limit] %>
	5	+ mem_limit_each <%= options[:mem_limit] %>
	6	+ score_each 10
	7	+
	8	+ <% 1.upto(num_testcase) do \|i\| %>
	9	+ run <%= i %>
	10	+ tests <%= i %>
	11	+ end
	12	+ <% end %>
	13	+ end

grader ¶ +8 -6

               #!/usr/bin/ruby
               def talk(str)
                 if TALKATIVE
                   puts str
                 end
               end
               def execute(command, error_message="")
                 if not system(command)
                   puts "ERROR: #{error_message}"
                   exit(127)
                 end
               end
               def save_source(submission,dir,fname)
                 f = File.open("#{dir}/#{fname}","w")
                 f.write(submission.source)
                 f.close
               end
               def call_judge(problem_home,language,problem_out_dir,fname)
                 ENV['PROBLEM_HOME'] = problem_home
                 Dir.chdir problem_out_dir
                 cmd = "#{problem_home}/script/judge #{language} #{fname}"
               #  puts "CMD: #{cmd}"
                 system(cmd)
               end
               def read_result(test_result_dir)
                 cmp_msg_fname = "#{test_result_dir}/compiler_message"
                 cmp_msg = File.open(cmp_msg_fname).read
                 result_fname = "#{test_result_dir}/result"
                 comment_fname = "#{test_result_dir}/comment"
                 if FileTest.exist?(result_fname)
                   result = File.open(result_fname).readline.to_i
                   comment = File.open(comment_fname).readline.chomp
                   return {:points => result,
                     :comment => comment,
                     :cmp_msg => cmp_msg}
                 else
                   return {:points => 0,
                     :comment => 'compile error',
                     :cmp_msg => cmp_msg}
                 end
               end
               def save_result(submission,result)
                 submission.graded_at = Time.now
                 submission.points = result[:points]
                 submission.grader_comment = report_comment(result[:comment])
                 submission.compiler_message = result[:cmp_msg]
                 submission.save
               end
               def grade(submission_id)
                 sub = Submission.find(submission_id)
                 user = sub.user
                 problem = sub.problem
                 language = sub.language.name
                 lang_ext = sub.language.ext
                 # FIX THIS
                 talk 'some hack on language'
                 if language == 'cpp'
                   language = 'c++'
                 end
                 user_dir = "#{USER_RESULT_DIR}/#{user.login}"
                 Dir.mkdir(user_dir) if !FileTest.exist?(user_dir)
                 problem_out_dir = "#{user_dir}/#{problem.name}"
                 Dir.mkdir(problem_out_dir) if !FileTest.exist?(problem_out_dir)
                 problem_home = "#{PROBLEMS_DIR}/#{problem.name}"
                 source_name = "#{problem.name}.#{lang_ext}"
                 save_source(sub,problem_out_dir,source_name)
                 call_judge(problem_home,language,problem_out_dir,source_name)
                 save_result(sub,read_result("#{problem_out_dir}/test-result"))
               end
               # reading environment
               GRADER_ENV = 'exam'
               if ARGV.length > 1
                 GRADER_ENV = ARGV[1]
               end
               require File.dirname(__FILE__) + "/environment.rb"
               #main program
               talk 'Reading rails environment'
               RAILS_ENV = 'development'
               require RAILS_APP_DIR + '/config/environment'
               current_dir = `pwd`
               talk 'Grader queue'
-            - task = Task.find(:first, :order => 'created_at')
+            + while true
-            - if task!=nil
+            +   task = Task.find(:first, :order => 'created_at')
-            -   grade(task.submission_id)
+            +   if task!=nil
-            -   task.destroy
+            +     grade(task.submission_id)
-            - else
+            +     task.destroy
-            -   puts "No job"
+            +   else
+            +     sleep(1)
+            +   end
               end

import_problem ¶ +2 -11

               #!/usr/bin/ruby
               # import_problem:
               #  * creates a directory for a problem in the current directory,
               #  * copy standard scripts
               #  * copy testdata in the old format and create standard testcase config file
               require 'erb'
               def input_filename(dir,i)
                 "#{dir}/input-#{i}.txt"
               end
               def answer_filename(dir,i)
                 "#{dir}/answer-#{i}.txt"
               end
               def copy_testcase(importing_test_dir,dir,i)
                 system("cp #{importing_test_dir}/#{i}.in #{input_filename(dir,i)}")
                 system("cp #{importing_test_dir}/#{i}.sol #{answer_filename(dir,i)}")
               end
               def process_options(options)
                 i = 3
                 while i<ARGV.length
                   if ARGV[i]=='-t'
                     options[:time_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   if ARGV[i]=='-m'
                     options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   i += 1
                 end
               end
               GRADER_DIR = File.dirname(__FILE__)
               # print usage
               if ARGV.length < 3
                 puts "using: import_task problem importing_testcase_dir number_of_testcase [options]"
                 exit(127)
               end
               # processing arguments
               problem = ARGV[0]
               testcase_dir = ARGV[1]
               num_testcases = ARGV[2].to_i
               options = {:time_limit => 1,  :mem_limit => 16}
               process_options(options)
               # start working
               puts "creating directories"
               system("mkdir #{problem}")
               system("mkdir #{problem}/script")
               system("mkdir #{problem}/test_cases")
               system("cp #{GRADER_DIR}/std-script/* #{problem}/script")
               puts "copying testcases"
 .upto(num_testcases) do |i|
                 system("mkdir #{problem}/test_cases/#{i}")
                 copy_testcase("#{testcase_dir}","#{problem}/test_cases/#{i}",i)
               end
               # generating all_tests.cfg
               puts "generating testcase config file"
-            - template = %q{
+            + template = File.open("all_tests.cfg.erb").readlines
-            - problem do
-            -   num_tests <%= num_testcases %>
-            -   full_score <%= num_testcases*10 %>
-            -   time_limit_each <%= options[:time_limit] %>
-            -   mem_limit_each <%= options[:mem_limit] %>
-            -   score_each 10
-            - end
-            - }
               all_test_cfg = ERB.new(template)
-            - cfg_file = File.open("#{problem}/test_cases/all_test.cfg","w")
+            + cfg_file = File.open("#{problem}/test_cases/all_tests.cfg","w")
               cfg_file.puts all_test_cfg.result
               cfg_file.close
               puts "done"

std-script/judge ¶ +1 -1

               #!/usr/bin/ruby
               problem_home = ENV['PROBLEM_HOME']
               def execute(command, error_message="")
                 if not system(command)
                   puts "ERROR: #{error_message}"
                   exit(127)
                 end
               end
               # ARGV[0] --- language
               # ARGV[1] --- program source file
               # ARGV[2] --- test result directory
               # ARGV[3] --- sandbox directory
               if ARGV.length < 2 || ARGV.length > 4
                 puts "Usage: judge <language> <program-source> [<test-result-directory>] [<sandbox-directory>]"
                 puts "  <sandbox-directory> is defaulted to ./sandbox"
                 puts "  <test-result-directory> is defaulted to ./test-result"
                 puts "WARNING: The judge script will forcefully create the (implicitly and explicitly) specified directories and remove anything inside it."
                 exit(127)
               end
               language = ARGV[0]
               if language != "c" && language != "c++" && language != "pascal"
                 puts "You specified a language that is not supported."
                 exit(127)
               end
               source_file = ARGV[1]
               if File.exist?(source_file) == false
                 puts "The source file does not exist."
                 exit(127)
               end
               puts "Making test result and sandbox directories..."
               current_dir = `pwd`
               current_dir.strip!
               if ARGV.length >= 3
                 test_result_dir = ARGV[2]
               else
                 test_result_dir = "#{current_dir}/test-result"
               end
               puts "Test result directory: #{test_result_dir}"
               system("rm -Rf #{test_result_dir}")
               execute("mkdir #{test_result_dir}", "Cannot make directory #{test_result_dir}.")
               if ARGV.length >= 4
                 sandbox_dir = ARGV[3]
               else
                 sandbox_dir = "#{current_dir}/sandbox"
               end
               puts "Sandbox directory: #{sandbox_dir}"
               system("rm -Rf #{sandbox_dir}")
               execute("mkdir #{sandbox_dir}", "Cannot make directory #{sandbox_dir}")
               # Compile
               puts
               puts "Compiling..."
               execute("cp #{source_file} #{sandbox_dir}", "Cannot copy the source file to #{sandbox_dir}")
               begin
                 Dir.chdir sandbox_dir
               rescue
                 puts "ERROR: Cannot change directory to #{sandbox_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/compile #{language} #{source_file}", "Compilation error!")
               compile_message = `cat compiler_message`
               compile_message.strip!
               execute("mv compiler_message #{test_result_dir}", "Cannot move the compiler message to #{test_result_dir}.")
-            - if compile_message != ""
+            + if !FileTest.exist?("a.out")
                 puts "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
                 exit(127)
               else
                 execute("mv a.out #{test_result_dir}", "Cannot move the compiled program to #{test_result_dir}")
                 system("rm -Rf #{sandbox_dir}/*")
               end
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               if problem.well_formed? == false
                 puts "The problem specification is not well formed."
                 exit(127)
               end
               # Doing the testing.
               (1..(problem.num_tests)).each do |test_num|
                 puts
                 execute("cp #{test_result_dir}/a.out #{sandbox_dir}", "Cannot copy the compiled program into #{sandbox_dir}")
                 execute("#{problem_home}/script/run #{language} #{test_num}", "Error occured during execution of the run script")
                 execute("mkdir #{test_result_dir}/#{test_num}", "Cannot create directory #{test_result_dir}/#{test_num}")
                 execute("mv #{sandbox_dir}/result #{test_result_dir}/#{test_num}", "Cannot copy the result file into #{test_result_dir}/#{test_num}")
                 execute("mv #{sandbox_dir}/comment #{test_result_dir}/#{test_num}", "Cannot copy the comment file into #{test_result_dir}/#{test_num}")
                 execute("rm -Rf #{sandbox_dir}/*", "Cannot clear #{sandbox_dir}")
               end
               # Grade
               puts
               puts "Grading..."
               begin
                 Dir.chdir test_result_dir
               rescue
                 puts "ERROR: Cannot change directory to #{test_result_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/grade", "An error occured during grading!")
               puts
               puts "All done!"

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

r3:4a517b89268a - Thu, 17 Jan 2008 14:02:35 - 4 files changed: 24 inserted, 18 deleted

Sign in to your account

Commit r3:4a517b89268a public

Author

r3:4a517b89268a - Thu, 17 Jan 2008 14:02:35 - 4 files changed: 24 inserted, 18 deleted

Commit `r3:4a517b89268a` public