tnargav 1.2.3 → 1.3.3

data/lib/vagrant/action/builtin/confirm.rb

@@ -29,6 +29,7 @@ module Vagrant
 
           # The result is only true if the user said "Y"
           env[:result] = choice && choice.upcase == "Y"
+          env["#{@force_key}_result".to_sym] = env[:result]
 
           @app.call(env)
         end

data/lib/vagrant/action/builtin/graceful_halt.rb

@@ -1,4 +1,5 @@
 require "log4r"
+require "timeout"
 
 module Vagrant
   module Action
@@ -52,11 +53,14 @@ module Vagrant
             end
 
             @logger.debug("Waiting for target graceful halt state: #{@target_state}")
-            count = 0
-            while env[:machine].state.id != @target_state
-              count += 1
-              return if count >= env[:machine].config.vm.graceful_halt_retry_count
-              sleep env[:machine].config.vm.graceful_halt_retry_interval
+            begin
+              Timeout.timeout(env[:machine].config.vm.graceful_halt_timeout) do
+                while env[:machine].state.id != @target_state
+                  sleep 1
+                end
+              end
+            rescue Timeout::Error
+              # Don't worry about it, we catch the case later.
             end
 
             # The result of this matters on whether we reached our

data/lib/vagrant/action/builtin/handle_box_url.rb

@@ -1,5 +1,7 @@
 require "thread"
 
+require "log4r"
+
 module Vagrant
   module Action
     module Builtin
@@ -13,9 +15,16 @@ module Vagrant
 
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_box_url")
         end
 
         def call(env)
+          if !env[:machine].config.vm.box || !env[:machine].config.vm.box_url
+            @logger.info("Skipping HandleBoxUrl because box or box_url not set.")
+            @app.call(env)
+            return
+          end
+
           if !env[:machine].box
             # Get a "big lock" to make sure that our more fine grained
             # lock access is thread safe.
@@ -29,18 +38,17 @@ module Vagrant
             # raise a terrible runtime error.
             box_name = env[:machine].config.vm.box
             box_url  = env[:machine].config.vm.box_url
+            box_download_insecure = env[:machine].config.vm.box_download_insecure
 
             lock.synchronize do
               # First see if we actually have the box now.
               has_box = false
 
-              formats = env[:machine].provider_options[:box_format] ||
+              box_formats = env[:machine].provider_options[:box_format] ||
                 env[:machine].provider_name
-              [formats].flatten.each do |format|
-                if env[:box_collection].find(box_name, format)
-                  has_box = true
-                  break
-                end
+              if env[:box_collection].find(box_name, box_formats)
+                has_box = true
+                break
               end
 
               if !has_box
@@ -53,8 +61,9 @@ module Vagrant
 
                 begin
                   env[:action_runner].run(Vagrant::Action.action_box_add, {
+                    :box_download_insecure => box_download_insecure,
                     :box_name     => box_name,
-                    :box_provider => env[:machine].provider_name,
+                    :box_provider => box_formats,
                     :box_url      => box_url
                   })
                 rescue Errors::BoxAlreadyExists

data/lib/vagrant/action/builtin/handle_forwarded_port_collisions.rb

@@ -70,7 +70,7 @@ module Vagrant
 
             # If the port is open (listening for TCP connections)
             if extra_in_use.include?(host_port) || is_port_open?("127.0.0.1", host_port)
-              if !repair
+              if !repair || !options[:auto_correct]
                 raise Errors::ForwardPortCollision,
                   :guest_port => guest_port.to_s,
                   :host_port  => host_port.to_s

data/lib/vagrant/action/builtin/mixin_provisioners.rb

