vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/action.rb

@@ -2,62 +2,41 @@ require 'vagrant/action/builder'
 
 module Vagrant
   module Action
-    autoload :Builtin,     'vagrant/action/builtin'
-    autoload :Environment, 'vagrant/action/environment'
     autoload :Runner,      'vagrant/action/runner'
     autoload :Warden,      'vagrant/action/warden'
 
-    module Box
-      autoload :Destroy,   'vagrant/action/box/destroy'
-      autoload :Download,  'vagrant/action/box/download'
-      autoload :Package,   'vagrant/action/box/package'
-      autoload :Unpackage, 'vagrant/action/box/unpackage'
-      autoload :Verify,    'vagrant/action/box/verify'
-    end
-
-    module Env
-      autoload :Set, 'vagrant/action/env/set'
+    # Builtin contains middleware classes that are shipped with Vagrant-core
+    # and are thus available to all plugins as a "standard library" of sorts.
+    module Builtin
+      autoload :BoxAdd,  "vagrant/action/builtin/box_add"
+      autoload :Call,    "vagrant/action/builtin/call"
+      autoload :Confirm, "vagrant/action/builtin/confirm"
+      autoload :ConfigValidate, "vagrant/action/builtin/config_validate"
+      autoload :EnvSet,  "vagrant/action/builtin/env_set"
+      autoload :GracefulHalt, "vagrant/action/builtin/graceful_halt"
+      autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
+      autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
+      autoload :Lock, "vagrant/action/builtin/lock"
+      autoload :NFS, "vagrant/action/builtin/nfs"
+      autoload :Provision, "vagrant/action/builtin/provision"
+      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
+      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
+      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
     end
 
     module General
-      autoload :CheckVirtualbox, 'vagrant/action/general/check_virtualbox'
       autoload :Package,  'vagrant/action/general/package'
-      autoload :Validate, 'vagrant/action/general/validate'
     end
 
-    module VM
-      autoload :Boot,                'vagrant/action/vm/boot'
-      autoload :CheckAccessible,     'vagrant/action/vm/check_accessible'
-      autoload :CheckBox,            'vagrant/action/vm/check_box'
-      autoload :CheckGuestAdditions, 'vagrant/action/vm/check_guest_additions'
-      autoload :CheckPortCollisions, 'vagrant/action/vm/check_port_collisions'
-      autoload :CleanMachineFolder,  'vagrant/action/vm/clean_machine_folder'
-      autoload :ClearForwardedPorts, 'vagrant/action/vm/clear_forwarded_ports'
-      autoload :ClearNetworkInterfaces, 'vagrant/action/vm/clear_network_interfaces'
-      autoload :ClearSharedFolders,  'vagrant/action/vm/clear_shared_folders'
-      autoload :Customize,           'vagrant/action/vm/customize'
-      autoload :DefaultName,         'vagrant/action/vm/default_name'
-      autoload :Destroy,             'vagrant/action/vm/destroy'
-      autoload :DestroyUnusedNetworkInterfaces, 'vagrant/action/vm/destroy_unused_network_interfaces'
-      autoload :DiscardState,        'vagrant/action/vm/discard_state'
-      autoload :Export,              'vagrant/action/vm/export'
-      autoload :ForwardPorts,        'vagrant/action/vm/forward_ports'
-      autoload :Halt,                'vagrant/action/vm/halt'
-      autoload :HostName,            'vagrant/action/vm/host_name'
-      autoload :Import,              'vagrant/action/vm/import'
-      autoload :MatchMACAddress,     'vagrant/action/vm/match_mac_address'
-      autoload :Network,             'vagrant/action/vm/network'
-      autoload :NFS,                 'vagrant/action/vm/nfs'
-      autoload :Package,             'vagrant/action/vm/package'
-      autoload :PackageVagrantfile,  'vagrant/action/vm/package_vagrantfile'
-      autoload :Provision,           'vagrant/action/vm/provision'
-      autoload :ProvisionerCleanup,  'vagrant/action/vm/provisioner_cleanup'
-      autoload :PruneNFSExports,     'vagrant/action/vm/prune_nfs_exports'
-      autoload :Resume,              'vagrant/action/vm/resume'
-      autoload :SaneDefaults,        'vagrant/action/vm/sane_defaults'
-      autoload :ShareFolders,        'vagrant/action/vm/share_folders'
-      autoload :SetupPackageFiles,   'vagrant/action/vm/setup_package_files'
-      autoload :Suspend,             'vagrant/action/vm/suspend'
+    # This is the action that will add a box from a URL. This middleware
+    # sequence is built-in to Vagrant. Plugins can hook into this like any
+    # other middleware sequence. This is particularly useful for provider
+    # plugins, which can hook in to do things like verification of boxes
+    # that are downloaded.
+    def self.action_box_add
+      Builder.new.tap do |b|
+        b.use Builtin::BoxAdd
+      end
     end
   end
 end

data/lib/vagrant/action/builder.rb

@@ -9,18 +9,39 @@ module Vagrant
     #
     # Building an action sequence is very easy:
     #
-    #     app = Vagrant::Action::Builder.new do
-    #       use MiddlewareA
-    #       use MiddlewareB
+    #     app = Vagrant::Action::Builder.new.tap do |b|
+    #       b.use MiddlewareA
+    #       b.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?
+      # 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
@@ -38,11 +59,6 @@ module Vagrant
       #
       # @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)
@@ -57,6 +73,7 @@ module Vagrant
       # 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
         stack.insert(index, [middleware, args, block])
       end
 
