vagrant 1.0.7 → 2.4.4

data/lib/vagrant/capability_host.rb

@@ -0,0 +1,180 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  # This module enables a class to host capabilities. Prior to being able
+  # to use any capabilities, the `initialize_capabilities!` method must be
+  # called.
+  #
+  # Capabilities allow small pieces of functionality to be plugged in using
+  # the Vagrant plugin model. Capabilities even allow for a certain amount
+  # of inheritance, where only a subset of capabilities may be implemented but
+  # a parent implements the rest.
+  #
+  # Capabilities are used heavily in Vagrant for host/guest interactions. For
+  # example, "mount_nfs_folder" is a guest-OS specific operation, so capabilities
+  # defer these operations to the guest.
+  module CapabilityHost
+    # Initializes the capability system by detecting the proper capability
+    # host to execute on and building the chain of capabilities to execute.
+    #
+    # @param [Symbol] host The host to use for the capabilities, or nil if
+    #   we should auto-detect it.
+    # @param [Hash<Symbol, Array<Class, Symbol>>] hosts Potential capability
+    #   hosts. The key is the name of the host, value[0] is a class that
+    #   implements `#detect?` and value[1] is a parent host (if any).
+    # @param [Hash<Symbol, Hash<Symbol, Class>>] capabilities The capabilities
+    #   that are supported. The key is the host of the capability. Within that
+    #   is a hash where the key is the name of the capability and the value
+    #   is the class/module implementing it.
+    def initialize_capabilities!(host, hosts, capabilities, *args)
+      @cap_logger = Log4r::Logger.new(
+        "vagrant::capability_host::#{self.class.to_s.downcase}")
+
+      if host && !hosts[host]
+        raise Errors::CapabilityHostExplicitNotDetected, value: host.to_s
+      end
+
+      if !host
+        host = autodetect_capability_host(hosts, *args) if !host
+        raise Errors::CapabilityHostNotDetected if !host
+      end
+
+      if !hosts[host]
+        # This should never happen because the autodetect above uses the
+        # hosts hash to look up hosts. And if an explicit host is specified,
+        # we do another check higher up.
+        raise "Internal error. Host not found: #{host}"
+      end
+
+      name      = host
+      host_info = hosts[name]
+      host      = host_info[0].new
+      chain     = []
+      chain << [name, host]
+
+      # Build the proper chain of parents if there are any.
+      # This allows us to do "inheritance" of capabilities later
+      if host_info[1]
+        parent_name = host_info[1]
+        parent_info = hosts[parent_name]
+        while parent_info
+          chain << [parent_name, parent_info[0].new]
+          parent_name = parent_info[1]
+          parent_info = hosts[parent_name]
+        end
+      end
+
+      @cap_host_chain = chain
+      @cap_args       = args
+      @cap_caps       = capabilities
+      true
+    end
+
+    # Returns the chain of hosts that will be checked for capabilities.
+    #
+    # @return [Array<Array<Symbol, Class>>]
+    def capability_host_chain
+      @cap_host_chain
+    end
+
+    # Tests whether the given capability is possible.
+    #
+    # @param [Symbol] cap_name Capability name
+    # @return [Boolean]
+    def capability?(cap_name)
+      !capability_module(cap_name.to_sym).nil?
+    end
+
+    # Executes the capability with the given name, optionally passing more
+    # arguments onwards to the capability. If the capability returns a value,
+    # it will be returned.
+    #
+    # @param [Symbol] cap_name Name of the capability
+    def capability(cap_name, *args)
+      cap_mod = capability_module(cap_name.to_sym)
+      if !cap_mod
+        raise Errors::CapabilityNotFound,
+          cap:  cap_name.to_s,
+          host: @cap_host_chain[0][0].to_s
+      end
+
+      cap_method = nil
+      begin
+        cap_method = cap_mod.method(cap_name)
+      rescue NameError
+        raise Errors::CapabilityInvalid,
+          cap: cap_name.to_s,
+          host: @cap_host_chain[0][0].to_s
+      end
+
+      args = @cap_args + args
+      @cap_logger.info(
+        "Execute capability: #{cap_name} #{args.inspect} (#{@cap_host_chain[0][0]})")
+      cap_method.call(*args)
+    end
+
+    protected
+
+    def autodetect_capability_host(hosts, *args)
+      @cap_logger.info("Autodetecting host type for #{args.inspect}")
+
+      # Get the mapping of hosts with the most parents. We start searching
+      # with the hosts with the most parents first.
+      parent_count = {}
+      hosts.each do |name, parts|
+        parent_count[name] = 0
+
+        parent = parts[1]
+        while parent
+          parent_count[name] += 1
+          parent = hosts[parent]
+          parent = parent[1] if parent
+        end
+      end
+
+      # Now swap around the mapping so that it is a mapping of
+      # count to the actual list of host names
+      parent_count_to_hosts = {}
+      parent_count.each do |name, count|
+        parent_count_to_hosts[count] ||= []
+        parent_count_to_hosts[count] << name
+      end
+
+      sorted_counts = parent_count_to_hosts.keys.sort.reverse
+      sorted_counts.each do |count|
+        parent_count_to_hosts[count].each do |name|
+          @cap_logger.debug("Trying: #{name}")
+          host_info = hosts[name]
+          host      = host_info[0].new
+
+          if host.detect?(*args)
+            @cap_logger.info("Detected: #{name}!")
+            return name
+          end
+        end
+      end
+
+      return nil
+    end
+
+    # Returns the registered module for a capability with the given name.
+    #
+    # @param [Symbol] cap_name
+    # @return [Module]
+    def capability_module(cap_name)
+      @cap_logger.debug("Searching for cap: #{cap_name}")
+      @cap_host_chain.each do |host_name, host|
+        @cap_logger.debug("Checking in: #{host_name}")
+        caps = @cap_caps[host_name]
+
+        if caps && caps.key?(cap_name)
+          @cap_logger.debug("Found cap: #{cap_name} in #{host_name}")
+          return caps[cap_name]
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/vagrant/cli.rb

