vagrant 1.0.7 → 1.5.0

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

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

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

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

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

@@ -1,171 +0,0 @@
-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
-            use VM::CheckGuestAdditions
-          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::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

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

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

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