cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r254:8d92eda43960` public

parent | child

Description:

- new install script - add comment in grader chain

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

r254:8d92eda43960 - Wed, 11 Jul 2018 10:33:10 - 3 files changed: 27 inserted, 20 deleted

installer/install.sh ¶ +16 -20

               #!/bin/sh
+            + #installation script for cafe-grader, for ubuntu 16.04
+            +
               echo "This script will install and configure Cafe grader."
-            - RUBY_VERSION=2.1.2
+            + RUBY_VERSION=2.3.7
-            - echo "This will install Ruby $RUBY_VERSION under RVM"
-            - echo "Installing required apts"
-            - sudo apt-get update
-            - sudo apt-get install mysql-server mysql-client \
-            -   g++ gcc apache2 libmysqlclient20 build-essential \
-            -   git-core openssl libreadline6 libreadline6-dev \
-            -   zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev \
-            -   sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev \
-            -   ncurses-dev automake libtool bison subversion \
-            -   pkg-config curl nodejs unzip pyflakes ruby default-jdk \
-            -   libmysqld-dev mercurial python-setuptools python-dev python3-numpy
-            - echo "Installing RVM"
-            - curl -k -L https://get.rvm.io | bash -s stable
-            - source ~/.rvm/scripts/rvm
               echo "Installing Ruby $RUBY_VERSION in RVM"
               rvm install $RUBY_VERSION
               rvm use $RUBY_VERSION
               echo "Fetching Cafe Grader from Git repositories"
               echo "Fetching web interface"
               mkdir cafe_grader
               cd cafe_grader
-            - git clone -q git://github.com/jittat/cafe-grader-web.git web
+            + git clone -q git://github.com/cafe-grader-team/cafe-grader-web.git web
               echo "Configuring rails app"
               cp web/config/application.rb.SAMPLE web/config/application.rb
               cp web/config/initializers/cafe_grader_config.rb.SAMPLE web/config/initializers/cafe_grader_config.rb
               #replace UTC in application.rb with the system timezone
               timezone='UTC'
               if [ -f '/etc/timezone' ]; then
                 timezone=\"`cat /etc/timezone`\"
               else
                 if [ -f '/etc/sysconfig/clock' ]; then
                   timezone=`grep -e '^TIMEZONE' /etc/sysconfig/clock | grep -o -e '\".*\"'`
                 fi
               fi
               replace="s!'UTC'!$timezone!g"
               sed -i $replace web/config/application.rb
               echo "At this point we will need MySQL user and database."
               echo "Have you created MySQL user and database for Cafe grader? (Y/N) "
               read ch
               if [ "$ch" = "n" -o "$ch" = "N" ]
               then
               echo "  pool: 5" >> config/database.yml
               echo "  username: $username" >> config/database.yml
               echo "  password: $password" >> config/database.yml
               echo "  host: localhost" >> config/database.yml
               echo "  socket: /var/run/mysqld/mysqld.sock" >> config/database.yml
               echo "Object.instance_eval{remove_const :GRADER_ROOT_DIR}" >> config/initializers/cafe_grader_config.rb
               echo "Object.instance_eval{remove_const :GRADING_RESULT_DIR}" >> config/initializers/cafe_grader_config.rb
               echo "GRADER_ROOT_DIR = '$CAFE_PATH/judge'" >> config/initializers/cafe_grader_config.rb
               echo "GRADING_RESULT_DIR = '$CAFE_PATH/judge/result'" >> config/initializers/cafe_grader_config.rb
               echo "Installing required gems"
               gem install bundler
               bundle install
               echo "Running rake tasks to initialize database"
               rake db:migrate
               rake db:seed
               echo "Running rake tasks to precompile the assets"
               rake assets:precompile
+            + echo "setup the secret file"
+            + SECRET_A=`rake secret`
+            + SECRET_B=`rake secret`
+            + SECRET_C=`rake secret`
+            + echo "development:" > config/secrets.yml
+            + echo "  secret_key_base: '$SECRET_A'" >> config/secrets.yml
+            + echo "test:" >> config/secrets.yml
+            + echo "  secret_key_base: '$SECRET_B'" >> config/secrets.yml
+            + echo "production:" >> config/secrets.yml
+            + echo "  secret_key_base: '$SECRET_C'" >> config/secrets.yml
+            +
               echo "Intalling web interface complete..."
               echo
               echo "Fetching grader"
               cd ..
               mkdir judge
               cd judge
-            - git clone -q git://github.com/jittat/cafe-grader-judge-scripts.git scripts
+            + git clone -q git://github.com/cafe-grader-team/cafe-grader-judge-scripts.git scripts
               mkdir raw
               mkdir ev-exam
               mkdir ev
               mkdir result
               mkdir log
               echo "Configuring grader"
               cp scripts/config/env_exam.rb.SAMPLE scripts/config/env_exam.rb
               cp scripts/config/env_grading.rb.SAMPLE scripts/config/env_grading.rb
               # create new environment.rb file
               echo "RAILS_ROOT = '$CAFE_PATH/web'" > scripts/config/environment.rb
               echo "GRADER_ROOT = '$CAFE_PATH/judge/scripts'" >> scripts/config/environment.rb
               echo "require File.join(File.dirname(__FILE__),'../lib/boot')" >> scripts/config/environment.rb
               echo "require File.dirname(__FILE__) + \"/env_#{GRADER_ENV}.rb\"" >> scripts/config/environment.rb
               # compiling box
               MACHINE_TYPE=`uname -m`
               if [ ${MACHINE_TYPE} == 'x86_64' ]; then
                 gcc -std=c99 -o scripts/std-script/box scripts/std-script/box64-new.c
               else
                 g++ -o scripts/std-script/box scripts/std-script/box.cc
               fi

lib/engine.rb ¶ +8

                       # only look for c++.
                       if language == 'cpp'
                         language = '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
                       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)
                         puts "PROBLEM DIR: #{problem_home}"
                         raise "engine: No test data."
                       end
+            +         # copy the source script, using lock
                       dinit = DirInit::Manager.new(problem_home)
+            +         # lock the directory and copy the scripts
                       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")
+            +         # unlock the directory
                       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
+            +     #change directory to problem_home
+            +     #call the "judge" script
                   def call_judge(problem_home,language,grading_dir,fname)
                     ENV['PROBLEM_HOME'] = problem_home
                     ENV['RUBYOPT'] = ''
                     talk grading_dir
                     Dir.chdir grading_dir
                     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
+            +     #copy any script presented in std-script directory that is not in the problem_home
+            +     #this allow a problem setter to provide their own version for each script
+            +     #in case that they want to hack something
                   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')

lib/runner.rb ¶ +3

               #
               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
+            +     # grade a specified problem for the latest submission of each user
+            +     # optionally, on all submission when options[:all_sub] is set
+            +     # optionally, only submission that has error (use when the problem itself has some problem)
                   def grade_problem(problem, options={})
                     user_index = 0
                     user_count = User.count
                     User.find_each do |u|
                       puts "user: #{u.login} (#{user_index}/#{user_count})"
                       user_index += 1
                       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|
                           next if options[:only_err] and sub.grader_comment != 'error during grading'
                           @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) unless options[:only_err] and last_sub.grader_comment != 'error during grading'
                         end
                       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

r254:8d92eda43960 - Wed, 11 Jul 2018 10:33:10 - 3 files changed: 27 inserted, 20 deleted

Sign in to your account

Commit r254:8d92eda43960 public

Author

r254:8d92eda43960 - Wed, 11 Jul 2018 10:33:10 - 3 files changed: 27 inserted, 20 deleted

Commit `r254:8d92eda43960` public