@@ -1,46 +1,77 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
 require 'log4r'
 require 'optparse'
 
+require 'vagrant/util/experimental'
+
 module Vagrant
   # Manages the command line interface to Vagrant.
-  class CLI < Command::Base
+  class CLI < Vagrant.plugin("2", :command)
+
     def initialize(argv, env)
       super
 
       @logger = Log4r::Logger.new("vagrant::cli")
       @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
 
+      ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+      @triggers = Vagrant::Plugin::V2::Trigger.new(env, env.vagrantfile.config.trigger, nil, ui)
+
+      Util::CheckpointClient.instance.setup(env).check
       @logger.info("CLI: #{@main_args.inspect} #{@sub_command.inspect} #{@sub_args.inspect}")
     end
 
     def execute
-      if @main_args.include?("-v") || @main_args.include?("--version")
-        # Version short-circuits the whole thing. Just print
-        # the version and exit.
-        @env.ui.info(I18n.t("vagrant.commands.version.output",
-                            :version => Vagrant::VERSION),
-                     :prefix => false)
-
-        return 0
-      elsif @main_args.include?("-h") || @main_args.include?("--help")
+      if @main_args.include?("-h") || @main_args.include?("--help")
         # Help is next in short-circuiting everything. Print
         # the help and exit.
         help
         return 0
       end
 
+      if @sub_command == "login"
+        $stderr.puts "WARNING: This command has been deprecated and aliased to `vagrant cloud auth login`"
+      end
+
       # If we reached this far then we must have a subcommand. If not,
       # then we also just print the help and exit.
