vagrant 1.5.0 → 2.4.4

data/lib/vagrant/config/v1/loader.rb

@@ -0,0 +1,108 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/config/v1/root"
+
+module Vagrant
+  module Config
+    module V1
+      # This is the loader that handles configuration loading for V1
+      # configurations.
+      class Loader < VersionBase
+        # Returns a bare empty configuration object.
+        #
+        # @return [V1::Root]
+        def self.init
+          new_root_object
+        end
+
+        # Finalizes the configuration by making sure there is at least
+        # one VM defined in it.
+        def self.finalize(config)
+          # Call the `#finalize` method on each of the configuration keys.
+          # They're expected to modify themselves in our case.
+          config.finalize!
+
+          # Return the object
+          config
+        end
+
+        # Loads the configuration for the given proc and returns a configuration
+        # object.
+        #
+        # @param [Proc] config_proc
+        # @return [Object]
+        def self.load(config_proc)
+          # Create a root configuration object
+          root = new_root_object
+
+          # Call the proc with the root
+          config_proc.call(root)
+
+          # Return the root object, which doubles as the configuration object
+          # we actually use for accessing as well.
+          root
+        end
+
+        # Merges two configuration objects.
+        #
+        # @param [V1::Root] old The older root config.
+        # @param [V1::Root] new The newer root config.
+        # @return [V1::Root]
+        def self.merge(old, new)
+          # Grab the internal states, we use these heavily throughout the process
+          old_state = old.__internal_state
+          new_state = new.__internal_state
+
+          # The config map for the new object is the old one merged with the
+          # new one.
+          config_map = old_state["config_map"].merge(new_state["config_map"])
+
+          # Merge the keys.
+          old_keys = old_state["keys"]
+          new_keys = new_state["keys"]
+          keys     = {}
+          old_keys.each do |key, old_value|
+            if new_keys.key?(key)
+              # We need to do a merge, which we expect to be available
+              # on the config class itself.
+              keys[key] = old_value.merge(new_keys[key])
+            else
+              # We just take the old value, but dup it so that we can modify.
+              keys[key] = old_value.dup
+            end
+          end
+
+          new_keys.each do |key, new_value|
+            # Add in the keys that the new class has that we haven't merged.
+            if !keys.key?(key)
+              keys[key] = new_value.dup
+            end
+          end
+
+          # Return the final root object
+          V1::Root.new(config_map, keys)
+        end
+
+        protected
+
+        def self.new_root_object
+          # Get all the registered configuration objects and use them. If
+          # we're currently on version 1, then we load all the config objects,
+          # otherwise we load only the upgrade safe ones, since we're
+          # obviously being loaded for an upgrade.
+          config_map = nil
+          plugin_manager = Vagrant.plugin("1").manager
+          if Config::CURRENT_VERSION == "1"
+            config_map = plugin_manager.config
+          else
+            config_map = plugin_manager.config_upgrade_safe
+          end
+
+          # Create the configuration root object
+          V1::Root.new(config_map)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v1/root.rb

