right_popen 1.1.3 → 3.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c6e583ac6c97d2d520601667148416247a8cbca
+  data.tar.gz: ac4c240351ecb997a4b911e1fa6e8a71ca95275a
+SHA512:
+  metadata.gz: fceac1055ea55fb2b423fd65b51b380c4a948b7736084f3e2288df6bfa3715276650737fd8505b82cf9eabcb7e79d729b21802b893d95cfcd0b34113fdea8a41
+  data.tar.gz: 3f0b2cd13282f1456c1115df88a7a2c8d6a4fdc742cb73faece900fa504c2937758d555603929ad4485ad7afdc36288e816313e9035079c81141a2df5d08554a

data/README.rdoc

@@ -1,5 +1,7 @@
 = RightPopen
 
+Maintained by the RightScale Teal Team
+
 == DESCRIPTION
 
 === Synopsis

data/lib/right_popen.rb

@@ -21,39 +21,20 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'right_popen', 'target_proxy'))
-
-# TEAL FIX: this seems like test harness code smell, not production code. it
-# should be removed in next major revision. unfortunately we cannot remove these
-# require statements without breaking any code that depends on them.
-unless RUBY_PLATFORM =~ /mswin|mingw/
-  require File.expand_path(File.join(File.dirname(__FILE__), 'right_popen', 'linux', 'accumulator'))
-  require File.expand_path(File.join(File.dirname(__FILE__), 'right_popen', 'linux', 'utilities'))
-end
-
 module RightScale
+  module RightPopen
 
-  # see popen3_async for details.
-  #
-  # @deprecated in favor of sync vs. async methods in RightPopen namespace.
-  #
-  # === Parameters
-  # @param [Hash] options for execution
-  #
-  # === Returns
-  # @return [TrueClass] always true
-  def self.popen3(options)
-    warn 'WARNING: RightScale.popen3 is deprecated in favor of RightScale::RightPopen.popen3_async'
-    options = options.dup
-    cmd = options.dup.delete(:command)
-    raise ::ArgumentError.new("Missing command") unless cmd
-    ::RightScale::RightPopen.popen3_async(options[:command], options)
-  end
+    # exceptions
+    class ProcessError < Exception; end
 
