vagrant 1.0.7 → 1.5.0

data/lib/vagrant/ui.rb

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

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

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

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

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

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

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

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

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