|
|
#!/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]
|
|
|
(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(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)
|
|
|
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)
|
|
|
end)
|
|
|
end
|
|
|
|
|
|
if options[:report]
|
|
|
result_collector.print_report_by_user
|
|
|
end
|
|
|
end
|
|
|
|
|
|
def grader_grade_submissions(grader_proc, options)
|
|
|
engine = Grader::Engine.new
|
|
|
runner = Grader::Runner.new(engine, grader_proc)
|
|
|
|
|
|
grader_proc.report_active if grader_proc!=nil
|
|
|
|
|
|
ARGV.each do |sub_id|
|
|
|
puts "Grading #{sub_id}"
|
|
|
begin
|
|
|
submission = Submission.find(sub_id.to_i)
|
|
|
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}"
|
|
|
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
|
|
|
|
|
|
#
|
|
|
# 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
|
|
|
|
|
|
|
