shexecutor 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 610b8828b18a5c04454d349966788f26997f6f12
-  data.tar.gz: f9e6d63577e7acd0fb79001863c6f67a4f901e0e
+  metadata.gz: b7bd1eafe5b0bcf3c40dfb7abcb428642fd8f56a
+  data.tar.gz: 5b24e222f42885b8e4e3e4f231d44eb623f60f09
 SHA512:
-  metadata.gz: b91c99fd12ce80faaf82636b2bb4f4b055ca803674eb5f6298442d7d7bb5f6462719a42c085a3a273f66198c8d9e5ef14ce5ece0586dda73b96dc7f67c32216b
-  data.tar.gz: ce988ff050c5e011268683556073f43c8b2ff55d393052675a3e509d734d03cbea3a141818a18389d1ee070ec4579c48a3fb7ad6bd0077f2d0418580f694d2e7
+  metadata.gz: 562083bd0cd5db122e2332955518bb19cc403940bb98fdadc8edcaacc26724269dec003a28bfdcbff5107f1d0376357fd4e5e038ff1d806582091531253f111f
+  data.tar.gz: c46cd8e3d5f8835bf70bce083a02c692b75f35e87b818725e2dfee1e50104f0b66a48f7c99fdabb675f4dc54b7b43139abe55907f9293b108372b88f1dc61db2

data/.gitignore

@@ -2,3 +2,5 @@
 coverage
 *gem
 doc
+.~lock*
+Reviews.odt

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shexecutor (0.0.6)
+    shexecutor (0.0.7)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,19 +1,16 @@
 # SHExecutor
 
-SHExecutor is a convenience wrapper for executing shell commands from with-in a ruby process. It is intended to be used for the simple execution of shell commands or scripts that are not expected to generate GBs of output or require feeding via stdin.
+SHExecutor is a convenience wrapper for executing shell commands from with-in a ruby process.
 
 ## It supports:
 - blocking indefinitely, on exit you can get status, stdout and stderr
 - blocking with timeout, on exit you can get status, stdout, stderr, timeout exception (then output streams are not available)
 - non-blocking, then you get no output streams, but status of the forked process
 - replacement, then you get a replaced process and none of the above
-
-## It is intended to support (future release):
 - redirecting of stderr and stdout, separately, to file, with the option to overwrite or append
 
 ## It does not support:
 - streaming input to stdin
-- large stdout and stderr outputs that require real-time reading from the pipes
 
 ## For any executor:
 - you can ask status, which will tell you "not executed", current status (e.g. run or sleep) and "no longer executing"
@@ -57,7 +54,7 @@ puts "For more see: #{iut.result.methods}"
 ```
 iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => "/bin/sleep", :params => ["2"]})
 iut.execute
-# Timeout::Error gets raised and the spawned process is killed
+# Timeout::Error gets raised. The spawned process continues and needs to be managed separately if required.
 ```
 
 ###Non-blocking
@@ -83,6 +80,17 @@ iut.execute
 
 ```
 iut.flush
+puts iut.stdout
+puts iut.stderr
+```
+
+###redirecting stdout and stderr
+```
+iut = SHExecutor::Executor.new({:wait_for_completion => false, :application_path => "/bin/sleep", :params => ["1"], :stdout_path => "/tmp/mystdout", :stderr_path => "/tmp/mystderr", :append_stdout_path => false, :append_stderr_path => true})
+iut.execute
+iut.flush
+puts iut.stdout
+puts iut.stderr
 ```
 
   Remember to call iut.flush in order to stream stdout and stderr to the Executor object.

data/lib/shexecutor/version.rb

@@ -1,3 +1,3 @@
 module SHExecutor
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/lib/shexecutor.rb

@@ -6,7 +6,7 @@ module SHExecutor
     :timeout => -1,
     :protect_against_injection => true,
     :stdout_path => nil,
-    :strerr_path => nil,
+    :stderr_path => nil,
     :append_stdout_path => true,
     :append_stderr_path => true,
     :replace => false,
@@ -23,6 +23,8 @@ module SHExecutor
     attr_accessor :stderr
     attr_accessor :result
     attr_accessor :pid
+    attr_accessor :data_out
+    attr_accessor :data_err
 
     def initialize(options = ::SHExecutor::default_options)
       # set default options
@@ -47,16 +49,20 @@ module SHExecutor
       @result.value
     end
 
+    def possible_injection?(application_path)
+      (@options[:protect_against_injection]) and (@options[:application_path].include?(" ") or @options[:application_path].tainted?)
+    end
+
     def validate
       errors = []