@@ -0,0 +1,43 @@
+module Vagrant
+  module Action
+    module Builtin
+      module MixinProvisioners
+        # This returns all the instances of the configured provisioners.
+        # This is safe to call multiple times since it will cache the results.
+        #
+        # @return [Array<Provisioner>]
+        def provisioner_instances
+          return @_provisioner_instances if @_provisioner_instances
+
+          # Make the mapping that'll keep track of provisioner => type
+          @_provisioner_types = {}
+
+          # Get all the configured provisioners
+          @_provisioner_instances = @env[:machine].config.vm.provisioners.map do |provisioner|
+            # Instantiate the provisioner
+            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.name]
+            result = klass.new(@env[:machine], provisioner.config)
+
+            # Store in the type map so that --provision-with works properly
+            @_provisioner_types[result] = provisioner.name
+
+            # Return the result
+            result
+          end
+
+          return @_provisioner_instances
+        end
+
+        # This will return a mapping of a provisioner instance to its
+        # type.
+        def provisioner_type_map
+          # Call this in order to initial the map if it hasn't been already
+          provisioner_instances
+
+          # Return the type map
+          @_provisioner_types
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/nfs.rb

@@ -1,9 +1,11 @@
-require 'digest/md5'
 require 'fileutils'
 require 'pathname'
+require 'zlib'
 
 require "log4r"
 
+require 'vagrant/util/platform'
+
 module Vagrant
   module Action
     module Builtin
@@ -37,7 +39,8 @@ module Vagrant
 
             # Expand the host path, create it if we have to and
             # store away the folder.
-            hostpath = Pathname.new(opts[:hostpath]).expand_path(env[:root_path])
+            hostpath = Pathname.new(opts[:hostpath]).
+              expand_path(env[:root_path])
 
             if !hostpath.directory? && opts[:create]
               # Host path doesn't exist, so let's create it.
@@ -51,6 +54,12 @@ module Vagrant
               end
             end
 
+            # Determine the real path by expanding symlinks and getting
+            # proper casing. We have to do this after creating it
+            # if it doesn't exist.
+            hostpath = hostpath.realpath
+            hostpath = Util::Platform.fs_real_path(hostpath)
+
             # Set the hostpath back on the options and save it
             opts[:hostpath] = hostpath.to_s
             folders[id] = opts
@@ -60,13 +69,16 @@ module Vagrant
             raise Errors::NFSNoHostIP if !env[:nfs_host_ip]
             raise Errors::NFSNoGuestIP if !env[:nfs_machine_ip]
 
+            machine_ip = env[:nfs_machine_ip]
+            machine_ip = [machine_ip] if !machine_ip.is_a?(Array)
+
             # Prepare the folder, this means setting up various options
             # and such on the folder itself.
             folders.each { |id, opts| prepare_folder(opts) }
 
             # Export the folders
             env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
-            env[:host].nfs_export(env[:machine].id, env[:nfs_machine_ip], folders)
+            env[:host].nfs_export(env[:machine].id, machine_ip, folders)
 
             # Mount
             env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
@@ -90,11 +102,9 @@ module Vagrant
           opts[:map_gid] = prepare_permission(:gid, opts)
           opts[:nfs_version] ||= 3
 
-          # The poor man's UUID. An MD5 hash here is sufficient since
-          # we need a 32 character "uuid" to represent the filesystem
-          # of an export. Hashing the host path is safe because two of
-          # the same host path will hash to the same fsid.
-          opts[:uuid]    = Digest::MD5.hexdigest(opts[:hostpath])
+          # We use a CRC32 to generate a 32-bit checksum so that the
+          # fsid is compatible with both old and new kernels.
+          opts[:uuid] = Zlib.crc32(opts[:hostpath]).to_s
         end
 
         # Prepares the UID/GID settings for a single folder.

data/lib/vagrant/action/builtin/provision.rb

@@ -1,5 +1,7 @@
 require "log4r"
 
+require_relative "mixin_provisioners"
+
 module Vagrant
   module Action
     module Builtin
@@ -10,34 +12,41 @@ module Vagrant
       # can do some setup, and then run again (on the return path) against
       # a running machine.
       class Provision
+        include MixinProvisioners
+
         def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::provision")
+          @app             = app
+          @logger          = Log4r::Logger.new("vagrant::action::builtin::provision")
         end
 
         def call(env)
+          @env = env
+
           # Check if we're even provisioning things.
           enabled = true
-          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
-
-          # This keeps track of a mapping between provisioner and type
-          type_map = {}
 
