vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/lib/vagrant/cli.rb

@@ -1,82 +0,0 @@
-require 'log4r'
-require 'optparse'
-
-module Vagrant
-  # Manages the command line interface to Vagrant.
-  class CLI < Vagrant.plugin("2", :command)
-    def initialize(argv, env)
-      super
-
-      @logger = Log4r::Logger.new("vagrant::cli")
-      @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-      @logger.info("CLI: #{@main_args.inspect} #{@sub_command.inspect} #{@sub_args.inspect}")
-    end
-
-    def execute
-      if @main_args.include?("-v") || @main_args.include?("--version")
-        # Version short-circuits the whole thing. Just print
-        # the version and exit.
-        @env.ui.info(I18n.t("vagrant.commands.version.output",
-                            :version => Vagrant::VERSION),
-                     :prefix => false)
-
-        return 0
-      elsif @main_args.include?("-h") || @main_args.include?("--help")
-        # Help is next in short-circuiting everything. Print
-        # the help and exit.
-        help
-        return 0
-      end
-
-      # If we reached this far then we must have a subcommand. If not,
-      # then we also just print the help and exit.
-      command_class = nil
-      if @sub_command
-        command_class = Vagrant.plugin("2").manager.commands[@sub_command.to_sym]
-      end
-
-      if !command_class || !@sub_command
-        help
-        return 1
-      end
-      @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
-
-      # Initialize and execute the command class, returning the exit status.
-      result = command_class.new(@sub_args, @env).execute
-      result = 0 if !result.is_a?(Fixnum)
-      return result
-    end
-
-    # This prints out the help for the CLI.
-    def help
-      # We use the optionparser for this. Its just easier. We don't use
-      # an optionparser above because I don't think the performance hits
-      # of creating a whole object are worth checking only a couple flags.
-      opts = OptionParser.new do |o|
-        o.banner = "Usage: vagrant [-v] [-h] command [<args>]"
-        o.separator ""
-        o.on("-v", "--version", "Print the version and exit.")
-        o.on("-h", "--help", "Print this help.")
-        o.separator ""
-        o.separator "Available subcommands:"
-
-        # Add the available subcommands as separators in order to print them
-        # out as well.
-        keys = []
-        Vagrant.plugin("2").manager.commands.each do |key, _|
-          keys << key
-        end
-
-        keys.sort.each do |key|
-          o.separator "     #{key}"
-        end
-
-        o.separator ""
-        o.separator "For help on any individual command run `vagrant COMMAND -h`"
-      end
-
-      @env.ui.info(opts.help, :prefix => false)
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/config/container.rb

@@ -1,37 +0,0 @@
-module Vagrant
-  module Config
-    # Contains loaded configuration values and provides access to those
-    # values.
-    #
-    # This is the class returned when loading configuration and stores
-    # the completely loaded configuration values. This class is meant to
-    # be immutable.
-    class Container
-      attr_reader :global
-      attr_reader :vms
-
-      # Initializes the configuration container.
-      #
-      # @param [Top] global Top-level configuration for the global
-      #   applicatoin.
-      # @param [Array] vms Array of VM configurations.
-      def initialize(global, vms)
-        @global = global
-        @vms    = []
-        @vm_configs = {}
-
-        vms.each do |vm_config|
-          @vms << vm_config.vm.name
-          @vm_configs[vm_config.vm.name] = vm_config
-        end
-      end
-
-      # This returns the configuration for a specific virtual machine.
-      # The values for this configuration are usually pertinent to a
-      # single virtual machine and do not affect the system globally.
-      def for_vm(name)
-        @vm_configs[name]
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/config/loader.rb

