dia 1.5 → 2.0.0

data/TODO.md

@@ -1,8 +0,0 @@
-## TODO
-
-### 1.4
-* Dia::Sandbox.run() doesn't use @app to launch a process, but uses @app\_path which was removed in 1.3
- * If you're going to run a block under a sandbox, make Dia::Sandbox#run accept *args so they may be passed onto the block.
-
-### 1.3
-* Remove link to experimental branch in gemspec before release

data/lib/dia/commonapi.rb

@@ -1,7 +0,0 @@
-module Dia
-  module CommonAPI
-    extend FFI::Library
-    ffi_lib(%w(sandbox system libSystem.B.dylib))
-    attach_function :sandbox_init, [ :pointer, :uint64, :pointer ], :int
-  end
-end

data/lib/dia/sandbox.rb

@@ -1,208 +0,0 @@
-module Dia
-  
-  class Sandbox
-  
-    require('io/wait')
-
-    include Dia::CommonAPI
-    
-    attr_reader :app
-    attr_reader :profile
-    attr_reader :pid
-    attr_reader :blk
-
-    # The constructer accepts a profile as the first parameter, and an 
-    # application path _or_ block as its second parameter.  
-    #
-    # @example
-    #
-    #     # Passing an application to the constructer ..
-    #     sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES, 'ping google.com')
-    #     
-    #     # Passing a block to the constructer ..
-    #     sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-    #       File.open('foo.txt', 'w') do |f|
-    #         f.puts "bar"
-    #       end
-    #     end
-    #
-    # @see Dia::Sandbox#run See Dia::Sandbox#run for executing the sandbox.
-    #
-    # @param  [Constant]     Profile      The profile to be used when creating a
-    #                                     sandbox.
-    #
-    # @param  [Proc]         Proc         A proc object you want to run under a 
-    #                                     sandbox.   
-    #                                     Omit the "Application" parameter if 
-    #                                     passed.
-    #
-    # @param  [String]       Application  The path to an application you want
-    #                                     to run under a sandbox.   
-    #                                     Omit the "Proc" parameter if passed.
-    # @return [Dia::SandBox] Returns an instance of Dia::SandBox
-    
-    def initialize(profile, app=nil, &blk)
-      if (app && blk) || (app.nil? && blk.nil?) 
-        raise ArgumentError, 'Application or Proc object expected'
-      end
-      
-      @app      = app
-      @blk      = blk
-      @profile  = profile
-      @pid      = nil
-      initialize_streams()
-    end
-
-    # The #exception_raised?() method returns true if an exception has been 
-    # raised in the last call to #run(), and false otherwise.
-    #
-    # @return [Boolean] Returns true or false.
-    # @since  1.5
-    def exception_raised?()
-      !!exception()
-    end
-
-    # The exception() method returns the last exception raised after a 
-    # a call to #run(), or nil.
-    #
-    # Every call to #run() resets the variable storing the exception object
-    # to nil, and it will only be a non-nil value if the last call to #run()
-    # raised an exception.
-    #
-    # This method can be used if you need access(from the parent process)
-    # to an exception raised in your sandbox.
-    #
-    # If the sandbox raises an exception rather quickly, you might need to
-    # sleep(X) (0.3-0.5s on my machine) before the parent process 
-    # recieves the exception.
-    # 
-    # @return [Exception, nil]  Returns an instance or subclass instance of 
-    #                           Exception when successful, and nil when 
-    #                           there is no exception available.
-    # @since 1.5
-    def exception()
-      @write.close()
-      if @read.ready?()
-        @e = Marshal.load(@read.readlines().join())
-      end
-      @read.close()
-      initialize_streams()
-      @e
-    end
-
-    # The run method will spawn a child process and run the application _or_
-    # block supplied to the constructer under a sandbox.  
-    # This method will not block.
-    #
-    # @param  [Arguments] Arguments   A variable amount of arguments that will 
-    #                                 be passed onto the block supplied to the 
-    #                                 constructer. Optional.
-    #
-    # @raise  [SystemCallError]       In the case of running a block, a number 
-    #                                 of subclasses of SystemCallError may be 
-    #                                 raised if the block violates sandbox 
-    #                                 restrictions.
-    #                                 The parent process will not be affected 
-    #                                 and if you wish to catch exceptions you 
-    #                                 should do so in your block.
-    #
-    # @raise  [Dia::SandboxException] Will raise Dia::SandboxException in a 
-    #                                 child process and exit if the sandbox 
-    #                                 could not be initiated.
-    #
-    # @return [Fixnum]                The Process ID(PID) that the sandboxed 
-    #                                 application is being run under.
-    def run(*args)
-      @e = nil
-      initialize_streams()      
-      @pid = fork do
-        begin
-          if sandbox_init(FFI::MemoryPointer.from_string(@profile), 
-                          0x0001, 
-                          err = FFI::MemoryPointer.new(:pointer)) == -1
-
-            raise(Dia::SandboxException, "Failed to initialize sandbox" \
-                                         "(#{err.read_pointer.read_string})")
-          end
-          
-          if @app
-            exec(@app)
-          else
-            @blk.call(*args)
-          end
-
-        rescue SystemExit, Interrupt => e 
-          raise(e)
-        rescue Exception => e        
-          @write.write(Marshal.dump(e))
-        ensure
-          @write.close()
-          @read.close()
-        end
-      end
-
-      # parent ..
-      @thr = Process.detach(@pid)
-      @pid
-    end
-   
-    # The exit_status method will return the exit status of the child process 
-    # running in a sandbox.  
-    # This method *will* block until the child process exits.
-    #
-    # @return [Fixnum, nil] Returns the exit status of the process that ran
-    #                       under a sandbox.
-    #                       Returns nil if Dia::Sandbox#run has not 
-    #                       been called yet, or if the process stopped
-    #                       abnormally(ie: through SIGKILL, or #terminate).
-    # @since 1.5
-    def exit_status()
-      @thr.value().exitstatus() unless @thr.nil?
-    end
-
-    # The terminate method will send SIGKILL to a process running in a sandbox.
-    # By doing so, it effectively terminates the sandbox.
-    #
-    # @raise  [SystemCallError] It may raise a number of subclasses of 
-    #                           SystemCallError if a call to Process.kill 
-    #                           was unsuccessful ..
-    #
-    # @return [Fixnum, nil]     It will return 1 when successful, and 
-    #                           it will return "nil" if Dia::Sandbox#run() 
-    #                           has not been called yet. 
-    def terminate()
-      Process.kill('SIGKILL', @pid) unless @pid.nil?
-    end
-    
-    # The running? method will return true if a sandbox is running, 
-    # and false otherwise.  
-    #
-    # @raise  [SystemCallError] It may raise a subclass of SystemCallError if 
-    #                           you do not have permission to send a signal
-    #                           to the process running in a sandbox.
-    #
-    # @return [Boolean,nil]     It will return true or false if the sandbox 
-    #                           is running or not, and it will return "nil"
-    #                           if Dia::Sandbox#run has not been called yet.
-    def running?()
-      if @pid.nil?
-        nil
-      else
-        begin
-          Process.kill(0, @pid)
-          true
-        rescue Errno::ESRCH
-          false
-        end
-      end
-    end
-   
-    private
-    
-    def initialize_streams()
-      @read, @write = IO.pipe()
-    end
- 
-  end
-  
-end

