vagrant 0.5.4 → 0.6.0

data/lib/vagrant/action/box/download.rb

@@ -13,31 +13,27 @@ module Vagrant
           @env = env
           @env["download.classes"] ||= []
           @env["download.classes"] += [Downloaders::HTTP, Downloaders::File]
+          @downloader = nil
         end
 
         def call(env)
           @env = env
 
           download if instantiate_downloader
-          return if env.error?
-
           @app.call(@env)
 
-          cleanup
+          recover(env) # called in both cases to cleanup workspace
         end
 
         def instantiate_downloader
           @env["download.classes"].each do |klass|
             if klass.match?(@env["box"].uri)
-              @env.logger.info "Downloading with #{klass}..."
+              @env.ui.info I18n.t("vagrant.actions.box.download.with", :class => klass.to_s)
               @downloader = klass.new(@env)
             end
           end
 
-          if !@downloader
-            @env.error!(:box_download_unknown_type)
-            return false
-          end
+          raise Errors::BoxDownloadUnknownType.new if !@downloader
 
           @downloader.prepare(@env["box"].uri)
           true
@@ -50,26 +46,25 @@ module Vagrant
           end
         end
 
-        def cleanup
+        def recover(env)
           if temp_path && File.exist?(temp_path)
-            @env.logger.info "Cleaning up downloaded box..."
+            env.ui.info I18n.t("vagrant.actions.box.download.cleaning")
             File.unlink(temp_path)
           end
         end
 
         def with_tempfile
-          @env.logger.info "Creating tempfile for storing box file..."
           File.open(box_temp_path, Platform.tar_file_options) do |tempfile|
             yield tempfile
           end
         end
 
         def box_temp_path
-          File.join(@env.env.tmp_path, BASENAME + Time.now.to_i.to_s)
+          @env.env.tmp_path.join(BASENAME + Time.now.to_i.to_s)
         end
 
         def download_to(f)
-          @env.logger.info "Copying box to temporary location..."
+          @env.ui.info I18n.t("vagrant.actions.box.download.copying")
           @downloader.download!(@env["box"].uri, f)
         end
       end

data/lib/vagrant/action/box/unpackage.rb

@@ -1,3 +1,6 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
 module Vagrant
   class Action
     module Box
@@ -21,35 +24,29 @@ module Vagrant
         def call(env)
           @env = env
 
-          return if !setup_box_directory
+          setup_box_directory
           decompress
 
           @app.call(@env)
-
-          cleanup if @env.error?
         end
 
-        def cleanup
+        def recover(env)
           if File.directory?(box_directory)
             FileUtils.rm_rf(box_directory)
           end
         end
 
         def setup_box_directory
-          if File.directory?(@env["box"].directory)
-            @env.error!(:box_already_exists, :box_name => @env["box"].name)
-            return false
-          end
+          raise Errors::BoxAlreadyExists.new(:name => @env["box"].name) if File.directory?(@env["box"].directory)
 
           FileUtils.mkdir_p(@env["box"].directory)
           @box_directory = @env["box"].directory
-          true
         end
 
         def decompress
           Dir.chdir(@env["box"].directory) do
-            @env.logger.info "Extracting box to #{@env["box"].directory}..."
-            Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box"].directory)
+            @env.ui.info I18n.t("vagrant.actions.box.unpackage.extracting")
+            Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box"].directory.to_s)
           end
         end
       end

data/lib/vagrant/action/box/verify.rb

@@ -9,10 +9,10 @@ module Vagrant
 
         def call(env)
           begin
-            env.logger.info "Verifying box..."
-            VirtualBox::Appliance.new(env["box"].ovf_file)
+            env.ui.info I18n.t("vagrant.actions.box.verify.verifying")
+            VirtualBox::Appliance.new(env["box"].ovf_file.to_s)
           rescue Exception
-            return env.error!(:box_verification_failed)
+            raise Errors::BoxVerificationFailed.new
           end
 
           @app.call(env)

data/lib/vagrant/action/builder.rb

@@ -110,36 +110,9 @@ module Vagrant
       # @param [Vagrant::Action::Environment] env The action environment
       # @return [Object] A callable object
       def to_app(env)
