tnargav 1.2.2

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

@@ -0,0 +1,47 @@
+module Vagrant
+  module Plugin
+    module V2
+      # This is the container class for the components of a single plugin.
+      # This allows us to separate the plugin class which defines the
+      # components, and the actual container of those components. This
+      # removes a bit of state overhead from the plugin class itself.
+      class Components
+        # This contains all the action hooks.
+        #
+        # @return [Hash<Symbol, Array>]
+        attr_reader :action_hooks
+
+        # This contains all the configuration plugins by scope.
+        #
+        # @return [Hash<Symbol, Registry>]
+        attr_reader :configs
+
+        # This contains all the guests and their parents.
+        #
+        # @return [Registry<Symbol, Array<Class, Symbol>>]
+        attr_reader :guests
+
+        # This contains all the registered guest capabilities.
+        #
+        # @return [Hash<Symbol, Registry>]
+        attr_reader :guest_capabilities
+
+        # This contains all the provider plugins by name, and returns
+        # the provider class and options.
+        #
+        # @return [Hash<Symbol, Registry>]
+        attr_reader :providers
+
+        def initialize
+          # The action hooks hash defaults to []
+          @action_hooks = Hash.new { |h, k| h[k] = [] }
+
+          @configs = Hash.new { |h, k| h[k] = Registry.new }
+          @guests  = Registry.new
+          @guest_capabilities = Hash.new { |h, k| h[k] = Registry.new }
+          @providers = Registry.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+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 = Object.new
+
+        # 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)
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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,78 @@
+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 capabilties.
+      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 guest?(machine)
+          false
+        end
+
+        # Halt the machine. This method should gracefully shut down the
+        # operating system. This method will cause `vagrant halt` and associated
+        # commands to _block_, meaning that if the machine doesn't halt
+        # in a reasonable amount of time, this method should just return.
+        #
+        # If when this method returns, the machine's state isn't "powered_off,"
+        # Vagrant will proceed to forcefully shut the machine down.
+        def halt
+          raise BaseError, :_key => :unsupported_halt
+        end
+
+        # Mounts a shared folder.
+        #
+        # This method should create, mount, and properly set permissions
+        # on the shared folder. This method should also properly
+        # adhere to any configuration values such as `shared_folder_uid`
+        # on `config.vm`.
+        #
+        # @param [String] name The name of the shared folder.
+        # @param [String] guestpath The path on the machine which the user
+        #   wants the folder mounted.
+        # @param [Hash] options Additional options for the shared folder
+        #   which can be honored.
+        def mount_shared_folder(name, guestpath, options)
+          raise BaseError, :_key => :unsupported_shared_folder
+        end
+
+        # Mounts a shared folder via NFS. This assumes that the exports
+        # via the host are already done.
+        def mount_nfs(ip, folders)
+          raise BaseError, :_key => :unsupported_nfs
+        end
+
+        # Configures the given list of networks on the virtual machine.
+        #
+        # The networks parameter will be an array of hashes where the hashes
+        # represent the configuration of a network interface. The structure
+        # of the hash will be roughly the following:
+        #
+        # {
+        #   :type      => :static,
+        #   :ip        => "192.168.33.10",
+        #   :netmask   => "255.255.255.0",
+        #   :interface => 1
+        # }
+        #
+        def configure_networks(networks)
+          raise BaseError, :_key => :unsupported_configure_networks
+        end
+
+        # Called to change the hostname of the virtual machine.
+        def change_host_name(name)
+          raise BaseError, :_key => :unsupported_host_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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 becauase 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 self.match?
+          nil
+        end
+
+        # The precedence of the host when checking for matches. This is to
+        # allow certain host such as generic OS's ("Linux", "BSD", etc.)
+        # to be specified last.
+        #
+        # The hosts with the higher numbers will be checked first.
+        #
+        # If you're implementing a basic host, you can probably ignore this.
+        def self.precedence
+          5
+        end
+
+        # Initializes a new host class.
+        #
+        # The only required parameter is a UI object so that the host
+        # objects have some way to communicate with the outside world.
+        #
+        # @param [UI] ui UI for the hosts to output to.
+        def initialize(ui)
+          @ui = ui
+        end
+
+        # Returns true of false denoting whether or not this host supports
+        # NFS shared folder setup. This method ideally should verify that
+        # NFS is installed.
+        #
+        # @return [Boolean]
+        def nfs?
+          false
+        end
+
+        # Exports the given hash of folders via NFS.
+        #
+        # @param [String] id A unique ID that is guaranteed to be unique to
+        #   match these sets of folders.
+        # @param [String] ip IP of the guest machine.
+        # @param [Hash] folders Shared folders to sync.
+        def nfs_export(id, ip, folders)
+        end
+
+        # Prunes any NFS exports made by Vagrant which aren't in the set
+        # of valid ids given.
+        #
+        # @param [Array<String>] valid_ids Valid IDs that should not be
+        #   pruned.
+        def nfs_prune(valid_ids)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+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
+
+        # This returns all the registered commands.
+        #
+        # @return [Hash]
+        def commands
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.command)
+            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 registered host classes.
+        #
+        # @return [Hash]
+        def hosts
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.host)
+            end
+          end
+        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 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 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