tnargav 1.2.2

data/lib/vagrant/util/busy.rb

@@ -0,0 +1,59 @@
+module Vagrant
+  module Util
+    # Utility class which allows blocks of code to be marked as "busy"
+    # with a specified interrupt handler. During busy areas of code, it
+    # is often undesirable for SIGINTs to immediately kill the application.
+    # This class is a helper to cleanly register callbacks to handle this
+    # situation.
+    class Busy
+      @@registered = []
+      @@mutex = Mutex.new
+
+      class << self
+        # Mark a given block of code as a "busy" block of code, which will
+        # register a SIGINT handler for the duration of the block. When a
+        # SIGINT occurs, the `sig_callback` proc will be called. It is up
+        # to the callback to behave properly and exit the application.
+        def busy(sig_callback)
+          register(sig_callback)
+          return yield
+        ensure
+          unregister(sig_callback)
+        end
+
+        # Registers a SIGINT handler. This typically is called from {busy}.
+        # Callbacks are only registered once, so calling this multiple times
+        # with the same callback has no consequence.
+        def register(sig_callback)
+          @@mutex.synchronize do
+            registered << sig_callback
+            registered.uniq!
+
+            # Register the handler if this is our first callback.
+            Signal.trap("INT") { fire_callbacks } if registered.length == 1
+          end
+        end
+
+        # Unregisters a SIGINT handler.
+        def unregister(sig_callback)
+          @@mutex.synchronize do
+            registered.delete(sig_callback)
+
+            # Remove the signal trap if no more registered callbacks exist
+            Signal.trap("INT", "DEFAULT") if registered.empty?
+          end
+        end
+
+        # Fires all the registered callbacks.
+        def fire_callbacks
+          registered.reverse.each { |r| r.call }
+        end
+
+        # Helper method to get access to the class variable. This is mostly
+        # exposed for tests. This shouldn't be mucked with directly, since it's
+        # structure may change at any time.
+        def registered; @@registered; end
+      end
+    end
+  end
+end

data/lib/vagrant/util/counter.rb

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # Atomic counter implementation. This is useful for incrementing
+    # a counter which is guaranteed to only be used once in its class.
+    module Counter
+      def get_and_update_counter(name=nil)
+        name ||= :global
+
+        mutex.synchronize do
+          @__counter ||= Hash.new(1)
+          result = @__counter[name]
+          @__counter[name] += 1
+          result
+        end
+      end
+
+      def mutex
+        @__counter_mutex ||= Mutex.new
+      end
+    end
+  end
+end

data/lib/vagrant/util/downloader.rb

