cheetah 0.4.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd4cbe464be1d5ee56434c1a380d958cf0cbcb40095d8f21fcfb3cf7b2320db2
+  data.tar.gz: 3572805d086b24911c1feb6169b5911723a918fcf1ca0547d2f28984e0827ade
+SHA512:
+  metadata.gz: 032f86dbf253379e1663e01d03f8a5a013a13829e4bb5b9c3f880d73611a2c92176e51086402b604cfd20a30d28dfa1571766b9fa2e4eb5377e4c12a6bda1b39
+  data.tar.gz: 1ecf8c2ff66d2eef73b658f925bbb5a7c6292861ce4fd52a9f2ed6fab91e49f3ba25fe5cd84f8da294b6340887872c9ef5100f2799fa8f8c319afbcead8ced3e

data/CHANGELOG

@@ -1,11 +1,46 @@
+1.0.0 (2021-11-30)
+------------------
+
+* Add support for ruby 3.0
+  As side effect now Recorder#record_status receive additional parameter
+
+0.5.2 (2020-01-06)
+------------------
+
+* If listed in allowed_exitstatus, log exit code as Info, not as Error
+  (bsc#1153749)
+* Added support for ruby 2.7
+
+0.5.1 (2019-10-16)
+------------------
+
+* Implement closing open fds after call to fork (bsc#1151960). This will work
+  only in linux system with mounted /proc. For other Unixes it works as before.
+* drop support for ruby that is EOL (2.3 and lower)
+* Added support for ruby 2.4, 2.5, 2.6
+
+0.5.0 (2015-12-18)
+------------------
+
+* Added chroot option for executing in different system root.
+* Added ENV overwrite option.
+* Allowed to specify known exit codes that are not errors.
+* Documented how to execute in different working directory.
+* Allowed passing nil as :stdin to be same as :stdout and :strerr.
+* Converted parameters for command to strings with `.to_s`.
+* Adapted testsuite to new rspec.
+* Updated documentation with various fixes.
+* Dropped support for Ruby 1.9.3.
+* Added support for Ruby 2.1 and 2.2.
+
 0.4.0 (2013-11-21)
 ------------------
 
 * Implemented incremental logging. The input and both outputs of the executed
   command are now logged one-by-line by the default recorder. A custom recorder
   can record them on even finer granularity.
-* Dropped support of Ruby 1.8.7.
-* Added support of Ruby 2.0.0.
+* Dropped support for Ruby 1.8.7.
+* Added support for Ruby 2.0.0.
 * Internal code improvements.
 
 0.3.0 (2012-06-21)

data/README.md

@@ -1,5 +1,9 @@
 Cheetah
 =======
+[![Travis Build](https://travis-ci.org/openSUSE/cheetah.svg?branch=master)](https://travis-ci.org/openSUSE/cheetah)
+[![Code Climate](https://codeclimate.com/github/openSUSE/cheetah/badges/gpa.svg)](https://codeclimate.com/github/openSUSE/cheetah)
+[![Coverage Status](https://img.shields.io/coveralls/openSUSE/cheetah.svg)](https://coveralls.io/r/openSUSE/cheetah?branch=master)
+
 
 Your swiss army knife for executing external commands in Ruby safely and
 conveniently.
@@ -9,11 +13,11 @@ Examples
 
 ```ruby
 # Run a command and capture its output
-files = Cheetah.run("ls", "-la", :stdout => :capture)
+files = Cheetah.run("ls", "-la", stdout: :capture)
 
 # Run a command and capture its output into a stream
 File.open("files.txt", "w") do |stdout|
-  Cheetah.run("ls", "-la", :stdout => stdout)
+  Cheetah.run("ls", "-la", stdout: stdout)
 end
 
 # Run a command and handle errors
@@ -22,7 +26,7 @@ begin
 rescue Cheetah::ExecutionFailed => e
   puts e.message
   puts "Standard output: #{e.stdout}"
-  puts "Error ouptut:    #{e.stderr}"
+  puts "Error output:    #{e.stderr}"
 end
 ```
 
@@ -34,7 +38,11 @@ Features
   * Piping commands together
   * 100% secure (shell expansion is impossible by design)
   * Raises exceptions on errors (no more manual status code checks)
+    but allows to specify which non-zero codes are not an error
+  * Thread-safety
+  * Allows overriding environment variables
   * Optional logging for easy debugging
+  * Running on changed root ( requires chroot permission )
 
 Non-features
 ------------
@@ -63,13 +71,16 @@ To run a command, just specify it together with its arguments:
 
 ```ruby
 Cheetah.run("tar", "xzf", "foo.tar.gz")
+
+Cheetah converts each argument to a string using `#to_s`.
+
 ```
 ### Passing Input
 
 Using the `:stdin` option you can pass a string to command's standard input:
 
 ```ruby
-Cheetah.run("python", :stdin => source_code)
+Cheetah.run("python", stdin: source_code)
 ```
 
 If the input is big you may want to avoid passing it in one huge string. In that
@@ -78,7 +89,7 @@ input from it gradually.
 
 ```ruby
 File.open("huge_program.py") do |stdin|
-  Cheetah.run("python", :stdin => stdin)
+  Cheetah.run("python", stdin: stdin)
 end
 ```
 
@@ -88,7 +99,7 @@ To capture command's standard output, set the `:stdout` option to `:capture`.
 You will receive the output as a return value of the call:
 
 ```ruby
-files = Cheetah.run("ls", "-la", :stdout => :capture)
+files = Cheetah.run("ls", "-la", stdout: :capture)
 ```
 
 The same technique works with the error output — just use the `:stderr` option.
@@ -96,7 +107,7 @@ If you specify capturing of both outputs, the return value will be a two-element
 array:
 
 ```ruby
-results, errors = Cheetah.run("grep", "-r", "User", ".", :stdout => :capture, :stderr => :capture)
+results, errors = Cheetah.run("grep", "-r", "User", ".", stdout: => :capture, stderr: => :capture)
 ```
 
 If the output is big you may want to avoid capturing it into a huge string. In
@@ -105,7 +116,7 @@ command will write its output into it gradually.
 
 ```ruby
 File.open("files.txt", "w") do |stdout|
-  Cheetah.run("ls", "-la", :stdout => stdout)
+  Cheetah.run("ls", "-la", stdout: stdout)
 end
 ```
 
@@ -115,12 +126,12 @@ You can pipe multiple commands together and execute them as one. Just specify
 the commands together with their arguments as arrays:
 
 ```ruby
-processes = Cheetah.run(["ps", "aux"], ["grep", "ruby"], :stdout => :capture)
+processes = Cheetah.run(["ps", "aux"], ["grep", "ruby"], stdout: :capture)
 ```
 
 ### Error Handling
 
-If the command can't be executed for some reason or returns a non-zero exit
+If the command can't be executed for some reason or returns an unexpected non-zero exit
 status, Cheetah raises an exception with detailed information about the failure:
 
 ```ruby
@@ -130,7 +141,8 @@ begin
 rescue Cheetah::ExecutionFailed => e
   puts e.message
   puts "Standard output: #{e.stdout}"
-  puts "Error ouptut:    #{e.stderr}"
+  puts "Error output:    #{e.stderr}"
+  puts "Exit status:     #{e.status.exitstatus}"
 end
 ```
 ### Logging
@@ -139,7 +151,55 @@ For debugging purposes, you can use a logger. Cheetah will log the command, its
 status, input and both outputs to it:
 
 ```ruby
-Cheetah.run("ls -l", :logger => logger)
+Cheetah.run("ls -l", logger: logger)
+```
+
+### Overwriting env
+
+If the command needs adapted environment variables, use the :env option.
+Passed hash is used to update existing env (for details see ENV.update).
+Nil value means unset variable. Environment is restored to its original state after
+running the command.
+
+```ruby
+  Cheetah.run("env", env: { "LC_ALL" => "C" })
+```
+
+### Expecting Non-zero Exit Status
+
+If command is expected to return valid a non-zero exit status like `grep` command
+which return `1` if given regexp is not found, then option `:allowed_exitstatus`
+can be used:
+
+```ruby
+# Run a command, handle exitstatus  and handle errors
+begin
+  exitstatus = Cheetah.run("grep", "userA", "/etc/passwd", allowed_exitstatus: 1)
+  if exitstates == 0
+    puts "found"
+  else
+    puts "not found"
+  end
+rescue Cheetah::ExecutionFailed => e
+  puts e.message
+  puts "Standard output: #{e.stdout}"
+  puts "Error output:    #{e.stderr}"
+  puts "Exit status:     #{e.status.exitstatus}"
+end
+```
+
+Exit status is returned as last element of result. If it is only captured thing,
+then it is return without array.
+Supported input for `allowed_exitstatus` are anything supporting include, fixnum
+or nil for no allowed existatus.
+
+```ruby
+# allowed inputs
+allowed_exitstatus: 1
+allowed_exitstatus: 1..5
+allowed_exitstatus: [1, 2]
+allowed_exitstatus: object_with_include_method
+allowed_exitstatus: nil
 ```
 
 ### Setting Defaults
@@ -149,13 +209,33 @@ To avoid repetition, you can set global default value of any option passed too
 
 ```ruby
 # If you're tired of passing the :logger option all the time...
-Cheetah.default_options = { :logger = my_logger }
+Cheetah.default_options = { :logger => my_logger }
 Cheetah.run("./configure")
 Cheetah.run("make")
 Cheetah.run("make", "install")
 Cheetah.default_options = {}
 ```
 
+### Changing Working Directory
+
+If diferent working directory is needed for running program, then suggested
+usage is to enclose call into `Dir.chdir` method.
+
+```ruby
+Dir.chdir("/workspace") do
+  Cheetah.run("make")
+end
+```
+
+### Changing System Root
+
+If a command needs to be executed in different system root then the `:chroot`
+option can be used:
+
+```ruby
+Cheetah.run("/usr/bin/inspect", chroot: "/mnt/target_system")
+```
+
 ### More Information
 
 For more information, see the
@@ -164,7 +244,7 @@ For more information, see the
 Compatibility
 -------------
 
-Cheetah should run well on any Unix system with Ruby 1.9.3 or 2.0.0. Non-Unix
+Cheetah should run well on any Unix system with Ruby 2.0.0, 2.1 and 2.2. Non-Unix
 systems and different Ruby implementations/versions may work too but they were
 not tested.
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+1.0.0

data/lib/cheetah/version.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
+# Cheetah namespace
 module Cheetah
   # Cheetah version (uses [semantic versioning](http://semver.org/)).
-  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").strip
+  VERSION = File.read("#{File.dirname(__FILE__)}/../../VERSION").strip
 end

data/lib/cheetah.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "abstract_method"
 require "logger"
 require "shellwords"
 require "stringio"
 
-require File.expand_path(File.dirname(__FILE__) + "/cheetah/version")
+require File.expand_path("#{File.dirname(__FILE__)}/cheetah/version")
 
 # Your swiss army knife for executing external commands in Ruby safely and
 # conveniently.
@@ -22,11 +24,11 @@ require File.expand_path(File.dirname(__FILE__) + "/cheetah/version")
 #   * Handling of interactive commands
 #
 # @example Run a command and capture its output
-#   files = Cheetah.run("ls", "-la", :stdout => :capture)
+#   files = Cheetah.run("ls", "-la", stdout: :capture)
 #
 # @example Run a command and capture its output into a stream
 #   File.open("files.txt", "w") do |stdout|
-#     Cheetah.run("ls", "-la", :stdout => stdout)
+#     Cheetah.run("ls", "-la", stdout: stdout)
 #   end
 #
 # @example Run a command and handle errors
@@ -119,17 +121,22 @@ module Cheetah
     #
     #   @abstract
     #   @param [Process::Status] status the executed command exit status
+    #   @param [Boolean] allowed_status whether the exit code is in the list of allowed exit codes
     abstract_method :record_status
   end
 
   # A recorder that does not record anyting. Used by {Cheetah.run} when no
   # logger is passed.
   class NullRecorder < Recorder
-    def record_commands(commands); end
-    def record_stdin(stdin);       end
-    def record_stdout(stdout);     end
-    def record_stderr(stderr);     end
-    def record_status(status);     end
+    def record_commands(_commands); end
+
+    def record_stdin(_stdin);       end
+
+    def record_stdout(_stdout);     end
+
+    def record_stderr(_stderr);     end
+
+    def record_status(_status, _allowed_status); end
   end
 
   # A default recorder. It uses the `Logger::INFO` level for normal messages and
@@ -138,16 +145,18 @@ module Cheetah
   class DefaultRecorder < Recorder
     # @private
     STREAM_INFO = {
-      :stdin  => { :name => "Standard input",  :method => :info  },
-      :stdout => { :name => "Standard output", :method => :info  },
-      :stderr => { :name => "Error output",    :method => :error }
-    }
+      stdin: { name: "Standard input", method: :info },
+      stdout: { name: "Standard output", method: :info  },
+      stderr: { name: "Error output",    method: :error }
+    }.freeze
 
     def initialize(logger)
+      super()
+
       @logger = logger
 
-      @stream_used   = { :stdin => false, :stdout => false, :stderr => false }
-      @stream_buffer = { :stdin => "",    :stdout => "",    :stderr => "" }
+      @stream_used   = { stdin: false, stdout: false, stderr: false }
+      @stream_buffer = { stdin: +"", stdout: +"", stderr: +"" }
     end
 
     def record_commands(commands)
@@ -166,24 +175,25 @@ module Cheetah
       log_stream_increment(:stderr, stderr)
     end
 
-    def record_status(status)
+    def record_status(status, allowed_status)
       log_stream_remainder(:stdin)
       log_stream_remainder(:stdout)
       log_stream_remainder(:stderr)
 
-      @logger.send status.success? ? :info : :error,
-        "Status: #{status.exitstatus}"
+      @logger.send allowed_status ? :info : :error,
+                   "Status: #{status.exitstatus}"
     end
 
     protected
 
     def format_commands(commands)
-      '"' + commands.map { |c| Shellwords.join(c) }.join(" | ") + '"'
+      "\"#{commands.map { |c| Shellwords.join(c) }.join(' | ')}\""
     end
 
     def log_stream_increment(stream, data)
       @stream_buffer[stream] + data =~ /\A((?:.*\n)*)(.*)\z/
-      lines, rest = $1, $2
+      lines = Regexp.last_match(1)
+      rest = Regexp.last_match(2)
 
       lines.each_line { |l| log_stream_line(stream, l) }
 
@@ -192,9 +202,9 @@ module Cheetah
     end
 
     def log_stream_remainder(stream)
-      if @stream_used[stream] && !@stream_buffer[stream].empty?
-        log_stream_line(stream, @stream_buffer[stream])
-      end
+      return if !@stream_used[stream] || @stream_buffer[stream].empty?
+
+      log_stream_line(stream, @stream_buffer[stream])
     end
 
     def log_stream_line(stream, line)
@@ -207,11 +217,13 @@ module Cheetah
 
   # @private
   BUILTIN_DEFAULT_OPTIONS = {
-    :stdin              => "",
-    :stdout             => nil,
-    :stderr             => nil,
-    :logger             => nil
-  }
+    stdin: "",
+    stdout: nil,
+    stderr: nil,
+    logger: nil,
+    env: {},
+    chroot: "/"
+  }.freeze
 
   READ  = 0 # @private
   WRITE = 1 # @private
@@ -225,7 +237,7 @@ module Cheetah
     # By default, no values are specified here.
     #
     # @example Setting a logger once for execution of multiple commands
-    #   Cheetah.default_options = { :logger = my_logger }
+    #   Cheetah.default_options = { logger: my_logger }
     #   Cheetah.run("./configure")
     #   Cheetah.run("make")
     #   Cheetah.run("make", "install")
@@ -244,7 +256,7 @@ module Cheetah
     # multiple command case, the execution succeeds if the last command can be
     # executed and returns a zero exit status.)
     #
-    # Commands and their arguments never undergo shell expansion — they are
+    # Commands and their arguments never undergo shell expansion - they are
     # passed directly to the operating system. While this may create some
     # inconvenience in certain cases, it eliminates a whole class of security
     # bugs.
@@ -296,6 +308,14 @@ module Cheetah
     #     execution
     #   @option options [Recorder, nil] :recorder (DefaultRecorder.new) recorder
     #     to handle the command execution logging
+    #   @option options [Fixnum, .include?, nil] :allowed_exitstatus (nil)
+    #     Allows to specify allowed exit codes that do not cause exception. It
+    #     adds as last element of result exitstatus.
+    #   @option options [Hash] :env ({})
+    #     Allows to update ENV for the time of running the command. if key maps to nil value it
+    #     is deleted from ENV.
+    #   @option options [String] :chroot ("/")
+    #     Allows to run on different system root.
     #
     #   @example
     #     Cheetah.run("tar", "xzf", "foo.tar.gz")
@@ -325,16 +345,16 @@ module Cheetah
     #     in the first variant
     #
     #   @example
-    #     processes = Cheetah.run(["ps", "aux"], ["grep", "ruby"], :stdout => :capture)
+    #     processes = Cheetah.run(["ps", "aux"], ["grep", "ruby"], stdout: :capture)
     #
     # @raise [ExecutionFailed] when the execution fails
     #
     # @example Run a command and capture its output
-    #   files = Cheetah.run("ls", "-la", :stdout => capture)
+    #   files = Cheetah.run("ls", "-la", stdout: :capture)
     #
     # @example Run a command and capture its output into a stream
     #   File.open("files.txt", "w") do |stdout|
-    #     Cheetah.run("ls", "-la", :stdout => stdout)
+    #     Cheetah.run("ls", "-la", stdout: stdout)
     #   end
     #
     # @example Run a command and handle errors
@@ -345,10 +365,35 @@ module Cheetah
     #     puts "Standard output: #{e.stdout}"
     #     puts "Error ouptut:    #{e.stderr}"
     #   end
+    #
+    # @example Run a command with expected false and handle errors
+    #   begin
+    #     # exit code 1 for grep mean not found
+    #     result = Cheetah.run("grep", "userA", "/etc/passwd", allowed_exitstatus: 1)
+    #     if result == 0
+    #       puts "found"
+    #     else
+    #       puts "not found"
+    #     end
+    #   rescue Cheetah::ExecutionFailed => e
+    #     puts e.message
+    #     puts "Standard output: #{e.stdout}"
+    #     puts "Error ouptut:    #{e.stderr}"
+    #   end
+    #
+    # @example more complex example with allowed_exitstatus
+    #   stdout, exitcode = Cheetah.run("cmd", stdout: :capture, allowed_exitstatus: 1..5)
+    #
+
     def run(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       options = BUILTIN_DEFAULT_OPTIONS.merge(@default_options).merge(options)
 
+      options[:stdin] ||= "" # allow passing nil stdin see issue gh#11
+      if !options[:allowed_exitstatus].respond_to?(:include?)
+        options[:allowed_exitstatus] = Array(options[:allowed_exitstatus])
+      end
+
       streamed = compute_streamed(options)
       streams  = build_streams(options, streamed)
       commands = build_commands(args)
@@ -356,39 +401,63 @@ module Cheetah
 
       recorder.record_commands(commands)
 
-      pid, pipes = fork_commands(commands)
+      pid, pipes = fork_commands(commands, options)
       select_loop(streams, pipes, recorder)
-      pid, status = Process.wait2(pid)
+      _pid, status = Process.wait2(pid)
+
+      # when more exit status are allowed, then pass it below that it did
+      # not fail (bsc#1153749)
+      success = allowed_status?(status, options)
 
       begin
-        check_errors(commands, status, streams, streamed)
+        report_errors(commands, status, streams, streamed) if !success
       ensure
-        recorder.record_status(status)
+        # backward compatibility for recorders with just single parameter
+        if recorder.method(:record_status).arity == 1
+          recorder.record_status(status)
+        else
+          recorder.record_status(status, success)
+        end
       end
 
-      build_result(streams, options)
+      build_result(streams, status, options)
     end
 
     private
 
+    def allowed_status?(status, options)
+      exit_status = status.exitstatus
+      return exit_status.zero? unless allowed_exitstatus?(options)
+
+      options[:allowed_exitstatus].include?(exit_status)
+    end
+
     # Parts of Cheetah.run
 
+    def with_env(env, &block)
+      old_env = ENV.to_hash
+      ENV.update(env)
+      block.call
+    ensure
+      ENV.replace(old_env)
+    end
+
     def compute_streamed(options)
       # The assumption for :stdout and :stderr is that anything except :capture
       # and nil is an IO-like object. We avoid detecting it directly to allow
       # passing StringIO, mocks, etc.
       {
-        :stdin  => !options[:stdin].is_a?(String),
-        :stdout => ![nil, :capture].include?(options[:stdout]),
-        :stderr => ![nil, :capture].include?(options[:stderr])
+        stdin: !options[:stdin].is_a?(String),
+        stdout: ![nil, :capture].include?(options[:stdout]),
+        stderr: ![nil, :capture].include?(options[:stderr])
       }
     end
 
     def build_streams(options, streamed)
       {
-        :stdin  => streamed[:stdin]  ? options[:stdin]  : StringIO.new(options[:stdin]),
-        :stdout => streamed[:stdout] ? options[:stdout] : StringIO.new(""),
-        :stderr => streamed[:stderr] ? options[:stderr] : StringIO.new("")
+        stdin: streamed[:stdin] ? options[:stdin] : StringIO.new(options[:stdin]),
+        stdout: streamed[:stdout] ? options[:stdout] : StringIO.new(+""),
+        stderr: streamed[:stderr] ? options[:stderr] : StringIO.new(+"")
       }
     end
 
@@ -410,7 +479,8 @@ module Cheetah
       # The following code ensures that the result consistently (in all three
       # cases) contains an array of arrays specifying commands and their
       # arguments.
-      args.all? { |a| a.is_a?(Array) } ? args : [args]
+      commands = args.all? { |a| a.is_a?(Array) } ? args : [args]
+      commands.map { |c| c.map(&:to_s) }
     end
 
     def build_recorder(options)
@@ -421,54 +491,106 @@ module Cheetah
       end
     end
 
-    def fork_commands_recursive(commands, pipes)
-      fork do
-        begin
-          if commands.size == 1
-            pipes[:stdin][WRITE].close
-            STDIN.reopen(pipes[:stdin][READ])
-            pipes[:stdin][READ].close
-          else
-            pipe_to_child = IO.pipe
-
-            fork_commands_recursive(commands[0..-2], {
-              :stdin  => pipes[:stdin],
-              :stdout => pipe_to_child,
-              :stderr => pipes[:stderr]
-            })
-
-            pipes[:stdin][READ].close
-            pipes[:stdin][WRITE].close
-
-            pipe_to_child[WRITE].close
-            STDIN.reopen(pipe_to_child[READ])
-            pipe_to_child[READ].close
-          end
+    # Reopen *stream* to write **into** the writing half of *pipe*
+    # and close the reading half of *pipe*.
+    # @param pipe [Array<IO>] a pair of IOs as returned from IO.pipe
+    # @param stream [IO]
+    def into_pipe(stream, pipe)
+      stream.reopen(pipe[WRITE])
+      pipe[WRITE].close
+      pipe[READ].close
+    end
+
+    # Reopen *stream* to read **from** the reading half of *pipe*
+    # and close the writing half of *pipe*.
+    # @param pipe [Array<IO>] a pair of IOs as returned from IO.pipe
+    # @param stream [IO]
+    def from_pipe(stream, pipe)
+      stream.reopen(pipe[READ])
+      pipe[READ].close
+      pipe[WRITE].close
+    end
+
+    def chroot_step(options)
+      return options if [nil, "/"].include?(options[:chroot])
 
-          pipes[:stdout][READ].close
-          STDOUT.reopen(pipes[:stdout][WRITE])
-          pipes[:stdout][WRITE].close
+      options = options.dup
+      # delete chroot option otherwise in pipe will chroot each fork recursively
+      root = options.delete(:chroot)
+      Dir.chroot(root)
+      # curdir can be outside chroot which is considered as security problem
+      Dir.chdir("/")
 
-          pipes[:stderr][READ].close
-          STDERR.reopen(pipes[:stderr][WRITE])
-          pipes[:stderr][WRITE].close
+      options
+    end
+
+    def fork_commands_recursive(commands, pipes, options)
+      fork do
+        # support chrooting
+        options = chroot_step(options)
+
+        if commands.size == 1
+          from_pipe($stdin, pipes[:stdin])
+        else
+          pipe_to_child = IO.pipe
+
+          fork_commands_recursive(commands[0..-2],
+                                  {
+                                    stdin: pipes[:stdin],
+                                    stdout: pipe_to_child,
+                                    stderr: pipes[:stderr]
+                                  },
+                                  options)
+
+          pipes[:stdin][READ].close
+          pipes[:stdin][WRITE].close
+
+          from_pipe($stdin, pipe_to_child)
+        end
 
-          # All file descriptors from 3 above should be closed here, but since I
-          # don't know about any way how to detect the maximum file descriptor
-          # number portably in Ruby, I didn't implement it. Patches welcome.
+        into_pipe($stdout, pipes[:stdout])
+        into_pipe($stderr, pipes[:stderr])
 
-          command, *args = commands.last
+        close_fds
+
+        command, *args = commands.last
+        with_env(options[:env]) do
           exec([command, command], *args)
-        rescue SystemCallError => e
-          exit!(127)
         end
+      rescue SystemCallError => e
+        # depends when failed, if pipe is already redirected or not, so lets find it
+        output = pipes[:stderr][WRITE].closed? ? $stderr : pipes[:stderr][WRITE]
+        output.puts e.message
+
+        exit!(127)
       end
     end
 
-    def fork_commands(commands)
-      pipes = { :stdin => IO.pipe, :stdout => IO.pipe, :stderr => IO.pipe }
+    # closes all open fds starting with 3 and above
+    def close_fds
+      # NOTE: this will work only if unix has /proc filesystem. If it does not
+      # have it, it won't close other fds.
+      Dir.glob("/proc/self/fd/*").each do |path|
+        fd = File.basename(path).to_i
+        next if (0..2).include?(fd)
 
-      pid = fork_commands_recursive(commands, pipes)
+        # here we intentionally ignore some failures when fd close failed
+        # rubocop:disable Lint/SuppressedException
+        begin
+          IO.new(fd).close
+        # Ruby reserves some fds for its VM and it result in this exception
+        rescue ArgumentError
+        # Ignore if close failed with invalid FD
+        rescue Errno::EBADF
+        end
+        # rubocop:enable Lint/SuppressedException
+      end
+    end
+
+    def fork_commands(commands, options)
+      pipes = { stdin: IO.pipe, stdout: IO.pipe, stderr: IO.pipe }
+
+      pid = fork_commands_recursive(commands, pipes, options)
 
       [
         pipes[:stdin][READ],
@@ -508,11 +630,9 @@ module Cheetah
         break if pipes_readable.empty? && pipes_writable.empty?
 
         ios_read, ios_write, ios_error = select(pipes_readable, pipes_writable,
-          pipes_readable + pipes_writable)
+                                                pipes_readable + pipes_writable)
 
-        if !ios_error.empty?
-          raise IOError, "Error when communicating with executed program."
-        end
+        raise IOError, "Error when communicating with executed program." if !ios_error.empty?
 
         ios_read.each do |pipe|
           begin
@@ -540,46 +660,61 @@ module Cheetah
       end
     end
 
-    def check_errors(commands, status, streams, streamed)
+    def report_errors(commands, status, streams, streamed)
       return if status.success?
 
       stderr_part = if streamed[:stderr]
-        " (error output streamed away)"
-      elsif streams[:stderr].string.empty?
-        " (no error output)"
-      else
-        lines = streams[:stderr].string.split("\n")
-        ": " + lines.first + (lines.size > 1 ? " (...)" : "")
-      end
+                      " (error output streamed away)"
+                    elsif streams[:stderr].string.empty?
+                      " (no error output)"
+                    else
+                      lines = streams[:stderr].string.split("\n")
+                      ": #{lines.first}#{lines.size > 1 ? ' (...)' : ''}"
+                    end
 
       raise ExecutionFailed.new(
         commands,
         status,
         streamed[:stdout] ? nil : streams[:stdout].string,
         streamed[:stderr] ? nil : streams[:stderr].string,
-        "Execution of #{format_commands(commands)} " +
+        "Execution of #{format_commands(commands)} " \
           "failed with status #{status.exitstatus}#{stderr_part}."
       )
     end
 
-    def build_result(streams, options)
-      case [options[:stdout] == :capture, options[:stderr] == :capture]
-        when [false, false]
-          nil
-        when [true, false]
-          streams[:stdout].string
-        when [false, true]
-          streams[:stderr].string
-        when [true, true]
-          [streams[:stdout].string, streams[:stderr].string]
+    def build_result(streams, status, options)
+      res = case [options[:stdout] == :capture, options[:stderr] == :capture]
+            when [false, false]
+              nil
+            when [true, false]
+              streams[:stdout].string
+            when [false, true]
+              streams[:stderr].string
+            when [true, true]
+              [streams[:stdout].string, streams[:stderr].string]
+            end
+
+      if allowed_exitstatus?(options)
+        if res.nil?
+          res = status.exitstatus
+        else
+          res = Array(res)
+          res << status.exitstatus
+        end
       end
+
+      res
+    end
+
+    def allowed_exitstatus?(options)
+      # more exit status allowed for non array or non empty array
+      !options[:allowed_exitstatus].is_a?(Array) || !options[:allowed_exitstatus].empty?
     end
 
     def format_commands(commands)
-      '"' + commands.map { |c| Shellwords.join(c) }.join(" | ") + '"'
+      "\"#{commands.map { |c| Shellwords.join(c) }.join(' | ')}\""
     end
   end
 
   self.default_options = {}
 end
-

metadata

@@ -1,80 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: cheetah
 version: !ruby/object:Gem::Version
-  version: 0.4.0
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - David Majda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-21 00:00:00.000000000 Z
+date: 2021-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_method
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.11
 description: Your swiss army knife for executing external commands in Ruby safely
   and conveniently.
 email: dmajda@suse.de
@@ -91,28 +68,26 @@ files:
 homepage: https://github.com/openSUSE/cheetah
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.7.6.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Your swiss army knife for executing external commands in Ruby safely and
   conveniently.
 test_files: []
-has_rdoc: