right_popen 1.0.20-x86-mswin32-60 → 1.0.21-x86-mswin32-60

data/lib/right_popen/version.rb

@@ -23,6 +23,6 @@
 
 module RightScale
   module RightPopen
-    VERSION = "1.0.20"
+    VERSION = "1.0.21"
   end
 end

data/spec/produce_mixed_output.rb

@@ -1,8 +1,9 @@
 count = ARGV[0] ? ARGV[0].to_i : 1
+exit_code = ARGV[1] ? ARGV[1].to_i : 0
 
 count.times do |i|
   $stderr.puts "stderr #{i}" if 0 == i % 10
   $stdout.puts "stdout #{i}"
 end
 
-exit 99
+exit exit_code

data/spec/right_popen_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'runner'))
+require 'stringio'
 
 module RightScale
   describe 'popen3' do
@@ -105,24 +106,62 @@ module RightScale
       status.pid.should > 0
     end
 
-    it 'should preserve the integrity of stdout and stderr despite interleaving' do
-      count = LARGE_OUTPUT_COUNTER
-      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{count}"
+    it 'should preserve interleaved output when yielding CPU on consumer thread' do
+      lines = 11
+      exit_code = 42
+      repeats = 5
+      force_yield = 0.1
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{lines} #{exit_code}"
+      runner = Runner.new
+      actual_output = StringIO.new
+      actual_error = StringIO.new
+      puts
+      stats = runner.run_right_popen(command, :repeats=>repeats, :force_yield=>force_yield) do |status|
+        status.status.exitstatus.should == exit_code
+        status.pid.should > 0
+        actual_output << status.output_text
+        actual_error << status.error_text
+        print '+'
+      end
+      puts
+      stats.size.should == repeats
+
+      expected_output = StringIO.new
+      repeats.times do
+        lines.times do |i|
+          expected_output << "stdout #{i}\n"
+        end
+      end
+      actual_output.string.should == expected_output.string
+
+      expected_error = StringIO.new
+      repeats.times do
+        lines.times do |i|
+          (expected_error << "stderr #{i}\n") if 0 == i % 10
+        end
+      end
+      actual_error.string.should == expected_error.string
+    end
+
+    it 'should preserve interleaved output when process is spewing rapidly' do
+      lines = LARGE_OUTPUT_COUNTER
+      exit_code = 99
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{lines} #{exit_code}"
       runner = Runner.new
       status = runner.run_right_popen(command)
-      status.status.exitstatus.should == 99
+      status.status.exitstatus.should == exit_code
 
-      results = ''
-      count.times do |i|
-        results << "stdout #{i}\n"
+      expected_output = StringIO.new
+      lines.times do |i|
+        expected_output << "stdout #{i}\n"
       end
-      status.output_text.should == results
+      status.output_text.should == expected_output.string
 
-      results = ''
-      count.times do |i|
-        (results << "stderr #{i}\n") if 0 == i % 10
+      expected_error = StringIO.new
+      lines.times do |i|
+        (expected_error << "stderr #{i}\n") if 0 == i % 10
       end
-      status.error_text.should == results
+      status.error_text.should == expected_error.string
       status.pid.should > 0
     end
 
@@ -132,7 +171,7 @@ module RightScale
       status = runner.run_right_popen(command)
       status.status.exitstatus.should == 0
       status.output_text.should_not include('_test_')
-      status = runner.run_right_popen(command, :__test__ => '42')
+      status = runner.run_right_popen(command, :env=>{ :__test__ => '42' })
       status.status.exitstatus.should == 0
       status.output_text.should match(/^__test__=42$/)
       status.pid.should > 0
@@ -145,7 +184,7 @@ module RightScale
         ENV.each { |k, v| old_envs[k] = v }
         command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
         runner = Runner.new
-        status = runner.run_right_popen(command, :__test__ => '42')
+        status = runner.run_right_popen(command, :env=>{ :__test__ => '42' })
         status.status.exitstatus.should == 0
         status.output_text.should match(/^__test__=42$/)
         ENV.each { |k, v| old_envs[k].should == v }
@@ -162,7 +201,7 @@ module RightScale
       it 'should merge the PATH variable instead of overriding it' do
         command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
         runner = Runner.new
-        status = runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
+        status = runner.run_right_popen(command, :env=>{ 'PATH' => "c:/bogus\\bin" })
         status.status.exitstatus.should == 0
         status.output_text.should include('c:\\bogus\\bin;')
         status.pid.should > 0
@@ -204,17 +243,19 @@ module RightScale
       pending 'Set environment variable TEST_LEAK to enable' unless ENV['TEST_LEAK']
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
       runner = Runner.new
-      status = runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
-      status.status.exitstatus.should == 0
-      status.output_text.should == STANDARD_MESSAGE + "\n"
-      status.error_text.should == ERROR_MESSAGE + "\n"
-      status.pid.should > 0
+      stats = runner.run_right_popen(command, :repeats=>REPEAT_TEST_COUNTER)
+      stats.each do |status|
+        status.status.exitstatus.should == 0
+        status.output_text.should == STANDARD_MESSAGE + "\n"
+        status.error_text.should == ERROR_MESSAGE + "\n"
+        status.pid.should > 0
+      end
     end
 
     it 'should pass input to child process' do
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'increment.rb'))}\""
       runner = Runner.new
