childprocess 0.2.3 → 0.2.4

data/.travis.yml

@@ -1,4 +1,5 @@
 rvm:
   - 1.8.7
   - 1.9.2
-  - 1.9.3
+  - 1.9.3
+  - jruby

data/README.md

@@ -14,18 +14,30 @@ Usage
 ```ruby
 process = ChildProcess.build("ruby", "-e", "sleep")
 
-# inherit stdout/stderr from parent
+# inherit stdout/stderr from parent...
 process.io.inherit!
 
-# or pass an IO
+# ...or pass an IO
 process.io.stdout = Tempfile.new("child-output")
 
+# start the process
+
 process.start
 
+# check process status
 process.alive?    #=> true
 process.exited?   #=> false
 
-process.stop
+# wait indefinitely for process to exit...
+process.wait
+process.exited?   #=> true
+
+# ...or poll for exit + force quit
+begin
+  process.poll_for_exit(10)
+rescue ChildProcess::TimeoutError
+  process.stop # tries increasingly harsher methods to kill the process.
+end
 ```
 
 The object returned from ChildProcess.build will implement ChildProcess::AbstractProcess.

data/lib/childprocess/abstract_process.rb

@@ -44,6 +44,10 @@ module ChildProcess
       raise SubclassResponsibility, "io"
     end
 
+    #
+    # @return [Fixnum] the pid of the process after it has started
+    #
+
     def pid
       raise SubclassResponsibility, "pid"
     end
@@ -71,6 +75,16 @@ module ChildProcess
       raise SubclassResponsibility, "stop"
     end
 
+    #
+    # Block until the process has been terminated.
+    #
+    # @return [Fixnum] The exit status of the process
+    #
+
+    def wait
+      raise SubclassResponsibility, "wait"
+    end
+
     #
     # Did the process exit?
     #

data/lib/childprocess/errors.rb

@@ -3,4 +3,5 @@ module ChildProcess
   class TimeoutError < StandardError; end
   class SubclassResponsibility < StandardError; end
   class InvalidEnvironmentVariableName < StandardError; end
+  class LaunchError < StandardError; end
 end

data/lib/childprocess/jruby.rb

@@ -4,6 +4,6 @@ module ChildProcess
 end
 
 require "java"
-require "childprocess/jruby/redirector"
+require "childprocess/jruby/pump"
 require "childprocess/jruby/io"
 require "childprocess/jruby/process"

data/lib/childprocess/jruby/process.rb

@@ -3,6 +3,12 @@ require "java"
 module ChildProcess
   module JRuby
     class Process < AbstractProcess
+      def initialize(args)
+        super(args)
+
+        @pumps = []
+      end
+
       def io
         @io ||= JRuby::IO.new
       end
@@ -12,6 +18,8 @@ module ChildProcess
 
         assert_started
         @exit_code = @process.exitValue
+        stop_pumps
+
         true
       rescue java.lang.IllegalThreadStateException
         false
@@ -23,8 +31,13 @@ module ChildProcess
         assert_started
 
         @process.destroy
-        @process.waitFor # no way to actually use the timeout here..
+        wait # no way to actually use the timeout here..
+      end
+
+      def wait
+        @process.waitFor
 
+        stop_pumps
         @exit_code = @process.exitValue
       end
 
@@ -37,7 +50,7 @@ module ChildProcess
       #
       def pid
         if @process.getClass.getName != "java.lang.UNIXProcess"
-          raise NotImplementedError.new("pid is not supported by JRuby child processes on Windows")
+          raise NotImplementedError, "pid is only supported by JRuby child processes on Unix"
         end
 
         # About the best way we can do this is with a nasty reflection-based impl
@@ -56,21 +69,29 @@ module ChildProcess
         pb.directory java.io.File.new(Dir.pwd)
         set_env pb.environment
 
