rvagrant 0.8.7.dev

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

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      class ProvisionerCleanup
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          enabled_provisioners.each do |instance|
+            instance.cleanup
+          end
+
+          @app.call(env)
+        end
+
+        def enabled_provisioners
+          @env["config"].vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Vagrant
+  class Action
+    module VM
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env["vm"].vm.saved?
+            env.ui.info I18n.t("vagrant.actions.vm.resume.resuming")
+            env["actions"].run(Boot)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Vagrant
+  class Action
+    module VM
+      class ShareFolders
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+
+          create_metadata
+
+          @app.call(env)
+
+          mount_shared_folders
+        end
+
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
+        def shared_folders
+          @env.env.config.vm.shared_folders.inject({}) do |acc, data|
+            key, value = data
+
+            next acc if value[:disabled]
+
+            # This to prevent overwriting the actual shared folders data
+            value = value.dup
+            acc[key] = value
+            acc
+          end
+        end
+
+        def create_metadata
+          proc = lambda do |vm|
+            @env.ui.info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+            shared_folders.each do |name, data|
+              folder = VirtualBox::SharedFolder.new
+              folder.name = name
+              folder.host_path = File.expand_path(data[:hostpath], @env.env.root_path)
+              vm.shared_folders << folder
+            end
+          end
+
+          @env["vm.modify"].call(proc)
+        end
+
+        def mount_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|
+              if data[:guestpath]
+                # Guest path specified, so mount the folder to specified point
+                @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                    :name => name,
+                                    :guest_path => data[:guestpath]))
+
+                # Calculate the owner and group
+                owner = data[:owner] || @env["config"].ssh.username
+                group = data[:group] || @env["config"].ssh.username
+
+                # Mount the actual folder
+                @env["vm"].system.mount_shared_folder(ssh, name, data[:guestpath], owner, group)
+              else
+                # If no guest path is specified, then automounting is disabled
+                @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                    :name => name))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/vagrant/action/warden.rb

@@ -0,0 +1,85 @@
+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.
+    #
+    # 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) }
+      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
+          env["logger"].info("warden") { "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
+          env["logger"].info("warden") { "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)
+            env["logger"].info("warden") { "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
+
+        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,90 @@
+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_accessor :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
+
+    # 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(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 })
+    end
+
+    # Begins the process of destroying this box. This cannot be undone!
+    def destroy
+      env.actions.run(:box_remove, { "box" => self, "validate" => false })
+    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)
+    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,53 @@
+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>
+  #
+  class BoxCollection
+    include Enumerable
+    extend Forwardable
+    def_delegators :@boxes, :length, :each
+
+    # The environment this box collection belongs to
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+      @boxes = []
+
+      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
+
+    # 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.each do |d|
+          next if d == "." || d == ".." || !File.directory?(env.boxes_path.join(d))
+          @boxes << 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

data/lib/vagrant/command.rb

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