-          # Get all the configured provisioners
-          provisioners = env[:machine].config.vm.provisioners.map do |provisioner|
-            # Instantiate the provisioner
-            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.name]
-            result = klass.new(env[:machine], provisioner.config)
-
-            # Store in the type map so that --provision-with works properly
-            type_map[result] = provisioner.name
-
-            # Return the result
-            result
+          # Check if we already provisioned, and if so, disable the rest
+          ignore_sentinel = true
+          ignore_sentinel = env[:provision_ignore_sentinel] if env.has_key?(:provision_ignore_sentinel)
+          if !ignore_sentinel
+            @logger.info("Checking provisioner sentinel if we should run...")
+            sentinel = env[:machine].data_dir.join("action_provision")
+            if sentinel.file?
+              @logger.info("Sentinel found! Not provisioning.")
+              enabled = false
+            else
+              @logger.info("Sentinel not found.")
+              sentinel.open("w") do |f|
+                f.write(Time.now.to_i.to_s)
+              end
+            end
           end
 
+          # If we explicitly specified, take that value.
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+
           # Ask the provisioners to modify the configuration if needed
-          provisioners.each do |p|
+          provisioner_instances.each do |p|
             p.configure(env[:machine].config)
           end
 
@@ -46,11 +55,11 @@ module Vagrant
 
           # Actually provision if we enabled it
           if enabled
-            provisioners.each do |p|
+            provisioner_instances.each do |p|
               next if env[:provision_types] && \
-                !env[:provision_types].include?(type_map[p])
+                !env[:provision_types].include?(provisioner_type_map[p])
 
-              run_provisioner(env, type_map[p].to_s, p)
+              run_provisioner(env, provisioner_type_map[p].to_s, p)
             end
           end
         end

data/lib/vagrant/action/builtin/provisioner_cleanup.rb

@@ -0,0 +1,35 @@
+require "log4r"
+
+require_relative "mixin_provisioners"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This action will run the cleanup methods on provisioners and should
+      # be used as part of any Destroy action.
+      class ProvisionerCleanup
+        include MixinProvisioners
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::provision_cleanup")
+        end
+
+        def call(env)
+          @env = env
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioner_instances.each do |p|
+            env[:ui].info(I18n.t(
+              "vagrant.provisioner_cleanup",
+              name: provisioner_type_map[p].to_s))
+            p.cleanup
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/wait_for_communicator.rb

@@ -0,0 +1,84 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This waits for the communicator to be ready for a set amount of
+      # time.
+      class WaitForCommunicator
+        def initialize(app, env, states=nil)
+          @app    = app
+          @states = states
+        end
+
+        def call(env)
+          # Wait for ready in a thread so that we can continually check
+          # for interrupts.
+          ready_thr = Thread.new do
+            Thread.current[:result] = env[:machine].communicate.wait_for_ready(
+              env[:machine].config.vm.boot_timeout)
+          end
+
+          # Start a thread that verifies the VM stays in a good state.
+          states_thr = Thread.new do
+            Thread.current[:result] = true
+
+            # If we aren't caring about states, just basically put this
+            # thread to sleep because it'll get killed later.
+            if !@states
+              while true
+                sleep 300
+              end
+
+              next
+            end
+
+            # Otherwise, periodically verify the VM isn't in a bad state.
+            while true
+              state = env[:machine].provider.state.id
+
+              # Used to report invalid states
+              Thread.current[:last_known_state] = state
+
+              # Check if we have the proper state so we can break out
+              if !@states.include?(state)
+                Thread.current[:result] = false
+                break
+              end
+
+              # Sleep a bit so we don't hit 100% CPU constantly.
+              sleep 1
+            end
+          end
+
+          # Wait for a result or an interrupt
+          env[:ui].info I18n.t("vagrant.boot_waiting")
+          while ready_thr.alive? && states_thr.alive?
+            return if env[:interrupted]
+          end
+
+          # If it went into a bad state, then raise an error
+          if !states_thr[:result]
+            raise Errors::VMBootBadState,
+              valid: @states.join(", "),
+              invalid: states_thr[:last_known_state]
+          end
+
+          # If it didn't boot, raise an error
+          if !ready_thr[:result]
+            raise Errors::VMBootTimeout
+          end
+
+          env[:ui].info I18n.t("vagrant.boot_completed")
+
+          # Make sure our threads are all killed
+          ready_thr.kill
+          states_thr.kill
+
+          @app.call(env)
+        ensure
+          ready_thr.kill
+          states_thr.kill
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/warden.rb

