vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,167 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "set"
+
+module Vagrant
+  module Plugin
+    module V2
+      # This is the base class for a configuration key defined for
+      # V2. Any configuration key plugins for V2 should inherit from this
+      # class.
+      class Config
+        # This constant represents an unset value. This is useful so it is
+        # possible to know the difference between a configuration value that
+        # was never set, and a value that is nil (explicitly). Best practice
+        # is to initialize all variables to this value, then the {#merge}
+        # method below will "just work" in many cases.
+
+        UNSET_VALUE = :__UNSET__VALUE__
+
+        # This is called as a last-minute hook that allows the configuration
+        # object to finalize itself before it will be put into use. This is
+        # a useful place to do some defaults in the case the user didn't
+        # configure something or so on.
+        #
+        # An example of where this sort of thing is used or has been used:
+        # the "vm" configuration key uses this to make sure that at least
+        # one sub-VM has been defined: the default VM.
+        #
+        # The configuration object is expected to mutate itself.
+        def finalize!
+          # Default implementation is to do nothing.
+        end
+
+        # Merge another configuration object into this one. This assumes that
+        # the other object is the same class as this one. This should not
+        # mutate this object, but instead should return a new, merged object.
+        #
+        # The default implementation will simply iterate over the instance
+        # variables and merge them together, with this object overriding
+        # any conflicting instance variables of the older object. Instance
+        # variables starting with "__" (double underscores) will be ignored.
+        # This lets you set some sort of instance-specific state on your
+        # configuration keys without them being merged together later.
+        #
+        # @param [Object] other The other configuration object to merge from,
+        #   this must be the same type of object as this one.
+        # @return [Object] The merged object.
+        def merge(other)
+          result = self.class.new
+
+          # Set all of our instance variables on the new class
+          [self, other].each do |obj|
+            obj.instance_variables.each do |key|
+              # Ignore keys that start with a double underscore. This allows
+              # configuration classes to still hold around internal state
+              # that isn't propagated.
+              if !key.to_s.start_with?("@__")
+                # Don't set the value if it is the unset value, either.
+                value = obj.instance_variable_get(key)
+                result.instance_variable_set(key, value) if value != UNSET_VALUE
+              end
+            end
+          end
+
+          # Persist through the set of invalid methods
+          this_invalid  = @__invalid_methods || Set.new
+          other_invalid = other.instance_variable_get(:"@__invalid_methods") || Set.new
+          result.instance_variable_set(:"@__invalid_methods", this_invalid + other_invalid)
+
+          result
+        end
+
+        # Capture all bad configuration calls and save them for an error
+        # message later during validation.
+        def method_missing(name, *args, &block)
+          return super if @__finalized
+
+          # There are a few scenarios where ruby will attempt to implicity
+          # coerce a given object into a certain type. Configs 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 Config back, Ruby will raise a
+          # TypeError. Doing the normal thing of raising NoMethodError allows
+          # Config 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
+
+          name = name.to_s
+          name = name[0...-1] if name.end_with?("=")
+
+          @__invalid_methods ||= Set.new
+          @__invalid_methods.add(name)
+
+          # Return the dummy object so that anything else works
+          ::Vagrant::Config::V2::DummyConfig.new
+        end
+
+        # Allows setting options from a hash. By default this simply calls
+        # the `#{key}=` method on the config class with the value, which is
+        # the expected behavior most of the time.
+        #
+        # This is expected to mutate itself.
+        #
+        # @param [Hash] options A hash of options to set on this configuration
+        #   key.
+        def set_options(options)
+          options.each do |key, value|
+            send("#{key}=", value)
+          end
+        end
+
+        # Converts this configuration object to JSON.
+        def to_json(*a)
+          instance_variables_hash.to_json(*a)
+        end
+
+        # A default to_s implementation.
+        def to_s
+          self.class.to_s
+        end
+
+        # Returns the instance variables as a hash of key-value pairs.
+        def instance_variables_hash
+          instance_variables.inject({}) do |acc, iv|
+            acc[iv.to_s[1..-1]] = instance_variable_get(iv)
+            acc
+          end
+        end
+
+        # Called after the configuration is finalized and loaded to validate
+        # this object.
+        #
+        # @param [Machine] machine Access to the machine that is being
+        #   validated.
+        # @return [Hash]
+        def validate(machine)
+          return { self.to_s => _detected_errors }
+        end
+
+        # This returns any automatically detected errors.
+        #
+        # @return [Array<String>]
+        def _detected_errors
+          return [] if !@__invalid_methods || @__invalid_methods.empty?
+          return [I18n.t("vagrant.config.common.bad_field",
+                         fields: @__invalid_methods.to_a.sort.join(", "))]
+        end
+
+        # An internal finalize call that no subclass should override.
+        def _finalize!
+          @__finalized = true
+        end
+
+        def clean_up_config_object(config)
+          # Remote variables that are internal
+          config.delete_if{|k,_| k.start_with?("_") }
+          config
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/errors.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# This file contains all the errors that the V2 plugin interface
+# may throw.
+
+module Vagrant
+  module Plugin
+    module V2
+      # Exceptions that can be thrown within the plugin interface all
+      # inherit from this parent exception.
+      class Error < StandardError; end
+
+      # This is thrown when a command name given is invalid.
+      class InvalidCommandName < Error; end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/guest.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Plugin
+    module V2
+      # A base class for a guest OS. A guest OS is responsible for detecting
+      # that the guest operating system running within the machine. The guest
+      # can then be extended with various "guest capabilities" which are their
+      # own form of plugin.
+      #
+      # The guest class itself is only responsible for detecting itself,
+      # and may provide helpers for the capabilities.
+      class Guest
+        # This method is called when the machine is booted and has communication
+        # capabilities in order to detect whether this guest operating system
+        # is running within the machine.
+        #
+        # @return [Boolean]
+        def detect?(machine)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/host.rb