@@ -0,0 +1,146 @@
+require "log4r"
+
+require "vagrant/util/busy"
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    # This class downloads files using various protocols by subprocessing
+    # to cURL. cURL is a much more capable and complete download tool than
+    # a hand-rolled Ruby library, so we defer to it's expertise.
+    class Downloader
+      def initialize(source, destination, options=nil)
+        @logger      = Log4r::Logger.new("vagrant::util::downloader")
+        @source      = source.to_s
+        @destination = destination.to_s
+
+        # Get the various optional values
+        options     ||= {}
+        @insecure    = options[:insecure]
+        @ui          = options[:ui]
+      end
+
+      # This executes the actual download, downloading the source file
+      # to the destination with the given opens used to initialize this
+      # class.
+      #
+      # If this method returns without an exception, the download
+      # succeeded. An exception will be raised if the download failed.
+      def download!
+        # Build the list of parameters to execute with cURL
+        options = [
+          "--fail",
+          "--location",
+          "--max-redirs", "10",
+          "--output", @destination
+        ]
+
+        options << "--insecure" if @insecure
+        options << @source
+
+        # Specify some options for the subprocess
+        subprocess_options = {}
+
+        # If we're in Vagrant, then we use the packaged CA bundle
+        if Vagrant.in_installer?
+          subprocess_options[:env] ||= {}
+          subprocess_options[:env]["CURL_CA_BUNDLE"] =
+            File.expand_path("cacert.pem", ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"])
+        end
+
+        # This variable can contain the proc that'll be sent to
+        # the subprocess execute.
+        data_proc = nil
+
+        if @ui
+          # If we're outputting progress, then setup the subprocess to
+          # tell us output so we can parse it out.
+          subprocess_options[:notify] = :stderr
+
+          progress_data = ""
+          progress_regexp = /(\r(.+?))\r/
+
+          # Setup the proc that'll receive the real-time data from
+          # the downloader.
+          data_proc = Proc.new do |type, data|
+            # Type will always be "stderr" because that is the only
+            # type of data we're subscribed for notifications.
+
+            # Accumulate progress_data
+            progress_data << data
+
+            while true
+              # If we have a full amount of column data (two "\r") then
+              # we report new progress reports. Otherwise, just keep
+              # accumulating.
+              match = progress_regexp.match(progress_data)
+              break if !match
+              data = match[2]
+              progress_data.gsub!(match[1], "")
+
+              # Ignore the first \r and split by whitespace to grab the columns
+              columns = data.strip.split(/\s+/)
+
+              # COLUMN DATA:
+              #
+              # 0 - % total
+              # 1 - Total size
+              # 2 - % received
+              # 3 - Received size
+              # 4 - % transferred
+              # 5 - Transferred size
+              # 6 - Average download speed
+              # 7 - Average upload speed
+              # 9 - Total time
+              # 9 - Time spent
+              # 10 - Time left
+              # 11 - Current speed
+
+              output = "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+              @ui.clear_line
+              @ui.info(output, :new_line => false)
+            end
+          end
+        end
+
+        # Add the subprocess options onto the options we'll execute with
+        options << subprocess_options
+
+        # Create the callback that is called if we are interrupted
+        interrupted  = false
+        int_callback = Proc.new do
+          @logger.info("Downloader interrupted!")
+          interrupted = true
+        end
+
+        @logger.info("Downloader starting download: ")
+        @logger.info("  -- Source: #{@source}")
+        @logger.info("  -- Destination: #{@destination}")
+
+        # Execute!
+        result = Busy.busy(int_callback) do
+          Subprocess.execute("curl", *options, &data_proc)
+        end
+
+        # If the download was interrupted, then raise a specific error
+        raise Errors::DownloaderInterrupted if interrupted
+
+        # If we're outputting to the UI, clear the output to
+        # avoid lingering progress meters.
+        @ui.clear_line if @ui
+
+        # If it didn't exit successfully, we need to parse the data and
+        # show an error message.
+        if result.exit_code != 0
+          @logger.warn("Downloader exit code: #{result.exit_code}")
+          parts    = result.stderr.split(/\n*curl:\s+\(\d+\)\s*/, 2)
+          parts[1] ||= ""
+          raise Errors::DownloaderError, :message => parts[1].chomp
+        end
+
+        # Everything succeeded
+        true
+      end
+    end
+  end
+end

data/lib/vagrant/util/file_checksum.rb

@@ -0,0 +1,38 @@
+# This is an "interface" that should be implemented by any digest class
+# passed into FileChecksum. Note that this isn't strictly enforced at
+# the moment, and this class isn't directly used. It is merely here for
+# documentation of structure of the class.
+class DigestClass
+  def update(string); end
+  def hexdigest; end
+end
+
+class FileChecksum
+  BUFFER_SIZE = 1024
+
+  # Initializes an object to calculate the checksum of a file. The given
+  # ``digest_klass`` should implement the ``DigestClass`` interface. Note
+  # that the built-in Ruby digest classes duck type this properly:
+  # Digest::MD5, Digest::SHA1, etc.
+  def initialize(path, digest_klass)
+    @digest_klass = digest_klass
+    @path   = path
+  end
+
+  # This calculates the checksum of the file and returns it as a
+  # string.
+  #
+  # @return [String]
+  def checksum
+    digest= @digest_klass.new
+
+    File.open(@path, "r") do |f|
+      while !f.eof
+        buf = f.readpartial(BUFFER_SIZE)
+        digest.update(buf)
+      end
+    end
+
+    return digest.hexdigest
+  end
+end

data/lib/vagrant/util/file_mode.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    class FileMode
+      # This returns the file permissions as a string from
+      # an octal number.
+      def self.from_octal(octal)
+        perms = sprintf("%o", octal)
+        perms.reverse[0..2].reverse
+      end
+    end
+  end
+end

data/lib/vagrant/util/hash_with_indifferent_access.rb

@@ -0,0 +1,63 @@
+module Vagrant
+  module Util
+    # A hash with indifferent access. Mostly taken from Thor/Rails (thanks).
+    # Normally I'm not a fan of using an indifferent access hash since Symbols
+    # are basically memory leaks in Ruby, but since Vagrant is typically a quick
+    # one-off binary run and it doesn't use too many hash keys where this is
+    # used, the effect should be minimal.
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #
+    class HashWithIndifferentAccess < ::Hash
+      def initialize(hash={}, &block)
+        super(&block)
+
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+    end
+  end
+end

data/lib/vagrant/util/is_port_open.rb

@@ -0,0 +1,38 @@
+require "socket"
+require "timeout"
+
+module Vagrant
+  module Util
+    # Contains the method {#is_ruby_open?} to check if a port is open
+    # (listening) or closed (not in use). This method isn't completely
+    # fool-proof, but it works enough of the time to be useful.
+    module IsPortOpen
+      # Checks if a port is open (listening) on a given host and port.
+      #
+      # @param [String] host Hostname or IP address.
+      # @param [Integer] port Port to check.
+      # @return [Boolean] `true` if the port is open (listening), `false`
+      #   otherwise.
+      def is_port_open?(host, port)
+        # We wrap this in a timeout because once in awhile the TCPSocket
+        # _will_ hang, but this signals that the port is closed.
+        Timeout.timeout(1) do
+          # Attempt to make a connection
+          s = TCPSocket.new(host, port)
+
+          # A connection was made! Properly clean up the socket, not caring
+          # at all if any exception is raised, because we already know the
+          # result.
+          s.close rescue nil
+
+          # The port is open if we reached this point, since we were able
+          # to connect.
+          return true
+        end
+      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+        # Any of the above exceptions signal that the port is closed.
+        return false
+      end
+    end
+  end
+end

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,58 @@
+require 'rbconfig'
+
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def cygwin?
+          return true if ENV["VAGRANT_DETECTED_OS"] &&
+            ENV["VAGRANT_DETECTED_OS"].downcase.include?("cygwin")
+
+          platform.include?("cygwin")
+        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
+
+        # This takes any path and converts it to a full-length Windows
+        # path on Windows machines in Cygwin.
+        #
+        # @return [String]
+        def cygwin_windows_path(path)
+          return path if !cygwin?
+
+          process = Subprocess.execute("cygpath", "-w", "-l", "-a", path.to_s)
+          process.stdout.chomp
+        end
+
+        # Returns a boolean noting whether the terminal supports color.
+        # output.
+        def terminal_supports_colors?
+          if windows?
+            return ENV.has_key?("ANSICON") || cygwin?
+          end
+
+          true
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,31 @@
+require "log4r"
+
+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)
+        logger = nil
+        opts   = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on] => e
+          if (opts[:tries] -= 1) > 0
+            logger = Log4r::Logger.new("vagrant::util::retryable")
+            logger.info("Retryable exception raised: #{e.inspect}")
+
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_chdir.rb