-        @process = pb.start
+        begin
+          @process = pb.start
+        rescue java.io.IOException => ex
+          raise LaunchError, ex.message
+        end
+
         setup_io
       end
 
       def setup_io
         if @io
-          redirect @process.getErrorStream, @io.stderr
-          redirect @process.getInputStream, @io.stdout
+          @pumps << redirect(@process.getErrorStream, @io.stderr)
+          @pumps << redirect(@process.getInputStream, @io.stdout)
         else
           @process.getErrorStream.close
           @process.getInputStream.close
         end
 
         if duplex?
-          io._stdin = @process.getOutputStream.to_io
+          stdin = @process.getOutputStream.to_io
+          stdin.sync = true
+
+          io._stdin = stdin
         else
           @process.getOutputStream.close
         end
@@ -82,8 +103,11 @@ module ChildProcess
           return
         end
 
-        output = output.to_outputstream
-        Thread.new { Redirector.new(input, output).run }
+        Pump.new(input, output.to_outputstream).run
+      end
+
+      def stop_pumps
+        @pumps.each { |pump| pump.stop }
       end
 
       def set_env(env)

data/lib/childprocess/jruby/pump.rb

@@ -0,0 +1,51 @@
+module ChildProcess
+  module JRuby
+    class Pump
+      BUFFER_SIZE = 2048
+
+      def initialize(input, output)
+        @input  = input
+        @output = output
+        @stop   = false
+      end
+
+      def stop
+        @stop = true
+        @thread && @thread.join
+      end
+
+      def run
+        @thread = Thread.new { pump }
+
+        self
+      end
+
+      private
+
+      def pump
+        buffer = Java.byte[BUFFER_SIZE].new
+
+        until @stop
+          read, avail = 0, 0
+
+          while read != -1
+            avail = [@input.available, 1].max
+            read = @input.read(buffer, 0, avail)
+
+            if read > 0
+              @output.write(buffer, 0, read)
+              @output.flush
+            end
+          end
+
+          sleep 0.1
+        end
+
+        @output.flush
+      rescue java.io.IOException => ex
+        $stderr.puts ex.message, ex.backtrace if $DEBUG
+      end
+
+    end # Pump
+  end # JRuby
+end # ChildProcess

data/lib/childprocess/unix/process.rb

@@ -1,9 +1,6 @@
 module ChildProcess
   module Unix
     class Process < AbstractProcess
-      #
-      # @return [Fixnum] the pid of the process after it has started
-      #
       attr_reader :pid
 
       def io
@@ -28,12 +25,6 @@ module ChildProcess
         true
       end
 
-      #
-      # Did the process exit?
-      #
-      # @return [Boolean]
-      #
-
       def exited?
         return true if @exit_code
 
@@ -49,12 +40,14 @@ module ChildProcess
         !!pid
       end
 
-      private
-
       def wait
-        @exit_code = ::Process.waitpid @pid
+        pid, status = ::Process.waitpid2 @pid
+
+        @exit_code = status.exitstatus || status.termsig
       end
 
+      private
+
       def send_term
         send_signal 'TERM'
       end
@@ -76,11 +69,16 @@ module ChildProcess
           stderr = @io.stderr
         end
 
+        # pipe used to detect exec() failure
+        exec_r, exec_w = ::IO.pipe
+        ChildProcess.close_on_exec exec_w
+
         if duplex?
           reader, writer = ::IO.pipe
         end
 
         @pid = fork {
+          exec_r.close
           set_env
 
           STDOUT.reopen(stdout || "/dev/null")
@@ -91,14 +89,25 @@ module ChildProcess
             writer.close
           end
 
-          exec(*@args)
+          begin
+            exec(*@args)
+          rescue SystemCallError => ex
+            exec_w << ex.message
+          end
         }
 
+        exec_w.close
+
         if duplex?
           io._stdin = writer
           reader.close
         end
 
