vagrant-lxc 0.0.1 → 0.0.2

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

@@ -1,98 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # Base class for a communicator in Vagrant. A communicator is
-      # responsible for communicating with a machine in some way. There
-      # are various stages of Vagrant that require things such as uploading
-      # files to the machine, executing shell commands, etc. Implementors
-      # of this class are expected to provide this functionality in some
-      # way.
-      #
-      # Note that a communicator must provide **all** of the methods
-      # in this base class. There is currently no way for one communicator
-      # to provide say a more efficient way of uploading a file, but not
-      # provide shell execution. This sort of thing will come in a future
-      # version.
-      class Communicator
-        # This returns true/false depending on if the given machine
-        # can be communicated with using this communicator. If this returns
-        # `true`, then this class will be used as the primary communication
-        # method for the machine.
-        #
-        # @return [Boolean]
-        def self.match?(machine)
-          false
-        end
-
-        # Initializes the communicator with the machine that we will be
-        # communicating with. This base method does nothing (it doesn't
-        # even store the machine in an instance variable for you), so you're
-        # expected to override this and do something with the machine if
-        # you care about it.
-        #
-        # @param [Machine] machine The machine this instance is expected to
-        #   communicate with.
-        def initialize(machine)
-        end
-
-        # Checks if the target machine is ready for communication. If this
-        # returns true, then all the other methods for communicating with
-        # the machine are expected to be functional.
-        #
-        # @return [Boolean]
-        def ready?
-          false
-        end
-
-        # Download a file from the remote machine to the local machine.
-        #
-        # @param [String] from Path of the file on the remote machine.
-        # @param [String] to Path of where to save the file locally.
-        def download(from, to)
-        end
-
-        # Upload a file to the remote machine.
-        #
-        # @param [String] from Path of the file locally to upload.
-        # @param [String] to Path of where to save the file on the remote
-        #   machine.
-        def upload(from, to)
-        end
-
-        # Execute a command on the remote machine. The exact semantics
-        # of this method are up to the implementor, but in general the
-        # users of this class will expect this to be a shell.
-        #
-        # This method gives you no way to write data back to the remote
-        # machine, so only execute commands that don't expect input.
-        #
-        # @param [String] command Command to execute.
-        # @yield [type, data] Realtime output of the command being executed.
-        # @yieldparam [String] type Type of the output. This can be
-        #   `:stdout`, `:stderr`, etc. The exact types are up to the
-        #   implementor.
-        # @yieldparam [String] data Data for the given output.
-        # @return [Integer] Exit code of the command.
-        def execute(command, opts=nil)
-        end
-
-        # Executes a command on the remote machine with administrative
-        # privileges. See {#execute} for documentation, as the API is the
-        # same.
-        #
-        # @see #execute
-        def sudo(command, opts=nil)
-        end
-
-        # Executes a command and returns true if the command succeeded,
-        # and false otherwise. By default, this executes as a normal user,
-        # and it is up to the communicator implementation if they expose an
-        # option for running tests as an administrator.
-        #
-        # @see #execute
-        def test(command, opts=nil)
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a configuration key defined for
-      # V1. Any configuration key plugins for V1 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?("@__")
-                result.instance_variable_set(key, obj.instance_variable_get(key))
-              end
-            end
-          end
-
-          result
-        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
-
-        # 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
-
-        # This is called to upgrade this V1 config to V2. The parameter given
-        # is the full V2 configuration object, so you can do anything to it
-        # that you want.
-        #
-        # No return value is expected, modifications should be made directly
-        # to the new V2 object.
-        #
-        # @param [V2::Root] new
-        def upgrade(new)
-        end
-
-        # Called after the configuration is finalized and loaded to validate
-        # this object.
-        #
-        # @param [Environment] env Vagrant::Environment object of the
-        #   environment that this configuration has been loaded into. This
-        #   gives you convenient access to things like the the root path
-        #   and so on.
-        # @param [ErrorRecorder] errors
-        def validate(env, errors)
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# 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/vendor/vagrant/lib/vagrant/plugin/v1/guest.rb

@@ -1,92 +0,0 @@
-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/vendor/vagrant/lib/vagrant/plugin/v1/host.rb

@@ -1,66 +0,0 @@
-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/vendor/vagrant/lib/vagrant/plugin/v1/manager.rb

@@ -1,131 +0,0 @@
-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