-        # Prepend the error halt task so errneous environments are halted
-        # before the chain even begins.
-        items = stack.dup.unshift([Env::ErrorHalt, [], nil])
-
-        # Convert each middleware into a lambda which takes the next
-        # middleware.
-        items = items.collect do |item|
-          klass, args, block = item
-
-          lambda do |app|
-            if klass.is_a?(Class)
-              # A middleware klass which is to be instantiated with the
-              # app, env, and any arguments given
-              klass.new(app, env, *args, &block)
-            elsif klass.respond_to?(:call)
-              # Make it a lambda which calls the item then forwards
-              # up the chain
-              lambda do |e|
-                klass.call(e)
-                app.call(e)
-              end
-            else
-              raise "Invalid middleware: #{item.inspect}"
-            end
-          end
-        end
-
-        # Append the final step and convert into flattened call chain.
-        items << lambda { |env| }
-        items[0...-1].reverse.inject(items.last) { |a,e| e.call(a) }
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(stack.dup, env)
       end
 
       # Runs the builder stack with the given environment.

data/lib/vagrant/action/builtin.rb

@@ -65,7 +65,6 @@ module Vagrant
       up = Builder.new do
         use VM::CheckBox
         use VM::Import
-        use VM::Persist
         use VM::MatchMACAddress
         use VM::CheckGuestAdditions
         use Action[:start]
@@ -118,6 +117,12 @@ module Vagrant
       end
 
       register :box_repackage, box_repackage
+
+      # post_load - Called after environment is loaded
+      environment_load = Builder.new do
+      end
+
+      register :environment_load, environment_load
     end
   end
 end

data/lib/vagrant/action/environment.rb

@@ -4,15 +4,11 @@ module Vagrant
     # to the `call` method of each action. This environment contains
     # some helper methods for accessing the environment as well
     # as being a hash, to store any additional options.
-    class Environment < Hash
+    class Environment < Util::HashWithIndifferentAccess
       # The {Vagrant::Environment} object represented by this
       # action environment.
       attr_reader :env
 
-      # If nonnil, the error associated with this environment. Set
-      # using {#error!}
-      attr_reader :error
-
       def initialize(env)
         super() do |h,k|
           # By default, try to find the key as a method on the
@@ -26,72 +22,28 @@ module Vagrant
         end
 
         @env = env
-        @error = nil
-      end
-
-      # Returns a logger associated with the environment.
-      def logger
-        env.logger
+        @interrupted = false
       end
 
-      # Flags the environment as erroneous. Stores the given key
-      # and options until the end of the action sequence.
-      #
-      # @param [Symbol] key Key to translation to display error message.
-      # @param [Hash] options Variables to pass to the translation
-      def error!(key, options=nil)
-        @error = [key, (options || {})]
+      # Returns a UI object from the environment
+      def ui
+        env.ui
       end
 
-      # Returns boolean denoting if environment is in erroneous state.
-      #
-      # @return [Boolean]
-      def error?
-        !error.nil?
+      # Marks an environment as interrupted (by an outside signal or
+      # anything). This will trigger any middleware sequences using this
+      # environment to halt. This is automatically set by {Action} when
+      # a SIGINT is captured.
+      def interrupt!
+        @interrupted = true
       end
 
       # Returns a boolean denoting if environment has been interrupted
       # with a SIGINT.
+      #
+      # @return [Bool]
       def interrupted?
-        error? && error.first == :interrupt
-      end
-
-      #-----------------------------------------------------------------
-      # Hash with indifferent access
-      #-----------------------------------------------------------------
-      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 has_key?(key)
-        super(convert_key(key))
-      end
-
-      def convert_key(key)
-        key.is_a?(Symbol) ? key.to_s : key
+        !!@interrupted
       end
     end
   end

data/lib/vagrant/action/general/package.rb

@@ -1,3 +1,6 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
 module Vagrant
   class Action
     module General
@@ -19,55 +22,59 @@ module Vagrant
           @env = env
           @env["package.output"] ||= env["config"].package.name
           @env["package.include"] ||= []
+          @env["package.vagrantfile"] ||= nil
         end
 
         def call(env)
           @env = env
 
-          return env.error!(:package_output_exists) if File.exist?(tar_path)
-          return env.error!(:package_requires_directory) if !@env["package.directory"] || !File.directory?(@env["package.directory"])
-          return if !verify_included_files
+          raise Errors::PackageOutputExists.new if File.exist?(tar_path)
+          raise Errors::PackageRequiresDirectory.new if !@env["package.directory"] || !File.directory?(@env["package.directory"])
+
+          verify_files_to_copy
           compress
 
           @app.call(env)
-
-          cleanup if env.error?
         end
 
