vagrantup 0.5.4 → 0.6.0

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

@@ -12,8 +12,8 @@ module Vagrant
         def call(env)
           @app.call(env)
 
-          if !env.error? && provisioning_enabled?
-            @env.logger.info "Beginning provisioning process..."
+          if provisioning_enabled?
+            @env.ui.info I18n.t("vagrant.actions.vm.provision.beginning")
             @provisioner.provision!
           end
         end
@@ -27,7 +27,7 @@ module Vagrant
 
           if provisioner.is_a?(Class)
             @provisioner = provisioner.new(@env)
-            return @env.error!(:provisioner_invalid_class) unless @provisioner.is_a?(Provisioners::Base)
+            raise Errors::ProvisionInvalidClass.new if !@provisioner.is_a?(Provisioners::Base)
           elsif provisioner.is_a?(Symbol)
             # We have a few hard coded provisioners for built-ins
             mapping = {
@@ -36,11 +36,11 @@ module Vagrant
             }
 
             provisioner_klass = mapping[provisioner]
-            return @env.error!(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
+            raise Errors::ProvisionUnknownType.new(:provisioner => provisioner.to_s) if provisioner_klass.nil?
             @provisioner = provisioner_klass.new(@env)
           end
 
-          @env.logger.info "Provisioning enabled with #{@provisioner.class}"
+          @env.ui.info I18n.t("vagrant.actions.vm.provision.enabled", :provisioner => @provisioner.class.to_s)
           @provisioner.prepare
           @provisioner
         end

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

@@ -8,7 +8,7 @@ module Vagrant
 
         def call(env)
           if env["vm"].vm.saved?
-            env.logger.info "Resuming suspended VM..."
+            env.ui.info I18n.t("vagrant.actions.vm.resume.resuming")
             env["actions"].run(Boot)
           end
 

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

@@ -2,8 +2,6 @@ module Vagrant
   class Action
     module VM
       class ShareFolders
-        include ExceptionCatcher
-
         def initialize(app, env)
           @app = app
           @env = env
@@ -16,14 +14,7 @@ module Vagrant
 
           @app.call(env)
 
-          if !env.error?
-            catch_action_exception(env) do
-              # Only mount and setup shared folders in the absense of an
-              # error
-              mount_shared_folders
-              setup_unison
-            end
-          end
+          mount_shared_folders
         end
 
         # This method returns an actual list of VirtualBox shared
@@ -36,31 +27,13 @@ module Vagrant
 
             # This to prevent overwriting the actual shared folders data
             value = value.dup
-
-            if value[:sync]
-              # Syncing this folder. Change the guestpath to reflect
-              # what we're actually mounting.
-              value[:original] = value.dup
-              value[:guestpath] = "#{value[:guestpath]}#{@env.env.config.unison.folder_suffix}"
-            end
-
             acc[key] = value
             acc
           end
         end
 
-        # This method returns the list of shared folders which are to
-        # be synced via unison.
-        def unison_folders
-          shared_folders.inject({}) do |acc, data|
-            key, value = data
-            acc[key] = value if !!value[:sync]
-            acc
-          end
-        end
-
         def create_metadata
-          @env.logger.info "Creating shared folders metadata..."
+          @env.ui.info I18n.t("vagrant.actions.vm.share_folders.creating")
 
           shared_folders.each do |name, data|
             folder = VirtualBox::SharedFolder.new
@@ -73,28 +46,17 @@ module Vagrant
         end
 
         def mount_shared_folders
-          @env.logger.info "Mounting shared folders..."
+          @env.ui.info I18n.t("vagrant.actions.vm.share_folders.mounting")
 
           @env["vm"].ssh.execute do |ssh|
             shared_folders.each do |name, data|
-              @env.logger.info "-- #{name}: #{data[:guestpath]}"
+              @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                           :name => name,
+                           :guest_path => data[:guestpath]))
               @env["vm"].system.mount_shared_folder(ssh, name, data[:guestpath])
             end
           end
         end
-
-        def setup_unison
-          return if unison_folders.empty?
-
-          @env["vm"].ssh.execute do |ssh|
-            @env["vm"].system.prepare_unison(ssh)
-
-            @env.logger.info "Creating unison crontab entries..."
-            unison_folders.each do |name, data|
-              @env["vm"].system.create_unison(ssh, data)
-            end
-          end
-        end
       end
     end
   end

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

@@ -8,7 +8,7 @@ module Vagrant
 
         def call(env)
           if env["vm"].vm.running?
-            env.logger.info "Saving VM state and suspending execution..."
+            env.ui.info I18n.t("vagrant.actions.vm.suspend.suspending")
             env["vm"].vm.save_state
           end
 

data/lib/vagrant/action/warden.rb

@@ -0,0 +1,74 @@
+module Vagrant
+  class 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.
+    #
+    # Except for those who are curious about the internal workings of Vagrant,
+    # Warden will "just work" behind the scenes.
+    class Warden
+      attr_accessor :actions, :stack
+
+      def initialize(actions, env)
+        @stack = []
+        @actions = actions.map { |m| finalize_action(m, env) }
+      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.new if env.interrupted?
+          @stack.unshift(@actions.shift).first.call(env)
+          raise Errors::VagrantInterrupt.new if env.interrupted?
+        rescue Exception => 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|
+          act.recover(env) if act.respond_to?(:recover)
+        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
+
+        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

@@ -4,42 +4,7 @@ module Vagrant
   # 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 actions.
-  #
-  # What can the {Box} class do?
-  #
-  # * Find boxes
-  # * Add existing boxes (from some URI)
-  # * Delete existing boxes
-  #
-  # # Finding Boxes
-  #
-  # Using the {Box.find} method, you can search for existing boxes. This
-  # method will return `nil` if none is found or an instance of {Box}
-  # otherwise.
-  #
-  #     box = Vagrant::Box.find("base")
-  #     if box.nil?
-  #       puts "Box not found!"
-  #     else
-  #       puts "Box exists at #{box.directory}"
-  #     end
-  #
-  # # Adding a Box
-  #
-  # Boxes can be added from any URI. Some schemas aren't supported; if this
-  # is the case, the error will output to the logger.
-  #
-  #     Vagrant::Box.add("foo", "http://myfiles.com/foo.box")
-  #
-  # # Destroying a box
-  #
-  # Boxes can be deleted as well. This method is _final_ and there is no way
-  # to undo this action once it is completed.
-  #
-  #     box = Vagrant::Box.find("foo")
-  #     box.destroy
-  #
+  # is kicked out to middlewares.
   class Box
     # The name of the box.
     attr_accessor :name
@@ -50,36 +15,9 @@ module Vagrant
     # 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
+    attr_reader :env
 
     class << self
-      # Returns an array of all created boxes, as strings.
-      #
-      # @return [Array<String>]
-      def all(env)
-        results = []
-
-        Dir.open(env.boxes_path) do |dir|
-          dir.each do |d|
-            next if d == "." || d == ".." || !File.directory?(File.join(env.boxes_path, d))
-            results << d.to_s
-          end
-        end
-
-        results
-      end
-
-      # Finds a box with the given name. This method searches for a box
-      # with the given name, returning `nil` if none is found or returning
-      # a {Box} instance otherwise.
-      #
-      # @param [String] name The name of the box
-      # @return [Box] Instance of {Box} representing the box found
-      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
       # begins the process of adding a box from a given URI by setting up
       # the {Box} instance and calling {#add}.
@@ -87,22 +25,10 @@ module Vagrant
       # @param [String] name The name of the box
       # @param [String] uri URI to the box file
       def add(env, name, uri)
-        box = new
-        box.name = name
+        box = new(env, name)
         box.uri = uri
-        box.env = env
         box.add
       end
-
-      # Returns the directory to a box of the given name. The name given
-      # as a parameter is not checked for existence; this method simply
-      # returns the directory which would be used if the box did exist.
-      #
-      # @param [String] name Name of the box whose directory you're interested in.
-      # @return [String] Full path to the box directory.
-      def directory(env, name)
-        File.join(env.boxes_path, name)
-      end
     end
 
     # Creates a new box instance. Given an optional `name` parameter,
@@ -120,19 +46,21 @@ module Vagrant
     # 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
-      File.join(directory, env.config.vm.box_ovf)
+      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 {Actions::Box::Add add box} action.
+    # is kicked out to the `box_add` registered middleware.
     def add
       env.actions.run(:box_add, { "box" => self })
     end
 
-    # Begins the process of destroying this box.
+    # Begins the process of destroying this box. This cannot be undone!
     def destroy
       env.actions.run(:box_remove, { "box" => self })
     end
@@ -143,11 +71,19 @@ module Vagrant
     end
 
     # Returns the directory to the location of this boxes content in the local
-    # filesystem.
+    # 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
-      self.class.directory(env, self.name)
+      env.boxes_path.join(name)
+    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,47 @@
+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>
+  #
+  class BoxCollection < Array
+    # The environment this box collection belongs to
+    attr_reader :env
+
+    def initialize(env)
+      super()
+
+      @env = env
+      reload!
+    end
+
+    # Find a box in the collection by the given name. The name must
+    # be a string, for now.
+    def find(name)
+      each do |box|
+        return box if box.name == name
+      end
+
+      nil
+    end
+
+    # Loads the list of all boxes from the source. This modifies the
+    # current array.
+    def reload!
+      clear
+
+      Dir.open(env.boxes_path) do |dir|
+        dir.each do |d|
+          next if d == "." || d == ".." || !File.directory?(env.boxes_path.join(d))
+          self << Box.new(env, d)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/cli.rb

@@ -0,0 +1,55 @@
+require 'thor'
+
+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 }
+      end
+
+      if opts[:alias]
+        # Alises are defined for this command, so properly alias the
+        # newly defined method/subcommand:
+        map opts[:alias] => name
+      end
+    end
+  end
+end