open4 0.2.0 → 0.3.0

data/README

@@ -3,14 +3,15 @@ URIS
   http://rubyforge.org/frs/?group_id=1024
   http://www.codeforpeople.com/lib/ruby/
 
-
 SYNOPSIS
 
   open child process with handles on pid, stdin, stdout, and stderr
 
-
 HISTORY
 
+  0.3.0 :
+    - bug fix from jordan breeding.  general clean up.  added spawn method.
+
   0.2.0 :
     - added exception marshaled from child -> parent when exec fails.  thanks
       to jordan breeding for a patch (yay!) and paul brannan for this most
@@ -22,17 +23,17 @@ HISTORY
   0.0.0 :
     - initial version
 
-
 INSTALL
 
   ~> gem install open4
 
-
 SAMPLES
 
-  simple usage:
+  ----------------------------------------------------------------------------
+  simple usage
+  ----------------------------------------------------------------------------
 
-    jib:~/eg/ruby/open4/open4-0.2.0 > cat sample/simple.rb
+    harp: > cat sample/simple.rb
     require "open4"
 
     pid, stdin, stdout, stderr = Open4::popen4 "sh"
@@ -50,7 +51,7 @@ SAMPLES
     puts "exitstatus : #{ status.exitstatus }"
 
 
-    jib:~/eg/ruby/open4/open4-0.2.0 > ruby sample/simple.rb
+    harp: > ruby sample/simple.rb
     pid        : 17273
     stdout     : 42.out
     stderr     : 42.err
@@ -58,10 +59,11 @@ SAMPLES
     exitstatus : 0
 
 
-  block form - child process is automatically waited for:
-
+  ----------------------------------------------------------------------------
+  in block form - the child process is automatically waited for
+  ----------------------------------------------------------------------------
 
-    jib:~/eg/ruby/open4/open4-0.2.0 > cat sample/block.rb
+    harp: > cat sample/block.rb
     require 'open4'
 
     status =
@@ -79,32 +81,65 @@ SAMPLES
         puts "exitstatus : #{ status.exitstatus }"
 
 
-    jib:~/eg/ruby/open4/open4-0.2.0 > ruby sample/block.rb
+    harp: > ruby sample/block.rb
     pid        : 17295
     stdout     : 42.out
     stderr     : 42.err
     status     : #<Process::Status: pid=17295,exited(0)>
     exitstatus : 0
 
+  ----------------------------------------------------------------------------
+  exceptions are marshaled from child to parent if fork/exec fails
+  ----------------------------------------------------------------------------
 
-  exceptions are marshaled from child to parent if fork/exec fails:
-
-
-    jib:~/eg/ruby/open4/open4-0.2.0 > cat sample/exception.rb
+    harp: > cat sample/exception.rb
     require "open4"
     Open4::popen4 "noexist"
 
 
-    jib:~/eg/ruby/open4/open4-0.2.0 > ruby sample/exception.rb
+    harp: > ruby sample/exception.rb
     /dmsp/reference/ruby-1.8.1//lib/ruby/site_ruby/open4.rb:100:in `popen4': No such file or directory - noexist (Errno::ENOENT)
             from sample/exception.rb:3
 
+  ----------------------------------------------------------------------------
+  the spawn method provides and even more convenient method of running a
+  process, allowing any object that supports 'each', 'read', or 'to_s' to be
+  given as stdin and any objects that support '<<' to be given as
+  stdout/stderr.  an exception is thrown if the exec'd cmd fails (nonzero
+  exitstatus) unless the option 'raise'=>false is given
+  ----------------------------------------------------------------------------
+  
+    harp: > cat sample/spawn.rb
+    require 'open4'
+    include Open4
+
+    cat = '  ruby -e"  ARGF.each{|line| STDOUT << line}  "  '
+
+    stdout, stderr = '', ''
+    status = spawn cat, 'stdin' => '42', 'stdout' => stdout, 'stderr' => stderr
+    p status
+    p stdout
+    p stderr
+
+    stdout, stderr = '', ''
+    status = spawn cat, 0=>'42', 1=>stdout, 2=>stderr
+    p status
+    p stdout
+    p stderr
+
+
+    harp: > RUBYLIB=lib ruby sample/spawn.rb
+    0
+    "42"
+    ""
+    0
+    "42"
+    ""
 
 AUTHOR
 
   ara.t.howard@noaa.gov
 
-
 LICENSE
 
   ruby's

data/lib/open4-0.3.0.rb