-      command_class = Vagrant.commands.get(@sub_command.to_sym) if @sub_command
-      if !command_class || !@sub_command
+      command_plugin = nil
+      if @sub_command
+        command_plugin = Vagrant.plugin("2").manager.commands[@sub_command.to_sym]
+
+        if !command_plugin
+          alias_command = Alias.new(@env).commands[@sub_command.to_sym]
+
+          if alias_command
+            return alias_command.call(@sub_args)
+          end
+        end
+      end
+
+      if !command_plugin || !@sub_command
         help
-        return 0
+        return 1
       end
+
+      command_class = command_plugin[0].call
       @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
 
+      Util::CheckpointClient.instance.display
+
       # Initialize and execute the command class, returning the exit status.
-      result = command_class.new(@sub_args, @env).execute
-      result = 0 if !result.is_a?(Fixnum)
+      result = 0
+      begin
+        @triggers.fire(@sub_command, :before, nil, :command)
+        result = command_class.new(@sub_args, @env).execute
+        @triggers.fire(@sub_command, :after, nil, :command)
+      rescue Interrupt
+        @env.ui.info(I18n.t("vagrant.cli_interrupt"))
+        result = 1
+      end
+
+      result = 0 if !result.is_a?(Integer)
       return result
     end
 
@@ -49,28 +80,43 @@ module Vagrant
       # We use the optionparser for this. Its just easier. We don't use
       # an optionparser above because I don't think the performance hits
       # of creating a whole object are worth checking only a couple flags.
-      opts = OptionParser.new do |opts|
-        opts.banner = "Usage: vagrant [-v] [-h] command [<args>]"
-        opts.separator ""
-        opts.on("-v", "--version", "Print the version and exit.")
-        opts.on("-h", "--help", "Print this help.")
-        opts.separator ""
-        opts.separator "Available subcommands:"
+      opts = OptionParser.new do |o|
+        o.banner = "Usage: vagrant [options] <command> [<args>]"
+        o.separator ""
+        o.on("-v", "--version", "Print the version and exit.")
+        o.on("-h", "--help", "Print this help.")
+        o.separator ""
+        o.separator "Common commands:"
 
         # Add the available subcommands as separators in order to print them
         # out as well.
-        keys = []
-        Vagrant.commands.each { |key, value| keys << key.to_s }
+        commands = {}
+        longest = 0
+        Vagrant.plugin("2").manager.commands.each do |key, data|
+          # Skip non-primary commands. These only show up in extended
+          # help output.
+          next if !data[1][:primary]
+
+          key           = key.to_s
+          klass         = data[0].call
+          commands[key] = klass.synopsis
+          longest       = key.length if key.length > longest
+        end
 
-        keys.sort.each do |key|
-          opts.separator "     #{key}"
+        commands.keys.sort.each do |key|
+          o.separator "     #{key.ljust(longest+2)} #{commands[key]}"
+          @env.ui.machine("cli-command", key.dup)
         end
 
-        opts.separator ""
-        opts.separator "For help on any individual command run `vagrant COMMAND -h`"
+        o.separator ""
+        o.separator "For help on any individual command run `vagrant COMMAND -h`"
+        o.separator ""
+        o.separator "Additional subcommands are available, but are either more advanced"
+        o.separator "or not commonly used. To see all subcommands, run the command"
+        o.separator "`vagrant list-commands`."
       end
 
-      @env.ui.info(opts.help, :prefix => false)
+      @env.ui.info(opts.help, prefix: false)
     end
   end
 end

data/lib/vagrant/config/loader.rb

@@ -1,3 +1,6 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
 require "pathname"
 
 require "log4r"
@@ -12,15 +15,21 @@ module Vagrant
     # set later always overrides those set earlier; this is how
     # configuration "scoping" is implemented.
     class Loader
-      # This is an array of symbols specifying the order in which
-      # configuration is loaded. For examples, see the class documentation.
-      attr_accessor :load_order
-
-      def initialize
-        @logger  = Log4r::Logger.new("vagrant::config::loader")
-        @sources = {}
-        @proc_cache = {}
-        @config_cache = {}
+      # Initializes a configuration loader.
+      #
+      # @param [Registry] versions A registry of the available versions and
+      #   their associated loaders.
+      # @param [Array] version_order An array of the order of the versions
+      #   in the registry. This is used to determine if upgrades are
+      #   necessary. Additionally, the last version in this order is always
+      #   considered the "current" version.
+      def initialize(versions, version_order)
+        @logger        = Log4r::Logger.new("vagrant::config::loader")
+        @config_cache  = {}
+        @proc_cache    = {}
+        @sources       = {}
+        @versions      = versions
+        @version_order = version_order
       end
 
       # Set the configuration data for the given name.
@@ -35,20 +44,30 @@ module Vagrant
       # `set` multiple times with the same name will override any previously
       # set values. In this way, the last set data for a given name wins.
       def set(name, sources)
-        @logger.debug("Set #{name.inspect} = #{sources.inspect}")
-
         # Sources should be an array
         sources = [sources] if !sources.kind_of?(Array)
 
+        reliably_inspected_sources = sources.reduce({}) { |accum, source|
+          begin
+            accum[source] = source.inspect
+          rescue Encoding::CompatibilityError
+            accum[source] = "<!Vagrant failed to call #inspect source with object id #{source.object_id} and class #{source.class} due to a string encoding error>"
+          end
+
+          accum
+        }
+
+        @logger.info("Set #{name.inspect} = #{reliably_inspected_sources.values}")
+
         # Gather the procs for every source, since that is what we care about.
         procs = []
         sources.each do |source|
-          if !@proc_cache.has_key?(source)
+          if !@proc_cache.key?(source)
             # Load the procs for this source and cache them. This caching
             # avoids the issue where a file may have side effects when loading
             # and loading it multiple times causes unexpected behavior.
-            @logger.debug("Populating proc cache for #{source.inspect}")
-            @proc_cache[source] = procs_for_source(source)
+            @logger.debug("Populating proc cache for #{reliably_inspected_sources[source]}")
+            @proc_cache[source] = procs_for_source(source, reliably_inspected_sources)
           end
 
           # Add on to the array of procs we're going to use
@@ -59,40 +78,174 @@ module Vagrant
         @sources[name] = procs
       end
 
-      # This loads the configured sources in the configured order and returns
+      # This loads the configuration sources in the given order and returns
       # an actual configuration object that is ready to be used.
-      def load
-        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
+      #
+      # @param [Array<Symbol>] order The order of configuration to load.
+      # @return [Object] The configuration object. This is different for
+      #   each configuration version.
+      def load(order)
+        @logger.info("Loading configuration in order: #{order.inspect}")
 
-        unknown_sources = @sources.keys - @load_order
+        unknown_sources = @sources.keys - order
         if !unknown_sources.empty?
-          # TODO: Raise exception here perhaps.
-          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
+          @logger.warn("Unknown config sources: #{unknown_sources.inspect}")
         end
 
-        # Create the top-level configuration which will hold all the config.
-        result = Top.new
+        # Get the current version config class to use
+        current_version      = @version_order.last
+        current_config_klass = @versions.get(current_version)
+
+        # This will hold our result
+        result = current_config_klass.init
+
+        # Keep track of the warnings and errors that may come from
+        # upgrading the Vagrantfiles
+        warnings = []
+        errors   = []
 
-        @load_order.each do |key|
-          next if !@sources.has_key?(key)
+        if !@sources[:root].nil? && @sources[:root].eql?(@sources[:home])
+          # Vagrants home dir is set to the same dir as its project directory
+          # so we don't want to load and merge the same Vagrantfile config
+          # and execute its settings/procs twice
+          #
+          # Note: This protection won't work if there are two separate but
+          # identical Vagrantfiles in the home and project dir
+          @logger.info("Duplicate Vagrantfile config objects detected in :root and :home.")
+          @sources.delete(:home)
+          @logger.info("Removed :home config from being loaded")
+        end
+
+        order.each do |key|
+          next if !@sources.key?(key)
 
-          @sources[key].each do |proc|
-            if !@config_cache.has_key?(proc)
+          @sources[key].each do |version, proc|
+            if !@config_cache.key?(proc)
               @logger.debug("Loading from: #{key} (evaluating)")
-              current = Top.new
-              proc.call(current)
-              @config_cache[proc] = current
+
+              # Get the proper version loader for this version and load
+              version_loader = @versions.get(version)
+              begin
+                version_config = version_loader.load(proc)
+              rescue NameError => e
+                line = "(unknown)"
+                path = "(unknown)"
+                if e.backtrace && e.backtrace[0]
+                  backtrace_tokens = e.backtrace[0].split(":")
+                  path = e.backtrace.first.slice(0, e.backtrace.first.rindex(':')).rpartition(':').first
+                  backtrace_tokens.each do |part|
+                    if part =~ /\d+/
+                      line = part.to_i
+                      break
+                    end
+                  end
+                end
+
+                raise Errors::VagrantfileNameError,
+                  path: path,
+                  line: line,
+                  message: e.message.sub(/' for .*$/, "'")
+              end
+
+              # Store the errors/warnings associated with loading this
+              # configuration. We'll store these for later.
+              version_warnings = []
+              version_errors   = []
+
+              # If this version is not the current version, then we need
+              # to upgrade to the latest version.
+              if version != current_version
+                @logger.debug("Upgrading config from version #{version} to #{current_version}")
+                version_index = @version_order.index(version)
+                current_index = @version_order.index(current_version)
+
+                (version_index + 1).upto(current_index) do |index|
+                  next_version = @version_order[index]
+                  @logger.debug("Upgrading config to version #{next_version}")
+
+                  # Get the loader of this version and ask it to upgrade
+                  loader = @versions.get(next_version)
+                  upgrade_result = loader.upgrade(version_config)
+
+                  this_warnings = upgrade_result[1]
+                  this_errors   = upgrade_result[2]
+                  @logger.debug("Upgraded to version #{next_version} with " +
+                                "#{this_warnings.length} warnings and " +
+                                "#{this_errors.length} errors")
+
+                  # Append loading this to the version warnings and errors
+                  version_warnings += this_warnings
+                  version_errors   += this_errors
+
+                  # Store the new upgraded version
+                  version_config = upgrade_result[0]
+                end
+              end
+
+              # Cache the loaded configuration along with any warnings
+              # or errors so that they can be retrieved later.
+              @config_cache[proc] = [version_config, version_warnings, version_errors]
             else
               @logger.debug("Loading from: #{key} (cache)")
             end
 
-            # Merge in the results of this proc's configuration
-            result = result.merge(@config_cache[proc])
+            # Merge the configurations
+            cache_data = @config_cache[proc]
+            result = current_config_klass.merge(result, cache_data[0])
+
+            # Append the total warnings/errors
+            warnings += cache_data[1]
+            errors   += cache_data[2]
           end
         end
 
-        @logger.debug("Configuration loaded successfully")
-        result
+        @logger.debug("Configuration loaded successfully, finalizing and returning")
+        [current_config_klass.finalize(result), warnings, errors]
+      end
+
+      # This method is used for doing partial loads of the
+      # Vagrantfile. It will load the contents of a single
+      # location and return the config. No merging is performed
+      # and no finalization is applied.
+      #
+      # @param key [Symbol] name of location
+      # @return [Object] configuration
+      # @note: This will load either version, but we assume a v2 result
+      # @todo(spox): check version and raise error on v1
+      def partial_load(key)
+        raise KeyError,
+              "Unknown path key provided (#{key})" if !@sources.key?(key)
+
+        version, proc = @sources[key].first
+        @logger.debug("Loading from: #{key} (evaluating)")
+
+        # Get the proper version loader for this version and load
+        version_loader = @versions.get(version)
+        raise KeyError,
+              "Failed to create loader for requested version: #{version}" if version_loader.nil?
+
+        begin
+          version_config = version_loader.load(proc)
+        rescue NameError => e
+          line = "(unknown)"
+          path = "(unknown)"
+          if e.backtrace && e.backtrace[0]
+            backtrace_tokens = e.backtrace[0].split(":")
+            path = e.backtrace.first.slice(0, e.backtrace.first.rindex(':')).rpartition(':').first
+            backtrace_tokens.each do |part|
+              if part =~ /\d+/
+                line = part.to_i
+                break
+              end
+            end
+          end
+
+          raise Errors::VagrantfileNameError,
+                path: path,
+                line: line,
+                message: e.message.sub(/' for .*$/, "'") + "\n#{e.backtrace.join("\n")}" + "\nVersion #{version.inspect} loader: #{version_loader.inspect} versions: #{@versions.inspect}"
+        end
+        version_config
       end
 
       protected
@@ -101,26 +254,69 @@ module Vagrant
       # The `Proc` objects returned will expect a single argument for
       # the configuration object and are expected to mutate this
       # configuration object.
-      def procs_for_source(source)
-        return [source] if source.is_a?(Proc)
+      def procs_for_source(source, reliably_inspected_sources)
+        # Convert all pathnames to strings so we just have their path
+        source = source.to_s if source.is_a?(Pathname)
 
-        # Assume all string sources are actually pathnames
-        source = Pathname.new(source) if source.is_a?(String)
+        if source.is_a?(Array)
+          # An array must be formatted as [version, proc], so verify
+          # that and then return it
+          raise ArgumentError, "String source must have format [version, proc]" if source.length != 2
 
-        if source.is_a?(Pathname)
-          @logger.debug("Load procs for pathname: #{source.inspect}")
+          # Return it as an array since we're expected to return an array
+          # of [version, proc] pairs, but an array source only has one.
+          return [source]
+        elsif source.is_a?(String)
+          # Strings are considered paths, so load them
+          return procs_for_path(source)
+        else
+          raise ArgumentError, "Unknown configuration source: #{reliably_inspected_sources[source]}"
+        end
+      end
+
+      # This returns an array of `Proc` objects for the given path source.
+      #
+      # @param [String] path Path to the file which contains the proper
+      #   `Vagrant.configure` calls.
+      # @return [Array<Proc>]
+      def procs_for_path(path)
+        @logger.debug("Load procs for pathname: #{path}")
 
+        return Config.capture_configures do
           begin
-            return Config.capture_configures do
-              Kernel.load source
-            end
+            Kernel.load path
           rescue SyntaxError => e
             # Report syntax errors in a nice way.
-            raise Errors::VagrantfileSyntaxError, :file => e.message
+            raise Errors::VagrantfileSyntaxError, file: e.message
+          rescue SystemExit
+            # Continue raising that exception...
+            raise
+          rescue Vagrant::Errors::VagrantError
+            # Continue raising known Vagrant errors since they already
+            # contain well worded error messages and context.
+            raise
+          rescue Exception => e
+            @logger.error("Vagrantfile load error: #{e.message}")
+            @logger.error(e.backtrace.join("\n"))
+
+            line = "(unknown)"
+            if e.backtrace && e.backtrace[0]
+              e.backtrace[0].split(":").each do |part|
+                if part =~ /\d+/
+                  line = part.to_i
+                  break
+                end
+              end
+            end
+
+            # Report the generic exception
+            raise Errors::VagrantfileLoadError,
+              path: path,
+              line: line,
+              exception_class: e.class,
+              message: e.message
           end
         end
-
-        raise Exception, "Unknown configuration source: #{source.inspect}"
       end
     end
   end