cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r99:f439789e790b` public

parent | child

Description:

removed 'system' from grader, grader_id, import_problem

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

r99:f439789e790b - Sat, 24 Apr 2010 09:22:26 - 3 files changed: 14 inserted, 32 deleted

grader ¶ +1 -1

               #!/usr/bin/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}")
-            -     system("rm " + 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]
                      (3) grader stop [all|pids-list]
                      (4) grader --help
               (1) call grader with environment = 'exam', mode = 'queue'
               (2) possible modes are: 'queue', 'prob', 'test_request'
               (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
                 end
                 options[:dry_run] = (ARGV.delete('--dry') != nil)
                 if options[:dry_run] and (not ['prob','contest'].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'].include? options[:mode])
                   puts "Report currently works only for 'prob' or 'contest' modes."
                   exit(0)
                 end
                 return options
               end
               class ResultCollector
                 def initialize
                   @results = {}
                   @problems = {}
                   @users = {}
                 end
                 def save(user, problem, grading_result)
                   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
                 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
               #########################################
               # main program
               #########################################
               options = process_options_and_stop_file
               GRADER_ENV = options[:environment]
               grader_mode = options[:mode]
               dry_run = options[:dry_run]
               puts "environment: #{GRADER_ENV}"
               require File.join(File.dirname(__FILE__),'config/environment')
               # add grader_mode to config
               # this is needed because method log needs it.  TODO: clean this up
               class << config
                 attr_accessor :grader_mode
               end
               config.grader_mode = grader_mode
               # reading rails environment
               log 'Reading rails environment'
               RAILS_ENV = config.rails_env
               require RAILS_ROOT + '/config/environment'
               # register grader process
               if config.report_grader
                 grader_proc = GraderProcess.register(config.grader_hostname,
                                                      Process.pid,
                                                      grader_mode)
               else
                 grader_proc = nil
               end
               #set loggin environment
               ENV['GRADER_LOGGING'] = log_file_name
               # register exit handler to report inactive, and terminated
               at_exit do
                 if grader_proc!=nil
                   grader_proc.report_inactive
                   grader_proc.terminate
                 end
               end

grader_id ¶ -21

               #!/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
-            - def stop_grader
-            -   File.open(File.dirname(__FILE__) + '/stop','w')
-            - end
-            - def check_stopfile
-            -   FileTest.exist?(File.dirname(__FILE__) + '/stop')
-            - end
-            - def clear_stopfile
-            -   system("rm " + File.dirname(__FILE__) + '/stop')
-            - end
               # reading environment and options
               GRADER_ENV = 'exam'
               puts "environment: #{GRADER_ENV}"
               require File.dirname(__FILE__) + "/environment.rb"
               #main program
               talk 'Reading rails environment'
               RAILS_ENV = 'development'
               require RAILS_APP_DIR + '/config/environment'
               current_dir = `pwd`
               grade(ARGV[0].to_i)

import_problem ¶ +13 -10

               #!/usr/bin/ruby
               require 'erb'
+            + require 'ftools'
               require 'fileutils'
               require File.join(File.dirname(__FILE__),'lib/import_helper')
               JUDGE_ENVIRONMENTS = [:grading, :exam]
               ENV_INFO = {
                 :grading => {
                   :ev_dir => 'ev',
                   :raw_prefix => '',
                 },
                 :exam => {
                   :ev_dir => 'ev-exam',
                   :raw_prefix => 'ex.',
                 }
               }
               def input_filename(dir,i)
                 "#{dir}/input-#{i}.txt"
               end
               def answer_filename(dir,i)
                 "#{dir}/answer-#{i}.txt"
               end
               def build_testrun_info_from_dir(num_testruns, importing_test_dir, raw_prefix='')
                 filenames = Dir["#{importing_test_dir}/#{raw_prefix}*.in"].collect do |filename|
                   File.basename((/(.*)\.in/.match(filename))[1])
                 end
                 build_testrun_info(num_testruns,filenames,raw_prefix)
               end
               def copy_testcase(importing_test_dir,fname,dir,i)
-            -   system("cp #{importing_test_dir}/#{fname}.in #{input_filename(dir,i)}")
+            +   File.copy("#{importing_test_dir}/#{fname}.in", "#{input_filename(dir,i)}")
-            -   system("cp #{importing_test_dir}/#{fname}.sol #{answer_filename(dir,i)}")
+            +   File.copy("#{importing_test_dir}/#{fname}.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_f 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
               def print_usage
                 puts "using: import_problem_new name dir check [options]
               where: name = problem_name (put '-' (dash) to use dir name)
                      dir = importing testcase directory
                      check = check script, which can be
                              'integer', 'text' (for standard script),
                              path_to_your_script, or
                              'wrapper:(path_to_your_wrapped_script)'
               options: -t time-limit (in seconds)
                        -m memory-limit (in megabytes)
               The script looks at test data files in the dir of the forms: *.in and
               *.sol and import them to the evaluation dir for their environment,
               based on their prefixes.
               Currently supporting environments are:"
                 JUDGE_ENVIRONMENTS.each do |env|
                   prefix = ENV_INFO[env][:raw_prefix]
                   prefix = 'no prefix' if prefix==''
                   puts "  * #{env}"
                   puts "      import to: #{ENV_INFO[env][:ev_dir]}"
                   puts "      prefix with: #{prefix}  (e.g., #{ENV_INFO[env][:raw_prefix]}1.in, #{ENV_INFO[env][:raw_prefix]}5a.sol)"
                 end
                 puts"
               For each environment, the script
                 * creates a directory for a problem in ev dir of that environment,
                 * copies testdata in the old format and create standard testcase config file
                 * copies a check script for grading
                 * creates a test_request template in the ev dir + '/test_request'
               For wrapped checked script see comment in templates/check_wrapper for
                 information."
               end
               def count_testruns(testcase_dir, raw_prefix)
                 n = 0
                 begin
                   # check for test case n+1
                   if ((Dir["#{testcase_dir}/#{raw_prefix}#{n+1}.in"].length==0) and
                       (Dir["#{testcase_dir}/#{raw_prefix}#{n+1}[a-z].in"].length==0))
                     return n
                   end
                   n += 1
                 end while true
               end
               def import_problem(ev_dir, problem, testcase_dir, num_testruns, raw_prefix, check_script, options)
                 testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir, raw_prefix)
                 if !(FileTest.exists? ev_dir)
                   puts "Testdata dir (#{ev_dir}) not found."
                   return
                 end
                 problem_dir = "#{ev_dir}/#{problem}"
                 # start working
                 puts "creating directories"
-            -   system("mkdir #{problem_dir}")
+            +   File.makedirs("#{problem_dir}")
-            -   system("mkdir #{problem_dir}/script")
+            +   File.makedirs("#{problem_dir}/script")
-            -   system("mkdir #{problem_dir}/test_cases")
+            +   File.makedirs("#{problem_dir}/test_cases")
                 puts "copying testcases"
                 tr_num = 0
                 num_testcases = 0
                 testrun_info.each do |testrun|
                   tr_num += 1
                   puts "testrun: #{tr_num}"
                   testrun.each do |testcase_info|
                     testcase_num, testcase_fname = testcase_info
                     puts "copy #{testcase_fname} to #{testcase_num}"
-            -       system("mkdir #{problem_dir}/test_cases/#{testcase_num}")
+            +       File.makedirs("#{problem_dir}/test_cases/#{testcase_num}")
                     copy_testcase("#{testcase_dir}",testcase_fname,"#{problem_dir}/test_cases/#{testcase_num}",testcase_num)
                     num_testcases += 1
                   end
                 end
                 # generating all_tests.cfg
                 puts "generating testcase config file"
                 template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
                 all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{problem_dir}/test_cases/all_tests.cfg","w")
                 cfg_file.puts all_test_cfg.result binding
                 cfg_file.close
                 # copy check script
                 if res = /^wrapper:(.*)$/.match(check_script)
                   # wrapper script
                   check_script_fname = res[1]
                   script_name = File.basename(check_script_fname)
                   check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
                   check_wrapper = ERB.new(check_wrapper_template)
                   check_file = File.open("#{problem_dir}/script/check","w")
                   check_file.puts check_wrapper.result binding
                   check_file.close
                   File.chmod(0755,"#{problem_dir}/script/check")
-            -     system("cp #{check_script_fname} #{problem_dir}/script/#{script_name}")
+            +     File.copy("#{check_script_fname}", "#{problem_dir}/script/#{script_name}")
                 else
                   if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
                     check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
                   else
                     check_script_fname = check_script
                   end
-            -     system("cp #{check_script_fname} #{problem_dir}/script/check")
+            +     File.copy("#{check_script_fname}", "#{problem_dir}/script/check")
                 end
                 # generating test_request directory
                 puts "generating test_request template"
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/script")
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/test_cases/1")
                 template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
                 test_request_all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{ev_dir}/test_request/#{problem}/test_cases/all_tests.cfg","w")
                 cfg_file.puts test_request_all_test_cfg.result
                 cfg_file.close
-            -   system("cp #{SCRIPT_DIR}/templates/check_empty #{ev_dir}/test_request/#{problem}/script/check")
+            +   File.copy("#{SCRIPT_DIR}/templates/check_empty",
-            -   system("cp #{SCRIPT_DIR}/templates/answer-1.txt #{ev_dir}/test_request/#{problem}/test_cases/1")
+            +             "#{ev_dir}/test_request/#{problem}/script/check")
+            +   File.copy("#{SCRIPT_DIR}/templates/answer-1.txt",
+            +             "#{ev_dir}/test_request/#{problem}/test_cases/1")
                 puts "done"
               end
               SCRIPT_DIR = File.dirname(__FILE__)
               # print usage
               if (ARGV.length < 3) or (ARGV[2][0,1]=="-")
                 print_usage
                 exit(127)
               end
               # processing arguments
               problem = ARGV[0]
               testcase_dir = ARGV[1]
               problem = File.basename(testcase_dir) if problem=="-"
               check_script = ARGV[2]
               options = {:time_limit => 1,  :mem_limit => 16}
               process_options(options)
               JUDGE_ENVIRONMENTS.each do |env|
                 ev_dir = ENV_INFO[env][:ev_dir]
                 raw_prefix = ENV_INFO[env][:raw_prefix]
                 num_testruns = count_testruns(testcase_dir,raw_prefix)
                 puts ""
                 puts "*** Environment: #{env} (#{num_testruns} test runs) ***"
                 puts ""
                 import_problem(ev_dir,
                                problem,
                                testcase_dir,
                                num_testruns,
                                raw_prefix,
                                check_script,
                                options)
               end

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

r99:f439789e790b - Sat, 24 Apr 2010 09:22:26 - 3 files changed: 14 inserted, 32 deleted

Sign in to your account

Commit r99:f439789e790b public

Author

r99:f439789e790b - Sat, 24 Apr 2010 09:22:26 - 3 files changed: 14 inserted, 32 deleted

Commit `r99:f439789e790b` public