vagrant-unbundled 2.2.6.0 → 2.2.9.0

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

@@ -348,9 +348,15 @@ module Vagrant
             end
 
             if opts[:checksum] && opts[:checksum_type]
-              env[:ui].detail(I18n.t("vagrant.actions.box.add.checksumming"))
-              validate_checksum(
-                opts[:checksum_type], opts[:checksum], box_url)
+              if opts[:checksum].to_s.strip.empty?
+                @logger.warn("Given checksum is empty, cannot validate checksum for box")
+              elsif opts[:checksum_type].to_s.strip.empty?
+                @logger.warn("Given checksum type is empty, cannot validate checksum for box")
+              else
+                env[:ui].detail(I18n.t("vagrant.actions.box.add.checksumming"))
+                validate_checksum(
+                  opts[:checksum_type], opts[:checksum], box_url)
+              end
             end
 
             # Add the box!
@@ -427,7 +433,8 @@ module Vagrant
           downloader_options[:headers] = ["Accept: application/json"] if opts[:json]
           downloader_options[:ui] = env[:ui] if opts[:ui]
           downloader_options[:location_trusted] = env[:box_download_location_trusted]
-
+          downloader_options[:box_extra_download_options] = env[:box_extra_download_options]
+          
           Util::Downloader.new(url, temp_path, downloader_options)
         end
 

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

@@ -40,7 +40,7 @@ module Vagrant
           # Have download options specified in the environment override
           # options specified for the machine.
           download_options = {
-            automatic_check: true,
+            automatic_check: !env[:box_outdated_force],
             ca_cert: env[:ca_cert] || machine.config.vm.box_download_ca_cert,
             ca_path: env[:ca_path] || machine.config.vm.box_download_ca_path,
             client_cert: env[:client_cert] ||
@@ -70,15 +70,23 @@ module Vagrant
               message: e.message))
           end
           env[:box_outdated] = update != nil
-          if update
+          local_update = check_outdated_local(env)
+          if update && (local_update.nil? || (local_update.version < update[1].version))
             env[:ui].warn(I18n.t(
               "vagrant.box_outdated_single",
               name: update[0].name,
               provider: box.provider,
               current: box.version,
               latest: update[1].version))
+          elsif local_update
+            env[:ui].warn(I18n.t(
+              "vagrant.box_outdated_local",
+              name: local_update.name,
+              old: box.version,
+              new: local_update.version))
+            env[:box_outdated] = true
           else
-            check_outdated_local(env)
+            env[:box_outdated] = false
           end
 
           @app.call(env)
@@ -93,19 +101,8 @@ module Vagrant
           version ||= ""
           version += "> #{machine.box.version}"
 
