right_popen 1.0.9-x86-mswin32-60 → 1.0.11-x86-mswin32-60

data/README.rdoc

@@ -26,6 +26,11 @@ to report issues.
   @stdout_text = ""
   @stderr_text = ""
   @exit_status = nil
+  @pid = nil
+
+  def on_pid(pid)
+    @pid = pid
+  end
 
   def on_read_stdout(data)
     @stdout_text << data
@@ -45,6 +50,7 @@ to report issues.
       RightScale.popen3(:command        => command,
                         :target         => self,
                         :environment    => nil,
+                        :pid_handler    => :on_pid,
                         :stdout_handler => :on_read_stdout,
                         :stderr_handler => :on_read_stderr,
                         :exit_handler   => :on_exit)
@@ -60,6 +66,7 @@ to report issues.
   puts "@stdout_text = #{@stdout_text}"
   puts "@stderr_text = #{@stderr_text}"
   puts "@exit_status.exitstatus = #{@exit_status.exitstatus}"
+  puts "@pid = #{@pid}"
 
 
 == INSTALLATION

data/lib/right_popen.rb

@@ -45,10 +45,11 @@ module RightScale
   # All handlers must be methods exposed by the given target.
   #
   # === Parameters
-  # options[:command](String):: Command to execute, including any arguments
+  # options[:command](String or Array):: Command to execute, including any arguments as a single string or an array of command and arguments
   # options[:environment](Hash):: Hash of environment variables values keyed by name
   # options[:input](String):: Input string that will get streamed into child's process stdin
   # options[:target](Object):: object defining handler methods to be called, optional (no handlers can be defined if not specified)
+  # options[:pid_handler](String):: PID notification handler method name, optional
   # options[:stdout_handler](String):: Stdout handler method name, optional
   # options[:stderr_handler](String):: Stderr handler method name, optional
   # options[:exit_handler](String):: Exit handler method name, optional
@@ -58,7 +59,7 @@ module RightScale
   def self.popen3(options)
     raise "EventMachine reactor must be started" unless EM.reactor_running?
     raise "Missing command" unless options[:command]
-    raise "Missing target" unless options[:target] || !options[:stdout_handler] && !options[:stderr_handler] && !options[:exit_handler]
+    raise "Missing target" unless options[:target] || !options[:stdout_handler] && !options[:stderr_handler] && !options[:exit_handler] && !options[:pid_handler]
     RightScale.popen3_imp(options)
     true
   end

data/lib/win32/right_popen.rb

@@ -53,7 +53,7 @@ module RightScale
     end
 
   end
-  
+
   # Provides an eventmachine callback handler for the stdout stream.
   module StdOutHandler
 
@@ -70,7 +70,7 @@ module RightScale
 
       # === Parameters
       # pid(Integer):: Process ID.
-      # 
+      #
       # exitstatus(Integer):: Process exit code
       def initialize(pid, exitstatus)
         @pid = pid
@@ -200,15 +200,31 @@ module RightScale
   def self.popen3_imp(options)
     raise "EventMachine reactor must be started" unless EM.reactor_running?
 
+    # merge command string
+    unless options[:command].instance_of?(String)
+      options[:command] = options[:command].join(' ')
+    end
+
     # merge and format environment strings, if necessary.
     environment_hash = options[:environment] || {}
     environment_strings = RightPopenEx.merge_environment(environment_hash)
 
+    # resolve command string from array, if necessary.
+    cmd = options[:command]
+    if cmd.kind_of?(Array)
+      escaped = []
+      cmd.flatten.each do |arg|
+        value = arg.to_s
+        escaped << (value.index(' ') ? "\"#{value}\"" : value)
+      end
+      cmd = escaped.join(" ")
+    end
+
     # launch cmd and request asynchronous output.
     mode = "t"
     show_window = false
     asynchronous_output = true
-    stream_in, stream_out, stream_err, pid = RightPopen.popen4(options[:command], mode, show_window, asynchronous_output, environment_strings)
+    stream_in, stream_out, stream_err, pid = RightPopen.popen4(cmd, mode, show_window, asynchronous_output, environment_strings)
 
     # close input immediately.
     stream_in.close if options[:input].nil?
@@ -217,7 +233,10 @@ module RightScale
     # streams aren't used directly by the connectors except that they are closed
     # on unbind.
     stderr_eventable = EM.watch(stream_err, StdErrHandler, options, stream_err) { |c| c.notify_readable = true } if options[:stderr_handler]
