open4 1.1.0 → 1.2.0

data/README

@@ -193,6 +193,44 @@ SAMPLES
     42
     /dmsp/reference/ruby-1.8.1//lib/ruby/1.8/timeout.rb:42:in `relay': execution expired (Timeout::Error)
 
+  ----------------------------------------------------------------------------
+  pfork4 is similar to popen4, but instead of executing a command, it runs
+  ruby code in a child process. if the child process raises an exception, it
+  propagates to the parent.
+  ----------------------------------------------------------------------------
+
+    harp: > cat sample/pfork4.rb
+    require 'open4'
+
+    echo = lambda do
+      $stdout.write $stdin.read
+      raise 'finish implementing me'
+    end
+
+    org_message = "hello, world!"
+    got_message = nil
+    exception   = nil
+
+    begin
+      Open4.pfork4(echo) do |cid, stdin, stdout, stderr|
+        stdin.write org_message
+        stdin.close
+        got_message = stdout.read
+      end
+    rescue RuntimeError => e
+      exception = e.to_s
+    end
+
+    puts "org_message: #{org_message}"
+    puts "got_message: #{got_message}"
+    puts "exception  : #{exception}"
+
+
+    harp: > ruby sample/pfork4.rb
+    org_message: hello, world!
+    got_message: hello, world!
+    exception  : finish implementing me
+
 HISTORY
   1.0.0
     - added ability for spawn to take a proc (respond_to?(:call))

data/README.erb

@@ -193,6 +193,44 @@ SAMPLES
     42
     /dmsp/reference/ruby-1.8.1//lib/ruby/1.8/timeout.rb:42:in `relay': execution expired (Timeout::Error)
 
+  ----------------------------------------------------------------------------
+  pfork4 is similar to popen4, but instead of executing a command, it runs
+  ruby code in a child process. if the child process raises an exception, it
+  propagates to the parent.
+  ----------------------------------------------------------------------------
+
+    harp: > cat sample/pfork4.rb
+    require 'open4'
+
+    echo = lambda do
+      $stdout.write $stdin.read
+      raise 'finish implementing me'
+    end
+
+    org_message = "hello, world!"
+    got_message = nil
+    exception   = nil
+
+    begin
+      Open4.pfork4(echo) do |cid, stdin, stdout, stderr|
+        stdin.write org_message
+        stdin.close
+        got_message = stdout.read
+      end
+    rescue RuntimeError => e
+      exception = e.to_s
+    end
+
+    puts "org_message: #{org_message}"
+    puts "got_message: #{got_message}"
+    puts "exception  : #{exception}"
+
+
+    harp: > ruby sample/pfork4.rb
+    org_message: hello, world!
+    got_message: hello, world!
+    exception  : finish implementing me
+
 HISTORY
   1.0.0
     - added ability for spawn to take a proc (respond_to?(:call))

data/lib/open4.rb

@@ -4,19 +4,46 @@ require 'timeout'
 require 'thread'
 
 module Open4
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
   def self.version() VERSION end
 
   class Error < ::StandardError; end
 
+  def pfork4(fun, &b)
+    Open4.do_popen(b, :block) do |ps_read, _|
+      ps_read.close
+      begin
+        fun.call
+      rescue SystemExit => e
+        # Make it seem to the caller that calling Kernel#exit in +fun+ kills
+        # the child process normally. Kernel#exit! bypasses this rescue
+        # block.
+        exit! e.status
+      else
+        exit! 0
+      end
+    end
+  end
+  module_function :pfork4
+
   def popen4(*cmd, &b)
+    Open4.do_popen(b, :init) do |ps_read, ps_write|
+      ps_read.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      ps_write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      exec(*cmd)
+      raise 'forty-two'   # Is this really needed?
+    end
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  def self.do_popen(b = nil, exception_propagation_at = nil, &cmd)
     pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
 
     verbose = $VERBOSE
     begin
       $VERBOSE = nil
-      ps.first.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
       cid = fork {
         pw.last.close
@@ -34,48 +61,57 @@ module Open4
         STDOUT.sync = STDERR.sync = true
 
         begin
-          exec(*cmd)
-          raise 'forty-two' 
+          cmd.call(ps)
         rescue Exception => e
           Marshal.dump(e, ps.last)
           ps.last.flush
+        ensure
+          ps.last.close unless ps.last.closed?
         end
-        ps.last.close unless (ps.last.closed?)
+
         exit!
       }
     ensure
       $VERBOSE = verbose
     end
 
-    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+    [ pw.first, pr.last, pe.last, ps.last ].each { |fd| fd.close }
 