-          box = env[:box_collection].find(
+          env[:box_collection].find(
             machine.box.name, machine.box.provider, version)
-          if box
-            env[:ui].warn(I18n.t(
-              "vagrant.box_outdated_local",
-              name: box.name,
-              old: machine.box.version,
-              new: box.version))
-            env[:box_outdated] = true
-            return
-          end
-
-          env[:box_outdated] = false
         end
       end
     end

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

@@ -0,0 +1,56 @@
+require "json"
+
+module Vagrant
+  module Action
+    module Builtin
+      class CleanupDisks
+        # Removes any attached disks no longer defined in a Vagrantfile config
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::disk")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          defined_disks = get_disks(machine, env)
+
+          # Call into providers machine implementation for disk management
+          disk_meta_file = read_disk_metadata(machine)
+
+          if !disk_meta_file.empty?
+            if machine.provider.capability?(:cleanup_disks)
+              machine.provider.capability(:cleanup_disks, defined_disks, disk_meta_file)
+            else
+              env[:ui].warn(I18n.t("vagrant.actions.disk.provider_unsupported",
+                                   provider: machine.provider_name))
+            end
+          end
+
+          # Continue On
+          @app.call(env)
+        end
+
+        def read_disk_metadata(machine)
+          meta_file = machine.data_dir.join("disk_meta")
+          if File.file?(meta_file)
+            disk_meta = JSON.parse(meta_file.read)
+          else
+            @logger.info("No previous disk_meta file defined for guest #{machine.name}")
+            disk_meta = {}
+          end
+
+          return disk_meta
+        end
+
+        def get_disks(machine, env)
+          return @_disks if @_disks
+
+          @_disks = []
+          @_disks = machine.config.vm.disks
+
+          @_disks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This class is used to delay execution until the end of
+      # a configured stack
+      class Delayed
+        # @param [Object] callable The object to call (must respond to #call)
+        def initialize(app, env, callable)
+          if !callable.respond_to?(:call)
+            raise TypeError, "Callable argument is expected to respond to `#call`"
+          end
+          @app         = app
+          @env         = env
+          @callable    = callable
+        end
+
+        def call(env)
+          # Allow the rest of the call stack to execute
+          @app.call(env)
+          # Now call our delayed stack
+          @callable.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "json"
+
+module Vagrant
+  module Action
+    module Builtin
+      class Disk
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::disk")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          defined_disks = get_disks(machine, env)
+
+          # Call into providers machine implementation for disk management
+          configured_disks = {}
+          if !defined_disks.empty?
+            if machine.provider.capability?(:configure_disks)
+             configured_disks = machine.provider.capability(:configure_disks, defined_disks)
+            else
+              env[:ui].warn(I18n.t("vagrant.actions.disk.provider_unsupported",
+                                 provider: machine.provider_name))
+            end
+          end
+
+          write_disk_metadata(machine, configured_disks) unless configured_disks.empty?
+
+          # Continue On
+          @app.call(env)
+        end
+
+        def write_disk_metadata(machine, current_disks)
+          meta_file = machine.data_dir.join("disk_meta")
+          @logger.debug("Writing disk metadata file to #{meta_file}")
+          File.open(meta_file.to_s, "w+") do |file|
+            file.write(JSON.dump(current_disks))
+          end
+        end
+
+        def get_disks(machine, env)
+          return @_disks if @_disks
+
+          @_disks = []
+          @_disks = machine.config.vm.disks
+
+          @_disks
+        end
+      end
+    end
+  end
+end

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

@@ -67,6 +67,7 @@ module Vagrant
           box_download_checksum_type = machine.config.vm.box_download_checksum_type
           box_download_checksum = machine.config.vm.box_download_checksum
           box_download_location_trusted = machine.config.vm.box_download_location_trusted
+          box_extra_download_options = machine.config.vm.box_extra_download_options
           box_formats = machine.provider_options[:box_format] ||
             machine.provider_name
 
@@ -92,6 +93,7 @@ module Vagrant
               box_checksum_type: box_download_checksum_type,
               box_checksum: box_download_checksum,
               box_download_location_trusted: box_download_location_trusted,
+              box_extra_download_options: box_extra_download_options,
             }))
           rescue Errors::BoxAlreadyExists
             # Just ignore this, since it means the next part will succeed!

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

@@ -1,6 +1,7 @@
 require "set"
 
 require "log4r"
+require "socket"
 
 require "vagrant/util/is_port_open"
 
@@ -242,18 +243,36 @@ module Vagrant
           return extra_in_use.fetch(hostport).include?(hostip)
         end
 
+        def ipv4_interfaces
+          Socket.getifaddrs.select do |ifaddr|
+            ifaddr.addr && ifaddr.addr.ipv4?
+          end.map do |ifaddr|
+            [ifaddr.name, ifaddr.addr.ip_address]
+          end
+        end
+
         def port_check(host_ip, host_port)
-          # If no host_ip is specified, intention taken to be list on all interfaces.
-          # If platform is windows, default back to localhost only
+          # If no host_ip is specified, intention taken to be listen on all interfaces.
           test_host_ip = host_ip || "0.0.0.0"
