right_popen 1.0.21 → 1.1.3

data/spec/runner.rb

@@ -22,103 +22,195 @@
 #++
 
 module RightScale
-  class Runner
-    class RunnerStatus
-      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    = callback
-        @pid         = nil
-        @force_yield = options[:force_yield]
-        EM.next_tick do
-          @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) if options[:expect_timeout]
-          end
+  module RightPopen
+    class Runner
+      class RunnerStatus
+        def initialize(command, options={}, &callback)
+          options = {:repeats=>1, :force_yield=>nil, :timeout=>nil, :expect_timeout=>false}.merge(options)
+
+          @command     = command
+          @output_text = ""
+          @error_text  = ""
+          @status      = nil
+          @did_timeout = false
+          @callback    = callback
+          @pid         = nil
+          @force_yield = options[:force_yield]
+
+          @expect_timeout    = options[:expect_timeout]
+          @expect_size_limit = options[:expect_size_limit]
         end
-      end
 
-      attr_accessor :output_text, :error_text, :status, :did_timeout, :pid
+        attr_accessor :output_text, :error_text, :status, :pid
+        attr_accessor :did_timeout, :did_size_limit
 
-      def on_read_stdout(data)
-        sleep @force_yield if @force_yield
-        @output_text << data
-      end
+        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
+        def on_read_stderr(data)
+          sleep @force_yield if @force_yield
+          @error_text << data
+        end
+
+        def on_pid(pid)
+          raise "PID already set!" unless @pid.nil?
+          @pid = pid
+        end
+
+        def on_timeout
+          puts "\n** Failed to run #{@command.inspect}: Timeout" unless @expect_timeout
+          @did_timeout = true
+          @callback.call(self) if @expect_timeout
+        end
+
+        def on_size_limit
+          puts "\n** Failed to run #{@command.inspect}: Size limit" unless @expect_size_limit
+          @did_size_limit = true
+          @callback.call(self) if @expect_size_limit
+        end
 
-      def on_pid(pid)
-        raise "PID already set!" unless @pid.nil?
-        @pid = pid
+        def on_exit(status)
+          @status = status
+          @callback.call(self)
+        end
       end
 
-      def on_exit(status)
-        @timeout.cancel if @timeout
-        @status = status
-        @callback.call(self)
+      def initialize
+        @count          = 0
+        @done           = false
+        @last_exception = nil
+        @last_iteration = 0
       end
-    end
 
-    def initialize
-      @count          = 0
-      @done           = false
-      @last_exception = nil
-      @last_iteration = 0
-    end
+      def run_right_popen3(synchronicity, command, runner_options={}, &callback)
+        runner_options = {
+          :repeats           => 1,
+          :expect_timeout    => false,
+          :expect_size_limit => false
+        }.merge(runner_options)
+        popen3_options = {
+          :input              => runner_options[:input],
+          :environment        => runner_options[:env],
+          :timeout_seconds    => runner_options.has_key?(:timeout) ? runner_options[:timeout] : 2,
+          :size_limit_bytes   => runner_options[:size_limit_bytes],
+          :watch_directory    => runner_options[:watch_directory]
+        }
+        case synchronicity
+        when :sync
+          run_right_popen3_sync(command, runner_options, popen3_options, &callback)
+        when :async
+          run_right_popen3_async(command, runner_options, popen3_options, &callback)
+        else
+          raise "unknown synchronicity = #{synchronicity.inspect}"
+        end
+      end
 
-    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          => 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_popen3_sync(command, runner_options, popen3_options, &callback)
+        begin
+          @iterations = 0
+          @repeats = runner_options[:repeats]
+          @stats = []
+          while @iterations < @repeats
+            @iterations += 1
+            do_right_popen3_sync(command, runner_options, popen3_options) do |runner_status|
+              @stats << runner_status
+              callback.call(runner_status) if callback
+              if @repeats > 1
+                puts if 1 == (@iterations % 64)
+                print '+'
+                puts if @iterations == @repeats
+              end
+            end
+          end
+          @stats.uniq!
+          @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 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.defer do
-            do_right_popen(command, options) do |status|
-              maybe_continue(status, command, options, &callback)
+      def run_right_popen3_async(command, runner_options, popen3_options, &callback)
+        begin
+          @iterations = 0
+          @repeats = runner_options[:repeats]
+          @stats = []
+          EM.run do
+            EM.defer do
+              begin
+                do_right_popen3_async(command, runner_options, popen3_options) do |runner_status|
+                  maybe_continue_popen3_async(runner_status, command, runner_options, popen3_options, &callback)
+                end
+              rescue Exception => e
+                puts e.class, e.message, e.backtrace.join("\n")
+                EM.stop
+              end
             end
           end
+          @stats.uniq!
+          @stats.size < 2 ? @stats.first : @stats
+        rescue Exception => e
+          puts "\n** Failed: #{e.message} FROM\n#{e.backtrace.join("\n")}"
+          raise e
         end
