vagrant-lxc 0.0.1 → 0.0.2

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

@@ -1,217 +0,0 @@
-require "set"
-
-require "log4r"
-
-require "vagrant/plugin/v2/components"
-
-module Vagrant
-  module Plugin
-    module V2
-      # This is the superclass for all V2 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::v2::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 V2 plugins.
-        #
-        # @return [V2::Manager]
-        def self.manager
-          @manager ||= Manager.new
-        end
-
-        # Returns the {Components} for this plugin.
-        #
-        # @return [Components]
-        def self.components
-          @components ||= Components.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 [String] name Name of the action.
-        # @param [Symbol] hook_name The location to hook. If this isn't
-        #   set, every middleware action is hooked.
-        # @return [Array] List of the hooks for the given action.
-        def self.action_hook(name, hook_name=nil, &block)
-          # The name is currently not used but we want it for the future.
-
-          hook_name ||= ALL_ACTIONS
-          components.action_hooks[hook_name] << 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.
-        # XXX: Document options hash
-        def self.config(name, scope=nil, &block)
-          scope ||= :top
-          components.configs[scope].register(name.to_sym, &block)
-          nil
-        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

data/vendor/vagrant/lib/vagrant/plugin/v2/provider.rb

@@ -1,69 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      # This is the base class for a provider for the V2 API. A provider
-      # is responsible for creating compute resources to match the needs
-      # of a Vagrant-configured system.
-      class Provider
-        # Initialize the provider to represent the given machine.
-        #
-        # @param [Vagrant::Machine] machine The machine that this provider
-        #   is responsible for.
-        def initialize(machine)
-        end
-
-        # This should return an action callable for the given name.
-        #
-        # @param [Symbol] name Name of the action.
-        # @return [Object] A callable action sequence object, whether it
-        #   is a proc, object, etc.
-        def action(name)
-          nil
-        end
-
-        # This method is called if the underying machine ID changes. Providers
-        # can use this method to load in new data for the actual backing
-        # machine or to realize that the machine is now gone (the ID can
-        # become `nil`). No parameters are given, since the underlying machine
-        # is simply the machine instance given to this object. And no
-        # return value is necessary.
-        def machine_id_changed
-        end
-
-        # This should return a hash of information that explains how to
-        # SSH into the machine. If the machine is not at a point where
-        # SSH is even possible, then `nil` should be returned.
-        #
-        # The general structure of this returned hash should be the
-        # following:
-        #
-        #     {
-        #       :host => "1.2.3.4",
-        #       :port => "22",
-        #       :username => "mitchellh",
-        #       :private_key_path => "/path/to/my/key"
-        #     }
-        #
-        # **Note:** Vagrant only supports private key based authentication,
-        # mainly for the reason that there is no easy way to exec into an
-        # `ssh` prompt with a password, whereas we can pass a private key
-        # via commandline.
-        #
-        # @return [Hash] SSH information. For the structure of this hash
-        #   read the accompanying documentation for this method.
-        def ssh_info
-          nil
-        end
-
-        # This should return the state of the machine within this provider.
-        # The state must be an instance of {MachineState}. Please read the
-        # documentation of that class for more information.
-        #
-        # @return [MachineState]
-        def state
-          nil
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/plugin/v2/provisioner.rb

