childprocess 4.0.0 → 5.0.0

data/lib/childprocess.rb

@@ -2,6 +2,7 @@ require 'childprocess/version'
 require 'childprocess/errors'
 require 'childprocess/abstract_process'
 require 'childprocess/abstract_io'
+require 'childprocess/process_spawn_process'
 require "fcntl"
 require 'logger'
 
@@ -15,15 +16,9 @@ module ChildProcess
     def new(*args)
       case os
       when :macosx, :linux, :solaris, :bsd, :cygwin, :aix
-        if posix_spawn?
-          Unix::PosixSpawnProcess.new(args)
-        elsif jruby?
-          JRuby::Process.new(args)
-        else
-          Unix::ForkExecProcess.new(args)
-        end
+        Unix::Process.new(*args)
       when :windows
-        Windows::Process.new(args)
+        Windows::Process.new(*args)
       else
         raise Error, "unsupported platform #{platform_name.inspect}"
       end
@@ -40,13 +35,7 @@ module ChildProcess
     end
 
     def platform
-      if RUBY_PLATFORM == "java"
-        :jruby
-      elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
-        :ironruby
-      else
-        os
-      end
+      os
     end
 
     def platform_name
@@ -62,35 +51,18 @@ module ChildProcess
     end
 
     def jruby?
-      platform == :jruby
+      RUBY_ENGINE == 'jruby'
     end
 
     def windows?
       os == :windows
     end
 
-    def posix_spawn?
-      enabled = @posix_spawn || %w[1 true].include?(ENV['CHILDPROCESS_POSIX_SPAWN'])
-      return false unless enabled
-
-      begin
-        require 'ffi'
-      rescue LoadError
-        raise ChildProcess::MissingFFIError
-      end
-
-      begin
-        require "childprocess/unix/platform/#{ChildProcess.platform_name}"
-      rescue LoadError
-        raise ChildProcess::MissingPlatformError
-      end
-
-      require "childprocess/unix/lib"
-      require 'childprocess/unix/posix_spawn_process'
+    def posix_spawn_chosen_explicitly?
+      @posix_spawn || %w[1 true].include?(ENV['CHILDPROCESS_POSIX_SPAWN'])
+    end
 
-      true
-    rescue ChildProcess::MissingPlatformError => ex
-      warn_once ex.message
+    def posix_spawn?
       false
     end
 
@@ -103,6 +75,8 @@ module ChildProcess
     end
 
     def os