-        @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, command, options, &callback)
-      @iterations += 1
-      @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)
+      def do_right_popen3(synchronicity, command, runner_options, popen3_options, &callback)
+        runner_status = RunnerStatus.new(command, runner_options, &callback)
+        popen3_options = {
+          :target             => runner_status,
+          :stdout_handler     => :on_read_stdout,
+          :stderr_handler     => :on_read_stderr,
+          :pid_handler        => :on_pid,
+          :timeout_handler    => :on_timeout,
+          :size_limit_handler => :on_size_limit,
+          :exit_handler       => :on_exit
+        }.merge(popen3_options)
+        case synchronicity
+        when :sync
+          result = ::RightScale::RightPopen.popen3_sync(command, popen3_options)
+        when :async
+          result = ::RightScale::RightPopen.popen3_async(command, popen3_options)
+        else
+          raise "Uknown synchronicity = #{synchronicity.inspect}"
+        end
+        result.should == true
+        true
+      end
+
+      def do_right_popen3_sync(command, runner_options, popen3_options, &callback)
+        do_right_popen3(:sync, command, runner_options, popen3_options, &callback)
+      end
+
+      def do_right_popen3_async(command, runner_options, popen3_options, &callback)
+        do_right_popen3(:async, command, runner_options, popen3_options, &callback)
+      end
+
+      def maybe_continue_popen3_async(runner_status, command, runner_options, popen3_options, &callback)
+        @iterations += 1
+        @stats << runner_status
+        callback.call(runner_status) if callback
+        if @iterations < @repeats
+          if @repeats > 1
+            puts if 1 == (@iterations % 64)
+            print '+'
+            puts if @iterations == @repeats
+          end
+          EM.defer do
+            begin
+              do_right_popen3_async(command, runner_options, popen3_options) do |runner_status2|
+                maybe_continue_popen3_async(runner_status2, command, runner_options, popen3_options, &callback)
+              end
+            rescue Exception => e
+              puts e.class, e.message, e.backtrace.join("\n")
+              EM.stop
+            end
           end
+        else
+          EM.stop
         end
-      else
-        EM.stop
       end
     end
   end

data/spec/sleeper.rb

@@ -0,0 +1,35 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2011 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+REPEATS = (ARGV[0] || '4').to_i
+
+STDOUT.sync = true
+STDERR.sync = true
+REPEATS.times do |i|
+  STDOUT.puts "To sleep... #{i}"
+  STDERR.puts "Perchance to dream... #{i}"
+  sleep 1
+end
+STDOUT.puts "The sleeper must awaken."
+
+exit 0

data/spec/stdout.rb

@@ -23,6 +23,6 @@
 
 $stderr.puts "Closing stdout"
 STDOUT.close
-sleep 3
+sleep 15
 $stderr.puts "Exiting"
 exit 0

data/spec/writer.rb

@@ -0,0 +1,34 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2011 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+watched_dir = ARGV[0]
+
+10.times do |i|
+  path = ::File.join(watched_dir, "file#{i}.txt")
+  ::File.open(path, 'w') do |f|
+    f.write 'x' * 100
+  end
+  sleep 0.2
+end
+
+exit 0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_popen
 version: !ruby/object:Gem::Version 
-  hash: 61
-  prerelease: false
+  hash: 21
+  prerelease: 
   segments: 
   - 1
-  - 0
-  - 21
-  version: 1.0.21
+  - 1
+  - 3
+  version: 1.1.3
 platform: ruby
 authors: 
 - Scott Messier
@@ -17,26 +17,26 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-25 00:00:00 -07:00
-default_executable: 
+date: 2013-07-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 57
+        hash: 23
         segments: 
+        - 1
         - 0
-        - 12
-        - 11
-        version: 0.12.11
-  type: :runtime
-  name: eventmachine
-  prerelease: false
+        - 0
+        version: 1.0.0
   version_requirements: *id001
+  name: eventmachine
+  type: :development
 - !ruby/object:Gem::Dependency 
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -47,11 +47,11 @@ dependencies:
         - 1
         - 3
         version: "1.3"
-  type: :development
-  name: rspec
-  prerelease: false
   version_requirements: *id002
+  name: rspec
+  type: :development
 - !ruby/object:Gem::Dependency 
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -63,11 +63,11 @@ dependencies:
         - 8
         - 7
         version: 0.8.7
-  type: :development
-  name: rake
-  prerelease: false
   version_requirements: *id003
+  name: rake
+  type: :development
 - !ruby/object:Gem::Dependency 
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -77,10 +77,9 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  name: flexmock
-  prerelease: false
   version_requirements: *id004
+  name: flexmock
+  type: :development
 description: |
   RightPopen allows running external processes aynchronously while still
   capturing their standard and error outputs. It relies on EventMachine for most
@@ -100,9 +99,14 @@ files:
 - Rakefile
 - lib/right_popen.rb
 - lib/right_popen/linux/accumulator.rb
+- lib/right_popen/linux/popen3_async.rb
+- lib/right_popen/linux/popen3_sync.rb
 - lib/right_popen/linux/process.rb
-- lib/right_popen/linux/right_popen.rb
 - lib/right_popen/linux/utilities.rb
+- lib/right_popen/process_base.rb
+- lib/right_popen/process_status.rb
+- lib/right_popen/safe_output_buffer.rb
+- lib/right_popen/target_proxy.rb
 - lib/right_popen/version.rb
 - right_popen.gemspec
 - spec/background.rb
@@ -115,11 +119,13 @@ files:
 - spec/produce_stdout_only.rb
 - spec/right_popen/linux/accumulator_spec.rb
 - spec/right_popen/linux/utilities_spec.rb
+- spec/right_popen/safe_output_buffer_spec.rb
 - spec/right_popen_spec.rb
 - spec/runner.rb
+- spec/sleeper.rb
 - spec/spec_helper.rb
 - spec/stdout.rb
-has_rdoc: true
+- spec/writer.rb
 homepage: https://github.com/rightscale/right_popen
 licenses: []
 
@@ -154,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: right_popen
-rubygems_version: 1.3.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Provides a platform-independent popen implementation