@@ -1,47 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      # This is the base class for a provisioner for the V2 API. A provisioner
-      # is primarily responsible for installing software on a Vagrant guest.
-      class Provisioner
-        attr_reader :machine
-        attr_reader :config
-
-        # Initializes the provisioner with the machine that it will be
-        # provisioning along with the provisioner configuration (if there
-        # is any).
-        #
-        # The provisioner should _not_ do anything at this point except
-        # initialize internal state.
-        #
-        # @param [Machine] machine The machine that this will be provisioning.
-        # @param [Object] config Provisioner configuration, if one was set.
-        def initialize(machine, config)
-          @machine = machine
-          @config  = config
-        end
-
-        # Called with the root configuration of the machine so the provisioner
-        # can add some configuration on top of the machine.
-        #
-        # During this step, and this step only, the provisioner should modify
-        # the root machine configuration to add any additional features it
-        # may need. Examples include sharing folders, networking, and so on.
-        # This step is guaranteed to be called before any of those steps are
-        # done so the provisioner may do that.
-        #
-        # No return value is expected.
-        def configure(root_config)
-        end
-
-        # This is the method called when the actual provisioning should be
-        # done. The communicator is guaranteed to be ready at this point,
-        # and any shared folders or networks are already setup.
-        #
-        # No return value is expected.
-        def provision
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require "log4r"
-
-# We don't autoload components because if we're loading anything in the
-# V2 namespace anyways, then we're going to need the Components class.
-require "vagrant/plugin/v2/components"
-require "vagrant/plugin/v2/errors"
-
-module Vagrant
-  module Plugin
-    module V2
-      autoload :Command, "vagrant/plugin/v2/command"
-      autoload :Communicator, "vagrant/plugin/v2/communicator"
-      autoload :Config, "vagrant/plugin/v2/config"
-      autoload :Guest,  "vagrant/plugin/v2/guest"
-      autoload :Host,   "vagrant/plugin/v2/host"
-      autoload :Manager, "vagrant/plugin/v2/manager"
-      autoload :Plugin, "vagrant/plugin/v2/plugin"
-      autoload :Provider, "vagrant/plugin/v2/provider"
-      autoload :Provisioner, "vagrant/plugin/v2/provisioner"
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-module Vagrant
-  module Plugin
-    autoload :V1, "vagrant/plugin/v1"
-    autoload :V2, "vagrant/plugin/v2"
-  end
-end

data/vendor/vagrant/lib/vagrant/registry.rb

@@ -1,78 +0,0 @@
-module Vagrant
-  # Register components in a single location that can be queried.
-  #
-  # This allows certain components (such as guest systems, configuration
-  # pieces, etc.) to be registered and queried, lazily.
-  class Registry
-    def initialize
-      @items = {}
-      @results_cache = {}
-    end
-
-    # Register a key with a lazy-loaded value.
-    #
-    # If a key with the given name already exists, it is overwritten.
-    def register(key, &block)
-      raise ArgumentError, "block required" if !block_given?
-      @items[key] = block
-    end
-
-    # Get a value by the given key.
-    #
-    # This will evaluate the block given to `register` and return the
-    # resulting value.
-    def get(key)
-      return nil if !@items.has_key?(key)
-      return @results_cache[key] if @results_cache.has_key?(key)
-      @results_cache[key] = @items[key].call
-    end
-    alias :[] :get
-
-    # Checks if the given key is registered with the registry.
-    #
-    # @return [Boolean]
-    def has_key?(key)
-      @items.has_key?(key)
-    end
-
-    # Iterate over the keyspace.
-    def each(&block)
-      @items.each do |key, _|
-        yield key, get(key)
-      end
-    end
-
-    # Merge one registry with another and return a completely new
-    # registry. Note that the result cache is completely busted, so
-    # any gets on the new registry will result in a cache miss.
-    def merge(other)
-      self.class.new.tap do |result|
-        result.merge!(self)
-        result.merge!(other)
-      end
-    end
-
-    # Like #{merge} but merges into self.
-    def merge!(other)
-      @items.merge!(other.__internal_state[:items])
-      self
-    end
-
-    # Converts this registry to a hash
-    def to_hash
-      result = {}
-      self.each do |key, value|
-        result[key] = value
-      end
-
-      result
-    end
-
-    def __internal_state
-      {
-        :items => @items,
-        :results_cache => @results_cache
-      }
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/ssh.rb

