vagrant 1.0.7 → 1.5.0

data/lib/vagrant/action/warden.rb

@@ -1,92 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    # The action warden is a middleware which injects itself between
-    # every other middleware, watching for exceptions which are raised
-    # and performing proper cleanup on every action by calling the `recover`
-    # method. The warden therefore allows middlewares to not worry about
-    # exceptional events, and by providing a simple callback, can clean up
-    # in any erroneous case.
-    #
-    # Warden will "just work" behind the scenes, and is not of particular
-    # interest except to those who are curious about the internal workings
-    # of Vagrant.
-    class Warden
-      attr_accessor :actions, :stack
-
-      def initialize(actions, env)
-        @stack = []
-        @actions = actions.map { |m| finalize_action(m, env) }
-        @logger  = Log4r::Logger.new("vagrant::action::warden")
-      end
-
-      def call(env)
-        return if @actions.empty?
-
-        begin
-          # Call the next middleware in the sequence, appending to the stack
-          # of "recoverable" middlewares in case something goes wrong!
-          raise Errors::VagrantInterrupt if env[:interrupted]
-          action = @actions.shift
-          @logger.info("Calling action: #{action}")
-          @stack.unshift(action).first.call(env)
-          raise Errors::VagrantInterrupt if env[:interrupted]
-        rescue SystemExit
-          # This means that an "exit" or "abort" was called. In these cases,
-          # we just exit immediately.
-          raise
-        rescue Exception => e
-          @logger.error("Error occurred: #{e}")
-          env["vagrant.error"] = e
-
-          # Something went horribly wrong. Start the rescue chain then
-          # reraise the exception to properly kick us out of limbo here.
-          begin_rescue(env)
-          raise
-        end
-      end
-
-      # Begins the recovery sequence for all middlewares which have run.
-      # It does this by calling `recover` (if it exists) on each middleware
-      # which has already run, in reverse order.
-      def begin_rescue(env)
-        @stack.each do |act|
-          if act.respond_to?(:recover)
-            @logger.info("Calling recover: #{act}")
-            act.recover(env)
-          end
-        end
-
-        # Clear stack so that warden down the middleware chain doesn't
-        # rescue again.
-        @stack.clear
-      end
-
-      # A somewhat confusing function which simply initializes each
-      # middleware properly to call the next middleware in the sequence.
-      def finalize_action(action, env)
-        klass, args, block = action
-
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class.
-        args ||= []
-
-        if klass.is_a?(Class)
-          # A action klass which is to be instantiated with the
-          # app, env, and any arguments given
-          klass.new(self, env, *args, &block)
-        elsif klass.respond_to?(:call)
-          # Make it a lambda which calls the item then forwards
-          # up the chain
-          lambda do |e|
-            klass.call(e)
-            self.call(e)
-          end
-        else
-          raise "Invalid action: #{action.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/box.rb

@@ -1,44 +0,0 @@
-module Vagrant
-  # Represents a "box," which is simply a packaged vagrant environment.
-  # Boxes are simply `tar` files which contain an exported VirtualBox
-  # virtual machine, at the least. They are created with `vagrant package`
-  # and may contain additional files if specified by the creator. This
-  # class serves to help manage these boxes, although most of the logic
-  # is kicked out to middlewares.
-  class Box
-    # The name of the box.
-    attr_reader :name
-
-    # The directory where this box is stored
-    attr_reader :directory
-
-    # Creates a new box instance. Given an optional `name` parameter,
-    # newly created instance will have that name, otherwise it defaults
-    # to `nil`.
-    #
-    # **Note:** This method does not actually _create_ the box, but merely
-    # returns a new, abstract representation of it. To add a box, see {#add}.
-    def initialize(name, directory, action_runner)
-      @name          = name
-      @directory     = directory
-      @action_runner = action_runner
-    end
-
-    # Begins the process of destroying this box. This cannot be undone!
-    def destroy
-      @action_runner.run(:box_remove, { :box_name => @name, :box_directory => @directory })
-    end
-
-    # Begins sequence to repackage this box.
-    def repackage(options=nil)
-      @action_runner.run(:box_repackage, { :box_name => @name, :box_directory => @directory })
-    end
-
-    # Implemented for comparison with other boxes. Comparison is implemented
-    # by simply comparing name.
-    def <=>(other)
-      return super if !other.is_a?(self.class)
-      name <=> other.name
-    end
-  end
-end

data/lib/vagrant/box_collection.rb

@@ -1,58 +0,0 @@
-require 'forwardable'
-
-module Vagrant
-  # Represents a collection of boxes, providing helpful methods for
-  # finding boxes.
-  class BoxCollection
-    include Enumerable
-    extend Forwardable
-    def_delegators :@boxes, :length, :each
-
-    # The directory that the boxes are being searched for.
-    attr_reader :directory
-
-    # Initializes the class to search for boxes in the given directory.
-    def initialize(directory, action_runner)
-      @directory     = directory
-      @boxes         = []
-      @action_runner = action_runner
-
-      reload!
-    end
-
-    # Find a box in the collection by the given name. The name must
-    # be a string, for now.
-    def find(name)
-      @boxes.each do |box|
-        return box if box.name == name
-      end
-
-      nil
-    end
-
-    # Adds a box to this collection with the given name and located
-    # at the given URL.
-    def add(name, url)
-      raise Errors::BoxAlreadyExists, :name => name if find(name)
-
-      @action_runner.run(:box_add,
-                         :box_name => name,
-                         :box_url => url,
-                         :box_directory => @directory.join(name))
-    end
-
-    # Loads the list of all boxes from the source. This modifies the
-    # current array.
-    def reload!
-      @boxes.clear
-
-      Dir.open(@directory) do |dir|
-        dir.each do |d|
-          next if d == "." || d == ".." || !@directory.join(d).directory?
-          @boxes << Box.new(d, @directory.join(d), @action_runner)
-        end
-      end
-    end
-  end
-end
-

data/lib/vagrant/cli.rb

@@ -1,76 +0,0 @@
-require 'log4r'
-require 'optparse'
-
-module Vagrant
-  # Manages the command line interface to Vagrant.
-  class CLI < Command::Base
-    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 = Vagrant.commands.get(@sub_command.to_sym) if @sub_command
-      if !command_class || !@sub_command
-        help
-        return 0
-      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 |opts|
-        opts.banner = "Usage: vagrant [-v] [-h] command [<args>]"
-        opts.separator ""
-        opts.on("-v", "--version", "Print the version and exit.")
-        opts.on("-h", "--help", "Print this help.")
-        opts.separator ""
-        opts.separator "Available subcommands:"
-
-        # Add the available subcommands as separators in order to print them
-        # out as well.
-        keys = []
-        Vagrant.commands.each { |key, value| keys << key.to_s }
-
-        keys.sort.each do |key|
-          opts.separator "     #{key}"
-        end
-
-        opts.separator ""
-        opts.separator "For help on any individual command run `vagrant COMMAND -h`"
-      end
-
-      @env.ui.info(opts.help, :prefix => false)
-    end
-  end
-end

data/lib/vagrant/command.rb

@@ -1,24 +0,0 @@
-module Vagrant
-  module Command
-    autoload :Base,      'vagrant/command/base'
-
-    autoload :Box,          'vagrant/command/box'
-    autoload :BoxAdd,       'vagrant/command/box_add'
-    autoload :BoxRemove,    'vagrant/command/box_remove'
-    autoload :BoxRepackage, 'vagrant/command/box_repackage'
-    autoload :BoxList,      'vagrant/command/box_list'
-    autoload :Destroy,      'vagrant/command/destroy'
-    autoload :Gem,          'vagrant/command/gem'
-    autoload :Halt,         'vagrant/command/halt'
-    autoload :Init,         'vagrant/command/init'
-    autoload :Package,      'vagrant/command/package'
-    autoload :Provision,    'vagrant/command/provision'
-    autoload :Reload,       'vagrant/command/reload'
-    autoload :Resume,       'vagrant/command/resume'
-    autoload :SSH,          'vagrant/command/ssh'
-    autoload :SSHConfig,    'vagrant/command/ssh_config'
-    autoload :Status,       'vagrant/command/status'
-    autoload :Suspend,      'vagrant/command/suspend'
-    autoload :Up,           'vagrant/command/up'
-  end
-end

data/lib/vagrant/command/base.rb

@@ -1,167 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Command
-    # Base class for any CLI commands.
-    #
-    # This class provides documentation on the interface as well as helper
-    # functions that a command has.
-    class Base
-      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|
-            raise Errors::MultiVMEnvironmentRequired if !@env.multivm?
-
-            if name =~ /^\/(.+?)\/$/
-              # This is a regular expression name, so we convert to a regular
-              # expression and allow that sort of matching.
-              regex = Regexp.new($1.to_s)
-
-              @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
-        raise Errors::MultiVMTargetRequired if options[:single_target] && vms.length != 1
-
-        # 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