childprocess 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4e76f415dff2879680f9ca7c48442132fde2099dbdcd956aaf44b429269067b
-  data.tar.gz: b02b05e8ec6ad8a63c31cbaae6067cf5dae11e80b79850ebf9cf630e6fe69ddf
+  metadata.gz: 3b5d923affd397c31cc2193e6dc9d6e1a6d32e485f3721210e65caf72b9ee138
+  data.tar.gz: '06896c2aa64a9c521b45206d1a0638a8aa63e433a013c261909a920fab135c75'
 SHA512:
-  metadata.gz: ea2985d14f2b941e48dfa544c4531440560e6e4fc7c8edb1bdf68200099f9002cba20e033c0267a5f87bed8f886ae655dd3476c023f1133ce0729d7428610d8f
-  data.tar.gz: d962183e2e67e3612be72a7120a2a083bae78f738662cd8f0af7e50513b9936406814a25136e8a5cb7ae2c3166eb4d3ead38f85be834478b6fd26106c000dd56
+  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,6 +1,17 @@
+### 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://`
+* [#177](https://github.com/enkessler/childprocess/pull/177): Add ARM64-macos support
+
 ### Version 4.0.0 / 2020-06-18
 
 * [#167](https://github.com/enkessler/childprocess/pull/167): Fix detach behavior on Windows
+* [#168](https://github.com/enkessler/childprocess/pull/168): Drop support for Ruby 2.3
 
 ### Version 3.0.0 / 2019-09-20
 

data/Gemfile

@@ -5,17 +5,3 @@ gemspec
 
 # Used for local development/testing only
 gem 'rake'
-
-if RUBY_VERSION =~ /^1\./
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-
-  # ffi gem for Windows requires Ruby 2.x on/after this version
-  gem 'ffi', '< 1.9.15' if ENV['CHILDPROCESS_POSIX_SPAWN'] == 'true' || Gem.win_platform?
-elsif Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2')
-  # Ruby 2.0/2.1 support only ffi before 1.10
-  gem 'ffi', '~> 1.9.0' if ENV['CHILDPROCESS_POSIX_SPAWN'] == 'true' || Gem.win_platform?
-else
-  gem 'ffi' if ENV['CHILDPROCESS_POSIX_SPAWN'] == 'true' || Gem.win_platform?
-end

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/childprocess.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Jari Bakken", "Eric Kessler", "Shane da Silva"]
   s.email       = ["morrow748@gmail.com", "shane@dasilva.io"]
-  s.homepage    = "http://github.com/enkessler/childprocess"
+  s.homepage    = "https://github.com/enkessler/childprocess"
   s.summary     = %q{A simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.}
   s.description = %q{This gem aims at being a simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.}
 

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.0.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"