childprocess 0.9.0 → 4.1.0

data/lib/childprocess/jruby/process.rb

@@ -1,159 +1,184 @@
-require "java"
-
-module ChildProcess
-  module JRuby
-    class Process < AbstractProcess
-      def initialize(args)
-        super(args)
-
-        @pumps = []
-      end
-
-      def io
-        @io ||= JRuby::IO.new
-      end
-
-      def exited?
-        return true if @exit_code
-
-        assert_started
-        @exit_code = @process.exitValue
-        stop_pumps
-
-        true
-      rescue java.lang.IllegalThreadStateException => ex
-        log(ex.class => ex.message)
-        false
-      ensure
-        log(:exit_code => @exit_code)
-      end
-
-      def stop(timeout = nil)
-        assert_started
-
-        @process.destroy
-        wait # no way to actually use the timeout here..
-      end
-
-      def wait
-        if exited?
-          exit_code
-        else
-          @process.waitFor
-
-          stop_pumps
-          @exit_code = @process.exitValue
-        end
-      end
-
-      #
-      # Only supported in JRuby on a Unix operating system, thanks to limitations
-      # in Java's classes
-      #
-      # @return [Integer] the pid of the process after it has started
-      # @raise [NotImplementedError] when trying to access pid on non-Unix platform
-      #
-      def pid
-        if @process.getClass.getName != "java.lang.UNIXProcess"
-          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
-        # Thanks to Martijn Courteaux
-        # http://stackoverflow.com/questions/2950338/how-can-i-kill-a-linux-process-in-java-with-sigkill-process-destroy-does-sigter/2951193#2951193
-        field = @process.getClass.getDeclaredField("pid")
-        field.accessible = true
-        field.get(@process)
-      end
-
-      private
-
-      def launch_process(&blk)
-        pb = java.lang.ProcessBuilder.new(@args)
-
-        pb.directory java.io.File.new(@cwd || Dir.pwd)
-        set_env pb.environment
-
-        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)
-        else
-          @process.getErrorStream.close
-          @process.getInputStream.close
-        end
-
-        if duplex?
-          io._stdin = create_stdin
-        else
-          @process.getOutputStream.close
-        end
-      end
-
-      def redirect(input, output)
-        if output.nil?
-          input.close
-          return
-        end
-
-        @pumps << Pump.new(input, output.to_outputstream).run
-      end
-
-      def stop_pumps
-        @pumps.each { |pump| pump.stop }
-      end
-
-      def set_env(env)
-        merged = ENV.to_hash
-
-        @environment.each { |k, v| merged[k.to_s] = v }
-
-        merged.each do |k, v|
-          if v
-            env.put(k, v.to_s)
-          elsif env.has_key? k
-            env.remove(k)
-          end
-        end
-
-        removed_keys = env.key_set.to_a - merged.keys
-        removed_keys.each { |k| env.remove(k) }
-      end
-
-      def create_stdin
-        output_stream = @process.getOutputStream
-
-        stdin = output_stream.to_io
-        stdin.sync = true
-        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
-
-        class << stdin
-          # The stream provided is a BufferedeOutputStream, so we
-          # have to flush it to make the bytes flow to the process
-          def __childprocess_flush__
-            @childprocess_java_stream.flush
-          end
-
-          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
-            define_method(m) do |*args|
-              super(*args)
-              self.__childprocess_flush__
-            end
-          end
-        end
-
-        stdin
-      end
-
-    end # Process
-  end # JRuby
-end # ChildProcess
+require "java"
+
+module ChildProcess
+  module JRuby
+    class Process < AbstractProcess
+      def initialize(args)
+        super(args)
+
+        @pumps = []
+      end
+
+      def io
+        @io ||= JRuby::IO.new
+      end
+
+      def exited?
+        return true if @exit_code
+
+        assert_started
+        @exit_code = @process.exitValue
+        stop_pumps
+
+        true
+      rescue java.lang.IllegalThreadStateException => ex
+        log(ex.class => ex.message)
+        false
+      ensure
+        log(:exit_code => @exit_code)
+      end
+
+      def stop(timeout = nil)
+        assert_started
+
+        @process.destroy
+        wait # no way to actually use the timeout here..
+      end
+
+      def wait
+        if exited?
+          exit_code
+        else
+          @process.waitFor
+
+          stop_pumps
+          @exit_code = @process.exitValue
+        end
+      end
+
+      # Implementation of ChildProcess::JRuby::Process#pid depends heavily on
+      # what Java SDK is being used; here, we look it up once at load, then
+      # define the method once to avoid runtime overhead.
+      normalised_java_version_major = java.lang.System.get_property("java.version")
+                                                      .slice(/^(1\.)?([0-9]+)/, 2)
+                                                      .to_i
+      if normalised_java_version_major >= 9
+
+        # On modern Javas, we can simply delegate through to `Process#pid`,
+        # which was introduced in Java 9.
+        #
+        # @return [Integer] the pid of the process after it has started
+        # @raise [NotImplementedError] when trying to access pid on platform for
+        #                              which it is unsupported in Java
+        def pid
+          @process.pid
+        rescue java.lang.UnsupportedOperationException => e
+          raise NotImplementedError, "pid is not supported on this platform: #{e.message}"
+        end
+
+      else
+
+        # On Legacy Javas, fall back to reflection.
+        #
+        # Only supported in JRuby on a Unix operating system, thanks to limitations
+        # in Java's classes
+        #
+        # @return [Integer] the pid of the process after it has started
+        # @raise [NotImplementedError] when trying to access pid on non-Unix platform
+        #
+        def pid
+          if @process.getClass.getName != "java.lang.UNIXProcess"
+            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
+          # Thanks to Martijn Courteaux
+          # http://stackoverflow.com/questions/2950338/how-can-i-kill-a-linux-process-in-java-with-sigkill-process-destroy-does-sigter/2951193#2951193
+          field = @process.getClass.getDeclaredField("pid")
+          field.accessible = true
+          field.get(@process)
+        end
+
+      end
+
+      private
+
+      def launch_process(&blk)
+        pb = java.lang.ProcessBuilder.new(@args)
+
+        pb.directory java.io.File.new(@cwd || Dir.pwd)
+        set_env pb.environment
+
+        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)
+        else
+          @process.getErrorStream.close
+          @process.getInputStream.close
+        end
+
+        if duplex?
+          io._stdin = create_stdin
+        else
+          @process.getOutputStream.close
+        end
+      end
+
+      def redirect(input, output)
+        if output.nil?
+          input.close
+          return
+        end
+
+        @pumps << Pump.new(input, output.to_outputstream).run
+      end
+
+      def stop_pumps
+        @pumps.each { |pump| pump.stop }
+      end
+
+      def set_env(env)
+        merged = ENV.to_hash
+
+        @environment.each { |k, v| merged[k.to_s] = v }
+
+        merged.each do |k, v|
+          if v
+            env.put(k, v.to_s)
+          elsif env.has_key? k
+            env.remove(k)
+          end
+        end
+
+        removed_keys = env.key_set.to_a - merged.keys
+        removed_keys.each { |k| env.remove(k) }
+      end
+
+      def create_stdin
+        output_stream = @process.getOutputStream
+
+        stdin = output_stream.to_io
+        stdin.sync = true
+        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
+
+        class << stdin
+          # The stream provided is a BufferedeOutputStream, so we
+          # have to flush it to make the bytes flow to the process
+          def __childprocess_flush__
+            @childprocess_java_stream.flush
+          end
+
+          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
+            define_method(m) do |*args|
+              super(*args)
+              self.__childprocess_flush__
+            end
+          end
+        end
+
+        stdin
+      end
+
+    end # Process
+  end # JRuby
+end # ChildProcess

