boxcar 0.10005.1

data/lib/vagrant/action/box/package.rb

@@ -0,0 +1,19 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  module Action
+    module Box
+      # Packages a box which has already been unpackaged (such as
+      # for the `vagrant box repackage` command) by leveraging the
+      # general packager middleware.
+      class Package < General::Package
+        # Alias instead of calling super for testability
+        alias_method :general_call, :call
+        def call(env)
+          env["package.directory"] = env["box_directory"]
+          general_call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/box/unpackage.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
+module Vagrant
+  module Action
+    module Box
+      # Unpackages a downloaded box to a given directory with a given
+      # name.
+      #
+      # # Required Variables
+      #
+      # * `download.temp_path` - A location for the downloaded box. This is
+      #   set by the {Download} action.
+      # * `box` - A {Vagrant::Box} object.
+      #
+      class Unpackage
+        attr_reader :box_directory
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+
+          setup_box_directory
+          decompress
+
+          @app.call(@env)
+        end
+
+        def recover(env)
+          if box_directory && File.directory?(box_directory)
+            FileUtils.rm_rf(box_directory)
+          end
+        end
+
+        def setup_box_directory
+          if File.directory?(@env["box_directory"])
+            raise Errors::BoxAlreadyExists, :name => @env["box_name"]
+          end
+
+          FileUtils.mkdir_p(@env["box_directory"])
+          @box_directory = @env["box_directory"]
+        end
+
+        def decompress
+          Dir.chdir(@env["box_directory"]) do
+            @env[:ui].info I18n.t("vagrant.actions.box.unpackage.extracting")
+            begin
+              Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box_directory"].to_s)
+            rescue SystemCallError
+              raise Errors::BoxUnpackageFailure
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/box/verify.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  module Action
+    module Box
+      class Verify
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env[:ui].info I18n.t("vagrant.actions.box.verify.verifying")
+
+          driver = Driver::VirtualBox.new(nil)
+          if !driver.verify_image(env["box_directory"].join("box.ovf").to_s)
+            raise Errors::BoxVerificationFailed
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builder.rb