data/test/suite/check_if_sandbox_is_alive_test.rb

@@ -1,29 +0,0 @@
-BareTest.suite "Dia::Sandbox#running?", :tags => [ :running? ] do
-  
-  assert 'Confirm that Dia::Sandbox#running? returns true when a sandbox is running' do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      sleep(20)
-    end
-    
-    sandbox.run
-    equal(true, sandbox.running?)
-    sandbox.terminate
-  end
-
-  assert 'Confirm that Dia::Sandbox#running? returns false when a sandbox is not running' do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      sleep(20)
-    end
-    sandbox.run
-    sandbox.terminate
-    sleep(1)
-    equal(false, sandbox.running?)
-  end
- 
-  assert("nil will be returned if Dia::Sandbox#run hasn't been called before a call to #running?()") do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do
-      # ...
-    end
-    equal(nil, sandbox.running?)
-  end
-end

data/test/suite/exception()_test.rb

@@ -1,55 +0,0 @@
-BareTest.suite('Dia::Sandbox#exception()') do
-  assert('#exception() will return an exception raised in the sandbox') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      raise()
-    end
-  
-    sandbox.run()
-    sleep(0.1)
-    equal(RuntimeError, sandbox.exception.class())
-  end
-
-  assert('#exception() returns nil if called before ' \
-         'Dia::Sandbox#run()') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-                # ...
-              end
-    equal(nil, sandbox.exception())
-  end
-
-  assert('#exception() returns an exception object the first' \
-          ' and second time it is called after a single call to #run()') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do 
-      raise()
-    end
-  
-    sandbox.run()
-    sleep(0.1)
-    equal(RuntimeError, sandbox.exception().class)
-    equal(RuntimeError, sandbox.exception().class)
-  end
-
-  assert('#exception() will be set to nil after the first call to ' \
-         '#run raises an exception, and the second does not') do
-
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do 
-      raise()
-    end
-    
-    sandbox.run()
-    sleep(0.1)
-    equal(RuntimeError, sandbox.exception().class)
-    sandbox.instance_variable_set("@blk", proc { })
-    sandbox.run()
-    equal(nil, sandbox.exception())
-  end
-
-  assert('#exception() can marshal data containing one or more \n') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do 
-      fork {}
-    end
-    sandbox.run()
-    sleep(0.5)
-    equal(Errno::EPERM, sandbox.exception().class)
-  end
-end