data/lib/childprocess/jruby/pump.rb

@@ -1,53 +1,53 @@
-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 && (@input.available == 0)
-          read, avail = 0, 0
-
-          while read != -1
-            avail = [@input.available, 1].max
-            avail = BUFFER_SIZE if avail > BUFFER_SIZE
-            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
-        ChildProcess.logger.debug ex.message
-        ChildProcess.logger.debug ex.backtrace
-      end
-
-    end # Pump
-  end # JRuby
-end # ChildProcess
+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 && (@input.available == 0)
+          read, avail = 0, 0
+
+          while read != -1
+            avail = [@input.available, 1].max
+            avail = BUFFER_SIZE if avail > BUFFER_SIZE
+            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
+        ChildProcess.logger.debug ex.message
+        ChildProcess.logger.debug ex.backtrace
+      end
+
+    end # Pump
+  end # JRuby
+end # ChildProcess

data/lib/childprocess/jruby.rb

@@ -1,56 +1,56 @@
-require 'java'
-require 'jruby'
-
-class Java::SunNioCh::FileChannelImpl
-  field_reader :fd
-end
-
-class Java::JavaIo::FileDescriptor
-  if ChildProcess.os == :windows
-    field_reader :handle
-  end
-
-  field_reader :fd
-end
-
-module ChildProcess
-  module JRuby
-    def self.posix_fileno_for(obj)
-      channel = ::JRuby.reference(obj).channel
-      begin
-        channel.getFDVal
-      rescue NoMethodError
-        fileno = channel.fd
-        if fileno.kind_of?(Java::JavaIo::FileDescriptor)
-          fileno = fileno.fd
-        end
-
-        fileno == -1 ? obj.fileno : fileno
-      end
-    rescue
-      # fall back
-      obj.fileno
-    end
-
-    def self.windows_handle_for(obj)
-      channel = ::JRuby.reference(obj).channel
-      fileno = obj.fileno
-
-      begin
-        fileno = channel.getFDVal
-      rescue NoMethodError
-        fileno = channel.fd if channel.respond_to?(:fd)
-      end
-
-      if fileno.kind_of? Java::JavaIo::FileDescriptor
-        fileno.handle
-      else
-        Windows::Lib.handle_for fileno
-      end
-    end
-  end
-end
-
-require "childprocess/jruby/pump"
-require "childprocess/jruby/io"
-require "childprocess/jruby/process"
+require 'java'
+require 'jruby'
+
+class Java::SunNioCh::FileChannelImpl
+  field_reader :fd
+end
+
+class Java::JavaIo::FileDescriptor
+  if ChildProcess.os == :windows
+    field_reader :handle
+  end
+
+  field_reader :fd
+end
+
+module ChildProcess
+  module JRuby
+    def self.posix_fileno_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      begin
+        channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd
+        if fileno.kind_of?(Java::JavaIo::FileDescriptor)
+          fileno = fileno.fd
+        end
+
+        fileno == -1 ? obj.fileno : fileno
+      end
+    rescue
+      # fall back
+      obj.fileno
+    end
+
+    def self.windows_handle_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      fileno = obj.fileno
+
+      begin
+        fileno = channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd if channel.respond_to?(:fd)
+      end
+
+      if fileno.kind_of? Java::JavaIo::FileDescriptor
+        fileno.handle
+      else
+        Windows::Lib.handle_for fileno
+      end
+    end
+  end
+end
+
+require "childprocess/jruby/pump"
+require "childprocess/jruby/io"
+require "childprocess/jruby/process"