-        def cleanup
+        def recover(env)
           # Cleanup any packaged files if the packaging failed at some point.
           File.delete(tar_path) if File.exist?(tar_path)
         end
 
-        def verify_included_files
-          @env["package.include"].each do |file|
-            if !File.exist?(file)
-              @env.error!(:package_include_file_doesnt_exist, :filename => file)
-              return false
-            end
+        def files_to_copy
+          package_dir = Pathname.new(@env["package.directory"]).join("include")
+
+          files = @env["package.include"].inject({}) do |acc, file|
+            source = Pathname.new(file)
+            acc[file] = source.relative? ? package_dir.join(source) : package_dir.join(source.basename)
+            acc
           end
 
-          true
+          files[@env["package.vagrantfile"]] = package_dir.join("_Vagrantfile") if @env["package.vagrantfile"]
+          files
+        end
+
+        def verify_files_to_copy
+          files_to_copy.each do |file, _|
+            raise Errors::PackageIncludeMissing.new(:file => file) if !File.exist?(file)
+          end
         end
 
         # This method copies the include files (passed in via command line)
         # to the temporary directory so they are included in a sub-folder within
         # the actual box
         def copy_include_files
-          if @env["package.include"].length > 0
-            include_dir = File.join(@env["package.directory"], "include")
-            FileUtils.mkdir_p(include_dir)
-
-            @env["package.include"].each do |f|
-              @env.logger.info "Packaging additional file: #{f}"
-              FileUtils.cp(f, include_dir)
-            end
+          files_to_copy.each do |from, to|
+            @env.ui.info I18n.t("vagrant.actions.general.package.packaging", :file => from)
+            FileUtils.mkdir_p(to.parent)
+            FileUtils.cp(from, to)
           end
         end
 
         # Compress the exported file into a package
         def compress
-          @env.logger.info "Compressing package to #{tar_path}..."
+          @env.ui.info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
           File.open(tar_path, Platform.tar_file_options) do |tar|
             Archive::Tar::Minitar::Output.open(tar) do |output|
               begin

data/lib/vagrant/action/vm/boot.rb

@@ -8,32 +8,25 @@ module Vagrant
         end
 
         def call(env)
-          # Do nothing if the environment is erroneous
-          return if env.error?
-
           @env = env
 
           # Start up the VM and wait for it to boot.
           boot
-          return env.error!(:vm_failed_to_boot) if !wait_for_boot
-          return if env.error?
-
+          raise Errors::VMFailedToBoot.new if !wait_for_boot
           @app.call(env)
         end
 
         def boot
-          @env.logger.info "Booting VM..."
+          @env.ui.info I18n.t("vagrant.actions.vm.boot.booting")
           @env["vm"].vm.start(@env.env.config.vm.boot_mode)
         end
 
         def wait_for_boot
-          @env.logger.info "Waiting for VM to boot..."
+          @env.ui.info I18n.t("vagrant.actions.vm.boot.waiting")
 
           @env.env.config.ssh.max_tries.to_i.times do |i|
-            @env.logger.info "Trying to connect (attempt ##{i+1} of #{@env.env.config[:ssh][:max_tries]})..."
-
             if @env["vm"].ssh.up?
-              @env.logger.info "VM booted and ready for use!"
+              @env.ui.info I18n.t("vagrant.actions.vm.boot.ready")
               return true
             end
 
@@ -44,7 +37,7 @@ module Vagrant
             sleep 5 if !@env["vagrant.test"]
           end
 
-          @env.logger.info "Failed to connect to VM! Failed to boot?"
+          @env.ui.error I18n.t("vagrant.actions.vm.boot.failed")
           false
         end
       end

data/lib/vagrant/action/vm/check_box.rb

@@ -8,13 +8,13 @@ module Vagrant
 
         def call(env)
           box_name = env["config"].vm.box
-          return env.error!(:box_not_specified) if !box_name
+          raise Errors::BoxNotSpecified.new if !box_name
 
-          if !Vagrant::Box.find(env.env , box_name)
+          if !env.env.boxes.find(box_name)
             box_url = env["config"].vm.box_url
-            return env.error!(:box_specified_doesnt_exist, :box_name => box_name) if !box_url
+            raise Errors::BoxSpecifiedDoesntExist.new(:name => box_name) if !box_url
 
-            env.logger.info "Box #{box_name} not found. Fetching box since URL specified..."
+            env.ui.info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
             Vagrant::Box.add(env.env, box_name, box_url)
             env.env.load_box!
           end