cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r214:336e928de90e` public

parent | child

Description:

update java-bm

Commit status:

[Not Reviewed]

References:

merge java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r214:336e928de90e - Thu, 19 Feb 2015 15:48:36 - 9 files changed: 60 inserted, 21 deleted

installer/install.sh ¶ +32 -6

               #!/bin/sh
               echo "This script will install and configure Cafe grader."
-            - echo "This will install Ruby 1.9.2 under rvm"
+            + RUBY_VERSION=2.1.2
+            + 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 libmysqlclient15-dev 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
+            +   pkg-config curl nodejs unzip pyflakes ruby default-jdk
               echo "Installing RVM"
               curl -k -L https://get.rvm.io | bash -s stable
-            - ~/.rvm/scripts/rvm
+            + source ~/.rvm/scripts/rvm
-            - echo "Installing Ruby 1.9.2 in RVM"
+            + echo "Installing Ruby $RUBY_VERSION in RVM"
-            - rvm install 1.9.2
+            + rvm install $RUBY_VERSION
-            - rvm use 1.9.2
+            + 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
               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 "Please open another terminal and create the user and database for Cafe grader."
                 echo "Don't forget to grant access to that database for the user."
                 echo "Please have username, password, and database name ready before continue."
                 echo
                 echo "The following are instructions:"
                 echo "1. Run mysql:"
                 echo
                 echo "      mysql -u root -p"
                 echo
                 echo "   if you have just installed mysql, the root password is the one that you have just entered"
                 echo "2. Create a new database, a new user, and grant access to grader database:"
                 echo
                 echo "      create user 'USERNAME'@'localhost' identified by 'PASSWORD';"
                 echo "      create database \`DATABASENEME\`;"
                 echo "      grant all on \`DATABASENAME\`.* to 'USERNAME'@'localhost';"
                 echo
                 echo "   Replace USERNAME, PASSWORD, and DATABASENAME accordingly."
                 echo
               echo "  adapter: mysql2" >> config/database.yml
               echo "  encoding: utf8" >> config/database.yml
               echo "  reconnect: false" >> config/database.yml
               echo "  database: $database" >> config/database.yml
               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 "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
               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
+            +
+            +
               cd ..
               echo "Now you are ready to run cafe grader...."
               echo
               echo "Try:"
               echo
               echo "  cd web"
               echo "  rails s"
               echo
               echo "and access web at http://localhost:3000/"
               echo "The root username is 'root', its password is 'ioionrails'."

new_problem ¶ +1 -1

-            - #!/usr/bin/ruby
+            + #!/usr/bin/env ruby
               # new_problem:
               #  * creates a directory for a problem in the current directory,
               #  * create standard testcase config file
               require 'erb'
               def process_options(options)
                 i = 2
                 while i<ARGV.length
                   if ARGV[i]=='-t'
                     options[:time_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   if ARGV[i]=='-m'
                     options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   i += 1
                 end
               end
               puts "This script is out of dated, shall be fixed soon"

std-script/box64-new.c ¶ +17 -4

               \n\
               Options:\n\
               -a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
               -c <dir>\tChange directory to <dir> first\n\
               -e\t\tInherit full environment of the parent process\n\
               -E <var>\tInherit the environment variable <var> from the parent process\n\
               -E <var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
               -f\t\tFilter system calls (-ff=very restricted)\n\
               -i <file>\tRedirect stdin from <file>\n\
               -k <size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
               -m <size>\tLimit address space to <size> KB\n\
               -M <file>\tOutput process information to <file> (name:value)\n\
               -o <file>\tRedirect stdout to <file>\n\
               -p <path>\tPermit access to the specified path (or subtree if it ends with a `/')\n\
               -p <path>=<act>\tDefine action for the specified path (<act>=yes/no)\n\
               -r <file>\tRedirect stderr to <file>\n\
               -s <sys>\tPermit the specified syscall (be careful)\n\
               -s <sys>=<act>\tDefine action for the specified syscall (<act>=yes/no/file)\n\
               -t <time>\tSet run time limit (seconds, fractions allowed)\n\
               -T\t\tAllow syscalls for measuring run time\n\
               -v\t\tBe verbose (use multiple times for even more verbosity)\n\
               -w <time>\tSet wall clock time limit (seconds, fractions allowed)\n\
               -x <time>\tSet extra timeout, before which a timing-out program is not yet killed,\n\
               \t\tso that its real execution time is reported (seconds, fractions allowed)\n\
+            + -A <opt>\tPass <opt> as additional argument to the <command>\n\
+            + \t\tBe noted that this option will be appended after <arguments> respectively\n\
               ");
                 exit(2);
               }
               int
               main(int argc, char **argv)
               {
                 int c;
                 uid_t uid;
+            +   char **prog_argv = xmalloc(sizeof(char*) * argc);
+            +   int prog_argc = 0;
-            -   while ((c = getopt(argc, argv, "a:c:eE:fi:k:m:M:o:p:r:s:t:Tvw:x:")) >= 0)
+            +   while ((c = getopt(argc, argv, "a:c:eE:fi:k:m:M:o:p:r:s:t:Tvw:x:A:")) >= 0)
                   switch (c)
                     {
                     case 'a':
               	file_access = atol(optarg);
               	break;
                     case 'c':
               	set_cwd = optarg;
               	break;
                     case 'e':
               	pass_environ = 1;
               	break;
                     case 'E':
               	if (!set_env_action(optarg))
               	  usage();
               	break;
                     case 'f':
               	filter_syscalls++;
               	break;
                     case 'k':
               	stack_limit = atol(optarg);
               	break;
                     case 'i':
               	redir_stdin = optarg;
               	break;
               	if (!set_path_action(optarg))
               	  usage();
               	break;
                     case 'r':
               	redir_stderr = optarg;
               	break;
                     case 's':
               	if (!set_syscall_action(optarg))
               	  usage();
               	break;
                     case 't':
               	timeout = 1000*atof(optarg);
               	break;
                     case 'T':
               	syscall_action[__NR_times] = A_YES;
               	break;
                     case 'v':
               	verbose++;
               	break;
                     case 'w':
                       wall_timeout = 1000*atof(optarg);
               	break;
                     case 'x':
               	extra_timeout = 1000*atof(optarg);
+            +       case 'A':
+            +   prog_argv[prog_argc++] = strdup(optarg);
+            +   break;
               	break;
                     default:
               	usage();
                     }
                 if (optind >= argc)
                   usage();
                 sanity_check();
                 uid = geteuid();
                 if (setreuid(uid, uid) < 0)
                   die("setreuid: %m");
                 box_pid = fork();
                 if (box_pid < 0)
                   die("fork: %m");
-            -   if (!box_pid)
+            +   if (!box_pid) {
-            -     box_inside(argc-optind, argv+optind);
+            +     int real_argc = prog_argc + argc - optind;
-            -   else
+            +     char **real_argv = xmalloc(sizeof(char*) * (real_argc));
+            +     for (int i = 0;i < argc-optind;i++)
+            +       real_argv[i] = strdup(argv[i+optind]);
+            +     for (int i = 0;i < prog_argc;i++)
+            +       real_argv[argc - optind + i] = strdup(prog_argv[i]);
+            +     box_inside(real_argc, real_argv);
+            +   } else
                   boxkeeper();
                 die("Internal error: fell over edge of the world");
               }

