cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r196:4097795ac013` public

parent | child

Description:

Merge pull request #1 from jittat/master Merge from origin

Commit status:

[Not Reviewed]

References:

merge default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r196:4097795ac013 - Thu, 14 Aug 2014 13:39:40 - 3 files changed: 33 inserted, 31 deleted

grader ¶ +1 -1

                 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 "Record not found"
+            +       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

lib/engine.rb ¶ +30 -28

               require 'fileutils'
               require File.join(File.dirname(__FILE__),'dir_init')
               module Grader
                 #
                 # A grader engine grades a submission, against anything: a test
                 # data, or a user submitted test data.  It uses two helpers objects:
                 # room_maker and reporter.
                 #
                 class Engine
                   attr_writer :room_maker
                   attr_writer :reporter
                   def initialize(options={})
                     # default options
                     if not options.include? :room_maker
                       options[:room_maker] = Grader::SubmissionRoomMaker.new
                     end
                     if not options.include? :reporter
                       options[:reporter] =  Grader::SubmissionReporter.new
                     end
                     @config = Grader::Configuration.get_instance
                     @room_maker = options[:room_maker]
                     @reporter = options[:reporter]
                   end
                   # takes a submission, asks room_maker to produce grading directories,
                   # calls grader scripts, and asks reporter to save the result
                   def grade(submission)
                     current_dir = FileUtils.pwd
                     user = submission.user
                     problem = submission.problem
-            -       # TODO: will have to create real exception for this
-            -       if user==nil or problem == nil
-            -         @reporter.report_error(submission,"Grading error: problem with submission")
-            -         #raise "engine: user or problem is nil"
-            -       end
+            -
-            -       # TODO: this is another hack so that output only task can be judged
-            -       if submission.language!=nil
-            -         language = submission.language.name
-            -         lang_ext = submission.language.ext
-            -       else
-            -         language = 'c'
-            -         lang_ext = 'c'
-            -       end
+            +       begin
+            +         # TODO: will have to create real exception for this
+            +         if user==nil or problem == nil
+            +           @reporter.report_error(submission,"Grading error: problem with submission")
+            +           raise "engine: user or problem is nil"
+            +         end
-            -       # This is needed because older version of std-scripts/compile
-            -       # only look for c++.
-            -       if language == 'cpp'
-            -         language = 'c++'
-            -       end
+            +         # TODO: this is another hack so that output only task can be judged
+            +         if submission.language!=nil
+            +           language = submission.language.name
+            +           lang_ext = submission.language.ext
+            +         else
+            +           language = 'c'
+            +           lang_ext = 'c'
+            +         end
-            -       # COMMENT: should it be only source.ext?
-            -       if problem!=nil
-            -         source_name = "#{problem.name}.#{lang_ext}"
-            -       else
-            -         source_name = "source.#{lang_ext}"
-            -       end
+            +         # This is needed because older version of std-scripts/compile
+            +         # only look for c++.
+            +         if language == 'cpp'
+            +           language = 'c++'
+            +         end
-            -       begin
+            +         # COMMENT: should it be only source.ext?
+            +         if problem!=nil
+            +           source_name = "#{problem.name}.#{lang_ext}"
+            +         else
+            +           source_name = "source.#{lang_ext}"
+            +         end
+            +
                       grading_dir = @room_maker.produce_grading_room(submission)
                       @room_maker.save_source(submission,source_name)
                       problem_home = @room_maker.find_problem_home(submission)
                       # puts "GRADING DIR: #{grading_dir}"
                       # puts "PROBLEM DIR: #{problem_home}"
                       if !FileTest.exist?(problem_home)
-            -           raise "No test data."
+            +           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}"
                     talk "CMD: #{cmd}"
                     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 "std-script directory not found" if !FileTest.exist?(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
                     log
                   end
                   def clear_copy_log(problem_home)
                     File.delete(copy_log_filename(problem_home))
                   end
                   def clear_script(log,problem_home)
                     log.each do |s|
                       FileUtils.rm("#{problem_home}/script/#{s}")
                     end
                   end

std-script/compile ¶ +2 -2

               #!/usr/bin/env ruby
               require 'fileutils'
               ##############################
               #
               # Standard Compile Script
               #
               # Supported compilers:
               #   gcc, g++, and fpc.
               #
               ##############################
-            - def talk(msg)
+            + def talk(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
-            -     fp.puts("run: #{Time.new.strftime("%H:%M")} #{msg}")
+            +     fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               C_COMPILER = "/usr/bin/gcc"
               CPLUSPLUS_COMPILER = "/usr/bin/g++"
               PASCAL_COMPILER = "/usr/bin/fpc"
               C_OPTIONS = "-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
               CPLUSPLUS_OPTIONS = "-O2 -s -static -DCONTEST -lm -Wall"
               PASCAL_OPTIONS = "-O1 -XS -dCONTEST"
               # Check for the correct number of arguments. Otherwise, print usage.
               if ARGV.length == 0 or ARGV.length > 4
                 puts "Usage: compile <language> [<source-file>] [<output-file>] [<message-file>]"
                 puts
                 puts "<source-file>  is defaulted to \"source\"."
                 puts "<output-file>  is defaulted to \"a.out\"."
                 puts "<message-file> is defaulted to \"compiler_message\"."
                 puts
                 exit(127)
               end
               PARAMS = {
                 :source_file => [1,'source'],
                 :output_file => [2,'a.out'],
                 :message_file => [3,'compiler_message']
               }
               params = {}
               params[:prog_lang] = ARGV[0]
               PARAMS.each_key do |param_name|
                 index, default = PARAMS[param_name]
                 if ARGV.length > index
                   params[param_name] = ARGV[index]
                 else
                   params[param_name] = default
                 end
                 talk "#{param_name}: #{params[param_name]}"
               end
               # Remove any remaining output files or message files.
               if FileTest.exists? params[:output_file]
                 FileUtils.rm(params[:output_file])
               end
               if FileTest.exists? params[:message_file]
                 FileUtils.rm(params[:message_file])
               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

r196:4097795ac013 - Thu, 14 Aug 2014 13:39:40 - 3 files changed: 33 inserted, 31 deleted

Sign in to your account

Commit r196:4097795ac013 public

Author

r196:4097795ac013 - Thu, 14 Aug 2014 13:39:40 - 3 files changed: 33 inserted, 31 deleted

Commit `r196:4097795ac013` public