cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r123:57e6d251108e` public

parent | child

Description:

sends whole submission to result collecter in submission reporter, instead of just user and 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

r123:57e6d251108e - Sun, 02 May 2010 05:37:30 - 2 files changed: 6 inserted, 5 deleted

grader ¶ +5 -3

               #!/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}")
                   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', 'test_request', 'prob', 'sub', 'contest', and 'autonew'
               (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','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
                 return options
               end
               class ResultCollector
                 def initialize
                   @results = {}
                   @problems = {}
                   @users = {}
                 end
-            -   def after_save_hook(user, problem, grading_result)
+            +   def after_save_hook(submission, grading_result)
                 end
-            -   def save(user, problem, grading_result)
+            +   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(user, problem, 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 ! 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)
                   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
                 contest_name = ARGV.shift
                 contest = Contest.find_by_name(contest_name)
                 if contest==nil
                   puts "cannot find contest: #{contest_name}"
                   exit(0)
                 end
                 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 => 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
                 contest.problems.each do |problem|
                   puts "Grading: #{problem.name}"
                   runner.grade_problem(problem,
                                        :user_conditions => lambda do |u|
                                          u.contest_finished? and
                                            u.contest_ids.include?(contest.id)

lib/submission_helper.rb ¶ +1 -2

               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.user,
+            +         @result_collector.save(sub,
-            -                                sub.problem,
                                              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"
                     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
                       return {:points => result,
                         :comment => comment,
                         :cmp_msg => cmp_msg}
                     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])
                     #
                     # 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 ''
                     if not @dry_run
                       submission.save
                     end
                   end
                 end
               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

r123:57e6d251108e - Sun, 02 May 2010 05:37:30 - 2 files changed: 6 inserted, 5 deleted

Sign in to your account

Commit r123:57e6d251108e public

Author

r123:57e6d251108e - Sun, 02 May 2010 05:37:30 - 2 files changed: 6 inserted, 5 deleted

Commit `r123:57e6d251108e` public