-    begin
-      e = Marshal.load ps.first
-      raise(Exception === e ? e : "unknown failure!")
-    rescue EOFError # If we get an EOF error, then the exec was successful
-      42
-    ensure
-      ps.first.close
-    end
+    Open4.propagate_exception cid, ps.first if exception_propagation_at == :init
 
     pw.last.sync = true
 
-    pi = [pw.last, pr.first, pe.first]
+    pi = [ pw.last, pr.first, pe.first ]
+
+    begin
+      return [cid, *pi] unless b
 
-    if b 
       begin
-        b[cid, *pi]
-        Process.waitpid2(cid).last
+        b.call(cid, *pi)
       ensure
-        pi.each{|fd| fd.close unless fd.closed?}
+        pi.each { |fd| fd.close unless fd.closed? }
       end
-    else
-      [cid, pw.last, pr.first, pe.first]
+
+      Open4.propagate_exception cid, ps.first if exception_propagation_at == :block
+
+      Process.waitpid2(cid).last
+    ensure
+      ps.first.close unless ps.first.closed?
     end
   end
-  alias open4 popen4
-  module_function :popen4
-  module_function :open4
+
+  def self.propagate_exception(cid, ps_read)
+    e = Marshal.load ps_read
+    raise Exception === e ? e : "unknown failure!"
+  rescue EOFError
+    # Child process did not raise exception.
+  rescue
+    # Child process raised exception; wait it in order to avoid a zombie.
+    Process.waitpid2 cid
+    raise
+  ensure
+    ps_read.close
+  end
 
   class SpawnError < Error
     attr 'cmd'

data/open4.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "open4"
-  spec.version = "1.1.0"
+  spec.version = "1.2.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "open4"
   spec.description = "description: open4 kicks the ass"
@@ -12,19 +12,25 @@ Gem::Specification::new do |spec|
 ["LICENSE",
  "README",
  "README.erb",
- "Rakefile",
  "lib",
  "lib/open4.rb",
  "open4.gemspec",
+ "rakefile",
  "samples",
  "samples/bg.rb",
  "samples/block.rb",
  "samples/exception.rb",
  "samples/jesse-caldwell.rb",
+ "samples/pfork4.rb",
  "samples/simple.rb",
  "samples/spawn.rb",
  "samples/stdin_timeout.rb",
  "samples/timeout.rb",
+ "test",
+ "test/pfork4_test.rb",
+ "test/popen4_test.rb",
+ "test/support",
+ "test/support/test_case.rb",
  "white_box",
  "white_box/leak.rb"]
 

data/{Rakefile → rakefile}

@@ -9,19 +9,8 @@ task :default do
 end
 
 task :test do
-  run_tests!
-end
-
-namespace :test do
-  task(:unit){ run_tests!(:unit) }
-  task(:functional){ run_tests!(:functional) }
-  task(:integration){ run_tests!(:integration) }
-end
-
-def run_tests!(which = nil)
-  which ||= '**'
   test_dir = File.join(This.dir, "test")
-  test_glob ||= File.join(test_dir, "#{ which }/**_test.rb")
+  test_glob ||= File.join(test_dir, "/**_test.rb")
   test_rbs = Dir.glob(test_glob).sort
         
   div = ('=' * 119)
@@ -29,7 +18,7 @@ def run_tests!(which = nil)
 
   test_rbs.each_with_index do |test_rb, index|
     testno = index + 1
-    command = "#{ This.ruby } -I ./lib -I ./test/lib #{ test_rb }"
+    command = "#{ This.ruby } -rubygems -I ./lib -I ./test/support #{ test_rb }"
 
     puts
     say(div, :color => :cyan, :bold => true)

data/samples/pfork4.rb

@@ -0,0 +1,24 @@
+require 'open4'
+
+echo = lambda do
+  $stdout.write $stdin.read
+  raise 'finish implementing me'
+end
+
+org_message = "hello, world!"
+got_message = nil
+exception   = nil
+
+begin
+  Open4.pfork4(echo) do |cid, stdin, stdout, stderr|
+    stdin.write org_message
+    stdin.close
+    got_message = stdout.read
+  end
+rescue RuntimeError => e
+  exception = e.to_s
+end
+
+puts "org_message: #{org_message}"
+puts "got_message: #{got_message}"
+puts "exception  : #{exception}"

data/test/pfork4_test.rb

