vagrant 1.5.0 → 2.4.4

data/plugins/providers/virtualbox/model/storage_controller.rb

@@ -0,0 +1,138 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # Represents a storage controller for VirtualBox. Storage controllers
+      # have a type, a name, and can have hard disks or optical drives attached.
+      class StorageController
+        IDE_CONTROLLER_TYPES = ["PIIX4", "PIIX3", "ICH6"].map(&:freeze).freeze
+        SATA_CONTROLLER_TYPES = ["IntelAhci"].map(&:freeze).freeze
+        SCSI_CONTROLLER_TYPES = ["LsiLogic", "BusLogic", "VirtioSCSI"].map(&:freeze).freeze
+
+        IDE_DEVICES_PER_PORT = 2.freeze
+        SATA_DEVICES_PER_PORT = 1.freeze
+        SCSI_DEVICES_PER_PORT = 1.freeze
+
+        IDE_BOOT_PRIORITY = 1.freeze
+        SATA_BOOT_PRIORITY = 2.freeze
+        SCSI_BOOT_PRIORITY = 3.freeze
+
+        # The name of the storage controller.
+        #
+        # @return [String]
+        attr_reader :name
+
+        # The specific type of controller.
+        #
+        # @return [String]
+        attr_reader :type
+
+        # The maximum number of avilable ports for the storage controller.
+        #
+        # @return [Integer]
+        attr_reader :maxportcount
+
+        # The number of devices that can be attached to each port. For SATA
+        # controllers, this will usually be 1, and for IDE controllers this
+        # will usually be 2.
+        # @return [Integer]
+        attr_reader :devices_per_port
+
+        # The maximum number of individual disks that can be attached to the
+        # storage controller. For SATA controllers, this equals the maximum
+        # number of ports. For IDE controllers, this will be twice the max
+        # number of ports (primary/secondary).
+        #
+        # @return [Integer]
+        attr_reader :limit
+
+        # The boot priority of the storage controller. This does not seem to
+        # depend on the controller number returned by `showvminfo`.
+        # Experimentation has determined that VirtualBox will try to boot from
+        # the first controller it finds with a hard disk, in this order:
+        #   IDE, SATA, SCSI
+        #
+        # @return [Integer]
+        attr_reader :boot_priority
+
+        # The list of disks/ISOs attached to each storage controller.
+        #
+        # @return [Array<Hash>]
+        attr_reader :attachments
+
+        def initialize(name, type, maxportcount, attachments)
+          @name = name
+          @type = type
+
+          @maxportcount = maxportcount.to_i
+
+          if IDE_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :ide
+            @devices_per_port = IDE_DEVICES_PER_PORT
+            @boot_priority = IDE_BOOT_PRIORITY
+          elsif SATA_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :sata
+            @devices_per_port = SATA_DEVICES_PER_PORT
+            @boot_priority = SATA_BOOT_PRIORITY
+          elsif SCSI_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :scsi
+            @devices_per_port = SCSI_DEVICES_PER_PORT
+            @boot_priority = SCSI_BOOT_PRIORITY
+          else
+            @storage_bus = :unknown
+            @devices_per_port = 1
+          end
+
+          @limit = @maxportcount * @devices_per_port
+
+          attachments ||= []
+          @attachments = attachments
+        end
+
+        # Get a single storage device, either by port/device address or by
+        # UUID.
+        #
+        # @param [Hash] opts - A hash of options to match
+        # @return [Hash] attachment - Attachment information
+        def get_attachment(opts = {})
+          if opts[:port] && opts[:device]
+            @attachments.detect { |a| a[:port] == opts[:port] &&
+                                      a[:device] == opts[:device] }
+          elsif opts[:uuid]
+            @attachments.detect { |a| a[:uuid] == opts[:uuid] }
+          end
+        end
+
+        # Returns true if the storage controller has a supported type.
+        #
+        # @return [Boolean]
+        def supported?
+          [:ide, :sata, :scsi].include?(@storage_bus)
+        end
+
+        # Returns true if the storage controller is a IDE type controller.
+        #
+        # @return [Boolean]
+        def ide?
+          @storage_bus == :ide
+        end
+
+        # Returns true if the storage controller is a SATA type controller.
+        #
+        # @return [Boolean]
+        def sata?
+          @storage_bus == :sata
+        end
+
+        # Returns true if the storage controller is a SCSI type controller.
+        #
+        # @return [Boolean]
+        def scsi?
+          @storage_bus == :scsi
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/model/storage_controller_array.rb

@@ -0,0 +1,101 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../cap/validate_disk_ext"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # A collection of storage controllers. Includes finder methods to look
+      # up a storage controller by given attributes.
+      class StorageControllerArray < Array
+        # Returns a storage controller with the given name. Raises an
+        # exception if a matching controller can't be found.
+        #
+        # @param [String] name - The name of the storage controller
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_controller(name)
+          controller = detect { |c| c.name == name }
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksControllerNotFound, name: name
+          end
+          controller
+        end
+
+        # Find the controller containing the primary disk (i.e. the boot
+        # disk). This is used to determine which controller virtual disks
+        # should be attached to.
+        #
+        # Raises an exception if no supported controllers are found.
+        #
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_primary_controller
+          ordered = find_all(&:supported?).sort_by(&:boot_priority)
+          controller = ordered.detect { |c| c.attachments.any? { |a| hdd?(a) } }
+
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksNoSupportedControllers,
+              supported_types: supported_types.join(", ")
+          end
+
+          controller
+        end
+
+        # Find the attachment representing the primary disk (i.e. the boot
+        # disk). We can't rely on the order of #list_hdds, as they will not
+        # always come in port order, but primary is always Port 0 Device 0.
+        #
+        # @return [Hash] attachment - Primary disk attachment information
+        def get_primary_attachment
+          attachment = nil
+
+          controller = get_primary_controller
+          attachment = controller.get_attachment(port: "0", device: "0")
+          if !attachment
+            raise Vagrant::Errors::VirtualBoxDisksPrimaryNotFound
+          end
+
+          attachment
+        end
+
+        # Returns the first supported storage controller for attaching dvds.
+        # Will raise an exception if no suitable controller can be found.
+        #
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_dvd_controller
+          ordered = find_all(&:supported?).sort_by(&:boot_priority)
+          controller = ordered.first
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksNoSupportedControllers,
+              supported_types: supported_types.join(", ")
+          end
+
+          controller
+        end
+
+        private
+
+        # Determine whether the given attachment is a hard disk.
+        #
+        # @param [Hash] attachment - Attachment information
+        # @return [Boolean]
+        def hdd?(attachment)
+          if !attachment
+            false
+          else
+            ext = File.extname(attachment[:location].to_s).downcase.split('.').last
+            VagrantPlugins::ProviderVirtualBox::Cap::ValidateDiskExt.validate_disk_ext(nil, ext)
+          end
+        end
+
+        # Returns a list of all the supported controller types.
+        #
+        # @return [Array<String>]
+        def supported_types
+          StorageController::SATA_CONTROLLER_TYPES + StorageController::IDE_CONTROLLER_TYPES +
+            StorageController::SCSI_CONTROLLER_TYPES
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/plugin.rb

@@ -0,0 +1,120 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    class Plugin < Vagrant.plugin("2")
+      name "VirtualBox provider"
+      description <<-EOF
+      The VirtualBox provider allows Vagrant to manage and control
+      VirtualBox-based virtual machines.
+      EOF
+
+      provider(:virtualbox, priority: 6) do
+        require File.expand_path("../provider", __FILE__)
+        Provider
+      end
+
+      config(:virtualbox, :provider) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      synced_folder(:virtualbox) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      provider_capability(:virtualbox, :forwarded_ports) do
+        require_relative "cap"
+        Cap
+      end
+
+      provider_capability(:virtualbox, :nic_mac_addresses) do
+        require_relative "cap"
+        Cap
+      end
+
+      provider_capability(:virtualbox, :public_address) do
+        require_relative "cap/public_address"
+        Cap::PublicAddress
+      end
+
+      provider_capability(:virtualbox, :configure_disks) do
+        require_relative "cap/configure_disks"
+        Cap::ConfigureDisks
+      end
+
+      provider_capability(:virtualbox, :cleanup_disks) do
+        require_relative "cap/cleanup_disks"
+        Cap::CleanupDisks
+      end
+
+      provider_capability(:virtualbox, :validate_disk_ext) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
+      provider_capability(:virtualbox, :default_disk_exts) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
+      provider_capability(:virtualbox, :set_default_disk_ext) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
+      provider_capability(:virtualbox, :snapshot_list) do
+        require_relative "cap"
+        Cap
+      end
+
+      synced_folder_capability(:virtualbox, "mount_options") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:virtualbox, "mount_type") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:virtualbox, "mount_name") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+    end
+
+    autoload :Action, File.expand_path("../action", __FILE__)
+
+    # Drop some autoloads in here to optimize the performance of loading
+    # our drivers only when they are needed.
+    module Driver
+      autoload :Meta, File.expand_path("../driver/meta", __FILE__)
+      autoload :Version_4_0, File.expand_path("../driver/version_4_0", __FILE__)
+      autoload :Version_4_1, File.expand_path("../driver/version_4_1", __FILE__)
+      autoload :Version_4_2, File.expand_path("../driver/version_4_2", __FILE__)
+      autoload :Version_4_3, File.expand_path("../driver/version_4_3", __FILE__)
+      autoload :Version_5_0, File.expand_path("../driver/version_5_0", __FILE__)
+      autoload :Version_5_1, File.expand_path("../driver/version_5_1", __FILE__)
+      autoload :Version_5_2, File.expand_path("../driver/version_5_2", __FILE__)
+      autoload :Version_6_0, File.expand_path("../driver/version_6_0", __FILE__)
+      autoload :Version_6_1, File.expand_path("../driver/version_6_1", __FILE__)
+      autoload :Version_7_0, File.expand_path("../driver/version_7_0", __FILE__)
+      autoload :Version_7_1, File.expand_path("../driver/version_7_1", __FILE__)
+    end
+
+    module Model
+      autoload :ForwardedPort, File.expand_path("../model/forwarded_port", __FILE__)
+      autoload :StorageController, File.expand_path("../model/storage_controller", __FILE__)
+      autoload :StorageControllerArray, File.expand_path("../model/storage_controller_array", __FILE__)
+    end
+
+    module Util
+      autoload :CompileForwardedPorts, File.expand_path("../util/compile_forwarded_ports", __FILE__)
+    end
+  end
+end

data/plugins/providers/virtualbox/provider.rb

@@ -0,0 +1,133 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def self.installed?
+        Driver::Meta.new
+        true
+      rescue Vagrant::Errors::VirtualBoxInvalidVersion,
+             Vagrant::Errors::VirtualBoxNotDetected,
+             Vagrant::Errors::VirtualBoxKernelModuleNotLoaded,
+             Vagrant::Errors::VirtualBoxInstallIncomplete
+        return false
+      end
+
+      def self.usable?(raise_error=false)
+        # Instantiate the driver, which will determine the VirtualBox
+        # version and all that, which checks for VirtualBox being present
+        Driver::Meta.new
+        true
+      rescue Vagrant::Errors::VirtualBoxInvalidVersion,
+             Vagrant::Errors::VirtualBoxNotDetected,
+             Vagrant::Errors::VirtualBoxKernelModuleNotLoaded,
+             Vagrant::Errors::VirtualBoxInstallIncomplete,
+             Vagrant::Errors::VBoxManageNotFoundError
+        raise if raise_error
+        return false
+      end
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::virtualbox")
+        @machine = machine
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      # @see Vagrant::Plugin::V1::Provider#action
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # driver.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the driver for machine ID: #{@machine.id.inspect}")
+          @driver = Driver::Meta.new(id)
+        rescue Driver::Meta::VMNotFound
+          # The virtual machine doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("VM not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # Returns the SSH info for accessing the VirtualBox VM.
+      def ssh_info
+        # If the VM is not running that we can't possibly SSH into it
+        return nil if state.id != :running
+
+        # Return what we know. The host is always "127.0.0.1" because
+        # VirtualBox VMs are always local. The port we try to discover
+        # by reading the forwarded ports.
+        return {
+          host: "127.0.0.1",
+          port: @driver.ssh_port(@machine.config.ssh.guest_port)
+        }
+      end
+
+      # Return the state of VirtualBox virtual machine by actually
+      # querying VBoxManage.
+      #
+      # @return [Symbol]
+      def state
+        # We have to check if the UID matches to avoid issues with
+        # VirtualBox.
+        if Vagrant::Util::Platform.wsl_windows_access_bypass?(@machine.data_dir)
+          @logger.warn("Skipping UID check on machine by user request for WSL Windows access.")
+        else
+          uid = @machine.uid
+          if uid && uid.to_s != Process.uid.to_s
+            raise Vagrant::Errors::VirtualBoxUserMismatch,
+              original_uid: uid.to_s,
+              uid: Process.uid.to_s
+          end
+        end
+
+        # Determine the ID of the state here.
+        state_id = nil
+        state_id = :not_created if !@driver.uuid
+        state_id = @driver.read_state if !state_id
+        state_id = :unknown if !state_id
+
+        # Translate into short/long descriptions
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        # Return the state
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      # Returns a human-friendly string version of this provider which
+      # includes the machine's ID that this provider represents, if it
+      # has one.
+      #
+      # @return [String]
+      def to_s
+        id = @machine.id ? @machine.id : "new VM"
+        "VirtualBox (#{id})"
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/synced_folder.rb

