childprocess 4.1.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5e6dc8970dbfa81b42c587480b4cd7a564995c2a6a0be84f2c8192edcf6d0c
-  data.tar.gz: 766be22f3575a6ef9ba837a37722f0a852f509fc9efb2a77b01ca121b865a28e
+  metadata.gz: 9af8db7e1ea6ba4571c4b26bf7631147d9dc3e9d1b96bf602534a054621d44dd
+  data.tar.gz: fcb40387f9f29e29019663fdea7c1fa94a531c80ee125f6b207194f76617b7cf
 SHA512:
-  metadata.gz: 8e4ac84967566de68d200d983bfebca6fce9575d7e8fb0aa0324b64dc4b6e0d29d29abe173ce99a54f8b37501eb515573b457f6b612a395f3f5d2bc672da6802
-  data.tar.gz: 16bc7aaffd67ab47f1f8a8ded31681fb88f1767421838c3ddb1f1033fb7dc0f5c5d664b7dce3fb4107edb9818a73ce2769f23a3e1f30bf51ffc3dd088d8a7690
+  metadata.gz: 8eec57e14538d054468f8582802596cc6ecafcc88660bc2242b90c9da2ba6ec9d5e053d39c8d6338aa9486ff8eb942942e6eae2216c52bde3cac53128192b796
+  data.tar.gz: 9e5335a82ab47954fff0d7781cd666f20742ab5c48b670bb8adb567466f22d20a96500b581ac750e9e91ea36d63f7a9a01d05a89a21a6eef20134c66891510f3

data/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+        ruby: [ '2.4', '2.5', '2.6', '2.7', '3.0', '3.1', '3.2', '3.3', head, jruby, truffleruby ]
+        # CRuby < 2.6 does not support macos-arm64, so test those on amd64 instead
+        # JRuby 9.4.7.0 does not have native console support on macos-arm64: https://github.com/jruby/jruby/issues/8271
+        include:
+        - { os: macos-13, ruby: '2.4' }
+        - { os: macos-13, ruby: '2.5' }
+        - { os: macos-13, ruby: jruby }
+        exclude:
+        - { os: macos-latest, ruby: '2.4' }
+        - { os: macos-latest, ruby: '2.5' }
+        - { os: macos-latest, ruby: jruby }
+        - { os: windows-latest, ruby: truffleruby }
+        # fails to load rspec: RuntimeError: CRITICAL: RUBYGEMS_ACTIVATION_MONITOR.owned?: before false -> after true
+        - { os: windows-latest, ruby: jruby }
+    runs-on: ${{ matrix.os }}
+    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,13 @@
+### Version 5.1.0 / 2024-01-06
+
+* [#196](https://github.com/enkessler/childprocess/pull/196): Remove `ostruct` dependency to fix deprecation warning on Ruby 3.4
+* [#199](https://github.com/enkessler/childprocess/pull/199): Add `logger` dependency to fix deprecation warning on Ruby 3.4
+
+### 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

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in child_process.gemspec
 gemspec
@@ -6,4 +6,5 @@ gemspec
 # Used for local development/testing only
 gem 'rake'
 
-gem 'ffi' if ENV['CHILDPROCESS_POSIX_SPAWN'] == 'true' || Gem.win_platform?
+# Newer versions of term-ansicolor (used by coveralls) do not work on Ruby 2.4
+gem 'term-ansicolor', '< 1.8.0' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.5')

data/README.md

@@ -6,9 +6,8 @@ external programs running in the background on any Ruby / OS combination.
 The code originated in the [selenium-webdriver](https://rubygems.org/gems/selenium-webdriver) gem, but should prove useful as
 a standalone library.
 
-[![Build Status](https://secure.travis-ci.org/enkessler/childprocess.svg)](http://travis-ci.org/enkessler/childprocess)
-[![Build status](https://ci.appveyor.com/api/projects/status/fn2snbcd7kku5myk/branch/dev?svg=true)](https://ci.appveyor.com/project/enkessler/childprocess/branch/dev)
-[![Gem Version](https://badge.fury.io/rb/childprocess.svg)](http://badge.fury.io/rb/childprocess)
+[![CI](https://github.com/enkessler/childprocess/actions/workflows/ci.yml/badge.svg)](https://github.com/enkessler/childprocess/actions/workflows/ci.yml)
+![Gem Version](https://img.shields.io/gem/v/childprocess)
 [![Code Climate](https://codeclimate.com/github/enkessler/childprocess.svg)](https://codeclimate.com/github/enkessler/childprocess)
 [![Coverage Status](https://coveralls.io/repos/enkessler/childprocess/badge.svg?branch=master)](https://coveralls.io/r/enkessler/childprocess?branch=master)
 
@@ -16,8 +15,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 +70,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 +135,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 +181,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

@@ -20,6 +20,8 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.4.0'
 
+  s.add_dependency "logger", "~> 1.5"
+
   s.add_development_dependency "rspec", "~> 3.0"
   s.add_development_dependency "yard", "~> 0.0"
   s.add_development_dependency 'coveralls', '< 1.0'

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