tnargav 1.3.5 → 1.3.6

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

@@ -0,0 +1,15 @@
+# This file contains all the errors that the V1 plugin interface
+# may throw.
+
+module Vagrant
+  module Plugin
+    module V1
+      # 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/v1/guest.rb

@@ -0,0 +1,92 @@
+module Vagrant
+  module Plugin
+    module V1
+      # The base class for a guest. A guest represents an installed system
+      # within a machine that Vagrant manages. There are some portions of
+      # Vagrant which are OS-specific such as mountaing shared folders and
+      # halting the machine, and this abstraction allows the implementation
+      # for these to be seperate from the core of Vagrant.
+      class Guest
+        class BaseError < Errors::VagrantError
+          error_namespace("vagrant.guest.base")
+        end
+
+        include Vagrant::Util
+
+        # The VM which this system is tied to.
+        attr_reader :vm
+
+        # Initializes the system. Any subclasses MUST make sure this
+        # method is called on the parent. Therefore, if a subclass overrides
+        # `initialize`, then you must call `super`.
+        def initialize(vm)
+          @vm = vm
+        end
+
+        # This method is automatically called when the system is available (when
+        # Vagrant can successfully SSH into the machine) to give the system a chance
+        # to determine the distro and return a distro-specific system.
+        #
+        # If this method returns nil, then this instance is assumed to be
+        # the most specific guest implementation.
+        def distro_dispatch
+        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/v1/host.rb

@@ -0,0 +1,66 @@
+module Vagrant
+  module Plugin
+    module V1
+      # 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/v1/manager.rb

@@ -0,0 +1,131 @@
+require "log4r"
+
+module Vagrant
+  module Plugin
+    module V1
+      # 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::v1::manager")
+          @registered = []
+        end
+
+        # This returns all the registered communicators.
+        #
+        # @return [Hash]
+        def communicators
+          result = {}
+
+          @registered.each do |plugin|
+            result.merge!(plugin.communicator.to_hash)
+          end
+
+          result
+        end
+
+        # This returns all the registered configuration classes.
+        #
+        # @return [Hash]
+        def config
+          result = {}
+
+          @registered.each do |plugin|
+            plugin.config.each do |key, klass|
+              result[key] = klass
+            end
+          end
+
+          result
+        end
+
+        # This returns all the registered configuration classes that were
+        # marked as "upgrade safe."
+        #
+        # @return [Hash]
+        def config_upgrade_safe
+          result = {}
+
+          @registered.each do |plugin|
+            configs = plugin.data[:config_upgrade_safe]
+            if configs
+              configs.each do |key|
+                result[key] = plugin.config.get(key)
+              end
+            end
+          end
+
+          result
+        end
+
+        # This returns all the registered guests.
+        #
+        # @return [Hash]
+        def guests
+          result = {}
+
+          @registered.each do |plugin|
+            result.merge!(plugin.guest.to_hash)
+          end
+
+          result
+        end
+
+        # This returns all registered host classes.
+        #
+        # @return [Hash]
+        def hosts
+          hosts = {}
+
+          @registered.each do |plugin|
+            hosts.merge!(plugin.host.to_hash)
+          end
+
+          hosts
+        end
+
+        # This returns all registered providers.
+        #
+        # @return [Hash]
+        def providers
+          providers = {}
+
+          @registered.each do |plugin|
+            providers.merge!(plugin.provider.to_hash)
+          end
+
+          providers
+        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 V1 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

data/lib/vagrant/plugin/v1/plugin.rb