std-script/run ¶ +2 -2

               end
               # Hide PROBLEM_HOME
               ENV['PROBLEM_HOME'] = nil
               ENV['SOURCE_NAME'] = nil
               # Run the program.
               #run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
               #
               JAVA_OPTION = "-s set_robust_list -s futex -s clone -s getppid -s clone -s wait4 -p /usr/bin/ -p ./"
               RUBY_OPTION   = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -p #{sandbox_dir}/ -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat -s pipe"
               PYTHON_OPTION = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /usr/bin/ -p /lib64/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -s set_robust_list -s openat -s recvmsg -s connect -s socket -s sendto -s futex -E PYTHONNOUSERSITE=yes"
               PHP_OPTION = "-p /usr/lib64/ -p/lib64/ -p /usr/bin/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p /usr/share/ -s setfsuid -s setfsgid -s openat -s set_robust_list -s futex -s clone -s socket -s connect"
               case language
                 when "java"
                   # for java, extract the classname
                   # wne have to add additional systemcall and we don't check the mem limit (dunno how to fix...)
                   classname = 'DUMMY'
                   File.open(program_name,"r").each do |line|
                     classname = line
                   end
                   #for java, we cannot really check the memory limit...
-            -     run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java #{classname} "
+            +     run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java -A -Xmx#{mem_limit}k -A #{classname} "
                 when "ruby"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{RUBY_OPTION} -i #{input_file_name} -o output.txt /usr/bin/ruby #{program_name} "
                 when "python"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python #{program_name} "
                 when "php"
-            -     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php #{program_name} "
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[128*1024,mem_limit].max} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php -A -d -A memory_limit=#{mem_limit}k -A #{program_name} "
                 else # for c++, pascal, we do the normal checking
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} "
               end
               log "Running test #{test_num}..."
               log run_command
               log
               system(run_command,err: 'run_result')
               # Restore PROBLEM_HOME
               ENV['PROBLEM_HOME'] = problem_home
               # Create the result file.
               result_file = File.new("result", "w")
               comment_file = File.new("comment", "w")
               # Check if the program actually produced any output.
               run_result_file = File.new("run_result", "r")
               run_result = run_result_file.readlines
               run_result_file.close
               run_stat = run_result[run_result.length-1]
               running_time = extract_time(run_stat)

templates/check_wrapper ¶ +1 -1

