lrun-ruby 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzllZjNiZGQzZWZhOWVjMjlmOTliNGUxYTExYzE1MzI2ZmQ0ZDc1Yg==
+  data.tar.gz: !binary |-
+    YzM1YTU5ZjkwNTRlYzE5OTI5NWNmZWFmYzljYzNlNmQ0NTdiYjQ1Yg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MmEwNjQ0NGUwYWM0YWJhMTVkOGI0Y2E4N2ViMmI4MWI5YWMxMjg0N2FiNmQ1
+    N2ZkM2I0YmVjZmQ1Mjc2YTc3MWQ0YWRlYTU4MjNmODM3MjI4MTQxMjViZWQ2
+    NTc3YzlhMjk3MmQ4MjU2MDQxZTQzNTEwMzY5OWI2ODRkNzI4ODQ=
+  data.tar.gz: !binary |-
+    MTZmOTE1NTdiNDdhZDkwNzdkYmZmZmRlMWE0ZmJjMzk0NzJmYWM4MDM2MzRj
+    NzQyOTQ5ZTk1M2EzMzRjNTM1M2EzZDA3MGI2ZmIwZDY1Mjk4YzFkZDYzZGY1
+    Y2I0MmJmMjhkNjYwMWIyMjNhYTlkYWVkMDI3M2JlNjMwYzI0YzA=

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2013 WU Jun <quark@zju.edu.cn>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# lrun-ruby
+
+[![Build Status](https://travis-ci.org/quark-zju/lrun-ruby.png)](https://travis-ci.org/quark-zju/lrun-ruby)
+[![Code Climate](https://codeclimate.com/github/quark-zju/lrun-ruby.png)](https://codeclimate.com/github/quark-zju/lrun-ruby)
+
+Ruby binding for [lrun](https://github.com/quark-zju/lrun)
+
+## Dependencies
+
+* [lrun](https://github.com/quark-zju/lrun)
+* Ruby 1.9 or above
+
+## Installation
+
+1. Install lrun binary. For detailed steps, please refer to [lrun project page](https://github.com/quark-zju/lrun).
+2. Install `lrun-ruby` gem:
+
+```bash
+gem install lrun-ruby
+```
+
+## Documentation
+
+lrun-ruby is documented with examples. 
+
+[Browse online](http://rdoc.info/github/quark-zju/lrun-ruby).
+
+Alternatively, run `rake doc` and open `doc/index.html`.
+
+## Usage
+
+See examples in documentation.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'yard'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new
+YARD::Rake::YardocTask.new
+
+task :doc => [:yard]
+task :test => [:spec]

data/lib/lrun.rb

@@ -0,0 +1,381 @@
+################################################################################
+# Copyright (C) 2012-2013 WU Jun <quark@zju.edu.cn>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+################################################################################
+
+require 'tempfile'
+require 'shellwords'
+
+# Run program using <tt>lrun</tt>. Require external <tt>lrun</tt> binary.
+#
+# @see Lrun.run
+# @see https://github.com/quark-zju/lrun lrun project page
+#
+# = Example
+#
+#   Lrun.run('foo', Lrun.merge_options({:max_memory => 2 ** 20, :max_cpu_time => 5}, {:network => false}))
+#
+module Lrun
+
+  # Name of lrun executable
+  LRUN_BINARY = 'lrun'
+
+  # Full path of lrun executable, automatically detected using {LRUN_BINARY} and <tt>PATH</tt> environment variable
+  LRUN_PATH   = ENV['PATH'].split(':').map{|p| File.join(p, LRUN_BINARY)}.find{|p| File.executable? p}
+
+  # Available lrun options, and whether they can occur multiple times (1: no, 2: yes)
+  LRUN_OPTIONS = {
+    :max_cpu_time => 1,
+    :max_real_time => 1,
+    :max_memory => 1,
+    :max_output => 1,
+    :max_nprocess => 1,
+    :max_rtprio => 1,
+    :max_nfile => 1,
+    :max_stack => 1,
+    :isolate_process => 1,
+    :basic_devices => 1,
+    :reset_env => 1,
+    :network => 1,
+    :chroot => 1,
+    :chdir => 1,
+    :nice => 1,
+    :umask => 1,
+    :uid => 1,
+    :gid => 1,
+    :interval => 1,
+    :cgname => 1,
+    :bindfs => 2,
+    :cgroup_option => 2,
+    :tmpfs => 2,
+    :env => 2,
+    :fd => 2,
+    :group => 2,
+    :cmd => 2,
+  }
+
+  # Keep how many bytes of stdout and stderr, can be overrided using <tt>options[:truncate]</tt>
+  TRUNCATE_OUTPUT_LENGTH = 4096
+
+  # Error related to lrun
+  class LrunError < RuntimeError; end
+
+  # Result of {Lrun.run}.
+  class Result < Struct.new(:memory, :cputime, :exceed, :exitcode, :signal, :stdout, :stderr)
+
+    # @!attribute memory
+    #   @return [Integer] peak memory used, in bytes
+    #
+    # @!attribute cputime
+    #   @return [Float] CPU time consumed, in seconds
+    #
+    # @!attribute exceed
+    #   @return [Symbol] what limit exceed,
+    #           <tt>:time</tt> if time limit exceeded,
+    #           <tt>:memory</tt> if memory limit exceeded,
+    #           <tt>:output</tt> if output limit exceeded,
+    #           or <tt>nil</tt> if no limit exceeded
+    #
+    # @!attribute exitcode
+    #   @return [Integer] exit code
+    #
+    # @!attribute signal
+    #   @return [Integer] signal number received, or <tt>nil</tt> if exited normally
+    #
+    # @!attribute stdout
+    #   @return [String] standard output, or <tt>nil</tt> if it is redirected in options
+    #
+    # @!attribute stderr
+    #   @return [String] standard error output, or <tt>nil</tt> if stderr is redirected in options
+
+    # @return [Boolean] whether the program exited without crash and has a zero exit code
+    def clean?
+      exitcode.to_i == 0 && !crashed?
+    end
+
+    # @return [Boolean] whether the program crashed (exited by signal)
+    def crashed?
+      !signal.nil?
+    end
+  end
+
+
+  # Merge options so that it can be used in {Lrun.run}.
+  #
+  # @param [Array<Hash>] options options to be merged
+  # @return [Hash] merged options, can be used again in {Lrun.merge_options}
+  #
+  # = Example
+  #
+  #   Lrun.merge_options({:uid => 1000}, {:gid => 100})
+  #   # => {:uid=>1000, :gid=>100}
+  #
+  #   Lrun.merge_options({:nice => 1, :uid => 1001}, {:nice => 2})
+  #   # => {:nice=>2, :uid=>1000}
+  #
+  #   Lrun.merge_options({:fd => [4, 6]}, {:fd => 5}, {:fd => 7})
+  #   # => {:fd=>[4, 6, 5, 7]}
+  #
+  #   Lrun.merge_options({:env => {'A'=>'1', 'B' => '2'}}, {:env => {'C' => '3'}})
+  #   # => {:env=>[["A", "1"], ["B", "2"], ["C", "3"]]}
+  #
+  #   Lrun.merge_options({:uid => 1000}, {:uid => nil})
+  #   # => {}
+  #
+  #   Lrun.merge_options({:fd => [4]}, {:fd => 5}, {:fd => nil})
+  #   # => {}
+  #
+  #   Lrun.merge_options({:network => true, :chdir => '/tmp', :bindfs => {'/a' => '/b'}},
+  #                      {:network => nil, :bindfs => {'/c' => '/d'}})
+  #   # => {:chdir=>"/tmp", :bindfs=>[["/a", "/b"], ["/c", "/d"]]}
+  def self.merge_options(*options)
+    # Remove nil
+    options.compact!
+
+    # Check type of options
+    raise TypeError, 'options should be Hash' unless options.all? { |o| o.is_a? Hash }
+
+    # Merge options
+    options.inject({}) do |result, option|
+      option.each do |k, v|
+        # Remove an option using nil
+        if v.nil?
+          result.delete k
+          next
+        end
+
+        # Append to or Replace an option
+        case LRUN_OPTIONS[k]
+        when 2
+          # Append to previous options
+          result[k] ||= []
+          result[k] += [*v]
+        else
+          # Overwrite previous option
+          result[k] = v
+        end
+      end
+      result
+    end
+  end
+
+  # Run program using <tt>lrun</tt> binary.
+  #
+  # @param [Array<String>, String] commands
+  #   commands to be executed
+  #
+  # @param [Hash] options
+  #   options for lrun.
+  #   Besides options in {Lrun.LRUN_OPTIONS}, there are some additional options available:
+  #
+  #   truncate::
+  #     maximum bytes read for stderr and stdout (default: {Lrun.TRUNCATE_OUTPUT_LENGTH}).
+  #   stdin::
+  #     stdin file path (default: no input).
+  #   stdout::
+  #     stdout file path (default: a tempfile, will be deleted automatically).
+  #     If this option is set, the returned result will have no stdout,
+  #     you should read and delete stdout file manually.
+  #   stderr::
+  #     stderr file path (default: a tempfile, will be deleted automatically).
+  #     If this option is set, the returned result will have no stderr,
+  #     you should read and delete stderr file manually.
+  #
+  #   Note: lrun chroot and mounts does not affect above paths.
+  #
+  # @return [Lrun::Result]
+  #
+  # = Example
+  #
+  #   Lrun.run('echo hello')
+  #   # => #<struct Lrun::Result
+  #   #             memory=262144, cputime=0.002,
+  #   #             exceed=nil, exitcode=0, signal=nil,
+  #   #             stdout="hello\n", stderr="">
+  #
+  #   Lrun.run('java', :max_memory => 2 ** 19, :stdout => '/tmp/out.txt')
+  #   # => #<struct Lrun::Result
+  #   #             memory=524288, cputime=0.006,
+  #   #             exceed=:memory, exitcode=0, signal=nil,
+  #   #             stdout=nil, stderr="">
+  #
+  #   Lrun.run('sleep 30', :max_real_time => 1, :stderr => '/dev/null')
+  #   #  => #<struct Lrun::Result
+  #   #              memory=262144, cputime=0.002,
+  #   #              exceed=:time, exitcode=0, signal=nil,
+  #   #              stdout="", stderr=nil>
+  #
+  #   Lrun.run('cat', :max_output => 100, :stdin => '/dev/urandom', :truncate => 2)
+  #   # => #<struct Lrun::Result
+  #   #             memory=782336, cputime=0.05,
+  #   #             exceed=:output, exitcode=0, signal=nil,
+  #   #             stdout="U\xE1", stderr="">
+  #
+  def self.run(commands, options = {})
+    # Make sure lrun binary is available
+    available!
+
+    # Temp files storing stdout and stderr of target process
+    tmp_out = tmp_err = nil
+
+    # Create temp stdout, stderr files if user does not redirect them
+    options = options.dup
+    options[:stdout] ||= (tmp_out = Tempfile.new("lrun.#{$$}.out")).path
+    options[:stderr] ||= (tmp_err = Tempfile.new("lrun.#{$$}.err")).path
+
+    IO.pipe do |rfd, wfd|
+      # Keep pid of lrun process for checking its status
+      pid = spawn_lrun commands, options, wfd
+
+      # Read fd 3, where lrun write its report
+      wfd.close
+      report = rfd.read
+
+      # Check if lrun exits normally
+      stat = Process.wait2(pid)[-1]
+      if stat.signaled? || stat.exitstatus != 0
+        raise LrunError, "lrun exits abnormally: #{stat}. #{tmp_err.read unless tmp_err.nil?}"
+      end
+
+      # Build and return result
+      build_result report, tmp_out, tmp_err, options[:truncate]
+    end
+  ensure
+    clean_tmpfile [tmp_out, tmp_err]
+  end
+
+  # Check if lrun binary exists
+  #
+  # @return [Bool] whether lrun binary is found
+  def self.available?
+    !LRUN_PATH.nil?
+  end
+
+  # Complain if lrun binary is not available
+  def self.available!
+    raise LrunError, "#{LRUN_BINARY} not found in PATH. Please install lrun first." unless available?
+  end
+
+  private
+
+  # Clean temp files
+  #
+  # @param [Array<Tempfile>] temp_files temp files to be cleaned
+  def self.clean_tmpfile(temp_files)
+    temp_files.each do |file|
+      file.unlink rescue nil
+    end
+  end
+
+  # Expand options to be used in command line
+  #
+  # @param [Hash] options single options hash returned by {Lrun.merge_options}
+  # @return [Array<String>] command line arguments
+  #
+  # = Example
+  #
+  #   Lrun.format_options({:chdir=>"/tmp", :bindfs=>[["/a", "/b"], ["/c", "/d"]], :fd => [2, 3]})
+  #   # => ["--chdir", "/tmp", "--bindfs", "/a", "/b", "--bindfs", "/c", "/d", "--fd", "2", "--fd", "3"]
+  def self.expand_options(options)
+    raise TypeError, 'expect options to be a Hash' unless options.is_a? Hash
+
+    command_arguments = options.map do |key, values|
+      expand_option key, values
+    end
+
+    command_arguments.compact.flatten.map(&:to_s)
+  end
+
+  # Expand a single option to be used in command line
+  #
+  # @param [Symbol] key option name
+  # @param [Array, #to_s] values option value(s)
+  # @return [Array<String>] arguments used in command line
+  def self.expand_option(key, values)
+    return nil unless LRUN_OPTIONS.has_key? key
+
+    [*values].map do |value|
+      ["--#{key.to_s.gsub('_', '-')}", *value]
+    end
+  end
+
+  # Spawn lrun process.
+  #
+  # @param [IO:fd] report_fd
+  #   file descriptor used to receive lrun report
+  #
+  # @return [Integer] pid spawned process id of lrun
+  def self.spawn_lrun(commands, options, report_fd)
+    # Expand commands if commands is a string
+    commands = Shellwords.split(commands) if commands.is_a? String
+    raise ArgumentError, 'commands should not be empty' if commands.nil? || commands.empty?
+
+    # Build command line
+    command_line = [LRUN_PATH, *expand_options(options), *commands]
+    spawn_options = {0 => options[:stdin] || :close,
+                     1 => options[:stdout] || (tmp_out = Tempfile.new("lrun.#{$$}.out")).path,
+                     2 => options[:stderr] || (tmp_err = Tempfile.new("lrun.#{$$}.err")).path,
+                     3 => report_fd.fileno}
+
+    # Keep pid of lrun process for checking its status
+    Process.spawn(*command_line, spawn_options)
+  end
+
+  # Build {Lrun::Result} from essential information.
+  #
+  # @return [Lrun::Result]
+  def self.build_result(lrun_report, stdout = nil, stderr = nil, truncate = TRUNCATE_OUTPUT_LENGTH)
+    report = Hash[lrun_report.lines.map{ |l| l.chomp.split(' ', 2)}]
+
+    # Collect information
+    memory = report['MEMORY'].to_i
+    cputime = report['CPUTIME'].to_f
+    exceed = parse_exceed(report['EXCEED'])
+    exitcode = report['EXITCODE'].to_i
+    signal = report['SIGNALED'].to_i == 0 ? nil : report['TERMSIG'].to_i
+    stdout &&= stdout.read(truncate) || ''
+    stderr &&= stderr.read(truncate) || ''
+
+    # Build Result
+    Result.new(memory, cputime, exceed, exitcode, signal, stdout, stderr)
+  end
+
+  # Parse exceed information from lrun report
+  #
+  # @param [String] report_exceed exceed reported by lrun
+  # @return [Symbol, nil] exceeded limit in symbol, or <tt>nil</tt> if no limit exceeded
+  def self.parse_exceed(report_exceed)
+    case report_exceed
+    when 'none'
+      nil
+    when /TIME/
+      :time
+    when /OUTPUT/
+      :output
+    when /MEMORY/
+      :memory
+    else
+      raise LrunError, "unexpected EXCEED returned by lrun: #{report['EXCEED']}"
+    end
+  end
+
+  # Autoload {Lrun::Runner}
+  autoload :Runner, 'lrun/runner'
+end

data/lib/lrun/runner.rb

@@ -0,0 +1,84 @@
+################################################################################
+# Copyright (C) 2012-2013 WU Jun <quark@zju.edu.cn>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+################################################################################
+
+require 'lrun'
+
+# {Lrun} provides essential methods to run program with different options
+# using <tt>lrun</tt> binary.
+#
+# {Lrun::Runner} makes it easier to run many programs with same options.
+#
+# = Example
+#
+#   runner = Lrun::Runner.new(:max_cpu_time=>1, :tmpfs=>[["/tmp", 2**20]], :chdir=>"/tmp")
+#   # or:
+#   runner = Lrun::Runner.new.where(:max_cpu_time=>1, :tmpfs=>[["/tmp", 2**20]], :chdir=>"/tmp")
+#   # or:
+#   runner = Lrun::Runner.new.max_cpu_time(1).tmpfs('/tmp' => 2**20).chdir('/tmp')
+#
+#   runner.options
+#   # => {:max_cpu_time=>1, :tmpfs=>[["/tmp", 1048576]], :chdir=>"/tmp"} 
+#   runner.max_cpu_time(nil).options
+#   # => {:tmpfs=>[["/tmp", 1048576]], :chdir=>"/tmp"} 
+#
+#   runner.run('pwd').stdout
+#   # => "/tmp\n"
+#   runner.cmd("touch `seq 1 4`").run('ls').stdout
+#   # => "1\n2\n3\n4\n"
+#   runner.cmd("echo 'puts ENV[?A]' > a.rb").env('A' => 'Hello').run('ruby a.rb').stdout
+#   # => "Hello\n"
+class Lrun::Runner
+
+  # @!attribute [rw] options
+  #   @return [Hash] options used in {#run}
+  attr_accessor :options
+
+  # @param [Hash] options options for the runner
+  def initialize(options = {})
+    @options = options
+  end
+
+  # Methods for easily applying custom options
+  [:stdin, :stdout, :stderr, *Lrun::LRUN_OPTIONS.keys].each do |name|
+    define_method name do |value| where(name => value) end
+  end
+
+  # Run commands using current {#options}.
+  #
+  # @param [Array<String>, String] commands commands to be executed
+  #
+  # @see options
+  # @see Lrun.run
+  def run(commands)
+    Lrun.run commands, @options
+  end
+
+  # Create a new runner with new options
+  #
+  # @param [Hash] options new options to be merged
+  # @return [Lrun::Runner] new runner created with merged options
+  def where(options)
+    raise TypeError, 'expect options to be a Hash' unless options.is_a? Hash
+    Lrun::Runner.new(Lrun.merge_options(@options, options))
+  end
+
+end

data/lrun-ruby.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = 'lrun-ruby'
+  s.version = '0.1.1'
+  s.date = Date.civil(2013,3,23)
+  s.summary = 'Ruby binding for lrun'
+  s.description = 'Ruby binding for lrun, a standalone executable designed to run programs with limited resources under Linux.'
+  s.authors = ["Wu Jun"]
+  s.email = 'quark@zju.edu.cn'
+  s.homepage = 'https://github.com/quark-zju/lrun-ruby'
+  s.require_paths = ['lib']
+  s.licenses = ['MIT']
+  s.has_rdoc = 'yard'
+  s.files = %w(LICENSE README.md Rakefile lrun-ruby.gemspec)
+  s.files += Dir.glob("lib/**/*.rb")
+  s.files += Dir.glob("spec/**/*.rb")
+  s.test_files = Dir['spec/**/*.rb']
+end

data/spec/lrun_runner_spec.rb

@@ -0,0 +1,59 @@
+require 'lrun/runner'
+
+describe Lrun::Runner, '#new' do
+
+  it 'creates a runner' do
+    Lrun::Runner.new.class.should == Lrun::Runner
+  end
+
+  it 'accepts options' do
+    Lrun::Runner.new(:uid => 2, :gid => 3).options.should == {:uid => 2, :gid => 3}
+  end
+
+  it 'rejects too many options' do
+    lambda { Lrun::Runner.new({:uid => 2}, {:gid => 3}) }.should raise_error(ArgumentError)
+  end
+
+end
+
+describe Lrun::Runner, '#where' do
+
+  let(:runner) { Lrun::Runner.new(:uid => 2, :fd => 2, :tmpfs => {'/tmp' => 0}) }
+
+  it 'change options' do
+    runner.where(:uid => 3).options[:uid].should == 3
+  end
+
+  it 'add options' do
+    runner.where(:fd => 3).options[:fd].should == [2, 3]
+    runner.where(:fd => [4, 5]).options[:fd].should == [2, 4, 5]
+    runner.where(:tmpfs => {'/usr/bin' => 1}).options[:tmpfs].should == [["/tmp", 0], ["/usr/bin", 1]]
+  end
+
+  it 'delete options' do
+    runner.where(:uid => nil).options[:fd].should_not include(:uid)
+    runner.where(:fd => nil).options.keys.should_not include(:fd)
+    runner.where(:fd => nil, :uid => nil, :tmpfs => nil).options.should be_empty
+  end
+
+  it 'does not change original options' do
+    lambda {
+      runner.where(:uid => 5, :fd => nil, :tmpfs => {'/a' => 2}, :gid => 6)
+    }.should_not change(runner, :options)
+  end
+
+end
+
+describe Lrun::Runner, '#run', :if => Lrun.available? do
+
+  let(:runner) { Lrun::Runner.new(:uid => 2, :fd => 2, :tmpfs => {'/tmp' => 0}) }
+
+  it 'runs' do
+    runner.run('echo a').stdout.should == "a\n"
+  end
+
+  it 'passes options' do
+    runner.env('A' => 42).run(['sh', '-c', 'echo $A']).stdout.chomp.should == '42'
+  end
+
+end

data/spec/lrun_spec.rb

@@ -0,0 +1,144 @@
+require 'lrun'
+require 'tempfile'
+
+describe Lrun do
+
+  it 'can not be instantiated' do
+    lambda { Lrun.new }.should raise_error(NoMethodError)
+  end
+
+end
+
+describe Lrun, '#merge_options' do
+
+  it 'accepts empty options' do
+    Lrun.merge_options(nil).should == {}
+    Lrun.merge_options({}).should == {}
+  end
+
+  it 'rejects non-Hash' do
+    lambda { Lrun.merge_options(1) }.should raise_error(TypeError)
+    lambda { Lrun.merge_options('a', 'b') }.should raise_error(TypeError)
+  end
+
+  it 'merges options' do
+    Lrun.merge_options({:uid => 1000}, {:gid => 100, :interval => 2}, {:network => false}).should == {:network => false, :uid => 1000, :gid => 100, :interval => 2}
+    Lrun.merge_options({:fd => [4, 6]}, {:fd => 5}, {:fd => 7}).should == {:fd=>[4, 6, 5, 7]}
+    Lrun.merge_options({:bindfs => {'/a' => '/b'}}, {:bindfs => {'/c' => '/d'}}).should == {:bindfs => [["/a", "/b"], ["/c", "/d"]]}
+  end
+
+  it 'overwrite options' do
+    Lrun.merge_options({:uid => 1}, {:uid => 3}, {:uid => 4}).should == {:uid => 4}
+  end
+
+  it 'removes options' do
+    Lrun.merge_options({:uid => 1000}, {:uid => nil}).should == {}
+    Lrun.merge_options({:fd => [4, 5, 6]}, {:fd => 7}, {:fd => nil}).should == {}
+  end
+
+end
+
+describe Lrun, '#run', :if => Lrun.available? do
+
+  context "when running true and false" do
+    let(:true_result) { Lrun.run('true') }
+    let(:false_result) { Lrun.run('false') }
+
+    it 'returns exitcode' do
+      true_result.exitcode.should == 0
+      false_result.exitcode.should_not == 0
+    end
+
+    it 'returns cpu and memory usage' do
+      true_result.memory.should > 0
+      true_result.cputime.should >= 0
+    end
+
+    it 'returns exceed' do
+      true_result.exceed.should be_nil
+      false_result.exceed.should be_nil
+    end
+
+    it 'returns stdout and stderr' do
+      true_result.stdout.should == ""
+      false_result.stdout.should == ""
+    end
+
+    it 'returns stderr' do
+      true_result.stderr.should == ""
+      false_result.stderr.should == ""
+    end
+
+    it '.clean?' do
+      true_result.clean?.should be_true
+      false_result.clean?.should be_false
+    end
+
+    it '.crashed?' do
+      true_result.crashed?.should be_false
+      false_result.crashed?.should be_false
+    end
+  end
+
+  context 'when running cat' do
+    it 'can redirect stdin' do
+      begin
+        tmpfile = Tempfile.new("input")
+        tmpfile.write("foo bar")
+        tmpfile.close
+        Lrun.run('cat', stdin: tmpfile.path).stdout.should == "foo bar"
+      ensure
+        tmpfile.unlink rescue nil
+      end
+    end
+
+    it 'does not alter options' do
+      options = {}
+      Lrun.run('cat', options)
+      options.should == {}
+    end
+  end
+
+  context 'when running echo' do
+    it 'captures stdout' do
+      Lrun.run('echo Hello').stdout.should == "Hello\n"
+      Lrun.run(['echo', 'World']).stdout.should == "World\n"
+    end
+
+    it 'can redirect stdout' do
+      begin
+        tmpfile = Tempfile.new("output")
+        result = Lrun.run('echo blabla', stdout: tmpfile.path)
+        result.stderr.should == ""
+        result.stdout.should be_nil
+        tmpfile.read.should == "blabla\n"
+      ensure
+        tmpfile.unlink rescue nil
+      end
+    end
+  end
+
+  context 'when setting limit options' do
+    it 'returns exceed' do
+      Lrun.run('sleep 1', :max_real_time => 0.1).exceed.should == :time
+      Lrun.run(['cat', '/dev/full'], :stdout => '/dev/null', :max_cpu_time => 0.1).exceed.should == :time
+      Lrun.run(['cpp', '/dev/full', '-o', '/dev/null'], :max_memory => 1_000_000).exceed.should == :memory
+      Lrun.run(['cat', '/dev/full'], :stdout => '/dev/null', :max_output => 1_000).exceed.should == :output
+    end
+  end
+
+  context 'when parameters are illegal' do
+    it 'rejects empty command' do
+      lambda { Lrun.run(nil) }.should raise_error(ArgumentError)
+      lambda { Lrun.run('') }.should raise_error(ArgumentError)
+      lambda { Lrun.run([]) }.should raise_error(ArgumentError)
+    end
+
+    it 'handles lrun errors' do
+      lambda { Lrun.run('strange_non_existed_executable') }.should raise_error(Lrun::LrunError)
+      lambda { Lrun.run(['--unsupported-options', 'true']) }.should raise_error(Lrun::LrunError)
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: lrun-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Wu Jun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-23 00:00:00.000000000 Z
+dependencies: []
+description: Ruby binding for lrun, a standalone executable designed to run programs
+  with limited resources under Linux.
+email: quark@zju.edu.cn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lrun-ruby.gemspec
+- lib/lrun.rb
+- lib/lrun/runner.rb
+- spec/lrun_spec.rb
+- spec/lrun_runner_spec.rb
+homepage: https://github.com/quark-zju/lrun-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby binding for lrun
+test_files:
+- spec/lrun_spec.rb
+- spec/lrun_runner_spec.rb
+has_rdoc: yard