vagrant 0.8.10 → 0.9.0

data/lib/vagrant/action/vm/suspend.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Suspend
         def initialize(app, env)
@@ -7,9 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].vm.running?
-            env.ui.info I18n.t("vagrant.actions.vm.suspend.suspending")
-            env["vm"].vm.save_state
+          if env[:vm].state == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
+            env[:vm].driver.suspend
           end
 
           @app.call(env)

data/lib/vagrant/action/warden.rb

@@ -1,5 +1,7 @@
+require "log4r"
+
 module Vagrant
-  class Action
+  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`
@@ -16,6 +18,7 @@ module Vagrant
       def initialize(actions, env)
         @stack = []
         @actions = actions.map { |m| finalize_action(m, env) }
+        @logger  = Log4r::Logger.new("vagrant::action::warden")
       end
 
       def call(env)
@@ -24,17 +27,17 @@ module Vagrant
         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?
+          raise Errors::VagrantInterrupt if env[:interrupted]
           action = @actions.shift
-          env["logger"].info("warden") { "Calling action: #{action}" }
+          @logger.info("Calling action: #{action}")
           @stack.unshift(action).first.call(env)
-          raise Errors::VagrantInterrupt if env.interrupted?
+          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
-          env["logger"].info("warden") { "Error occurred: #{e}" }
+          @logger.error("Error occurred: #{e}")
           env["vagrant.error"] = e
 
           # Something went horribly wrong. Start the rescue chain then
@@ -50,7 +53,7 @@ module Vagrant
       def begin_rescue(env)
         @stack.each do |act|
           if act.respond_to?(:recover)
-            env["logger"].info("warden") { "Calling recover: #{act}" }
+            @logger.info("Calling recover: #{act}")
             act.recover(env)
           end
         end
@@ -65,6 +68,10 @@ module Vagrant
       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

data/lib/vagrant/box.rb

@@ -7,29 +7,10 @@ module Vagrant
   # is kicked out to middlewares.
   class Box
     # The name of the box.
-    attr_accessor :name
+    attr_reader :name
 
-    # The URI for a new box. This is not available for existing boxes.
-    attr_accessor :uri
-
-    # The environment which this box belongs to. Although this could
-    # actually be many environments, this points to the environment
-    # of a specific instance.
-    attr_reader :env
-
-    class << self
-      # Adds a new box with given name from the given URI. This method
-      # begins the process of adding a box from a given URI by setting up
-      # the {Box} instance and calling {#add}.
-      #
-      # @param [String] name The name of the box
-      # @param [String] uri URI to the box file
-      def add(env, name, uri)
-        box = new(env, name)
-        box.uri = uri
-        box.add
-      end
-    end
+    # 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
@@ -37,47 +18,20 @@ module Vagrant
     #
     # **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(env=nil, name=nil)
-      @name = name
-      @env = env
-    end
-
-    # Returns path to the OVF file of the box. The OVF file is an open
-    # virtual machine file which contains specifications of the exported
-    # virtual machine this box contains.
-    #
-    # This will only be valid once the box is imported.
-    #
-    # @return [String]
-    def ovf_file
-      directory.join(env.config.vm.box_ovf)
-    end
-
-    # Begins the process of adding a box to the vagrant installation. This
-    # method requires that `name` and `uri` be set. The logic of this method
-    # is kicked out to the `box_add` registered middleware.
-    def add
-      raise Errors::BoxAlreadyExists, :name => name if File.directory?(directory)
-      env.actions.run(:box_add, { "box" => self, "validate" => false })
+    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
-      env.actions.run(:box_remove, { "box" => self, "validate" => false })
+      @action_runner.run(:box_remove, { :box_name => @name, :box_directory => @directory })
     end
 
     # Begins sequence to repackage this box.
     def repackage(options=nil)
-      env.actions.run(:box_repackage, { "box" => self, "validate" => false }.merge(options || {}))
-    end
-
-    # Returns the directory to the location of this boxes content in the local
-    # filesystem. Note that if the box isn't imported yet, then the path may not
-    # yet exist, but still represents where the box will be imported to.
-    #
-    # @return [String]
-    def directory
-      env.boxes_path.join(name)
+      @action_runner.run(:box_repackage, { :box_name => @name, :box_directory => @directory })
     end
 
     # Implemented for comparison with other boxes. Comparison is implemented

data/lib/vagrant/box_collection.rb

@@ -2,26 +2,20 @@ require 'forwardable'
 
 module Vagrant
   # Represents a collection of boxes, providing helpful methods for
-  # finding boxes. An instance of this is returned by {Environment#boxes}.
-  #
-  # # Finding a Box
-  #
-  # To find a box, use the {#find} method with the name of the box. The name
-  # is an exact match search.
-  #
-  #     env.boxes.find("base") # => #<Vagrant::Box>
-  #
+  # finding boxes.
   class BoxCollection
     include Enumerable
     extend Forwardable
     def_delegators :@boxes, :length, :each
 
-    # The environment this box collection belongs to
-    attr_reader :env
+    # The directory that the boxes are being searched for.
+    attr_reader :directory
 
-    def initialize(env)
-      @env = env
-      @boxes = []
+    # 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
@@ -36,15 +30,26 @@ module Vagrant
       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(env.boxes_path) do |dir|
+      Dir.open(@directory) do |dir|
         dir.each do |d|
-          next if d == "." || d == ".." || !File.directory?(env.boxes_path.join(d))
-          @boxes << Box.new(env, d)
+          next if d == "." || d == ".." || !@directory.join(d).directory?
+          @boxes << Box.new(d, @directory.join(d), @action_runner)
         end
       end
     end

data/lib/vagrant/cli.rb

@@ -1,55 +1,70 @@
-require 'thor'
+require 'log4r'
+require 'optparse'
 
 module Vagrant
-  # Entrypoint for the Vagrant CLI. This class should never be
-  # initialized directly (like a typical Thor class). Instead,
-  # use {Environment#cli} to invoke the CLI.
-  #
-  # # Defining Custom CLI Commands
-  #
-  # If you're looking to define custom CLI commands, then look at
-  # one of the two following classes:
-  #
-  # * {Command::Base} - Implementing a single command such as `vagrant up`, e.g.
-  #   one without subcommands. Also take a look at {Command::NamedBase}.
-  # * {Command::GroupBase} - Implementing a command with subcommands, such as
-  #   `vagrant box`, which has the `list`, `add`, etc. subcommands.
-  #
-  # The above linked classes contain the main documentation for each
-  # type of command.
-  class CLI < Thor
-    # Registers the given class with the CLI so it can be accessed.
-    # The class must be a subclass of either {Command::Base} or {Command::GroupBase}.
-    # Don't call this method directly, instead call the {Command::Base.register}
-    # or {Command::GroupBase.register} methods.
-    #
-    # @param [Class] klass Command class
-    # @param [String] name Command name, accessed at `vagrant NAME`
-    # @param [String] usage Command usage, such as "vagrant NAME [--option]"
-    # @param [String] description Description of the command shown during the
-    #   command listing.
-    # @param [Hash] opts Other options (not gone into detail here, look at
-    #   the source instead).
-    def self.register(klass, name, usage, description, opts=nil)
-      opts ||= {}
-
-      if klass <= Command::GroupBase
-        # A subclass of GroupBase is a subcommand, since it contains
-        # many smaller commands within it.
-        desc usage, description, opts
-        subcommand name, klass
-      elsif klass <= Command::Base
-        # A subclass of Base is a single command, since it
-        # is invoked as a whole (as Thor::Group)
-        desc usage, description, opts
-        define_method(name) { |*args| invoke klass, args }
+  # 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
+      elsif @main_args.include?("-h") || @main_args.include?("--help")
+        # Help is next in short-circuiting everything. Print
+        # the help and exit.
+        return help
       end
 
-      if opts[:alias]
-        # Alises are defined for this command, so properly alias the
-        # newly defined method/subcommand:
-        map opts[:alias] => name
+      # 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
+      return help if !command_class || !@sub_command
+      @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+      # Initialize and execute the command class.
+      command_class.new(@sub_args, @env).execute
+    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,25 +1,23 @@
 module Vagrant
   module Command
     autoload :Base,      'vagrant/command/base'
-    autoload :GroupBase, 'vagrant/command/group_base'
-    autoload :Helpers,   'vagrant/command/helpers'
-    autoload :NamedBase, 'vagrant/command/named_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 :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
-
-# The built-in commands must always be loaded
-require 'vagrant/command/box'
-require 'vagrant/command/destroy'
-require 'vagrant/command/halt'
-require 'vagrant/command/init'
-require 'vagrant/command/package'
-require 'vagrant/command/provision'
-require 'vagrant/command/reload'
-require 'vagrant/command/resume'
-require 'vagrant/command/ssh'
-require 'vagrant/command/ssh_config'
-require 'vagrant/command/status'
-require 'vagrant/command/suspend'
-require 'vagrant/command/up'
-require 'vagrant/command/upgrade_to_060'
-require 'vagrant/command/version'

data/lib/vagrant/command/base.rb

@@ -1,105 +1,150 @@
-require 'thor/group'
-require 'thor/actions'
+require 'log4r'
 
 module Vagrant
   module Command
-    # A {Base} is the superclass for all commands which are single
-    # commands, e.g. `vagrant init`, `vagrant up`. Not commands like
-    # `vagrant box add`. For commands which have more subcommands, use
-    # a {GroupBase}.
+    # Base class for any CLI commands.
     #
-    # A {Base} is a subclass of `Thor::Group`, so view the documentation
-    # there on how to add arguments, descriptions etc. The important note
-    # about this is that when invoked, _all public methods_ will be called
-    # in the order they are defined. If you don't want a method called when
-    # the command is invoked, it must be made `protected` or `private`.
-    #
-    # The best way to get examples of how to create your own command is to
-    # view the various Vagrant commands, which are relatively simple, and
-    # can be found in the Vagrant source tree at `lib/vagrant/command/`.
-    #
-    # # Defining a New Command
-    #
-    # To define a new single command, create a new class which inherits
-    # from this class, then call {register} to register the command. That's
-    # it! When the command is invoked, _all public methods_ will be called.
-    # Below is an example `SayHello` class:
-    #
-    #     class SayHello < Vagrant::Command::Base
-    #       register "hello", "Says hello"
-    #
-    #       def hello
-    #         env.ui.info "Hello"
-    #       end
-    #     end
-    #
-    # In this case, the above class is invokable via `vagrant hello`. To give
-    # this a try, just copy and paste the above into a Vagrantfile somewhere.
-    # The command will be available for that project!
-    #
-    # Also note that the above example uses `env.ui` to output. It is recommended
-    # you use this instead of raw "puts" since it is configurable and provides
-    # additional functionality, such as colors and asking for user input. See
-    # the {UI} class for more information.
-    #
-    # ## Defining Command-line Options
-    #
-    # Most command line actions won't be as simple as `vagrant hello`, and will
-    # probably require parameters or switches. Luckily, Thor makes adding these
-    # easy:
-    #
-    #     class SayHello < Vagrant::Command::Base
-    #       register "hello", "Says hello"
-    #       argument :name, :type => :string
-    #
-    #       def hello
-    #         env.ui.info "Hello, #{name}"
-    #       end
-    #     end
-    #
-    # Then, the above can be invoked with `vagrant hello Mitchell` which would
-    # output "Hello, Mitchell." If instead you're looking for switches, such as
-    # "--name Mitchell", then take a look at `class_option`, an example of which
-    # can be found in the {PackageCommand}.
-    class Base < Thor::Group
-      include Thor::Actions
-      include Helpers
-
-      attr_reader :env
-
-      # Register the command with the main Vagrant CLI under the
-      # given name. The name will be used for accessing it from the CLI,
-      # so if you name it "lamp", then the command to invoke this
-      # will be `vagrant lamp`.
-      #
-      # The description is used when the help is listed, and is meant to be
-      # a brief (one sentence) description of what the command does.
+    # This class provides documentation on the interface as well as helper
+    # functions that a command has.
+    class Base
+      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.
       #
-      # Some additional options may be passed in as the last parameter:
+      # This is a convenience method that properly handles duping the
+      # originally argv array so that it is not destroyed.
       #
-      # * `:alias` - If given as an array or string, these will be aliases
-      #  for the same command. For example, `vagrant version` is also
-      #  `vagrant --version` and `vagrant -v`
+      # 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.
       #
-      # @param [String] usage
-      # @param [String] description
-      # @param [Hash] opts
-      def self.register(usage, description, opts=nil)
-        desc description
-        CLI.register(self, extract_name_from_usage(usage), usage, desc, opts)
+      # 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
+          puts opts.help
+          return nil
+        end
+
+        opts.parse!(argv)
+        return argv
+      rescue OptionParser::InvalidOption
+        raise Errors::CLIInvalidOptions, :help => opts.help.chomp
       end
 
-      def initialize(*args)
-        super
-        initialize_environment(*args)
+      # 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(name=nil, single_target=false)
+        # Using VMs requires a Vagrant environment to be properly setup
+        raise Errors::NoEnvironmentError if !@env.root_path
+
+        # First determine the proper array of VMs.
+        vms = []
+        if 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
+        else
+          vms = @env.vms_ordered
+        end
+
+        # Make sure we're only working with one VM if single target
+        raise Errors::MultiVMTargetRequired if single_target && vms.length != 1
+
+        # 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
 
-      protected
+      # 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?
 
-      # Extracts the name of the command from a usage string. Example:
-      # `init [box_name] [box_url]` becomes just `init`.
-      def self.extract_name_from_usage(usage)
-        /^([-_a-zA-Z0-9]+)(\s+(.+?))?$/.match(usage).to_a[1]
+        return [main_args, sub_command, sub_args]
       end
     end
   end