vagrant-unbundled 2.2.7.0 → 2.2.16.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
@@ -107,6 +108,14 @@ module Vagrant
             end
           end
 
+          is_error = is_metadata_results.find do |b|
+            b.is_a?(Errors::DownloaderError)
+          end
+          if is_error
+            raise Errors::BoxMetadataDownloadError,  
+              message: is_error.extra_data[:message]
+          end
+
           is_metadata = is_metadata_results.any? { |b| b === true }
           if is_metadata && url.length > 1
             raise Errors::BoxAddMetadataMultiURL,
@@ -117,7 +126,7 @@ module Vagrant
             url = [url.first, authed_urls.first]
             add_from_metadata(url, env, expanded)
           else
-            add_direct(url, env)
+            add_direct(authed_urls, env)
           end
 
           @app.call(env)
@@ -433,14 +442,18 @@ 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)
+          d = Util::Downloader.new(url, temp_path, downloader_options)
+          env[:hook].call(:authenticate_box_downloader, downloader: d)
+          d
         end
 
         def download(url, env, **opts)
           opts[:ui] = true if !opts.key?(:ui)
 
           d = downloader(url, env, **opts)
+          env[:hook].call(:authenticate_box_downloader, downloader: d)
 
           # Download the box to a temporary path. We store the temporary
           # path as an instance variable so that the `#recover` method can
@@ -484,6 +497,7 @@ module Vagrant
         # @return [Boolean] true if metadata
         def metadata_url?(url, env)
           d = downloader(url, env, json: true, ui: false)
+          env[:hook].call(:authenticate_box_downloader, downloader: d)
 
           # If we're downloading a file, cURL just returns no
           # content-type (makes sense), so we just test if it is JSON
@@ -494,7 +508,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|
@@ -532,11 +546,13 @@ module Vagrant
           !!(match.last.chomp =~ /application\/json/)
         end
 
-        def validate_checksum(checksum_type, checksum, path)
+        def validate_checksum(checksum_type, _checksum, path)
+          checksum = _checksum.strip()
           @logger.info("Validating checksum with #{checksum_type}")
           @logger.info("Expected checksum: #{checksum}")
 
-          actual = FileChecksum.new(path, checksum_type).checksum
+          _actual = FileChecksum.new(path, checksum_type).checksum
+          actual = _actual.strip()
           @logger.info("Actual checksum: #{actual}")
           if actual.casecmp(checksum) != 0
             raise Errors::BoxChecksumMismatch,

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

@@ -46,7 +46,8 @@ module Vagrant
             client_cert: env[:client_cert] ||
                            machine.config.vm.box_download_client_cert,
             insecure: !env[:insecure].nil? ?
-                        env[:insecure] : machine.config.vm.box_download_insecure
+                        env[:insecure] : machine.config.vm.box_download_insecure,
+            box_extra_download_options: env[:box_extra_download_options] || machine.config.vm.box_extra_download_options,
           }
 
           env[:ui].output(I18n.t(

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,122 @@
+require 'vagrant/util/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 [Vagrant::Util::Mime::MultiPart] 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 [Vagrant::Util::Mime::Entity] 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
+
+          text_msg = Vagrant::Util::Mime::Entity.new(text, cfg.content_type)
+          text_msg.disposition = "attachment; filename=\"#{File.basename(cfg.content_disposition_filename).gsub('"', '\"')}\"" if cfg.content_disposition_filename
+          text_msg
+        end
+
+        # Combines all known cloud_init configs into a multipart mixed MIME text
+        # message
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Array<Vagrant::Util::Mime::Entity>] text_msg - One or more text configs
+        # @return [Vagrant::Util::Mime::Multipart] msg
+        def generate_cfg_msg(machine, text_cfgs)
+          msg = Vagrant::Util::Mime::Multipart.new
+          msg.headers["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 [Vagrant::Util::Mime::Multipart] 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

@@ -1,3 +1,5 @@
+require "json"
+
 module Vagrant
   module Action
     module Builtin
@@ -12,19 +14,30 @@ module Vagrant
           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)
-             machine.provider.capability(:configure_disks, defined_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
 

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