@@ -30,9 +30,10 @@ module Vagrant
           # of "recoverable" middlewares in case something goes wrong!
           raise Errors::VagrantInterrupt if env[:interrupted]
           action = @actions.shift
-          @logger.info("Calling action: #{action}")
+          @logger.info("Calling IN action: #{action}")
           @stack.unshift(action).first.call(env)
           raise Errors::VagrantInterrupt if env[:interrupted]
+          @logger.info("Calling OUT action: #{action}")
         rescue SystemExit
           # This means that an "exit" or "abort" was called. In these cases,
           # we just exit immediately.

data/lib/vagrant/box_collection.rb

@@ -70,31 +70,35 @@ module Vagrant
     #   the box represents will be added.
     # @param [Boolean] force If true, any existing box with the same name
     #   and provider will be replaced.
-    def add(path, name, provider=nil, force=false)
+    def add(path, name, formats=nil, force=false)
+      formats = [formats] if formats && !formats.is_a?(Array)
+      provider = nil
+
       with_collection_lock do
         # A helper to check if a box exists. We store this in a variable
         # since we call it multiple times.
-        check_box_exists = lambda do |box_provider|
-          box = find(name, box_provider)
+        check_box_exists = lambda do |box_formats|
+          box = find(name, box_formats)
           next if !box
 
           if !force
-            @logger.error("Box already exists, can't add: #{name} #{box_provider}")
-            raise Errors::BoxAlreadyExists, :name => name, :provider => box_provider
+            @logger.error("Box already exists, can't add: #{name} #{box_formats.join(", ")}")
+            raise Errors::BoxAlreadyExists, :name => name, :formats => box_formats.join(", ")
           end
 
           # We're forcing, so just delete the old box
-          @logger.info("Box already exists, but forcing so removing: #{name} #{box_provider}")
+          @logger.info(
+            "Box already exists, but forcing so removing: #{name} #{box_formats.join(", ")}")
           box.destroy!
         end
 
-        log_provider = provider ? provider : "any provider"
+        log_provider = formats ? formats.join(", ") : "any provider"
         @logger.debug("Adding box: #{name} (#{log_provider}) from #{path}")
 
         # Verify the box doesn't exist early if we're given a provider. This
         # can potentially speed things up considerably since we don't need
         # to unpack any files.
-        check_box_exists.call(provider) if provider
+        check_box_exists.call(formats) if formats
 
         # Verify that a V1 box doesn't exist. If it does, then we signal
         # to the user that we need an upgrade.
@@ -121,26 +125,35 @@ module Vagrant
           with_temp_dir(temp_dir) do |final_temp_dir|
             # Get an instance of the box we just added before it is finalized
             # in the system so we can inspect and use its metadata.
-            box = Box.new(name, provider, final_temp_dir)
+            box = Box.new(name, nil, final_temp_dir)
 
             # Get the provider, since we'll need that to at the least add it
             # to the system or check that it matches what is given to us.
             box_provider = box.metadata["provider"]
 
-            if provider
-              # Verify that the given provider matches what the box has.
-              if box_provider.to_sym != provider
-                @logger.error("Added box provider doesnt match expected: #{box_provider}")
-                raise Errors::BoxProviderDoesntMatch, :expected => provider, :actual => box_provider
+            if formats
+              found = false
+              formats.each do |format|
+                # Verify that the given provider matches what the box has.
+                if box_provider.to_sym == format.to_sym
+                  found = true
+                  break
+                end
               end
-            else
-              # We weren't given a provider, so store this one.
-              provider = box_provider.to_sym
 
