vagrant 1.5.0 → 2.4.4

data/plugins/providers/hyperv/action.rb

@@ -0,0 +1,326 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use action_halt
+            b2.use action_start
+          end
+        end
+      end
+
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b1.use Call, DestroyConfirm do |env2, b2|
+              if !env2[:result]
+                b2.use MessageWillNotDestroy
+                next
+              end
+
+              b2.use ConfigValidate
+              b2.use ProvisionerCleanup, :before
+              b2.use StopInstance
+              b2.use DeleteVM
+              b2.use SyncedFolderCleanup
+            end
+          end
+        end
+      end
+
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use Call, GracefulHalt, :off, :running do |env2, b3|
+              if !env2[:result]
+                b3.use StopInstance
+              end
+            end
+          end
+        end
+      end
+
+      # This action packages the virtual machine into a single box file.
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use CheckEnabled
+          b.use Call, IsState, :not_created do |env1, b2|
+            if env1[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use PackageSetupFolders
+            b2.use PackageSetupFiles
+            b2.use action_halt
+            b2.use SyncedFolderCleanup
+            b2.use Package
+            b2.use PackageVagrantfile
+            b2.use PackageMetadataJson
+            b2.use Export
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                b3.use Message, I18n.t("vagrant_hyperv.message_not_running")
+                next
+              end
+
+              b3.use Provision
+            end
+          end
+        end
+      end
+
+      def self.action_resume
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b1|
+            if env[:result]
+              b1.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b1.use ResumeVM
+            b1.use WaitForIPAddress
+            b1.use WaitForCommunicator, [:running]
+          end
+        end
+      end
+
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :running do |env1, b1|
+            if env1[:result]
+              b1.use action_provision
+              next
+            end
+
+            b1.use Call, IsState, :paused do |env2, b2|
+              if env2[:result]
+                b2.use action_resume
+                next
+              end
+
+              b2.use Call, IsState, :saved do |env3, b3|
+                # When state is `:saved` it is a snapshot being restored
+                if !env3[:result]
+                  b3.use Provision
+                  b3.use Configure
+                  b3.use SetName
+                  b3.use NetSetVLan
+                  b3.use NetSetMac
+                end
+
+                b3.use CleanupDisks
+                b3.use Disk
+                b3.use SyncedFolderCleanup
+                b3.use StartInstance
+                b3.use WaitForIPAddress
+                b3.use WaitForCommunicator, [:running]
+                b3.use SyncedFolders
+                b3.use SetHostname
+              end
+            end
+          end
+        end
+      end
+
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use CheckEnabled
+          b.use CheckAccess
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use Import
+            end
+
+            b1.use action_start
+          end
+        end
+      end
+
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              raise Vagrant::Errors::VMNotCreatedError
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                raise Vagrant::Errors::VMNotRunningError
+              end
+
+              b3.use SSHExec
+            end
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              raise Vagrant::Errors::VMNotCreatedError
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                raise Vagrant::Errors::VMNotRunningError
+              end
+
+              b3.use SSHRun
+            end
+          end
+        end
+      end
+
+      def self.action_suspend
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use SuspendVM
+          end
+        end
+      end
+
+      def self.action_snapshot_delete
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use SnapshotDelete
+
+          end
+        end
+      end
+
+      def self.action_snapshot_restore
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+
+            b2.use action_halt
+            b2.use SnapshotRestore
+
+            b2.use Call, IsEnvSet, :snapshot_delete do |env2, b3|
+              if env2[:result]
+                b3.use action_snapshot_delete
+              end
+            end
+
+            b2.use action_start
+
+          end
+        end
+      end
+
+      def self.action_snapshot_save
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_hyperv.message_not_created")
+              next
+            end
+            b2.use SnapshotSave
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :PackageSetupFolders, action_root.join("package_setup_folders")
+      autoload :PackageSetupFiles, action_root.join("package_setup_files")
+      autoload :PackageVagrantfile, action_root.join("package_vagrantfile")
+      autoload :PackageMetadataJson, action_root.join("package_metadata_json")
+      autoload :Export, action_root.join("export")
+
+      autoload :CheckEnabled, action_root.join("check_enabled")
+      autoload :CheckAccess, action_root.join("check_access")
+      autoload :Configure, action_root.join("configure")
+      autoload :DeleteVM, action_root.join("delete_vm")
+      autoload :Import, action_root.join("import")
+      autoload :Package, action_root.join("package")
+      autoload :IsWindows, action_root.join("is_windows")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :ResumeVM, action_root.join("resume_vm")
+      autoload :StartInstance, action_root.join('start_instance')
+      autoload :StopInstance, action_root.join('stop_instance')
+      autoload :SuspendVM, action_root.join("suspend_vm")
+      autoload :WaitForIPAddress, action_root.join("wait_for_ip_address")
+      autoload :NetSetVLan, action_root.join("net_set_vlan")
+      autoload :NetSetMac, action_root.join("net_set_mac")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :SnapshotDelete, action_root.join("snapshot_delete")
+      autoload :SnapshotRestore, action_root.join("snapshot_restore")
+      autoload :SnapshotSave, action_root.join("snapshot_save")
+      autoload :SetName, action_root.join("set_name")
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "vagrant/util/experimental"
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module CleanupDisks
+        LOGGER = Log4r::Logger.new("vagrant::plugins::hyperv::cleanup_disks")
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
+        # @param [Hash] disk_meta_file - A hash of all the previously defined disks from the last configure_disk action
+        def self.cleanup_disks(machine, defined_disks, disk_meta_file)
+          return if disk_meta_file.values.flatten.empty?
+
+          handle_cleanup_disk(machine, defined_disks, disk_meta_file["disk"])
+          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
+        def self.handle_cleanup_disk(machine, defined_disks, disk_meta)
+          all_disks = machine.provider.driver.list_hdds
+
+          disk_meta.each do |d|
+            # look at Path instead of Name or UUID
+            disk_name  = File.basename(d["Path"], '.*')
+            dsk = defined_disks.select { |dk| dk.name == disk_name }
+
+            if !dsk.empty? || d["primary"] == true
+              next
+            else
+              LOGGER.warn("Found disk not in Vagrantfile config: '#{d["Name"]}'. Removing disk from guest #{machine.name}")
+
+              machine.ui.warn(I18n.t("vagrant.cap.cleanup_disks.disk_cleanup", name: d["Name"]), prefix: true)
+
+              disk_actual = all_disks.select { |a| File.realdirpath(a["Path"]) == File.realdirpath(d["Path"]) }.first
+              if !disk_actual
+                machine.ui.warn(I18n.t("vagrant.cap.cleanup_disks.disk_not_found", name: d["Name"]), prefix: true)
+              else
+                machine.provider.driver.remove_disk(disk_actual["ControllerType"], disk_actual["ControllerNumber"], disk_actual["ControllerLocation"], disk_actual["Path"])
+              end
+            end
+          end
+        end
+
+        def self.handle_cleanup_dvd(machine, defined_disks, disk_meta)
+          # Get a list of all attached DVD drives
+          attached = machine.provider.driver.read_scsi_controllers.map do |controller|
+            controller["Drives"].map do |drive|
+              drive if drive["DvdMediaType"].to_i == 1
+            end.compact
+          end.flatten.compact
+
+          # Generate list of dvd disks that previously
+          # existed but are no longer defined
+          orphan_attachments = disk_meta.find_all do |mdisk|
+            defined_disks.none? do |defined_disk|
+              defined_disk.type == :dvd &&
+                File.expand_path(mdisk["Path"]) == File.expand_path(defined_disk.file)
+            end
+          end
+
+          # Remove any entries that are not currently
+          # attached
+          orphan_attachments.delete_if do |mdisk|
+            attached.any? do |attachment|
+              File.expand_path(attachment["Path"]) == mdisk["Path"]
+            end
+          end
+
+          # Now remove any orphan attachments that remain
+          orphan_attachments.each do |mdisk|
+            LOGGER.debug("removing dvd attachment: #{mdisk}")
+
+            machine.provider.driver.detach_dvd(
+              mdisk["ControllerLocation"],
+              mdisk["ControllerNumber"]
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "fileutils"
+require "vagrant/util/numeric"
+require "vagrant/util/experimental"
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module ConfigureDisks
+        LOGGER = Log4r::Logger.new("vagrant::plugins::hyperv::configure_disks")
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
+        # @return [Hash] configured_disks - A hash of all the current configured disks
+        def self.configure_disks(machine, defined_disks)
+          return {} if defined_disks.empty?
+
+          machine.ui.info(I18n.t("vagrant.cap.configure_disks.start"))
+
+          current_disks = machine.provider.driver.list_hdds
+
+          configured_disks = {disk: [], floppy: [], dvd: []}
+
+          defined_disks.each do |disk|
+            if disk.type == :disk
+              disk_data = handle_configure_disk(machine, disk, current_disks)
+              configured_disks[:disk] << disk_data if !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
+              disk_data = handle_configure_dvd(machine, disk)
+              configured_disks[:dvd] << disk_data if !disk_data.empty?
+            end
+          end
+
+          configured_disks
+        end
+
+        protected
+
+        # @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
+        # @return [Hash] current_disk - Returns the current disk. Returns nil if it doesn't exist
+        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 should always be the
+            # first disk.
+
+            sorted_disks = all_disks.sort_by { |d|
+              [d["ControllerNumber"].to_i, d["ControllerLocation"].to_i]
+            }
+
+            LOGGER.debug("sorted disks for primary detection: #{sorted_disks}")
+
+            current_disk = sorted_disks.first
+
+            # Need to get actual disk info to obtain UUID instead of what's returned
+            #
+            # This is not required for newly created disks, as its metadata is
+            # set when creating and attaching the disk. This is only for the primary
+            # disk, since it already exists.
+            current_disk = machine.provider.driver.get_disk(current_disk["Path"])
+          else
+            # Hyper-V disk names aren't the actual names of the disk, so we have
+            # to grab the name from the file path instead
+            current_disk = all_disks.detect { |d| File.basename(d["Path"], '.*') == disk.name}
+          end
+
+          current_disk
+        end
+
+        # Handles all disk configs of type `:disk`
+        #
+        # @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
+        # @return [Hash] - disk_metadata
+        def self.handle_configure_disk(machine, disk, all_disks)
+          disk_metadata = {}
+
+          # Grab the existing configured disk, 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
+            disk_metadata = {UUID: current_disk["DiskIdentifier"], Name: disk.name, Path: current_disk["Path"]}
+            if disk.primary
+              disk_metadata[:primary] = true
+            end
+          end
+
+          disk_metadata
+        end
+
+        def self.handle_configure_dvd(machine, dvd)
+          dvd_location = File.expand_path(dvd.file)
+
+          find_dvd_disk = proc {
+            catch(:found) do
+              machine.provider.driver.read_scsi_controllers.each do |controller|
+                controller["Drives"].each do |disk|
+                  throw :found, disk if File.expand_path(disk["Path"]) == dvd_location
+                end
+              end
+
+              nil
+            end
+          }
+
+          generate_dvd_metadata = proc { |disk|
+            disk.slice(
+              "Name", "Id", "Path",
+              "ControllerLocation", "ControllerNumber",
+              "ControllerType"
+            )
+          }
+
+          # If the disk is already attached just
+          # return the information
+          if dvd_attached = find_dvd_disk.call
+            return generate_dvd_metadata.call(dvd_attached)
+          end
+
+          # Attach the disk
+          machine.provider.driver.attach_dvd(dvd_location)
+
+          # Find disk and return information
+          disk = find_dvd_disk.call
+          return generate_dvd_metadata.call(disk) if disk
+
+          LOGGER.warn("failed to locate dvd on controller, stubbing")
+          {"Path" => dvd_location}
+        end
+
+        # Check to see if current disk is configured based on defined_disks
+        #
+        # @param [Kernel_V2::VagrantConfigDisk] disk_config
+        # @param [Hash] defined_disk
+        # @return [Boolean]
+        def self.compare_disk_size(machine, disk_config, defined_disk)
+          # Hyper-V returns disk size in bytes
+          requested_disk_size = disk_config.size
+          disk_actual = machine.provider.driver.get_disk(defined_disk["Path"])
+          defined_disk_size = disk_actual["Size"]
+
+          if defined_disk_size > requested_disk_size
+            if File.extname(disk_actual["Path"]) == ".vhdx"
+              # VHDX formats can be shrunk
+              return true
+            else
+              machine.ui.warn(I18n.t("vagrant.cap.configure_disks.shrink_size_not_supported", name: disk_config.name))
+              return false
+            end
+          elsif defined_disk_size < requested_disk_size
+            return true
+          else
+            return false
+          end
+        end
+
+        # Creates and attaches a disk to a machine
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Kernel_V2::VagrantConfigDisk] disk_config
+        def self.create_disk(machine, disk_config)
+          machine.ui.detail(I18n.t("vagrant.cap.configure_disks.create_disk", name: disk_config.name))
+          disk_provider_config = {}
+
+          if disk_config.provider_config && disk_config.provider_config.key?(:hyperv)
+            disk_provider_config = disk_config.provider_config[:hyperv]
+          end
+
+          if !disk_provider_config.empty?
+            disk_provider_config = convert_size_vars!(disk_provider_config)
+          end
+
+          # Get the machines data dir, that will now be the path for the new disk
+          guest_disk_folder = machine.data_dir.join("Virtual Hard Disks")
+
+          if disk_config.file
+            disk_file = disk_config.file
+            LOGGER.info("Disk already defined by user at '#{disk_file}'. Using this disk instead of creating a new one...")
+          else
+            # Set the extension
+            disk_ext = disk_config.disk_ext
+            disk_file = File.join(guest_disk_folder, disk_config.name) + ".#{disk_ext}"
+
+            LOGGER.info("Attempting to create a new disk file '#{disk_file}' of size '#{disk_config.size}' bytes")
+
+            machine.provider.driver.create_disk(disk_file, disk_config.size, **disk_provider_config)
+          end
+
+          disk_info = machine.provider.driver.get_disk(disk_file)
+          disk_metadata = {UUID: disk_info["DiskIdentifier"], Name: disk_config.name, Path: disk_info["Path"]}
+
+          machine.provider.driver.attach_disk(disk_file, **disk_provider_config)
+
+          disk_metadata
+        end
+
+        # Converts any "shortcut" options such as "123MB" into its byte form. This
+        # is due to what parameter type is expected when calling the `New-VHD`
+        # powershell command
+        #
+        # @param [Hash] disk_provider_config
+        # @return [Hash] disk_provider_config
+        def self.convert_size_vars!(disk_provider_config)
+          if disk_provider_config.key?(:BlockSizeBytes)
+            bytes = Vagrant::Util::Numeric.string_to_bytes(disk_provider_config[:BlockSizeBytes])
+            disk_provider_config[:BlockSizeBytes] = bytes
+          end
+
+          disk_provider_config
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @param [Config::Disk] disk_config - the current disk to configure
+        # @param [Hash] defined_disk - current disk as represented by VirtualBox
+        # @return [Hash] - disk_metadata
+        def self.resize_disk(machine, disk_config, defined_disk)
+          machine.ui.detail(I18n.t("vagrant.cap.configure_disks.resize_disk", name: disk_config.name), prefix: true)
+
+          machine.provider.driver.resize_disk(defined_disk["Path"], disk_config.size.to_i)
+
+          disk_info = machine.provider.driver.get_disk(defined_disk["Path"])
+
+          # Store updated metadata
+          disk_metadata = {UUID: disk_info["DiskIdentifier"], Name: disk_config.name, Path: disk_info["Path"]}
+
+          disk_metadata
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/cap/public_address.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module PublicAddress
+        def self.public_address(machine)
+          return nil if machine.state.id != :running
+
+          ssh_info = machine.ssh_info
+          return nil if !ssh_info
+          ssh_info[:host]
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/cap/snapshot_list.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module SnapshotList
+        def self.snapshot_list(machine)
+          machine.provider.driver.list_snapshots
+        end
+      end
+    end
+  end
+end