childprocess 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5e6dc8970dbfa81b42c587480b4cd7a564995c2a6a0be84f2c8192edcf6d0c
-  data.tar.gz: 766be22f3575a6ef9ba837a37722f0a852f509fc9efb2a77b01ca121b865a28e
+  metadata.gz: 3b5d923affd397c31cc2193e6dc9d6e1a6d32e485f3721210e65caf72b9ee138
+  data.tar.gz: '06896c2aa64a9c521b45206d1a0638a8aa63e433a013c261909a920fab135c75'
 SHA512:
-  metadata.gz: 8e4ac84967566de68d200d983bfebca6fce9575d7e8fb0aa0324b64dc4b6e0d29d29abe173ce99a54f8b37501eb515573b457f6b612a395f3f5d2bc672da6802
-  data.tar.gz: 16bc7aaffd67ab47f1f8a8ded31681fb88f1767421838c3ddb1f1033fb7dc0f5c5d664b7dce3fb4107edb9818a73ce2769f23a3e1f30bf51ffc3dd088d8a7690
+  metadata.gz: a0a5d3cfee92a6e4896eaf557dbf4fc50d54b54d42c43033776165991b1b606f12ccd1e17d0dbe26963b7d002482ee40877b3ea024765b371393e4a0cbd0343f
+  data.tar.gz: 6814491e59bbb30b61393670ca84d5da9d61ea5cb5dbc54a45599ef9cb7318bbf82751fddaf5c7ee5ef501718d7cad4a08636fab3a379148899af3acd0303bd4