-      if (!@options[:application_path].nil? and @options[:application_path].strip != "")
+      if (@options[:protect_against_injection]) and (!@options[:application_path].nil? and @options[:application_path].strip != "")
         if (File.exists?(@options[:application_path]))
           errors << "Application path not executable" if !File.executable?(@options[:application_path])
 	else
           errors << "Application path not found"
 	end
 
-       errors << "Suspected injection vulnerability due to space in application_path. Turn off strict checking if you are sure" if @options[:application_path].include?(" ")
+       errors << "Suspected injection vulnerability due to space in application_path or the object being marked as 'tainted' by Ruby. Turn off strict checking if you are sure by setting :protect_against_injection to false" if possible_injection?(@options[:application_path])
 
       else
         errors << "No application path provided" if (@options[:application_path].nil?) or (@options[:application_path].strip == "")
@@ -88,32 +94,82 @@ module SHExecutor
     # Check status? before calling this to see if the process has completed if you do not want to block
     def flush
       #store output for inspection
-      @stdout = @stdout_stream.gets(nil)
-      @stderr = @stderr_stream.gets(nil)
+      stdout_data = @data_out.string
+      stderr_data = @data_err.string
+      @stdout = stdout_data if stdout_data != ""
+      @stderr = stderr_data if stderr_data != ""
+      stdout_to_file if (@options[:stdout_path])
+      stderr_to_file if (@options[:stderr_path])
     end
 
     private
 
+    def buffer_to_file(buffer, path, append)
+      if not append
+        FileUtils.rm_f(path)
+      end
+      File.write(path, buffer, buffer.size, mode: 'a')
+    end
+
+    def stdout_to_file
+      buffer_to_file(@data_out.string, @options[:stdout_path], @options[:append_stdout_path]) if @options[:stdout_path]
+    end
+
+    def stderr_to_file
+      buffer_to_file(@data_err.string, @options[:stderr_path], @options[:append_stderr_path]) if @options[:stderr_path]
+    end
+
     def replace_process
       validate
       @options[:params].nil? ? exec(@options[:application_path]) : exec(@options[:application_path], *@options[:params]) 
     end
 
+    def run_process(application_path, options = "")
+      data_out = StringIO.new
+      data_err = StringIO.new
+      t0 = nil
+      Open3::popen3(application_path, options) do |stdin, stdout, stderr, thr|
+        t0 = thr
+        # read srderr and stdout into buffers to prevent blocking
+        t1 = Thread.new do
+          IO.copy_stream(stdout, data_out)
+        end
+        t2 = Thread.new do
+          IO.copy_stream(stderr, data_err)
+        end
+        stdin.close
+        #These streams should never produce IOErrors. If they do, memory is shot.
+        #Having them abort on exception interrupts TimeoutError, so turn abort of
+        #wanting to see timeouts
+        t1.abort_on_exception = false if should_timeout?
+        t2.abort_on_exception = false if should_timeout?
+        #No need to join here. t0 is joined by the caller.
+        #Explicitly join here if not configured for timeout to make the point that
+        #if you join here when configured for timeout, timeout will break, as the
+        #join will only finish when the thread finishes, i.e. the timeout exception
+        #will come too late
+        t1.join if not should_timeout?
+        t2.join if not should_timeout?
+      end
+      return data_out, data_err, t0
+    end
+
     def block_process
       validate
-      @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
+      @data_out, @data_err, @result = run_process(@options[:application_path], *@options[:params])
+      @result.join
       @result.value
     end
 
     def block_process_with_timeout
       validate
-      @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
       begin
         Timeout.timeout(@options[:timeout]) do
-          @result.value
+          @data_out, @data_err, @result = run_process(@options[:application_path], *@options[:params])
         end
+        @result.join
+        @result.value
       rescue Timeout::Error => ex
-        Process.kill 9, @result.pid
         raise ex
       end
     end
@@ -122,11 +178,11 @@ module SHExecutor
       validate
       @stdin_stream, @stdout_stream, @stderr_stream, @result = Open3::popen3(@options[:application_path], *@options[:params]) 
     end
+
+    private
+
+    def should_timeout?
+      @options[:timeout] > 0
+    end
   end
 end
-
-#def redirect_all_output_to_file file
-#   log = File.new(file, "w+")
-#   STDOUT.reopen log;  STDERR.reopen log
-#   STDOUT.sync = true
-#end

data/spec/executor_spec.rb

@@ -23,7 +23,7 @@ describe 'Executor' do
         :timeout => -1,
         :protect_against_injection=>true,
         :stdout_path => '/log/testlog',
-        :strerr_path => '/log/testlog',
+        :stderr_path => '/log/testlog',
         :append_stdout_path => false,
         :append_stderr_path => false,
         :replace => false,