+      return :windows if ENV['FAKE_WINDOWS'] == 'true'
+
       @os ||= (
         require "rbconfig"
         host_os = RbConfig::CONFIG['host_os'].downcase
@@ -158,17 +132,6 @@ module ChildProcess
     def close_on_exec(file)
       if file.respond_to?(:close_on_exec=)
         file.close_on_exec = true
-      elsif file.respond_to?(:fcntl) && defined?(Fcntl::FD_CLOEXEC)
-        file.fcntl Fcntl::F_SETFD, Fcntl::FD_CLOEXEC
-
-        if jruby? && posix_spawn?
-          # on JRuby, the fcntl call above apparently isn't enough when
-          # we're launching the process through posix_spawn.
-          fileno = JRuby.posix_fileno_for(file)
-          Unix::Lib.fcntl fileno, Fcntl::F_SETFD, Fcntl::FD_CLOEXEC
-        end
-      elsif windows?
-        Windows::Lib.dont_inherit file
       else
         raise Error, "not sure how to set close-on-exec for #{file.inspect} on #{platform_name.inspect}"
       end
@@ -203,8 +166,8 @@ module ChildProcess
   end # class << self
 end # ChildProcess
 
-require 'jruby' if ChildProcess.jruby?
-
-require 'childprocess/unix'    if ChildProcess.unix?
-require 'childprocess/windows' if ChildProcess.windows?
-require 'childprocess/jruby'   if ChildProcess.jruby?
+if ChildProcess.windows?
+  require 'childprocess/windows'
+else
+  require 'childprocess/unix'
+end

data/spec/childprocess_spec.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 require File.expand_path('../spec_helper', __FILE__)
-require 'rubygems/mock_gem_ui'
 
 
 describe ChildProcess do
@@ -11,12 +10,17 @@ describe ChildProcess do
   let(:gemspec) { eval(File.read "#{here}/../childprocess.gemspec") }
 
   it 'validates cleanly' do
-    mock_ui = Gem::MockGemUi.new
-    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
+    if Gem::VERSION >= "3.5.0"
+      expect { gemspec.validate }.not_to output(/warn/i).to_stderr
+    else
+      require 'rubygems/mock_gem_ui'
 
-    expect(mock_ui.error).to_not match(/warn/i)
-  end
+      mock_ui = Gem::MockGemUi.new
+      Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
 
+      expect(mock_ui.error).to_not match(/warn/i)
+    end
+  end
 
   it "returns self when started" do
     process = sleeping_ruby
@@ -25,14 +29,7 @@ describe ChildProcess do
     expect(process).to be_alive
   end
 
-  # We can't detect failure to execve() when using posix_spawn() on Linux
-  # without waiting for the child to exit with code 127.
-  #
-  # See e.g. http://repo.or.cz/w/glibc.git/blob/669704fd:/sysdeps/posix/spawni.c#l34
-  #
-  # We could work around this by doing the PATH search ourselves, but not sure
-  # it's worth it.
-  it "raises ChildProcess::LaunchError if the process can't be started", :posix_spawn_on_linux => false do
+  it "raises ChildProcess::LaunchError if the process can't be started" do
     expect { invalid_process.start }.to raise_error(ChildProcess::LaunchError)
   end
 
@@ -95,7 +92,7 @@ describe ChildProcess do
     end
   end
 
-  it "can override env vars only for the current process" do
+  it "can override env vars only for the child process" do
     Tempfile.open("env-spec") do |file|
       file.close
       process = write_env(file.path)
@@ -127,6 +124,31 @@ describe ChildProcess do
     end
   end
 
+  it "can set env vars using Symbol keys and values" do
+    Tempfile.open("env-spec") do |file|
+      process = ruby('puts ENV["SYMBOL_KEY"]')
+      process.environment[:SYMBOL_KEY] = :VALUE
+      process.io.stdout = file
+      process.start
+      process.wait
+      expect(rewind_and_read(file)).to eq "VALUE\n"
+    end
+  end
+
+  it "raises ChildProcess::InvalidEnvironmentVariable for invalid env vars" do
+    process = ruby(':OK')
+    process.environment["a\0b"] = '1'
+    expect { process.start }.to raise_error(ChildProcess::InvalidEnvironmentVariable)
+
+    process = ruby(':OK')
+    process.environment["A=1"] = '2'
+    expect { process.start }.to raise_error(ChildProcess::InvalidEnvironmentVariable)
+
+    process = ruby(':OK')
+    process.environment['A'] = "a\0b"
+    expect { process.start }.to raise_error(ChildProcess::InvalidEnvironmentVariable)
+  end
+
   it "inherits the parent's env vars also when some are overridden" do
     Tempfile.open("env-spec") do |file|
       file.close
@@ -195,7 +217,7 @@ describe ChildProcess do
 
     Tempfile.open('grandparent_out') do |gp_file|
       # Create a parent and detached child process that will spit out their PID. Make sure that the child process lasts longer than the parent.
-      p_process = ruby("require 'childprocess' ; c_process = ChildProcess.build('ruby', '-e', 'puts \\\"Child PID: \#{Process.pid}\\\" ; sleep 5') ; c_process.io.inherit! ; c_process.detach = true ;  c_process.start ; puts \"Child PID: \#{c_process.pid}\" ; puts \"Parent PID: \#{Process.pid}\"")
+      p_process = ruby("$: << 'lib'; require 'childprocess' ; c_process = ChildProcess.build('ruby', '-e', 'puts \\\"Child PID: \#{Process.pid}\\\" ; sleep 5') ; c_process.io.inherit! ; c_process.detach = true ;  c_process.start ; puts \"Child PID: \#{c_process.pid}\" ; puts \"Parent PID: \#{Process.pid}\"")
       p_process.io.stdout = p_process.io.stderr = gp_file
 
       # Let the parent process die
@@ -277,7 +299,7 @@ describe ChildProcess do
     }
   end
 
-  it 'kills the full process tree', :process_builder => false do
+  it 'kills the full process tree' do
     Tempfile.open('kill-process-tree') do |file|
       process = write_pid_in_sleepy_grand_child(file.path)
       process.leader = true
@@ -288,6 +310,8 @@ describe ChildProcess do
       end
 
       process.stop