-    EM.watch(stream_out, StdOutHandler, options, stderr_eventable, stream_out, pid) { |c| c.notify_readable = true }
+    EM.watch(stream_out, StdOutHandler, options, stderr_eventable, stream_out, pid) do |c|
+      c.notify_readable = true
+      options[:target].method(options[:pid_handler]).call(pid) if options[:pid_handler]
+    end
     EM.attach(stream_in, StdInHandler, options, stream_in) if options[:input]
 
     # note that control returns to the caller, but the launched cmd continues

data/right_popen.gemspec

@@ -6,8 +6,8 @@ end
 
 spec = Gem::Specification.new do |spec|
   spec.name      = 'right_popen'
-  spec.version   = '1.0.9'
-  spec.authors   = ['Scott Messier', 'Raphael Simon']
+  spec.version   = '1.0.11'
+  spec.authors   = ['Scott Messier', 'Raphael Simon', 'Graham Hughes']
   spec.email     = 'scott@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_popen'
   if is_windows?

data/spec/right_popen_spec.rb

@@ -1,182 +1,233 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-RUBY_CMD         = 'ruby'
-STANDARD_MESSAGE = 'Standard message'
-ERROR_MESSAGE    = 'Error message'
-EXIT_STATUS      = 146
+describe 'RightScale::popen3' do
 
-# manually bump count up for more aggressive multi-processor testing, lessen
-# for a quick smoke test
-LARGE_OUTPUT_COUNTER = 1000
+  module RightPopenSpec
+    class Runner
+      class RunnerStatus
+        def initialize(command, block)
+          @output_text = ""
+          @error_text  = ""
+          @status      = nil
+          @did_timeout = false
+          @callback    = block
+          @pid         = nil
+          EM.next_tick do
+            @timeout = EM::Timer.new(2) do
+              puts "\n** Failed to run #{command.inspect}: Timeout"
+              @did_timeout = true
+              @callback.call(self)
+            end
+          end
+        end
 
-# bump up count for most exhaustive leak detection.
-REPEAT_TEST_COUNTER = 256
+        attr_accessor :output_text, :error_text, :status, :did_timeout, :pid
 
-def is_windows?
-  return RUBY_PLATFORM =~ /mswin/
-end
+        def on_read_stdout(data)
+          @output_text << data
+        end
 
-describe 'RightScale::popen3' do
+        def on_read_stderr(data)
+          @error_text << data
+        end
 
-  module RightPopenSpec
+        def on_pid(pid)
+          raise "PID already set!" unless @pid.nil?
+          @pid = pid
+        end
+
+        def on_exit(status)
+          @timeout.cancel if @timeout
+          @status = status
+          @callback.call(self)
+        end
+      end
 
-    class Runner
       def initialize
+        @count          = 0
         @done           = false
-        @output_text    = nil
-        @error_text     = nil
-        @status         = nil
         @last_exception = nil
         @last_iteration = 0
       end
 