@@ -64,13 +64,13 @@ describe 'Executor' do
       iut = SHExecutor::Executor.new({:application_path => f.path})
       expect{
         iut.validate
-      }.to raise_error(ArgumentError, "Application path not executable")
+      }.to raise_error(ArgumentError, "Application path not executable,Suspected injection vulnerability due to space in application_path or the object being marked as 'tainted' by Ruby. Turn off strict checking if you are sure by setting :protect_against_injection to false")
     end
   end
 
   context 'when initialized with valid options' do
     it 'validate should not raise an exception' do
-      iut = SHExecutor::Executor.new({:application_path => @executable_file.path})
+      iut = SHExecutor::Executor.new({:application_path => @executable_file.path, :protect_against_injection => false})
       iut.validate
     end
   end
@@ -99,7 +99,7 @@ describe 'Executor' do
       expect(Kernel::last_params).to eq(*test_params)
     end
 
-    it 'should use exec with the command if no parameters are specified' do
+    it 'should use exec with the command if no parameters are specified and replacing' do
       test_command = "/bin/ls"
       iut = SHExecutor::Executor.new({:replace => true, :application_path => test_command})
       iut.execute
@@ -107,6 +107,12 @@ describe 'Executor' do
       expect(Kernel::last_params).to be_nil
     end
 
+    it 'should use exec with the command if no parameters are specified and not waiting for completion' do
+      test_command = "/bin/ls"
+      iut = SHExecutor::Executor.new({:application_path => test_command, :wait_for_completion => true})
+      iut.execute
+    end
+
     it 'should validate' do
       iut = SHExecutor::Executor.new({:replace => true})
       expect{
@@ -201,42 +207,32 @@ describe 'Executor' do
   end
 
   context 'when asked to execute and block' do
-    it 'should raise a TimeoutException if a timeout is specified and the forked process does not exit before' do
+    it 'should raise a TimeoutException if a timeout is specified and the process does not exit before' do
       test_command = "/bin/sleep"
-      test_params = ["2"]
+      test_params = ["5"]
       iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => test_command, :params => test_params})
       before = Time.now
       expect {
         iut.execute
       }.to raise_error(Timeout::Error, "execution expired")
       after = Time.now
-      expect(after - before).to be < 2
-    end
-
-    it 'should kill the subprocess when a TimeoutException is raised' do
-      test_command = "/bin/sleep"
-      test_params = ["2"]
-      iut = SHExecutor::Executor.new({:timeout => 1, :wait_for_completion => true, :application_path => test_command, :params => test_params})
-      expect(Process).to receive(:kill)
-      expect {
-        iut.execute
-      }.to raise_error(Timeout::Error, "execution expired")
+      expect(after - before).to be < 2.1
     end
 
-    it 'should use Open3::popen3 with the command and parameters specified' do
+    it 'should call run_process with the command and parameters specified' do
       test_command = "/bin/ls"
       test_params = ["/tmp/"]
       iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command, :params => test_params})
       stdin = stdout = stderr = StringIO.new
-      expect(Open3).to receive(:popen3).with(test_command, *test_params).and_return([stdin, stdout, stderr, Result.new(true)])
+      expect(iut).to receive(:run_process).with(test_command, *test_params).and_return([stdout, stderr, Result.new(true)])
       iut.execute
     end
 
-    it 'should use Open3::popen3 with the command' do
+    it 'should use run_process with the command' do
       test_command = "/bin/ls"
       iut = SHExecutor::Executor.new({:wait_for_completion => true, :application_path => test_command})
       stdin = stdout = stderr = StringIO.new
-      expect(Open3).to receive(:popen3).with(test_command).and_return([stdin, stdout, stderr, Result.new(true)])
+      expect(iut).to receive(:run_process).with(test_command).and_return([stdout, stderr, Result.new(true)])
       iut.execute
     end
 
@@ -250,6 +246,21 @@ describe 'Executor' do
       expect(after - before).to be > 2
     end
 
