vagrant 1.5.0 → 2.4.4

data/lib/vagrant/action/builtin/provision.rb

@@ -0,0 +1,146 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require_relative "mixin_provisioners"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run the configured provisioners against the
+      # machine.
+      #
+      # This action should be placed BEFORE the machine is booted so it
+      # can do some setup, and then run again (on the return path) against
+      # a running machine.
+      class Provision
+        include MixinProvisioners
+
+        def initialize(app, env)
+          @app             = app
+          @logger          = Log4r::Logger.new("vagrant::action::builtin::provision")
+        end
+
+        def call(env)
+          @env = env
+
+          # Tracks whether we were configured to provision
+          config_enabled = true
+          config_enabled = env[:provision_enabled] if env.key?(:provision_enabled)
+
+          # Check if we already provisioned, and if so, disable the rest
+          provision_enabled = true
+
+          ignore_sentinel = true
+          if env.key?(:provision_ignore_sentinel)
+            ignore_sentinel = env[:provision_ignore_sentinel]
+          end
+          if ignore_sentinel
+            @logger.info("Ignoring sentinel check, forcing provision")
+          end
+
+          @logger.info("Checking provisioner sentinel file...")
+          sentinel_path = env[:machine].data_dir.join("action_provision")
+          update_sentinel = false
+          if sentinel_path.file?
+            # The sentinel file is in the format of "version:data" so that
+            # we can remain backwards compatible with previous sentinels.
+            # Versions so far:
+            #
+            #   Vagrant < 1.5.0: A timestamp. The weakness here was that
+            #     if it wasn't cleaned up, it would incorrectly not provision
+            #     new machines.
+            #
+            #   Vagrant >= 1.5.0: "1.5:ID", where ID is the machine ID.
+            #     We compare both so we know whether it is a new machine.
+            #
+            contents = sentinel_path.read.chomp
+            parts    = contents.split(":", 2)
+
+            if parts.length == 1
+              @logger.info("Old-style sentinel found! Not provisioning.")
+              provision_enabled = false if !ignore_sentinel
+              update_sentinel = true
+            elsif parts[0] == "1.5" && parts[1] == env[:machine].id.to_s
+              @logger.info("Sentinel found! Not provisioning.")
+              provision_enabled = false if !ignore_sentinel
+            else
+              @logger.info("Sentinel found with another machine ID. Removing.")
+              sentinel_path.unlink
+            end
+          end
+
+          # Store the value so that other actions can use it
+          env[:provision_enabled] = provision_enabled if !env.key?(:provision_enabled)
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioner_instances(env).each do |p, _|
+            p.configure(env[:machine].config)
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+
+          # If we're configured to not provision, notify the user and stop
+          if !config_enabled
+            env[:ui].info(I18n.t("vagrant.actions.vm.provision.disabled_by_config"))
+            return
+          end
+
+          # If we're not provisioning because of the sentinel, tell the user
+          # but continue trying for the "always" provisioners
+          if !provision_enabled
+            env[:ui].info(I18n.t("vagrant.actions.vm.provision.disabled_by_sentinel"))
+          end
+
+          # Write the sentinel if we have to
+          if update_sentinel || !sentinel_path.file?
+            @logger.info("Writing provisioning sentinel so we don't provision again")
+            sentinel_path.open("w") do |f|
+              f.write("1.5:#{env[:machine].id}")
+            end
+          end
+
+          type_map = provisioner_type_map(env)
+          provisioner_instances(env).each do |p, options|
+            type_name = type_map[p]
+
+            if options[:run] == :never
+              next if env[:provision_types].nil? || !env[:provision_types].include?(options[:name])
+            else
+              next if env[:provision_types] && \
+                !env[:provision_types].include?(type_name) && \
+                !env[:provision_types].include?(options[:name])
+
+              # Don't run if sentinel is around and we're not always running
+              next if !provision_enabled && options[:run] != :always
+            end
+
+            name = type_name
+            if options[:name]
+              name = "#{options[:name]} (#{type_name})"
+            end
+
+            env[:ui].info(I18n.t(
+              "vagrant.actions.vm.provision.beginning",
+              provisioner: name))
+
+            env[:hook].call(:provisioner_run, env.merge(
+              callable: method(:run_provisioner),
+              provisioner: p,
+              provisioner_name: type_name,
+            ))
+          end
+        end
+
+        # This is pulled out into a separate method so that users can
+        # subclass and implement custom behavior if they'd like to work around
+        # this step.
+        def run_provisioner(env)
+          env[:provisioner].provision
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/provisioner_cleanup.rb

@@ -0,0 +1,57 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require_relative "mixin_provisioners"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This action will run the cleanup methods on provisioners and should
+      # be used as part of any Destroy action.
+      class ProvisionerCleanup
+        include MixinProvisioners
+
+        def initialize(app, env, place=nil)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::provision_cleanup")
+
+          place ||= :after
+          @place = place.to_sym
+        end
+
+        def call(env)
+          do_cleanup(env) if @place == :before
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+
+          do_cleanup(env) if @place == :after
+        end
+
+        def do_cleanup(env)
+          type_map = provisioner_type_map(env)
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioner_instances(env).each do |p, _|
+            name = type_map[p].to_s
+
+            # Check if the subclass defined a cleanup method. The parent
+            # provisioning class defines a `cleanup` method, so we cannot use
+            # `respond_to?` here. Instead, we have to check if _this_ instance
+            # defines a cleanup task.
+            if p.public_methods(false).include?(:cleanup)
+              env[:ui].info(I18n.t("vagrant.provisioner_cleanup",
+                name: name,
+              ))
+              p.cleanup
+            else
+              @logger.debug("Skipping cleanup tasks for `#{name}' - not defined")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/set_hostname.rb

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware sets the hostname of the guest according to the
+      # "vm.hostname" configuration parameter if it is set. This middleware
+      # should be placed such that the after the @app.call, a booted machine
+      # is available (this generally means BEFORE the boot middleware).
+      class SetHostname
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::set_hostname")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          hostname = env[:machine].config.vm.hostname
+          allow_hosts_modification = env[:machine].config.vm.allow_hosts_modification
+          if !hostname.nil? && allow_hosts_modification
+            env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
+            env[:machine].guest.capability(:change_host_name, hostname)
+          else
+            @logger.info("`allow_hosts_modification` set to false. Hosts modification has been disabled, skiping changing hostname.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_exec.rb

@@ -0,0 +1,47 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+
+require "vagrant/util/ssh"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will exec into a full fledged SSH console into the
+      # remote machine. This middleware assumes that the VM is running and
+      # ready for SSH, and uses the {Machine#ssh_info} method to retrieve
+      # SSH information necessary to connect.
+      #
+      # Note: If there are any middleware after `SSHExec`, they will **not**
+      # run, since exec replaces the currently running process.
+      class SSHExec
+        # For quick access to the `SSH` class.
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Grab the SSH info from the machine or the environment
+          info = env[:ssh_info]
+          info ||= env[:machine].ssh_info
+
+          # If the result is nil, then the machine is telling us that it is
+          # not yet ready for SSH, so we raise this exception.
+          raise Errors::SSHNotReady if info.nil?
+
+          info[:private_key_path] ||= []
+
+          if info[:private_key_path].empty? && info[:password]
+            env[:ui].warn(I18n.t("vagrant.ssh_exec_password"))
+          end
+
+          # Exec!
+          SSH.exec(info, env[:ssh_opts])
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_run.rb

@@ -0,0 +1,88 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/ssh"
+require "vagrant/util/shell_quote"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run a single command on the remote machine and will
+      # mirror the output to the UI. The resulting exit status of the command
+      # will exist in the `:ssh_run_exit_status` key in the environment.
+      class SSHRun
+        # For quick access to the `SSH` class.
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::ssh_run")
+        end
+
+        def call(env)
+          # Grab the SSH info from the machine or the environment
+          info = env[:ssh_info]
+          info ||= env[:machine].ssh_info
+
+          # If the result is nil, then the machine is telling us that it is
+          # not yet ready for SSH, so we raise this exception.
+          raise Errors::SSHNotReady if info.nil?
+
+          info[:private_key_path] ||= []
+
+          if info[:keys_only] && info[:private_key_path].empty?
+            raise Errors::SSHRunRequiresKeys
+          end
+
+          # Get the command and wrap it in a login shell
+          command = ShellQuote.escape(env[:ssh_run_command], "'")
+
+          if env[:machine].config.vm.communicator == :winssh
+            shell = env[:machine].config.winssh.shell
+          else
+            shell = env[:machine].config.ssh.shell
+          end
+
+          if shell == "cmd"
+            # Add an extra space to the command so cmd.exe quoting works
+            # properly
+            command = "#{shell} /C #{command} "
+          elsif shell == "powershell"
+            command = "$ProgressPreference = \"SilentlyContinue\"; #{command}"
+            command = Base64.strict_encode64(command.encode("UTF-16LE", "UTF-8"))
+            command = "#{shell} -encodedCommand #{command}"
+          else
+            command = "#{shell} -c '#{command}'"
+          end
+
+          # Execute!
+          opts = env[:ssh_opts] || {}
+          opts[:extra_args] ||= []
+
+          # Allow the user to specify a tty or non-tty manually, but if they
+          # don't then we default to a TTY unless they are using WinSSH
+          if !opts[:extra_args].include?("-t") &&
+              !opts[:extra_args].include?("-T") &&
+              env[:tty] &&
+              env[:machine].config.vm.communicator != :winssh
+            opts[:extra_args] << "-t"
+          end
+
+          opts[:extra_args] << command
+          opts[:subprocess] = true
+          env[:ssh_run_exit_status] = _raw_ssh_exec(env, info, opts)
+
+          # Call the next middleware
+          @app.call(env)
+        end
+
+        def _raw_ssh_exec(env, info, opts)
+          Util::SSH.exec(info, opts)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/synced_folder_cleanup.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require_relative "mixin_synced_folders"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware will run cleanup tasks for synced folders using
+      # the appropriate synced folder plugin.
+      class SyncedFolderCleanup
+        include MixinSyncedFolders
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::synced_folder_cleanup")
+        end
+
+        def call(env)
+          folders = synced_folders(env[:machine])
+
+          # Go through each folder and do cleanup
+          folders.each_key do |impl_name|
+            @logger.info("Invoking synced folder cleanup for: #{impl_name}")
+            plugins[impl_name.to_sym][0].new.cleanup(
+              env[:machine], impl_opts(impl_name, env))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/synced_folders.rb

@@ -0,0 +1,154 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require 'vagrant/util/platform'
+
+require_relative "mixin_synced_folders"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware will setup the synced folders for the machine using
+      # the appropriate synced folder plugin.
+      class SyncedFolders
+        include MixinSyncedFolders
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::synced_folders")
+        end
+
+        def call(env)
+          opts = {
+            cached: !!env[:synced_folders_cached],
+            config: env[:synced_folders_config],
+          }
+
+          @logger.info("SyncedFolders loading from cache: #{opts[:cached]}")
+          folders = synced_folders(env[:machine], **opts)
+          original_folders = folders
+
+          folders.each do |impl_name, fs|
+            @logger.info("Synced Folder Implementation: #{impl_name}")
+
+            fs.each do |id, data|
+              # Log every implementation and their paths
+              @logger.info("  - #{id}: #{data[:hostpath]} => #{data[:guestpath]}")
+            end
+          end
+
+          # Go through each folder and make sure to create it if
+          # it does not exist on host
+          folders.each do |_, fs|
+            fs.each do |id, data|
+              next if data[:hostpath_exact]
+
+              data[:hostpath] = File.expand_path(
+                data[:hostpath], env[:root_path])
+
+              # Expand the symlink if this is a path that exists
+              if File.file?(data[:hostpath])
+                data[:hostpath] = File.realpath(data[:hostpath])
+              end
+
+              # Create the hostpath if it doesn't exist and we've been told to
+              if !File.directory?(data[:hostpath]) && data[:create]
+                @logger.info("Creating shared folder host directory: #{data[:hostpath]}")
+                begin
+                  Pathname.new(data[:hostpath]).mkpath
+                rescue Errno::EACCES
+                  raise Vagrant::Errors::SharedFolderCreateFailed,
+                    path: data[:hostpath]
+                end
+              end
+
+              if File.directory?(data[:hostpath])
+                data[:hostpath] = File.realpath(data[:hostpath])
+                data[:hostpath] = Util::Platform.fs_real_path(data[:hostpath]).to_s
+              end
+            end
+          end
+
+          # Build up the instances of the synced folders. We do this once
+          # so that they can store state.
+          folders = folders.map do |impl_name, fs|
+            instance = plugins[impl_name.to_sym][0].new
+            [instance, impl_name, fs]
+          end
+
+          # Go through each folder and prepare the folders
+          folders.each do |impl, impl_name, fs|
+            if !env[:synced_folders_disable]
+              @logger.info("Invoking synced folder prepare for: #{impl_name}")
+              impl.prepare(env[:machine], fs, impl_opts(impl_name, env))
+            end
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+
+          # Once booted, setup the folder contents
+          folders.each do |impl, impl_name, fs|
+            if !env[:synced_folders_disable]
+              @logger.info("Invoking synced folder enable: #{impl_name}")
+              impl.enable(env[:machine], fs, impl_opts(impl_name, env))
+              next
+            end
+
+            # We're disabling synced folders
+            to_disable = {}
+            fs.each do |id, data|
+              next if !env[:synced_folders_disable].include?(id)
+              to_disable[id] = data
+            end
+
+            @logger.info("Invoking synced folder disable: #{impl_name}")
+            to_disable.each do |id, _|
+              @logger.info("  - Disabling: #{id}")
+            end
+            impl.disable(env[:machine], to_disable, impl_opts(impl_name, env))
+          end
+
+          # If we disabled folders, we have to delete some from the
+          # save, so we load the entire cached thing, and delete them.
+          if env[:synced_folders_disable]
+            all = synced_folders(env[:machine], cached: true)
+            all.each do |impl, fs|
+              fs.keys.each do |id|
+                if env[:synced_folders_disable].include?(id)
+                  fs.delete(id)
+                end
+              end
+            end
+
+            save_synced_folders(env[:machine], all)
+          else
+            save_opts = { merge: true }
+            save_opts[:vagrantfile] = true if !opts[:config]
+
+            # Save the synced folders
+            save_synced_folders(env[:machine], original_folders, **save_opts)
+          end
+
+          # Persist the mounts by adding them to fstab (only if the guest is available)
+          begin
+            persist_mount = env[:machine].guest.capability?(:persist_mount_shared_folder)
+          rescue Errors::MachineGuestNotReady
+            persist_mount = false
+          end
+          if persist_mount
+            # Persist the mounts by adding them to fstab
+            if env[:machine].config.vm.allow_fstab_modification
+              fstab_folders = original_folders
+            else
+              fstab_folders = nil
+            end
+            env[:machine].guest.capability(:persist_mount_shared_folder, fstab_folders)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/trigger.rb

@@ -0,0 +1,40 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class is used within the Builder class for injecting triggers into
+      # different parts of the call stack.
+      class Trigger
+        # @param [Class, String, Symbol] name Name of trigger to fire
+        # @param [Vagrant::Plugin::V2::Triger] triggers Trigger object
+        # @param [Symbol] timing When trigger should fire (:before/:after)
+        # @param [Symbol] type Type of trigger
+        def initialize(app, env, name, triggers, timing, type=:action, all: false)
+          @app         = app
+          @env         = env
+          @triggers    = triggers
+          @name        = name
+          @timing      = timing
+          @type        = type
+          @all         = all
+
+          if ![:before, :after].include?(timing)
+            raise ArgumentError,
+              "Invalid value provided for `timing` (allowed: :before or :after)"
+          end
+        end
+
+        def call(env)
+          machine = env[:machine]
+          machine_name = machine.name if machine
+
+          @triggers.fire(@name, @timing, machine_name, @type, all: @all)
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/wait_for_communicator.rb

@@ -0,0 +1,82 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This waits for the communicator to be ready for a set amount of
+      # time.
+      class WaitForCommunicator
+        def initialize(app, env, states=nil)
+          @app    = app
+          @states = states
+        end
+
+        def call(env)
+          # Wait for ready in a thread so that we can continually check
+          # for interrupts.
+          ready_thr = Thread.new do
+            Thread.current[:result] = env[:machine].communicate.wait_for_ready(
+              env[:machine].config.vm.boot_timeout)
+          end
+
+          # Start a thread that verifies the VM stays in a good state.
+          states_thr = Thread.new do
+            Thread.current[:result] = true
+
+            # Otherwise, periodically verify the VM isn't in a bad state.
+            while true
+              state = env[:machine].state.id
+
+              # Used to report invalid states
+              Thread.current[:last_known_state] = state
+
+              # Check if we have the proper state so we can break out
+              if @states && !@states.include?(state)
+                Thread.current[:result] = false
+                break
+              end
+
+              # Sleep a bit so we don't hit 100% CPU constantly.
+              sleep 1
+            end
+          end
+
+          # Wait for a result or an interrupt
+          env[:ui].output(I18n.t("vagrant.boot_waiting"))
+          while ready_thr.alive? && states_thr.alive?
+            sleep 1
+            return if env[:interrupted]
+          end
+
+          # Join so that they can raise exceptions if there were any
+          ready_thr.join if !ready_thr.alive?
+          states_thr.join if !states_thr.alive?
+
+          # If it went into a bad state, then raise an error
+          if !states_thr[:result]
+            raise Errors::VMBootBadState,
+              valid: @states.join(", "),
+              invalid: states_thr[:last_known_state]
+          end
+
+          # If it didn't boot, raise an error
+          if !ready_thr[:result]
+            raise Errors::VMBootTimeout
+          end
+
+          env[:ui].output(I18n.t("vagrant.boot_completed"))
+
+          # Make sure our threads are all killed
+          ready_thr.kill
+          states_thr.kill
+
+          @app.call(env)
+        ensure
+          ready_thr.kill
+          states_thr.kill
+        end
+      end
+    end
+  end
+end