@@ -0,0 +1,229 @@
+require "set"
+
+require "log4r"
+
+module Vagrant
+  module Plugin
+    module V1
+      # This is the superclass for all V1 plugins.
+      class Plugin
+        # Special marker that can be used for action hooks that matches
+        # all action sequences.
+        ALL_ACTIONS = :__all_actions__
+
+        # The logger for this class.
+        LOGGER = Log4r::Logger.new("vagrant::plugin::v1::plugin")
+
+        # Set the root class up to be ourself, so that we can reference this
+        # from within methods which are probably in subclasses.
+        ROOT_CLASS = self
+
+        # This returns the manager for all V1 plugins.
+        #
+        # @return [V1::Manager]
+        def self.manager
+          @manager ||= Manager.new
+        end
+
+        # Set the name of the plugin. The moment that this is called, the
+        # plugin will be registered and available. Before this is called, a
+        # plugin does not exist. The name must be unique among all installed
+        # plugins.
+        #
+        # @param [String] name Name of the plugin.
+        # @return [String] The name of the plugin.
+        def self.name(name=UNSET_VALUE)
+          # Get or set the value first, so we have a name for logging when
+          # we register.
+          result = get_or_set(:name, name)
+
+          # The plugin should be registered if we're setting a real name on it
+          Plugin.manager.register(self) if name != UNSET_VALUE
+
+          # Return the result
+          result
+        end
+
+        # Sets a human-friendly descrition of the plugin.
+        #
+        # @param [String] value Description of the plugin.
+        # @return [String] Description of the plugin.
+        def self.description(value=UNSET_VALUE)
+          get_or_set(:description, value)
+        end
+
+        # Registers a callback to be called when a specific action sequence
+        # is run. This allows plugin authors to hook into things like VM
+        # bootup, VM provisioning, etc.
+        #
+        # @param [Symbol] name Name of the action.
+        # @return [Array] List of the hooks for the given action.
+        def self.action_hook(name, &block)
+          # Get the list of hooks for the given hook name
+          data[:action_hooks] ||= {}
+          hooks = data[:action_hooks][name.to_sym] ||= []
+
+          # Return the list if we don't have a block
+          return hooks if !block_given?
+
+          # Otherwise add the block to the list of hooks for this action.
+          hooks << block
+        end
+
+        # Defines additional command line commands available by key. The key
+        # becomes the subcommand, so if you register a command "foo" then
+        # "vagrant foo" becomes available.
+        #
+        # @param [String] name Subcommand key.
+        def self.command(name=UNSET_VALUE, &block)
+          data[:command] ||= Registry.new
+
+          if name != UNSET_VALUE
+            # Validate the name of the command
+            if name.to_s !~ /^[-a-z0-9]+$/i
+              raise InvalidCommandName, "Commands can only contain letters, numbers, and hyphens"
+            end
+
+            # Register a new command class only if a name was given.
+            data[:command].register(name.to_sym, &block)
+          end
+
+          # Return the registry
+          data[:command]
+        end
+
+        # Defines additional communicators to be available. Communicators
+        # should be returned by a block passed to this method. This is done
+        # to ensure that the class is lazy loaded, so if your class inherits
+        # from or uses any Vagrant internals specific to Vagrant 1.0, then
+        # the plugin can still be defined without breaking anything in future
+        # versions of Vagrant.
+        #
+        # @param [String] name Communicator name.
+        def self.communicator(name=UNSET_VALUE, &block)
+          data[:communicator] ||= Registry.new
+
+          # Register a new communicator class only if a name was given.
+          data[:communicator].register(name.to_sym, &block) if name != UNSET_VALUE
+
+          # Return the registry
+          data[:communicator]
+        end
+
+        # Defines additional configuration keys to be available in the
+        # Vagrantfile. The configuration class should be returned by a
+        # block passed to this method. This is done to ensure that the class
+        # is lazy loaded, so if your class inherits from any classes that
+        # are specific to Vagrant 1.0, then the plugin can still be defined
+        # without breaking anything in future versions of Vagrant.
+        #
+        # @param [String] name Configuration key.
+        # @param [Boolean] upgrade_safe If this is true, then this configuration
+        #   key is safe to load during an upgrade, meaning that it depends
+        #   on NO Vagrant internal classes. Do _not_ set this to true unless
+        #   you really know what you're doing, since you can cause Vagrant
+        #   to crash (although Vagrant will output a user-friendly error
+        #   message if this were to happen).
+        def self.config(name=UNSET_VALUE, upgrade_safe=false, &block)
+          data[:config] ||= Registry.new
+
+          # Register a new config class only if a name was given.
+          if name != UNSET_VALUE
+            data[:config].register(name.to_sym, &block)
+
+            # If we were told this is an upgrade safe configuration class
+            # then we add it to the set.
+            if upgrade_safe
+              data[:config_upgrade_safe] ||= Set.new
+              data[:config_upgrade_safe].add(name.to_sym)
+            end
+          end
+
+          # Return the registry
+          data[:config]
+        end
+
+        # Defines an additionally available guest implementation with
+        # the given key.
+        #
+        # @param [String] name Name of the guest.
+        def self.guest(name=UNSET_VALUE, &block)
+          data[:guests] ||= Registry.new
+
+          # Register a new guest class only if a name was given
+          data[:guests].register(name.to_sym, &block) if name != UNSET_VALUE
+
+          # Return the registry
+          data[:guests]
+        end
+
+        # Defines an additionally available host implementation with
+        # the given key.
+        #
+        # @param [String] name Name of the host.
+        def self.host(name=UNSET_VALUE, &block)
+          data[:hosts] ||= Registry.new
+
+          # Register a new host class only if a name was given
+          data[:hosts].register(name.to_sym, &block) if name != UNSET_VALUE
+
+          # Return the registry
+          data[:hosts]
+        end
+
+        # Registers additional providers to be available.
+        #
+        # @param [Symbol] name Name of the provider.
+        def self.provider(name=UNSET_VALUE, &block)
+          data[:providers] ||= Registry.new
+
+          # Register a new provider class only if a name was given
+          data[:providers].register(name.to_sym, &block) if name != UNSET_VALUE
+
+          # Return the registry
+          data[:providers]
+        end
+
+        # Registers additional provisioners to be available.
+        #
+        # @param [String] name Name of the provisioner.
+        def self.provisioner(name=UNSET_VALUE, &block)
+          data[:provisioners] ||= Registry.new
+
+          # Register a new provisioner class only if a name was given
+          data[:provisioners].register(name.to_sym, &block) if name != UNSET_VALUE
+
+          # Return the registry
+          data[:provisioners]
+        end
+
+        # Returns the internal data associated with this plugin. This
+        # should NOT be called by the general public.
+        #
+        # @return [Hash]
+        def self.data
+          @data ||= {}
+        end
+
+        protected
+
+        # Sentinel value denoting that a value has not been set.
+        UNSET_VALUE = Object.new
+
+        # Helper method that will set a value if a value is given, or otherwise
+        # return the already set value.
+        #
+        # @param [Symbol] key Key for the data
+        # @param [Object] value Value to store.
+        # @return [Object] Stored value.
+        def self.get_or_set(key, value=UNSET_VALUE)
+          # If no value is to be set, then return the value we have already set
+          return data[key] if value.eql?(UNSET_VALUE)
+
+          # Otherwise set the value
+          data[key] = value
+        end
+      end
+    end
+  end
+end