@@ -0,0 +1,133 @@
+require 'fcntl'
+
+module Open4
+#--{{{
+  def self.version() '0.3.0' end
+
+  def popen4(*cmd)
+#--{{{
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      cid = fork {
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        begin
+          exec(*cmd)
+          raise "exec failed!"
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
+        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}
+
+    begin
+      e = Marshal.load ps.first
+      if Exception === e
+        raise e
+      else
+        raise "unknown failure"
+      end
+    rescue EOFError # If we get an EOF error, then the exec was successful
+      42
+    end
+
+    pw.last.sync = true
+
+    pi = [pw.last, pr.first, pe.first]
+
+    if defined? yield
+      begin
+        yield(cid, *pi)
+        Process.waitpid2(cid).last
+      ensure
+        pi.each{|fd| fd.close unless fd.closed?}
+      end
+    else
+      [cid, pw.last, pr.first, pe.first]
+    end
+#--}}}
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  def spawn cmd, opts = {} 
+#--{{{
+    getopt = lambda do |*args|
+      keys, default, ignored = args
+      catch('opt') do
+        [keys].flatten.each do |key|
+          [key, key.to_s, key.to_s.intern].each do |key|
+            throw 'opt', opts[key] if opts.has_key?(key)
+          end
+        end
+        default
+      end
+    end
+
+    dont_raise = getopt[ 'quiet', !getopt['raise', true] ]
+    exitstatus = getopt[ %w( exitstatus exit_status status ), 0 ]
+    stdin = getopt[ ['stdin', 'in', '0', 0] ]
+    stdout = getopt[ ['stdout', 'out', '1', 1] ]
+    stderr = getopt[ ['stderr', 'err', '2', 2] ]
+
+    started = false
+
+    status =
+      begin
+        popen4(cmd) do |c, i, o, e|
+          started = true
+
+          if stdin.respond_to? :each
+            stdin.each{|buf| i << buf}
+          elsif stdin.respond_to? :read
+            i << stdin.read
+          else
+            i << stdin.to_s
+          end
+
+          i.close
+
+          ot = Thread.new(o){ o.each{|buf| stdout << buf if stdout} }
+          et = Thread.new(e){ e.each{|buf| stderr << buf if stderr} }
+
+          ot.join
+          et.join
+        end
+      rescue
+        raise unless(not started and dont_raise)
+      end
+
+    raise "cmd <#{ cmd }> failed with <#{ status }>" unless
+      ((status == exitstatus) or dont_raise)
+
+    status
+#--}}}
+  end
+  module_function :spawn
+#--}}}
+end

data/lib/open4.rb

@@ -1,131 +1,133 @@
-# vim: ts=2 sts=2 et
-# stolen directly from Open3::open3.rb!
-#
-# open4.rb: Spawn a program like popen, but with stderr, and pid, too. You might
-# also want to use this if you want to bypass the shell. (By passing multiple
-# args, which IO#popen does not allow)
-#
-# Usage:
-#       require "open4"
-#
-#      pid, stdin, stdout, stderr = Open4.popen4('nroff -man')
-#  or
-#       include Open4
-#      pid, stdin, stdout, stderr = popen4('nroff -man')
-
 require 'fcntl'
 
 module Open4
 #--{{{
-
-if false
-  PROCESSES = Hash.new
-
-  orig_sigchld_handler = trap("CLD") do |*args|
-    begin
-      PROCESSES.each do |pid, foo|
-        if (Process.waitpid2(pid, Process::WNOHANG) == pid)
-          PROCESSES.delete(pid)
-        end
-      end
-    rescue Errno::ECHILD
-      nil
-    end
-    orig_sigchld_handler.call(*args) if (not (orig_sigchld_handler.nil?))
-  end
-end
-
-  #
-  # [ pid, stdin, stdout, stderr ] = popen4 command
-  #
+  def self.version() '0.3.0' end
 
   def popen4(*cmd)
 #--{{{
-
-    pw = IO::pipe # pipe[1] for read, pipe[0] for write
-    pr = IO::pipe # pipe[0] for read, pipe[1] for write
-    pe = IO::pipe # pipe[0] for read, pipe[1] for write
-    ps = IO::pipe # pipe[0] for read, pipe[1] for write
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
 
     verbose = $VERBOSE
     begin
