vagrant 0.8.10 → 0.9.0

data/lib/vagrant/ui.rb

@@ -1,80 +1,148 @@
+require "log4r"
+
 module Vagrant
-  # Vagrant UIs handle communication with the outside world (typically
-  # through a shell). They must respond to the typically logger methods
-  # of `warn`, `error`, `info`, and `confirm`.
-  class UI
-    attr_accessor :env
-
-    def initialize(env)
-      @env = env
-    end
+  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
 
-    [:warn, :error, :info, :confirm].each do |method|
-      define_method(method) do |message, *opts|
-        # Log normal console messages
-        env.logger.info("ui") { message }
+      def initialize(resource)
+        @logger   = Log4r::Logger.new("vagrant::ui::interface")
+        @resource = resource
       end
-    end
-
-    [:clear_line, :report_progress, :ask, :no?, :yes?].each do |method|
-      # By default do nothing, these aren't logged
-      define_method(method) { |*args| }
-    end
 
-    # A shell UI, which uses a `Thor::Shell` object to talk with
-    # a terminal.
-    class Shell < UI
-      def initialize(env, shell)
-        super(env)
+      [:ask, :warn, :error, :info, :success].each do |method|
+        define_method(method) do |message, *opts|
+          # Log normal console messages
+          @logger.info { "#{method}: #{message}" }
+        end
+      end
 
-        @shell = shell
+      [: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; end
 
-      [[:warn, :yellow], [:error, :red], [:info, nil], [:confirm, :green]].each do |method, color|
+    # This is a UI implementation that outputs the text as is. It
+    # doesn't add any color.
+    class Basic < Interface
+      # 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, opts=nil)
+          def #{method}(message, *args)
             super(message)
-            opts ||= {}
-            opts[:new_line] = true if !opts.has_key?(:new_line)
-            @shell.say("\#{format_message(message, opts)}", #{color.inspect}, opts[:new_line])
+            say(#{method.inspect}, message, *args)
           end
         CODE
       end
 
-      [:ask, :no?, :yes?].each do |method|
-        class_eval <<-CODE
-          def #{method}(message, opts=nil)
-            super(message)
-            opts ||= {}
-            @shell.send(#{method.inspect}, format_message(message, opts), opts[:color])
-          end
-        CODE
+      def ask(message, opts=nil)
+        super(message)
+
+        # 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)
         percent = (progress.to_f / total.to_f) * 100
-        line = "Progress: #{percent.to_i}%"
-        line << " (#{progress} / #{total})" if show_parts
+        line    = "Progress: #{percent.to_i}%"
+        line   << " (#{progress} / #{total})" if show_parts
 
-        @shell.say(line, nil, false)
+        info(line, :new_line => false)
       end
 
       def clear_line
-        @shell.say(line_reset, nil, false)
+        reset = "\r"
+        reset += "\e[0K" unless Util::Platform.windows?
+        reset
+
+        info(reset, :new_line => false)
       end
 
-      protected
+      # 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
 
-      def format_message(message, opts=nil)
-        opts = { :prefix => true }.merge(opts || {})
-        message = "[#{env.resource}] #{message}" if opts[:prefix]
+        # 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!
+        channel.send(printer, format_message(type, message, opts))
+      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
 
-      def line_reset
-        reset = "\r"
-        reset += "\e[0K" unless Util::Platform.windows?
-        reset
+    # 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

data/lib/vagrant/util/busy.rb

@@ -46,7 +46,7 @@ module Vagrant
 
         # Fires all the registered callbacks.
         def fire_callbacks
-          registered.each { |r| r.call }
+          registered.reverse.each { |r| r.call }
         end
 
         # Helper method to get access to the class variable. This is mostly

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/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

@@ -1,4 +1,5 @@
 require 'rbconfig'
+require 'tempfile'
 
 module Vagrant
   module Util

data/lib/vagrant/util/subprocess.rb

@@ -0,0 +1,227 @@
+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
+
+        # Close the writer pipes, since we're just reading
+        stdout_writer.close
+        stderr_writer.close
+
+        # 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[r] += 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_data[io] += extra_data
+
+          # Yield to any listeners any remaining data
+          io_name = io == stdout ? :stdout : :stderr
+          yield io_name, extra_data if block_given?
+        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.
+              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