right_popen 1.0.21-x86-mswin32-60 → 1.1.3-x86-mswin32-60

data/lib/right_popen/win32/popen3_sync.rb

@@ -0,0 +1,35 @@
+#--
+# Copyright (c) 2013 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.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), "process"))
+
+module RightScale::RightPopen
+
+  # See RightScale.popen3_sync for details
+  def self.popen3_sync_impl(cmd, target, options)
+    process = ::RightScale::RightPopen::Process.new(options)
+    process.sync_all(cmd, target)
+    true
+  end
+
+end

data/lib/right_popen/win32/process.rb

@@ -0,0 +1,306 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2013 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.
+#++
+
+require 'win32/process'
+
+require ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', 'process_base'))
+require ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', 'process_status'))
+require ::File.expand_path(::File.join(::File.dirname(__FILE__), 'right_popen_ex'))
+require ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', '..', 'win32', 'right_popen.so'))  # win32 native code
+
+module RightScale
+  module RightPopen
+    class Process < ProcessBase
+
+      def initialize(options={})
+        super(options)
+      end
+
+      # Determines if the process is still running.
+      #
+      # === Return
+      # @return [TrueClass|FalseClass] true if running
+      def alive?
+        raise ProcessError.new('Process not started') unless @pid
+        unless @status
+          # note that ::Process.kill(0, pid) is unreliable from win32-process
+          # gem because it can returns a false positive if called before and
+          # then after process termination.
+          handle = ::Windows::Process::OpenProcess.call(
+            desired_access = ::Windows::Process::PROCESS_ALL_ACCESS,
+            inherit_handle = 0,
+            @pid)
+          alive = false
+          if handle != ::Windows::Handle::INVALID_HANDLE_VALUE
+            begin
+              # immediate check (zero milliseconds) to see if process handle is
+              # signalled (i.e. terminated). the process remains signalled after
+              # termination and can be checked repeatedly in this manner (until
+              # the OS recycles the PID at an unspecified time later).
+              result = ::Windows::Synchronize::WaitForSingleObject.call(
+                handle,
+                milliseconds = 0)
+              alive = result == ::Windows::Synchronize::WAIT_TIMEOUT
+            ensure
+              ::Windows::Handle::CloseHandle.call(handle)
+            end
+          end
+          wait_for_exit_status unless alive
+        end
+        @status.nil?
+      end
+
+      # Windows must drain all streams on child death in order to ensure all
+      # output is read. if the child closes only one of the streams there is no
+      # possibility of hanging (Windows will simply read EOF).
+      #
+      # === Return
+      # @return [TrueClass|FalseClass] true if draining all
+      def drain_all_upon_death?
+        true
+      end
+
+      # @return [Array] escalating termination signals for this platform
+      def signals_for_interrupt
+        ['INT', 'BRK', 'KILL']
+      end
+
+      # spawns a child process using given command and handler target in a
+      # win32-specific manner.
+      #
+      # must be overridden and override must call super.
+      #
+      # === Parameters
+      # @param [String|Array] cmd as shell command or binary to execute
+      # @param [Object] target that implements all handlers (see TargetProxy)
+      #
+      # === Return
+      # @return [TrueClass] always true
+      def spawn(cmd, target)
+        super(cmd, target)
+
+        # garbage collection has no good effect for spawning a child process in
+        # Windows because forking is not supported and so Ruby objects cannot be
+        # shared with child process (although handles can be shared via some
+        # advanced API programming). the following GC call is only for
+        # compatibility with the Linux implementation.
+        ::GC.start
+
+        # merge and format environment strings, if necessary.
+        environment_hash = @options[:environment] || {}
+        environment_strings = ::RightScale::RightPopenEx.merge_environment(environment_hash)
+
+        # resolve command string from array, if necessary.
+        if cmd.kind_of?(::Array)
+          escaped = []
+          cmd.flatten.each_with_index do |token, token_index|
+            token = token.to_s
+            if token_index == 0
+              token = self.class.find_executable_in_path(token)
+            end
+            escaped << self.class.quoted_command_token(token)
+          end
+          cmd = escaped.join(' ')
+        else
+          # resolve first token as an executable using PATH, etc.
+          cmd = cmd.to_s
+          delimiter = (cmd[0..0] == '"') ? '"' : ' '
+          if delimiter_offset = cmd.index(delimiter, 1)
+            token = cmd[0..delimiter_offset].strip
+            remainder = cmd[(delimiter_offset + 1)..-1].to_s.strip
+          else
+            token = cmd
+            remainder = ''
+          end
+          token = self.class.find_executable_in_path(token)
+          token = self.class.quoted_command_token(token)
+          if remainder.empty?
+            cmd = token
+          else
+            cmd = "#{token} #{remainder}"
+          end
+        end
+
+        result = []
+        spawner = lambda do
+          # launch cmd using native win32 implementation.
+          result += ::RightScale::RightPopen.popen4(
+            cmd,
+            mode = 't',
+            show_window = false,
+            asynchronous_output = true,
+            environment_strings)
+        end
+        if @options[:directory]
+          # note that invoking Dir.chdir with a block when already inside a
+          # chdir block is can print an annoying warning to STDERR when paths
+          # differ under circumstances that are hard to define.
+          # case sensitivity? forward vs. backslash?
+          # anyway, do our own comparison to try and avoid this warning.
+          current_directory = ::Dir.pwd.gsub("\\", '/')
+          new_directory = ::File.expand_path(@options[:directory]).gsub("\\", '/')
+          if 0 == current_directory.casecmp(new_directory)
+            spawner.call
+          else
+            ::Dir.chdir(@options[:directory]) { spawner.call }
+          end
+        else
+          spawner.call
+        end
+        @stdin, @stdout, @stderr, @pid = result
+        start_timer
+        true
+      rescue
+        # catch-all for failure to spawn process ensuring a non-nil status. the
+        # PID most likely is nil but the exit handler can be invoked for async.
+        safe_close_io
+        @status = ::RightScale::RightPopen::ProcessStatus.new(@pid, 1)
+        raise
+      end
+
+      # blocks waiting for process exit status.
+      #
+      # === Return
+      # @return [ProcessStatus] exit status
+      def wait_for_exit_status
+        raise ProcessError.new('Process not started') unless @pid
+        unless @status
+          exitstatus = 0
+          begin
+            # note that win32-process gem doesn't support the no-hang parameter
+            # and returns exit code instead of status.
+            ignored, exitstatus = ::Process.waitpid2(@pid)
+          rescue Process::Error
+            # process is gone, which means we have no recourse to retrieve the
+            # actual exit code.
+          end
+
+          # an interrupted process can still return zero exit status; if we
+          # interrupted it then don't treat it as successful. simulate the Linux
+          # termination signal behavior here.
+          if interrupted?
+            exitstatus = nil
+            termsig = @last_interrupt
+          end
+          @status = ::RightScale::RightPopen::ProcessStatus.new(@pid, exitstatus, termsig)
+        end
+        @status
+      end
+
+      # Finds the given command name in the PATH. this emulates the 'which'
+      # command from linux (without the terminating newline). Supplies the
+      # executable file extension if missing.
+      #
+      # === Parameters
+      # @param [String] token to be qualified
+      #
+      # === Return
+      # @return [String] path to first matching executable file in PATH or nil
+      def self.find_executable_in_path(token)
+        # strip any surrounding double-quotes (single quotes are considered to
+        # be literals in Windows).
+        token = unquoted_command_token(token)
+        unless token.empty?
+          # note that File.executable? returns a false positive in Windows for
+          # directory paths, so only use File.file?
+          return executable_path(token) if File.file?(token)
+
+          # must search all known (executable) path extensions unless the
+          # explicit extension was given. this handles a case such as 'curl'
+          # which can either be on the path as 'curl.exe' or as a command shell
+          # shortcut called 'curl.cmd', etc.
+          use_path_extensions = 0 == File.extname(token).length
+          path_extensions = use_path_extensions ? (ENV['PATHEXT'] || '').split(/;/) : nil
+
+          # must check the current working directory first just to be completely
+          # sure what would happen if the command were executed. note that Linux
+          # ignores the CWD, so this is platform-specific behavior for Windows.
+          cwd = Dir.getwd
+          path = ENV['PATH']
+          path = (path.nil? || 0 == path.length) ? cwd : (cwd + ';' + path)
+          path.split(/;/).each do |dir|
+            # note that PATH elements are optionally double-quoted.
+            dir = unquoted_command_token(dir)
+            if use_path_extensions
+              path_extensions.each do |path_extension|
+                path = File.join(dir, token + path_extension)
+                return executable_path(path) if File.file?(path)
+              end
+            else
+              path = File.join(dir, token)
+              return executable_path(path) if File.file?(path)
+            end
+          end
+        end
+
+        # cannot be resolved.
+        return nil
+      end
+
+      # Determines if the given command token requires double-quotes.
+      #
+      # === Parameter
+      # @param [String] token
+      #
+      # === Return
+      # @return [String] quoted token or unchanged
+      def self.quoted_command_token(token)
+        token = "\"#{token}\"" if token[0..0] != '"' && token.index(' ')
+        token
+      end
+
+      # Determines if the given command token has double-quotes that need to be
+      # removed.
+      #
+      # === Parameter
+      # @param [String] token
+      #
+      # === Return
+      # @return [String] unquoted token or unchanged
+      def self.unquoted_command_token(token)
+        delimiter = '"'
+        if token[0..0] == delimiter
+          delimiter_offset = token.index(delimiter, delimiter.length)
+          if delimiter_offset
+            token = token[1..(delimiter_offset-1)].strip
+          else
+            token = token[1..-1].strip
+          end
+        end
+        token
+      end
+
+      # Makes a pretty path for executing a command in Windows.
+      #
+      # === Parameters
+      # @param [String] path to qualify
+      #
+      # === Return
+      # @return [String] fully qualified executable path
+      def self.executable_path(path)
+        ::File.expand_path(path).gsub('/', "\\")
+      end
+
+    end
+  end
+end