+      expect(process).to be_exited
+
       wait_until(3) { expect(alive?(pid)).to eql(false) }
     end
   end

data/spec/io_spec.rb

@@ -138,7 +138,7 @@ describe ChildProcess do
 
       stdin.close
       process.poll_for_exit(exit_timeout)
-     ensure
+    ensure
       out_receiver.close
       out.close
     end
@@ -151,7 +151,7 @@ describe ChildProcess do
   # http://travis-ci.org/#!/enkessler/childprocess/jobs/487331
   #
 
-  it "works with pipes", :process_builder => false do
+  it "works with pipes" do
     process = ruby(<<-CODE)
       STDOUT.print "stdout"
       STDERR.print "stderr"

data/spec/spec_helper.rb

@@ -210,16 +210,9 @@ module ChildProcessSpecHelper
   end
 
   def alive?(pid)
-    if ChildProcess.windows?
-      ChildProcess::Windows::Lib.alive?(pid)
-    else
-      begin
-        Process.getpgid pid
-        true
-      rescue Errno::ESRCH
-        false
-      end
-    end
+    !!Process.kill(0, pid)
+  rescue Errno::ESRCH
+    false
   end
 
   def capture_std
@@ -259,12 +252,4 @@ RSpec.configure do |c|
   c.after(:each) {
     defined?(@process) && @process.alive? && @process.stop
   }
-
-  if ChildProcess.jruby? && ChildProcess.new("true").instance_of?(ChildProcess::JRuby::Process)
-    c.filter_run_excluding :process_builder => false
-  end
-
-  if ChildProcess.linux? && ChildProcess.posix_spawn?
-    c.filter_run_excluding :posix_spawn_on_linux => false
-  end
 end

data/spec/unix_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../spec_helper', __FILE__)
 require "pid_behavior"
 
-if ChildProcess.unix? && !ChildProcess.jruby? && !ChildProcess.posix_spawn?
+if ChildProcess.unix?
 
   describe ChildProcess::Unix::Process do
     it_behaves_like "a platform that provides the child's pid"
@@ -9,7 +9,7 @@ if ChildProcess.unix? && !ChildProcess.jruby? && !ChildProcess.posix_spawn?
     it "handles ECHILD race condition where process dies between timeout and KILL" do
       process = sleeping_ruby
 
