vagrant-unbundled 2.2.9.0 → 2.2.10.0

data/plugins/providers/virtualbox/cap/mount_options.rb

@@ -0,0 +1,35 @@
+require_relative "../../../synced_folders/unix_mount_helpers"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Cap
+      module MountOptions
+        extend VagrantPlugins::SyncedFolder::UnixMountHelpers
+
+        VB_MOUNT_TYPE = "vboxsf".freeze
+
+        # Returns mount options for a virual box synced folder
+        #
+        # @param [Machine] machine
+        # @param [String] name of mount
+        # @param [String] path of mount on guest
+        # @param [Hash] hash of mount options 
+        def self.mount_options(machine, name, guest_path, options)
+          mount_options = options.fetch(:mount_options, [])
+          detected_ids = detect_owner_group_ids(machine, guest_path, mount_options, options)
+          mount_uid = detected_ids[:uid]
+          mount_gid = detected_ids[:gid]
+
+          mount_options << "uid=#{mount_uid}"
+          mount_options << "gid=#{mount_gid}"
+          mount_options = mount_options.join(',')
+          return mount_options, mount_uid, mount_gid
+        end
+
+        def self.mount_type(machine)
+          return VB_MOUNT_TYPE
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/cap/validate_disk_ext.rb

@@ -7,18 +7,25 @@ module VagrantPlugins
         LOGGER = Log4r::Logger.new("vagrant::plugins::virtualbox::validate_disk_ext")
 
         # The default set of disk formats that VirtualBox supports
-        DEFAULT_DISK_EXT = ["vdi", "vmdk", "vhd"].map(&:freeze).freeze
+        DEFAULT_DISK_EXT_LIST = ["vdi", "vmdk", "vhd"].map(&:freeze).freeze
+        DEFAULT_DISK_EXT = "vdi".freeze
 
         # @param [Vagrant::Machine] machine
         # @param [String] disk_ext
         # @return [Bool]
         def self.validate_disk_ext(machine, disk_ext)
-          DEFAULT_DISK_EXT.include?(disk_ext)
+          DEFAULT_DISK_EXT_LIST.include?(disk_ext)
         end
 
         # @param [Vagrant::Machine] machine
         # @return [Array]
-        def self.get_default_disk_ext(machine)
+        def self.default_disk_exts(machine)
+          DEFAULT_DISK_EXT_LIST
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @return [String]
+        def self.set_default_disk_ext(machine)
           DEFAULT_DISK_EXT
         end
       end

data/plugins/providers/virtualbox/driver/meta.rb

@@ -117,6 +117,7 @@ module VagrantPlugins
           :export,
           :forward_ports,
           :get_port_and_device,
+          :get_storage_controller,
           :halt,
           :import,
           :list_snapshots,
@@ -133,6 +134,7 @@ module VagrantPlugins
           :read_machine_folder,
           :read_network_interfaces,
           :read_state,
+          :read_storage_controllers,
           :read_used_ports,
           :read_vms,
           :reconfig_host_only,
@@ -144,6 +146,7 @@ module VagrantPlugins
           :set_mac_address,
           :set_name,
           :share_folders,
+          :show_medium_info,
           :ssh_port,
           :start,
           :suspend,

data/plugins/providers/virtualbox/driver/version_5_0.rb

@@ -22,20 +22,22 @@ module VagrantPlugins
         # - Port: 0
         # - Device: 0
         #
+        # @param [String] controller_name - name of storage controller to attach disk to
         # @param [String] port - port on device to attach disk to
         # @param [String] device - device on controller for disk
-        # @param [String] file - disk file path
         # @param [String] type - type of disk to attach
+        # @param [String] file - disk file path
         # @param [Hash]   opts -  additional options
-        def attach_disk(port, device, file, type="hdd", **opts)
-          # Maybe only support SATA Controller for `:disk`???
-          controller = "SATA Controller"
-
+        def attach_disk(controller_name, port, device, type, file, **opts)
           comment = "This disk is managed externally by Vagrant. Removing or adjusting settings could potentially cause issues with Vagrant."
 
-          execute('storageattach', @uuid, '--storagectl', controller, '--port',
-                  port.to_s, '--device', device.to_s, '--type', type, '--medium',
-                  file, '--comment', comment)
+          execute('storageattach', @uuid,
+                  '--storagectl', controller_name,
+                  '--port', port.to_s,
+                  '--device', device.to_s,
+                  '--type', type,
+                  '--medium', file,
+                  '--comment', comment)
         end
 
         def clear_forwarded_ports
@@ -224,12 +226,15 @@ module VagrantPlugins
           raise
         end
 
+        # @param [String] controller_name - controller name to remove disk from
         # @param [String] port - port on device to attach disk to
         # @param [String] device - device on controller for disk
-        # @param [Hash]   opts -  additional options
-        def remove_disk(port, device)
-          controller = "SATA Controller"
-          execute('storageattach', @uuid, '--storagectl', controller, '--port', port.to_s, '--device', device.to_s, '--medium', "none")
+        def remove_disk(controller_name, port, device)
+          execute('storageattach', @uuid,
+                  '--storagectl', controller_name,
+                  '--port', port.to_s,
+                  '--device', device.to_s,
+                  '--medium', "none")
         end
 
         # @param [String] disk_file
@@ -388,20 +393,21 @@ module VagrantPlugins
         # Returns port and device for an attached disk given a disk uuid. Returns
         # empty hash if disk is not attachd to guest
         #
-        # @param [Hash] vm_info - A guests information from vboxmanage
         # @param [String] disk_uuid - the UUID for the disk we are searching for
         # @return [Hash] disk_info - Contains a device and port number
         def get_port_and_device(disk_uuid)
-          vm_info = show_vm_info
-
           disk = {}
-          disk_info_key = vm_info.key(disk_uuid)
-          return disk if !disk_info_key
 
-          disk_info = disk_info_key.split("-")
-
-          disk[:port] = disk_info[2]
-          disk[:device] = disk_info[3]
+          storage_controllers = read_storage_controllers
+          storage_controllers.each do |controller|
+            controller.attachments.each do |attachment|
+              if disk_uuid == attachment[:uuid]
+                disk[:port] = attachment[:port]
+                disk[:device] = attachment[:device]
+                return disk
+              end
+            end
+          end
 
           return disk
         end
@@ -802,6 +808,26 @@ module VagrantPlugins
           end
         end
 
+        # Returns information for a given disk
+        #
+        # @param [String] disk_type - can be "disk", "dvd", or "floppy"
+        # @param [String] disk_uuid_or_file
+        # @return [Hash] disk
+        def show_medium_info(disk_type, disk_uuid_or_file)
+          disk = {}
+          execute('showmediuminfo', disk_type, disk_uuid_or_file, retryable: true).split("\n").each do |line|
+            parts = line.partition(":")
+            key = parts.first.strip
+            value = parts.last.strip
+            disk[key] = value
+
+            if key == "Location"
+              disk["Disk Name"] = File.basename(value, ".*")
+            end
+          end
+          disk
+        end
+
         def ssh_port(expected_port)
           @logger.debug("Searching for SSH port: #{expected_port.inspect}")
 
@@ -923,6 +949,55 @@ module VagrantPlugins
           destination
         end
 
+        # Helper method to get a list of storage controllers added to the
+        # current VM
+        #
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageControllerArray]
+        def read_storage_controllers
+          vm_info = show_vm_info
+          count = vm_info.count { |key, value| key.match(/^storagecontrollername\d+$/) }
+          all_disks = list_hdds
+
+          storage_controllers = Model::StorageControllerArray.new
+
+          (0..count - 1).each do |n|
+            # basic controller metadata
+            name = vm_info["storagecontrollername#{n}"]
+            type = vm_info["storagecontrollertype#{n}"]
+            maxportcount = vm_info["storagecontrollermaxportcount#{n}"].to_i
+
+            # build attachments array
+            attachments = []
+            vm_info.each do |k, v|
+              if /^#{name}-ImageUUID-(\d+)-(\d+)$/ =~ k
+                port = $1.to_s
+                device = $2.to_s
+                uuid = v
+                location = vm_info["#{name}-#{port}-#{device}"]
+
+                extra_disk_data = all_disks.detect { |d| d["UUID"] == uuid }
+
+                attachment = { port: port,
+                               device: device,
+                               uuid: uuid,
+                               location: location }
+
+                extra_disk_data&.each do |dk,dv|
+                  # NOTE: We convert the keys from VirtualBox to symbols
+                  # to be consistent with the other keys
+                  attachment[dk.downcase.gsub(' ', '_').to_sym] = dv
+                end
+
+                attachments << attachment
+              end
+            end
+
+            storage_controllers << Model::StorageController.new(name, type, maxportcount, attachments)
+          end
+
+          storage_controllers
+        end
+
         protected
 
         def valid_ip_address?(ip)

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

@@ -0,0 +1,135 @@
+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"].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,100 @@
+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 = sort { |a, b| a.boot_priority <=> b.boot_priority }
+          controller = ordered.detect do |c|
+            c.supported? && c.attachments.any? { |a| hdd?(a) }
+          end
+
+          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 = sort { |a, b| a.boot_priority <=> b.boot_priority }
+          controller = ordered.detect { |c| c.supported? }
+          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