-  module RightPopen
+    # autoloads
+    autoload :ProcessStatus, 'right_popen/process_status'
+    autoload :SafeOutputBuffer, 'right_popen/safe_output_buffer'
+    autoload :TargetProxy, 'right_popen/target_proxy'
 
     # see popen3_async for details.
     DEFAULT_POPEN3_OPTIONS = {
+      :directory        => nil,
       :environment      => nil,
       :exit_handler     => nil,
       :group            => nil,
@@ -80,15 +61,36 @@ module RightScale
     # === Return
     # @return [TrueClass] always true
     def self.require_popen3_impl(synchronicity)
+      # implementation of Process is specific to platform.
       case RUBY_PLATFORM
       when /mswin/
-        platform = 'win32'
+        platform_subdir = 'windows'
+        impl_subdir = ::File.join(platform_subdir, 'mswin')
       when /mingw/
-        platform = 'mingw'
+        platform_subdir = 'windows'
+        impl_subdir = ::File.join(platform_subdir, 'mingw')
+      when /win32|dos|cygwin/
+        raise NotImplementedError
       else
-        platform = 'linux'
+        platform_subdir = 'linux'
+        impl_subdir = platform_subdir
       end
-      require ::File.expand_path(::File.join(::File.dirname(__FILE__), 'right_popen', platform, synchronicity.to_s))
+      impl_module = ::File.join(impl_subdir, 'process')
+
+      # only require EM when async is requested.
+      case synchronicity
+      when :popen3_sync
+        sync_module = 'popen3_sync'
+      when :popen3_async
+        sync_module = ::File.join(platform_subdir, 'popen3_async')
+      else
+        fail 'unexpected synchronicity'
+      end
+
+      # platform-specific requires.
+      base_dir = ::File.join(::File.dirname(__FILE__), 'right_popen').gsub("\\", '/')
+      require ::File.expand_path(impl_module, base_dir)
+      require ::File.expand_path(sync_module, base_dir)
     end
 
     # Spawns a process to run given command synchronously. This is similar to
@@ -129,6 +131,7 @@ module RightScale
     #
     # === Parameters
     # @param [Hash] options for execution
+    # @option options [String] :directory as initial working directory for child process or nil to inherit current working directory
     # @option options [Hash] :environment variables values keyed by name
     # @option options [Symbol] :exit_handler target method called on exit
     # @option options [Integer|String] :group or gid for forked process (linux only)
@@ -145,6 +148,7 @@ module RightScale
     # @option options [Integer|String] :user or uid for forked process (linux only)
     # @option options [Symbol] :watch_handler called periodically with process during watch; return true to continue, false to abandon (sync only)
     # @option options [String] :watch_directory to monitor for child process writing files
+    # @option options [Symbol] :async_exception_handler target method called if an exception is handled (on another thread)
     #
     # === Returns
     # @return [TrueClass] always true

data/lib/right_popen/linux/popen3_async.rb

@@ -22,9 +22,9 @@
 #++
 
 require 'rubygems'
+require 'right_popen'
 require 'eventmachine'
-
-require File.expand_path(File.join(File.dirname(__FILE__), "process"))
+require 'yaml'
 
 module RightScale::RightPopen
 
@@ -32,12 +32,13 @@ module RightScale::RightPopen
   raise "#{StatusHandler.name} is already defined" if defined?(StatusHandler)
 
   module StatusHandler
-    def initialize(file_handle)
+    def initialize(file_handle, target)
       # Voodoo to make sure that Ruby doesn't gc the file handle
       # (closing the stream) before we're done with it.  No, oddly
       # enough EventMachine is not good about holding on to this
       # itself.
       @handle = file_handle
+      @target = target
       @data = ""
     end
 
@@ -59,8 +60,15 @@ module RightScale::RightPopen
 
     def unbind
       if @data.size > 0
-        e = ::Marshal.load(@data)
-        raise (::Exception === e ? e : "unknown failure: saw #{e} on status channel")
+        error_data = ::YAML.load(@data)
+        status_fd_error = ::RightScale::RightPopen::ProcessError.new(
+          "#{error_data['class']}: #{error_data['message']}")
+        if error_data['backtrace']
+          status_fd_error.set_backtrace(error_data['backtrace'])
+        end
+        if @target
+          @target.async_exception_handler(status_fd_error) rescue nil
+        end
       end
     end
   end
@@ -132,7 +140,7 @@ module RightScale::RightPopen
 
         # connect EM eventables to open streams.
         handlers = []
-        handlers << ::EM.attach(process.status_fd, ::RightScale::RightPopen::StatusHandler, process.status_fd)
+        handlers << ::EM.attach(process.status_fd, ::RightScale::RightPopen::StatusHandler, process.status_fd, target)
         handlers << ::EM.attach(process.stderr, ::RightScale::RightPopen::PipeHandler, process.stderr, target, :stderr_handler)
         handlers << ::EM.attach(process.stdout, ::RightScale::RightPopen::PipeHandler, process.stdout, target, :stdout_handler)
         handlers << ::EM.attach(process.stdin, ::RightScale::RightPopen::InputHandler, process.stdin, options[:input])
@@ -147,13 +155,16 @@ module RightScale::RightPopen
 
         # periodic watcher.
         watch_process(process, 0.1, target, handlers)
-      rescue
+      rescue Exception => e
         # we can't raise from the main EM thread or it will stop EM.
         # the spawn method will signal the exit handler but not the
         # pid handler in this case since there is no pid. any action
         # (logging, etc.) associated with the failure will have to be
         # driven by the exit handler.
-        target.exit_handler(process.status) rescue nil if target && process
+        if target
+          target.async_exception_handler(e) rescue nil
+          target.exit_handler(process.status) rescue nil if process
+        end
       end
     end
     true
@@ -188,13 +199,18 @@ module RightScale::RightPopen
           target.size_limit_handler rescue nil if process.size_limit_exceeded?
           target.exit_handler(process.status) rescue nil
         end
-      rescue
+      rescue Exception => e
         # we can't raise from the main EM thread or it will stop EM.
         # the spawn method will signal the exit handler but not the
         # pid handler in this case since there is no pid. any action
         # (logging, etc.) associated with the failure will have to be
         # driven by the exit handler.
-        target.exit_handler(process.status) rescue nil if target && process
+        if target
+          target.async_exception_handler(e) rescue nil
+          status = process && process.status
+          status ||= ::RightScale::RightPopen::ProcessStatus.new(nil, 1)
+          target.exit_handler(status)
+        end
       end
     end
     true

data/lib/right_popen/linux/process.rb

@@ -21,14 +21,16 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rubygems'
 require 'etc'
-
-require ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', 'process_base'))
-require ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', 'process_status'))
+require 'fcntl'
+require 'yaml'
+require 'right_popen'
+require 'right_popen/process_base'
 
 module RightScale
   module RightPopen
-    class Process < ProcessBase
+    class Process < ::RightScale::RightPopen::ProcessBase
 
       def initialize(options={})
         super(options)
@@ -39,7 +41,9 @@ module RightScale
       # === Return
       # @return [TrueClass|FalseClass] true if running
       def alive?
-        raise ProcessError.new('Process not started') unless @pid
+        unless @pid
+          raise ::RightScale::RightPopen::ProcessError, 'Process not started'
+        end
         unless @status
           begin
             ignored, status = ::Process.waitpid2(@pid, ::Process::WNOHANG)
@@ -72,7 +76,9 @@ module RightScale
       # === Return
       # @return [ProcessStatus] exit status
       def wait_for_exit_status
-        raise ProcessError.new('Process not started') unless @pid
+        unless @pid
+          raise ::RightScale::RightPopen::ProcessError, 'Process not started'
+        end
         unless @status
           begin
             ignored, status = ::Process.waitpid2(@pid)
@@ -162,7 +168,7 @@ module RightScale
             environment_hash['LC_ALL'] = 'C' if @options[:locale]
             environment_hash.merge!(@options[:environment]) if @options[:environment]
             environment_hash.each do |key, value|
-              ::ENV[key.to_s] = value.to_s if value
+              ::ENV[key.to_s] = value.nil? ? nil: value.to_s
             end
 
             if cmd.kind_of?(Array)
@@ -173,7 +179,14 @@ module RightScale
             end
             raise 'Unreachable code'
           rescue ::Exception => e
-            ::Marshal.dump(e, status_w)
+            # note that Marshal.dump/load isn't reliable for all kinds of
+            # exceptions or else can be truncated by I/O buffering.
+            error_data = {
+              'class' => e.class.name,
+              'message' => e.message,
+              'backtrace' => e.backtrace
+            }
+            status_w.puts(::YAML.dump(error_data))
           end
           status_w.close
           exit!
@@ -197,23 +210,6 @@ module RightScale
         raise
       end
 
-      # @deprecated this seems like test harness code smell, not production code.
-      def wait_for_exec
-        warn 'WARNING: RightScale::RightPopen::Process#wait_for_exec is deprecated in lib and will be moved to spec'
-        begin
-          e = ::Marshal.load(@status_fd)
-          # thus meaning that the process failed to exec...
-          @stdin.close
-          @stdout.close
-          @stderr.close
-          raise(Exception === e ? e : "unknown failure!")
-        rescue EOFError
-          # thus meaning that the process did exec and we can continue.
-        ensure
-          @status_fd.close
-        end
-      end
-
       private
 
       def get_user

data/lib/right_popen/{linux/popen3_sync.rb → popen3_sync.rb}

@@ -21,7 +21,8 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require File.expand_path(File.join(File.dirname(__FILE__), "process"))
+require 'rubygems'
+require 'right_popen'
 
 module RightScale::RightPopen
 

data/lib/right_popen/process_base.rb

@@ -21,14 +21,15 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rubygems'
+require 'right_popen'
 require 'thread'
+require 'yaml'
 
 module RightScale
   module RightPopen
     class ProcessBase
 
-      class ProcessError < Exception; end
-
       attr_reader :pid, :stdin, :stdout, :stderr, :status_fd, :status
       attr_reader :start_time, :stop_time, :channels_to_finish
 
@@ -146,6 +147,7 @@ module RightScale
         @status = nil
         @last_interrupt = nil
         @channels_to_finish = nil
+        @wait_thread = nil
 
         if @size_limit_bytes = @options[:size_limit_bytes]
           @watch_directory = @options[:watch_directory] || @options[:directory] || ::Dir.pwd
@@ -205,7 +207,7 @@ module RightScale
       # @return [TrueClass] always true
       def sync_exit_with_target
         abandon = false
-        last_exception = nil
+        status_fd_data = []
         begin
           while true
             channels_to_watch = @channels_to_finish.map { |ctf| ctf.last }
@@ -223,7 +225,7 @@ module RightScale
                 data = dead ? channel.gets(nil) : channel.gets
                 if data
                   if key == :status_fd
-                    last_exception = ::Marshal.load(data)
+                    status_fd_data << data
                   else
                     @target.method(key).call(data)
                   end
@@ -242,19 +244,19 @@ module RightScale
             end
           end
           wait_for_exit_status
+          unless status_fd_data.empty?
+            data = status_fd_data.join
+            error_data = ::YAML.load(data)
+            status_fd_error = ::RightScale::RightPopen::ProcessError.new(
+              "#{error_data['class']}: #{error_data['message']}")
+            if error_data['backtrace']
+              status_fd_error.set_backtrace(error_data['backtrace'])
+            end
+            raise status_fd_error
+          end
           @target.timeout_handler if timer_expired?
           @target.size_limit_handler if size_limit_exceeded?
           @target.exit_handler(@status)
-
-          # re-raise exception from fork, if any.
-          case last_exception
-          when nil
-            # all good
-          when ::Exception
-            raise last_exception
-          else
-            raise "Unknown failure: saw #{last_exception.inspect} on status channel."
-          end
         ensure
           # abandon will not close I/O objects; caller takes responsibility via
           # process object passed to watch_handler. if anyone calls interrupt
@@ -295,7 +297,7 @@ module RightScale
               next_interrupt = sigs.first
             end
             unless next_interrupt
-              raise ::RightScale::RightPopen::ProcessBase::ProcessError
+              raise ::RightScale::RightPopen::ProcessError,
                     'Unable to kill child process'
             end
             @last_interrupt = next_interrupt
@@ -328,7 +330,9 @@ module RightScale
       def start_timer
         # start timer when process comes alive (ruby processes are slow to
         # start in Windows, etc.).
-        raise ProcessError.new("Process not started") unless @pid
+        unless @pid
+          raise ::RightScale::RightPopen::ProcessError, 'Process not started'
+        end
         @start_time = ::Time.now
         @stop_time  = @options[:timeout_seconds] ?
                       (@start_time + @options[:timeout_seconds]) :

data/lib/right_popen/process_status.rb

@@ -21,6 +21,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rubygems'
+require 'right_popen'
+
 module RightScale
 
   module RightPopen

data/lib/right_popen/safe_output_buffer.rb

@@ -21,6 +21,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rubygems'
+require 'right_popen'
+
 module RightScale
 
   module RightPopen

data/lib/right_popen/target_proxy.rb

@@ -21,6 +21,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rubygems'
+require 'right_popen'
+
 module RightScale
   module RightPopen
 
@@ -29,19 +32,20 @@ module RightScale
     class TargetProxy
 
       HANDLER_NAME_TO_PARAMETER_COUNT = {
-        :exit_handler       => 1,
-        :pid_handler        => 1,
-        :size_limit_handler => 0,
-        :stderr_handler     => 1,
-        :stdout_handler     => 1,
-        :timeout_handler    => 0,
-        :watch_handler      => 1,
+        :exit_handler            => 1,
+        :pid_handler             => 1,
+        :size_limit_handler      => 0,
+        :stderr_handler          => 1,
+        :stdout_handler          => 1,
+        :timeout_handler         => 0,
+        :watch_handler           => 1,
+        :async_exception_handler => 1,
       }
 
       def initialize(options = {})
         if options[:target].nil? &&
            !(options.keys & HANDLER_NAME_TO_PARAMETER_COUNT.keys).empty?
-          raise ArgumentError, "Missing target"
+          raise ::ArgumentError, 'Missing target'
         end
         @target = options[:target]  # hold target reference (if any) against GC