vagrant 1.0.7 → 1.5.0

data/lib/vagrant/util/line_ending_helpers.rb

@@ -1,14 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,247 +0,0 @@
-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