vagrantup 0.2.0 → 0.3.0

data/lib/vagrant/box.rb

@@ -51,16 +51,21 @@ module Vagrant
     # only be used internally.
     attr_accessor :temp_path
 
+    # The environment which this box belongs to. Although this could
+    # actually be many environments, this points to the environment
+    # of a specific instance.
+    attr_accessor :env
+
     class <<self
       # Returns an array of all created boxes, as strings.
       #
       # @return [Array<String>]
-      def all
+      def all(env)
         results = []
 
-        Dir.open(Env.boxes_path) do |dir|
+        Dir.open(env.boxes_path) do |dir|
           dir.each do |d|
-            next if d == "." || d == ".." || !File.directory?(File.join(Env.boxes_path, d))
+            next if d == "." || d == ".." || !File.directory?(File.join(env.boxes_path, d))
             results << d.to_s
           end
         end
@@ -74,9 +79,9 @@ module Vagrant
       #
       # @param [String] name The name of the box
       # @return [Box] Instance of {Box} representing the box found
-      def find(name)
-        return nil unless File.directory?(directory(name))
-        new(name)
+      def find(env, name)
+        return nil unless File.directory?(directory(env, name))
+        new(env, name)
       end
 
       # Adds a new box with given name from the given URI. This method
@@ -85,10 +90,11 @@ module Vagrant
       #
       # @param [String] name The name of the box
       # @param [String] uri URI to the box file
-      def add(name, uri)
+      def add(env, name, uri)
         box = new
         box.name = name
         box.uri = uri
+        box.env = env
         box.add
       end
 
@@ -98,8 +104,8 @@ module Vagrant
       #
       # @param [String] name Name of the box whose directory you're interested in.
       # @return [String] Full path to the box directory.
-      def directory(name)
-        File.join(Env.boxes_path, name)
+      def directory(env, name)
+        File.join(env.boxes_path, name)
       end
     end
 
@@ -109,8 +115,9 @@ 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(name=nil)
+    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
@@ -139,7 +146,7 @@ module Vagrant
     #
     # @return [String]
     def directory
-      self.class.directory(self.name)
+      self.class.directory(env, self.name)
     end
   end
 end

data/lib/vagrant/busy.rb

@@ -45,6 +45,13 @@ module Vagrant
       end
 
       def wait_for_not_busy(sleeptime=5)
+        if @@trap_thread
+          logger.info "Exiting vagrant immediately!"
+          Thread.kill(@@trap_thread)
+          abort
+          return # for tests
+        end
+
         @@trap_thread ||= Thread.new do
           # Wait while the app is busy
           loop do

data/lib/vagrant/command.rb

@@ -0,0 +1,27 @@
+module Vagrant
+  # This class handles commands from the command line program `vagrant`
+  # and redirects them to the proper sub-command, setting up the environment
+  # and executing.
+  class Command
+    attr_reader :env
+
+    class <<self
+      # Executes a given subcommand within the current environment (from the
+      # current working directory).
+      def execute(*args)
+        env = Environment.load!
+        env.commands.subcommand(*args)
+      end
+    end
+
+    def initialize(env)
+      @env = env
+    end
+
+    # Execute a subcommand with the given name and args. This method properly
+    # finds the subcommand, instantiates it, and executes.
+    def subcommand(*args)
+      Commands::Base.dispatch(env, *args)
+    end
+  end
+end

data/lib/vagrant/commands/base.rb

@@ -0,0 +1,163 @@
+require 'optparse'
+
+module Vagrant
+  class Commands
+    # This is the base command class which all sub-commands must
+    # inherit from. Subclasses of bases are expected to implement two
+    # methods: {#execute} and {#options_spec} (optional). The former
+    # defines the actual behavior of the command while the latter is a spec
+    # outlining the options that the command may take.
+    class Base
+      include Util
+
+      attr_reader :env
+
+      class <<self
+        # Contains the list of registered subcommands. The registered commands are
+        # stored in a hash table and are therefore unordered.
+        #
+        # @return [Hash]
+        def subcommands
+          @subcommands ||= {}
+        end
+
+        # Registers a command with `vagrant`. This method allows 3rd parties to
+        # dynamically add new commands to the `vagrant` command, allowing plugins
+        # to act as 1st class citizens within vagrant.
+        #
+        # @param [String] key The subcommand which will invoke the registered command.
+        # @param [Class] klass. The subcommand class (a subclass of {Base})
+        def subcommand(key, klass)
+          subcommands[key] = klass
+        end
+
+        # Dispatches a subcommand to the proper registered command. Otherwise, it
+        # prints a help message.
+        def dispatch(env, *args)
+          klass = subcommands[args[0]] unless args.empty?
+          if klass.nil?
+            # Run _this_ command!
+            command = self.new(env)
+            command.execute(args)
+            return
+          end
+
+          # Shift off the front arg, since we just consumed it in finding the
+          # subcommand.
+          args.shift
+
+          # Dispatch to the next class
+          klass.dispatch(env, *args)
+        end
+
+        # Prints out the list of supported commands and their descriptions (if
+        # available) then exits.
+        def puts_help
+          puts "Usage: vagrant SUBCOMMAND ...\n\n"
+
+          puts "Supported commands:"
+          subcommands.keys.sort.each do |key|
+            klass = subcommands[key]
+            next if klass.description.empty?
+
+            puts "#{' ' * 4}#{key.ljust(20)}#{klass.description}"
+          end
+
+          exit
+        end
+
+        # Sets or reads the description, depending on if the value is set in the
+        # parameter.
+        def description(value=nil)
+          @description ||= ''
+
+          return @description if value.nil?
+          @description = value
+        end
+      end
+
+      def initialize(env)
+        @env = env
+      end
+
+      # This method should be overriden by subclasses. This is the method
+      # which is called by {Vagrant::Command} when a command is being
+      # executed. The `args` parameter is an array of parameters to the
+      # command (similar to ARGV)
+      def execute(args)
+        parse_options(args)
+
+        if options[:version]
+          puts_version
+        else
+          # Just print out the help, since this top-level command does nothing
+          # on its own
+          self.class.puts_help
+        end
+      end
+
+      # This method is called by the base class to get the `optparse` configuration
+      # for the command.
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant SUBCOMMAND"
+
+        opts.on("--version", "Output running Vagrant version.") do |v|
+          options[:version] = v
+        end
+      end
+
+      #-------------------------------------------------------------------
+      # Methods below are not meant to be overriden/implemented by subclasses
+      #-------------------------------------------------------------------
+
+      # Shows the version
+      def puts_version
+        File.open(File.join(PROJECT_ROOT, "VERSION"), "r") do |f|
+          puts f.read
+        end
+      end
+
+      # Returns the `OptionParser` instance to be used with this subcommand,
+      # based on the specs defined in {#options_spec}.
+      def option_parser(reload=false)
+        @option_parser = nil if reload
+        @option_parser ||= OptionParser.new do |opts|
+          options_spec(opts)
+        end
+      end
+
+      # The options for the given command. This will just be an empty hash
+      # until {#parse_options} is called.
+      def options
+        @options ||= {}
+      end
+
+      # Parse options out of the command-line. This method uses `optparse`
+      # to parse command line options.
+      def parse_options(args)
+        option_parser.parse!(args)
+        options
+      rescue OptionParser::InvalidOption
+        show_help
+      end
+
+      # Gets the description of the command. This is similar grabbed from the
+      # class level.
+      def description
+        self.class.description
+      end
+
+      # Prints the help for the given command. Prior to calling this method,
+      # {#parse_options} must be called or a nilerror will be raised. This
+      # is by design.
+      def show_help
+        if !description.empty?
+          puts "Description: #{description}"
+        end
+
+        puts option_parser.help
+        exit
+      end
+    end
+  end
+end

data/lib/vagrant/commands/box.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  class Commands
+    # Manages the `vagrant box` command, allowing the user to add
+    # and remove boxes. This single command, given an array, determines
+    # which action to take and calls the respective action method
+    # (see {box_add} and {box_remove})
+    class BoxCommand < Base
+      Base.subcommand "box", self
+      description "Box commands"
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant box SUBCOMMAND"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/box/add.rb

@@ -0,0 +1,24 @@
+module Vagrant
+  class Commands
+    # Adds a box to the local filesystem, given a URI.
+    module Box
+      class Add < BoxCommand
+        BoxCommand.subcommand "add", self
+        description "Add a box"
+
+        def execute(args)
+          if args.length != 2
+            show_help
+            return
+          end
+
+          Vagrant::Box.add(env, args[0], args[1])
+        end
+
+        def options_spec(opts)
+          opts.banner = "Usage: vagrant box add NAME URI"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/box/list.rb

@@ -0,0 +1,30 @@
+module Vagrant
+  class Commands
+    # Lists all added boxes
+    module Box
+      class List < BoxCommand
+        BoxCommand.subcommand "list", self
+        description "List all installed boxes"
+
+        def execute(args=[])
+          boxes = Vagrant::Box.all(env).sort
+
+          wrap_output do
+            if !boxes.empty?
+              puts "Installed Vagrant Boxes:\n\n"
+              boxes.each do |box|
+                puts box
+              end
+            else
+              puts "No Vagrant Boxes Added!"
+            end
+          end
+        end
+
+        def options_spec(opts)
+          opts.banner = "Usage: vagrant box list"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/box/remove.rb

@@ -0,0 +1,31 @@
+module Vagrant
+  class Commands
+    # Removes a box permanently from the hard drive.
+    module Box
+      class Remove < BoxCommand
+        BoxCommand.subcommand "remove", self
+        description "Remove an installed box permanently."
+
+        def execute(args=[])
+          if args.length != 1
+            show_help
+            return
+          end
+
+
+          box = Vagrant::Box.find(env, args[0])
+          if box.nil?
+            error_and_exit(:box_remove_doesnt_exist)
+            return # for tests
+          end
+
+          box.destroy
+        end
+
+        def options_spec(opts)
+          opts.banner = "Usage: vagrant box remove NAME"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/commands/destroy.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  class Commands
+    # Destroys a vagrant instance. This not only shuts down the instance
+    # (if its running), but also deletes it from the system, including the
+    # hard disks associated with it.
+    #
+    # This command requires that an instance already be brought up with
+    # `vagrant up`.
+    class Destroy < Base
+      Base.subcommand "destroy", self
+      description "Destroys the vagrant environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.vm.destroy
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant destroy"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/down.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  class Commands
+    # `vagrant down` is now `vagrant destroy`
+    class Down < Base
+      Base.subcommand "down", self
+
+      def execute(args=[])
+        error_and_exit(:command_deprecation_down)
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant down"
+      end
+    end
+  end
+end

data/lib/vagrant/commands/halt.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  class Commands
+    # Halts a running vagrant instance. This forcibly halts the instance;
+    # it is the equivalent of pulling the power on a machine. The instance
+    # can be restarted again with {up}.
+    #
+    # This command requires than an instance already be brought up with
+    # `vagrant up`.
+    class Halt < Base
+      Base.subcommand "halt", self
+      description "Halts the currently running vagrant environment"
+
+      def execute(args=[])
+        env.require_persisted_vm
+        env.vm.execute!(Actions::VM::Halt)
+      end
+
+      def options_spec(opts)
+        opts.banner = "Usage: vagrant halt"
+      end
+    end
+  end
+end