cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r9:8595e5379ca6` public

parent | child

Description:

add warning for check git-svn-id: http://theory.cpe.ku.ac.th/grader/cli/trunk/scripts@22 6386c4cd-e34a-4fa8-8920-d93eb39b512e

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

r9:8595e5379ca6 - Fri, 18 Jan 2008 14:19:16 - 2 files changed: 32 inserted, 0 deleted

grader ¶ +28

               #!/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
                 puts problem_out_dir
                 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_file = File.open(cmp_msg_fname)
                 cmp_msg = cmp_file.read
                 cmp_file.close
                 result_fname = "#{test_result_dir}/result"
                 comment_fname = "#{test_result_dir}/comment"
                 if FileTest.exist?(result_fname)
                   result_file = File.open(result_fname)
                   result = result_file.readline.to_i
                   result_file.close
                   comment_file = File.open(comment_fname)
                   comment = comment_file.readline.chomp
                   comment_file.close
                   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)
                 problem = Problem.find(submission.problem_id)
                 submission.graded_at = Time.now
                 submission.points = result[:points]
                 if submission.points == problem.full_score
                   submission.grader_comment = 'PASSED: ' + report_comment(result[:comment])
                 else
                   submission.grader_comment = 'FAILED: ' + report_comment(result[:comment])
                 end
                 submission.compiler_message = result[:cmp_msg]
                 submission.save
               end
               def grade(submission_id)
                 current_dir = `pwd`.chomp
                 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"))
                 Dir.chdir(current_dir)
               end
               def stop_grader
                 File.open(File.dirname(__FILE__) + '/stop','w').close
               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
               if (ARGV.length >= 1) and (ARGV[0]=='stop')
                 stop_grader
                 puts "stop file created"
                 exit(0)
               end
               if check_stopfile
                 puts "stop file exists"
                 clear_stopfile
                 exit(0)
               end
+            + grader_mode = 'queue'
               if ARGV.length >= 1
                 GRADER_ENV = ARGV[0]
+            +   if ARGV.length >=2
+            +     grader_mode = ARGV[1]
+            +   end
               else
                 GRADER_ENV = 'exam'
               end
               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'
+            + case grader_mode
+            + when "queue"
                 talk 'Grader queue'
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     puts "stopped"
                     exit(0)
                   end
                   task = Task.find(:first, :order => 'created_at')
                   if task!=nil
                     grade(task.submission_id)
                     task.destroy
                   else
                     sleep(1)
                   end
                 end
+            + when "prob"
+            +   prob = Problem.find_by_name(ARGV[2])
+            +   if prob==nil
+            +     puts "cannot find problem: #{ARGV[2]}"
+            +     exit(0)
+            +   end
+            +   users = User.find(:all)
+            +   users.each do |u|
+            +     puts "user: #{u.login}"
+            +     last_sub = Submission.find(:first,
+            +                                :conditions => "user_id = #{u.id} and " +
+            +                                "problem_id = #{prob.id}",
+            +                                :order => 'submitted_at DESC')
+            +     if last_sub!=nil
+            +       grade(last_sub.id)
+            +     end
+            +   end
+            + end
+            +
+            +
+            +
+            +

std-script/check ¶ +4

               #!/usr/bin/ruby
               problem_home = ENV['PROBLEM_HOME']
               require "#{problem_home}/script/test_dsl.rb"
               if ARGV.length < 2
                 puts "Usage: check <language> <test-number> [<output-file>]"
                 exit(0)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length >= 3
                 output_file_name = ARGV[2]
               else
                 output_file_name = "output.txt"
               end
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               output_file = File.new(output_file_name, "r")
               answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
               result_file = File.new("check_result", "w")
               output_file_content = output_file.read
               answer_file_content = answer_file.read
               report_correct = lambda {
                 result_file.write "Correct\n"
                 result_file.write problem.get_score(test_num)
                 result_file.write "\n"
                 result_file.close
                 exit(0)
               }
               report_wrong = lambda {
                 result_file.write "Incorrect\n"
                 result_file.write "0\n"
                 result_file.close
                 exit(0)
               }
               ##################
               # Your code here #
               ##################
+            +
+            + puts "YOU HAVE TO EDIT THE CHECKING CODE HERE: #{__FILE__}"
+            + exit(127)
+            +
               num_pattern = /^[0-9]*/
               if (output_file_content =~ num_pattern) == nil
                 report_wrong.call
               end
               output_i = output_file_content.to_i
               answer_i = answer_file_content.to_i
               if output_i == answer_i
                 report_correct.call
               else
                 report_wrong.call
               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

r9:8595e5379ca6 - Fri, 18 Jan 2008 14:19:16 - 2 files changed: 32 inserted, 0 deleted

Sign in to your account

Commit r9:8595e5379ca6 public

Author

r9:8595e5379ca6 - Fri, 18 Jan 2008 14:19:16 - 2 files changed: 32 inserted, 0 deleted

Commit `r9:8595e5379ca6` public