vagrantup 0.5.4 → 0.6.0

data/lib/vagrant/ui.rb

@@ -0,0 +1,65 @@
+require 'mario'
+
+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
+
+    [:warn, :error, :info, :confirm, :say_with_vm, :report_progress, :ask, :no?, :yes?].each do |method|
+      # By default these methods don't do anything. A silent UI.
+      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)
+
+        @shell = shell
+      end
+
+      [[:warn, :yellow], [:error, :red], [:info, nil], [:confirm, :green]].each do |method, color|
+        define_method(method) do |message, opts=nil|
+          @shell.say("#{line_reset}#{format_message(message, opts)}", color)
+        end
+      end
+
+      [:ask, :no?, :yes?].each do |method|
+        define_method(method) do |message, opts=nil|
+          opts ||= {}
+          @shell.send(method, format_message(message, opts), opts[:color])
+        end
+      end
+
+      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 = "#{line_reset}#{line}"
+
+        @shell.say(line, nil, false)
+      end
+
+      protected
+
+      def format_message(message, opts=nil)
+        opts = { :prefix => true }.merge(opts || {})
+        message = "[#{env.resource}] #{message}" if opts[:prefix]
+        message
+      end
+
+      def line_reset
+        reset = "\r"
+        reset += "\e[0K" unless Mario::Platform.windows?
+        reset
+      end
+    end
+  end
+end

data/lib/vagrant/util.rb

@@ -1,23 +1,13 @@
 module Vagrant
   module Util
-    def self.included(base)
-      base.extend(self)
-    end
-
-    def error_and_exit(key, data = {})
-      abort <<-error
-=====================================================================
-Vagrant experienced an error!
-
-#{Translator.t(key, data).chomp}
-=====================================================================
-error
-    end
-
-    def wrap_output
-      puts "====================================================================="
-      yield
-      puts "====================================================================="
-    end
+    autoload :Busy,                      'vagrant/util/busy'
+    autoload :GlobLoader,                'vagrant/util/glob_loader'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :PlainLogger,               'vagrant/util/plain_logger'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :ResourceLogger,            'vagrant/util/resource_logger'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
   end
 end

data/lib/vagrant/util/glob_loader.rb

@@ -1,22 +1,24 @@
 module Vagrant
-  # Eases the processes of loading specific files then globbing
-  # the rest from a specified directory.
-  module GlobLoader
-    # Glob requires all ruby files in a directory, optionally loading select
-    # files initially (since others may depend on them).
-    #
-    # @param [String] dir The directory to glob
-    # @param [Array<String>] initial_files Initial files (relative to `dir`)
-    #   to load
-    def self.glob_require(dir, initial_files=[])
-      initial_files.each do |file|
-        require File.expand_path(file, dir)
-      end
+  module Util
+    # Eases the processes of loading specific files then globbing
+    # the rest from a specified directory.
+    module GlobLoader
+      # Glob requires all ruby files in a directory, optionally loading select
+      # files initially (since others may depend on them).
+      #
+      # @param [String] dir The directory to glob
+      # @param [Array<String>] initial_files Initial files (relative to `dir`)
+      #   to load
+      def self.glob_require(dir, initial_files=[])
+        initial_files.each do |file|
+          require File.expand_path(file, dir)
+        end
 
-      # Glob require the rest
-      Dir[File.join(dir, "**", "*.rb")].each do |f|
-        require File.expand_path(f)
+        # Glob require the rest
+        Dir[File.join(dir, "**", "*.rb")].each do |f|
+          require File.expand_path(f)
+        end
       end
     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 sine 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/plain_logger.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Vagrant
   module Util
     # Subclass of the standard library logger which has no format on

data/lib/vagrant/util/platform.rb

@@ -1,3 +1,5 @@
+require 'mario'
+
 module Vagrant
   module Util
     # This class just contains some platform checking code.

data/lib/vagrant/util/resource_logger.rb

@@ -11,14 +11,8 @@ module Vagrant
     #
     # This class is thread safe. The backing class which actually does
     # all the logging IO is protected.
-    #
-    # This class also handles progress meters of multiple resources and
-    # handles all the proper interleaving and console updating to
-    # display the progress meters in a way which doesn't conflict with
-    # other incoming log messages.
     class ResourceLogger
       @@singleton_logger = nil
-      @@progress_reporters = nil
       @@writer_lock = Mutex.new
 
       # The resource which this logger represents.
@@ -37,10 +31,11 @@ module Vagrant
         # instantiated, then the given environment will be used to
         # create a new logger.
         def singleton_logger(env=nil)
-          if env && env.config && env.config.loaded?
-            @@singleton_logger ||= PlainLogger.new(env.config.vagrant.log_output)
-          else
-            PlainLogger.new(nil)
+          return PlainLogger.new(nil) if !env.loaded?
+
+          @@singleton_logger ||= begin
+            file = env.log_path.join("#{Time.now.to_i}.log")
+            PlainLogger.new(file)
           end
         end
 
@@ -48,12 +43,6 @@ module Vagrant
         def reset_singleton_logger!
           @@singleton_logger = nil
         end
-
-        # Returns the progress parts array which contains the various
-        # progress reporters.
-        def progress_reporters
-          @@progress_reporters ||= {}
-        end
       end
 
       def initialize(resource, env)
