boxcar 0.10005.1

data/lib/vagrant/ui.rb

@@ -0,0 +1,168 @@
+require "log4r"
+
+require "vagrant/util/safe_puts"
+
+module Vagrant
+  module UI
+    # Vagrant UIs handle communication with the outside world (typically
+    # through a shell). They must respond to the following methods:
+    #
+    # * `info`
+    # * `warn`
+    # * `error`
+    # * `success`
+    class Interface
+      attr_accessor :resource
+
+      def initialize(resource)
+        @logger   = Log4r::Logger.new("vagrant::ui::interface")
+        @resource = resource
+      end
+
+      [:ask, :warn, :error, :info, :success].each do |method|
+        define_method(method) do |message, *opts|
+          # Log normal console messages
+          @logger.info { "#{method}: #{message}" }
+        end
+      end
+
+      [:clear_line, :report_progress].each do |method|
+        # By default do nothing, these aren't logged
+        define_method(method) { |*args| }
+      end
+    end
+
+    # This is a UI implementation that does nothing.
+    class Silent < Interface
+      def ask(*args)
+        super
+
+        # Silent can't do this, obviously.
+        raise Errors::UIExpectsTTY
+      end
+    end
+
+    # This is a UI implementation that outputs the text as is. It
+    # doesn't add any color.
+    class Basic < Interface
+      include Util::SafePuts
+
+      # Use some light meta-programming to create the various methods to
+      # output text to the UI. These all delegate the real functionality
+      # to `say`.
+      [:info, :warn, :error, :success].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, *args)
+            super(message)
+            say(#{method.inspect}, message, *args)
+          end
+        CODE
+      end
+
+      def ask(message, opts=nil)
+        super(message)
+
+        # We can't ask questions when the output isn't a TTY.
+        raise Errors::UIExpectsTTY if !$stdin.tty?
+
+        # Setup the options so that the new line is suppressed
+        opts ||= {}
+        opts[:new_line] = false if !opts.has_key?(:new_line)
+        opts[:prefix]   = false if !opts.has_key?(:prefix)
+
+        # Output the data
+        say(:info, message, opts)
+
+        # Get the results and chomp off the newline
+        $stdin.gets.chomp
+      end
+
+      # This is used to output progress reports to the UI.
+      # Send this method progress/total and it will output it
+      # to the UI. Send `clear_line` to clear the line to show
+      # a continuous progress meter.
+      def report_progress(progress, total, show_parts=true)
+        if total && total > 0
+          percent = (progress.to_f / total.to_f) * 100
+          line    = "Progress: #{percent.to_i}%"
+          line   << " (#{progress} / #{total})" if show_parts
+        else
+          line    = "Progress: #{progress}"
+        end
+
+        info(line, :new_line => false)
+      end
+
+      def clear_line
+        reset = "\r"
+        reset += "\e[0K" unless Util::Platform.windows?
+        reset
+
+        info(reset, :new_line => false)
+      end
+
+      # This method handles actually outputting a message of a given type
+      # to the console.
+      def say(type, message, opts=nil)
+        defaults = { :new_line => true, :prefix => true }
+        opts     = defaults.merge(opts || {})
+
+        # Determine whether we're expecting to output our
+        # own new line or not.
+        printer = opts[:new_line] ? :puts : :print
+
+        # Determine the proper IO channel to send this message
+        # to based on the type of the message
+        channel = type == :error || opts[:channel] == :error ? $stderr : $stdout
+
+        # Output!
+        safe_puts(format_message(type, message, opts),
+                  :io => channel, :printer => printer)
+      end
+
+      # This is called by `say` to format the message for output.
+      def format_message(type, message, opts=nil)
+        opts ||= {}
+        message = "[#{@resource}] #{message}" if opts[:prefix]
+        message
+      end
+    end
+
+    # This is a UI implementation that outputs color for various types
+    # of messages. This should only be used with a TTY that supports color,
+    # but is up to the user of the class to verify this is the case.
+    class Colored < Basic
+      # Terminal colors
+      COLORS = {
+        :clear  => "\e[0m",
+        :red    => "\e[31m",
+        :green  => "\e[32m",
+        :yellow => "\e[33m"
+      }
+
+      # Mapping between type of message and the color to output
+      COLOR_MAP = {
+        :warn    => COLORS[:yellow],
+        :error   => COLORS[:red],
+        :success => COLORS[:green]
+      }
+
+      # This is called by `say` to format the message for output.
+      def format_message(type, message, opts=nil)
+        # Get the format of the message before adding color.
+        message = super
+
+        # Colorize the message if there is a color for this type of message,
+        # either specified by the options or via the default color map.
+        if opts.has_key?(:color)
+          color   = COLORS[opts[:color]]
+          message = "#{color}#{message}#{COLORS[:clear]}"
+        else
+          message = "#{COLOR_MAP[type]}#{message}#{COLORS[:clear]}" if COLOR_MAP[type]
+        end
+
+        message
+      end
+    end
+  end
+end

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)
+          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/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
+        # Any of the above exceptions signal that the port is closed.
+        return false
+      end
+    end
+  end
+end