@@ -0,0 +1,63 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "set"
+
+module Vagrant
+  module Config
+    module V1
+      # This is the root configuration class. An instance of this is what
+      # is passed into version 1 Vagrant configuration blocks.
+      class Root
+        # Initializes a root object that maps the given keys to specific
+        # configuration classes.
+        #
+        # @param [Hash] config_map Map of key to config class.
+        def initialize(config_map, keys=nil)
+          @keys              = keys || {}
+          @config_map        = config_map
+          @missing_key_calls = Set.new
+        end
+
+        # We use method_missing as a way to get the configuration that is
+        # used for Vagrant and load the proper configuration classes for
+        # each.
+        def method_missing(name, *args)
+          return @keys[name] if @keys.key?(name)
+
+          config_klass = @config_map[name.to_sym]
+          if config_klass
+            # Instantiate the class and return the instance
+            @keys[name] = config_klass.new
+            return @keys[name]
+          else
+            # Record access to a missing key as an error
+            @missing_key_calls.add(name.to_s)
+            return DummyConfig.new
+          end
+        end
+
+        # Called to finalize this object just prior to it being used by
+        # the Vagrant system. The "!" signifies that this is expected to
+        # mutate itself.
+        def finalize!
+          @keys.each do |_key, instance|
+            instance.finalize!
+          end
+        end
+
+        # Returns the internal state of the root object. This is used
+        # by outside classes when merging, and shouldn't be called directly.
+        # Note the strange method name is to attempt to avoid any name
+        # clashes with potential configuration keys.
+        def __internal_state
+          {
+            "config_map"        => @config_map,
+            "keys"              => @keys,
+            "missing_key_calls" => @missing_key_calls
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v1.rb

@@ -0,0 +1,12 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Config
+    module V1
+      autoload :DummyConfig, "vagrant/config/v1/dummy_config"
+      autoload :Loader, "vagrant/config/v1/loader"
+      autoload :Root,   "vagrant/config/v1/root"
+    end
+  end
+end

data/lib/vagrant/config/v2/dummy_config.rb

@@ -0,0 +1,60 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Config
+    module V2
+      # This is a configuration object that can have anything done
+      # to it. Anything, and it just appears to keep working.
+      class DummyConfig < Vagrant::Plugin::V2::Config
+        LOG  = Log4r::Logger.new("vagrant::config::v2::dummy_config")
+
+        def method_missing(name, *args, &block)
+          # There are a few scenarios where ruby will attempt to implicity
+          # coerce a given object into a certain type. DummyConfigs can end up
+          # in some of these scenarios when they're being shipped around in
+          # callbacks with splats. If method_missing allows these methods to be
+          # called but continues to return DummyConfig back, Ruby will raise a
+          # TypeError. Doing the normal thing of raising NoMethodError allows
+          # DummyConfig to behave normally as its being passed through splats.
+          #
+          # For a bit more detail and some keywords for further searching, see:
+          # https://ruby-doc.org/core-2.7.2/doc/implicit_conversion_rdoc.html
+          if [:to_hash, :to_ary].include?(name)
+            return super
+          end
+
+          # Trying to define a variable
+          if name.to_s.match(/^[\w]*=/)
+            LOG.debug("found name #{name}")
+            LOG.debug("setting instance variable name #{name.to_s.split("=")[0]}")
+            var_name = "@#{name.to_s.split("=")[0]}"
+            self.instance_variable_set(var_name, args[0])
+          else
+            DummyConfig.new
+          end
+        end
+
+        def merge(c)
+          c
+        end
+
+        def set_options(options)
+          options.each do |key, value|
+            if key.to_s.match(/^[\w]*=/)
+              var_name = "@#{key.to_s}"
+              self.instance_variable_set(var_name, value)
+            end
+          end
+        end
+
+        def instance_variables_hash
+          instance_variables.inject({}) do |acc, iv|
+            acc[iv.to_s[1..-1]] = instance_variable_get(iv)
+            acc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2/loader.rb

@@ -0,0 +1,154 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/config/v2/root"
+
+module Vagrant
+  module Config
+    module V2
+      # This is the loader that handles configuration loading for V2
+      # configurations.
+      class Loader < VersionBase
+        # Returns a bare empty configuration object.
+        #
+        # @return [V2::Root]
+        def self.init
+          new_root_object
+        end
+
+        # Finalizes the configuration by making sure there is at least
+        # one VM defined in it.
+        def self.finalize(config)
+          # Call the `#finalize` method on each of the configuration keys.
+          # They're expected to modify themselves in our case.
+          config.finalize!
+
+          # Return the object
+          config
+        end
+
+        # Loads the configuration for the given proc and returns a configuration
+        # object.
+        #
+        # @param [Proc] config_proc
+        # @return [Object]
+        def self.load(config_proc)
+          # Create a root configuration object
+          root = new_root_object
+
+          # Call the proc with the root
+          config_proc.call(root)
+
+          # Return the root object, which doubles as the configuration object
+          # we actually use for accessing as well.
+          root
+        end
+
+        # Merges two configuration objects.
+        #
+        # @param [V2::Root] old The older root config.
+        # @param [V2::Root] new The newer root config.
+        # @return [V2::Root]
+        def self.merge(old, new)
+          # Grab the internal states, we use these heavily throughout the process
+          old_state = old.__internal_state
+          new_state = new.__internal_state
+
+          # Make sure we instantiate every key in the config so that we
+          # merge every key. This avoids issues with the same reference
+          # being part of the config.
+          old_state["config_map"].each do |k, _|
+            old.public_send(k)
+          end
+          new_state["config_map"].each do |k, _|
+            new.public_send(k)
+          end
+
+          # The config map for the new object is the old one merged with the
+          # new one.
+          config_map = old_state["config_map"].merge(new_state["config_map"])
+
+          # Merge the keys.
+          old_keys = old_state["keys"]
+          new_keys = new_state["keys"]
+          keys     = {}
+          old_keys.each do |key, old_value|
+            if new_keys.key?(key)
+              # We need to do a merge, which we expect to be available
+              # on the config class itself.
+              keys[key] = old_value.merge(new_keys[key])
+            else
+              # We just take the old value, but dup it so that we can modify.
+              keys[key] = old_value.dup
+            end
+          end
+
+          new_keys.each do |key, new_value|
+            # Add in the keys that the new class has that we haven't merged.
+            if !keys.key?(key)
+              keys[key] = new_value.dup
+            end
+          end
+
+          # Merge the missing keys
+          new_missing_key_calls =
+            old_state["missing_key_calls"] + new_state["missing_key_calls"]
+
+          # Return the final root object
+          V2::Root.new(config_map).tap do |result|
+            result.__set_internal_state({
+              "config_map"        => config_map,
+              "keys"              => keys,
+              "missing_key_calls" => new_missing_key_calls
+            })
+          end
+        end
+
+        # Upgrade a V1 configuration to a V2 configuration. We do this by
+        # creating a V2 configuration, and calling "upgrade" on each of the
+        # V1 configurations, expecting them to set the right settings on the
+        # new root.
+        #
+        # @param [V1::Root] old
+        # @return [Array] A 3-tuple result.
+        def self.upgrade(old)
+          # Get a new root
+          root = new_root_object
+
+          # Store the warnings/errors
+          warnings = []
+          errors   = []
+
+          # Go through the old keys and upgrade them if they can be
+          old.__internal_state["keys"].each do |_, old_value|
+            if old_value.respond_to?(:upgrade)
+              result = old_value.upgrade(root)
+
+              # Sanity check to guard against random return values
+              if result.is_a?(Array)
+                warnings += result[0]
+                errors   += result[1]
+              end
+            end
+          end
+
+          old.__internal_state["missing_key_calls"].to_a.sort.each do |key|
+            warnings << I18n.t("vagrant.config.loader.bad_v1_key", key: key)
+          end
+
+          [root, warnings, errors]
+        end
+
+        protected
+
+        def self.new_root_object
+          # Get all the registered plugins for V2
+          config_map = Vagrant.plugin("2").manager.config
+
+          # Create the configuration root object
+          V2::Root.new(config_map)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2/root.rb

@@ -0,0 +1,122 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "set"
+
+require "vagrant/config/v2/util"
+
+module Vagrant
+  module Config
+    module V2
+      # This is the root configuration class. An instance of this is what
+      # is passed into version 2 Vagrant configuration blocks.
+      class Root
+        # Initializes a root object that maps the given keys to specific
+        # configuration classes.
+        #
+        # @param [Hash] config_map Map of key to config class.
+        def initialize(config_map, keys=nil)
+          @keys              = keys || {}
+          @config_map        = config_map
+          @missing_key_calls = Set.new
+          @logger            = Log4r::Logger.new("vagrant::config")
+        end
+
+        # We use method_missing as a way to get the configuration that is
+        # used for Vagrant and load the proper configuration classes for
+        # each.
+        def method_missing(name, *args)
+          return @keys[name] if @keys.key?(name)
+
+          config_klass = @config_map[name.to_sym]
+          if config_klass
+            # Instantiate the class and return the instance
+            @keys[name] = config_klass.new
+          else
+            @logger.debug("missing key request name=#{name} loc=#{caller.first}")
+            # Record access to a missing key as an error
+            @missing_key_calls.add(name.to_s)
+            @keys[name] = DummyConfig.new
+          end
+
+          @keys[name]
+        end
+
+        # Called to finalize this object just prior to it being used by
+        # the Vagrant system. The "!" signifies that this is expected to
+        # mutate itself.
+        def finalize!
+          @config_map.each do |key, klass|
+            if !@keys.key?(key)
+              @keys[key] = klass.new
+            end
+          end
+
+          @keys.each do |_key, instance|
+            instance.finalize!
+            instance._finalize!
+          end
+        end
+
+        # This validates the configuration and returns a hash of error
+        # messages by section. If there are no errors, an empty hash
+        # is returned.
+        #
+        # @param [Environment] env
+        # @return [Hash]
+        def validate(machine, ignore_provider=nil)
+          # Go through each of the configuration keys and validate
+          errors = {}
+          @keys.each do |_key, instance|
+            if instance.respond_to?(:validate)
+              # Validate this single item, and if we have errors then
+              # we merge them into our total errors list.
+              if _key == :vm
+                result = instance.validate(machine, ignore_provider)
+              else
+                result = instance.validate(machine)
+              end
+              if result && !result.empty?
+                errors = Util.merge_errors(errors, result)
+              end
+            end
+          end
+
+          # Go through and delete empty keys
+          errors.keys.each do |key|
+            errors.delete(key) if errors[key].empty?
+          end
+
+          # If we have missing keys, record those as errors
+          if !@missing_key_calls.empty?
+            errors["Vagrant"] = @missing_key_calls.to_a.sort.map do |key|
+              I18n.t("vagrant.config.root.bad_key", key: key)
+            end
+          end
+
+          errors
+        end
+
+        # Returns the internal state of the root object. This is used
+        # by outside classes when merging, and shouldn't be called directly.
+        # Note the strange method name is to attempt to avoid any name
+        # clashes with potential configuration keys.
+        def __internal_state
+          {
+            "config_map"        => @config_map,
+            "keys"              => @keys,
+            "missing_key_calls" => @missing_key_calls
+          }
+        end
+
+        # This sets the internal state. This is used by the core to do some
+        # merging logic and shouldn't be used by the general public.
+        def __set_internal_state(state)
+          @config_map        = state["config_map"] if state.key?("config_map")
+          @keys              = state["keys"] if state.key?("keys")
+          @missing_key_calls = state["missing_key_calls"] if state.key?("missing_key_calls")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2/util.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Config
+    module V2
+      class Util
+        # This merges two error hashes from validate methods.
+        #
+        # @param [Hash] first
+        # @param [Hash] second
+        # @return [Hash] Merged result
+        def self.merge_errors(first, second)
+          first.dup.tap do |result|
+            second.each do |key, value|
+              result[key] ||= []
+              result[key] += value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2.rb

@@ -0,0 +1,13 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Config
+    module V2
+      autoload :DummyConfig, "vagrant/config/v2/dummy_config"
+      autoload :Loader, "vagrant/config/v2/loader"
+      autoload :Root, "vagrant/config/v2/root"
+      autoload :Util, "vagrant/config/v2/util"
+    end
+  end
+end

data/lib/vagrant/config/version_base.rb

@@ -0,0 +1,83 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Config
+    # This is the base class for any configuration versions, and includes
+    # the stub methods that configuration versions must implement. Vagrant
+    # supports configuration versioning so that backwards compatibility can be
+    # maintained for past Vagrantfiles while newer configurations are added.
+    # Vagrant only introduces new configuration versions for major versions
+    # of Vagrant.
+    class VersionBase
+      # Returns an empty configuration object. This can be any kind of object,
+      # since it is treated as an opaque value on the other side, used only
+      # for things like calling into {merge}.
+      #
+      # @return [Object]
+      def self.init
+        raise NotImplementedError
+      end
+
+      # This is called just before configuration loading is complete of
+      # a potentially completely-merged value to perform final touch-ups
+      # to the configuration, if required.
+      #
+      # This is an optional method to implement. The default implementation
+      # will simply return the same object.
+      #
+      # This will ONLY be called if this is the version that is being
+      # used. In the case that an `upgrade` is called, this will never
+      # be called.
+      #
+      # @param [Object] obj Final configuration object.
+      # @param [Object] Finalized configuration object.
+      def self.finalize(obj)
+        obj
+      end
+
+      # Loads the configuration for the given proc and returns a configuration
+      # object. The return value is treated as an opaque object, so it can be
+      # anything you'd like. The return value is the object that is passed
+      # into methods like {merge}, so it should be something you expect.
+      #
+      # @param [Proc] proc The proc that is to be configured.
+      # @return [Object]
+      def self.load(proc)
+        raise NotImplementedError
+      end
+
+      # Merges two configuration objects, returning the merged object.
+      # The values of `old` and `new` are the opaque objects returned by
+      # {load} or {init}.
+      #
+      # Once again, the return object is treated as an opaque value by
+      # the Vagrant configuration loader, so it can be anything you'd like.
+      #
+      # @param [Object] old Old configuration object.
+      # @param [Object] new New configuration object.
+      # @return [Object] The merged configuration object.
+      def self.merge(old, new)
+        raise NotImplementedError
+      end
+
+      # This is called if a previous version of configuration needs to be
+      # upgraded to this version. Each version of configuration should know
+      # how to upgrade the version immediately prior to it. This should be
+      # a best effort upgrade that makes many assumptions. The goal is for
+      # this to work in almost every case, but perhaps with some warnings.
+      # The return value for this is a 3-tuple: `[object, warnings, errors]`,
+      # where `object` is the upgraded configuration object, `warnings` is
+      # an array of warning messages, and `errors` is an array of error
+      # messages.
+      #
+      # @param [Object] old The version of the configuration object just
+      #   prior to this one.
+      # @return [Array] The 3-tuple result. Please see the above documentation
+      #   for more information on the exact structure of this object.
+      def self.upgrade(old)
+        raise NotImplementedError
+      end
+    end
+  end
+end