-          begin
-            is_port_open?(test_host_ip, host_port)
-          rescue Errno::EADDRNOTAVAIL
-            if !host_ip && test_host_ip == "0.0.0.0"
-              test_host_ip = "127.0.0.1"
-              retry
+          if Util::Platform.windows? && test_host_ip == "0.0.0.0"
+            @logger.debug("Testing port #{host_port} on all IPv4 interfaces...")
+            available_interfaces = ipv4_interfaces.select do |interface|
+              @logger.debug("Testing #{interface[0]} with IP address #{interface[1]}")
+              !is_port_open?(interface[1], host_port)
+            end
+            if available_interfaces.empty?
+              @logger.debug("Cannot forward port #{host_port} on any interfaces.")
+              true
+            else
+              @logger.debug("Port #{host_port} will forward to the guest on the following interfaces: #{available_interfaces}")
+              false
+            end
+          else
+            # Do a regular check
+            if test_host_ip == "0.0.0.0" || ipv4_interfaces.detect { |iface| iface[1] == test_host_ip }
+              is_port_open?(test_host_ip, host_port)
             else
-              raise
+              raise Errors::ForwardPortHostIPNotFound, name: @machine.name, host_ip: host_ip
             end
           end
         end

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

@@ -25,9 +25,27 @@ module Vagrant
             # Store in the type map so that --provision-with works properly
             @_provisioner_types[result] = provisioner.type
 