@@ -0,0 +1,33 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    class SafeChdir
+      @@chdir_lock  = Mutex.new
+
+      # Safely changes directory of this process by putting a lock around
+      # it so that it is thread safe. This will yield a block and when the
+      # block exits it changes back to the original directory.
+      #
+      # @param [String] dir Dir to change to temporarily
+      def self.safe_chdir(dir)
+        lock = @@chdir_lock
+
+        begin
+          @@chdir_lock.synchronize {}
+        rescue ThreadError
+          # If we already hold the lock, just create a new lock so we
+          # definitely don't block and don't get an error.
+          lock = Mutex.new
+        end
+
+        lock.synchronize do
+          Dir.chdir(dir) do
+            return yield
+          end
+        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.
+    class SafeExec
+      def self.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/scoped_hash_override.rb

@@ -0,0 +1,45 @@
+module Vagrant
+  module Util
+    # This allows for hash options to be overridden by a scope key
+    # prefix. An example speaks best here. Imagine the following hash:
+    #
+    #     original = {
+    #       :id => "foo",
+    #       :mitchellh__id => "bar",
+    #       :mitchellh__other => "foo"
+    #     }
+    #
+    #     scoped = scoped_hash_override(original, "mitchellh")
+    #
+    #     scoped == {
+    #       :id => "bar",
+    #       :other => "foo"
+    #     }
+    #
+    module ScopedHashOverride
+      def scoped_hash_override(original, scope)
+        # Convert the scope to a string in case a symbol was given since
+        # we use string comparisons for everything.
+        scope = scope.to_s
+
+        # Shallow copy the hash for the result
+        result = original.dup
+
+        original.each do |key, value|
+          parts = key.to_s.split("__", 2)
+
+          # If we don't have the proper parts, then bail
+          next if parts.length != 2
+
+          # If this is our scope, then override
+          if parts[0] == scope
+            result[parts[1].to_sym] = value
+            result.delete(key)
+          end
+        end
+
+        result
+      end
+    end
+  end
+end