-      attr_reader :output_text, :error_text, :status
-
-      def do_right_popen(command, env=nil, input=nil)
-        @timeout = EM::Timer.new(2) { puts "\n** Failed to run #{command.inspect}: Timeout"; EM.stop }
-        @output_text = ''
-        @error_text  = ''
-        @status      = nil
-        RightScale.popen3(:command        => command, 
+      def do_right_popen(command, env=nil, input=nil, &callback)
+        status = RunnerStatus.new(command, callback)
+        RightScale.popen3(:command        => command,
                           :input          => input,
-                          :target         => self, 
+                          :target         => status,
                           :environment    => env,
-                          :stdout_handler => :on_read_stdout, 
-                          :stderr_handler => :on_read_stderr, 
+                          :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)
         begin
-          @command = command
-          @env = env
-          @last_iteration = 0
-          @count = count
-          puts "#{count}>" if count > 1
-          EM.run { EM.next_tick { do_right_popen(command, env, input) } }
+          @iterations = 0
+          EM.run do
+            EM.next_tick do
+              do_right_popen(command, env, input) do |status|
+                maybe_continue(status)
+              end
+            end
+          end
+          @status
         rescue Exception => e
           puts "\n** Failed: #{e.message} FROM\n#{e.backtrace.join("\n")}"
           raise e
         end
       end
 
-      def on_read_stdout(data)
-        @output_text << data
-      end
-
-      def on_read_stderr(data)
-        @error_text << data
-      end
-
-      def on_exit(status)
-        @last_iteration += 1
-        @timeout.cancel if @timeout
-        if @last_iteration < @count
-          EM.next_tick do
-            print '+'
-            STDOUT.flush
-            do_right_popen(@command, @env)
-          end
+      def maybe_continue(status)
+        @iterations += 1
+        if @iterations < @count
+          do_right_popen(command, env, input) {|status| maybe_continue(status)}
         else
-          puts "<" if @count > 1
+          @status = status
           EM.stop
         end
-        @status = status
       end
     end
+  end
 
+  def is_windows?
+    return !!(RUBY_PLATFORM =~ /mswin/)
   end
 
   it 'should redirect output' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == STANDARD_MESSAGE + "\n"
-    runner.error_text.should == ERROR_MESSAGE + "\n"
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
+    status.output_text.should == STANDARD_MESSAGE + "\n"
+    status.error_text.should == ERROR_MESSAGE + "\n"
+    status.pid.should > 0
   end
 
   it 'should return the right status' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_status.rb'))}\" #{EXIT_STATUS}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == EXIT_STATUS
-    runner.output_text.should == ''
-    runner.error_text.should == ''
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == EXIT_STATUS
+    status.output_text.should == ''
+    status.error_text.should == ''
+    status.pid.should > 0
+  end
+
+  it 'should correctly handle many small processes' do
+    pending 'Set environment variable TEST_STRESS to enable' unless ENV['TEST_STRESS']
+    TO_RUN = 100
+    command = is_windows? ? "cmd.exe /c exit 0" : "exit 0"
+    runner = RightPopenSpec::Runner.new
+    @completed = 0
+    @started = 0
+    run_cmd = Proc.new do
+      runner.do_right_popen(command) do |status|
+        @completed += 1
+        status.status.exitstatus.should == 0
+        status.output_text.should == ''
+        status.error_text.should == ''
+        status.pid.should > 0
+      end
+      @started += 1
+      if @started < TO_RUN
+        EM.next_tick { run_cmd.call }
+      end
+    end
+    EM.run do
+      EM.next_tick { run_cmd.call }
+
+      EM::PeriodicTimer.new(1) do
+        if @completed >= TO_RUN
+          EM.stop
+        end
+      end
+    end
   end
 
   it 'should preserve the integrity of stdout when stderr is unavailable' do
     count = LARGE_OUTPUT_COUNTER
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stdout_only.rb'))}\" #{count}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
 
     results = ''
     count.times do |i|
       results << "stdout #{i}\n"
     end
-    runner.output_text.should == results
-    runner.error_text.should == ''
+    status.output_text.should == results
+    status.error_text.should == ''
+    status.pid.should > 0
   end
 
   it 'should preserve the integrity of stderr when stdout is unavailable' do
     count = LARGE_OUTPUT_COUNTER
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stderr_only.rb'))}\" #{count}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
 
     results = ''
     count.times do |i|
       results << "stderr #{i}\n"
     end
-    runner.error_text.should == results
-    runner.output_text.should == ''
+    status.error_text.should == results
+    status.output_text.should == ''
+    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}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 99
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 99
 
     results = ''
     count.times do |i|
       results << "stdout #{i}\n"
     end
-    runner.output_text.should == results
+    status.output_text.should == results
 
     results = ''
     count.times do |i|
       (results << "stderr #{i}\n") if 0 == i % 10
     end
-    runner.error_text.should == results
+    status.error_text.should == results
+    status.pid.should > 0
   end
-  
+
   it 'should setup environment variables' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should_not include('_test_')
-    runner.run_right_popen(command, :__test__ => '42')
-    runner.status.exitstatus.should == 0
-    runner.output_text.should match(/^__test__=42$/)
+    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.status.exitstatus.should == 0
+    status.output_text.should match(/^__test__=42$/)
+    status.pid.should > 0
   end
 
   it 'should restore environment variables' do