@@ -0,0 +1,150 @@
+require 'test_case'
+
+module Open4
+
+class PFork4Test < TestCase
+  def test_fun_successful_return
+    fun = lambda { 'lucky me' }
+    cid, _ = pfork4 fun
+    assert_equal 0, wait_status(cid)
+  end
+
+  def test_fun_force_exit
+    exit_code = 43
+    fun = lambda { exit! exit_code }
+    cid, _ = pfork4 fun
+    assert_equal exit_code, wait_status(cid)
+  end
+
+  def test_fun_normal_exit
+    exit_code = 43
+    fun = lambda { exit exit_code }
+    cid, _ = pfork4 fun
+    assert_equal exit_code, wait_status(cid)
+  end
+
+  def test_fun_does_not_propagate_exception_without_block
+    fun = lambda { raise MyError }
+    cid, _ = pfork4 fun
+    refute_equal 0, wait_status(cid)
+  end
+
+  def test_fun_propagate_exception_with_block
+    fun = lambda { raise MyError }
+    assert_raises(MyError) { pfork4(fun) {} }
+  end
+
+  def test_fun_propagate_exception_with_block_avoids_zombie_child_process
+    fun = lambda { raise MyError }
+    assert_raises(MyError) { pfork4(fun) {} }
+    assert_empty Process.waitall
+  end
+
+  def test_call_block_upon_exception
+    fun = lambda { raise MyError }
+    block_called = false
+    assert_raises(MyError) { pfork4(fun) { block_called = true } }
+    assert_equal true, block_called
+  end
+
+  def test_passes_child_pid_to_block
+    fun = lambda { $stdout.write Process.pid }
+    cid_in_block = nil
+    cid_in_fun = nil
+    status = pfork4(fun) do |cid, _, stdout, _|
+      cid_in_block = cid
+      cid_in_fun = stdout.read.to_i
+    end
+    assert_equal cid_in_fun, cid_in_block
+  end
+
+  def test_io_pipes_without_block
+    via_msg = 'foo'
+    err_msg = 'bar'
+    fun = lambda do
+      $stdout.write $stdin.read
+      $stderr.write err_msg
+    end
+    out_actual, err_actual = nil, nil
+    cid, stdin, stdout, stderr = pfork4 fun
+    stdin.write via_msg
+    stdin.close
+    out_actual = stdout.read
+    err_actual = stderr.read
+    assert_equal via_msg, out_actual
+    assert_equal err_msg, err_actual
+    assert_equal 0, wait_status(cid)
+  end
+
+  def test_io_pipes_with_block
+    via_msg = 'foo'
+    err_msg = 'bar'
+    fun = lambda do
+      $stdout.write $stdin.read
+      $stderr.write err_msg
+    end
+    out_actual, err_actual = nil, nil
+    status = pfork4(fun) do |_, stdin, stdout, stderr|
+      stdin.write via_msg
+      stdin.close
+      out_actual = stdout.read
+      err_actual = stderr.read
+    end
+    assert_equal via_msg, out_actual
+    assert_equal err_msg, err_actual
+    assert_equal 0, status.exitstatus
+  end
+
+  def test_exec_in_fun
+    via_msg = 'foo'
+    fun = lambda { exec %{ruby -e "print '#{via_msg}'"} }
+    out_actual = nil
+    status = pfork4(fun) do |_, stdin, stdout, _|
+      stdin.close
+      out_actual = stdout.read
+    end
+    assert_equal via_msg, out_actual
+    assert_equal 0, status.exitstatus
+  end
+
+  def test_io_pipes_and_then_exception_propagation_with_block
+    via_msg = 'foo'
+    err_msg = 'bar'
+    fun = lambda do
+      $stdout.write $stdin.read
+      $stderr.write err_msg
+      raise MyError
+    end
+    out_actual, err_actual = nil, nil
+    assert_raises(MyError) do
+      pfork4(fun) do |_, stdin, stdout, stderr|
+        stdin.write via_msg
+        stdin.close
+        out_actual = stdout.read
+        err_actual = stderr.read
+      end
+    end
+    assert_equal via_msg, out_actual
+    assert_equal err_msg, err_actual
+  end
+
+  def test_blocked_on_io_read_and_exception_propagation_with_block
+    fun = lambda do
+      $stdin.read
+      raise MyError
+    end
+    out_actual, err_actual = nil, nil
+    assert_raises(MyError) do
+      pfork4(fun) do |_, stdin, stdout, stderr|
+        stdin.write 'foo'
+        stdin.close
+        out_actual = stdout.read
+        err_actual = stderr.read
+      end
+    end
+    assert_equal '', out_actual
+    assert_equal '', err_actual
+  end
+end
+
+end