@@ -0,0 +1,22 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Plugin
+    module V2
+      # Base class for a host in Vagrant. A host class contains functionality
+      # that is specific to a specific OS that is running Vagrant. This
+      # abstraction is done because there is some host-specific logic that
+      # Vagrant must do in some cases.
+      class Host
+        # This returns true/false depending on if the current running system
+        # matches the host class.
+        #
+        # @return [Boolean]
+        def detect?(env)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/manager.rb

@@ -0,0 +1,306 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Plugin
+    module V2
+      # This class maintains a list of all the registered plugins as well
+      # as provides methods that allow querying all registered components of
+      # those plugins as a single unit.
+      class Manager
+        attr_reader :registered
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::plugin::v2::manager")
+          @registered = []
+        end
+
+        # This returns all the action hooks.
+        #
+        # @return [Array]
+        def action_hooks(hook_name)
+          result = []
+
+          @registered.each do |plugin|
+            result += plugin.components.action_hooks[Plugin::ALL_ACTIONS]
+            result += plugin.components.action_hooks[hook_name]
+          end
+
+          result
+        end
+
+        # Find all hooks that are applicable for the given key. This
+        # lookup does not include hooks which are defined for ALL_ACTIONS.
+        # Key lookups will match on either string or symbol values. The
+        # provided keys is broken down into multiple parts for lookups,
+        # which allows defining hooks with an entire namespaced name,
+        # or a short suffx. For example:
+        #
+        #  Assume we are given an action class
+        #    key = Vagrant::Action::Builtin::SyncedFolders
+        #
+        #  The list of keys that will be checked for hooks:
+        #    ["Vagrant::Action::Builtin::SyncedFolders", "vagrant_action_builtin_synced_folders",
+        #     "Action::Builtin::SyncedFolders", "action_builtin_synced_folders",
+        #     "Builtin::SyncedFolders", "builtin_synced_folders",
+        #     "SyncedFolders", "synced_folders"]
+        #
+        # @param key [Class, String] key Key for hook lookups
+        # @return [Array<Proc>]
+        def find_action_hooks(key)
+          result = []
+
+          generate_hook_keys(key).each do |k|
+            @registered.each do |plugin|
+              result += plugin.components.action_hooks[k]
+              result += plugin.components.action_hooks[k.to_sym]
+            end
+          end
+
+          result
+        end
+
+        # Generate all valid lookup keys for given key
+        #
+        # @param [Class, String] key Base key for generation
+        # @return [Array<String>] all valid keys
+        def generate_hook_keys(key)
+          if key.is_a?(Class)
+            key = key.name.to_s
+          else
+            key = key.to_s
+          end
+          parts = key.split("::")
+          [].tap do |keys|
+            until parts.empty?
+              x = parts.join("::")
+              keys << x
+              y = x.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('::', '_').downcase
+              keys << y if x != y
+              parts.shift
+            end
+          end
+        end
+
+        # This returns all the registered commands.
+        #
+        # @return [Registry<Symbol, Array<Proc, Hash>>]
+        def commands
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.commands)
+            end
+          end
+        end
+
+        # This returns all the registered communicators.
+        #
+        # @return [Hash]
+        def communicators
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.communicator)
+            end
+          end
+        end
+
+        # This returns all the registered configuration classes.
+        #
+        # @return [Hash]
+        def config
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.configs[:top])
+            end
+          end
+        end
+
+        # This returns all the registered guests.
+        #
+        # @return [Hash]
+        def guests
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.guests)
+            end
+          end
+        end
+
+        # This returns all the registered guest capabilities.
+        #
+        # @return [Hash]
+        def guest_capabilities
+          results = Hash.new { |h, k| h[k] = Registry.new }
+
+          @registered.each do |plugin|
+            plugin.components.guest_capabilities.each do |guest, caps|
+              results[guest].merge!(caps)
+            end
+          end
+
+          results
+        end
+
+        # This returns all the registered guests.
+        #
+        # @return [Hash]
+        def hosts
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.hosts)
+            end
+          end
+        end
+
+        # This returns all the registered host capabilities.
+        #
+        # @return [Hash]
+        def host_capabilities
+          results = Hash.new { |h, k| h[k] = Registry.new }
+
+          @registered.each do |plugin|
+            plugin.components.host_capabilities.each do |host, caps|
+              results[host].merge!(caps)
+            end
+          end
+
+          results
+        end
+
+        # This returns all registered providers.
+        #
+        # @return [Hash]
+        def providers
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.providers)
+            end
+          end
+        end
+
+        # This returns all the registered provider capabilities.
+        #
+        # @return [Hash]
+        def provider_capabilities
+          results = Hash.new { |h, k| h[k] = Registry.new }
+
+          @registered.each do |plugin|
+            plugin.components.provider_capabilities.each do |provider, caps|
+              results[provider].merge!(caps)
+            end
+          end
+
+          results
+        end
+
+        # This returns all the config classes for the various providers.
+        #
+        # @return [Hash]
+        def provider_configs
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.configs[:provider])
+            end
+          end
+        end
+
+        # This returns all the config classes for the various provisioners.
+        #
+        # @return [Registry]
+        def provisioner_configs
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.configs[:provisioner])
+            end
+          end
+        end
+
+        # This returns all registered provisioners.
+        #
+        # @return [Hash]
+        def provisioners
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.provisioner)
+            end
+          end
+        end
+
+        # This returns all registered pushes.
+        #
+        # @return [Registry]
+        def pushes
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.pushes)
+            end
+          end
+        end
+
+        # This returns all the config classes for the various pushes.
+        #
+        # @return [Registry]
+        def push_configs
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.configs[:push])
+            end
+          end
+        end
+
+        # This returns all synced folder implementations.
+        #
+        # @return [Registry]
+        def synced_folders
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.synced_folders)
+            end
+          end
+        end
+        
+        # This returns all the registered synced folder capabilities.
+        #
+        # @return [Hash]
+        def synced_folder_capabilities
+          results = Hash.new { |h, k| h[k] = Registry.new }
+
+          @registered.each do |plugin|
+            plugin.components.synced_folder_capabilities.each do |synced_folder, caps|
+              results[synced_folder].merge!(caps)
+            end
+          end
+
+          results
+        end
+        # This registers a plugin. This should _NEVER_ be called by the public
+        # and should only be called from within Vagrant. Vagrant will
+        # automatically register V2 plugins when a name is set on the
+        # plugin.
+        def register(plugin)
+          if !@registered.include?(plugin)
+            @logger.info("Registered plugin: #{plugin.name}")
+            @registered << plugin
+          end
+        end
+
+        # This clears out all the registered plugins. This is only used by
+        # unit tests and should not be called directly.
+        def reset!
+          @registered.clear
+        end
+
+        # This unregisters a plugin so that its components will no longer
+        # be used. Note that this should only be used for testing purposes.
+        def unregister(plugin)
+          if @registered.include?(plugin)
+            @logger.info("Unregistered: #{plugin.name}")
+            @registered.delete(plugin)
+          end
+        end
+      end
+    end
+  end
+end