@@ -1,222 +0,0 @@
-require "pathname"
-
-require "log4r"
-
-module Vagrant
-  module Config
-    # This class is responsible for loading Vagrant configuration,
-    # usually in the form of Vagrantfiles.
-    #
-    # Loading works by specifying the sources for the configuration
-    # as well as the order the sources should be loaded. Configuration
-    # set later always overrides those set earlier; this is how
-    # configuration "scoping" is implemented.
-    class Loader
-      # Initializes a configuration loader.
-      #
-      # @param [Registry] versions A registry of the available versions and
-      #   their associated loaders.
-      # @param [Array] version_order An array of the order of the versions
-      #   in the registry. This is used to determine if upgrades are
-      #   necessary. Additionally, the last version in this order is always
-      #   considered the "current" version.
-      def initialize(versions, version_order)
-        @logger        = Log4r::Logger.new("vagrant::config::loader")
-        @config_cache  = {}
-        @proc_cache    = {}
-        @sources       = {}
-        @versions      = versions
-        @version_order = version_order
-      end
-
-      # Set the configuration data for the given name.
-      #
-      # The `name` should be a symbol and must uniquely identify the data
-      # being given.
-      #
-      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
-      # `data` can also be an array of such values.
-      #
-      # At this point, no configuration is actually loaded. Note that calling
-      # `set` multiple times with the same name will override any previously
-      # set values. In this way, the last set data for a given name wins.
-      def set(name, sources)
-        @logger.info("Set #{name.inspect} = #{sources.inspect}")
-
-        # Sources should be an array
-        sources = [sources] if !sources.kind_of?(Array)
-
-        # Gather the procs for every source, since that is what we care about.
-        procs = []
-        sources.each do |source|
-          if !@proc_cache.has_key?(source)
-            # Load the procs for this source and cache them. This caching
-            # avoids the issue where a file may have side effects when loading
-            # and loading it multiple times causes unexpected behavior.
-            @logger.debug("Populating proc cache for #{source.inspect}")
-            @proc_cache[source] = procs_for_source(source)
-          end
-
-          # Add on to the array of procs we're going to use
-          procs.concat(@proc_cache[source])
-        end
-
-        # Set this source by name.
-        @sources[name] = procs
-      end
-
-      # This loads the configuration sources in the given order and returns
-      # an actual configuration object that is ready to be used.
-      #
-      # @param [Array<Symbol>] order The order of configuration to load.
-      # @return [Object] The configuration object. This is different for
-      #   each configuration version.
-      def load(order)
-        @logger.info("Loading configuration in order: #{order.inspect}")
-
-        unknown_sources = @sources.keys - order
-        if !unknown_sources.empty?
-          # TODO: Raise exception here perhaps.
-          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
-        end
-
-        # Get the current version config class to use
-        current_version      = @version_order.last
-        current_config_klass = @versions.get(current_version)
-
-        # This will hold our result
-        result = current_config_klass.init
-
-        # Keep track of the warnings and errors that may come from
-        # upgrading the Vagrantfiles
-        warnings = []
-        errors   = []
-
-        order.each do |key|
-          next if !@sources.has_key?(key)
-
-          @sources[key].each do |version, proc|
-            if !@config_cache.has_key?(proc)
-              @logger.debug("Loading from: #{key} (evaluating)")
-
-              # Get the proper version loader for this version and load
-              version_loader = @versions.get(version)
-              version_config = version_loader.load(proc)
-
-              # Store the errors/warnings associated with loading this
-              # configuration. We'll store these for later.
-              version_warnings = []
-              version_errors   = []
-
-              # If this version is not the current version, then we need
-              # to upgrade to the latest version.
-              if version != current_version
-                @logger.debug("Upgrading config from version #{version} to #{current_version}")
-                version_index = @version_order.index(version)
-                current_index = @version_order.index(current_version)
-
-                (version_index + 1).upto(current_index) do |index|
-                  next_version = @version_order[index]
-                  @logger.debug("Upgrading config to version #{next_version}")
-
-                  # Get the loader of this version and ask it to upgrade
-                  loader = @versions.get(next_version)
-                  upgrade_result = loader.upgrade(version_config)
-
-                  this_warnings = upgrade_result[1]
-                  this_errors   = upgrade_result[2]
-                  @logger.debug("Upgraded to version #{next_version} with " +
-                                "#{this_warnings.length} warnings and " +
-                                "#{this_errors.length} errors")
-
-                  # Append loading this to the version warnings and errors
-                  version_warnings += this_warnings
-                  version_errors   += this_errors
-
-                  # Store the new upgraded version
-                  version_config = upgrade_result[0]
-                end
-              end
-
-              # Cache the loaded configuration along with any warnings
-              # or errors so that they can be retrieved later.
-              @config_cache[proc] = [version_config, version_warnings, version_errors]
-            else
-              @logger.debug("Loading from: #{key} (cache)")
-            end
-
-            # Merge the configurations
-            cache_data = @config_cache[proc]
-            result = current_config_klass.merge(result, cache_data[0])
-
-            # Append the total warnings/errors
-            warnings += cache_data[1]
-            errors   += cache_data[2]
-          end
-        end
-
-        @logger.debug("Configuration loaded successfully, finalizing and returning")
-        [current_config_klass.finalize(result), warnings, errors]
-      end
-
-      protected
-
-      # This returns an array of `Proc` objects for the given source.
-      # The `Proc` objects returned will expect a single argument for
-      # the configuration object and are expected to mutate this
-      # configuration object.
-      def procs_for_source(source)
-        # Convert all pathnames to strings so we just have their path
-        source = source.to_s if source.is_a?(Pathname)
-
-        if source.is_a?(Array)
-          # An array must be formatted as [version, proc], so verify
-          # that and then return it
-          raise ArgumentError, "String source must have format [version, proc]" if source.length != 2
-
-          # Return it as an array since we're expected to return an array
-          # of [version, proc] pairs, but an array source only has one.
-          return [source]
-        elsif source.is_a?(String)
-          # Strings are considered paths, so load them
-          return procs_for_path(source)
-        else
-          raise ArgumentError, "Unknown configuration source: #{source.inspect}"
-        end
-      end
-
-      # This returns an array of `Proc` objects for the given path source.
-      #
-      # @param [String] path Path to the file which contains the proper
-      #   `Vagrant.configure` calls.
-      # @return [Array<Proc>]
-      def procs_for_path(path)
-        @logger.debug("Load procs for pathname: #{path}")
-
-        return Config.capture_configures do
-          begin
-            Kernel.load path
-          rescue SyntaxError => e
-            # Report syntax errors in a nice way.
-            raise Errors::VagrantfileSyntaxError, :file => e.message
-          rescue SystemExit
-            # Continue raising that exception...
-            raise
-          rescue Vagrant::Errors::VagrantError
-            # Continue raising known Vagrant errors since they already
-            # contain well worded error messages and context.
-            raise
-          rescue Exception => e
-            @logger.error("Vagrantfile load error: #{e.message}")
-            @logger.error(e.backtrace.join("\n"))
-
-            # Report the generic exception
-            raise Errors::VagrantfileLoadError,
-              :path => path,
-              :message => e.message
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Vagrant
-  module Config
-    module V1
-      # This is a configuration object that can have anything done
-      # to it. Anything, and it just appears to keep working.
-      class DummyConfig
-        def method_missing(name, *args, &block)
-          DummyConfig.new
-        end
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-require "vagrant/config/v1/root"
-
-module Vagrant
-  module Config
-    module V1
-      # This is the loader that handles configuration loading for V1
-      # configurations.
-      class Loader < VersionBase
-        # Returns a bare empty configuration object.
-        #
-        # @return [V1::Root]
-        def self.init
-          new_root_object
-        end
-
-        # Finalizes the configuration by making sure there is at least
-        # one VM defined in it.
-        def self.finalize(config)
-          # Call the `#finalize` method on each of the configuration keys.
-          # They're expected to modify themselves in our case.
-          config.finalize!
-
-          # Return the object
-          config
-        end
-
-        # Loads the configuration for the given proc and returns a configuration
-        # object.
-        #
-        # @param [Proc] config_proc
-        # @return [Object]
-        def self.load(config_proc)
-          # Create a root configuration object
-          root = new_root_object
-
-          # Call the proc with the root
-          config_proc.call(root)
-
-          # Return the root object, which doubles as the configuration object
-          # we actually use for accessing as well.
-          root
-        end
-
-        # Merges two configuration objects.
-        #
-        # @param [V1::Root] old The older root config.
-        # @param [V1::Root] new The newer root config.
-        # @return [V1::Root]
-        def self.merge(old, new)
-          # Grab the internal states, we use these heavily throughout the process
-          old_state = old.__internal_state
-          new_state = new.__internal_state
-
-          # The config map for the new object is the old one merged with the
-          # new one.
-          config_map = old_state["config_map"].merge(new_state["config_map"])
-
-          # Merge the keys.
-          old_keys = old_state["keys"]
-          new_keys = new_state["keys"]
-          keys     = {}
-          old_keys.each do |key, old_value|
-            if new_keys.has_key?(key)
-              # We need to do a merge, which we expect to be available
-              # on the config class itself.
-              keys[key] = old_value.merge(new_keys[key])
-            else
-              # We just take the old value, but dup it so that we can modify.
-              keys[key] = old_value.dup
-            end
-          end
-
-          new_keys.each do |key, new_value|
-            # Add in the keys that the new class has that we haven't merged.
-            if !keys.has_key?(key)
-              keys[key] = new_value.dup
-            end
-          end
-
-          # Return the final root object
-          V1::Root.new(config_map, keys)
-        end
-
-        protected
-
-        def self.new_root_object
-          # Get all the registered configuration objects and use them. If
-          # we're currently on version 1, then we load all the config objects,
-          # otherwise we load only the upgrade safe ones, since we're
-          # obviously being loaded for an upgrade.
-          config_map = nil
-          plugin_manager = Vagrant.plugin("1").manager
-          if Config::CURRENT_VERSION == "1"
-            config_map = plugin_manager.config
-          else
-            config_map = plugin_manager.config_upgrade_safe
-          end
-
-          # Create the configuration root object
-          V1::Root.new(config_map)
-        end
-      end
-    end
-  end
-end