-      allow(process).to receive(:fork).and_return('fakepid')
+      allow(Process).to receive(:spawn).and_return('fakepid')
       allow(process).to receive(:send_term)
       allow(process).to receive(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
       allow(process).to receive(:send_kill).and_raise(Errno::ECHILD.new)
@@ -18,14 +18,12 @@ if ChildProcess.unix? && !ChildProcess.jruby? && !ChildProcess.posix_spawn?
       expect { process.stop }.not_to raise_error
 
       allow(process).to receive(:alive?).and_return(false)
-
-      process.send(:send_signal, 'TERM')
     end
 
     it "handles ESRCH race condition where process dies between timeout and KILL" do
       process = sleeping_ruby
 
-      allow(process).to receive(:fork).and_return('fakepid')
+      allow(Process).to receive(:spawn).and_return('fakepid')
       allow(process).to receive(:send_term)
       allow(process).to receive(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
       allow(process).to receive(:send_kill).and_raise(Errno::ESRCH.new)
@@ -34,8 +32,6 @@ if ChildProcess.unix? && !ChildProcess.jruby? && !ChildProcess.posix_spawn?
       expect { process.stop }.not_to raise_error
 
       allow(process).to receive(:alive?).and_return(false)
-
-      process.send(:send_signal, 'TERM')
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: childprocess
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Jari Bakken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-18 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -64,54 +64,37 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".document"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- appveyor.yml
 - childprocess.gemspec
 - lib/childprocess.rb
 - lib/childprocess/abstract_io.rb
 - lib/childprocess/abstract_process.rb
 - lib/childprocess/errors.rb
-- lib/childprocess/jruby.rb
-- lib/childprocess/jruby/io.rb
-- lib/childprocess/jruby/process.rb
-- lib/childprocess/jruby/pump.rb
-- lib/childprocess/tools/generator.rb
+- lib/childprocess/process_spawn_process.rb
 - lib/childprocess/unix.rb
-- lib/childprocess/unix/fork_exec_process.rb
 - lib/childprocess/unix/io.rb
-- lib/childprocess/unix/lib.rb
-- lib/childprocess/unix/platform/i386-linux.rb
-- lib/childprocess/unix/platform/i386-solaris.rb
-- lib/childprocess/unix/platform/x86_64-linux.rb
-- lib/childprocess/unix/platform/x86_64-macosx.rb
-- lib/childprocess/unix/posix_spawn_process.rb
 - lib/childprocess/unix/process.rb
 - lib/childprocess/version.rb
 - lib/childprocess/windows.rb
-- lib/childprocess/windows/handle.rb
 - lib/childprocess/windows/io.rb
-- lib/childprocess/windows/lib.rb
 - lib/childprocess/windows/process.rb
-- lib/childprocess/windows/process_builder.rb
-- lib/childprocess/windows/structs.rb
 - spec/abstract_io_spec.rb
 - spec/childprocess_spec.rb
 - spec/get_env.ps1
 - spec/io_spec.rb
-- spec/jruby_spec.rb
 - spec/pid_behavior.rb
 - spec/platform_detection_spec.rb
 - spec/spec_helper.rb
 - spec/unix_spec.rb
 - spec/windows_spec.rb
-homepage: http://github.com/enkessler/childprocess
+homepage: https://github.com/enkessler/childprocess
 licenses:
 - MIT
 metadata: {}
@@ -130,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.1
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A simple and reliable solution for controlling external programs running
@@ -140,7 +123,6 @@ test_files:
 - spec/childprocess_spec.rb
 - spec/get_env.ps1
 - spec/io_spec.rb
-- spec/jruby_spec.rb
 - spec/pid_behavior.rb
 - spec/platform_detection_spec.rb
 - spec/spec_helper.rb

data/.travis.yml

@@ -1,37 +0,0 @@
-os:
-  - linux
-  - osx
-
-rvm:
-  - rbx-3
-  - 2.4
-  - 2.5
-  - 2.6
-  - ruby-head
-
-sudo: false
-
-cache: bundler
-
-before_install:
-  - "echo 'gem: --no-document' > ~/.gemrc"
-  - gem install bundler
-
-before_script:
-  - 'export JAVA_OPTS="${JAVA_OPTS_FOR_SPECS}"'
-
-env:
-  global:
-  matrix:
-    - CHILDPROCESS_POSIX_SPAWN=true CHILDPROCESS_UNSET=should-be-unset
-    - CHILDPROCESS_POSIX_SPAWN=false CHILDPROCESS_UNSET=should-be-unset
-
-matrix:
-  allow_failures:
-    - rvm: rbx-3
-    - rvm: ruby-head
-    - env: "CHILDPROCESS_POSIX_SPAWN=true"
-  include:
-  - rvm: jruby-9.2.5.0
-    jdk: openjdk11
-    env: "JAVA_OPTS_FOR_SPECS='--add-opens java.base/java.io=org.jruby.dist --add-opens java.base/sun.nio.ch=org.jruby.dist'"

data/appveyor.yml

@@ -1,36 +0,0 @@
-version: '1.0.{build}'
-
-environment:
-  matrix:
-    - CHILDPROCESS_POSIX_SPAWN: true
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 24-x64
-    - CHILDPROCESS_POSIX_SPAWN: false
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 24-x64
-    - CHILDPROCESS_POSIX_SPAWN: true
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 25-x64
-    - CHILDPROCESS_POSIX_SPAWN: false
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 25-x64
-    - CHILDPROCESS_POSIX_SPAWN: true
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 26-x64
-    - CHILDPROCESS_POSIX_SPAWN: false
-      CHILDPROCESS_UNSET: should-be-unset
-      RUBY_VERSION: 26-x64
-
-install:
-  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
-  - bundle install
-
-build: off
-
-before_test:
-  - ruby -v
-  - gem -v
-  - bundle -v
-
-test_script:
-  - bundle exec rake

data/lib/childprocess/jruby/io.rb

@@ -1,16 +0,0 @@
-module ChildProcess
-  module JRuby
-    class IO < AbstractIO
-      private
-
-      def check_type(output)
-        unless output.respond_to?(:to_outputstream) && output.respond_to?(:write)
-          raise ArgumentError, "expected #{output.inspect} to respond to :to_outputstream"
-        end
-      end
-
-    end # IO
-  end # Unix
-end # ChildProcess
-
-

data/lib/childprocess/jruby/process.rb

@@ -1,184 +0,0 @@
-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