+              if !found
+                @logger.error("Added box provider doesnt match expected: #{log_provider}")
+                raise Errors::BoxProviderDoesntMatch,
+                  :expected => log_provider, :actual => box_provider
+              end
+            else
               # Verify the box doesn't already exist
-              check_box_exists.call(provider)
+              check_box_exists.call([box_provider])
             end
 
+            # We weren't given a provider, so store this one.
+            provider = box_provider.to_sym
+
             # Create the directory for this box, not including the provider
             box_dir = @directory.join(name)
             box_dir.mkpath
@@ -220,39 +233,43 @@ module Vagrant
     # Find a box in the collection with the given name and provider.
     #
     # @param [String] name Name of the box (logical name).
-    # @Param [String] provider Provider that the box implements.
+    # @param [String] provider Provider that the box implements.
     # @return [Box] The box found, or `nil` if not found.
-    def find(name, provider)
+    def find(name, providers)
+      providers = [providers].flatten
+
       with_collection_lock do
-        # First look directly for the box we're asking for.
-        box_directory = @directory.join(name, provider.to_s, "metadata.json")
-        @logger.info("Searching for box: #{name} (#{provider}) in #{box_directory}")
-        if box_directory.file?
-          @logger.info("Box found: #{name} (#{provider})")
-          return Box.new(name, provider, box_directory.dirname)
-        end
+        providers.each do |provider|
+          # First look directly for the box we're asking for.
+          box_directory = @directory.join(name, provider.to_s, "metadata.json")
+          @logger.info("Searching for box: #{name} (#{provider}) in #{box_directory}")
+          if box_directory.file?
+            @logger.info("Box found: #{name} (#{provider})")
+            return Box.new(name, provider, box_directory.dirname)
+          end
 
-        # If we're looking for a VirtualBox box, then we check if there is
-        # a V1 box.
-        if provider.to_sym == :virtualbox
-          # Check if a V1 version of this box exists, and if so, raise an
-          # exception notifying the caller that the box exists but needs
-          # to be upgraded. We don't do the upgrade here because it can be
-          # a fairly intensive activity and don't want to immediately degrade
-          # user performance on a find.
-          #
-          # To determine if it is a V1 box we just do a simple heuristic
-          # based approach.
-          @logger.info("Searching for V1 box: #{name}")
-          if v1_box?(@directory.join(name))
-            @logger.warn("V1 box found: #{name}")
-            raise Errors::BoxUpgradeRequired, :name => name
+          # If we're looking for a VirtualBox box, then we check if there is
+          # a V1 box.
+          if provider.to_sym == :virtualbox
+            # Check if a V1 version of this box exists, and if so, raise an
+            # exception notifying the caller that the box exists but needs
+            # to be upgraded. We don't do the upgrade here because it can be
+            # a fairly intensive activity and don't want to immediately degrade
+            # user performance on a find.
+            #
+            # To determine if it is a V1 box we just do a simple heuristic
+            # based approach.
+            @logger.info("Searching for V1 box: #{name}")
+            if v1_box?(@directory.join(name))
+              @logger.warn("V1 box found: #{name}")
+              raise Errors::BoxUpgradeRequired, :name => name
+            end
           end
         end
       end
 
       # Didn't find it, return nil
-      @logger.info("Box not found: #{name} (#{provider})")
+      @logger.info("Box not found: #{name} (#{providers.join(", ")})")
       nil
     end
 
@@ -261,6 +278,7 @@ module Vagrant
     # If the given box is found but is not a V1 box then `true` is returned
     # because this just works fine.
     #
+    # @param [String] name Name of the box (logical name).
     # @return [Boolean] `true` otherwise an exception is raised.
     def upgrade(name)
       with_collection_lock do
@@ -268,7 +286,7 @@ module Vagrant
         box_dir = @directory.join(name)
 
         # If the box doesn't exist at all, raise an exception
-        raise Errors::BoxNotFound, :name => name if !box_dir.directory?
+        raise Errors::BoxNotFound, :name => name, :provider => "virtualbox" if !box_dir.directory?
 
         if v1_box?(box_dir)
           @logger.debug("V1 box #{name} found. Upgrading!")