vagrant 1.5.0 → 2.4.4

data/plugins/providers/virtualbox/action/network_fix_ipv6.rb

@@ -0,0 +1,87 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "ipaddr"
+require "socket"
+
+require "log4r"
+
+require "vagrant/util/presence"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware works around a bug in VirtualBox where booting
+      # a VM with an IPv6 host-only network will sometimes lose the
+      # route to that machine.
+      class NetworkFixIPv6
+        include Vagrant::Util::Presence
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::network")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          # Determine if we have an IPv6 network
+          has_v6 = false
+          env[:machine].config.vm.networks.each do |type, options|
+            next if type != :private_network
+            options = scoped_hash_override(options, :virtualbox)
+            next if options[:ip].to_s.strip == ""
+
+            if IPAddr.new(options[:ip]).ipv6?
+              has_v6 = true
+              break
+            end
+          end
+
+          # Call up
+          @app.call(env)
+
+          # If we have no IPv6, forget it
+          return if !has_v6
+
+          link_local_range = IPAddr.new("fe80::/10")
+          host_only_interfaces(env).each do |interface|
+            next if !present?(interface[:ipv6])
+            next if interface[:status] != "Up"
+
+            ip = IPAddr.new(interface[:ipv6])
+            ip |= ("1" * (128 - interface[:ipv6_prefix].to_i)).to_i(2)
+
+            next if link_local_range.include?(ip)
+
+            @logger.info("testing IPv6: #{ip}")
+
+            begin
+              UDPSocket.new(Socket::AF_INET6).connect(ip.to_s, 80)
+            rescue Errno::EHOSTUNREACH
+              @logger.info("IPv6 host unreachable. Fixing: #{ip}")
+              env[:machine].provider.driver.reconfig_host_only(interface)
+            end
+          end
+        end
+
+        # The list of interface names for host-only adapters.
+        # @return [Array<String>]
+        def host_only_interface_names(env)
+          env[:machine].provider.driver.read_network_interfaces
+            .map { |_, i| i[:hostonly] if i[:type] == :hostonly }.compact
+        end
+
+        # The list of host_only_interfaces that are tied to a host-only adapter.
+        # @return [Array]
+        def host_only_interfaces(env)
+          iface_names = self.host_only_interface_names(env)
+          env[:machine].provider.driver.read_host_only_interfaces
+            .select { |interface| iface_names.include?(interface[:name]) }
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../../../../lib/vagrant/action/general/package"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Package < Vagrant::Action::General::Package
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          general_call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package_setup_files.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../../../../lib/vagrant/action/general/package_setup_files"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PackageSetupFiles < Vagrant::Action::General::PackageSetupFiles
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          general_call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package_setup_folders.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+
+require_relative "../../../../lib/vagrant/action/general/package_setup_folders"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PackageSetupFolders < Vagrant::Action::General::PackageSetupFolders
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          general_call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package_vagrantfile.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PackageVagrantfile
+        # For TemplateRenderer
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          create_vagrantfile
+          @app.call(env)
+        end
+
+        # This method creates the auto-generated Vagrantfile at the root of the
+        # box. This Vagrantfile contains the MAC address so that the user doesn't
+        # have to worry about it.
+        def create_vagrantfile
+          File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
+            f.write(TemplateRenderer.render("package_Vagrantfile", {
+              base_mac: @env[:machine].provider.driver.read_mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_clone_snapshot.rb

@@ -0,0 +1,69 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "digest/md5"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareCloneSnapshot
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::prepare_clone")
+        end
+
+        def call(env)
+          if !env[:clone_id]
+            @logger.info("no clone master, not preparing clone snapshot")
+            return @app.call(env)
+          end
+
+          # If we're not doing a linked clone, snapshots don't matter
+          if !env[:machine].provider_config.linked_clone
+            return @app.call(env)
+          end
+
+          # We lock so that we don't snapshot in parallel
+          lock_key = Digest::MD5.hexdigest("#{env[:clone_id]}-snapshot")
+          env[:machine].env.lock(lock_key, retry: true) do
+            prepare_snapshot(env)
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+        protected
+
+        def prepare_snapshot(env)
+          name = env[:machine].provider_config.linked_clone_snapshot
+          name_set = !!name
+          name = "base" if !name
+          env[:clone_snapshot] = name
+
+          # Get the snapshots. We're done if it already exists
+          snapshots = env[:machine].provider.driver.list_snapshots(env[:clone_id])
+          if snapshots.include?(name)
+            @logger.info("clone snapshot already exists, doing nothing")
+            return
+          end
+
+          # If they asked for a specific snapshot, it is an error
+          if name_set
+            # TODO: Error
+          end
+
+          @logger.info("Creating base snapshot for master VM.")
+          env[:machine].provider.driver.create_snapshot(
+            env[:clone_id], name) do |progress|
+              env[:ui].rewriting do |ui|
+                ui.clear_line
+                ui.report_progress(progress, 100, false)
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,38 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Get the forwarded ports used by other virtual machines and
+          # consider those in use as well.
+          env[:port_collision_extra_in_use] = env[:machine].provider.driver.read_used_ports
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:machine].provider.driver.read_forwarded_ports.each do |_nic, name, hostport, _guestport|
+            env[:machine].config.vm.networks.each do |type, options|
+              next if type != :forwarded_port
+
+              # If the ID matches the name of the forwarded port, then
+              # remap.
+              if options[:id] == name
+                remap[options[:host]] = hostport
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -0,0 +1,162 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "ipaddr"
+require "vagrant/action/builtin/mixin_synced_folders"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareNFSSettings
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+
+          @app.call(env)
+
+          opts = {
+            cached: !!env[:synced_folders_cached],
+            config: env[:synced_folders_config],
+            disable_usable_check: !!env[:test],
+          }
+          folders = synced_folders(env[:machine], **opts)
+
+          if folders.key?(:nfs)
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            add_ips_to_env!(env)
+          end
+        end
+
+        # Extracts the proper host and guest IPs for NFS mounts and stores them
+        # in the environment for the SyncedFolder action to use them in
+        # mounting.
+        #
+        # The ! indicates that this method modifies its argument.
+        def add_ips_to_env!(env)
+          adapter, host_ip = find_host_only_adapter
+          machine_ip       = read_static_machine_ips
+
+          if !machine_ip
+            # No static IP, attempt to use the dynamic IP.
+            machine_ip = read_dynamic_machine_ip(adapter)
+          else
+            # We have static IPs, also attempt to read any dynamic IPs.
+            # If there is no dynamic IP on the adapter, it doesn't matter. We
+            # already have a static IP.
+            begin
+              dynamic_ip = read_dynamic_machine_ip(adapter)
+            rescue Vagrant::Errors::NFSNoGuestIP
+              dynamic_ip = nil
+            end
+
+            # If we found a dynamic IP and we didn't include it in the
+            # machine_ip array yet, do so.
+            if dynamic_ip && !machine_ip.include?(dynamic_ip)
+              machine_ip.push(dynamic_ip)
+            end
+          end
+
+          if host_ip && !machine_ip.empty?
+            interface = @machine.provider.driver.read_host_only_interfaces.detect do |iface|
+              iface[:ip] == host_ip
+            end
+            host_ipaddr = IPAddr.new("#{host_ip}/#{interface.fetch(:netmask, "0.0.0.0")}")
+
+            case machine_ip
+            when String
+              machine_ip = nil if !host_ipaddr.include?(machine_ip)
+            when Array
+              machine_ip.delete_if do |m_ip|
+                !host_ipaddr.include?(m_ip)
+              end
+              machine_ip = nil if machine_ip.empty?
+            end
+          end
+
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
+
+          env[:nfs_host_ip]    = host_ip
+          env[:nfs_machine_ip] = machine_ip
+        end
+
+        # Finds first host only network adapter and returns its adapter number
+        # and IP address
+        #
+        # @return [Integer, String] adapter number, ip address of found host-only adapter
+        def find_host_only_adapter
+          @machine.provider.driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              @machine.provider.driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return adapter, interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address(es) of the guest by looking for static IPs
+        # given to host only adapters in the Vagrantfile
+        #
+        # @return [Array]<String> Configured static IPs
+        def read_static_machine_ips
+          ips = []
+          @machine.config.vm.networks.each do |type, options|
+            options = scoped_hash_override(options, :virtualbox)
+
+            if type == :private_network && options[:type] != :dhcp && options[:ip].is_a?(String)
+              ips << options[:ip]
+            end
+          end
+
+          if ips.empty?
+            return nil
+          end
+
+          ips
+        end
+
+        # Returns the IP address of the guest by looking at vbox guest property
+        # for the appropriate guest adapter.
+        #
+        # For DHCP interfaces, the guest property will not be present until the
+        # guest completes
+        #
+        # @param [Integer] adapter number to read IP for
+        # @return [String] ip address of adapter
+        def read_dynamic_machine_ip(adapter)
+          return nil unless adapter
+
+          # vbox guest properties are 0-indexed, while showvminfo network
+          # interfaces are 1-indexed. go figure.
+          guestproperty_adapter = adapter - 1
+
+          # we need to wait for the guest's IP to show up as a guest property.
+          # retry thresholds are relatively high since we might need to wait
+          # for DHCP, but even static IPs can take a second or two to appear.
+          retryable(retry_options.merge(on: Vagrant::Errors::VirtualBoxGuestPropertyNotFound)) do
+            @machine.provider.driver.read_guest_ip(guestproperty_adapter)
+          end
+        rescue Vagrant::Errors::VirtualBoxGuestPropertyNotFound
+          # this error is more specific with a better error message directing
+          # the user towards the fact that it's probably a reportable bug
+          raise Vagrant::Errors::NFSNoGuestIP
+        end
+
+        # Separating these out so we can stub out the sleep in tests
+        def retry_options
+          {tries: 15, sleep: 1}
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_nfs_valid_ids.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          env[:nfs_valid_ids] = env[:machine].provider.driver.read_vms.values
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/resume.rb

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+
+          if current_state == :paused
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.resume
+          elsif current_state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/sane_defaults.rb

@@ -0,0 +1,92 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class SaneDefaults
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
+          @app = app
+        end
+
+        def call(env)
+          # Set the env on an instance variable so we can access it in
+          # helpers.
+          @env = env
+
+          # Use rtcuseutc so that the VM sees UTC time.
+          command = ["modifyvm", env[:machine].id, "--rtcuseutc", "on"]
+          attempt_and_log(command, "Enabling rtcuseutc...")
+
+          if env[:machine].provider_config.auto_nat_dns_proxy
+            @logger.info("Automatically figuring out whether to enable/disable NAT DNS proxy...")
+
+            # Enable/disable the NAT DNS proxy as necessary
+            if enable_dns_proxy?
+              command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "on"]
+              attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
+            else
+              command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "off" ]
+              attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
+              command = ["modifyvm", env[:machine].id, "--natdnshostresolver1", "off" ]
+              attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
+            end
+          else
+            @logger.info("NOT trying to automatically manage NAT DNS proxy.")
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This is just a helper method that executes a single command, logs
+        # the given string to the log, and also includes the exit status in
+        # the log message.
+        #
+        # We assume every command is idempotent and pass along the `retryable`
+        # flag. This is because VBoxManage is janky about running simultaneously
+        # on the same box, and if we up multiple boxes at the same time, a bunch
+        # of modifyvm commands get fired
+        #
+        # @param [Array] command Command to run
+        # @param [String] log Log message to write.
+        def attempt_and_log(command, log)
+          begin
+            @env[:machine].provider.driver.execute_command(
+              command + [retryable: true])
+          rescue Vagrant::Errors::VBoxManageError => e
+            @logger.info("#{log} (error = #{e.inspect})")
+          end
+        end
+
+        # This uses some heuristics to determine if the NAT DNS proxy should
+        # be enabled or disabled. See the comments within the function body
+        # itself to see the checks it does.
+        #
+        # @return [Boolean]
+        def enable_dns_proxy?
+          begin
+            contents = File.read("/etc/resolv.conf")
+
+            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
+              # The use of both natdnsproxy and natdnshostresolver break on
+              # Ubuntu 12.04 and 12.10 that uses resolvconf with localhost. When used
+              # VirtualBox will give the client dns server 10.0.2.3, while
+              # not binding to that address itself. Therefore disable this
+              # feature if host uses the resolvconf server 127.0.0.1 or
+              # 127.0.1.1
+              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1 or 127.0.1.1")
+              return false
+            end
+          rescue Errno::ENOENT; end
+
+          return true
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/set_default_nic_type.rb

