cafe-grader-judge-scripts

Commit r99:f439789e790b public

parent | child
Description:
removed 'system' from grader, grader_id, import_problem
Commit status:
[Not Reviewed]
References:
default
Diff options:
Raw Diff | Patch Diff | Download Diff | Ignore whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r99:f439789e790b - - 3 files changed: 14 inserted, 32 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,210 +1,210
1 1 #!/usr/bin/ruby
2 2
3 3 def stop_grader(id)
4 4 if id==:all
5 5 File.open(File.dirname(__FILE__) + "/stop.all",'w').close
6 6 else
7 7 File.open(File.dirname(__FILE__) + "/stop.#{id}",'w').close
8 8 end
9 9 end
10 10
11 11 def check_stopfile
12 12 FileTest.exist?(File.dirname(__FILE__) + "/stop.all") or
13 13 FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
14 14 end
15 15
16 16 def clear_stopfile
17 17 if FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
18 - system("rm " + File.dirname(__FILE__) + "/stop.#{Process.pid}")
18 + File.delete(File.dirname(__FILE__) + "/stop.#{Process.pid}")
19 19 end
20 20 end
21 21
22 22 def config
23 23 Grader::Configuration.get_instance
24 24 end
25 25
26 26 def log_file_name
27 27 if !File.exists?(config.log_dir)
28 28 raise "Log directory does not exist: #{config.log_dir}"
29 29 end
30 30 config.log_dir +
31 31 "/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"
32 32 end
33 33
34 34 def log(str)
35 35 if config.talkative
36 36 puts str
37 37 end
38 38 if config.logging
39 39 fp = File.open(log_file_name,"a")
40 40 fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")
41 41 fp.close
42 42 end
43 43 end
44 44
45 45 def display_manual
46 46 puts <<USAGE
47 47 Grader.
48 48 using: (1) grader
49 49 (2) grader environment [mode]
50 50 (3) grader stop [all|pids-list]
51 51 (4) grader --help
52 52 (1) call grader with environment = 'exam', mode = 'queue'
53 53 (2) possible modes are: 'queue', 'prob', 'test_request'
54 54 (3) create stop-file to stop running grader in queue mode
55 55 (4) You are here.
56 56 USAGE
57 57 end
58 58
59 59 def process_options_and_stop_file
60 60 # The list of options are:
61 61 # - stop [all|process ids]
62 62 # -
63 63
64 64 # Process 'help' option
65 65 if (ARGV.length==1) and (/help/.match(ARGV[0]))
66 66 display_manual
67 67 exit(0)
68 68 end
69 69
70 70 # Process 'stop' option.
71 71 if (ARGV.length >= 1) and (ARGV[0]=='stop')
72 72 if ARGV.length==1
73 73 puts "you should specify pid-list or 'all'"
74 74 display_manual
75 75 elsif (ARGV.length==2) and (ARGV[1]=='all')
76 76 stop_grader(:all)
77 77 puts "A global stop file ('stop.all') created."
78 78 puts "You should remove it manually later."
79 79 else
80 80 (1..ARGV.length-1).each do |i|
81 81 stop_grader(ARGV[i])
82 82 end
83 83 puts "stop file(s) created"
84 84 end
85 85 exit(0)
86 86 end
87 87
88 88 # Check stop file.
89 89 if check_stopfile
90 90 puts "Stop file exists. Terminated."
91 91 clear_stopfile
92 92 exit(0)
93 93 end
94 94
95 95 #default options
96 96 options = {
97 97 :mode => 'queue',
98 98 :environment => 'exam',
99 99 :dry_run => false,
100 100 }
101 101
102 102 # Process mode and environment option
103 103 if ARGV.length >= 1
104 104 options[:environment] = ARGV.shift
105 105 if ARGV.length >=1
106 106 options[:mode] = ARGV.shift
107 107 end
108 108 end
109 109
110 110 options[:dry_run] = (ARGV.delete('--dry') != nil)
111 111 if options[:dry_run] and (not ['prob','contest'].include? options[:mode])
112 112 puts "Dry run currently works only for 'prob' or 'contest' modes."
113 113 exit(0)
114 114 end
115 115
116 116 options[:report] = (ARGV.delete('--report') != nil)
117 117 if options[:report] and (not ['prob','contest'].include? options[:mode])
118 118 puts "Report currently works only for 'prob' or 'contest' modes."
119 119 exit(0)
120 120 end
121 121
122 122 return options
123 123 end
124 124
125 125 class ResultCollector
126 126 def initialize
127 127 @results = {}
128 128 @problems = {}
129 129 @users = {}
130 130 end
131 131
132 132 def save(user, problem, grading_result)
133 133 if not @problems.has_key? problem.id
134 134 @problems[problem.id] = problem
135 135 end
136 136 if not @users.has_key? user.id
137 137 @users[user.id] = user
138 138 end
139 139 @results[[user.id, problem.id]] = grading_result
140 140 end
141 141
142 142 def print_report_by_user
143 143 puts "---------------------"
144 144 puts " REPORT"
145 145 puts "---------------------"
146 146
147 147 print "login,email"
148 148 @problems.each_value do |problem|
149 149 print ",#{problem.name}"
150 150 end
151 151 print "\n"
152 152
153 153 @users.each_value do |user|
154 154 print "#{user.login},#{user.email}"
155 155 @problems.each_value do |problem|
156 156 if @results.has_key? [user.id, problem.id]
157 157 print ",#{@results[[user.id,problem.id]][:points]}"
158 158 else
159 159 print ","
160 160 end
161 161 end
162 162 print "\n"
163 163 end
164 164 end
165 165 end
166 166
167 167 #########################################
168 168 # main program
169 169 #########################################
170 170
171 171 options = process_options_and_stop_file
172 172 GRADER_ENV = options[:environment]
173 173 grader_mode = options[:mode]
174 174 dry_run = options[:dry_run]
175 175
176 176 puts "environment: #{GRADER_ENV}"
177 177 require File.join(File.dirname(__FILE__),'config/environment')
178 178
179 179 # add grader_mode to config
180 180 # this is needed because method log needs it. TODO: clean this up
181 181 class << config
182 182 attr_accessor :grader_mode
183 183 end
184 184 config.grader_mode = grader_mode
185 185
186 186 # reading rails environment
187 187 log 'Reading rails environment'
188 188
189 189 RAILS_ENV = config.rails_env
190 190 require RAILS_ROOT + '/config/environment'
191 191
192 192 # register grader process
193 193 if config.report_grader
194 194 grader_proc = GraderProcess.register(config.grader_hostname,
195 195 Process.pid,
196 196 grader_mode)
197 197 else
198 198 grader_proc = nil
199 199 end
200 200
201 201 #set loggin environment
202 202 ENV['GRADER_LOGGING'] = log_file_name
203 203
204 204 # register exit handler to report inactive, and terminated
205 205 at_exit do
206 206 if grader_proc!=nil
207 207 grader_proc.report_inactive
208 208 grader_proc.terminate
209 209 end
210 210 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,110 +1,89
1 1 #!/usr/bin/ruby
2 2
3 3 def talk(str)
4 4 if TALKATIVE
5 5 puts str
6 6 end
7 7 end
8 8
9 - def execute(command, error_message="")
10 - if not system(command)
11 - puts "ERROR: #{error_message}"
12 - exit(127)
13 - end
14 - end
15 -
16 9 def save_source(submission,dir,fname)
17 10 f = File.open("#{dir}/#{fname}","w")
18 11 f.write(submission.source)
19 12 f.close
20 13 end
21 14
22 15 def call_judge(problem_home,language,problem_out_dir,fname)
23 16 ENV['PROBLEM_HOME'] = problem_home
24 17 Dir.chdir problem_out_dir
25 18 cmd = "#{problem_home}/script/judge #{language} #{fname}"
26 19 # puts "CMD: #{cmd}"
27 20 system(cmd)
28 21 end
29 22
30 23 def read_result(test_result_dir)
31 24 cmp_msg_fname = "#{test_result_dir}/compiler_message"
32 25 cmp_msg = File.open(cmp_msg_fname).read
33 26
34 27 result_fname = "#{test_result_dir}/result"
35 28 comment_fname = "#{test_result_dir}/comment"
36 29 if FileTest.exist?(result_fname)
37 30 result = File.open(result_fname).readline.to_i
38 31 comment = File.open(comment_fname).readline.chomp
39 32 return {:points => result,
40 33 :comment => comment,
41 34 :cmp_msg => cmp_msg}
42 35 else
43 36 return {:points => 0,
44 37 :comment => 'compile error',
45 38 :cmp_msg => cmp_msg}
46 39 end
47 40 end
48 41
49 42 def save_result(submission,result)
50 43 submission.graded_at = Time.now
51 44 submission.points = result[:points]
52 45 submission.grader_comment = report_comment(result[:comment])
53 46 submission.compiler_message = result[:cmp_msg]
54 47 submission.save
55 48 end
56 49
57 50 def grade(submission_id)
58 51 sub = Submission.find(submission_id)
59 52 user = sub.user
60 53 problem = sub.problem
61 54
62 55 language = sub.language.name
63 56 lang_ext = sub.language.ext
64 57 # FIX THIS
65 58 talk 'some hack on language'
66 59 if language == 'cpp'
67 60 language = 'c++'
68 61 end
69 62
70 63 user_dir = "#{USER_RESULT_DIR}/#{user.login}"
71 64 Dir.mkdir(user_dir) if !FileTest.exist?(user_dir)
72 65
73 66 problem_out_dir = "#{user_dir}/#{problem.name}"
74 67 Dir.mkdir(problem_out_dir) if !FileTest.exist?(problem_out_dir)
75 68
76 69 problem_home = "#{PROBLEMS_DIR}/#{problem.name}"
77 70 source_name = "#{problem.name}.#{lang_ext}"
78 71
79 72 save_source(sub,problem_out_dir,source_name)
80 73 call_judge(problem_home,language,problem_out_dir,source_name)
81 74 save_result(sub,read_result("#{problem_out_dir}/test-result"))
82 75 end
83 76
84 - def stop_grader
85 - File.open(File.dirname(__FILE__) + '/stop','w')
86 - end
87 -
88 - def check_stopfile
89 - FileTest.exist?(File.dirname(__FILE__) + '/stop')
90 - end
91 -
92 - def clear_stopfile
93 - system("rm " + File.dirname(__FILE__) + '/stop')
94 - end
95 -
96 77 # reading environment and options
97 78 GRADER_ENV = 'exam'
98 79 puts "environment: #{GRADER_ENV}"
99 80 require File.dirname(__FILE__) + "/environment.rb"
100 81
101 82 #main program
102 83 talk 'Reading rails environment'
103 84
104 85 RAILS_ENV = 'development'
105 86 require RAILS_APP_DIR + '/config/environment'
106 87
107 88 current_dir = `pwd`
108 89 grade(ARGV[0].to_i)
109 -
110 -
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,228 +1,231
1 1 #!/usr/bin/ruby
2 2
3 3 require 'erb'
4 + require 'ftools'
4 5 require 'fileutils'
5 6 require File.join(File.dirname(__FILE__),'lib/import_helper')
6 7
7 8 JUDGE_ENVIRONMENTS = [:grading, :exam]
8 9 ENV_INFO = {
9 10 :grading => {
10 11 :ev_dir => 'ev',
11 12 :raw_prefix => '',
12 13 },
13 14 :exam => {
14 15 :ev_dir => 'ev-exam',
15 16 :raw_prefix => 'ex.',
16 17 }
17 18 }
18 19
19 20 def input_filename(dir,i)
20 21 "#{dir}/input-#{i}.txt"
21 22 end
22 23
23 24 def answer_filename(dir,i)
24 25 "#{dir}/answer-#{i}.txt"
25 26 end
26 27
27 28 def build_testrun_info_from_dir(num_testruns, importing_test_dir, raw_prefix='')
28 29 filenames = Dir["#{importing_test_dir}/#{raw_prefix}*.in"].collect do |filename|
29 30 File.basename((/(.*)\.in/.match(filename))[1])
30 31 end
31 32 build_testrun_info(num_testruns,filenames,raw_prefix)
32 33 end
33 34
34 35 def copy_testcase(importing_test_dir,fname,dir,i)
35 - system("cp #{importing_test_dir}/#{fname}.in #{input_filename(dir,i)}")
36 - system("cp #{importing_test_dir}/#{fname}.sol #{answer_filename(dir,i)}")
36 + File.copy("#{importing_test_dir}/#{fname}.in", "#{input_filename(dir,i)}")
37 + File.copy("#{importing_test_dir}/#{fname}.sol", "#{answer_filename(dir,i)}")
37 38 end
38 39
39 40 def process_options(options)
40 41 i = 3
41 42 while i<ARGV.length
42 43 if ARGV[i]=='-t'
43 44 options[:time_limit] = ARGV[i+1].to_f if ARGV.length>i+1
44 45 i += 1
45 46 end
46 47 if ARGV[i]=='-m'
47 48 options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
48 49 i += 1
49 50 end
50 51 i += 1
51 52 end
52 53 end
53 54
54 55 def print_usage
55 56 puts "using: import_problem_new name dir check [options]
56 57
57 58 where: name = problem_name (put '-' (dash) to use dir name)
58 59 dir = importing testcase directory
59 60 check = check script, which can be
60 61 'integer', 'text' (for standard script),
61 62 path_to_your_script, or
62 63 'wrapper:(path_to_your_wrapped_script)'
63 64 options: -t time-limit (in seconds)
64 65 -m memory-limit (in megabytes)
65 66
66 67 The script looks at test data files in the dir of the forms: *.in and
67 68 *.sol and import them to the evaluation dir for their environment,
68 69 based on their prefixes.
69 70
70 71 Currently supporting environments are:"
71 72
72 73 JUDGE_ENVIRONMENTS.each do |env|
73 74 prefix = ENV_INFO[env][:raw_prefix]
74 75 prefix = 'no prefix' if prefix==''
75 76 puts " * #{env}"
76 77 puts " import to: #{ENV_INFO[env][:ev_dir]}"
77 78 puts " prefix with: #{prefix} (e.g., #{ENV_INFO[env][:raw_prefix]}1.in, #{ENV_INFO[env][:raw_prefix]}5a.sol)"
78 79 end
79 80
80 81 puts"
81 82 For each environment, the script
82 83 * creates a directory for a problem in ev dir of that environment,
83 84 * copies testdata in the old format and create standard testcase config file
84 85 * copies a check script for grading
85 86 * creates a test_request template in the ev dir + '/test_request'
86 87
87 88 For wrapped checked script see comment in templates/check_wrapper for
88 89 information."
89 90 end
90 91
91 92 def count_testruns(testcase_dir, raw_prefix)
92 93 n = 0
93 94 begin
94 95 # check for test case n+1
95 96 if ((Dir["#{testcase_dir}/#{raw_prefix}#{n+1}.in"].length==0) and
96 97 (Dir["#{testcase_dir}/#{raw_prefix}#{n+1}[a-z].in"].length==0))
97 98 return n
98 99 end
99 100 n += 1
100 101 end while true
101 102 end
102 103
103 104 def import_problem(ev_dir, problem, testcase_dir, num_testruns, raw_prefix, check_script, options)
104 105 testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir, raw_prefix)
105 106
106 107 if !(FileTest.exists? ev_dir)
107 108 puts "Testdata dir (#{ev_dir}) not found."
108 109 return
109 110 end
110 111
111 112 problem_dir = "#{ev_dir}/#{problem}"
112 113
113 114 # start working
114 115 puts "creating directories"
115 116
116 - system("mkdir #{problem_dir}")
117 - system("mkdir #{problem_dir}/script")
118 - system("mkdir #{problem_dir}/test_cases")
117 + File.makedirs("#{problem_dir}")
118 + File.makedirs("#{problem_dir}/script")
119 + File.makedirs("#{problem_dir}/test_cases")
119 120
120 121 puts "copying testcases"
121 122
122 123 tr_num = 0
123 124
124 125 num_testcases = 0
125 126
126 127 testrun_info.each do |testrun|
127 128 tr_num += 1
128 129 puts "testrun: #{tr_num}"
129 130
130 131 testrun.each do |testcase_info|
131 132 testcase_num, testcase_fname = testcase_info
132 133
133 134 puts "copy #{testcase_fname} to #{testcase_num}"
134 135
135 - system("mkdir #{problem_dir}/test_cases/#{testcase_num}")
136 + File.makedirs("#{problem_dir}/test_cases/#{testcase_num}")
136 137 copy_testcase("#{testcase_dir}",testcase_fname,"#{problem_dir}/test_cases/#{testcase_num}",testcase_num)
137 138
138 139 num_testcases += 1
139 140 end
140 141 end
141 142
142 143 # generating all_tests.cfg
143 144 puts "generating testcase config file"
144 145
145 146 template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
146 147 all_test_cfg = ERB.new(template)
147 148
148 149 cfg_file = File.open("#{problem_dir}/test_cases/all_tests.cfg","w")
149 150 cfg_file.puts all_test_cfg.result binding
150 151 cfg_file.close
151 152
152 153 # copy check script
153 154 if res = /^wrapper:(.*)$/.match(check_script)
154 155 # wrapper script
155 156 check_script_fname = res[1]
156 157 script_name = File.basename(check_script_fname)
157 158 check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
158 159 check_wrapper = ERB.new(check_wrapper_template)
159 160
160 161 check_file = File.open("#{problem_dir}/script/check","w")
161 162 check_file.puts check_wrapper.result binding
162 163 check_file.close
163 164
164 165 File.chmod(0755,"#{problem_dir}/script/check")
165 166
166 - system("cp #{check_script_fname} #{problem_dir}/script/#{script_name}")
167 + File.copy("#{check_script_fname}", "#{problem_dir}/script/#{script_name}")
167 168 else
168 169 if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
169 170 check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
170 171 else
171 172 check_script_fname = check_script
172 173 end
173 - system("cp #{check_script_fname} #{problem_dir}/script/check")
174 + File.copy("#{check_script_fname}", "#{problem_dir}/script/check")
174 175 end
175 176
176 177 # generating test_request directory
177 178 puts "generating test_request template"
178 179 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/script")
179 180 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/test_cases/1")
180 181
181 182 template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
182 183 test_request_all_test_cfg = ERB.new(template)
183 184
184 185 cfg_file = File.open("#{ev_dir}/test_request/#{problem}/test_cases/all_tests.cfg","w")
185 186 cfg_file.puts test_request_all_test_cfg.result
186 187 cfg_file.close
187 188
188 - system("cp #{SCRIPT_DIR}/templates/check_empty #{ev_dir}/test_request/#{problem}/script/check")
189 - system("cp #{SCRIPT_DIR}/templates/answer-1.txt #{ev_dir}/test_request/#{problem}/test_cases/1")
189 + File.copy("#{SCRIPT_DIR}/templates/check_empty",
190 + "#{ev_dir}/test_request/#{problem}/script/check")
191 + File.copy("#{SCRIPT_DIR}/templates/answer-1.txt",
192 + "#{ev_dir}/test_request/#{problem}/test_cases/1")
190 193
191 194 puts "done"
192 195 end
193 196
194 197
195 198 SCRIPT_DIR = File.dirname(__FILE__)
196 199
197 200 # print usage
198 201 if (ARGV.length < 3) or (ARGV[2][0,1]=="-")
199 202 print_usage
200 203 exit(127)
201 204 end
202 205
203 206 # processing arguments
204 207 problem = ARGV[0]
205 208 testcase_dir = ARGV[1]
206 209 problem = File.basename(testcase_dir) if problem=="-"
207 210 check_script = ARGV[2]
208 211 options = {:time_limit => 1, :mem_limit => 16}
209 212 process_options(options)
210 213
211 214 JUDGE_ENVIRONMENTS.each do |env|
212 215 ev_dir = ENV_INFO[env][:ev_dir]
213 216 raw_prefix = ENV_INFO[env][:raw_prefix]
214 217
215 218 num_testruns = count_testruns(testcase_dir,raw_prefix)
216 219
217 220 puts ""
218 221 puts "*** Environment: #{env} (#{num_testruns} test runs) ***"
219 222 puts ""
220 223
221 224 import_problem(ev_dir,
222 225 problem,
223 226 testcase_dir,
224 227 num_testruns,
225 228 raw_prefix,
226 229 check_script,
227 230 options)
228 231 end
You need to be logged in to leave comments. Login now