-      status = runner.run_right_popen(command, nil, "42\n")
+      status = runner.run_right_popen(command, :input=>"42\n")
       status.status.exitstatus.should == 0
       status.output_text.should == "43\n"
       status.error_text.should be_empty
@@ -225,7 +266,7 @@ module RightScale
 	  pending 'not implemented for windows' if is_windows?
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'stdout.rb'))}\""
       runner = Runner.new
-      status = runner.run_right_popen(command, nil, nil)
+      status = runner.run_right_popen(command, :expect_timeout=>true, :timeout=>2)
       status.did_timeout.should be_true
       status.output_text.should be_empty
       status.error_text.should == "Closing stdout\n"
@@ -235,7 +276,7 @@ module RightScale
 	  pending 'not implemented for windows' if is_windows?
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'background.rb'))}\""
       runner = Runner.new
-      status = runner.run_right_popen(command, nil, nil)
+      status = runner.run_right_popen(command)
       status.status.exitstatus.should == 0
       status.did_timeout.should be_false
       status.output_text.should be_empty

data/spec/runner.rb

@@ -24,18 +24,20 @@
 module RightScale
   class Runner
     class RunnerStatus
-      def initialize(command, block)
+      def initialize(command, options={}, &callback)
+        options = {:force_yield=>nil, :timeout=>nil, :expect_timeout=>false}.merge(options)
         @output_text = ""
         @error_text  = ""
         @status      = nil
         @did_timeout = false
-        @callback    = block
+        @callback    = callback
         @pid         = nil
+        @force_yield = options[:force_yield]
         EM.next_tick do
-          @timeout = EM::Timer.new(2) do
-            puts "\n** Failed to run #{command.inspect}: Timeout"
+          @timeout = EM::Timer.new(options[:timeout] || 2) do
+            puts "\n** Failed to run #{command.inspect}: Timeout" unless options[:expect_timeout]
             @did_timeout = true
-            @callback.call(self)
+            @callback.call(self) if options[:expect_timeout]
           end
         end
       end
@@ -43,10 +45,12 @@ module RightScale
       attr_accessor :output_text, :error_text, :status, :did_timeout, :pid
 
       def on_read_stdout(data)
+        sleep @force_yield if @force_yield
         @output_text << data
       end
 
       def on_read_stderr(data)
+        sleep @force_yield if @force_yield
         @error_text << data
       end
 
@@ -69,42 +73,51 @@ module RightScale
       @last_iteration = 0
     end
 
-    def do_right_popen(command, env=nil, input=nil, &callback)
-      status = RunnerStatus.new(command, callback)
+    def do_right_popen(command, options={}, &callback)
+      options = {:env=>nil, :input=>nil, :timeout=>nil, :force_yield=>nil, :expect_timeout=>false}.merge(options)
+      status = RunnerStatus.new(command, options, &callback)
       RightScale.popen3(:command        => command,
-                      :input          => input,
-                      :target         => status,
-                      :environment    => env,
-                      :stdout_handler => :on_read_stdout,
-                      :stderr_handler => :on_read_stderr,
-                      :pid_handler    => :on_pid,
-                      :exit_handler   => :on_exit)
+                        :input          => options[:input],
+                        :target         => status,
+                        :environment    => options[:env],
+                        :stdout_handler => :on_read_stdout,
+                        :stderr_handler => :on_read_stderr,
+                        :pid_handler    => :on_pid,
+                        :exit_handler   => :on_exit)
       status
     end
 
-    def run_right_popen(command, env=nil, input=nil, count=1)
+    def run_right_popen(command, options={}, &callback)
+      options = {:repeats=>1, :env=>nil, :input=>nil, :timeout=>nil, :force_yield=>nil, :expect_timeout=>false}.merge(options)
       begin
         @iterations = 0
+        @repeats = options[:repeats]
+        @stats = []
         EM.run do
-          EM.next_tick do
-            do_right_popen(command, env, input) do |status|
-              maybe_continue(status)
+          EM.defer do
+            do_right_popen(command, options) do |status|
+              maybe_continue(status, command, options, &callback)
             end
           end
         end
-        @status
+        @stats.size < 2 ? @stats.first : @stats
       rescue Exception => e
         puts "\n** Failed: #{e.message} FROM\n#{e.backtrace.join("\n")}"
         raise e
       end
     end
 
-    def maybe_continue(status)
+    def maybe_continue(status, command, options, &callback)
       @iterations += 1
-      if @iterations < @count
-        do_right_popen(command, env, input) {|status| maybe_continue(status)}
+      @stats << status
+      callback.call(status) if callback
+      if @iterations < @repeats
+        EM.defer do
+          do_right_popen(command, options) do |status|
+            maybe_continue(status, command, options, &callback)
+          end
+        end
       else
-        @status = status
         EM.stop
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_popen
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 61
   prerelease: false
   segments: 
   - 1
   - 0
-  - 20
-  version: 1.0.20
+  - 21
+  version: 1.0.21
 platform: x86-mswin32-60
 authors: 
 - Scott Messier
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-07 00:00:00 -08:00
+date: 2012-04-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency