vagrant-unbundled 2.2.9.0 → 2.2.10.0

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

@@ -16,38 +16,69 @@ module VagrantPlugins
           return if !Vagrant::Util::Experimental.feature_enabled?("disks")
 
           handle_cleanup_disk(machine, defined_disks, disk_meta_file["disk"])
-          # TODO: Floppy and DVD disks
+          handle_cleanup_dvd(machine, defined_disks, disk_meta_file["dvd"])
+          # TODO: Floppy disks
         end
 
         protected
 
         # @param [Vagrant::Machine] machine
         # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
-        # @param [Hash] disk_meta - A hash of all the previously defined disks from the last configure_disk action
+        # @param [Array<Hash>] disk_meta - An array of all the previously defined disks from the last configure_disk action
         def self.handle_cleanup_disk(machine, defined_disks, disk_meta)
-          vm_info = machine.provider.driver.show_vm_info
-          primary_disk = vm_info["SATA Controller-ImageUUID-0-0"]
+          raise TypeError, "Expected `Array` but received `#{disk_meta.class}`" if !disk_meta.is_a?(Array)
+          storage_controllers = machine.provider.driver.read_storage_controllers
+
+          primary = storage_controllers.get_primary_attachment
+          primary_uuid = primary[:uuid]
 
           disk_meta.each do |d|
             dsk = defined_disks.select { |dk| dk.name == d["name"] }
-            if !dsk.empty? || d["uuid"] == primary_disk
+            if !dsk.empty? || d["uuid"] == primary_uuid
               next
             else
               LOGGER.warn("Found disk not in Vagrantfile config: '#{d["name"]}'. Removing disk from guest #{machine.name}")
-              disk_info = machine.provider.driver.get_port_and_device(d["uuid"])
+              machine.ui.warn(I18n.t("vagrant.cap.cleanup_disks.disk_cleanup", name: d["name"]), prefix: true)
 
-              machine.ui.warn("Disk '#{d["name"]}' no longer exists in Vagrant config. Removing and closing medium from guest...", prefix: true)
+              controller = storage_controllers.get_controller(d["controller"])
+              attachment = controller.get_attachment(uuid: d["uuid"])
 
-              if disk_info.empty?
+              if !attachment
                 LOGGER.warn("Disk '#{d["name"]}' not attached to guest, but still exists.")
               else
-                machine.provider.driver.remove_disk(disk_info[:port], disk_info[:device])
+                machine.provider.driver.remove_disk(controller.name, attachment[:port], attachment[:device])
               end
 
               machine.provider.driver.close_medium(d["uuid"])
             end
           end
         end
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_dvds
+        # @param [Array<Hash>] dvd_meta - An array of all the previously defined dvds from the last configure_disk action
+        def self.handle_cleanup_dvd(machine, defined_dvds, dvd_meta)
+          raise TypeError, "Expected `Array` but received `#{dvd_meta.class}`" if !dvd_meta.is_a?(Array)
+          dvd_meta.each do |d|
+            dsk = defined_dvds.select { |dk| dk.name == d["name"] }
+            if !dsk.empty?
+              next
+            else
+              LOGGER.warn("Found dvd not in Vagrantfile config: '#{d["name"]}'. Removing dvd from guest #{machine.name}")
+              machine.ui.warn("DVD '#{d["name"]}' no longer exists in Vagrant config. Removing medium from guest...", prefix: true)
+
+              storage_controllers = machine.provider.driver.read_storage_controllers
+              controller = storage_controllers.get_controller(d["controller"])
+              attachment = controller.get_attachment(uuid: d["uuid"])
+
+              if !attachment
+                LOGGER.warn("DVD '#{d["name"]}' not attached to guest, but still exists.")
+              else
+                machine.provider.driver.remove_disk(controller.name, attachment[:port], attachment[:device])
+              end
+            end
+          end
+        end
       end
     end
   end

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

@@ -9,9 +9,6 @@ module VagrantPlugins
       module ConfigureDisks
         LOGGER = Log4r::Logger.new("vagrant::plugins::virtualbox::configure_disks")
 
-        # The max amount of disks that can be attached to a single device in a controller
-        MAX_DISK_NUMBER = 30.freeze
-
         # @param [Vagrant::Machine] machine
         # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
         # @return [Hash] configured_disks - A hash of all the current configured disks
@@ -20,27 +17,66 @@ module VagrantPlugins
 
           return {} if !Vagrant::Util::Experimental.feature_enabled?("disks")
 
-          if defined_disks.size > MAX_DISK_NUMBER
-            # you can only attach up to 30 disks per controller, INCLUDING the primary disk
-            raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit
-          end
-
           machine.ui.info(I18n.t("vagrant.cap.configure_disks.start"))
 
-          current_disks = machine.provider.driver.list_hdds
+          storage_controllers = machine.provider.driver.read_storage_controllers
+
+          # Check to determine which controller we should attach disks to.
+          # If there is only one storage controller attached to the VM, use
+          # it. If there are multiple controllers (e.g. IDE/SATA), attach DVDs
+          # to the IDE controller and disks to the SATA controller.
+          if storage_controllers.size == 1
+            controller = storage_controllers.first
+
+            # The only way you can define up to the controller limit is if
+            # exactly one disk is a primary disk, otherwise we need to reserve
+            # a slot for the primary
+            if (defined_disks.any? { |d| d.primary } && defined_disks.size > controller.limit) ||
+               defined_disks.size > controller.limit - 1
+              raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit,
+                limit: controller.limit,
+                name: controller.name
+            else
+              disk_controller = controller
+              dvd_controller = controller
+            end
+          else
+            disks_defined = defined_disks.select { |d| d.type == :disk }
+            if disks_defined.any?
+              disk_controller = storage_controllers.get_primary_controller
+
+              if (disks_defined.any? { |d| d.primary } && disks_defined.size > disk_controller.limit) ||
+                 disks_defined.size > disk_controller.limit - 1
+                raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit,
+                  limit: disk_controller.limit,
+                  name: disk_controller.name
+              end
+            end
+
+            dvds_defined = defined_disks.select { |d| d.type == :dvd }
+            if dvds_defined.any?
+              dvd_controller = storage_controllers.get_dvd_controller
+
+              if dvds_defined.size > dvd_controller.limit
+                raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit,
+                  limit: dvd_controller.limit,
+                  name: dvd_controller.name
+              end
+            end
+          end
 
-          configured_disks = {disk: [], floppy: [], dvd: []}
+          configured_disks = { disk: [], floppy: [], dvd: [] }
 
           defined_disks.each do |disk|
             if disk.type == :disk
-              disk_data = handle_configure_disk(machine, disk, current_disks)
+              disk_data = handle_configure_disk(machine, disk, disk_controller.name)
               configured_disks[:disk] << disk_data unless disk_data.empty?
             elsif disk.type == :floppy
               # TODO: Write me
               machine.ui.info(I18n.t("vagrant.cap.configure_disks.floppy_not_supported", name: disk.name))
             elsif disk.type == :dvd
-              # TODO: Write me
-              machine.ui.info(I18n.t("vagrant.cap.configure_disks.dvd_not_supported", name: disk.name))
+              dvd_data = handle_configure_dvd(machine, disk, dvd_controller.name)
+              configured_disks[:dvd] << dvd_data unless dvd_data.empty?
             end
           end
 
@@ -56,15 +92,10 @@ module VagrantPlugins
         def self.get_current_disk(machine, disk, all_disks)
           current_disk = nil
           if disk.primary
-            # Ensure we grab the proper primary disk
-            # We can't rely on the order of `all_disks`, as they will not
-            # always come in port order, but primary is always Port 0 Device 0.
-            vm_info = machine.provider.driver.show_vm_info
-            primary_uuid = vm_info["SATA Controller-ImageUUID-0-0"]
-
-            current_disk = all_disks.select { |d| d["UUID"] == primary_uuid }.first
+            storage_controllers = machine.provider.driver.read_storage_controllers
+            current_disk = storage_controllers.get_primary_attachment
           else
-            current_disk = all_disks.select { |d| d["Disk Name"] == disk.name}.first
+            current_disk = all_disks.detect { |d| d[:disk_name] == disk.name }
           end
 
           current_disk
@@ -74,40 +105,117 @@ module VagrantPlugins
         #
         # @param [Vagrant::Machine] machine - the current machine
         # @param [Config::Disk] disk - the current disk to configure
-        # @param [Array] all_disks - A list of all currently defined disks in VirtualBox
+        # @param [String] controller_name - the name of the storage controller to use
         # @return [Hash] - disk_metadata
-        def self.handle_configure_disk(machine, disk, all_disks)
+        def self.handle_configure_disk(machine, disk, controller_name)
+          storage_controllers = machine.provider.driver.read_storage_controllers
+          controller = storage_controllers.get_controller(controller_name)
+          all_disks = controller.attachments
+
           disk_metadata = {}
 
-          # Grab the existing configured disk, if it exists
+          # Grab the existing configured disk attached to guest, if it exists
           current_disk = get_current_disk(machine, disk, all_disks)
 
-          # Configure current disk
           if !current_disk
-            # create new disk and attach
-            disk_metadata = create_disk(machine, disk)
-          elsif compare_disk_size(machine, disk, current_disk)
-            disk_metadata = resize_disk(machine, disk, current_disk)
-          else
-            # TODO: What if it needs to be resized?
+            # Look for an existing disk that's not been attached but exists
+            # inside VirtualBox
+            #
+            # NOTE: This assumes that if that disk exists and was created by
+            # Vagrant, it exists in the same location as the primary disk file.
+            # Otherwise Vagrant has no good way to determining if the disk was
+            # associated with the guest, since disk names are not unique
+            # globally to VirtualBox.
+            primary = storage_controllers.get_primary_attachment
+            existing_disk = machine.provider.driver.list_hdds.detect do |d|
+              File.dirname(d["Location"]) == File.dirname(primary[:location]) &&
+                d["Disk Name"] == disk.name
+            end
 
-            disk_info = machine.provider.driver.get_port_and_device(current_disk["UUID"])
-            if disk_info.empty?
+            if !existing_disk
+              # create new disk and attach to guest
+              disk_metadata = create_disk(machine, disk, controller)
+            else
+              # Disk has been created but failed to be attached to guest, so
+              # this method recovers that disk from previous failure
+              # and attaches it onto the guest
               LOGGER.warn("Disk '#{disk.name}' is not connected to guest '#{machine.name}', Vagrant will attempt to connect disk to guest")
-              dsk_info = get_next_port(machine)
-              machine.provider.driver.attach_disk(dsk_info[:port],
+              dsk_info = get_next_port(machine, controller)
+              machine.provider.driver.attach_disk(controller.name,
+                                                  dsk_info[:port],
                                                   dsk_info[:device],
-                                                  current_disk["Location"])
-            else
-              LOGGER.info("No further configuration required for disk '#{disk.name}'")
+                                                  "hdd",
+                                                  existing_disk["Location"])
+
+              disk_metadata[:uuid] = existing_disk["UUID"]
+              disk_metadata[:port] = dsk_info[:port]
+              disk_metadata[:device] = dsk_info[:device]
+              disk_metadata[:name] = disk.name
+              disk_metadata[:controller] = controller.name
             end
+          elsif compare_disk_size(machine, disk, current_disk)
+            disk_metadata = resize_disk(machine, disk, current_disk, controller)
+          else
+            LOGGER.info("No further configuration required for disk '#{disk.name}'")
+            disk_metadata[:uuid] = current_disk[:uuid]
+            disk_metadata[:port] = current_disk[:port]
+            disk_metadata[:device] = current_disk[:device]
 
-            disk_metadata = {uuid: current_disk["UUID"], name: disk.name}
+            disk_metadata[:name] = disk.name
+            disk_metadata[:controller] = controller.name
           end
 
           disk_metadata
         end
 
+        # Handles all disk configs of type `:dvd`
+        #
+        # @param [Vagrant::Machine] machine - the current machine
+        # @param [Config::Disk] dvd - the current disk to configure
+        # @param [String] controller_name - the name of the storage controller to use
+        # @return [Hash] - dvd_metadata
+        def self.handle_configure_dvd(machine, dvd, controller_name)
+          storage_controllers = machine.provider.driver.read_storage_controllers
+          controller = storage_controllers.get_controller(controller_name)
+
+          dvd_metadata = {}
+
+          dvd_location = File.expand_path(dvd.file)
+          dvd_attached = controller.attachments.detect { |a| a[:location] == dvd_location }
+
+          if dvd_attached
+            LOGGER.info("No further configuration required for dvd '#{dvd.name}'")
+            dvd_metadata[:name] = dvd.name
+            dvd_metadata[:port] = dvd_attached[:port]
+            dvd_metadata[:device] = dvd_attached[:device]
+            dvd_metadata[:uuid] = dvd_attached[:uuid]
+            dvd_metadata[:controller] = controller.name
+          else
+            LOGGER.warn("DVD '#{dvd.name}' is not connected to guest '#{machine.name}', Vagrant will attempt to connect dvd to guest")
+            dsk_info = get_next_port(machine, controller)
+            machine.provider.driver.attach_disk(controller.name,
+                                                dsk_info[:port],
+                                                dsk_info[:device],
+                                                "dvddrive",
+                                                dvd.file)
+
+            # Refresh the controller information
+            storage_controllers = machine.provider.driver.read_storage_controllers
+            controller = storage_controllers.get_controller(controller_name)
+
+            attachment = controller.attachments.detect { |a| a[:port] == dsk_info[:port] &&
+                                                             a[:device] == dsk_info[:device] }
+
+            dvd_metadata[:name] = dvd.name
+            dvd_metadata[:port] = dsk_info[:port]
+            dvd_metadata[:device] = dsk_info[:device]
+            dvd_metadata[:uuid] = attachment[:uuid]
+            dvd_metadata[:controller] = controller.name
+          end
+
+          dvd_metadata
+        end
+
         # Check to see if current disk is configured based on defined_disks
         #
         # @param [Kernel_V2::VagrantConfigDisk] disk_config
@@ -115,7 +223,7 @@ module VagrantPlugins
         # @return [Boolean]
         def self.compare_disk_size(machine, disk_config, defined_disk)
           requested_disk_size = Vagrant::Util::Numeric.bytes_to_megabytes(disk_config.size)
-          defined_disk_size = defined_disk["Capacity"].split(" ").first.to_f
+          defined_disk_size = defined_disk[:capacity].split(" ").first.to_f
 
           if defined_disk_size > requested_disk_size
             machine.ui.warn(I18n.t("vagrant.cap.configure_disks.shrink_size_not_supported", name: disk_config.name))
@@ -131,7 +239,9 @@ module VagrantPlugins
         #
         # @param [Vagrant::Machine] machine
         # @param [Kernel_V2::VagrantConfigDisk] disk_config
-        def self.create_disk(machine, disk_config)
+        # @param [VagrantPlugins::ProviderVirtualBox::Model::StorageController] controller -
+        # the storage controller to use
+        def self.create_disk(machine, disk_config, controller)
           machine.ui.detail(I18n.t("vagrant.cap.configure_disks.create_disk", name: disk_config.name))
           # NOTE: At the moment, there are no provider specific configs for VirtualBox
           # but we grab it anyway for future use.
@@ -146,10 +256,16 @@ module VagrantPlugins
           LOGGER.info("Attempting to create a new disk file '#{disk_file}' of size '#{disk_config.size}' bytes")
 
           disk_var = machine.provider.driver.create_disk(disk_file, disk_config.size, disk_ext.upcase)
-          disk_metadata = {uuid: disk_var.split(':').last.strip, name: disk_config.name}
+          dsk_controller_info = get_next_port(machine, controller)
+          machine.provider.driver.attach_disk(controller.name,
+                                              dsk_controller_info[:port],
+                                              dsk_controller_info[:device],
+                                              "hdd",
+                                              disk_file)
 
-          dsk_controller_info = get_next_port(machine)
-          machine.provider.driver.attach_disk(dsk_controller_info[:port], dsk_controller_info[:device], disk_file)
+          disk_metadata = { uuid: disk_var.split(":").last.strip, name: disk_config.name,
+                            controller: controller.name, port: dsk_controller_info[:port],
+                            device: dsk_controller_info[:device] }
 
           disk_metadata
         end
@@ -167,20 +283,47 @@ module VagrantPlugins
         #  device = disk_info[3]
         #
         # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::ProviderVirtualBox::Model::StorageController] controller -
+        # the storage controller to use
         # @return [Hash] dsk_info - The next available port and device on a given controller
-        def self.get_next_port(machine)
-          vm_info = machine.provider.driver.show_vm_info
-          dsk_info = {device: "0", port: "0"}
-
-          disk_images = vm_info.select { |v| v.include?("ImageUUID") && v.include?("SATA Controller") }
-          used_ports = disk_images.keys.map { |k| k.split('-') }.map {|v| v[2].to_i}
-          next_available_port = ((0..(MAX_DISK_NUMBER-1)).to_a - used_ports).first
+        def self.get_next_port(machine, controller)
+          dsk_info = {}
+
+          if controller.devices_per_port == 1
+            used_ports = controller.attachments.map { |a| a[:port].to_i }
+            next_available_port = ((0..(controller.maxportcount - 1)).to_a - used_ports).first
+
+            dsk_info[:port] = next_available_port.to_s
+            dsk_info[:device] = "0"
+          elsif controller.devices_per_port == 2
+            # IDE Controllers have primary/secondary devices, so find the first port
+            # with an empty device
+            (0..(controller.maxportcount - 1)).each do |port|
+              # Skip this port if it's full
+              port_attachments = controller.attachments.select { |a| a[:port] == port.to_s }
+              next if port_attachments.count == controller.devices_per_port
+
+              dsk_info[:port] = port.to_s
+
+              # Check for a free device
+              if port_attachments.any? { |a| a[:device] == "0" }
+                dsk_info[:device] = "1"
+              else
+                dsk_info[:device] = "0"
+              end
+
+              break if dsk_info[:port]
+            end
+          else
+            raise Vagrant::Errors::VirtualBoxDisksUnsupportedController, controller_name: controller.name
+          end
 
-          dsk_info[:port] = next_available_port.to_s
-          if dsk_info[:port].empty?
+          if dsk_info[:port].to_s.empty?
             # This likely only occurs if additional disks have been added outside of Vagrant configuration
-            LOGGER.warn("There are no more available ports to attach disks to for the SATA Controller. Clear up some space on the SATA controller to attach new disks.")
-            raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit
+            LOGGER.warn("There is no more available space to attach disks to for the controller '#{controller}'. Clear up some space on the controller '#{controller}' to attach new disks.")
+            raise Vagrant::Errors::VirtualBoxDisksDefinedExceedLimit,
+              limit: controller.limit,
+              name: controller.name
           end
 
           dsk_info
@@ -189,47 +332,49 @@ module VagrantPlugins
         # @param [Vagrant::Machine] machine
         # @param [Config::Disk] disk_config - the current disk to configure
         # @param [Hash] defined_disk - current disk as represented by VirtualBox
+        # @param [VagrantPlugins::ProviderVirtualBox::Model::StorageController] controller -
+        # the storage controller to use
         # @return [Hash] - disk_metadata
-        def self.resize_disk(machine, disk_config, defined_disk)
+        def self.resize_disk(machine, disk_config, defined_disk, controller)
           machine.ui.detail(I18n.t("vagrant.cap.configure_disks.resize_disk", name: disk_config.name), prefix: true)
 
-          if defined_disk["Storage format"] == "VMDK"
+          if defined_disk[:storage_format] == "VMDK"
             LOGGER.warn("Disk type VMDK cannot be resized in VirtualBox. Vagrant will convert disk to VDI format to resize first, and then convert resized disk back to VMDK format")
 
-            # grab disk to be resized port and device number
-            disk_info = machine.provider.driver.get_port_and_device(defined_disk["UUID"])
             # original disk information in case anything goes wrong during clone/resize
             original_disk = defined_disk
-            backup_disk_location = "#{original_disk["Location"]}.backup"
+            backup_disk_location = "#{original_disk[:location]}.backup"
 
             # clone disk to vdi formatted disk
-            vdi_disk_file = machine.provider.driver.vmdk_to_vdi(defined_disk["Location"])
+            vdi_disk_file = machine.provider.driver.vmdk_to_vdi(defined_disk[:location])
             # resize vdi
             machine.provider.driver.resize_disk(vdi_disk_file, disk_config.size.to_i)
 
             begin
               # Danger Zone
-
               # remove and close original volume
-              machine.provider.driver.remove_disk(disk_info[:port], disk_info[:device])
+              machine.provider.driver.remove_disk(controller.name, defined_disk[:port], defined_disk[:device])
               # Create a backup of the original disk if something goes wrong
-              LOGGER.warn("Making a backup of the original disk at #{defined_disk["Location"]}")
-              FileUtils.mv(defined_disk["Location"], backup_disk_location)
+              LOGGER.warn("Making a backup of the original disk at #{defined_disk[:location]}")
+              FileUtils.mv(defined_disk[:location], backup_disk_location)
 
               # we have to close here, otherwise we can't re-clone after
               # resizing the vdi disk
-              machine.provider.driver.close_medium(defined_disk["UUID"])
+              machine.provider.driver.close_medium(defined_disk[:uuid])
 
               # clone back to original vmdk format and attach resized disk
               vmdk_disk_file = machine.provider.driver.vdi_to_vmdk(vdi_disk_file)
-              machine.provider.driver.attach_disk(disk_info[:port], disk_info[:device], vmdk_disk_file, "hdd")
+              machine.provider.driver.attach_disk(controller.name,
+                                                  defined_disk[:port],
+                                                  defined_disk[:device],
+                                                  "hdd",
+                                                  vmdk_disk_file)
             rescue ScriptError, SignalException, StandardError
               LOGGER.warn("Vagrant encountered an error while trying to resize a disk. Vagrant will now attempt to reattach and preserve the original disk...")
               machine.ui.error(I18n.t("vagrant.cap.configure_disks.recovery_from_resize",
-                                      location: original_disk["Location"],
+                                      location: original_disk[:location],
                                       name: machine.name))
-              recover_from_resize(machine, disk_info, backup_disk_location, original_disk, vdi_disk_file)
-
+              recover_from_resize(machine, defined_disk, backup_disk_location, original_disk, vdi_disk_file, controller)
               raise
             ensure
               # Remove backup disk file if all goes well
@@ -240,13 +385,17 @@ module VagrantPlugins
             machine.provider.driver.close_medium(vdi_disk_file)
 
             # Get new updated disk UUID for vagrant disk_meta file
-            new_disk_info = machine.provider.driver.list_hdds.select { |h| h["Location"] == defined_disk["Location"] }.first
+            storage_controllers = machine.provider.driver.read_storage_controllers
+            updated_controller = storage_controllers.get_controller(controller.name)
+            new_disk_info = updated_controller.attachments.detect { |h| h[:location] == defined_disk[:location] }
+
             defined_disk = new_disk_info
           else
-            machine.provider.driver.resize_disk(defined_disk["Location"], disk_config.size.to_i)
+            machine.provider.driver.resize_disk(defined_disk[:location], disk_config.size.to_i)
           end
 
-          disk_metadata = {uuid: defined_disk["UUID"], name: disk_config.name}
+          disk_metadata = { uuid: defined_disk[:uuid], name: disk_config.name, controller: controller.name,
+                            port: defined_disk[:port], device: defined_disk[:device] }
 
           disk_metadata
         end
@@ -261,13 +410,17 @@ module VagrantPlugins
         # @param [String] backup_disk_location - The place on disk where vagrant made a backup of the original disk being resized
         # @param [Hash] original_disk - The disk information from VirtualBox
         # @param [String] vdi_disk_file - The place on disk where vagrant made a clone of the original disk being resized
-        def self.recover_from_resize(machine, disk_info, backup_disk_location, original_disk, vdi_disk_file)
+        # @param [VagrantPlugins::ProviderVirtualBox::Model::StorageController] controller - the storage controller to use
+        def self.recover_from_resize(machine, disk_info, backup_disk_location, original_disk, vdi_disk_file, controller)
           begin
             # move backup to original name
-            FileUtils.mv(backup_disk_location, original_disk["Location"], force: true)
+            FileUtils.mv(backup_disk_location, original_disk[:location], force: true)
             # Attach disk
-            machine.provider.driver.
-              attach_disk(disk_info[:port], disk_info[:device], original_disk["Location"], "hdd")
+            machine.provider.driver.attach_disk(controller.name,
+                                                disk_info[:port],
+                                                disk_info[:device],
+                                                "hdd",
+                                                original_disk[:location])
 
             # Remove cloned disk if still hanging around
             if vdi_disk_file