+    it 'should block until completion and still have access to the ouput' do
+      file = Tempfile.new("testingargumenterror")
+      File.chmod(0744, file.path)
+      `echo "sleep 2" >> #{file.path}`
+      `echo "echo 'this did run'" >> #{file.path}`
+      test_command = file.path
+      iut = SHExecutor::Executor.new({:protect_against_injection => false, :wait_for_completion => true, :application_path => test_command})
+      before = Time.now
+      iut.execute
+      iut.flush
+      expect(iut.stdout).to eq("this did run\n")
+      after = Time.now
+      expect(after - before).to be > 2
+    end
+
     it 'should validate' do
       iut = SHExecutor::Executor.new({:wait_for_completion => true})
       expect{
@@ -259,27 +270,77 @@ describe 'Executor' do
   end
 
   context 'when asked to redirect stdout to a file appending' do
-    it 'should append stdout to the file specified, and create it if it does not exist'
-  end
+    before :each do
+      @stdout_test_path = '/tmp/append_stdout_path'
+      FileUtils.rm_f(@stdout_test_path)
+    end
 
-  context 'when asked to redirect stdout to a file overwriting' do
-    it 'should delete if exists and create the specified file, then append stdout to it'
-  end
+    def execute_stdout_test_command(append = true)
+      test_command = "/bin/echo"
+      test_params = ["hello world"]
+      @iut = SHExecutor::Executor.new({:append_stdout_path => append, :stdout_path => @stdout_test_path, :wait_for_completion => true, :application_path => test_command, :params => test_params})
+      @iut.execute
+      @iut.flush
+      File.open(@stdout_test_path).read
+    end
+
+    it 'should append stdout to the file specified, and create it if it does not exist' do
+      expect(execute_stdout_test_command).to eq("hello world\n")
+    end
+
+    it 'should append stdout to the file specified, if it exists' do
+      `echo "line 1" >> #{@stdout_test_path}`
+      expect(execute_stdout_test_command).to eq("line 1\nhello world\n")
+    end
 
-  context 'when asked to redirect stdout' do
-    it 'should raise an exception if one of the file operations fails'
+    it 'should delete if exists and create the specified file, then write to it if append is not set' do
+      `echo "line 1" >> #{@stdout_test_path}`
+      expect(execute_stdout_test_command(false)).to eq("hello world\n")
+    end
+
+    it 'should raise an exception if one of the file operations fails' do
+      @stdout_test_path = "/tmp/thisdirectorydoesnotexistdshlgh58iyg89rlehg8y/gn.dfllgyls54gh57479gh"
+      expect {
+        execute_stdout_test_command
+      }.to raise_error(Errno::ENOENT, "No such file or directory - /tmp/thisdirectorydoesnotexistdshlgh58iyg89rlehg8y/gn.dfllgyls54gh57479gh")
+    end
   end
 
   context 'when asked to redirect stderr to a file appending' do
-    it 'should append stderr to the file specified, and create it if it does not exist'
-  end
+    before :each do
+      @stderr_test_path = '/tmp/append_stderr_path'
+      FileUtils.rm_f(@stderr_test_path)
+    end
 
-  context 'when asked to redirect stderr to a file overwriting' do
-    it 'should delete if exists and create the specified file, then append stderr to it'
-  end
+    def execute_stderr_test_command(append = true)
+      test_command = "/bin/ls"
+      test_params = ["/tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0"]
+      @iut = SHExecutor::Executor.new({:append_stderr_path => append, :stderr_path => @stderr_test_path, :wait_for_completion => true, :application_path => test_command, :params => test_params})
+      @iut.execute
+      @iut.flush
+      File.open(@stderr_test_path).read
+    end
+
+    it 'should append stderr to the file specified, and create it if it does not exist' do
+      expect(execute_stderr_test_command).to eq("ls: /tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0: No such file or directory\n")
+    end
 
-  context 'when asked to redirect stderr' do
-    it 'should raise an exception if one of the file operations fails'
+    it 'should append stderr to the file specified, if it exists' do
+      `echo "line 1" >> #{@stderr_test_path}`
+      expect(execute_stderr_test_command).to eq("line 1\nls: /tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0: No such file or directory\n")
+    end
+
+    it 'should delete if exists and create the specified file, then write to it if append is not set' do
+      `echo "line 1" >> #{@stderr_test_path}`
+      expect(execute_stderr_test_command(false)).to eq("ls: /tmp/thisfiledoesnotexistsatgup80wh0hgoefhgohuo4whg4whg4w5hg0: No such file or directory\n")
+    end
+
+    it 'should raise an exception if one of the file operations fails' do
+      @stderr_test_path = "/tmp/thisdirectorydoesnotexistdshlgh58iyg89rlehg8y/gn.dfllgyls54gh57479gh"
+      expect {
+        execute_stderr_test_command
+      }.to raise_error(Errno::ENOENT, "No such file or directory - /tmp/thisdirectorydoesnotexistdshlgh58iyg89rlehg8y/gn.dfllgyls54gh57479gh")
+    end
   end
 
   context 'when asked to flush' do

data/spec/mocks/result.rb

@@ -4,4 +4,7 @@ class Result
   def initialize(value)
     @value = value
   end
+
+  def join
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shexecutor
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Ernst van Graan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler