boxcar 0.10005.1

data/lib/vagrant/action/warden.rb

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

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

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

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

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

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