@@ -0,0 +1,153 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine, raise_errors=false)
+        # These synced folders only work if the provider if VirtualBox
+        return false if machine.provider_name != :virtualbox
+
+        # This only happens with `vagrant package --base`. Sigh.
+        return true if !machine.provider_config
+
+        machine.provider_config.functional_vboxsf
+      end
+
+      def prepare(machine, folders, _opts)
+        share_folders(machine, folders, false)
+      end
+
+      def enable(machine, folders, _opts)
+        share_folders(machine, folders, true)
+
+        # short guestpaths first, so we don't step on ourselves
+        folders = folders.sort_by do |id, data|
+          if data[:guestpath]
+            data[:guestpath].length
+          else
+            # A long enough path to just do this at the end.
+            10000
+          end
+        end
+
+        # Go through each folder and mount
+        machine.ui.output(I18n.t("vagrant.actions.vm.share_folders.mounting"))
+        fstab_folders = []
+        folders.each do |id, data|
+          if data[:guestpath]
+            # Guest path specified, so mount the folder to specified point
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                  guestpath: data[:guestpath],
+                                  hostpath: data[:hostpath]))
+
+            # Dup the data so we can pass it to the guest API
+            data = data.dup
+
+            # Calculate the owner and group
+            ssh_info = machine.ssh_info
+            data[:owner] ||= ssh_info[:username]
+            data[:group] ||= ssh_info[:username]
+
+            # Mount the actual folder
+            machine.guest.capability(
+              :mount_virtualbox_shared_folder,
+              os_friendly_id(id), data[:guestpath], data)
+          else
+            # If no guest path is specified, then automounting is disabled
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                  hostpath: data[:hostpath]))
+          end
+        end
+      end
+
+      def disable(machine, folders, _opts)
+        if machine.guest.capability?(:unmount_virtualbox_shared_folder)
+          folders.each do |id, data|
+            machine.guest.capability(
+              :unmount_virtualbox_shared_folder,
+              data[:guestpath], data)
+          end
+        end
+
+        # Remove the shared folders from the VM metadata
+        names = folders.map { |id, _data| os_friendly_id(id) }
+        driver(machine).unshare_folders(names)
+      end
+
+      def cleanup(machine, opts)
+        driver(machine).clear_shared_folders if machine.id && machine.id != ""
+      end
+
+      protected
+
+      # This is here so that we can stub it for tests
+      def driver(machine)
+        machine.provider.driver
+      end
+
+      def os_friendly_id(id)
+        id.gsub(/[\s\/\\]/,'_').sub(/^_/, '')
+      end
+
+      # share_folders sets up the shared folder definitions on the
+      # VirtualBox VM.
+      #
+      # The transient parameter determines if we're FORCING transient
+      # or not. If this is false, then any shared folders will be
+      # shared as non-transient unless they've specifically asked for
+      # transient.
+      def share_folders(machine, folders, transient)
+        defs = []
+        warn_user_symlink = false
+
+        folders.each do |id, data|
+          hostpath = data[:hostpath]
+          if !data[:hostpath_exact]
+            hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
+          end
+
+          enable_symlink_create = true
+
+          if ENV['VAGRANT_DISABLE_VBOXSYMLINKCREATE']
+            enable_symlink_create = false
+          end
+
+          unless data[:SharedFoldersEnableSymlinksCreate].nil?
+            enable_symlink_create = data[:SharedFoldersEnableSymlinksCreate]
+          end
+
+          warn_user_symlink ||= enable_symlink_create
+
+          # Only setup the shared folders that match our transient level
+          if (!!data[:transient]) == transient
+            defs << {
+              name: os_friendly_id(id),
+              hostpath: hostpath.to_s,
+              transient: transient,
+              SharedFoldersEnableSymlinksCreate: enable_symlink_create,
+              automount: !!data[:automount]
+            }
+          end
+        end
+
+        if warn_user_symlink
+          display_symlink_create_warning(machine.env)
+        end
+
+        driver(machine).share_folders(defs)
+      end
+
+      def display_symlink_create_warning(env)
+        d_file = env.data_dir.join("vbox_symlink_create_warning")
+        if !d_file.exist?
+          FileUtils.touch(d_file.to_path)
+          env.ui.warn(I18n.t("vagrant.virtualbox.warning.shared_folder_symlink_create"))
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/util/compile_forwarded_ports.rb

@@ -0,0 +1,40 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Util
+      module CompileForwardedPorts
+        include Vagrant::Util::ScopedHashOverride
+
+        # This method compiles the forwarded ports into {ForwardedPort}
+        # models.
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port
+              guest_port = options[:guest]
+              host_port  = options[:host]
+              host_ip    = options[:host_ip]
+              protocol   = options[:protocol] || "tcp"
+              options    = scoped_hash_override(options, :virtualbox)
+              id         = options[:id]
+
+              # If the forwarded port was marked as disabled, ignore.
+              next if options[:disabled]
+
+              key = "#{host_ip}#{protocol}#{host_port}"
+              mappings[key] =
+                Model::ForwardedPort.new(id, host_port, guest_port, options)
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end