@@ -65,64 +54,10 @@ module Vagrant
       [:debug, :info, :error, :fatal].each do |method|
         define_method(method) do |message|
           @@writer_lock.synchronize do
-            # We clear the line in case progress reports have been going
-            # out.
-            print(cl_reset)
             logger.send(method, "[#{resource}] #{message}")
           end
-
-          # Once again flush the progress reporters since we probably
-          # cleared any existing ones.
-          flush_progress
         end
       end
-
-      # Sets a progress report for the resource that this logger
-      # represents. This progress report is interleaved within the output.
-      def report_progress(progress, total, show_parts=true)
-        # Simply add the progress reporter to the list of progress
-        # reporters
-        self.class.progress_reporters[resource] = {
-          :progress => progress,
-          :total => total,
-          :show_parts => show_parts
-        }
-
-        # And force an update to occur
-        flush_progress
-      end
-
-      # Clears the progress report for this resource
-      def clear_progress
-        self.class.progress_reporters.delete(resource)
-      end
-
-      def flush_progress
-        # Don't do anything if there are no progress reporters
-        return if self.class.progress_reporters.length <= 0
-
-        @@writer_lock.synchronize do
-          reports = []
-
-          # First generate all the report percentages and output
-          self.class.progress_reporters.each do |name, data|
-            percent = (data[:progress].to_f / data[:total].to_f) * 100
-            line = "#{name}: #{percent.to_i}%"
-            line << " (#{data[:progress]} / #{data[:total]})" if data[:show_parts]
-            reports << line
-          end
-
-          # Output it to stdout
-          print "#{cl_reset}[progress] #{reports.join(" ")}"
-          $stdout.flush
-        end
-      end
-
-      def cl_reset
-        reset = "\r"
-        reset += "\e[0K" unless Mario::Platform.windows?
-        reset
-      end
     end
   end
 end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,25 @@
+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)
+        opts = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue opts[:on]
+          if (opts[:tries] -= 1) > 0
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/template_renderer.rb

@@ -76,7 +76,7 @@ module Vagrant
       #
       # @return [String]
       def full_template_path
-        File.join(PROJECT_ROOT, 'templates', "#{template}.erb").squeeze("/")
+        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
       end
     end
   end

data/lib/vagrant/version.rb

@@ -2,5 +2,5 @@ module Vagrant
   # This will always be up to date with the current version of Vagrant,
   # since it is used to generate the gemspec and is also the source of
   # the version for `vagrant -v`
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/lib/vagrant/vm.rb

@@ -5,14 +5,14 @@ module Vagrant
     attr_reader :env
     attr_reader :system
     attr_reader :name
-    attr_accessor :vm
+    attr_reader :vm
 
     class << self
       # Finds a virtual machine by a given UUID and either returns
       # a Vagrant::VM object or returns nil.
-      def find(uuid, env=nil, vm_name=nil)
+      def find(uuid, env=nil, name=nil)
         vm = VirtualBox::VM.find(uuid)
-        new(:vm => vm, :env => env, :vm_name => vm_name)
+        new(:vm => vm, :env => env, :name => name)
       end
     end
 
@@ -20,13 +20,13 @@ module Vagrant
       defaults = {
         :vm => nil,
         :env => nil,
-        :vm_name => nil
+        :name => nil
       }
 
       opts = defaults.merge(opts || {})
 
       @vm = opts[:vm]
-      @name = opts[:vm_name]
+      @name = opts[:name]
 
       if !opts[:env].nil?
         # We have an environment, so we create a new child environment
@@ -35,7 +35,6 @@ module Vagrant
         @env = Vagrant::Environment.new({
           :cwd => opts[:env].cwd,
           :parent => opts[:env],
-          :vm_name => opts[:vm_name],
           :vm => self
         }).load!
 
@@ -54,19 +53,15 @@ module Vagrant
 
       if system.is_a?(Class)
         @system = system.new(self)
-        error_and_exit(:system_invalid_class, :system => system.to_s) unless @system.is_a?(Systems::Base)
+        raise Errors::VMSystemError.new(:_key => :invalid_class, :system => system.to_s) if !@system.is_a?(Systems::Base)
       elsif system.is_a?(Symbol)
         # Hard-coded internal systems
         mapping = { :linux => Systems::Linux }
 
-        if !mapping.has_key?(system)
-          error_and_exit(:system_unknown_type, :system => system.to_s)
-          return # for tests
-        end
-
+        raise Errors::VMSystemError.new(:_key => :unknown_type, :system => system.to_s) if !mapping.has_key?(system)
         @system = mapping[system].new(self)
       else
-        error_and_exit(:system_unspecified)
+        raise Errors::VMSystemError.new(:unspecified)
       end
     end
 
@@ -85,6 +80,25 @@ module Vagrant
       !vm.nil?
     end
 
+    # Sets the currently active VM for this VM. If the VM is a valid,
+    # created virtual machine, then it will also update the local data
+    # to persist the VM. Otherwise, it will remove itself from the
+    # local data (if it exists).
+    def vm=(value)
+      @vm = value
+      env.local_data[:active] ||= {}
+
+      if value && value.uuid
+        env.local_data[:active][name.to_s] = value.uuid
+      else
+        env.local_data[:active].delete(name.to_s)
+      end
+
+      # Commit the local data so that the next time vagrant is initialized,
+      # it realizes the VM exists
+      env.local_data.commit
+    end
+
     def uuid
       vm ? vm.uuid : nil
     end