+            # Set top level provisioner name to provisioner configs name if top level name not set.
+            # This is mostly for handling the shell provisioner, if a user has set its name like:
+            #
+            #   config.vm.provision "shell", name: "my_provisioner"
+            #
+            # Where `name` is a shell config option, not a top level provisioner class option
+            #
+            # Note: `name` is set to a symbol, since it is converted to one via #Config::VM.provision
+            provisioner_name = provisioner.name
+            if !provisioner_name
+              if provisioner.config.respond_to?(:name) &&
+                  provisioner.config.name
+                provisioner_name = provisioner.config.name.to_sym
+              end
+            else
+              provisioner_name = provisioner_name.to_sym
+            end
+
             # Build up the options
             options = {
-              name: provisioner.name,
+              name: provisioner_name,
               run:  provisioner.run,
               before:  provisioner.before,
               after:  provisioner.after,

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

@@ -36,17 +36,35 @@ module Vagrant
 
           # Get the command and wrap it in a login shell
           command = ShellQuote.escape(env[:ssh_run_command], "'")
-          command = "#{env[:machine].config.ssh.shell} -c '#{command}'"
+
+          if env[:machine].config.vm.communicator == :winssh
+            shell = env[:machine].config.winssh.shell
+          else
+            shell = env[:machine].config.ssh.shell
+          end
+
+          if shell == "cmd"
+            # Add an extra space to the command so cmd.exe quoting works
+            # properly
+            command = "#{shell} /C #{command} "
+          elsif shell == "powershell"
+            command = "$ProgressPreference = \"SilentlyContinue\"; #{command}"
+            command = Base64.strict_encode64(command.encode("UTF-16LE", "UTF-8"))
+            command = "#{shell} -encodedCommand #{command}"
+          else
+            command = "#{shell} -c '#{command}'"
+          end
 
           # Execute!
           opts = env[:ssh_opts] || {}
           opts[:extra_args] ||= []
 
           # Allow the user to specify a tty or non-tty manually, but if they
-          # don't then we default to a TTY
+          # don't then we default to a TTY unless they are using WinSSH
           if !opts[:extra_args].include?("-t") &&
               !opts[:extra_args].include?("-T") &&
-              env[:tty]
+              env[:tty] &&
+              env[:machine].config.vm.communicator != :winssh
             opts[:extra_args] << "-t"
           end
 

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

@@ -0,0 +1,36 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This class is used within the Builder class for injecting triggers into
+      # different parts of the call stack.
+      class Trigger
+        # @param [Class, String, Symbol] name Name of trigger to fire
+        # @param [Vagrant::Plugin::V2::Triger] triggers Trigger object
+        # @param [Symbol] timing When trigger should fire (:before/:after)
+        # @param [Symbol] type Type of trigger
+        def initialize(app, env, name, triggers, timing, type=:action)
+          @app         = app
+          @env         = env
+          @triggers    = triggers
+          @name        = name
+          @timing      = timing
+          @type        = type
+
+          if ![:before, :after].include?(timing)
+            raise ArgumentError,
+              "Invalid value provided for `timing` (allowed: :before or :after)"
+          end
+        end
+
+        def call(env)
+          machine = env[:machine]
+          machine_name = machine.name if machine
+
+          @triggers.fire(@name, @timing, machine_name, @type)
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/hook.rb

@@ -65,6 +65,14 @@ module Vagrant
         @prepend_hooks << [new, args, block]
       end
 
+      # @return [Boolean]
+      def empty?
+        before_hooks.empty? &&
+          after_hooks.empty? &&
+          prepend_hooks.empty? &&
+          append_hooks.empty?
+      end
+
       # This applies the given hook to a builder. This should not be
       # called directly.
       #
@@ -75,12 +83,22 @@ module Vagrant
         if !options[:no_prepend_or_append]
           # Prepends first
           @prepend_hooks.each do |klass, args, block|
-            builder.insert(0, klass, *args, &block)
+            if options[:root]
+              idx = builder.index(options[:root])
+            else
+              idx = 0
+            end
+            builder.insert(idx, klass, *args, &block)
           end
 
           # Appends
           @append_hooks.each do |klass, args, block|
-            builder.use(klass, *args, &block)
+            if options[:root]
+              idx = builder.index(options[:root])
+              builder.insert(idx + 1, klass, *args, &block)
+            else
+              builder.use(klass, *args, &block)
+            end
           end
         end
 

data/lib/vagrant/action/runner.rb

@@ -34,30 +34,19 @@ module Vagrant
         environment.merge!(@lazy_globals.call) if @lazy_globals
         environment.merge!(options || {})
 
-        if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-          # NOTE: Triggers are initialized later in the Action::Runer because of
-          # how `@lazy_globals` are evaluated. Rather than trying to guess where
-          # the `env` is coming from, we can wait until they're merged into a single
-          # hash above.
-          env = environment[:env]
-          machine = environment[:machine]
-          machine_name = machine.name if machine
+        # NOTE: Triggers are initialized later in the Action::Runer because of
+        # how `@lazy_globals` are evaluated. Rather than trying to guess where
+        # the `env` is coming from, we can wait until they're merged into a single
+        # hash above.
+        env = environment[:env]
+        machine = environment[:machine]
 
-          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
-          triggers = Vagrant::Plugin::V2::Trigger.new(env, env.vagrantfile.config.trigger, machine, ui)
-        end
-
-        # Setup the action hooks
-        hooks = Vagrant.plugin("2").manager.action_hooks(environment[:action_name])
-        if !hooks.empty?
-          @logger.info("Preparing hooks for middleware sequence...")
-          environment[:action_hooks] = hooks.map do |hook_proc|
-            Hook.new.tap do |h|
-              hook_proc.call(h)
-            end
-          end
+        environment[:triggers] = machine.triggers if machine
 
-          @logger.info("#{environment[:action_hooks].length} hooks defined.")
+        if env
+          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+          environment[:triggers] ||= Vagrant::Plugin::V2::Trigger.
+            new(env, env.vagrantfile.config.trigger, machine, ui)
         end
 
         # Run the action chain in a busy block, marking the environment as
@@ -95,14 +84,10 @@ module Vagrant
 
         action_name = environment[:action_name]
 
-        triggers.fire_triggers(action_name, :before, machine_name, :hook) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-
         # We place a process lock around every action that is called
         @logger.info("Running action: #{environment[:action_name]} #{callable_id}")
         Util::Busy.busy(int_callback) { callable.call(environment) }
 
-        triggers.fire_triggers(action_name, :after, machine_name, :hook) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-
         # Return the environment in case there are things in there that
         # the caller wants to use.
         environment