-            - #!/usr/bin/ruby
+            + #!/usr/bin/env ruby
               #
               # This is a check script wrapper.  It read all required information
               # and call a real check script call REAL_CHECK_SCRIPT in directory
               # [problem_home]/script
               #
               REAL_CHECK_SCRIPT = "<%= script_name %>"
               # The REAL_CHECK_SCRIPT is called with:
               #
               #  (script) <lang> <test-num> <in-file> <out-file> <ans-file> <full-score>
               #
               # and REAL_CHECK_SCRIPT's output to standard out is redirected to
               # 'check_result' as required by normal check script.
               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

test/data/ev/test_memory/script/check ¶ +1 -1

-            - #!/usr/bin/ruby
+            + #!/usr/bin/env 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")

test/data/ev/test_normal/script/check ¶ +1 -1

-            - #!/usr/bin/ruby
+            + #!/usr/bin/env 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")

test/data/ev/test_timeout/script/check ¶ +1 -1

-            - #!/usr/bin/ruby
+            + #!/usr/bin/env 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")

test/engine_spec.rb ¶ +4 -4

                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => '',
                                   :grader_comment= => '',
                                   :running_stat= => /template not found/,
                                   :running_time= => nil,
                                   :exit_status= => nil,
                                   :memory_usage= => nil,
                                   :save => nil})
                 end
                 it "should run test request and produce output file" do
                   problem = stub(Problem,
                                  :id => 1, :name => 'test_normal')
                   grader_should(:grade => 'test1_correct.c',
                                 :on => problem,
                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => '',
                                   :grader_comment= => '',
                                   :running_stat= => /0.0\d* sec./,
                                   :output_file_name= => lambda { |fname|
-            -                       File.exists?(fname).should be_true
+            +                       File.exists?(fname).should be true
                                   },
                                   :running_time= => nil,
                                   :exit_status= => nil,
                                   :memory_usage= => nil,
                                   :save => nil})
                 end
                 it "should clean up problem directory after running test request" do
                   problem = stub(Problem,
                                  :id => 1, :name => 'test_normal')
                   grader_should(:grade => 'test1_correct.c',
                                 :on => problem,
                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => '',
                                   :grader_comment= => '',
                                   :running_stat= => nil,
                                   :output_file_name= => nil,
                                   :running_time= => nil,
                                   :exit_status= => nil,
                                   :memory_usage= => nil,
                                   :save => nil})
-            -     File.exists?(@config.user_result_dir + "/test_request/test_normal/test_cases/1/input-1.txt").should be_false
+            +     File.exists?(@config.user_result_dir + "/test_request/test_normal/test_cases/1/input-1.txt").should be false
                 end
                 it "should compile test request with error and report compilation error" do
                   problem = stub(Problem,
                                  :id => 1, :name => 'test_normal')
                   grader_should(:grade => 'test1_compile_error.c',
                                 :on => problem,
                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => /.+/,
                                   :grader_comment= => /[Cc]ompil.*error/,
                                   :running_stat= => '',
                                   :save => nil})
                 end
                 it "should report exit status" do
                   problem = stub(Problem,
                                  :id => 1, :name => 'test_normal')
                   grader_should(:grade => 'add_nonzero_exit_status.c',
                                 :on => problem,
                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => '',
                                   :grader_comment= => '',
                                   :running_stat= => /[Ee]xit.*status.*10.*0\.0\d* sec/m,
                                   :output_file_name= => lambda { |fname|
-            -                       File.exists?(fname).should be_true
+            +                       File.exists?(fname).should be true
                                   },
                                   :running_time= => nil,
                                   :exit_status= => /10/,
                                   :memory_usage= => nil,
                                   :save => nil})
                 end
                 it "should produce running statistics for normal submission" do
                   problem = stub(Problem,
                                  :id => 1, :name => 'test_normal')
                   grader_should(:grade => 'test_run_stat.c',
                                 :on => problem,
                                 :with => 'in1.txt',
                                 :and_report => {
                                   :graded_at= => nil,
                                   :compiler_message= => '',
                                   :grader_comment= => '',
                                   :running_stat= => nil,
                                   :output_file_name= => lambda { |fname|
-            -                       File.exists?(fname).should be_true
+            +                       File.exists?(fname).should be true
                                   },
                                   :running_time= => lambda { |t|
                                     (t>=0.14) and (t<=0.16)
                                   },
                                   :exit_status= => nil,
                                   :memory_usage= => lambda { |s|
                                     (s>=500) and (s<=1000)
                                   },
                                   :save => nil})
                 end
                 protected
                 def grader_should(args)
                   @user1 = stub(User,
                                 :id => 1, :login => 'user1')
                   problem = args[:on]
                   input_file = @config.test_request_input_base_dir + "/" + args[:with]
                   submission =
                     create_submission_from_file(1, @user1, args[:on], args[:grade])
                   test_request = stub(TestRequest,
                                       :id => 1,

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

r214:336e928de90e - Thu, 19 Feb 2015 15:48:36 - 9 files changed: 60 inserted, 21 deleted

Sign in to your account

Commit r214:336e928de90e public

Author

r214:336e928de90e - Thu, 19 Feb 2015 15:48:36 - 9 files changed: 60 inserted, 21 deleted

Commit `r214:336e928de90e` public