data/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu, macos, windows ]
+        ruby: [ '2.4', '2.5', '2.6', '2.7', '3.0', '3.1', '3.2', '3.3', jruby, truffleruby ]
+        exclude:
+        - { os: windows, ruby: truffleruby }
+        # fails to load rspec: RuntimeError: CRITICAL: RUBYGEMS_ACTIVATION_MONITOR.owned?: before false -> after true
+        - { os: windows, ruby: jruby }
+    runs-on: ${{ matrix.os }}-latest
+    env:
+      CHILDPROCESS_UNSET: should-be-unset
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - run: bundle exec rake spec

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### Version 5.0.0 / 2024-01-06
+
+* [#175](https://github.com/enkessler/childprocess/pull/175): Replace all backends by `Process.spawn` for portability, reliability and simplicity.
+* [#185](https://github.com/enkessler/childprocess/pull/185): Add support for Ruby 3.x
+
 ### Version 4.1.0 / 2021-06-08
 
 * [#170](https://github.com/enkessler/childprocess/pull/170): Update gem homepage to use `https://`

data/Gemfile

@@ -5,5 +5,3 @@ gemspec
 
 # Used for local development/testing only
 gem 'rake'
-
-gem 'ffi' if ENV['CHILDPROCESS_POSIX_SPAWN'] == 'true' || Gem.win_platform?

data/README.md

@@ -16,8 +16,6 @@ a standalone library.
 
 * Ruby 2.4+, JRuby 9+
 
-Windows users **must** ensure the `ffi` gem (`>= 1.0.11`) is installed in order to use ChildProcess.
-
 # Usage
 
 The object returned from `ChildProcess.build` will implement `ChildProcess::AbstractProcess`.
@@ -73,9 +71,9 @@ begin
   process = ChildProcess.build("sh" , "-c",
                                "for i in {1..3}; do echo $i; sleep 1; done")
   process.io.stdout = w
-  process.start # This results in a fork, inheriting the write end of the pipe.
+  process.start # This results in a subprocess inheriting the write end of the pipe.
 
-  # Close parent's copy of the write end of the pipe so when the (forked) child
+  # Close parent's copy of the write end of the pipe so when the child
   # process closes its write end of the pipe the parent receives EOF when
   # attempting to read from it. If the parent leaves its write end open, it
   # will not detect EOF.
@@ -138,17 +136,6 @@ search.io.stdin.close
 search.wait
 ```
 
-#### Prefer posix_spawn on *nix
-
-If the parent process is using a lot of memory, `fork+exec` can be very expensive. The `posix_spawn()` API removes this overhead.
-
-```ruby
-ChildProcess.posix_spawn = true
-process = ChildProcess.build(*args)
-```
-
-To be able to use this, please make sure that you have the `ffi` gem installed.
-
 ### Ensure entire process tree dies
 
 By default, the child process does not create a new process group. This means there's no guarantee that the entire process tree will die when the child process is killed. To solve this:
@@ -195,11 +182,7 @@ ChildProcess.logger = logger
 
 # Implementation
 
-How the process is launched and killed depends on the platform:
-
-* Unix     : `fork + exec` (or `posix_spawn` if enabled)
-* Windows  : `CreateProcess()` and friends
-* JRuby    : `java.lang.{Process,ProcessBuilder}`
+ChildProcess 5+ uses `Process.spawn` from the Ruby core library for maximum portability.
 
 # Note on Patches/Pull Requests
 

data/lib/childprocess/abstract_process.rb

@@ -39,7 +39,7 @@ module ChildProcess
     # @see ChildProcess.build
     #
 
-    def initialize(args)
+    def initialize(*args)
       unless args.all? { |e| e.kind_of?(String) }
         raise ArgumentError, "all arguments must be String: #{args.inspect}"
       end

data/lib/childprocess/errors.rb

@@ -13,25 +13,4 @@ module ChildProcess
 
   class LaunchError < Error
   end
-
-  class MissingFFIError < Error
-    def initialize
-      message = "FFI is a required pre-requisite for Windows or posix_spawn support in the ChildProcess gem. " +
-                "Ensure the `ffi` gem is installed. " +
-                "If you believe this is an error, please file a bug at http://github.com/enkessler/childprocess/issues"
-
-      super(message)
-    end
-
-  end
-
-  class MissingPlatformError < Error
-    def initialize
-      message = "posix_spawn is not yet supported on #{ChildProcess.platform_name} (#{RUBY_PLATFORM}), falling back to default implementation. " +
-                "If you believe this is an error, please file a bug at http://github.com/enkessler/childprocess/issues"
-
-      super(message)
-    end
-
-  end
 end

data/lib/childprocess/process_spawn_process.rb

@@ -0,0 +1,127 @@
+require_relative 'abstract_process'
+
+module ChildProcess
+  class ProcessSpawnProcess < AbstractProcess
+    attr_reader :pid
+
+    def exited?
+      return true if @exit_code
+
+      assert_started
+      pid, status = ::Process.waitpid2(@pid, ::Process::WNOHANG | ::Process::WUNTRACED)
+      pid = nil if pid == 0 # may happen on jruby
+
+      log(:pid => pid, :status => status)
+
+      if pid
+        set_exit_code(status)
+      end
+
+      !!pid
+    rescue Errno::ECHILD
+      # may be thrown for detached processes
+      true
+    end
+
+    def wait
+      assert_started
+
+      if exited?
+        exit_code
+      else
+        _, status = ::Process.waitpid2(@pid)
+
+        set_exit_code(status)
+      end
+    end
+
+    private
+
+    def launch_process
+      environment = {}
+      @environment.each_pair do |key, value|
+        key = key.to_s
+        value = value.nil? ? nil : value.to_s
+
+        if key.include?("\0") || key.include?("=") || value.to_s.include?("\0")
+          raise InvalidEnvironmentVariable, "#{key.inspect} => #{value.to_s.inspect}"
+        end
+        environment[key] = value
+      end
+
+      options = {}
+
+      options[:out] = io.stdout ? io.stdout.fileno : File::NULL
+      options[:err] = io.stderr ? io.stderr.fileno : File::NULL
+
+      if duplex?
+        reader, writer = ::IO.pipe
+        options[:in] = reader.fileno
+        unless ChildProcess.windows?
+          options[writer.fileno] = :close
+        end
+      end
+
+      if leader?
+        if ChildProcess.windows?
+          options[:new_pgroup] = true
+        else
+          options[:pgroup] = true
+        end
+      end
+
+      options[:chdir] = @cwd if @cwd
+
+      if @args.size == 1
+        # When given a single String, Process.spawn would think it should use the shell
+        # if there is any special character in it. However,  ChildProcess should never
+        # use the shell. So we use the [cmdname, argv0] form to force no shell.
+        arg = @args[0]
+        args = [[arg, arg]]
+      else
+        args = @args
+      end
+
+      begin
+        @pid = ::Process.spawn(environment, *args, options)
+      rescue SystemCallError => e
+        raise LaunchError, e.message
+      end
+
+      if duplex?
+        io._stdin = writer
+        reader.close
+      end
+
+      ::Process.detach(@pid) if detach?
+    end
+
+    def set_exit_code(status)
+      @exit_code = status.exitstatus || status.termsig
+    end
+
+    def send_term
+      send_signal 'TERM'
+    end
+
+    def send_kill
+      send_signal 'KILL'
+    end
+
+    def send_signal(sig)
+      assert_started
+
+      log "sending #{sig}"
+      if leader?
+        if ChildProcess.unix?
+          ::Process.kill sig, -@pid # negative pid == process group
+        else
+          output = `taskkill /F /T /PID #{@pid}`
+          log output
+        end
+      else
+        ::Process.kill sig, @pid
+      end
+    end
+  end
+end

data/lib/childprocess/unix/process.rb

@@ -1,8 +1,8 @@
+require_relative '../process_spawn_process'
+
 module ChildProcess
   module Unix
-    class Process < AbstractProcess
-      attr_reader :pid
-
+    class Process < ProcessSpawnProcess
       def io
         @io ||= Unix::IO.new
       end
@@ -24,67 +24,6 @@ module ChildProcess
         # and send_kill
         true
       end
-
-      def exited?
-        return true if @exit_code
-
-        assert_started
-        pid, status = ::Process.waitpid2(@pid, ::Process::WNOHANG | ::Process::WUNTRACED)
-        pid = nil if pid == 0 # may happen on jruby
-
-        log(:pid => pid, :status => status)
-
-        if pid
-          set_exit_code(status)
-        end
-
-        !!pid
-      rescue Errno::ECHILD
-        # may be thrown for detached processes
-        true
-      end
-
-      def wait
-        assert_started
-
-        if exited?
-          exit_code
-        else
-          _, status = ::Process.waitpid2(@pid)
-
-          set_exit_code(status)
-        end
-      end
-
-      private
-
-      def send_term
-        send_signal 'TERM'
-      end
-
-      def send_kill
-        send_signal 'KILL'
-      end
-
-      def send_signal(sig)
-        assert_started
-
-        log "sending #{sig}"
-        ::Process.kill sig, _pid
-      end
-
-      def set_exit_code(status)
-        @exit_code = status.exitstatus || status.termsig
-      end
-
-      def _pid
-        if leader?
-          -@pid # negative pid == process group
-        else
-          @pid
-        end
-      end
-
     end # Process
   end # Unix
 end # ChildProcess

data/lib/childprocess/unix.rb

@@ -3,7 +3,5 @@ module ChildProcess
   end
 end
 
-require "childprocess/unix/io"
-require "childprocess/unix/process"
-require "childprocess/unix/fork_exec_process"
-# PosixSpawnProcess + ffi is required on demand.
+require_relative "unix/io"
+require_relative "unix/process"

data/lib/childprocess/version.rb

@@ -1,3 +1,3 @@
 module ChildProcess
-  VERSION = '4.1.0'
+  VERSION = '5.0.0'
 end

data/lib/childprocess/windows/process.rb

@@ -1,131 +1,28 @@
+require_relative '../process_spawn_process'
+
 module ChildProcess
   module Windows
-    class Process < AbstractProcess
-
-      attr_reader :pid
-
+    class Process < ProcessSpawnProcess
       def io
         @io ||= Windows::IO.new
       end
 
       def stop(timeout = 3)
         assert_started
+        send_kill
 
-        log "sending KILL"
-        @handle.send(WIN_SIGKILL)
-
-        poll_for_exit(timeout)
-      ensure
-        close_handle
-        close_job_if_necessary
-      end
-
-      def wait
-        if exited?
-          exit_code
-        else
-          @handle.wait
-          @exit_code = @handle.exit_code
-
-          close_handle
-          close_job_if_necessary
-
-          @exit_code
-        end
-      end
-
-      def exited?
-        return true if @exit_code
-        assert_started
-
-        code   = @handle.exit_code
-        exited = code != PROCESS_STILL_ACTIVE
-
-        log(:exited? => exited, :code => code)
-
-        if exited
-          @exit_code = code
-          close_handle
-          close_job_if_necessary
-        end
-
-        exited
-      end
-
-      private
-
-      def launch_process
-        builder = ProcessBuilder.new(@args)
-        builder.leader      = leader?
-        builder.detach      = detach?
-        builder.duplex      = duplex?
-        builder.environment = @environment unless @environment.empty?
-        builder.cwd         = @cwd
-
-        if @io
-          builder.stdout      = @io.stdout
-          builder.stderr      = @io.stderr
-        end
-
-        @pid = builder.start
-        @handle = Handle.open @pid
-
-        if leader?
-          @job = Job.new(detach?, true)
-          @job << @handle
-        end
-
-        if duplex?
-          raise Error, "no stdin stream" unless builder.stdin
-          io._stdin = builder.stdin
-        end
-
-        self
-      end
-
-      def close_handle
-        @handle.close
-      end
-
-      def close_job_if_necessary
-        @job.close if leader?
-      end
-
-
-      class Job
-        def initialize(detach, leader)
-          @pointer = Lib.create_job_object(nil, nil)
-
-          if @pointer.nil? || @pointer.null?
-            raise Error, "unable to create job object"
-          end
-
-          basic = JobObjectBasicLimitInformation.new
-          basic[:LimitFlags] |= JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE if !detach
-          basic[:LimitFlags] |= JOB_OBJECT_LIMIT_BREAKAWAY_OK if leader
-
-          extended = JobObjectExtendedLimitInformation.new
-          extended[:BasicLimitInformation] = basic
-
-          ret = Lib.set_information_job_object(
-            @pointer,
-            JOB_OBJECT_EXTENDED_LIMIT_INFORMATION,
-            extended,
-            extended.size
-          )
-
-          Lib.check_error ret
-        end
-
-        def <<(handle)
-          Lib.check_error Lib.assign_process_to_job_object(@pointer, handle.pointer)
+        begin
+          return poll_for_exit(timeout)
+        rescue TimeoutError
+          # try next
         end
 
-        def close
-          Lib.close_handle @pointer
-        end
+        wait
+      rescue Errno::ECHILD, Errno::ESRCH
+        # handle race condition where process dies between timeout
+        # and send_kill
+        true
       end
-
     end # Process
   end # Windows
 end # ChildProcess

data/lib/childprocess/windows.rb

@@ -1,38 +1,9 @@
 require "rbconfig"
 
-begin
-  require 'ffi'
-rescue LoadError
-  raise ChildProcess::MissingFFIError
-end
-
 module ChildProcess
   module Windows
-    module Lib
-      extend FFI::Library
-
-      def self.msvcrt_name
-        host_part = RbConfig::CONFIG['host_os'].split("_")[1]
-        manifest  = File.join(RbConfig::CONFIG['bindir'], 'ruby.exe.manifest')
-
-        if host_part && host_part.to_i > 80 && File.exists?(manifest)
-          "msvcr#{host_part}"
-        else
-          "msvcrt"
-        end
-      end
-
-      ffi_lib "kernel32", msvcrt_name
-      ffi_convention :stdcall
-
-
-    end # Library
   end # Windows
 end # ChildProcess
 
-require "childprocess/windows/lib"
-require "childprocess/windows/structs"
-require "childprocess/windows/handle"
 require "childprocess/windows/io"
-require "childprocess/windows/process_builder"
 require "childprocess/windows/process"

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