vagrant-lxc 0.0.1 → 0.0.2

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

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

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

@@ -1,68 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a provider for the V1 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 can be any symbol.
-        #
-        # @return [Symbol]
-        def state
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a provisioner for the V1 API. A provisioner
-      # is primarily responsible for installing software on a Vagrant guest.
-      class Provisioner
-        # The environment which provisioner is running in. This is the
-        # action environment, not a Vagrant::Environment.
-        attr_reader :env
-
-        # The configuration for this provisioner. This will be an instance of
-        # the `Config` class which is part of the provisioner.
-        attr_reader :config
-
-        def initialize(env, config)
-          @env    = env
-          @config = config
-        end
-
-        # This method is expected to return a class that is used for
-        # configuring the provisioner. This return value is expected to be
-        # a subclass of {Config}.
-        #
-        # @return [Config]
-        def self.config_class
-        end
-
-        # This is the method called to "prepare" the provisioner. This is called
-        # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
-        # This can be used to setup shared folders, forward ports, etc. Whatever is
-        # necessary on a "meta" level.
-        #
-        # No return value is expected.
-        def prepare
-        end
-
-        # This is the method called to provision the system. This method
-        # is expected to do whatever necessary to provision the system (create files,
-        # SSH, etc.)
-        def provision!
-        end
-
-        # This is the method called to when the system is being destroyed
-        # and allows the provisioners to engage in any cleanup tasks necessary.
-        def cleanup
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "log4r"
-
-require "vagrant/plugin/v1/errors"
-
-module Vagrant
-  module Plugin
-    module V1
-      autoload :Command, "vagrant/plugin/v1/command"
-      autoload :Communicator, "vagrant/plugin/v1/communicator"
-      autoload :Config, "vagrant/plugin/v1/config"
-      autoload :Guest,  "vagrant/plugin/v1/guest"
-      autoload :Host,   "vagrant/plugin/v1/host"
-      autoload :Manager, "vagrant/plugin/v1/manager"
-      autoload :Plugin, "vagrant/plugin/v1/plugin"
-      autoload :Provider, "vagrant/plugin/v1/provider"
-      autoload :Provisioner, "vagrant/plugin/v1/provisioner"
-    end
-  end
-end

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

@@ -1,234 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Plugin
-    module V2
-      # 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 [Hash] options Additional tweakable settings.
-        # @option options [Symbol] :provider The provider to back the
-        #   machines with. All machines will be backed with this
-        #   provider. If none is given, a sensible default is chosen.
-        # @option options [Boolean] :reverse If true, the resulting order
-        #   of machines is reversed.
-        # @option options [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)
-          @logger.debug("Getting target VMs for command. Arguments:")
-          @logger.debug(" -- names: #{names.inspect}")
-          @logger.debug(" -- options: #{options.inspect}")
-
-          # 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)
-
-          # This is a helper that gets a single machine with the proper
-          # provider. The "proper provider" in this case depends on what was
-          # given:
-          #
-          #   * If a provider was explicitly specified, then use that provider.
-          #     But if an active machine exists with a DIFFERENT provider,
-          #     then throw an error (for now), since we don't yet support
-          #     bringing up machines with different providers.
-          #
-          #   * If no provider was specified, then use the active machine's
-          #     provider if it exists, otherwise use the default provider.
-          #
-          get_machine = lambda do |name|
-            # Check for an active machine with the same name
-            provider_to_use = options[:provider]
-            provider_to_use = provider_to_use.to_sym if provider_to_use
-
-            @env.active_machines.each do |active_name, active_provider|
-              if name == active_name
-                # We found an active machine with the same name
-
-                if provider_to_use && provider_to_use != active_provider
-                  # We found an active machine with a provider that doesn't
-                  # match the requested provider. Show an error.
-                  raise Errors::ActiveMachineWithDifferentProvider,
-                    :name => active_name.to_s,
-                    :active_provider => active_provider.to_s,
-                    :requested_provider => provider_to_use.to_s
-                else
-                  # Use this provider and exit out of the loop. One of the
-                  # invariants [for now] is that there shouldn't be machines
-                  # with multiple providers.
-                  @logger.info("Active machine found with name #{active_name}. " +
-                               "Using provider: #{active_provider}")
-                  provider_to_use = active_provider
-                  break
-                end
-              end
-            end
-
-            # Use the default provider if nothing else
-            provider_to_use ||= @env.default_provider
-
-            # Get the right machine with the right provider
-            @env.machine(name, provider_to_use)
-          end
-
-          # First determine the proper array of VMs.
-          machines = []
-          if names.length > 0
-            names.each do |name|
-              if pattern = name[/^\/(.+?)\/$/, 1]
-                @logger.debug("Finding machines that match regex: #{pattern}")
-
-                # This is a regular expression name, so we convert to a regular
-                # expression and allow that sort of matching.
-                regex = Regexp.new(pattern)
-
-                @env.machine_names.each do |machine_name|
-                  if machine_name =~ regex
-                    machines << get_machine.call(machine_name)
-                  end
-                end
-
-                raise Errors::VMNoMatchError if machines.empty?
-              else
-                # String name, just look for a specific VM
-                @logger.debug("Finding machine that match name: #{name}")
-                machines << get_machine.call(name.to_sym)
-                raise Errors::VMNotFoundError, :name => name if !machines[0]
-              end
-            end
-          else
-            # No name was given, so we return every VM in the order
-            # configured.
-            @logger.debug("Loading all machines...")
-            machines = @env.machine_names.map do |machine_name|
-              get_machine.call(machine_name)
-            end
-          end
-
-          # Make sure we're only working with one VM if single target
-          if options[:single_target] && machines.length != 1
-            @logger.debug("Using primary machine since single target")
-            primary_name = @env.primary_machine_name
-            raise Errors::MultiVMTargetRequired if !primary_name
-            machines = [get_machine.call(primary_name)]
-          end
-
-          # If we asked for reversed ordering, then reverse it
-          machines.reverse! if options[:reverse]
-
-          # Go through each VM and yield it!
-          machines.each do |machine|
-            @logger.info("With machine: #{machine.name} (#{machine.provider.inspect})")
-            yield machine
-          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