data/test/suite/exception_raised?_test.rb

@@ -1,22 +0,0 @@
-BareTest.suite('Dia::Sandbox#exception_raised?()', 
-               :tags => [ :exception_raised] ) do
-  assert('#exception_raised?() returns false when no exception has been ' \
-         'raised') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      # ...
-    end 
-    sandbox.run()
-    sleep(0.1)
-    equal(false, sandbox.exception_raised?())
-  end
-
-  assert('#exception_raised?() returns true when an exception has been ' \
-         'raised') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      raise(StandardError, 'Exception')
-    end
-    sandbox.run()
-    sleep(0.1)
-    equal(true, sandbox.exception_raised?())
-  end
-end

data/test/suite/exceptions_test.rb

@@ -1,12 +0,0 @@
-BareTest.suite('Exceptions', :tags => [ :sandbox_init_exception ]) do
-  assert('Dia::SandboxException is raised if a call to sandbox_init() fails') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do 
-      # ...
-    end
-    sandbox.instance_variable_set("@profile", "i am going to break")
-    sandbox.run
-    sleep(0.1)
-    equal(Dia::SandboxException, sandbox.exception().class)
-  end
-end
-

data/test/suite/exit_status_test.rb

@@ -1,16 +0,0 @@
-BareTest.suite('Dia::Sandbox#exit_status') do
-  assert('The exit status of a child process running under a sandbox is returned.') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do
-      exit(10)
-    end
-    sandbox.run
-    equal(10, sandbox.exit_status)
-  end
-
-  assert("nil will be returned if Dia::Sandbox#run hasn't been called before a call to #exit_status") do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do
-    end
-    equal(nil, sandbox.exit_status)
-  end
-
-end

data/test/suite/passing_parameters_to_constructer_test.rb

@@ -1,34 +0,0 @@
-# See /test/suite/run_block_in_sandbox_test.rb for tests that confirm sandboxes are successfully created ..
-BareTest.suite 'Dia::Sandbox.new', :tags => [ :new ] do
-  
-  assert 'Passing no arguments to the constructer will raise an ArgumentError' do
-    raises(ArgumentError) do
-      Dia::Sandbox.new
-    end
-  end
-  
-  assert 'Passing only a profile to the constructer will raise an ArgumentError' do
-    raises(ArgumentError) do
-      Dia::Sandbox.new(Dia::Profiles::NO_INTERNET)
-    end
-  end
-  
-  assert 'Passing a profile, application path, and a block will raise an ArgumentError' do
-    raises(ArgumentError) do
-      Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES, 'ls') do
-        puts "foo"
-      end
-    end
-  end
-  
-  assert 'Passing an application path and a profile will raise nothing' do
-    Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES, 'ls')
-  end
-  
-  assert 'Passing a block and a profile will raise nothing' do
-    Dia::Sandbox.new(Dia::Profiles::NO_OS_SERVICES) do
-      puts "foo"
-    end
-  end
-  
-end

