vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/lib/vagrant/hosts.rb

@@ -1,28 +0,0 @@
-require 'log4r'
-
-module Vagrant
-  module Hosts
-    # This method detects the correct host based on the `match?` methods
-    # implemented in the registered hosts.
-    #
-    # @param [Hash] registry Hash mapping key to host class
-    def self.detect(registry)
-      logger = Log4r::Logger.new("vagrant::hosts")
-
-      # Sort the hosts by their precedence
-      host_klasses = registry.values.sort_by { |a| a.precedence }.reverse
-      logger.debug("Host path search classes: #{host_klasses.inspect}")
-
-      # Test for matches and return the host class that matches
-      host_klasses.each do |klass|
-        if klass.match?
-          logger.info("Host class: #{klass}")
-          return klass
-        end
-      end
-
-      # No matches found...
-      return nil
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/machine.rb

@@ -1,325 +0,0 @@
-require "log4r"
-
-module Vagrant
-  # This represents a machine that Vagrant manages. This provides a singular
-  # API for querying the state and making state changes to the machine, which
-  # is backed by any sort of provider (VirtualBox, VMWare, etc.).
-  class Machine
-    # The box that is backing this machine.
-    #
-    # @return [Box]
-    attr_reader :box
-
-    # Configuration for the machine.
-    #
-    # @return [Object]
-    attr_reader :config
-
-    # Directory where machine-specific data can be stored.
-    #
-    # @return [Pathname]
-    attr_reader :data_dir
-
-    # The environment that this machine is a part of.
-    #
-    # @return [Environment]
-    attr_reader :env
-
-    # ID of the machine. This ID comes from the provider and is not
-    # guaranteed to be of any particular format except that it is
-    # a string.
-    #
-    # @return [String]
-    attr_reader :id
-
-    # Name of the machine. This is assigned by the Vagrantfile.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # The provider backing this machine.
-    #
-    # @return [Object]
-    attr_reader :provider
-
-    # The provider-specific configuration for this machine.
-    #
-    # @return [Object]
-    attr_reader :provider_config
-
-    # The name of the provider.
-    #
-    # @return [Symbol]
-    attr_reader :provider_name
-
-    # Initialize a new machine.
-    #
-    # @param [String] name Name of the virtual machine.
-    # @param [Class] provider The provider backing this machine. This is
-    #   currently expected to be a V1 `provider` plugin.
-    # @param [Object] provider_config The provider-specific configuration for
-    #   this machine.
-    # @param [Object] config The configuration for this machine.
-    # @param [Pathname] data_dir The directory where machine-specific data
-    #   can be stored. This directory is ensured to exist.
-    # @param [Box] box The box that is backing this virtual machine.
-    # @param [Environment] env The environment that this machine is a
-    #   part of.
-    def initialize(name, provider_name, provider_cls, provider_config, config, data_dir, box, env, base=false)
-      @logger = Log4r::Logger.new("vagrant::machine")
-      @logger.info("Initializing machine: #{name}")
-      @logger.info("  - Provider: #{provider_cls}")
-      @logger.info("  - Box: #{box}")
-      @logger.info("  - Data dir: #{data_dir}")
-
-      @box             = box
-      @config          = config
-      @data_dir        = data_dir
-      @env             = env
-      @name            = name
-      @provider_config = provider_config
-      @provider_name   = provider_name
-
-      # Read the ID, which is usually in local storage
-      @id = nil
-
-      # XXX: This is temporary. This will be removed very soon.
-      if base
-        @id = name
-      else
-        # Read the id file from the data directory if it exists as the
-        # ID for the pre-existing physical representation of this machine.
-        id_file = @data_dir.join("id")
-        @id = id_file.read if id_file.file?
-      end
-
-      # Initializes the provider last so that it has access to all the
-      # state we setup on this machine.
-      @provider = provider_cls.new(self)
-    end
-
-    # This calls an action on the provider. The provider may or may not
-    # actually implement the action.
-    #
-    # @param [Symbol] name Name of the action to run.
-    # @param [Hash] extra_env This data will be passed into the action runner
-    #   as extra data set on the environment hash for the middleware
-    #   runner.
-    def action(name, extra_env=nil)
-      @logger.info("Calling action: #{name} on provider #{@provider}")
-
-      # Get the callable from the provider.
-      callable = @provider.action(name)
-
-      # If this action doesn't exist on the provider, then an exception
-      # must be raised.
-      if callable.nil?
-        raise Errors::UnimplementedProviderAction,
-          :action => name,
-          :provider => @provider.to_s
-      end
-
-      # Run the action with the action runner on the environment
-      env = {
-        :action_name    => "machine_action_#{name}".to_sym,
-        :machine        => self,
-        :machine_action => name,
-        :ui             => @env.ui_class.new(@name)
-      }.merge(extra_env || {})
-      @env.action_runner.run(callable, env)
-    end
-
-    # Returns a communication object for executing commands on the remote
-    # machine. Note that the _exact_ semantics of this are up to the
-    # communication provider itself. Despite this, the semantics are expected
-    # to be consistent across operating systems. For example, all linux-based
-    # systems should have similar communication (usually a shell). All
-    # Windows systems should have similar communication as well. Therefore,
-    # prior to communicating with the machine, users of this method are
-    # expected to check the guest OS to determine their behavior.
-    #
-    # This method will _always_ return some valid communication object.
-    # The `ready?` API can be used on the object to check if communication
-    # is actually ready.
-    #
-    # @return [Object]
-    def communicate
-      if !@communicator
-        # For now, we always return SSH. In the future, we'll abstract
-        # this and allow plugins to define new methods of communication.
-        klass = Vagrant.plugin("2").manager.communicators[:ssh]
-        @communicator = klass.new(self)
-      end
-
-      @communicator
-    end
-
-    # Returns a guest implementation for this machine. The guest implementation
-    # knows how to do guest-OS specific tasks, such as configuring networks,
-    # mounting folders, etc.
-    #
-    # @return [Object]
-    def guest
-      raise Errors::MachineGuestNotReady if !communicate.ready?
-
-      # Load the initial guest.
-      last_guest = config.vm.guest
-      guest      = load_guest(last_guest)
-
-      # Loop and distro dispatch while there are distros.
-      while true
-        distro = guest.distro_dispatch
-        break if !distro
-
-        # This is just some really basic loop detection and avoiding for
-        # guest classes. This is just here to help implementers a bit
-        # avoid a situation that is fairly easy, since if you subclass
-        # a parent which does `distro_dispatch`, you'll end up dispatching
-        # forever.
-        if distro == last_guest
-          @logger.warn("Distro dispatch loop in '#{distro}'. Exiting loop.")
-          break
-        end
-
-        last_guest = distro
-        guest      = load_guest(distro)
-      end
-
-      # Return the result
-      guest
-    end
-
-    # This sets the unique ID associated with this machine. This will
-    # persist this ID so that in the future Vagrant will be able to find
-    # this machine again. The unique ID must be absolutely unique to the
-    # virtual machine, and can be used by providers for finding the
-    # actual machine associated with this instance.
-    #
-    # **WARNING:** Only providers should ever use this method.
-    #
-    # @param [String] value The ID.
-    def id=(value)
-      # The file that will store the id if we have one. This allows the
-      # ID to persist across Vagrant runs.
-      id_file = @data_dir.join("id")
-
-      if value
-        # Write the "id" file with the id given.
-        id_file.open("w+") do |f|
-          f.write(value)
-        end
-      else
-        # Delete the file, since the machine is now destroyed
-        id_file.delete if id_file.file?
-      end
-
-      # Store the ID locally
-      @id = value
-
-      # Notify the provider that the ID changed in case it needs to do
-      # any accounting from it.
-      @provider.machine_id_changed
-    end
-
-    # This returns a clean inspect value so that printing the value via
-    # a pretty print (`p`) results in a readable value.
-    #
-    # @return [String]
-    def inspect
-      "#<#{self.class}: #{@name} (#{@provider.class})>"
-    end
-
-    # This returns the SSH info for accessing this machine. This SSH info
-    # is queried from the underlying provider. This method returns `nil` if
-    # the machine is not ready for SSH communication.
-    #
-    # The structure of the resulting hash is guaranteed to contain the
-    # following structure, although it may return other keys as well
-    # not documented here:
-    #
-    #     {
-    #       :host => "1.2.3.4",
-    #       :port => "22",
-    #       :username => "mitchellh",
-    #       :private_key_path => "/path/to/my/key"
-    #     }
-    #
-    # Note that Vagrant makes no guarantee that this info works or is
-    # correct. This is simply the data that the provider gives us or that
-    # is configured via a Vagrantfile. It is still possible after this
-    # point when attempting to connect via SSH to get authentication
-    # errors.
-    #
-    # @return [Hash] SSH information.
-    def ssh_info
-      # First, ask the provider for their information. If the provider
-      # returns nil, then the machine is simply not ready for SSH, and
-      # we return nil as well.
-      info = @provider.ssh_info
-      return nil if info.nil?
-
-      # Delete out the nil entries.
-      info.dup.each do |key, value|
-        info.delete(key) if value.nil?
-      end
-
-      # Next, we default some fields if they weren't given to us by
-      # the provider.
-      info[:host] ||= @config.ssh.host if @config.ssh.host
-      info[:port] ||= @config.ssh.port if @config.ssh.port
-      info[:username] ||= @config.ssh.username if @config.ssh.username
-
-      # We also set some fields that are purely controlled by Varant
-      info[:forward_agent] = @config.ssh.forward_agent
-      info[:forward_x11]   = @config.ssh.forward_x11
-
-      # Set the private key path. If a specific private key is given in
-      # the Vagrantfile we set that. Otherwise, we use the default (insecure)
-      # private key, but only if the provider didn't give us one.
-      if !info[:private_key_path]
-        if @config.ssh.private_key_path
-          info[:private_key_path] = @config.ssh.private_key_path
-        else
-          info[:private_key_path] = @env.default_private_key_path
-        end
-      end
-
-      # Expand the private key path relative to the root path
-      info[:private_key_path] = File.expand_path(info[:private_key_path], @env.root_path)
-
-      # Return the final compiled SSH info data
-      info
-    end
-
-    # Returns the state of this machine. The state is queried from the
-    # backing provider, so it can be any arbitrary symbol.
-    #
-    # @return [Symbol]
-    def state
-      result = @provider.state
-      raise Errors::MachineStateInvalid if !result.is_a?(MachineState)
-      result
-    end
-
-    protected
-
-    # Given a guest name (such as `:windows`), this will load the associated
-    # guest implementation and return an instance.
-    #
-    # @param [Symbol] guest The name of the guest implementation.
-    # @return [Object]
-    def load_guest(guest)
-      @logger.info("Loading guest: #{guest}")
-
-      klass = Vagrant.plugin("2").manager.guests[guest]
-
-      if klass.nil?
-        raise Errors::VMGuestError,
-          :_key  => :unknown_type,
-          :guest => guest.to_s
-      end
-
-      return klass.new(self)
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/machine_state.rb