+        # if we don't eventually get EOF, exec() failed
+        unless exec_r.eof?
+          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
+        end
+
         ::Process.detach(@pid) if detach?
       end
 

data/lib/childprocess/version.rb

@@ -1,3 +1,3 @@
 module ChildProcess
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/lib/childprocess/windows/functions.rb

@@ -34,6 +34,9 @@ module ChildProcess
           read_pipe = read_pipe_ptr.read_pointer
           write_pipe = write_pipe_ptr.read_pointer
 
+          ok = set_handle_information(write_pipe.address, HANDLE_FLAG_INHERIT, 0)
+          ok or raise Error, last_error_message
+
           si[:hStdInput] = read_pipe
         end
 
@@ -50,7 +53,7 @@ module ChildProcess
           pi        # process info
         )
 
-        ok or raise Error, last_error_message
+        ok or raise LaunchError, last_error_message
 
         close_handle pi[:hProcess]
         close_handle pi[:hThread]

data/lib/childprocess/windows/process.rb

@@ -1,9 +1,7 @@
 module ChildProcess
   module Windows
     class Process < AbstractProcess
-      #
-      # @return [Fixnum] the pid of the process after it has started
-      #
+
       attr_reader :pid
 
       def io
@@ -22,6 +20,11 @@ module ChildProcess
         @handle.close
       end
 
+      def wait
+        @handle.wait
+        @exit_code = @handle.exit_code
+      end
+
       def exited?
         return true if @exit_code
         assert_started

data/spec/childprocess_spec.rb

@@ -13,20 +13,32 @@ describe ChildProcess do
     process.should be_started
   end
 
+  it "raises ChildProcess::LaunchError if the process can't be started" do
+    lambda { invalid_process.start }.should raise_error(ChildProcess::LaunchError)
+  end
+
   it "knows if the process crashed" do
     process = exit_with(1).start
-    process.poll_for_exit(EXIT_TIMEOUT)
+    process.wait
 
     process.should be_crashed
   end
 
   it "knows if the process didn't crash" do
     process = exit_with(0).start
-    process.poll_for_exit(EXIT_TIMEOUT)
+    process.wait
 
     process.should_not be_crashed
   end
 
+  it "can wait for a process to finish" do
+    process = exit_with(0).start
+    return_value = process.wait
+
+    process.should_not be_alive
+    return_value.should == 0
+  end
+
   it "escalates if TERM is ignored" do
     process = ignored('TERM').start
     process.stop
@@ -42,7 +54,7 @@ describe ChildProcess do
     Tempfile.open("env-spec") do |file|
       with_env('INHERITED' => 'yes') do
         process = write_env(file.path).start
-        process.poll_for_exit(EXIT_TIMEOUT)
+        process.wait
       end
 
       file.rewind
@@ -59,7 +71,7 @@ describe ChildProcess do
 
       ENV['CHILD_ONLY'].should be_nil
 
-      process.poll_for_exit(EXIT_TIMEOUT)
+      process.wait
       file.rewind
 
       child_env = eval(file.read)
@@ -74,7 +86,8 @@ describe ChildProcess do
         process.environment['CHILD_ONLY'] = 'yes'
 
         process.start
-        process.poll_for_exit(EXIT_TIMEOUT)
+        process.wait
+
         file.rewind
         child_env = eval(file.read)
 
@@ -89,7 +102,7 @@ describe ChildProcess do
 
     Tempfile.open("argv-spec") do |file|
       process = write_argv(file.path, *args).start
-      process.poll_for_exit(EXIT_TIMEOUT)
+      process.wait
 
       file.rewind
       file.read.should == args.inspect
@@ -119,7 +132,7 @@ describe ChildProcess do
 
       process.start
       process.io.stdin.should be_nil
-      process.poll_for_exit(EXIT_TIMEOUT)
+      process.wait
 
       out.rewind
       err.rewind
@@ -133,11 +146,10 @@ describe ChildProcess do
   end
 
   it "can write to stdin if duplex = true" do