-      $VERBOSE = nil # shut up warning about forking in threads, world writable
-                     # dirs, etc
-
-      ps[1].fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      $VERBOSE = nil
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
       cid = fork {
-        # child
-        pw[1].close
-        STDIN.reopen(pw[0])
-        pw[0].close
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
 
-        pr[0].close
-        STDOUT.reopen(pr[1])
-        pr[1].close
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
 
-        pe[0].close
-        STDERR.reopen(pe[1])
-        pe[1].close
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
 
-        STDOUT.sync = true
-        STDERR.sync = true
+        STDOUT.sync = STDERR.sync = true
 
         begin
           exec(*cmd)
-          raise "exec returned!"
-        rescue Exception
-          Marshal.dump($!, ps[1])
-          ps[1].flush
+          raise "exec failed!"
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
         end
-        ps[1].close unless (ps[1].closed?)
+        ps.last.close unless (ps.last.closed?)
         exit!
       }
     ensure
       $VERBOSE = verbose
     end
 
-    pw[0].close
-    pr[1].close
-    pe[1].close
-    ps[1].close
+    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
 
-    exc = nil
     begin
-      exc = Marshal.load(ps[0])
+      e = Marshal.load ps.first
+      if Exception === e
+        raise e
+      else
+        raise "unknown failure"
+      end
     rescue EOFError # If we get an EOF error, then the exec was successful
+      42
     end
 
-    if (not (exc.nil?)) then
-      raise exc
-    end
+    pw.last.sync = true
 
-    # PROCESSES[cid] = true
+    pi = [pw.last, pr.first, pe.first]
 
-    pi = [pw[1], pr[0], pe[0]]
-    pw[1].sync = true
     if defined? yield
       begin
         yield(cid, *pi)
-        return((Process.waitpid2(cid, 1)).last)
+        Process.waitpid2(cid).last
       ensure
-        pi.each{|p| p.close unless p.closed?}
+        pi.each{|fd| fd.close unless fd.closed?}
       end
+    else
+      [cid, pw.last, pr.first, pe.first]
     end
-    [cid, pw[1], pr[0], pe[0]]
 #--}}}
   end
-
   alias open4 popen4
   module_function :popen4
   module_function :open4
 
-#--}}}
-end
+  def spawn cmd, opts = {} 
+#--{{{
+    getopt = lambda do |*args|
+      keys, default, ignored = args
+      catch('opt') do
+        [keys].flatten.each do |key|
+          [key, key.to_s, key.to_s.intern].each do |key|
+            throw 'opt', opts[key] if opts.has_key?(key)
+          end
+        end
+        default
+      end
+    end
+
+    dont_raise = getopt[ 'quiet', !getopt['raise', true] ]
+    exitstatus = getopt[ %w( exitstatus exit_status status ), 0 ]
+    stdin = getopt[ ['stdin', 'in', '0', 0] ]
+    stdout = getopt[ ['stdout', 'out', '1', 1] ]
+    stderr = getopt[ ['stderr', 'err', '2', 2] ]
+
+    started = false
+
+    status =
+      begin
+        popen4(cmd) do |c, i, o, e|
+          started = true
+
+          if stdin.respond_to? :each
+            stdin.each{|buf| i << buf}
+          elsif stdin.respond_to? :read
+            i << stdin.read
+          else
+            i << stdin.to_s
+          end
+
+          i.close
 
-if $0 == __FILE__
-  status = Open4::popen4('sh'){|cid,i,o,e|i.puts 'echo 42';i.close; puts o.read;}
-  p [status]
-  p status.exitstatus
-  p status == 0
+          ot = Thread.new(o){ o.each{|buf| stdout << buf if stdout} }
+          et = Thread.new(e){ e.each{|buf| stderr << buf if stderr} }
+
+          ot.join
+          et.join
+        end
+      rescue
+        raise unless(not started and dont_raise)
+      end
+
+    raise "cmd <#{ cmd }> failed with <#{ status }>" unless
+      ((status == exitstatus) or dont_raise)
+
+    status
+#--}}}
+  end
+  module_function :spawn
+#--}}}
 end

data/sample/spawn.rb

@@ -0,0 +1,16 @@
+require 'open4'
+include Open4
+
+cat = 'ruby -e"  ARGF.each{|line| STDOUT << line}  "'
+
+stdout, stderr = '', ''
+status = spawn cat, 'stdin' => '42', 'stdout' => stdout, 'stderr' => stderr
+p status
+p stdout
+p stderr
+
+stdout, stderr = '', ''
+status = spawn cat, 0=>'42', 1=>stdout, 2=>stderr
+p status
+p stdout
+p stderr

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: open4
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2006-02-13 00:00:00.000000 -07:00
+  version: 0.3.0
+date: 2006-04-19 00:00:00.000000 -06:00
 summary: open4
 require_paths: 
   - lib
