vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Boot
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          boot_mode = @env[:machine].provider_config.gui ? "gui" : "headless"
+
+          # Start up the VM and wait for it to boot.
+          env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
+          env[:machine].provider.driver.start(boot_mode)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class CheckAccessible
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :inaccessible
+            # The VM we are attempting to manipulate is inaccessible. This
+            # is a very bad situation and can only be fixed by the user. It
+            # also prohibits us from actually doing anything with the virtual
+            # machine, so we raise an error.
+            raise Vagrant::Errors::VMInaccessible
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is created, and raises an exception
+      # if it is not, notifying the user that creation is required.
+      class CheckCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :not_created
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class CheckGuestAdditions
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::check_guest_additions")
+        end
+
+        def call(env)
+          if !env[:machine].provider_config.check_guest_additions
+            @logger.info("Not checking guest additions because configuration")
+            return @app.call(env)
+          end
+
+          env[:ui].output(I18n.t("vagrant.virtualbox.checking_guest_additions"))
+
+          # Use the raw interface for now, while the virtualbox gem
+          # doesn't support guest properties (due to cross platform issues)
+          version = env[:machine].provider.driver.read_guest_additions_version
+          if !version
+            env[:ui].detail(I18n.t("vagrant.actions.vm.check_guest_additions.not_detected"))
+          else
+            # Read the versions
+            versions = [version, env[:machine].provider.driver.version]
+
+            # Strip of any -OSE or _OSE and read only the first two parts
+            # of the version such as "4.2" in "4.2.0"
+            versions.map! do |v|
+              v     = v.gsub(/[-_]ose/i, '')
+              match = /^(\d+\.\d+)\.(\d+)/.match(v)
+              v     = match[1] if match
+              v
+            end
+
+            guest_version = versions[0]
+            vb_version    = versions[1]
+
+            if guest_version != vb_version
+              env[:ui].detail(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
+                                   guest_version: version,
+                                   virtualbox_version: vb_version))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is running, and raises an exception
+      # if it is not, notifying the user that the VM must be running.
+      class CheckRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id != :running
+            raise Vagrant::Errors::VMNotRunningError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/platform'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # Checks that VirtualBox is installed and ready to be used.
+      class CheckVirtualbox
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox")
+        end
+
+        def call(env)
+          # This verifies that VirtualBox is installed and the driver is
+          # ready to function. If not, then an exception will be raised
+          # which will break us out of execution of the middleware sequence.
+          Driver::Meta.new.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # Cleans up the VirtualBox machine folder for any ".xml-prev"
+      # files which VirtualBox may have left over. This is a bug in
+      # VirtualBox. As soon as this is fixed, this middleware can and
+      # will be removed.
+      class CleanMachineFolder
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine_folder = env[:machine].provider.driver.read_machine_folder
+
+          begin
+            clean_machine_folder(machine_folder)
+          rescue Errno::EPERM
+            raise Vagrant::Errors::MachineFolderNotAccessible,
+              name: env[:machine].name,
+              path: machine_folder
+          end
+
+          @app.call(env)
+        end
+
+        def clean_machine_folder(machine_folder)
+          folder = File.join(machine_folder, "*")
+
+          # Small safeguard against potentially unwanted rm-rf, since the default
+          # machine folder will typically always be greater than 10 characters long.
+          # For users with it < 10, out of luck?
+          return if folder.length < 10
+
+          Dir[folder].each do |f|
+            next unless File.directory?(f)
+
+            keep = Dir["#{f}/**/*"].find do |d|
+              # Find a file that doesn't have ".xml-prev" as the suffix,
+              # which signals that we want to keep this folder
+              File.file?(d) && !(File.basename(d) =~ /\.vbox-prev$/)
+            end
+
+            FileUtils.rm_rf(f) if !keep
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ClearForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env[:machine].provider.driver.read_forwarded_ports.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+            env[:machine].provider.driver.clear_forwarded_ports
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ClearNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Create the adapters array to make all adapters nothing.
+          # We do adapters 2 to 8 because that is every built-in adapter
+          # excluding the NAT adapter on port 1 which Vagrant always
+          # expects to exist.
+          adapters = []
+          2.upto(env[:machine].provider.driver.max_network_adapters).each do |i|
+            adapters << {
+              adapter: i,
+              type:    :none
+            }
+          end
+
+          # "Enable" all the adapters we setup.
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
+          env[:machine].provider.driver.enable_adapters(adapters)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is created.
+          env[:result] = env[:machine].state.id != :not_created
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Customize
+        def initialize(app, env, event)
+          @app = app
+          @event = event
+        end
+
+        def call(env)
+          customizations = []
+          env[:machine].provider_config.customizations.each do |event, command|
+            if event == @event
+              customizations << command
+            end
+          end
+
+          if !customizations.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.customize.running", event: @event)
+
+            # Execute each customization command.
+            customizations.each do |command|
+              processed_command = command.collect do |arg|
+                arg = env[:machine].id if arg == :id
+                arg.to_s
+              end
+
+              begin
+                env[:machine].provider.driver.execute_command(
+                  processed_command + [retryable: true])
+              rescue Vagrant::Errors::VBoxManageError => e
+                raise Vagrant::Errors::VMCustomizationFailed, {
+                  command: command,
+                  error:   e.inspect
+                }
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
+          env[:machine].provider.driver.delete
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::destroy_unused_netifs")
+        end
+
+        def call(env)
+          if env[:machine].provider_config.destroy_unused_network_interfaces
+            @logger.info("Destroying unused network interfaces...")
+            env[:machine].provider.driver.delete_unused_host_only_networks
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DiscardState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.discard_state.discarding")
+            env[:machine].provider.driver.discard_saved_state
+          end
+
+           @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require 'vagrant/util/platform'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Export
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].state.id != :poweroff
+
+          export
+
+          @app.call(env)
+        end
+
+        def export
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          @env[:machine].provider.driver.export(ovf_path) do |progress|
+            @env[:ui].rewriting do |ui|
+              ui.clear_line
+              ui.report_progress(progress.percent, 100, false)
+            end
+          end
+
+          # Clear the line a final time so the next data can appear
+          # alone on the line.
+          @env[:ui].clear_line
+        end
+
+        def ovf_path
+          path = File.join(@env["export.temp_dir"], "box.ovf")
+
+          # If we're within WSL, we should use the correct path rather than
+          # the mnt path. GH-9059
+          if Vagrant::Util::Platform.wsl?
+            path = Vagrant::Util::Platform.wsl_to_windows_path(path)
+          end
+
+          return path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ForcedHalt
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :running || current_state == :gurumeditation
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+            env[:machine].provider.driver.halt
+          end
+
+          # Sleep for a second to verify that the VM properly
+          # cleans itself up. Silly VirtualBox.
+          sleep 1 if !env["vagrant.test"]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+
+          # Warn if we're port forwarding to any privileged ports...
+          env[:forwarded_ports].each do |fp|
+            if fp.host_port <= 1024
+              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              break
+            end
+          end
+
+          env[:ui].output(I18n.t("vagrant.actions.vm.forward_ports.forwarding"))
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          ports = []
+
+          interfaces = @env[:machine].provider.driver.read_network_interfaces
+
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              adapter: fp.adapter,
+              guest_port: fp.guest_port,
+              host_port: fp.host_port
+            }
+
+            # Assuming the only reason to establish port forwarding is
+            # because the VM is using Virtualbox NAT networking. Host-only
+            # bridged networking don't require port-forwarding and establishing
+            # forwarded ports on these attachment types has uncertain behaviour.
+            @env[:ui].detail(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                    **message_attributes))
+
+            # Verify we have the network interface to attach to
+            if !interfaces[fp.adapter]
+              raise Vagrant::Errors::ForwardPortAdapterNotFound,
+                adapter: fp.adapter.to_s,
+                guest: fp.guest_port.to_s,
+                host: fp.host_port.to_s
+            end
+
+            # Port forwarding requires the network interface to be a NAT interface,
+            # so verify that that is the case.
+            if interfaces[fp.adapter][:type] != :nat
+              @env[:ui].detail(I18n.t("vagrant.actions.vm.forward_ports.non_nat",
+                                    **message_attributes))
+              next
+            end
+
+            # Add the options to the ports array to send to the driver later
+            ports << {
+              adapter:   fp.adapter,
+              guestip:   fp.guest_ip,
+              guestport: fp.guest_port,
+              hostip:    fp.host_ip,
+              hostport:  fp.host_port,
+              name:      fp.id,
+              protocol:  fp.protocol
+            }
+          end
+
+          if !ports.empty?
+            # We only need to forward ports if there are any to forward
+            @env[:machine].provider.driver.forward_ports(ports)
+          end
+        end
+      end
+    end
+  end
+end