@@ -1,45 +0,0 @@
-module Vagrant
-  # This represents the state of a given machine. This is a very basic
-  # class that simply stores a short and long description of the state
-  # of a machine.
-  #
-  # The state also stores a state "id" which ca be used as a unique
-  # identifier for a state. This should be a symbol. This allows internal
-  # code to compare state such as ":not_created" instead of using
-  # string comparison.
-  #
-  # The short description should be a single word description of the
-  # state of the machine such as "running" or "not created".
-  #
-  # The long description can span multiple lines describing what the
-  # state actually means.
-  class MachineState
-    # Unique ID for this state.
-    #
-    # @return [Symbol]
-    attr_reader :id
-
-    # Short description for this state.
-    #
-    # @return [String]
-    attr_reader :short_description
-
-    # Long description for this state.
-    #
-    # @return [String]
-    attr_reader :long_description
-
-    # Creates a new instance to represent the state of a machine.
-    #
-    # @param [Symbol] id Unique identifier for this state.
-    # @param [String] short Short (preferably one-word) description of
-    #   the state.
-    # @param [String] long Long description (can span multiple lines)
-    #   of the state.
-    def initialize(id, short, long)
-      @id                = id
-      @short_description = short
-      @long_description  = long
-    end
-  end
-end

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

@@ -1,169 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a CLI command.
-      class Command
-        include Util::SafePuts
-
-        def initialize(argv, env)
-          @argv = argv
-          @env  = env
-          @logger = Log4r::Logger.new("vagrant::command::#{self.class.to_s.downcase}")
-        end
-
-        # This is what is called on the class to actually execute it. Any
-        # subclasses should implement this method and do any option parsing
-        # and validation here.
-        def execute
-        end
-
-        protected
-
-        # Parses the options given an OptionParser instance.
-        #
-        # This is a convenience method that properly handles duping the
-        # originally argv array so that it is not destroyed.
-        #
-        # This method will also automatically detect "-h" and "--help"
-        # and print help. And if any invalid options are detected, the help
-        # will be printed, as well.
-        #
-        # If this method returns `nil`, then you should assume that help
-        # was printed and parsing failed.
-        def parse_options(opts=nil)
-          # Creating a shallow copy of the arguments so the OptionParser
-          # doesn't destroy the originals.
-          argv = @argv.dup
-
-          # Default opts to a blank optionparser if none is given
-          opts ||= OptionParser.new
-
-          # Add the help option, which must be on every command.
-          opts.on_tail("-h", "--help", "Print this help") do
-            safe_puts(opts.help)
-            return nil
-          end
-
-          opts.parse!(argv)
-          return argv
-        rescue OptionParser::InvalidOption
-          raise Errors::CLIInvalidOptions, :help => opts.help.chomp
-        end
-
-        # Yields a VM for each target VM for the command.
-        #
-        # This is a convenience method for easily implementing methods that
-        # take a target VM (in the case of multi-VM) or every VM if no
-        # specific VM name is specified.
-        #
-        # @param [String] name The name of the VM. Nil if every VM.
-        # @param [Boolean] single_target If true, then an exception will be
-        #   raised if more than one target is found.
-        def with_target_vms(names=nil, options=nil)
-          # Using VMs requires a Vagrant environment to be properly setup
-          raise Errors::NoEnvironmentError if !@env.root_path
-
-          # Setup the options hash
-          options ||= {}
-
-          # Require that names be an array
-          names ||= []
-          names = [names] if !names.is_a?(Array)
-
-          # First determine the proper array of VMs.
-          vms = []
-          if names.length > 0
-            names.each do |name|
-              if pattern = name[/^\/(.+?)\/$/, 1]
-                # This is a regular expression name, so we convert to a regular
-                # expression and allow that sort of matching.
-                regex = Regexp.new(pattern)
-
-                @env.vms.each do |name, vm|
-                  vms << vm if name =~ regex
-                end
-
-                raise Errors::VMNoMatchError if vms.empty?
-              else
-                # String name, just look for a specific VM
-                vms << @env.vms[name.to_sym]
-                raise Errors::VMNotFoundError, :name => name if !vms[0]
-              end
-            end
-          else
-            vms = @env.vms_ordered
-          end
-
-          # Make sure we're only working with one VM if single target
-          if options[:single_target] && vms.length != 1
-            vm = @env.primary_vm
-            raise Errors::MultiVMTargetRequired if !vm
-            vms = [vm]
-          end
-
-          # If we asked for reversed ordering, then reverse it
-          vms.reverse! if options[:reverse]
-
-          # Go through each VM and yield it!
-          vms.each do |old_vm|
-            # We get a new VM from the environment here to avoid potentially
-            # stale VMs (if there was a config reload on the environment
-            # or something).
-            vm = @env.vms[old_vm.name]
-            yield vm
-          end
-        end
-
-        # This method will split the argv given into three parts: the
-        # flags to this command, the subcommand, and the flags to the
-        # subcommand. For example:
-        #
-        #     -v status -h -v
-        #
-        # The above would yield 3 parts:
-        #
-        #     ["-v"]
-        #     "status"
-        #     ["-h", "-v"]
-        #
-        # These parts are useful because the first is a list of arguments
-        # given to the current command, the second is a subcommand, and the
-        # third are the commands given to the subcommand.
-        #
-        # @return [Array] The three parts.
-        def split_main_and_subcommand(argv)
-          # Initialize return variables
-          main_args   = nil
-          sub_command = nil
-          sub_args    = []
-
-          # We split the arguments into two: One set containing any
-          # flags before a word, and then the rest. The rest are what
-          # get actually sent on to the subcommand.
-          argv.each_index do |i|
-            if !argv[i].start_with?("-")
-              # We found the beginning of the sub command. Split the
-              # args up.
-              main_args   = argv[0, i]
-              sub_command = argv[i]
-              sub_args    = argv[i + 1, argv.length - i + 1]
-
-              # Break so we don't find the next non flag and shift our
-              # main args.
-              break
-            end
-          end
-
-          # Handle the case that argv was empty or didn't contain any subcommand
-          main_args = argv.dup if main_args.nil?
-
-          return [main_args, sub_command, sub_args]
-        end
-      end
-    end
-  end
-end