vagrant-unbundled 2.2.6.1 → 2.2.10.0

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

@@ -25,6 +25,7 @@ module Vagrant
         def initialize(app, env)
           @app    = app
           @logger = Log4r::Logger.new("vagrant::action::builtin::box_add")
+          @parser = URI::RFC2396_Parser.new
         end
 
         def call(env)
@@ -44,7 +45,7 @@ module Vagrant
             u = u.gsub("\\", "/")
             if Util::Platform.windows? && u =~ /^[a-z]:/i
               # On Windows, we need to be careful about drive letters
-              u = "file:///#{URI.escape(u)}"
+              u = "file:///#{@parser.escape(u)}"
             end
 
             if u =~ /^[a-z0-9]+:.*$/i && !u.start_with?("file://")
@@ -53,9 +54,9 @@ module Vagrant
             end
 
             # Expand the path and try to use that, if possible
-            p = File.expand_path(URI.unescape(u.gsub(/^file:\/\//, "")))
+            p = File.expand_path(@parser.unescape(u.gsub(/^file:\/\//, "")))
             p = Util::Platform.cygwin_windows_path(p)
-            next "file://#{URI.escape(p.gsub("\\", "/"))}" if File.file?(p)
+            next "file://#{@parser.escape(p.gsub("\\", "/"))}" if File.file?(p)
 
             u
           end
@@ -348,9 +349,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,6 +434,7 @@ 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
@@ -488,7 +496,7 @@ module Vagrant
             url ||= uri.opaque
             #7570 Strip leading slash left in front of drive letter by uri.path
             Util::Platform.windows? && url.gsub!(/^\/([a-zA-Z]:)/, '\1')
-            url = URI.unescape(url)
+            url = @parser.unescape(url)
 
             begin
               File.open(url, "r") do |f|

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/cloud_init_setup.rb

@@ -0,0 +1,127 @@
+require 'mime'
+require 'tmpdir'
+
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitSetup
+        TEMP_PREFIX = "vagrant-cloud-init-iso-temp-".freeze
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinit::setup")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          user_data_configs = machine.config.vm.cloud_init_configs
+                                                  .select { |c| c.type == :user_data }
+
+          if !user_data_configs.empty?
+            user_data = setup_user_data(machine, env, user_data_configs)
+            meta_data = { "instance-id" => "i-#{machine.id.split('-').join}" }
+
+            write_cfg_iso(machine, env, user_data, meta_data)
+          end
+
+          # Continue On
+          @app.call(env)
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [Array<#VagrantPlugins::Kernel_V2::VagrantConfigCloudInit>] user_data_cfgs
+        # @return [MIME::Text] user_data
+        def setup_user_data(machine, env, user_data_cfgs)
+          machine.ui.info(I18n.t("vagrant.actions.vm.cloud_init_user_data_setup"))
+
+          text_cfgs = user_data_cfgs.map { |cfg| read_text_cfg(machine, cfg) }
+
+          user_data = generate_cfg_msg(machine, text_cfgs)
+          user_data
+        end
+
+        # Reads an individual cloud_init config and stores its contents and the
+        # content_type as a MIME text
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigCloudInit] cfg
+        # @return [MIME::Text] text_msg
+        def read_text_cfg(machine, cfg)
+          if cfg.path
+            text = File.read(Pathname.new(cfg.path).expand_path(machine.env.root_path))
+          else
+            text = cfg.inline
+          end
+
+          # Note: content_type must remove the leading `text/` because
+          # the MIME::Text initializer hardcodes `text/` already to the type.
+          # We assume content_type is correct due to the validation step
+          # in VagrantConfigCloudInit.
+          content_type = cfg.content_type.split('/', 2).last
+          text_msg = MIME::Text.new(text, content_type)
+
+          text_msg
+        end
+
+        # Combines all known cloud_init configs into a multipart mixed MIME text
+        # message
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Array<MIME::Text>] text_msg - One or more text configs
+        # @return [MIME::Multipart::Mixed] msg
+        def generate_cfg_msg(machine, text_cfgs)
+          msg = MIME::Multipart::Mixed.new
+          msg.headers.set("MIME-Version", "1.0")
+
+          text_cfgs.each do |c|
+            msg.add(c)
+          end
+
+          msg
+        end
+
+        # Writes the contents of the guests cloud_init config to a tmp
+        # dir and passes that source directory along to the host cap to be
+        # written to an iso
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [MIME::Multipart::Mixed] user_data
+        # @param [Hash] meta_data
+        def write_cfg_iso(machine, env, user_data, meta_data)
+          iso_path = nil
+
+          if env[:env].host.capability?(:create_iso)
+            begin
+              source_dir = Pathname.new(Dir.mktmpdir(TEMP_PREFIX))
+              File.open("#{source_dir}/user-data", 'w') { |file| file.write(user_data.to_s) }
+
+              File.open("#{source_dir}/meta-data", 'w') { |file| file.write(meta_data.to_yaml) }
+
+              iso_path = env[:env].host.capability(:create_iso,
+                                                   source_dir, volume_id: "cidata")
+              attach_disk_config(machine, env, iso_path.to_path)
+            ensure
+              FileUtils.remove_entry(source_dir)
+            end
+          else
+            raise Errors::CreateIsoHostCapNotFound
+          end
+        end
+
+        # Adds a new :dvd disk config with the given iso_path to be attached
+        # to the guest later
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [String] iso_path
+        def attach_disk_config(machine, env, iso_path)
+          @logger.info("Adding cloud_init iso '#{iso_path}' to disk config")
+          machine.config.vm.disk :dvd, file: iso_path, name: "vagrant-cloud_init-disk"
+          machine.config.vm.disks.each { |d| d.finalize! if d.type == :dvd && d.file == iso_path }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitWait
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinitwait")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          cloud_init_wait_cmd = "cloud-init status --wait"
+          if !machine.config.vm.cloud_init_configs.empty?
+            if machine.communicate.test("command -v cloud-init")
+              env[:ui].output(I18n.t("vagrant.cloud_init_waiting"))
+              result = machine.communicate.sudo(cloud_init_wait_cmd, error_check: false)
+              if result != 0
+                raise Vagrant::Errors::CloudInitCommandFailed, cmd: cloud_init_wait_cmd, guest_name: machine.name
+              end
+            else
+              raise Vagrant::Errors::CloudInitNotFound, guest_name: machine.name
+            end
+          end
+          @app.call(env)
+        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

@@ -20,7 +20,7 @@ module Vagrant
         def call(env)
           machine = env[:machine]
 
-          if !machine.config.vm.box
+          if !machine.config.vm.box || machine.config.vm.box.to_s.empty?
             @logger.info("Skipping HandleBox because no box is set")
             return @app.call(env)
           end
@@ -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,8 +1,10 @@
 require "set"
 
 require "log4r"
+require "socket"
 
 require "vagrant/util/is_port_open"
+require "vagrant/util/ipv4_interfaces"
 
 module Vagrant
   module Action
@@ -25,6 +27,7 @@ module Vagrant
       #
       class HandleForwardedPortCollisions
         include Util::IsPortOpen
+        include Util::IPv4Interfaces
 
         def initialize(app, env)
           @app    = app
@@ -120,6 +123,7 @@ module Vagrant
             in_use = is_forwarded_already(extra_in_use, host_port, host_ip) ||
               call_port_checker(port_checker, host_ip, host_port) ||
               lease_check(host_ip, host_port)
+
             if in_use
               if !repair || !options[:auto_correct]
                 raise Errors::ForwardPortCollision,
@@ -243,18 +247,33 @@ module Vagrant
         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
+          self.class.port_check(@machine, host_ip, host_port)
+        end
+
+        def self.port_check(machine, host_ip, host_port)
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_port_collisions")
+          # 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 = Vagrant::Util::IPv4Interfaces.ipv4_interfaces.select do |interface|
+              @logger.debug("Testing #{interface[0]} with IP address #{interface[1]}")
+              !Vagrant::Util::IsPortOpen.is_port_open?(interface[1], host_port)
+            end
+            if available_interfaces.empty?
+              @logger.debug("Cannot forward port #{host_port} on any interfaces.")
+              true
             else
-              raise
+              @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" && !Addrinfo.ip(test_host_ip).ipv4_loopback? &&
+                Vagrant::Util::IPv4Interfaces.ipv4_interfaces.none? { |iface| iface[1] == test_host_ip }
+              @logger.warn("host IP address is not local to this device host_ip=#{test_host_ip}")
             end
+            Vagrant::Util::IsPortOpen.is_port_open?(test_host_ip, host_port)
           end
         end