@@ -0,0 +1,128 @@
+module Vagrant
+  module Action
+    # Action builder which provides a nice DSL for building up
+    # a middleware sequence for Vagrant actions. This code is based
+    # heavily off of `Rack::Builder` and `ActionDispatch::MiddlewareStack`
+    # in Rack and Rails, respectively.
+    #
+    # Usage
+    #
+    # Building an action sequence is very easy:
+    #
+    #     app = Vagrant::Action::Builder.new do
+    #       use MiddlewareA
+    #       use MiddlewareB
+    #     end
+    #
+    #     Vagrant::Action.run(app)
+    #
+    class Builder
+      # Initializes the builder. An optional block can be passed which
+      # will be evaluated in the context of the instance.
+      def initialize(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      # Returns a mergeable version of the builder. If `use` is called with
+      # the return value of this method, then the stack will merge, instead
+      # of being treated as a separate single middleware.
+      def flatten
+        lambda do |env|
+          self.call(env)
+        end
+      end
+
+      # Adds a middleware class to the middleware stack. Any additional
+      # args and a block, if given, are saved and passed to the initializer
+      # of the middleware.
+      #
+      # @param [Class] middleware The middleware class
+      def use(middleware, *args, &block)
+        # Prepend with a environment setter if args are given
+        if !args.empty? && args.first.is_a?(Hash) && middleware != Env::Set
+          self.use(Env::Set, args.shift, &block)
+        end
+
+        if middleware.kind_of?(Builder)
+          # Merge in the other builder's stack into our own
+          self.stack.concat(middleware.stack)
+        else
+          self.stack << [middleware, args, block]
+        end
+
+        self
+      end
+
+      # Inserts a middleware at the given index or directly before the
+      # given middleware object.
+      def insert(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.insert(index, [middleware, args, block])
+      end
+
+      alias_method :insert_before, :insert
+
+      # Inserts a middleware after the given index or middleware object.
+      def insert_after(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        raise "no such middleware to insert after: #{index.inspect}" unless index
+        insert(index + 1, middleware, *args, &block)
+      end
+
+      # Replaces the given middlware object or index with the new
+      # middleware.
+      def replace(index, middleware, *args, &block)
+        if index.is_a?(Integer)
+          delete(index)
+          insert(index, middleware, *args, &block)
+        else
+          insert_before(index, middleware, *args, &block)
+          delete(index)
+        end
+      end
+
+      # Deletes the given middleware object or index
+      def delete(index)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.delete_at(index)
+      end
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+
+      protected
+
+      # Returns the numeric index for the given middleware object.
+      #
+      # @param [Object] object The item to find the index for
+      # @return [Integer]
+      def index(object)
+        stack.each_with_index do |item, i|
+          return i if item[0] == object
+        end
+
+        nil
+      end
+
+      # Returns the current stack of middlewares. You probably won't
+      # need to use this directly, and it's recommended that you don't.
+      #
+      # @return [Array]
+      def stack
+        @stack ||= []
+      end
+
+      # Converts the builder stack to a runnable action sequence.
+      #
+      # @param [Vagrant::Action::Environment] env The action environment
+      # @return [Object] A callable object
+      def to_app(env)
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(stack.dup, env)
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin.rb

@@ -0,0 +1,171 @@
+module Vagrant
+  module Action
+    # A registry object containing the built-in middleware stacks.
+    class Builtin < Registry
+      def initialize
+        # Properly initialize the registry object
+        super
+
+        # Register all the built-in stacks
+        register_builtin!
+      end
+
+      protected
+
+      def register_builtin!
+        # We do this so that the blocks below have a variable to access the
+        # outer registry.
+        registry = self
+
+        # provision - Provisions a running VM
+        register(:provision) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::Provision
+          end
+        end
+
+        # start - Starts a VM, assuming it already exists on the
+        # environment.
+        register(:start) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CleanMachineFolder
+            use VM::ClearForwardedPorts
+            use VM::CheckPortCollisions, :port_collision_handler => :correct
+            use VM::ForwardPorts
+            use VM::Provision
+            use VM::PruneNFSExports
+            use VM::NFS
+            use VM::ClearSharedFolders
+            use VM::ShareFolders
+            use VM::HostName
+            use VM::ClearNetworkInterfaces
+            use VM::Network
+            use VM::SaneDefaults
+            use VM::Customize
+            use VM::Boot
+          end
+        end
+
+        # halt - Halts the VM, attempting gracefully but then forcing
+        # a restart if fails.
+        register(:halt) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::DiscardState
+            use VM::Halt
+          end
+        end
+
+        # suspend - Suspends the VM
+        register(:suspend) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::Suspend
+          end
+        end
+
+        # resume - Resume a VM
+        register(:resume) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CheckPortCollisions
+            use VM::Resume
+          end
+        end
+
+        # reload - Halts then restarts the VM
+        register(:reload) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use registry.get(:halt)
+            use registry.get(:start)
+          end
+        end
+
+        # up - Imports, prepares, then starts a fresh VM.
+        register(:up) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CheckBox
+            use VM::Import
+            use VM::CheckGuestAdditions
+            use VM::DefaultName
+            use VM::MatchMACAddress
+            use registry.get(:start)
+          end
+        end
+
+        # destroy - Halts, cleans up, and destroys an existing VM
+        register(:destroy) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use registry.get(:halt), :force => true
+            use VM::ProvisionerCleanup
+            use VM::PruneNFSExports
+            use VM::Destroy
+            use VM::CleanMachineFolder
+            use VM::DestroyUnusedNetworkInterfaces
+          end
+        end
+
+        # package - Export and package the VM
+        register(:package) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::SetupPackageFiles
+            use VM::CheckAccessible
+            use registry.get(:halt)
+            use VM::ClearForwardedPorts
+            use VM::ClearSharedFolders
+            use VM::Export
+            use VM::PackageVagrantfile
+            use VM::Package
+          end
+        end
+
+        # box_add - Download and add a box.
+        register(:box_add) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use Box::Download
+            use Box::Unpackage
+            use Box::Verify
+          end
+        end
+
+        # box_remove - Removes/deletes a box.
+        register(:box_remove) do
+          Builder.new do
+            use Box::Destroy
+          end
+        end
+
+        # box_repackage - Repackages a box.
+        register(:box_repackage) do
+          Builder.new do
+            use Box::Package
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/env/set.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  module Action
+    module Env
+      # A middleware which just sets up the environment with some
+      # options which are passed to it.
+      class Set
+        def initialize(app, env, options=nil)
+          @app     = app
+          @options = options || {}
+        end
+
+        def call(env)
+          # Merge the options that were given to us
+          env.merge!(@options)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/environment.rb

@@ -0,0 +1,12 @@
+require 'vagrant/util/hash_with_indifferent_access'
+
+module Vagrant
+  module Action
+    # Represents an action environment which is what is passed
+    # to the `call` method of each action. This environment contains
+    # some helper methods for accessing the environment as well
+    # as being a hash, to store any additional options.
+    class Environment < Util::HashWithIndifferentAccess
+    end
+  end
+end

data/lib/vagrant/action/general/check_virtualbox.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  module Action
+    module General
+      # Checks that virtualbox is installed and ready to be used.
+      class CheckVirtualbox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Certain actions may not actually have a VM, and thus no
+          # driver, so we have to be clever about obtaining an instance
+          # of the driver.
+          driver = nil
+          driver = env[:vm].driver if env[:vm]
+          driver = Driver::VirtualBox.new(nil) if !driver
+
+          # Verify that it is ready to go! This will raise an exception
+          # if anything goes wrong.
+          driver.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end