data/test/popen4_test.rb

@@ -0,0 +1,82 @@
+require 'test_case'
+
+module Open4
+
+class POpen4Test < TestCase
+  UNKNOWN_CMD = 'asdfadsfjlkkk'
+  UNKNOWN_CMD_ERRORS = [Errno::ENOENT, Errno::EINVAL]
+
+  def test_unknown_command_propagates_exception
+    err = assert_raises(*UNKNOWN_CMD_ERRORS) { popen4 UNKNOWN_CMD }
+    assert_match /#{UNKNOWN_CMD}/, err.to_s if on_mri?
+  end
+
+  def test_exception_propagation_avoids_zombie_child_process
+    assert_raises(*UNKNOWN_CMD_ERRORS) { popen4 UNKNOWN_CMD }
+    assert_empty Process.waitall
+  end
+
+  def test_exit_failure
+    code = 43
+    cid, _ = popen4 %{ruby -e "exit #{43}"}
+    assert_equal code, wait_status(cid)
+  end
+
+  def test_exit_success
+    cid, _ = popen4 %{ruby -e "exit"}
+    assert_equal 0, wait_status(cid)
+  end
+
+  def test_passes_child_pid_to_block
+    cmd = %{ruby -e "STDOUT.print Process.pid"}
+    cid_in_block = nil
+    cid_in_fun = nil
+    status = popen4(cmd) do |cid, _, stdout, _|
+      cid_in_block = cid
+      cid_in_fun = stdout.read.to_i
+    end
+    assert_equal cid_in_fun, cid_in_block
+  end
+
+  def test_io_pipes_without_block
+    via_msg = 'foo'
+    err_msg = 'bar'
+    cmd = <<-END
+ruby -e "
+  STDOUT.write STDIN.read
+  STDERR.write '#{err_msg}'
+"
+    END
+    cid, stdin, stdout, stderr = popen4 cmd
+    stdin.write via_msg
+    stdin.close
+    out_actual = stdout.read
+    err_actual = stderr.read
+    assert_equal via_msg, out_actual
+    assert_equal err_msg, err_actual
+    assert_equal 0, wait_status(cid)
+  end
+
+  def test_io_pipes_with_block
+    via_msg = 'foo'
+    err_msg = 'bar'
+    out_actual, err_actual = nil
+    cmd = <<-END
+ruby -e "
+  STDOUT.write STDIN.read
+  STDERR.write '#{err_msg}'
+"
+    END
+    status = popen4(cmd) do |_, stdin, stdout, stderr|
+      stdin.write via_msg
+      stdin.close
+      out_actual = stdout.read
+      err_actual = stderr.read
+    end
+    assert_equal via_msg, out_actual
+    assert_equal err_msg, err_actual
+    assert_equal 0, status.exitstatus
+  end
+end
+
+end

data/test/support/test_case.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'minitest/autorun'
+require 'open4'
+require 'rbconfig'
+
+module Open4
+  class TestCase < MiniTest::Unit::TestCase
+    include Open4
+
+    # Custom exception class for tests so we don't shadow possible
+    # programming errors.
+    class MyError < RuntimeError; end
+
+    def on_mri?
+      ::Config::CONFIG['ruby_install_name'] == 'ruby'
+    end
+
+    def wait_status(cid)
+      Process.waitpid2(cid).last.exitstatus
+    end
+  end
+end

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: open4
 version: !ruby/object:Gem::Version 
+  hash: 31
   prerelease: 
-  version: 1.1.0
+  segments: 
+  - 1
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-24 00:00:00 Z
+date: 2011-10-05 00:00:00 Z
 dependencies: []
 
 description: "description: open4 kicks the ass"
@@ -25,21 +30,27 @@ files:
 - LICENSE
 - README
 - README.erb
-- Rakefile
 - lib/open4.rb
 - open4.gemspec
+- rakefile
 - samples/bg.rb
 - samples/block.rb
 - samples/exception.rb
 - samples/jesse-caldwell.rb
+- samples/pfork4.rb
 - samples/simple.rb
 - samples/spawn.rb
 - samples/stdin_timeout.rb
 - samples/timeout.rb
+- test/pfork4_test.rb
+- test/popen4_test.rb
+- test/support/test_case.rb
 - white_box/leak.rb
 homepage: https://github.com/ahoward/open4
 licenses: []
 
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
@@ -50,19 +61,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: codeforpeople
-rubygems_version: 1.7.2
+rubygems_version: 1.8.10
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: open4
 test_files: []