vagrant 1.0.7 → 2.4.4

data/lib/vagrant/action/warden.rb

@@ -1,4 +1,8 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
 require "log4r"
+require 'vagrant/util/experimental'
 
 module Vagrant
   module Action
@@ -16,9 +20,10 @@ module Vagrant
       attr_accessor :actions, :stack
 
       def initialize(actions, env)
-        @stack = []
-        @actions = actions.map { |m| finalize_action(m, env) }
-        @logger  = Log4r::Logger.new("vagrant::action::warden")
+        @stack      = []
+        @actions    = actions.map { |m| finalize_action(m, env) }.flatten
+        @logger     = Log4r::Logger.new("vagrant::action::warden")
+        @last_error = nil
       end
 
       def call(env)
@@ -29,28 +34,37 @@ module Vagrant
           # of "recoverable" middlewares in case something goes wrong!
           raise Errors::VagrantInterrupt if env[:interrupted]
           action = @actions.shift
-          @logger.info("Calling action: #{action}")
+          @logger.info("Calling IN action: #{action}")
           @stack.unshift(action).first.call(env)
           raise Errors::VagrantInterrupt if env[:interrupted]
-        rescue SystemExit
-          # This means that an "exit" or "abort" was called. In these cases,
-          # we just exit immediately.
+          @logger.info("Calling OUT action: #{action}")
+        rescue SystemExit, NoMemoryError
+          # This means that an "exit" or "abort" was called, or we have run out
+          # of memory. In these cases, we just exit immediately.
           raise
         rescue Exception => e
-          @logger.error("Error occurred: #{e}")
+          # We guard this so that the Warden only outputs this once for
+          # an exception that bubbles up.
+          if e != @last_error
+            @logger.error("Error occurred: #{e}")
+            @last_error = e
+          end
+
           env["vagrant.error"] = e
 
           # Something went horribly wrong. Start the rescue chain then
           # reraise the exception to properly kick us out of limbo here.
-          begin_rescue(env)
+          recover(env)
           raise
         end
       end
 
-      # Begins the recovery sequence for all middlewares which have run.
-      # It does this by calling `recover` (if it exists) on each middleware
-      # which has already run, in reverse order.
-      def begin_rescue(env)
+      # We implement the recover method ourselves in case a Warden is
+      # embedded within another Warden. To recover, we just do our own
+      # recovery process on our stack.
+      def recover(env)
+        @logger.info("Beginning recovery process...")
+
         @stack.each do |act|
           if act.respond_to?(:recover)
             @logger.info("Calling recover: #{act}")
@@ -58,6 +72,8 @@ module Vagrant
           end
         end
 
+        @logger.info("Recovery complete.")
+
         # Clear stack so that warden down the middleware chain doesn't
         # rescue again.
         @stack.clear
@@ -66,16 +82,34 @@ module Vagrant
       # A somewhat confusing function which simply initializes each
       # middleware properly to call the next middleware in the sequence.
       def finalize_action(action, env)
-        klass, args, block = action
+        if action.is_a?(Builder::StackItem)
+          klass = action.middleware
+          args = action.arguments.parameters
+          keywords = action.arguments.keywords
+          block = action.arguments.block
+        else
+          klass = action
+          args = []
+          keywords = {}
+        end
 
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class.
-        args ||= []
+        args = nil if args.empty?
+        keywords = nil if keywords.empty?
 
         if klass.is_a?(Class)
-          # A action klass which is to be instantiated with the
-          # app, env, and any arguments given
-          klass.new(self, env, *args, &block)
+          # NOTE: We need to detect if we are passing args and/or
+          #       keywords and do it explicitly. Earlier versions
+          #       are not as lax about splatting keywords when the
+          #       target method is not expecting them.
+          if args && keywords
+            klass.new(self, env, *args, **keywords, &block)
+          elsif args
+            klass.new(self, env, *args, &block)
+          elsif keywords
+            klass.new(self, env, **keywords, &block)
+          else
+            klass.new(self, env, &block)
+          end
         elsif klass.respond_to?(:call)
           # Make it a lambda which calls the item then forwards
           # up the chain

data/lib/vagrant/action.rb

@@ -1,63 +1,88 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
 require 'vagrant/action/builder'
 
 module Vagrant
   module Action
-    autoload :Builtin,     'vagrant/action/builtin'
-    autoload :Environment, 'vagrant/action/environment'
-    autoload :Runner,      'vagrant/action/runner'
-    autoload :Warden,      'vagrant/action/warden'
+    autoload :Builder,       'vagrant/action/builder'
+    autoload :Hook,          'vagrant/action/hook'
+    autoload :Runner,        'vagrant/action/runner'
+    autoload :PrimaryRunner, 'vagrant/action/primary_runner'
+    autoload :Warden,        'vagrant/action/warden'
 
