tnargav 1.2.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2013 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# Vagrant
+
+* Website: [http://www.vagrantup.com](http://www.vagrantup.com)
+* Source: [https://github.com/mitchellh/vagrant](https://github.com/mitchellh/vagrant)
+* IRC: `#vagrant` on Freenode
+* Mailing list: [Google Groups](http://groups.google.com/group/vagrant-up)
+
+Vagrant is a tool for building and distributing development environments.
+
+Vagrant provides the framework and configuration format to create and
+manage complete portable development environments. These development
+environments can live on your computer or in the cloud, and are portable
+between Windows, Mac OS X, and Linux.
+
+## Quick Start
+
+First, make sure your development machine has [VirtualBox](http://www.virtualbox.org)
+installed. After this, [download and install the appropriate Vagrant package for your OS](http://downloads.vagrantup.com). If you're not on Mac OS X or Windows, you'll need
+to add `/opt/vagrant/bin` to your `PATH`. After this, you're ready to go!
+
+To build your first virtual environment:
+
+    vagrant init precise32 http://files.vagrantup.com/precise32.box
+    vagrant up
+
+Note: The above `vagrant up` command will also trigger Vagrant to download the
+`precise32` box via the specified URL. Vagrant only does this if it detects that
+the box doesn't already exist on your system.
+
+## Getting Started Guide
+
+To learn how to build a fully functional rails development environment, view the
+[getting started guide](http://docs.vagrantup.com/v2/getting-started/index.html).
+
+## Installing the Gem from Git
+
+If you want the bleeding edge version of Vagrant, we try to keep master pretty stable
+and you're welcome to give it a shot. The following is an example showing how to do this:
+
+    rake install
+
+## Contributing to Vagrant
+
+### Dependencies and Unit Tests
+
+To hack on vagrant, you'll need [bundler](http://github.com/carlhuda/bundler) which can
+be installed with a simple `gem install bundler`. Afterwords, do the following:
+
+    bundle install
+    rake
+
+This will run the unit test suite, which should come back all green! Then you're good to go!
+
+If you want to run Vagrant without having to install the gem, you may use `bundle exec`,
+like so:
+
+    bundle exec bin/vagrant help
+
+### Acceptance Tests
+
+Vagrant also comes with an acceptance test suite which runs the system
+end-to-end, without mocking out any dependencies. Note that this test
+suite is **extremely slow**, with the test suite taking hours on even
+a decent system. A CI will be setup in due time to run these tests
+automatically. However, it is still useful to know how to run these
+tests since it is often useful to run a single test if you're working
+on a specific feature.
+
+The acceptance tests have absolutely _zero_ dependence on the Vagrant
+source. Instead, an external configuration file must be used to give
+the acceptance tests some parameters (such as what Vagrant version is
+running, where the Vagrant `vagrant` binary is, etc.). If you want to
+run acceptance tests against source, or just want to see an example of
+this file, you can generate it automatically for the source code:
+
+    rake acceptance:config
+
+This will drop an `acceptance_config.yml` file in your working directory.
+You can then run a specific acceptance test like so:
+
+    ACCEPTANCE_CONFIG=./acceptance_config.yml ruby test/acceptance/version_test.rb
+
+That's it!
+
+If you're developing an acceptance test and you're unsure why things
+might be failing, you can also view log output for the acceptance tests,
+which can be very verbose but are a great help in finding bugs:
+
+    ACCEPTANCE_LOGGING=debug ACCEPTANCE_CONFIG=./acceptance_config.yml ruby test/acceptance/version_test.rb

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler/setup'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Load all the rake tasks from the "tasks" folder. This folder
+# allows us to nicely separate rake tasks into individual files
+# based on their role, which makes development and debugging easier
+# than one monolithic file.
+task_dir = File.expand_path("../tasks", __FILE__)
+Dir["#{task_dir}/**/*.rake"].each do |task_file|
+  load task_file
+end
+
+task :default => "test:unit"

data/bin/vagrant

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+# Trap interrupts to quit cleanly. This will be overriden at some point
+# by Vagrant. This is made to catch any interrupts while Vagrant is
+# initializing which have historically resulted in stack traces.
+Signal.trap("INT") { exit 1 }
+
+require 'log4r'
+require 'vagrant'
+require 'vagrant/cli'
+require 'vagrant/util/platform'
+
+# Create a logger right away
+logger = Log4r::Logger.new("vagrant::bin::vagrant")
+logger.info("`vagrant` invoked: #{ARGV.inspect}")
+
+# Stdout/stderr should not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# These will be the options that are passed to initialze the Vagrant
+# environment.
+opts = {}
+
+# Disable color in a few cases:
+#
+#   * --no-color is anywhere in our arguments
+#   * STDOUT is not a TTY
+#   * The terminal doesn't support colors (Windows)
+#
+if ARGV.include?("--no-color")
+  # Delete the argument from the list so that it doesn't
+  # cause any invalid arguments down the road.
+  ARGV.delete("--no-color")
+
+  opts[:ui_class] = Vagrant::UI::Basic
+elsif !Vagrant::Util::Platform.terminal_supports_colors?
+  opts[:ui_class] = Vagrant::UI::Basic
+elsif !$stdout.tty? && !Vagrant::Util::Platform.cygwin?
+    opts[:ui_class] = Vagrant::UI::Basic
+end
+
+# Default to colored output
+opts[:ui_class] ||= Vagrant::UI::Colored
+
+# This is kind of hacky, and I'd love to find a better way to do this, but
+# if we're accessing the plugin interface, we want to NOT load plugins
+# for this run, because they can actually interfere with the function
+# of the plugin interface.
+ARGV.each do |arg|
+  if !arg.start_with?("-")
+    ENV["VAGRANT_NO_PLUGINS"] = "1" if arg == "plugin"
+    break
+  end
+end
+
+env = nil
+begin
+  # Create the environment, which is the cwd of wherever the
+  # `vagrant` command was invoked from
+  logger.debug("Creating Vagrant environment")
+  env = Vagrant::Environment.new(opts)
+
+  if !Vagrant.in_installer?
+    warned = false
+
+    # If we're in a bundler environment, we assume it is for plugin
+    # development and will let the user know that.
+    if defined?(Bundler)
+      require 'bundler/shared_helpers'
+      if Bundler::SharedHelpers.in_bundle?
+        warned = true
+      end
+    end
+
+    # If we're not in the installer, warn.
+    env.ui.warn(I18n.t("vagrant.general.not_in_installer")) if !warned
+  end
+
+  begin
+    # Execute the CLI interface, and exit with the proper error code
+    exit_status = env.cli(ARGV)
+  ensure
+    # Unload the environment so cleanup can be done
+    env.unload
+  end
+
+  # Exit with the exit status from our CLI command
+  exit(exit_status)
+rescue Vagrant::Errors::VagrantError => e
+  logger.error("Vagrant experienced an error! Details:")
+  logger.error(e.inspect)
+  logger.error(e.message)
+  logger.error(e.backtrace.join("\n"))
+
+  if env
+    opts = { :prefix => false }
+    env.ui.error e.message, opts if e.message
+  else
+    $stderr.puts "Vagrant failed to initialize at a very early stage:\n\n"
+    $stderr.puts e.message
+  end
+
+  exit e.status_code if e.respond_to?(:status_code)
+  exit 999 # An error occurred with no status code defined
+end

data/config/default.rb

@@ -0,0 +1,36 @@
+Vagrant.configure("2") do |config|
+  config.vagrant.host = :detect
+
+  config.ssh.forward_agent = false
+  config.ssh.forward_x11 = false
+  config.ssh.guest_port = 22
+  config.ssh.keep_alive = true
+  config.ssh.max_tries = 100
+  config.ssh.timeout = 30
+  config.ssh.shell = "bash -l"
+
+  config.ssh.default.username = "vagrant"
+
+  config.vm.usable_port_range = (2200..2250)
+  config.vm.box_url = nil
+  config.vm.base_mac = nil
+  config.vm.graceful_halt_retry_count = 60
+  config.vm.graceful_halt_retry_interval = 1
+  config.vm.guest = :linux
+
+  # Share SSH locally by default
+  config.vm.network :forwarded_port,
+    guest: 22,
+    host: 2222,
+    id: "ssh",
+    auto_correct: true
+
+  # Share the root folder. This can then be overridden by
+  # other Vagrantfiles, if they wish.
+  config.vm.synced_folder ".", "/vagrant"
+
+  config.nfs.map_uid = :auto
+  config.nfs.map_gid = :auto
+
+  config.package.name = 'package.box'
+end

data/contrib/README.md

@@ -0,0 +1,12 @@
+# Vagrant Contrib
+
+Miscellaneous contributions which assist people in using Vagrant will
+make their way into this directory. An up-to-date list of short descriptions
+for each item will be kept below.
+
+## List of Contrib Items
+
+* `emacs` - Contains a file showing how to associate `Vagrantfile` with
+  Ruby syntax highlighting.
+* `vim` - Contains a `.vim` file for enabling Ruby syntax highlighting
+  for `Vagrantfile`s.

data/contrib/bash/completion.sh

@@ -0,0 +1,3 @@
+# Autocompletion for Vagrant just put this line in your ~/.profile or link this file into it like:
+# source /path/to/vagrant/contrib/bash/completion.sh
+complete -W "$(echo `vagrant --help | awk '/^     /{print $1}'`;)" vagrant

data/contrib/emacs/vagrant.el

@@ -0,0 +1,8 @@
+;;--------------------------------------------------------------------
+;; Teach emacs to syntax highlight Vagrantfile as Ruby.
+;;
+;; Installation: Copy the line below into your emacs configuration,
+;; or drop this file anywhere in your "~/.emacs.d" directory and be
+;; sure to "load" it.
+;;--------------------------------------------------------------------
+(add-to-list 'auto-mode-alist '("Vagrantfile$" . ruby-mode))

data/contrib/vim/vagrantfile.vim

@@ -0,0 +1,9 @@
+" Teach vim to syntax highlight Vagrantfile as ruby
+"
+" Install: $HOME/.vim/plugin/vagrant.vim
+" Author: Brandon Philips <brandon@ifup.org>
+
+augroup vagrant
+	au!
+	au BufRead,BufNewFile Vagrantfile set filetype=ruby
+augroup END

data/keys/README.md

@@ -0,0 +1,17 @@
+# Insecure Keypair
+
+These keys are the "insecure" public/private keypair we offer to
+[base box creators](http://docs.vagrantup.com/v1/docs/base_boxes.html) for use in their base boxes so that
+vagrant installations can automatically SSH into the boxes.
+
+If you're working with a team or company or with a custom box and
+you want more secure SSH, you should create your own keypair
+and configure the private key in the Vagrantfile with
+`config.ssh.private_key_path`
+
+# Putty
+
+If you are using Vagrant on windows, the .ppk file contained here, in the keys directory,
+has been generated from the private key and should be used to connect Putty to any VMs that 
+are leveraging the default key pair. See [guide](http://docs.vagrantup.com/v1/docs/getting-started/ssh.html) 
+in the documentation for more details on using Putty with Vagrant.

data/keys/vagrant

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzI
+w+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoP
+kcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2
+hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NO
+Td0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcW
+yLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQIBIwKCAQEA4iqWPJXtzZA68mKd
+ELs4jJsdyky+ewdZeNds5tjcnHU5zUYE25K+ffJED9qUWICcLZDc81TGWjHyAqD1
+Bw7XpgUwFgeUJwUlzQurAv+/ySnxiwuaGJfhFM1CaQHzfXphgVml+fZUvnJUTvzf
+TK2Lg6EdbUE9TarUlBf/xPfuEhMSlIE5keb/Zz3/LUlRg8yDqz5w+QWVJ4utnKnK
+iqwZN0mwpwU7YSyJhlT4YV1F3n4YjLswM5wJs2oqm0jssQu/BT0tyEXNDYBLEF4A
+sClaWuSJ2kjq7KhrrYXzagqhnSei9ODYFShJu8UWVec3Ihb5ZXlzO6vdNQ1J9Xsf
+4m+2ywKBgQD6qFxx/Rv9CNN96l/4rb14HKirC2o/orApiHmHDsURs5rUKDx0f9iP
+cXN7S1uePXuJRK/5hsubaOCx3Owd2u9gD6Oq0CsMkE4CUSiJcYrMANtx54cGH7Rk
+EjFZxK8xAv1ldELEyxrFqkbE4BKd8QOt414qjvTGyAK+OLD3M2QdCQKBgQDtx8pN
+CAxR7yhHbIWT1AH66+XWN8bXq7l3RO/ukeaci98JfkbkxURZhtxV/HHuvUhnPLdX
+3TwygPBYZFNo4pzVEhzWoTtnEtrFueKxyc3+LjZpuo+mBlQ6ORtfgkr9gBVphXZG
+YEzkCD3lVdl8L4cw9BVpKrJCs1c5taGjDgdInQKBgHm/fVvv96bJxc9x1tffXAcj
+3OVdUN0UgXNCSaf/3A/phbeBQe9xS+3mpc4r6qvx+iy69mNBeNZ0xOitIjpjBo2+
+dBEjSBwLk5q5tJqHmy/jKMJL4n9ROlx93XS+njxgibTvU6Fp9w+NOFD/HvxB3Tcz
+6+jJF85D5BNAG3DBMKBjAoGBAOAxZvgsKN+JuENXsST7F89Tck2iTcQIT8g5rwWC
+P9Vt74yboe2kDT531w8+egz7nAmRBKNM751U/95P9t88EDacDI/Z2OwnuFQHCPDF
+llYOUI+SpLJ6/vURRbHSnnn8a/XG+nzedGH5JGqEJNQsz+xT2axM0/W/CRknmGaJ
+kda/AoGANWrLCz708y7VYgAtW2Uf1DPOIYMdvo6fxIB5i9ZfISgcJ/bbCUkFrhoH
++vq/5CIWxCPp0f85R4qxxQ5ihxJ0YDQT9Jpx4TMss4PSavPaBH3RXow5Ohe+bYoQ
+NE5OgEXk2wVfZczCZpigBKbKZHNYcelXtTt/nP3rsCuGcM4h53s=
+-----END RSA PRIVATE KEY-----

data/keys/vagrant.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key

data/lib/vagrant/action/builder.rb

@@ -0,0 +1,174 @@
+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.tap do |b|
+    #       b.use MiddlewareA
+    #       b.use MiddlewareB
+    #     end
+    #
+    #     Vagrant::Action.run(app)
+    #
+    class Builder
+      # This is the stack of middlewares added. This should NOT be used
+      # directly.
+      #
+      # @return [Array]
+      attr_reader :stack
+
+      # This is a shortcut for a middleware sequence with only one item
+      # in it. For a description of the arguments and the documentation, please
+      # see {#use} instead.
+      #
+      # @return [Builder]
+      def self.build(middleware, *args, &block)
+        new.use(middleware, *args, &block)
+      end
+
+      def initialize
+        @stack = []
+      end
+
+      # Implement a custom copy that copies the stack variable over so that
+      # we don't clobber that.
+      def initialize_copy(original)
+        super
+
+        @stack = original.stack.dup
+      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)
+        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)
+        raise "no such middleware to insert before: #{index.inspect}" unless index
+
+        if middleware.kind_of?(Builder)
+          middleware.stack.reverse.each do |stack_item|
+            stack.insert(index, stack_item)
+          end
+        else
+          stack.insert(index, [middleware, args, block])
+        end
+      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
+
+      # 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
+          return i if item[0].respond_to?(:name) && item[0].name == object
+        end
+
+        nil
+      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)
+        app_stack = nil
+
+        # If we have action hooks, then we apply them
+        if env[:action_hooks]
+          builder = self.dup
+
+          # These are the options to pass into hook application.
+          options = {}
+
+          # If we already ran through once and did append/prepends,
+          # then don't do it again.
+          if env[:action_hooks_already_ran]
+            options[:no_prepend_or_append] = true
+          end
+
+          # Specify that we already ran, so in the future we don't repeat
+          # the prepend/append hooks.
+          env[:action_hooks_already_ran] = true
+
+          # Apply all the hooks to the new builder instance
+          env[:action_hooks].each do |hook|
+            hook.apply(builder, options)
+          end
+
+          # The stack is now the result of the new builder
+          app_stack = builder.stack.dup
+        end
+
+        # If we don't have a stack then default to using our own
+        app_stack ||= stack.dup
+
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(app_stack, env)
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/box_add.rb

@@ -0,0 +1,81 @@
+require "log4r"
+
+require "vagrant/util/downloader"
+require "vagrant/util/platform"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware will download a remote box and add it to the
+      # given box collection.
+      class BoxAdd
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::box_add")
+        end
+
+        def call(env)
+          @temp_path = env[:tmp_path].join("box" + Time.now.to_i.to_s)
+          @logger.info("Downloading box to: #{@temp_path}")
+
+          url = env[:box_url]
+          if File.file?(url) || url !~ /^[a-z0-9]+:.*$/i
+            @logger.info("URL is a file or protocol not found and assuming file.")
+            file_path = File.expand_path(url)
+            file_path = Util::Platform.cygwin_windows_path(file_path)
+            url = "file:#{file_path}"
+          end
+
+          downloader_options = {}
+          downloader_options[:insecure] = env[:box_download_insecure]
+          downloader_options[:ui] = env[:ui]
+
+          # Download the box to a temporary path. We store the temporary
+          # path as an instance variable so that the `#recover` method can
+          # access it.
+          env[:ui].info(I18n.t("vagrant.actions.box.download.downloading"))
+          begin
+            downloader = Util::Downloader.new(url, @temp_path, downloader_options)
+            downloader.download!
+          rescue Errors::DownloaderInterrupted
+            # The downloader was interrupted, so just return, because that
+            # means we were interrupted as well.
+            env[:ui].info(I18n.t("vagrant.actions.box.download.interrupted"))
+            return
+          end
+
+          # Add the box
+          env[:ui].info I18n.t("vagrant.actions.box.add.adding", :name => env[:box_name])
+          added_box = nil
+          begin
+            added_box = env[:box_collection].add(
+              @temp_path, env[:box_name], env[:box_provider], env[:box_force])
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            # Upgrade the box
+            env[:box_collection].upgrade(env[:box_name])
+
+            # Try adding it again
+            retry
+          end
+
+          # Call the 'recover' method in all cases to clean up the
+          # downloaded temporary file.
+          recover(env)
+
+          # Success, we added a box!
+          env[:ui].success(
+            I18n.t("vagrant.actions.box.add.added", name: added_box.name, provider: added_box.provider))
+
+          # Carry on!
+          @app.call(env)
+        end
+
+        def recover(env)
+          if @temp_path && File.exist?(@temp_path)
+            File.unlink(@temp_path)
+          end
+        end
+      end
+    end
+  end
+end