@@ -92,8 +109,6 @@ module Vagrant
         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
@@ -101,27 +116,38 @@ module Vagrant
       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
 
-      # 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)
+        app_stack = nil
+
+        # If we have action hooks, then we apply them
+        if env[:action_hooks]
+          builder = self.dup
+
+          # Apply all the hooks to the new builder instance
+          env[:action_hooks].each do |hook|
+            hook.apply(builder)
+          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(stack.dup, env)
+        Warden.new(app_stack, env)
       end
     end
   end

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

@@ -0,0 +1,85 @@
+require "log4r"
+
+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)
+          # Instantiate the downloader
+          downloader = download_klass(env[:box_url]).new(env[:ui])
+          env[:ui].info I18n.t("vagrant.actions.box.download.with",
+                               :class => downloader.class.to_s)
+
+          # Download the box to a temporary path. We store the temporary
+          # path as an instance variable so that the `#recover` method can
+          # access it.
+          @temp_path = env[:tmp_path].join("box" + Time.now.to_i.to_s)
+          @logger.info("Downloading box to: #{@temp_path}")
+          File.open(@temp_path, Vagrant::Util::Platform.tar_file_options) do |f|
+            downloader.download!(env[:box_url], f)
+          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 download_klass(url)
+          # This is hardcoded for now. In the future I'd like to make this
+          # pluginnable as well.
+          classes = [Downloaders::HTTP, Downloaders::File]
+
+          # 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...
+            return klass if classes.length == (i + 1) || klass.match?(url)
+          end
+
+          # If no downloader knows how to download this file, then we
+          # raise an exception.
+          raise Errors::BoxDownloadUnknownType
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class allows a sort of "conditional" run within
+      # a single middlware sequence. It takes another middleware runnable,
+      # runs it with the same environment, then yields the resulting env to a block,
+      # allowing that block to determine the next course of action in the
+      # middleware sequence.
+      #
+      # The first argument to this middleware sequence is anywhere middleware
+      # runnable, whether it be a class, lambda, or something else that
+      # responds to `call`. This middleware runnable is run with the same
+      # environment as this class.
+      #
+      # After running, {Call} takes the environment and yields it to a block
+      # given to initialize the class, along with an instance of {Builder}.
+      # The result is used to build up a new sequence on the given builder.
+      # This builder is then run.
+      class Call
+        # For documentation, read the description of the {Call} class.
+        #
+        # @param [Object] callable A valid middleware runnable object. This
+        #   can be a class, a lambda, or an object that responds to `call`.
+        # @yield [result, builder] This block is expected to build on `builder`
+        #   which is the next middleware sequence that will be run.
+        def initialize(app, env, callable, *callable_args, &block)
+          raise ArgumentError, "A block must be given to Call" if !block
+
+          @app      = app
+          @callable = callable
+          @callable_args = callable_args
+          @block    = block
+          @child_app = nil
+        end
+
+        def call(env)
+          runner  = Runner.new
+
+          # Build the callable that we'll run
+          callable = Builder.build(@callable, *@callable_args)
+
+          # Run our callable with our environment
+          new_env = runner.run(callable, env)
+
+          # Build our new builder based on the result
+          builder = Builder.new
+          @block.call(new_env, builder)
+
+          # Run the result with our new environment
+          @child_app = builder.to_app(new_env)
+          final_env = runner.run(@child_app, new_env)
+
+          # Merge the environment into our original environment
+          env.merge!(final_env)
+
+          # Call the next step using our final environment
+          @app.call(env)
+        end
+
+        def recover(env)
+          # Call back into our compiled application and recover it.
+          @child_app.recover(env) if @child_app
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "vagrant/util/template_renderer"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class validates the configuration and raises an exception
+      # if there are any validation errors.
+      class ConfigValidate
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env.has_key?(:config_validate) || env[:config_validate]
+            errors = env[:machine].config.validate(env[:machine])
+
+            if errors && !errors.empty?
+              raise Errors::ConfigInvalid,
+                :errors => Util::TemplateRenderer.render(
+                  "config/validation_failed",
+                  :errors => errors)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This class asks the user to confirm some sort of question with
+      # a "Y/N" question. The only parameter is the text to ask the user.
+      # The result is placed in `env[:result]` so that it can be used
+      # with the {Call} class.
+      class Confirm
+        # For documentation, read the description of the {Confirm} class.
+        #
+        # @param [String] message The message to ask the user.
+        # @param [Symbol] force_key The key that if present and true in
+        #   the environment hash will skip the confirmation question.
+        def initialize(app, env, message, force_key=nil)
+          @app      = app
+          @message  = message
+          @force_key = force_key
+        end
+
+        def call(env)
+          choice = nil
+
+          # If we have a force key set and we're forcing, then set
+          # the result to "Y"
+          choice = "Y" if @force_key && env[@force_key]
+
+          # If we haven't chosen yes, then ask the user via TTY
+          choice = env[:ui].ask(@message) if !choice
+
+          # The result is only true if the user said "Y"
+          env[:result] = choice && choice.upcase == "Y"
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class allows you to modify the environment hash
+      # in the middle of a middleware sequence. The new environmental data
+      # will take affect at this stage in the middleware and will persist
+      # through.
+      class EnvSet
+        def initialize(app, env, new_env=nil)
+          @app     = app
+          @new_env = new_env || {}
+        end
+
+        def call(env)
+          # Merge in the new data
+          env.merge!(@new_env)
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end