vagrant-fixed-ssh 1.0.7

data/lib/vagrant/util/line_ending_helpers.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  module Util
+    module LineEndingHelpers
+      # Converts line endings to unix-style line endings in the
+      # given string.
+      #
+      # @param [String] string Original string
+      # @return [String] The fixed string
+      def dos_to_unix(string)
+        string.gsub("\r\n", "\n")
+      end
+    end
+  end
+end

data/lib/vagrant/util/network_ip.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  module Util
+    module NetworkIP
+      # Returns the network address of the given IP and subnet.
+      #
+      # @return [String]
+      def network_address(ip, subnet)
+        ip      = ip_parts(ip)
+        netmask = ip_parts(subnet)
+
+        # Bitwise-AND each octet to get the network address
+        # in octets and join each part with a period to get
+        # the resulting network address.
+        ip.map { |part| part & netmask.shift }.join(".")
+      end
+
+      protected
+
+      # Splits an IP into the four octets and returns each as an
+      # integer in an array.
+      #
+      # @return [Array<Integer>]
+      def ip_parts(ip)
+        ip.split(".").map { |i| i.to_i }
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -0,0 +1,68 @@
+require 'rbconfig'
+require 'tempfile'
+
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def tiger?
+          platform.include?("darwin8")
+        end
+
+        def leopard?
+          platform.include?("darwin9")
+        end
+
+        [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
+          define_method("#{type}?") do
+            platform.include?(type.to_s)
+          end
+        end
+
+        def windows?
+          %W[mingw mswin].each do |text|
+            return true if platform.include?(text)
+          end
+
+          false
+        end
+
+        # Returns boolean noting whether this is a 64-bit CPU. This
+        # is not 100% accurate and there could easily be false negatives.
+        #
+        # @return [Boolean]
+        def bit64?
+          ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
+        end
+
+        # Returns boolean noting whether this is a 32-bit CPU. This
+        # can easily throw false positives since it relies on {#bit64?}.
+        #
+        # @return [Boolean]
+        def bit32?
+          !bit64?
+        end
+
+        # Returns a boolean noting whether the terminal supports color.
+        # output.
+        def terminal_supports_colors?
+          if windows?
+            return ENV.has_key?("ANSICON")
+          end
+
+          true
+        end
+
+        def tar_file_options
+          # create, write only, fail if the file exists, binary if windows
+          File::WRONLY | File::EXCL | File::CREAT | (windows? ? File::BINARY : 0)
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,25 @@
+module Vagrant
+  module Util
+    module Retryable
+      # Retries a given block a specified number of times in the
+      # event the specified exception is raised. If the retries
+      # run out, the final exception is raised.
+      #
+      # This code is adapted slightly from the following blog post:
+      # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+      def retryable(opts=nil)
+        opts = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on]
+          if (opts[:tries] -= 1) > 0
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_exec.rb

@@ -0,0 +1,36 @@
+module Vagrant
+  module Util
+    # This module provies a `safe_exec` method which is a drop-in
+    # replacement for `Kernel.exec` which addresses a specific issue
+    # which manifests on OS X 10.5 (GH-51) and perhaps other operating systems.
+    # This issue causes `exec` to fail if there is more than one system
+    # thread. In that case, `safe_exec` automatically falls back to
+    # forking.
+    module SafeExec
+      def safe_exec(command, *args)
+        # Create a list of things to rescue from. Since this is OS
+        # specific, we need to do some defined? checks here to make
+        # sure they exist.
+        rescue_from = []
+        rescue_from << Errno::EOPNOTSUPP if defined?(Errno::EOPNOTSUPP)
+        rescue_from << Errno::E045 if defined?(Errno::E045)
+        rescue_from << SystemCallError
+
+        fork_instead = false
+        begin
+          pid = nil
+          pid = fork if fork_instead
+          Kernel.exec(command, *args) if pid.nil?
+          Process.wait(pid) if pid
+        rescue *rescue_from
+          # We retried already, raise the issue and be done
+          raise if fork_instead
+
+          # The error manifested itself, retry with a fork.
+          fork_instead = true
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_puts.rb

@@ -0,0 +1,31 @@
+module Vagrant
+  module Util
+    # This module provides a `safe_puts` method which outputs to
+    # the given IO object, and rescues any broken pipe errors and
+    # ignores them. This is useful in cases where you're outputting
+    # to stdout, for example, and the stdout is closed, but you want to
+    # keep running.
+    module SafePuts
+      # Uses `puts` on the given IO object and safely ignores any
+      # Errno::EPIPE.
+      #
+      # @param [String] message Message to output.
+      # @param [Hash] opts Options hash.
+      def safe_puts(message=nil, opts=nil)
+        message ||= ""
+        opts = {
+          :io => $stdout,
+          :printer => :puts
+        }.merge(opts || {})
+
+        begin
+          opts[:io].send(opts[:printer], message)
+        rescue Errno::EPIPE
+          # This is what makes this a `safe` puts.
+          return
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/util/stacked_proc_runner.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # Represents the "stacked proc runner" behavior which is used a
+    # couple places within Vagrant. This allows procs to "stack" on
+    # each other, then all execute in a single action. An example of
+    # its uses can be seen in the {Config} class.
+    module StackedProcRunner
+      # Returns the proc stack. This should always be called as the
+      # accessor of the stack. The instance variable itself should _never_
+      # be used.
+      #
+      # @return [Array<Proc>]
+      def proc_stack
+        @_proc_stack ||= []
+      end
+
+      # Adds (pushes) a proc to the stack. The actual proc added here is
+      # not executed, but merely stored.
+      #
+      # @param [Proc] block
+      def push_proc(&block)
+        proc_stack << block
+      end
+
+      # Executes all the procs on the stack, passing in the given arguments.
+      # The stack is not cleared afterwords. It is up to the user of this
+      # mixin to clear the stack by calling `proc_stack.clear`.
+      def run_procs!(*args)
+        proc_stack.each do |proc|
+          proc.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/subprocess.rb

@@ -0,0 +1,247 @@
+require 'childprocess'
+require 'log4r'
+
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Util
+    # Execute a command in a subprocess, gathering the results and
+    # exit status.
+    #
+    # This class also allows you to read the data as it is outputted
+    # from the subprocess in real time, by simply passing a block to
+    # the execute method.
+    class Subprocess
+      # The chunk size for reading from subprocess IO.
+      READ_CHUNK_SIZE = 4096
+
+      # Convenience method for executing a method.
+      def self.execute(*command, &block)
+        new(*command).execute(&block)
+      end
+
+      def initialize(*command)
+        @options = command.last.is_a?(Hash) ? command.pop : {}
+        @command = command
+        @logger  = Log4r::Logger.new("vagrant::util::subprocess")
+      end
+
+      def execute
+        # Get the timeout, if we have one
+        timeout = @options[:timeout]
+        workdir = @options[:workdir] || Dir.pwd
+
+        # Build the ChildProcess
+        @logger.info("Starting process: #{@command.inspect}")
+        process = ChildProcess.build(*@command)
+
+        # Create the pipes so we can read the output in real time as
+        # we execute the command.
+        stdout, stdout_writer = IO.pipe
+        stderr, stderr_writer = IO.pipe
+        process.io.stdout = stdout_writer
+        process.io.stderr = stderr_writer
+        process.duplex = true
+
+        # Set the environment on the process if we must
+        if @options[:env]
+          @options[:env].each do |k, v|
+            process.environment[k] = v
+          end
+        end
+
+        # Start the process
+        begin
+          Dir.chdir(workdir) do
+            process.start
+          end
+        rescue ChildProcess::LaunchError
+          # Raise our own version of the error so that users of the class
+          # don't need to be aware of ChildProcess
+          raise LaunchError
+        end
+
+        # Make sure the stdin does not buffer
+        process.io.stdin.sync = true
+
+        if RUBY_PLATFORM != "java"
+          # On Java, we have to close after. See down the method...
+          # Otherwise, we close the writers right here, since we're
+          # not on the writing side.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Create a dictionary to store all the output we see.
+        io_data = { :stdout => "", :stderr => "" }
+
+        # Record the start time for timeout purposes
+        start_time = Time.now.to_i
+
+        @logger.debug("Selecting on IO")
+        while true
+          results = IO.select([stdout, stderr], [process.io.stdin], nil, timeout || 5)
+          readers, writers = results
+
+          # Check if we have exceeded our timeout
+          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+          # Check the readers to see if they're ready
+          if !readers.empty?
+            readers.each do |r|
+              # Read from the IO object
+              data = read_io(r)
+
+              # We don't need to do anything if the data is empty
+              next if data.empty?
+
+              io_name = r == stdout ? :stdout : :stderr
+              @logger.debug("#{io_name}: #{data}")
+
+              io_data[io_name] += data
+              yield io_name, data if block_given?
+            end
+          end
+
+          # Break out if the process exited. We have to do this before
+          # attempting to write to stdin otherwise we'll get a broken pipe
+          # error.
+          break if process.exited?
+
+          # Check the writers to see if they're ready, and notify any listeners
+          if !writers.empty?
+            yield :stdin, process.io.stdin if block_given?
+          end
+        end
+
+        # Wait for the process to end.
+        begin
+          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+          remaining = 0 if remaining < 0
+          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
+
+          process.poll_for_exit(remaining)
+        rescue ChildProcess::TimeoutError
+          raise TimeoutExceeded, process.pid
+        end
+
+        @logger.debug("Exit status: #{process.exit_code}")
+
+        # Read the final output data, since it is possible we missed a small
+        # amount of text between the time we last read data and when the
+        # process exited.
+        [stdout, stderr].each do |io|
+          # Read the extra data, ignoring if there isn't any
+          extra_data = read_io(io)
+          next if extra_data == ""
+
+          # Log it out and accumulate
+          @logger.debug(extra_data)
+          io_name = io == stdout ? :stdout : :stderr
+          io_data[io_name] += extra_data
+
+          # Yield to any listeners any remaining data
+          yield io_name, extra_data if block_given?
+        end
+
+        if RUBY_PLATFORM == "java"
+          # On JRuby, we need to close the writers after the process,
+          # for some reason. See GH-711.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Return an exit status container
+        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+      end
+
+      protected
+
+      # Reads data from an IO object while it can, returning the data it reads.
+      # When it encounters a case when it can't read anymore, it returns the
+      # data.
+      #
+      # @return [String]
+      def read_io(io)
+        data = ""
+
+        while true
+          begin
+            if Platform.windows?
+              # Windows doesn't support non-blocking reads on
+              # file descriptors or pipes so we have to get
+              # a bit more creative.
+
+              # Check if data is actually ready on this IO device.
+              # We have to do this since `readpartial` will actually block
+              # until data is available, which can cause blocking forever
+              # in some cases.
+              results = IO.select([io], nil, nil, 1)
+              break if !results || results[0].empty?
+
+              # Read!
+              data << io.readpartial(READ_CHUNK_SIZE)
+            else
+              # Do a simple non-blocking read on the IO object
+              data << io.read_nonblock(READ_CHUNK_SIZE)
+            end
+          rescue Exception => e
+            # The catch-all rescue here is to support multiple Ruby versions,
+            # since we use some Ruby 1.9 specific exceptions.
+
+            breakable = false
+            if e.is_a?(EOFError)
+              # An `EOFError` means this IO object is done!
+              breakable = true
+            elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
+              # IO::WaitReadable is only available on Ruby 1.9+
+
+              # An IO::WaitReadable means there may be more IO but this
+              # IO object is not ready to be read from yet. No problem,
+              # we read as much as we can, so we break.
+              breakable = true
+            elsif e.is_a?(Errno::EAGAIN)
+              # Otherwise, we just look for the EAGAIN error which should be
+              # all that IO::WaitReadable does in Ruby 1.9.
+              breakable = true
+            end
+
+            # Break out if we're supposed to. Otherwise re-raise the error
+            # because it is a real problem.
+            break if breakable
+            raise
+          end
+        end
+
+        data
+      end
+
+      # An error which raises when a process fails to start
+      class LaunchError < StandardError; end
+
+      # An error which occurs when the process doesn't end within
+      # the given timeout.
+      class TimeoutExceeded < StandardError
+        attr_reader :pid
+
+        def initialize(pid)
+          super()
+          @pid = pid
+        end
+      end
+
+      # Container class to store the results of executing a subprocess.
+      class Result
+        attr_reader :exit_code
+        attr_reader :stdout
+        attr_reader :stderr
+
+        def initialize(exit_code, stdout, stderr)
+          @exit_code = exit_code
+          @stdout    = stdout
+          @stderr    = stderr
+        end
+      end
+    end
+  end
+end