@@ -0,0 +1,72 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This sets the default NIC type used for network adapters created
+      # on the guest. Also includes a check of NIC types in use and VirtualBox
+      # version to determine if E1000 NIC types are vulnerable.
+      #
+      # NOTE: Vulnerability was fixed here: https://www.virtualbox.org/changeset/75330/vbox
+      class SetDefaultNICType
+        # Defines versions of VirtualBox with susceptible implementation
+        # of the E1000 devices.
+        E1000_SUSCEPTIBLE = Gem::Requirement.new("< 5.2.22").freeze
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::set_default_nic_type")
+          @app    = app
+        end
+
+        def call(env)
+          default_nic_type = env[:machine].provider_config.default_nic_type
+
+          e1000_in_use = [
+            # simple check on default_nic_type
+            ->{ default_nic_type.nil? || default_nic_type.to_s.start_with?("8254") },
+            # check provider defined adapters
+            ->{ env[:machine].provider_config.network_adapters.values.detect{ |_, opts|
+                opts[:nic_type].to_s.start_with?("8254") } },
+            # finish with inspecting configured networks
+            ->{ env[:machine].config.vm.networks.detect{ |_, opts|
+                opts.fetch(:virtualbox__nic_type, opts[:nic_type]).to_s.start_with?("8254") } }
+          ]
+
+          # Check if VirtualBox E1000 implementation is vulnerable
+          if E1000_SUSCEPTIBLE.satisfied_by?(Gem::Version.new(env[:machine].provider.driver.version))
+            @logger.info("Detected VirtualBox version with susceptible E1000 implementation (`#{E1000_SUSCEPTIBLE}`)")
+            if e1000_in_use.any?(&:call)
+              env[:ui].warn I18n.t("vagrant.actions.vm.set_default_nic_type.e1000_warning")
+            end
+          end
+
+          if default_nic_type
+            @logger.info("Default NIC type for VirtualBox interfaces `#{default_nic_type}`")
+            # Update network adapters defined in provider configuration
+            env[:machine].provider_config.network_adapters.each do |slot, args|
+              _, opts = args
+              if opts && !opts.key?(:nic_type)
+                @logger.info("Setting default NIC type (`#{default_nic_type}`) adapter `#{slot}` - `#{args}`")
+                opts[:nic_type] = default_nic_type
+              end
+            end
+
+            # Update generally defined networks
+            env[:machine].config.vm.networks.each do |type, options|
+              next if !type.to_s.end_with?("_network")
+              if !options.key?(:nic_type) && !options.key?(:virtualbox__nic_type)
+                @logger.info("Setting default NIC type (`#{default_nic_type}`) for `#{type}` - `#{options}`")
+                options[:virtualbox__nic_type] = default_nic_type
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end