tnargav 1.3.5 → 1.3.6

data/lib/vagrant/util.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    autoload :Busy,                      'vagrant/util/busy'
+    autoload :Counter,                   'vagrant/util/counter'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :SafeExec,                  'vagrant/util/safe_exec'
+    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
+  end
+end

data/lib/vagrant/util/ansi_escape_code_remover.rb

@@ -0,0 +1,34 @@
+module Vagrant
+  module Util
+    module ANSIEscapeCodeRemover
+      # Removes ANSI escape code sequences from the text and returns
+      # it.
+      #
+      # This removes all the ANSI escape codes listed here along with
+      # the escape codes for VT100 terminals:
+      #
+      # http://ascii-table.com/ansi-escape-sequences.php
+      def remove_ansi_escape_codes(text)
+        # An array of regular expressions which match various kinds
+        # of escape sequences. I can't think of a better single regular
+        # expression or any faster way to do this.
+        matchers = [/\e\[\d*[ABCD]/,       # Matches things like \e[4D
+                    /\e\[(\d*;)?\d*[HF]/,  # Matches \e[1;2H or \e[H
+                    /\e\[(s|u|2J|K)/,      # Matches \e[s, \e[2J, etc.
+                    /\e\[=\d*[hl]/,        # Matches \e[=24h
+                    /\e\[\?[1-9][hl]/,     # Matches \e[?2h
+                    /\e\[20[hl]/,          # Matches \e[20l]
+                    /\e[DME78H]/,          # Matches \eD, \eH, etc.
+                    /\e\[[0-2]?[JK]/,      # Matches \e[0J, \e[K, etc.
+                    ]
+
+        # Take each matcher and replace it with emptiness.
+        matchers.each do |matcher|
+          text.gsub!(matcher, "")
+        end
+
+        text
+      end
+    end
+  end
+end

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,151 @@
+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 its expertise.
+    class Downloader
+      # Custom user agent provided to cURL so that requests to URL shorteners
+      # are properly tracked.
+      USER_AGENT = "Vagrant/#{VERSION}"
+
+      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 options 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",
+          "--user-agent", USER_AGENT,
+          "--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