vagrantup 1.0.7 → 1.1.0

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

@@ -1,25 +0,0 @@
-require 'fileutils'
-
-module Vagrant
-  module Action
-    module Box
-      class Destroy
-        def initialize(app, env)
-          @app = app
-          @env = env
-        end
-
-        def call(env)
-          # Delete the existing box
-          env[:ui].info I18n.t("vagrant.actions.box.destroy.destroying", :name => env[:box_name])
-          FileUtils.rm_rf(env[:box_directory])
-
-          # Reload the box collection
-          env[:box_collection].reload!
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-module Vagrant
-  module Action
-    module Box
-      class Download
-        BASENAME = "box"
-
-        include Util
-
-        attr_reader :temp_path
-
-        def initialize(app, env)
-          @app = app
-          @env = env
-          @env["download.classes"] ||= []
-          @env["download.classes"] += [Downloaders::HTTP, Downloaders::File]
-          @downloader = nil
-        end
-
-        def call(env)
-          @env = env
-
-          download if instantiate_downloader
-          @app.call(@env)
-
-          recover(env) # called in both cases to cleanup workspace
-        end
-
-        def instantiate_downloader
-          # Assign to a temporary variable since this is easier to type out,
-          # since it is used so many times.
-          classes = @env["download.classes"]
-
-          # Find the class to use.
-          classes.each_index do |i|
-            klass = classes[i]
-
-            # Use the class if it matches the given URI or if this
-            # is the last class...
-            if classes.length == (i + 1) || klass.match?(@env["box_url"])
-              @env[:ui].info I18n.t("vagrant.actions.box.download.with", :class => klass.to_s)
-              @downloader = klass.new(@env[:ui])
-              break
-            end
-          end
-
-          # This line should never be reached, but we'll keep this here
-          # just in case for now.
-          raise Errors::BoxDownloadUnknownType if !@downloader
-
-          @downloader.prepare(@env["box_url"])
-          true
-        end
-
-        def download
-          with_tempfile do |tempfile|
-            download_to(tempfile)
-            @temp_path = @env["download.temp_path"] = tempfile.path
-          end
-        end
-
-        def recover(env)
-          if temp_path && File.exist?(temp_path)
-            env[:ui].info I18n.t("vagrant.actions.box.download.cleaning")
-            File.unlink(temp_path)
-          end
-        end
-
-        def with_tempfile
-          File.open(box_temp_path, Platform.tar_file_options) do |tempfile|
-            yield tempfile
-          end
-        end
-
-        def box_temp_path
-          @env[:tmp_path].join(BASENAME + Time.now.to_i.to_s)
-        end
-
-        def download_to(f)
-          @downloader.download!(@env["box_url"], f)
-        end
-      end
-    end
-  end
-end

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/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