-    ENV['__test__'] = '41'
-    old_envs = {}
-    ENV.each { |k, v| old_envs[k] = v }
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
-    runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, :__test__ => '42')
-    runner.status.exitstatus.should == 0
-    runner.output_text.should match(/^__test__=42$/)
-    ENV.each { |k, v| old_envs[k].should == v }
-    old_envs.each { |k, v| ENV[k].should == v }
+    begin
+      ENV['__test__'] = '41'
+      old_envs = {}
+      ENV.each { |k, v| old_envs[k] = v }
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
+      runner = RightPopenSpec::Runner.new
+      status = runner.run_right_popen(command, :__test__ => '42')
+      status.status.exitstatus.should == 0
+      status.output_text.should match(/^__test__=42$/)
+      ENV.each { |k, v| old_envs[k].should == v }
+      old_envs.each { |k, v| ENV[k].should == v }
+      status.pid.should > 0
+    ensure
+      ENV.delete('__test__')
+    end
   end
 
   if is_windows?
@@ -185,37 +236,63 @@ describe 'RightScale::popen3' do
     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 = RightPopenSpec::Runner.new
-      runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
-      runner.status.exitstatus.should == 0
-      runner.output_text.should include('PATH=c:\\bogus\\bin;')
+      status = runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
+      status.status.exitstatus.should == 0
+      status.output_text.should include('PATH=c:\\bogus\\bin;')
+      status.pid.should > 0
     end
   else
     it 'should allow running bash command lines starting with a built-in command' do
       command = "for i in 1 2 3 4 5; do echo $i;done"
       runner = RightPopenSpec::Runner.new
-      runner.run_right_popen(command)
-      runner.status.exitstatus.should == 0
-      runner.output_text.should == "1\n2\n3\n4\n5\n"
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
+      status.output_text.should == "1\n2\n3\n4\n5\n"
+      status.pid.should > 0
     end
+
+    it 'should support running background processes' do
+      command = "(sleep 20)&"
+      now = Time.now
+      runner = RightPopenSpec::Runner.new
+      status = runner.run_right_popen(command)
+      finished = Time.now
+      (finished - now).should < 20
+      status.did_timeout.should be_false
+      status.status.exitstatus.should == 0
+      status.output_text.should == ""
+      status.pid.should > 0
+    end
+  end
+
+  it 'should support raw command arguments' do
+    command = is_windows? ? ["cmd.exe", "/c", "echo", "*"] : ["echo", "*"]
+    runner = RightPopenSpec::Runner.new
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
+    status.output_text.should == "*\n"
+    status.pid.should > 0
   end
 
   it 'should run repeatedly without leaking resources' do
     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 = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == STANDARD_MESSAGE + "\n"
-    runner.error_text.should == ERROR_MESSAGE + "\n"
+    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
   end
 
   it 'should pass input to child process' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'increment.rb'))}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, nil, "42\n")
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == "43\n"
-    runner.error_text.should be_empty
+    status = runner.run_right_popen(command, nil, "42\n")
+    status.status.exitstatus.should == 0
+    status.output_text.should == "43\n"
+    status.error_text.should be_empty
+    status.pid.should > 0
   end
 
 end

data/spec/spec_helper.rb

@@ -2,3 +2,19 @@ require 'rubygems'
 require 'spec'
 require 'eventmachine'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'right_popen')
+
+RUBY_CMD         = 'ruby'
+STANDARD_MESSAGE = 'Standard message'
+ERROR_MESSAGE    = 'Error message'
+EXIT_STATUS      = 146
+
+# manually bump count up for more aggressive multi-processor testing, lessen
+# for a quick smoke test
+LARGE_OUTPUT_COUNTER = 1000
+
+# bump up count for most exhaustive leak detection.
+REPEAT_TEST_COUNTER = 256
+
+def is_windows?
+  return RUBY_PLATFORM =~ /mswin/
+end

metadata

@@ -1,51 +1,39 @@
 --- !ruby/object:Gem::Specification 
 name: right_popen
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 9
-  version: 1.0.9
+  version: 1.0.11
 platform: x86-mswin32-60
 authors: 
 - Scott Messier
 - Raphael Simon
+- Graham Hughes
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-21 00:00:00 -07:00
+date: 2010-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 12
-        - 10
         version: 0.12.10
-  type: :runtime
-  version_requirements: *id001
+    version: 
 - !ruby/object:Gem::Dependency 
   name: win32-process
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 6
-        - 1
         version: 0.6.1
-  type: :runtime
-  version_requirements: *id002
+    version: 
 description: |
   RightPopen allows running external processes aynchronously while still
   capturing their standard and error outputs. It relies on EventMachine for most
@@ -95,22 +83,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 8
-      - 6
       version: 1.8.6
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: right_popen
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Provides a platform-independent popen implementation