@@ -29,18 +29,20 @@ cert_chain:
 authors: 
   - Ara T. Howard
 files: 
-  - lib
-  - install
+  - open4-0.3.0.gem
   - install.rb
-  - README
   - sample
+  - lib
+  - README
+  - build
+  - install
   - gemspec.rb
-  - open4-0.2.0.gem
-  - lib/open4.rb
-  - lib/open4-0.2.0.rb
   - sample/block.rb
   - sample/simple.rb
   - sample/exception.rb
+  - sample/spawn.rb
+  - lib/open4-0.3.0.rb
+  - lib/open4.rb
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []

data/lib/open4-0.2.0.rb

@@ -1,131 +0,0 @@
-# vim: ts=2 sts=2 et
-# stolen directly from Open3::open3.rb!
-#
-# open4.rb: Spawn a program like popen, but with stderr, and pid, too. You might
-# also want to use this if you want to bypass the shell. (By passing multiple
-# args, which IO#popen does not allow)
-#
-# Usage:
-#       require "open4"
-#
-#      pid, stdin, stdout, stderr = Open4.popen4('nroff -man')
-#  or
-#       include Open4
-#      pid, stdin, stdout, stderr = popen4('nroff -man')
-
-require 'fcntl'
-
-module Open4
-#--{{{
-
-if false
-  PROCESSES = Hash.new
-
-  orig_sigchld_handler = trap("CLD") do |*args|
-    begin
-      PROCESSES.each do |pid, foo|
-        if (Process.waitpid2(pid, Process::WNOHANG) == pid)
-          PROCESSES.delete(pid)
-        end
-      end
-    rescue Errno::ECHILD
-      nil
-    end
-    orig_sigchld_handler.call(*args) if (not (orig_sigchld_handler.nil?))
-  end
-end
-
-  #
-  # [ pid, stdin, stdout, stderr ] = popen4 command
-  #
-
-  def popen4(*cmd)
-#--{{{
-
-    pw = IO::pipe # pipe[1] for read, pipe[0] for write
-    pr = IO::pipe # pipe[0] for read, pipe[1] for write
-    pe = IO::pipe # pipe[0] for read, pipe[1] for write
-    ps = IO::pipe # pipe[0] for read, pipe[1] for write
-
-    verbose = $VERBOSE
-    begin
-      $VERBOSE = nil # shut up warning about forking in threads, world writable
-                     # dirs, etc
-
-      ps[1].fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-      cid = fork {
-        # child
-        pw[1].close
-        STDIN.reopen(pw[0])
-        pw[0].close
-
-        pr[0].close
-        STDOUT.reopen(pr[1])
-        pr[1].close
-
-        pe[0].close
-        STDERR.reopen(pe[1])
-        pe[1].close
-
-        STDOUT.sync = true
-        STDERR.sync = true
-
-        begin
-          exec(*cmd)
-          raise "exec returned!"
-        rescue Exception
-          Marshal.dump($!, ps[1])
-          ps[1].flush
-        end
-        ps[1].close unless (ps[1].closed?)
-        exit!
-      }
-    ensure
-      $VERBOSE = verbose
-    end
-
-    pw[0].close
-    pr[1].close
-    pe[1].close
-    ps[1].close
-
-    exc = nil
-    begin
-      exc = Marshal.load(ps[0])
-    rescue EOFError # If we get an EOF error, then the exec was successful
-    end
-
-    if (not (exc.nil?)) then
-      raise exc
-    end
-
-    # PROCESSES[cid] = true
-
-    pi = [pw[1], pr[0], pe[0]]
-    pw[1].sync = true
-    if defined? yield
-      begin
-        yield(cid, *pi)
-        return((Process.waitpid2(cid, 1)).last)
-      ensure
-        pi.each{|p| p.close unless p.closed?}
-      end
-    end
-    [cid, pw[1], pr[0], pe[0]]
-#--}}}
-  end
-
-  alias open4 popen4
-  module_function :popen4
-  module_function :open4
-
-#--}}}
-end
-
-if $0 == __FILE__
-  status = Open4::popen4('sh'){|cid,i,o,e|i.puts 'echo 42';i.close; puts o.read;}
-  p [status]
-  p status.exitstatus
-  p status == 0
-end