-    module Box
-      autoload :Destroy,   'vagrant/action/box/destroy'
-      autoload :Download,  'vagrant/action/box/download'
-      autoload :Package,   'vagrant/action/box/package'
-      autoload :Unpackage, 'vagrant/action/box/unpackage'
-      autoload :Verify,    'vagrant/action/box/verify'
+    # Builtin contains middleware classes that are shipped with Vagrant-core
+    # and are thus available to all plugins as a "standard library" of sorts.
+    module Builtin
+      autoload :BoxAdd,    "vagrant/action/builtin/box_add"
+      autoload :BoxCheckOutdated, "vagrant/action/builtin/box_check_outdated"
+      autoload :BoxRemove, "vagrant/action/builtin/box_remove"
+      autoload :BoxUpdate, "vagrant/action/builtin/box_update"
+      autoload :Call,    "vagrant/action/builtin/call"
+      autoload :CleanupDisks, "vagrant/action/builtin/cleanup_disks"
+      autoload :CloudInitSetup, "vagrant/action/builtin/cloud_init_setup"
+      autoload :CloudInitWait, "vagrant/action/builtin/cloud_init_wait"
+      autoload :ConfigValidate, "vagrant/action/builtin/config_validate"
+      autoload :Confirm, "vagrant/action/builtin/confirm"
+      autoload :Delayed, "vagrant/action/builtin/delayed"
+      autoload :DestroyConfirm, "vagrant/action/builtin/destroy_confirm"
+      autoload :Disk, "vagrant/action/builtin/disk"
+      autoload :EnvSet,  "vagrant/action/builtin/env_set"
+      autoload :GracefulHalt, "vagrant/action/builtin/graceful_halt"
+      autoload :HandleBox, "vagrant/action/builtin/handle_box"
+      autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
+      autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
+      autoload :HasProvisioner, "vagrant/action/builtin/has_provisioner"
+      autoload :IsEnvSet, "vagrant/action/builtin/is_env_set"
+      autoload :IsState, "vagrant/action/builtin/is_state"
+      autoload :Lock, "vagrant/action/builtin/lock"
+      autoload :Message, "vagrant/action/builtin/message"
+      autoload :MixinProvisioners, "vagrant/action/builtin/mixin_provisioners"
+      autoload :MixinSyncedFolders, "vagrant/action/builtin/mixin_synced_folders"
+      autoload :PrepareClone, "vagrant/action/builtin/prepare_clone"
+      autoload :Provision, "vagrant/action/builtin/provision"
+      autoload :ProvisionerCleanup, "vagrant/action/builtin/provisioner_cleanup"
+      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
+      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
+      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
+      autoload :SyncedFolderCleanup, "vagrant/action/builtin/synced_folder_cleanup"
+      autoload :SyncedFolders, "vagrant/action/builtin/synced_folders"
+      autoload :Trigger, "vagrant/action/builtin/trigger"
+      autoload :WaitForCommunicator, "vagrant/action/builtin/wait_for_communicator"
     end
 
-    module Env
-      autoload :Set, 'vagrant/action/env/set'
+    module General
+      autoload :Package, 'vagrant/action/general/package'
+      autoload :PackageSetupFiles, 'vagrant/action/general/package_setup_files'
+      autoload :PackageSetupFolders, 'vagrant/action/general/package_setup_folders'
     end
 
-    module General
-      autoload :CheckVirtualbox, 'vagrant/action/general/check_virtualbox'
-      autoload :Package,  'vagrant/action/general/package'
-      autoload :Validate, 'vagrant/action/general/validate'
+    # This is the action that will add a box from a URL. This middleware
+    # sequence is built-in to Vagrant. Plugins can hook into this like any
+    # other middleware sequence. This is particularly useful for provider
+    # plugins, which can hook in to do things like verification of boxes
+    # that are downloaded.
+    def self.action_box_add
+      Builder.new.tap do |b|
+        b.use Builtin::BoxAdd
+      end
+    end
+
+    # This actions checks if a box is outdated in a given Vagrant
+    # environment for a single machine.
+    def self.action_box_outdated
+      Builder.new.tap do |b|
+        b.use Builtin::BoxCheckOutdated
+      end
     end
 
-    module VM
-      autoload :Boot,                'vagrant/action/vm/boot'
-      autoload :CheckAccessible,     'vagrant/action/vm/check_accessible'
-      autoload :CheckBox,            'vagrant/action/vm/check_box'
-      autoload :CheckGuestAdditions, 'vagrant/action/vm/check_guest_additions'
-      autoload :CheckPortCollisions, 'vagrant/action/vm/check_port_collisions'
-      autoload :CleanMachineFolder,  'vagrant/action/vm/clean_machine_folder'
-      autoload :ClearForwardedPorts, 'vagrant/action/vm/clear_forwarded_ports'
-      autoload :ClearNetworkInterfaces, 'vagrant/action/vm/clear_network_interfaces'
-      autoload :ClearSharedFolders,  'vagrant/action/vm/clear_shared_folders'
-      autoload :Customize,           'vagrant/action/vm/customize'
-      autoload :DefaultName,         'vagrant/action/vm/default_name'
-      autoload :Destroy,             'vagrant/action/vm/destroy'
-      autoload :DestroyUnusedNetworkInterfaces, 'vagrant/action/vm/destroy_unused_network_interfaces'
-      autoload :DiscardState,        'vagrant/action/vm/discard_state'
-      autoload :Export,              'vagrant/action/vm/export'
-      autoload :ForwardPorts,        'vagrant/action/vm/forward_ports'
-      autoload :Halt,                'vagrant/action/vm/halt'
-      autoload :HostName,            'vagrant/action/vm/host_name'
-      autoload :Import,              'vagrant/action/vm/import'
-      autoload :MatchMACAddress,     'vagrant/action/vm/match_mac_address'
-      autoload :Network,             'vagrant/action/vm/network'
-      autoload :NFS,                 'vagrant/action/vm/nfs'
-      autoload :Package,             'vagrant/action/vm/package'
-      autoload :PackageVagrantfile,  'vagrant/action/vm/package_vagrantfile'
-      autoload :Provision,           'vagrant/action/vm/provision'
-      autoload :ProvisionerCleanup,  'vagrant/action/vm/provisioner_cleanup'
-      autoload :PruneNFSExports,     'vagrant/action/vm/prune_nfs_exports'
-      autoload :Resume,              'vagrant/action/vm/resume'
-      autoload :SaneDefaults,        'vagrant/action/vm/sane_defaults'
-      autoload :ShareFolders,        'vagrant/action/vm/share_folders'
-      autoload :SetupPackageFiles,   'vagrant/action/vm/setup_package_files'
-      autoload :Suspend,             'vagrant/action/vm/suspend'
+    # This is the action that will remove a box given a name (and optionally
+    # a provider). This middleware sequence is built-in to Vagrant. Plugins
+    # can hook into this like any other middleware sequence.
+    def self.action_box_remove
+      Builder.new.tap do |b|
+        b.use Builtin::BoxRemove
+      end
     end
   end
 end

data/lib/vagrant/alias.rb

@@ -0,0 +1,59 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/registry"
+
+module Vagrant
+  # This class imports and processes CLI aliases stored in ~/.vagrant.d/aliases
+  class Alias
+    def initialize(env)
+      @aliases = Registry.new
+      @env = env
+
+      if env.aliases_path.file?
+        env.aliases_path.readlines.each do |line|
+          # separate keyword-command pairs
+          keyword, command = interpret(line)
+
+          if keyword && command
+            register(keyword, command)
+          end
+        end
+      end
+    end
+
+    # This returns all the registered alias commands.
+    def commands
+      @aliases
+    end
+
+    # This interprets a raw line from the aliases file.
+    def interpret(line)
+      # is it a comment?
+      return nil if line.strip.start_with?("#")
+
+      keyword, command = line.split("=", 2).collect(&:strip)
+
+      # validate the keyword
+      if keyword.match(/\s/i)
+        raise Errors::AliasInvalidError, alias: line, message: "Alias keywords must not contain any whitespace."
+      end
+
+      [keyword, command]
+    end
+
+    # This registers an alias.
+    def register(keyword, command)
+      @aliases.register(keyword.to_sym) do
+        lambda do |args|
+          # directly execute shell commands
+          if command.start_with?("!")
+            return Util::SafeExec.exec "#{command[1..-1]} #{args.join(" ")}".strip
+          end
+
+          return CLI.new(command.split.concat(args), @env).execute
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/batch_action.rb

@@ -0,0 +1,181 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'thread'
+require "log4r"
+
+module Vagrant
+  # This class executes multiple actions as a single batch, parallelizing
+  # the action calls if possible.
+  class BatchAction
+    def initialize(allow_parallel=true)
+      @actions          = []
+      @allow_parallel   = allow_parallel
+      @logger           = Log4r::Logger.new("vagrant::batch_action")
+    end
+
+    # Add an action to the batch of actions that will be run.
+    #
+    # This will **not** run the action now. The action will be run
+    # when {#run} is called.
+    #
+    # @param [Machine] machine The machine to run the action on
+    # @param [Symbol] action The action to run
+    # @param [Hash] options Any additional options to send in.
+    def action(machine, action, options=nil)
+      @actions << [machine, action, options]
+    end
+
+    # Custom runs a custom proc against a machine.
+    #
+    # @param [Machine] machine The machine to run against.
+    def custom(machine, &block)
+      @actions << [machine, block, nil]
+    end
+
+    # Run all the queued up actions, parallelizing if possible.
+    #
+    # This will parallelize if and only if the provider of every machine
+    # supports parallelization and parallelization is possible from
+    # initialization of the class.
+    def run
+      par = false
+
+      if @allow_parallel
+        par = true
+        @logger.info("Enabling parallelization by default.")
+      end
+
+      if par
+        @actions.each do |machine, _, _|
+          if !machine.provider_options[:parallel]
+            @logger.info("Disabling parallelization because provider doesn't support it: #{machine.provider_name}")
+            par = false
+            break
+          end
+        end
+      end
+
+      if par && @actions.length <= 1
+        @logger.info("Disabling parallelization because only executing one action")
+        par = false
+      end
+
+      @logger.info("Batch action will parallelize: #{par.inspect}")
+
+      threads = []
+      @actions.each do |machine, action, options|
+        @logger.info("Starting action: #{machine} #{action} #{options}")
+
+        # Create the new thread to run our action. This is basically just
+        # calling the action but also contains some error handling in it
+        # as well.
+        thread = Thread.new do
+          Thread.current[:error] = nil
+
+          # Note that this thread is being used for running
+          # a batch action
+          Thread.current[:batch_parallel_action] = par
+
+          # Record our pid when we started in order to figure out if
+          # we've forked...
+          start_pid = Process.pid
+
+          begin
+            if action.is_a?(Proc)
+              action.call(machine)
+            else
+              machine.send(:action, action, options)
+            end
+          rescue Exception => e
+            # If we're not parallelizing, then raise the error. We also
+            # don't raise the error if we've forked, because it'll hang
+            # the process.
+            raise if !par && Process.pid == start_pid
+
+            # Store the exception that will be processed later
+            Thread.current[:error] = e
+
+            # We can only do the things below if we do not fork, otherwise
+            # it'll hang the process.
+            if Process.pid == start_pid
+              # Let the user know that this process had an error early
+              # so that they see it while other things are happening.
+              machine.ui.error(I18n.t("vagrant.general.batch_notify_error"))
+            end
+          end
+
+          # If we forked during the process run, we need to do a hard
+          # exit here. Ruby's fork only copies the running process (which
+          # would be us), so if we return from this thread, it results
+          # in a zombie Ruby process.
+          if Process.pid != start_pid
+            # We forked.
+
+            exit_status = true
+            if Thread.current[:error]
+              # We had an error, print the stack trace and exit immediately.
+              exit_status = false
+              error = Thread.current[:error]
+              @logger.error(error.inspect)
+              @logger.error(error.message)
+              @logger.error(error.backtrace.join("\n"))
+            end
+
+            Process.exit!(exit_status)
+          end
+        end
+
+        # Set some attributes on the thread for later
+        thread[:machine] = machine
+
+        if !par
+          thread.join(THREAD_MAX_JOIN_TIMEOUT) while thread.alive?
+        end
+        threads << thread
+      end
+
+      errors = []
+
+      threads.each do |thread|
+        # Wait for the thread to complete
+        thread.join(THREAD_MAX_JOIN_TIMEOUT) while thread.alive?
+
+        # If the thread had an error, then store the error to show later
+        if thread[:error]
+          e = thread[:error]
+          # If the error isn't a Vagrant error, then store the backtrace
+          # as well.
+          if !thread[:error].is_a?(Errors::VagrantError)
+            e       = thread[:error]
+            message = e.message
+            message += "\n"
+            message += "\n#{e.backtrace.join("\n")}"
+
+            errors << I18n.t("vagrant.general.batch_unexpected_error",
+                             machine: thread[:machine].name,
+                             message: message)
+          else
+            errors << I18n.t("vagrant.general.batch_vagrant_error",
+                             machine: thread[:machine].name,
+                             message: thread[:error].message)
+          end
+        end
+      end
+
+      if !errors.empty?
+        raise Errors::BatchMultiError, message: errors.join("\n\n")
+      end
+
+      # Check if any threads set an exit code and exit if found. If
+      # multiple threads have exit code values set, the first encountered
+      # will be the value used.
+      threads.each do |thread|
+        if thread[:exit_code]
+          @logger.debug("Found exit code set within batch action thread. Exiting")
+          Process.exit!(thread[:exit_code])
+        end
+      end
+    end
+  end
+end