tnargav 1.3.5 → 1.3.6

data/lib/vagrant/action.rb

@@ -0,0 +1,45 @@
+require 'vagrant/action/builder'
+
+module Vagrant
+  module Action
+    autoload :Runner,      'vagrant/action/runner'
+    autoload :Warden,      'vagrant/action/warden'
+
+    # 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 :DestroyConfirm, "vagrant/action/builtin/destroy_confirm"
+      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 :ProvisionerCleanup, "vagrant/action/builtin/provisioner_cleanup"
+      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
+      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
+      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
+      autoload :WaitForCommunicator, "vagrant/action/builtin/wait_for_communicator"
+    end
+
+    module General
+      autoload :Package,  'vagrant/action/general/package'
+    end
+
+    # 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

@@ -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 [Hash] env The action environment hash
+      # @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,92 @@
+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
+
+          box_formats = env[:box_provider]
+          if box_formats
+            # Determine the formats a box can support and allow the box to
+            # be any of those formats.
+            provider_plugin = Vagrant.plugin("2").manager.providers[env[:box_provider]]
+            if provider_plugin
+              box_formats = provider_plugin[1][:box_format]
+              box_formats ||= env[:box_provider]
+            end
+          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], box_formats, 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

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,39 @@
+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"
+          env["#{@force_key}_result".to_sym] = env[:result]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end