-    process = ruby(<<-CODE)
-      puts(STDIN.gets.chomp)
-    CODE
+    process = cat
 
     out = Tempfile.new("duplex")
+    out.sync = true
 
     begin
       process.io.stdout = out
@@ -146,7 +158,7 @@ describe ChildProcess do
 
       process.start
       process.io.stdin.puts "hello world"
-      process.io.stdin.close # JRuby seems to need this
+      process.io.stdin.close
 
       process.poll_for_exit(EXIT_TIMEOUT)
 
@@ -177,7 +189,7 @@ describe ChildProcess do
       process.io.stdout = process.io.stderr = file
 
       process.start
-      process.poll_for_exit(EXIT_TIMEOUT)
+      process.wait
 
       file.rewind
       file.read.should == Dir.pwd
@@ -189,11 +201,16 @@ describe ChildProcess do
 
     Tempfile.open("argv-spec") do |file|
       process = write_argv(file.path, *args).start
-      process.poll_for_exit(EXIT_TIMEOUT)
+      process.wait
 
       file.rewind
       file.read.should == args.inspect
     end
   end
 
+  it "times out when polling for exit" do
+    process = sleeping_ruby.start
+    lambda { process.poll_for_exit(0.1) }.should raise_error(ChildProcess::TimeoutError)
+  end
+
 end

data/spec/pid_behavior.rb

@@ -4,7 +4,7 @@ shared_examples_for "a platform that provides the child's pid" do
   it "knows the child's pid" do
     Tempfile.open("pid-spec") do |file|
       process = write_pid(file.path).start
-      process.poll_for_exit(10)
+      process.wait
       file.rewind
 
       process.pid.should == file.read.chomp.to_i

data/spec/spec_helper.rb

@@ -18,6 +18,10 @@ module ChildProcessSpecHelper
     ruby_process("-e", "sleep")
   end
 
+  def invalid_process
+    @process = ChildProcess.build("unlikely-to-exist")
+  end
+
   def ignored(signal)
     code = <<-RUBY
       trap(#{signal.inspect}, "IGNORE")
@@ -90,6 +94,19 @@ module ChildProcessSpecHelper
     raise last_error unless ok
   end
 
+  def cat
+    if ChildProcess.os == :windows
+      ruby(<<-CODE)
+            STDIN.sync  = true
+            STDOUT.sync = true
+
+            puts STDIN.read
+          CODE
+    else
+      ChildProcess.build("cat")
+    end
+  end
+
   def ruby(code)
     ruby_process(tmp_script(code))
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: childprocess
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - Jari Bakken
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-27 00:00:00 Z
+date: 2011-12-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -105,7 +105,7 @@ files:
 - lib/childprocess/jruby.rb
 - lib/childprocess/jruby/io.rb
 - lib/childprocess/jruby/process.rb
-- lib/childprocess/jruby/redirector.rb
+- lib/childprocess/jruby/pump.rb
 - lib/childprocess/unix.rb
 - lib/childprocess/unix/io.rb
 - lib/childprocess/unix/process.rb

data/lib/childprocess/jruby/redirector.rb

@@ -1,29 +0,0 @@
-module ChildProcess
-  module JRuby
-    class Redirector
-      BUFFER_SIZE = 2048
-
-      def initialize(input, output)
-        @input = input
-        @output = output
-        @buffer = Java.byte[BUFFER_SIZE].new
-      end
-
-      def run
-        read, avail = 0, 0
-
-        while(read != -1)
-          avail = [@input.available, 1].max
-          read  = @input.read(@buffer, 0, avail)
-
-          if read > 0
-            @output.write(@buffer, 0, read)
-          end
-        end
-      rescue java.io.IOException => ex
-        $stderr.puts ex.message, ex.backtrace if $DEBUG
-      end
-
-    end # Redirector
-  end # JRuby
-end # ChildProcess