cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r174:09d1e857c1e3` public

parent | child

Description:

add more logging

Commit status:

[Not Reviewed]

References:

algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r174:09d1e857c1e3 - Sun, 28 Sep 2014 04:20:52 - 3 files changed: 17 inserted, 3 deleted

grader ¶ +13 -1

                 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.
-            -             --all-sub    re-grade every submissions instead of just the latest submission of each user.
                 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[: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"
                   rescue ActiveRecord::RecordNotFound
                     puts "Submission #{sub_id} not found"
                     submission = nil
                   end
                   if submission!=nil
                     runner.grade_submission(submission)
                   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}"
               puts "grader mode: #{grader_mode}"
               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
+            + if options[:err_log]
+            +   err_file_name = log_file_name + '.err'
+            +   $stderr.reopen(err_file_name,"a")
+            +   log "STDERR log to file [#{err_file_name}]"
+            +   warn "start logging for grader PID #{Process.id} on #{Time.now.in_time_zone}"
+            + end
+            +
               # register exit handler to report inactive, and terminated
               at_exit do
                 if grader_proc!=nil
                   grader_proc.report_inactive
                   grader_proc.terminate
                 end
               end
               #
               # MAIN LOOP
               #
               case grader_mode
               when "queue"
                 grader_queue_loop(grader_proc, options)
               when "test_request"
                 grader_test_request_loop(grader_proc, options)
               when "prob"
                 grader_grade_problems(grader_proc, options)
               when "contest"
                 grader_grade_contests(grader_proc, options)
               when "sub"
                 grader_grade_submissions(grader_proc, options)
               when "autonew"
                 grader_autonew_loop(grader_proc, options)
               else
                 display_manual
                 exit(0)
               end

lib/engine.rb ¶ +3 -1

                       # puts "PROBLEM DIR: #{problem_home}"
                       if !FileTest.exist?(problem_home)
                         puts "PROBLEM DIR: #{problem_home}"
                         raise "engine: No test data."
                       end
                       dinit = DirInit::Manager.new(problem_home)
                       dinit.setup do
                         copy_log = copy_script(problem_home)
                         save_copy_log(problem_home,copy_log)
                       end
                       call_judge(problem_home,language,grading_dir,source_name)
                       @reporter.report(submission,"#{grading_dir}/test-result")
                       dinit.teardown do
                         copy_log = load_copy_log(problem_home)
                         clear_copy_log(problem_home)
                         clear_script(copy_log,problem_home)
                       end
                     rescue RuntimeError => msg
                       @reporter.report_error(submission, msg)
                       puts "ERROR: #{msg}"
                     ensure
                       @room_maker.clean_up(submission)
                       Dir.chdir(current_dir)   # this is really important
                     end
                   end
                   protected
                   def talk(str)
                     if @config.talkative
                       puts str
                     end
                   end
                   def call_judge(problem_home,language,grading_dir,fname)
                     ENV['PROBLEM_HOME'] = problem_home
                     ENV['RUBYOPT'] = ''
                     talk grading_dir
                     Dir.chdir grading_dir
-            -       cmd = "#{problem_home}/script/judge #{language} #{fname}"
+            +       script_name = "#{problem_home}/script/judge"
+            +       cmd = "#{script_name} #{language} #{fname}"
                     talk "CMD: #{cmd}"
+            +       warn "ERROR: file does not exists #{script_name}" unless File.exists? script_name
                     system(cmd)
                   end
                   def get_std_script_dir
                     GRADER_ROOT + '/std-script'
                   end
                   def copy_script(problem_home)
                     script_dir = "#{problem_home}/script"
                     std_script_dir = get_std_script_dir
                     raise "engine: std-script directory not found" if !FileTest.exist?(std_script_dir)
                     scripts = Dir[std_script_dir + '/*']
                     copied = []
                     scripts.each do |s|
                       fname = File.basename(s)
                       next if FileTest.directory?(s)
                       if !FileTest.exist?("#{script_dir}/#{fname}")
                         copied << fname
                         FileUtils.cp(s, "#{script_dir}", :preserve => true)
                       end
                     end
                     return copied
                   end
                   def copy_log_filename(problem_home)
                     return File.join(problem_home, '.scripts_copied')
                   end
                   def save_copy_log(problem_home, log)
                     f = File.new(copy_log_filename(problem_home),"w")
                     log.each do |fname|
                       f.write("#{fname}\n")
                     end
                     f.close
                   end
                   def load_copy_log(problem_home)
                     f = File.new(copy_log_filename(problem_home),"r")
                     log = []
                     f.readlines.each do |line|
                       log << line.strip
                     end
                     f.close

lib/runner.rb ¶ +1 -1

               #
               # 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.find_each do |u|
                       puts "user: #{u.login}"
                       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|
                           @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)
                         end
                       end
                     end
                   end
                   def grade_submission(submission)
-            -       puts "Submission: #{submission.id} by #{submission.user.full_name}"
+            +       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

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

r174:09d1e857c1e3 - Sun, 28 Sep 2014 04:20:52 - 3 files changed: 17 inserted, 3 deleted

Sign in to your account

Commit r174:09d1e857c1e3 public

Author

r174:09d1e857c1e3 - Sun, 28 Sep 2014 04:20:52 - 3 files changed: 17 inserted, 3 deleted

Commit `r174:09d1e857c1e3` public