data/test/suite/run_block_in_sandbox_test.rb

@@ -1,132 +0,0 @@
-# TODO: Add assertion for Dia::Profiles::NO_OS_SERVICES
-
-BareTest.suite 'Dia::Sandbox#run', :tags => [ :run ] do 
-
-  setup do
-    @reader, @writer = IO.pipe
-  end
-  
-  assert 'A Ruby block will not be able to access the internet' do
-    
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do
-      begin
-        @reader.close
-        TCPSocket.open('http://www.google.com', 80)
-        @writer.write('false')
-      rescue SocketError, SystemCallError => e
-        @writer.write('true')
-      end
-    end
-    
-    # a child process is spawned, and the block passed to the constructer executed.
-    sandbox.run
-    
-    # back in the parent.
-    @writer.close
-    successful = @reader.gets
-    @reader.close
-    
-    equal('true', successful)
-  end
-    
-  assert 'A Ruby block will not be able to write the filesystem' do
-    
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_FILESYSTEM_WRITE)  do
-      begin
-        @reader.close
-        File.open('foo.txt', 'w')
-        @writer.write('false')
-      rescue SystemCallError => e
-        @writer.write('true')
-      end
-    end
-
-    # a child process is spawned, and the block passed to the constructer executed.
-    sandbox.run
-    
-    # back in the parent.
-    @writer.close
-    successful = @reader.gets
-    @reader.close
-    
-    equal('true', successful)
-  end
-  
-  assert 'A Ruby block will not be able to write to the filesystem except when writing to /tmp' do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_FILESYSTEM_WRITE_EXCEPT_TMP) do
-      marshal = []
-      begin
-        marshal = Marshal.dump(marshal)
-        @reader.close
-        File.open('foo.txt', 'w')
-        @writer.write('false')
-      rescue SystemCallError => e
-        marshal = Marshal.dump(Marshal.load(marshal) << 'true')
-      end
-      
-      begin
-        File.open('/tmp/foo.txt', 'w') do |f|
-          f.puts 'foo'
-        end
-        @writer.write(marshal = Marshal.dump(Marshal.load(marshal) << 'true'))
-      rescue SystemCallError => e
-        @writer.write('false')
-      end
-    end
-    
-    # a child process is spawned, and the block passed to the constructer executed.
-    sandbox.run
-    
-    # back in the parent.
-    @writer.close
-    successful = Marshal.load(@reader.gets)
-    @reader.close
-    
-    equal(['true', 'true'], successful)
-  end
-  
-  assert 'A Ruby block will not be able to do any socket based communication' do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_NETWORKING) do  
-      begin
-        @reader.close
-        TCPSocket.open('http://www.youtube.com', 80)
-        @writer.write('false')
-      rescue SocketError => e
-        @writer.write('true')
-      end
-    end
-    
-    # a child process is spawned, and the block passed to the constructer executed.
-    sandbox.run
-    
-    # back in the parent.
-    @writer.close
-    successful = @reader.gets
-    @reader.close
-    
-    equal('true', successful)
-  end
- 
-  assert 'A Ruby block will be able to receive arguments through #run' do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do |foo, bar|
-      @reader.close
-      @writer.write(foo+bar)
-      @writer.close
-    end
-    sandbox.run('foo', 'bar')
-    
-    # back in the parent..
-    @writer.close
-    answer = @reader.gets
-    @reader.close
-    
-    equal('foobar', answer)
-  end
-
-  assert('A Ruby block will return the PID of the spawned child process after executing #run') do
-    sandbox = Dia::Sandbox.new(Dia::Profiles::NO_INTERNET) do
-      # ...
-    end
-    equal(Fixnum, sandbox.run.class)
-  end
-end