@@ -1,132 +0,0 @@
-require 'log4r'
-
-require 'vagrant/util/file_util'
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-require 'vagrant/util/safe_exec'
-
-module Vagrant
-  # Manages SSH connection information as well as allows opening an
-  # SSH connection.
-  class SSH
-    include Util::SafeExec
-
-    def initialize(vm)
-      @vm     = vm
-      @logger = Log4r::Logger.new("vagrant::ssh")
-    end
-
-    # Returns a hash of information necessary for accessing this
-    # virtual machine via SSH.
-    #
-    # @return [Hash]
-    def info
-      results = {
-        :host          => @vm.config.ssh.host,
-        :port          => @vm.config.ssh.port || @vm.driver.ssh_port(@vm.config.ssh.guest_port),
-        :username      => @vm.config.ssh.username,
-        :forward_agent => @vm.config.ssh.forward_agent,
-        :forward_x11   => @vm.config.ssh.forward_x11
-      }
-
-      # This can happen if no port is set and for some reason Vagrant
-      # can't detect an SSH port.
-      raise Errors::SSHPortNotDetected if !results[:port]
-
-      # Determine the private key path, which is either set by the
-      # configuration or uses just the built-in insecure key.
-      pk_path = @vm.config.ssh.private_key_path || @vm.env.default_private_key_path
-      results[:private_key_path] = File.expand_path(pk_path, @vm.env.root_path)
-
-      # We need to check and fix the private key permissions
-      # to make sure that SSH gets a key with 0600 perms.
-      check_key_permissions(results[:private_key_path])
-
-      # Return the results
-      return results
-    end
-
-    # Connects to the environment's virtual machine, replacing the ruby
-    # process with an SSH process.
-    #
-    # @param [Hash] opts Options hash
-    # @options opts [Boolean] :plain_mode If True, doesn't authenticate with
-    #   the machine, only connects, allowing the user to connect.
-    def exec(opts={})
-      # Get the SSH information and cache it here
-      ssh_info = info
-
-      # Ensure the platform supports ssh. On Windows there are several programs which
-      # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
-      if !Util::FileUtil.which("ssh")
-        if Util::Platform.windows?
-          raise Errors::SSHUnavailableWindows, :host => ssh_info[:host],
-                                               :port => ssh_info[:port],
-                                               :username => ssh_info[:username],
-                                               :key_path => ssh_info[:private_key_path]
-        end
-        raise Errors::SSHUnavailable 
-      end
-
-      # If plain mode is enabled then we don't do any authentication (we don't
-      # set a user or an identity file)
-      plain_mode = opts[:plain_mode]
-
-      options = {}
-      options[:host] = ssh_info[:host]
-      options[:port] = ssh_info[:port]
-      options[:username] = ssh_info[:username]
-      options[:private_key_path] = ssh_info[:private_key_path]
-
-      # Command line options
-      command_options = ["-p", options[:port].to_s, "-o", "UserKnownHostsFile=/dev/null",
-                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=QUIET"]
-
-      # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the IdentitiesOnly option
-      # (Also don't use it in plain mode, it'll skip user agents.)
-      command_options += ["-o", "IdentitiesOnly=yes"] if !(Util::Platform.solaris? || plain_mode)
-
-      command_options += ["-i", options[:private_key_path]] if !plain_mode
-      command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
-
-      # If there are extra options, then we append those
-      command_options.concat(opts[:extra_args]) if opts[:extra_args]
-
-      if ssh_info[:forward_x11]
-        # Both are required so that no warnings are shown regarding X11
-        command_options += ["-o", "ForwardX11=yes"]
-        command_options += ["-o", "ForwardX11Trusted=yes"]
-      end
-
-      host_string = options[:host]
-      host_string = "#{options[:username]}@#{host_string}" if !plain_mode
-      command_options << host_string
-      @logger.info("Invoking SSH: #{command_options.inspect}")
-      safe_exec("ssh", *command_options)
-    end
-
-    # Checks the file permissions for a private key, resetting them
-    # if needed.
-    def check_key_permissions(key_path)
-      # Windows systems don't have this issue
-      return if Util::Platform.windows?
-
-      @logger.debug("Checking key permissions: #{key_path}")
-      stat = File.stat(key_path)
-
-      if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
-        @logger.info("Attempting to correct key permissions to 0600")
-        File.chmod(0600, key_path)
-
-        stat = File.stat(key_path)
-        if Util::FileMode.from_octal(stat.mode) != "600"
-          raise Errors::SSHKeyBadPermissions, :key_path => key_path
-        end
-      end
-    rescue Errno::EPERM
-      # This shouldn't happen since we verified we own the file, but
-      # it is possible in theory, so we raise an error.
-      raise Errors::SSHKeyBadPermissions, :key_path => key_path
-    end
-  end
-end