data/lib/right_popen/win32/{right_popen.rb → right_popen_ex.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009-2011 RightScale Inc
+# Copyright (c) 2009-2013 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,244 +21,20 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require 'rubygems'
-require 'eventmachine'
-require 'win32/process'
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'win32', 'right_popen.so'))  # win32 native code
-
 module RightScale
 
-  # ensure uniqueness of handler to avoid confusion.
-  raise "#{StdInHandler.name} is already defined" if defined?(StdInHandler)
-
-  # Eventmachine callback handler for stdin stream
-  module StdInHandler
-
-    # === Parameters
-    # options[:input](String):: Input to be streamed into child process stdin
-    # stream_in(IO):: Standard input stream.
-    def initialize(options, stream_in)
-      @stream_in = stream_in
-      @input = options[:input]
-    end
-
-    # Eventmachine callback asking for more to write
-    # Send input and close stream in
-    def post_init
-      if @input
-        send_data(@input)
-        close_connection_after_writing
-        @input = nil
-      else
-        close_connection
-      end
-    end
-
-  end
-
-  # ensure uniqueness of handler to avoid confusion.
-  raise "#{StdOutHandler.name} is already defined" if defined?(StdOutHandler)
-
-  # Provides an eventmachine callback handler for the stdout stream.
-  module StdOutHandler
-
-    # Quacks like Process::Status, which we cannot instantiate ourselves because
-    # has no public new method. RightScale::popen3 needs this because the
-    # 'win32/process' gem currently won't return Process::Status objects but
-    # only returns a [pid, exitstatus] value.
-    class Status
-      # Process ID
-      attr_reader :pid
+  # helper classes for the win32 implementation of RightPopen.
+  module RightPopenEx
 
-      # Process exit code
-      attr_reader :exitstatus
+    # @deprecated because custom status is not specific to win32 platform.
+    class Status < ::RightScale::RightPopen::ProcessStatus
 
-      # === Parameters
-      # pid(Integer):: Process ID.
-      #
-      # exitstatus(Integer):: Process exit code
       def initialize(pid, exitstatus)
-        @pid = pid
-        @exitstatus = exitstatus
-      end
-
-      # Simulates Process::Status.exited?
-      #
-      # === Returns
-      # true in all cases because this object cannot be returned until the
-      # process exits
-      def exited?
-        return true
-      end
-
-      # Simulates Process::Status.success?
-      #
-      # === Returns
-      # true if the process returned zero as its exit code
-      def success?
-        return @exitstatus ? (0 == @exitstatus) : true;
-      end
-    end
-
-    # === Parameters
-    # options[:target](Object):: Object defining handler methods to be called.
-    # options[:stdout_handler](String):: Token for stdout handler method name.
-    # options[:exit_handler](String):: Token for exit handler method name.
-    # stderr_eventable(Connector):: EM object representing stderr handler.
-    # stream_out(IO):: Standard output stream.
-    # pid(Integer):: Child process ID.
-    def initialize(options, stderr_eventable, stream_out, pid)
-      @target = options[:target]
-      @stdout_handler = options[:stdout_handler]
-      @exit_handler = options[:exit_handler]
-      @stderr_eventable = stderr_eventable
-      @stream_out = stream_out
-      @pid = pid
-      @status = nil
-    end
-
-    # Callback from EM to asynchronously read the stdout stream. Note that this
-    # callback mechanism is deprecated after EM v0.12.8
-    def notify_readable
-      data = RightPopen.async_read(@stream_out)
-      receive_data(data) if (data && data.length > 0)
-      detach unless data
-    end
-
-    # Callback from EM to receive data, which we also use to handle the
-    # asynchronous data we read ourselves.
-    def receive_data(data)
-      @target.method(@stdout_handler).call(data) if @stdout_handler
-    end
-
-    # Override of Connection.get_status() for Windows implementation.
-    def get_status
-      unless @status
-        begin
-          @status = Status.new(@pid, Process.waitpid2(@pid)[1])
-        rescue Process::Error
-          # process is gone, which means we have no recourse to retrieve the
-          # actual exit code; let's be optimistic.
-          @status = Status.new(@pid, 0)
-        end
+        super(pid, exitstatus)
+        warn "WARNING: RightScale::RightPopenEx::Status is deprecated in favor of ::RightScale::RightPopen::ProcessStatus"
       end
-      return @status
-    end
-
-    # Callback from EM to unbind.
-    def unbind
-    # We force the stderr watched handler to go away so that
-      # we don't end up with a broken pipe
-      @stderr_eventable.force_detach if @stderr_eventable
-      @target.method(@exit_handler).call(get_status) if @exit_handler
-      @stream_out.close
-    end
-  end
-
-  # ensure uniqueness of handler to avoid confusion.
-  raise "#{StdErrHandler.name} is already defined" if defined?(StdErrHandler)
-
-  # Provides an eventmachine callback handler for the stderr stream.
-  module StdErrHandler
-
-    # === Parameters
-    # options[:target](Object):: Object defining handler methods to be called.
-    # options[:stderr_handler](Symbol):: Token for stderr handler method name.
-    # stream_err(IO):: Standard error stream.
-    def initialize(options, stream_err)
-      @target = options[:target]
-      @stderr_handler = options[:stderr_handler]
-      @stream_err = stream_err
-      @unbound = false
-    end
-
-    # Callback from EM to asynchronously read the stderr stream. Note that this
-    # callback mechanism is deprecated after EM v0.12.8
-    def notify_readable
-      data = RightPopen.async_read(@stream_err)
-      receive_data(data) if (data && data.length > 0)
-      detach unless data
-    end
-
-    # Callback from EM to receive data, which we also use to handle the
-    # asynchronous data we read ourselves.
-    def receive_data(data)
-      @target.method(@stderr_handler).call(data)
-    end
-
-    # Callback from EM to unbind.
-    def unbind
-      @unbound = true
-      @stream_err.close
     end
 
-    # Forces detachment of the stderr handler on EM's next tick.
-    def force_detach
-      # Use next tick to prevent issue in EM where descriptors list
-      # gets out-of-sync when calling detach in an unbind callback
-      EM.next_tick { detach unless @unbound }
-    end
-  end
-
-  # Creates a child process and connects event handlers to the standard output
-  # and error streams used by the created process. Connectors use named pipes
-  # and asynchronous I/O in the native Windows implementation.
-  #
-  # See RightScale.popen3
-  def self.popen3_imp(options, &block)
-    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(cmd, mode, show_window, asynchronous_output, environment_strings)
-
-    # close input immediately.
-    stream_in.close if options[:input].nil?
-
-    # attach handlers to event machine and let it monitor incoming data. the
-    # 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) 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
-    # running and sends output to the handlers. the caller is not responsible
-    # for waiting for the process to terminate or closing streams as the
-    # watched eventables will handle this automagically. notification will be
-    # sent to the exit_handler on process termination.
-    true
-  end
-
-  protected
-
-  module RightPopenEx
     # Key class for case-insensitive hash insertion/lookup.
     class NoCaseKey
       # Internal key
@@ -490,4 +266,5 @@ module RightScale
     end
 
   end
+
 end