vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/box_remove.rb

@@ -0,0 +1,125 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware will remove a box for a given provider.
+      class BoxRemove
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::box_remove")
+        end
+
+        def call(env)
+          box_name     = env[:box_name]
+          box_provider = env[:box_provider]
+          box_provider = box_provider.to_sym if box_provider
+          box_version  = env[:box_version]
+          box_remove_all_versions = env[:box_remove_all_versions]
+
+          boxes = {}
+          env[:box_collection].all.each do |n, v, p|
+            boxes[n] ||= {}
+            boxes[n][p] ||= []
+            boxes[n][p] << v
+          end
+
+          all_box = boxes[box_name]
+          if !all_box
+            raise Errors::BoxRemoveNotFound, name: box_name
+          end
+
+          all_versions = nil
+          if !box_provider
+            if all_box.length == 1
+              # There is only one provider, just use that.
+              all_versions = all_box.values.first
+              box_provider = all_box.keys.first
+            else
+              raise Errors::BoxRemoveMultiProvider,
+                name: box_name,
+                providers: all_box.keys.map(&:to_s).sort.join(", ")
+            end
+          else
+            all_versions = all_box[box_provider]
+            if !all_versions
+              raise Errors::BoxRemoveProviderNotFound,
+                name: box_name,
+                provider: box_provider.to_s,
+                providers: all_box.keys.map(&:to_s).sort.join(", ")
+            end
+          end
+
+          if !box_version
+            if all_versions.length == 1
+              # There is only one version, just use that.
+              box_version = all_versions.first
+            elsif not box_remove_all_versions
+              # There are multiple versions, we can't choose.
+              raise Errors::BoxRemoveMultiVersion,
+                name: box_name,
+                provider: box_provider.to_s,
+                versions: all_versions.sort.map { |k| " * #{k}" }.join("\n")
+            end
+          elsif !all_versions.include?(box_version)
+            raise Errors::BoxRemoveVersionNotFound,
+              name: box_name,
+              provider: box_provider.to_s,
+              version: box_version,
+              versions: all_versions.sort.map { |k| " * #{k}" }.join("\n")
+          end
+
+          versions_to_remove = [box_version]
+          versions_to_remove = all_versions if box_remove_all_versions
+
+          versions_to_remove.sort.each do |version_to_remove|
+            box = env[:box_collection].find(
+              box_name, box_provider, box_version)
+
+            # Verify that this box is not in use by an active machine,
+            # otherwise warn the user.
+            users = box.in_use?(env[:machine_index]) || []
+            users = users.find_all { |u| u.valid?(env[:home_path]) }
+            if !users.empty?
+              # Build up the output to show the user.
+              users = users.map do |entry|
+                "#{entry.name} (ID: #{entry.id})"
+              end.join("\n")
+
+              force_key = :force_confirm_box_remove
+              message   = I18n.t(
+                "vagrant.commands.box.remove_in_use_query",
+                name: box.name,
+                provider: box.provider,
+                version: box.version,
+                users: users) + " "
+
+              # Ask the user if we should do this
+              stack = Builder.new.tap do |b|
+                b.use Confirm, message, force_key
+              end
+
+              result = env[:action_runner].run(stack, env)
+              if !result[:result]
+                # They said "no", so continue with the next box
+                next
+              end
+            end
+
+            env[:ui].info(I18n.t("vagrant.commands.box.removing",
+                                name: box.name,
+                                provider: box.provider,
+                                version: box.version))
+            box.destroy!
+            env[:box_collection].clean(box.name)
+
+            # Passes on the removed box to the rest of the middleware chain
+            env[:box_removed] = box
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/box_update.rb

@@ -0,0 +1,20 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware updates a specific box if there are updates available.
+      class BoxUpdate
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            "vagrant::action::builtin::box_update")
+        end
+
+        def call(env)
+          machine = env[:machine]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/call.rb

@@ -0,0 +1,66 @@
+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)
+
+          # Append our own app onto the builder so we slide the new
+          # stack into our own chain...
+          builder.use @app
+          @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)
+        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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/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.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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/confirm.rb

@@ -0,0 +1,48 @@
+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, **opts)
+          @app      = app
+          @message  = message
+          @force_key = force_key
+          @allowed  = opts[:allowed]
+        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 !choice
+            while true
+              # If we haven't chosen yes, then ask the user via TTY
+              choice = env[:ui].ask(@message)
+
+              # If we don't have an allowed set just exit
+              break if !@allowed
+              break if @allowed.include?(choice)
+            end
+          end
+
+          # 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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/destroy_confirm.rb

@@ -0,0 +1,21 @@
+require_relative "confirm"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class asks the user to confirm the destruction of a machine
+      # that Vagrant manages. This is provided as a built-in on top of
+      # {Confirm} because it sets up the proper keys and such so that
+      # `vagrant destroy -f` works properly.
+      class DestroyConfirm < Confirm
+        def initialize(app, env)
+          force_key = :force_confirm_destroy
+          message   = I18n.t("vagrant.commands.destroy.confirmation",
+                             name: env[:machine].name)
+
+          super(app, env, message, force_key, allowed: ["y", "n", "Y", "N"])
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/graceful_halt.rb

@@ -0,0 +1,85 @@
+require "log4r"
+require "timeout"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class will attempt to perform a graceful shutdown
+      # of the machine using the guest implementation. This middleware is
+      # compatible with the {Call} middleware so you can branch based on
+      # the result, which is true if the halt succeeded and false otherwise.
+      class GracefulHalt
+        # Note: Any of the arguments can be arrays as well.
+        #
+        # @param [Symbol] target_state The target state ID that means that
+        #   the machine was properly shut down.
+        # @param [Symbol] source_state The source state ID that the machine
+        #   must be in to be shut down.
+        def initialize(app, env, target_state, source_state=nil)
+          @app          = app
+          @logger       = Log4r::Logger.new("vagrant::action::builtin::graceful_halt")
+          @source_state = source_state
+          @target_state = target_state
+        end
+
+        def call(env)
+          graceful = true
+          graceful = !env[:force_halt] if env.key?(:force_halt)
+
+          # By default, we didn't succeed.
+          env[:result] = false
+
+          if graceful && @source_state
+            @logger.info("Verifying source state of machine: #{@source_state.inspect}")
+
+            # If we're not in the proper source state, then we don't
+            # attempt to halt the machine
+            current_state = env[:machine].state.id
+            if current_state != @source_state
+              @logger.info("Invalid source state, not halting: #{current_state}")
+              graceful = false
+            end
+          end
+
+          # Only attempt to perform graceful shutdown under certain cases
+          # checked above.
+          if graceful
+            env[:ui].output(I18n.t("vagrant.actions.vm.halt.graceful"))
+
+            begin
+              env[:machine].guest.capability(:halt)
+
+              @logger.debug("Waiting for target graceful halt state: #{@target_state}")
+              begin
+                Timeout.timeout(env[:machine].config.vm.graceful_halt_timeout) do
+                  while env[:machine].state.id != @target_state
+                    sleep 1
+                  end
+                end
+              rescue Timeout::Error
+                # Don't worry about it, we catch the case later.
+              end
+            rescue Errors::GuestCapabilityNotFound
+              # This happens if insert_public_key is called on a guest that
+              # doesn't support it. This will block a destroy so we let it go.
+            rescue Errors::MachineGuestNotReady
+              env[:ui].detail(I18n.t("vagrant.actions.vm.halt.guest_not_ready"))
+            end
+
+            # The result of this matters on whether we reached our
+            # proper target state or not.
+            env[:result] = env[:machine].state.id == @target_state
+
+            if env[:result]
+              @logger.info("Gracefully halted.")
+            else
+              @logger.info("Graceful halt failed.")
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/handle_box.rb

@@ -0,0 +1,104 @@
+require "thread"
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This built-in middleware handles the `box` setting by verifying
+      # the box is already installed, dowloading the box if it isn't,
+      # updating the box if it is requested, etc.
+      class HandleBox
+        @@big_lock = Mutex.new
+        @@small_locks = Hash.new { |h,k| h[k] = Mutex.new }
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_box")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          if !machine.config.vm.box
+            @logger.info("Skipping HandleBox because no box is set")
+            return @app.call(env)
+          end
+
+          # Acquire a lock for this box to handle multi-threaded
+          # environments.
+          lock = nil
+          @@big_lock.synchronize do
+            lock = @@small_locks[machine.config.vm.box]
+          end
+
+          box_updated = false
+          lock.synchronize do
+            if machine.box
+              @logger.info("Machine already has box. HandleBox will not run.")
+              next
+            end
+
+            handle_box(env)
+            box_updated = true
+          end
+
+          if box_updated
+            # Reload the environment and set the VM to be the new loaded VM.
+            new_machine = machine.vagrantfile.machine(
+              machine.name, machine.provider_name,
+              machine.env.boxes, machine.data_dir, machine.env)
+            env[:machine].box = new_machine.box
+            env[:machine].config = new_machine.config
+            env[:machine].provider_config = new_machine.provider_config
+          end
+
+          @app.call(env)
+        end
+
+        def handle_box(env)
+          machine = env[:machine]
+
+          # Determine the set of formats that this box can be in
+          box_download_ca_cert = machine.config.vm.box_download_ca_cert
+          box_download_ca_path = machine.config.vm.box_download_ca_path
+          box_download_client_cert = machine.config.vm.box_download_client_cert
+          box_download_insecure = machine.config.vm.box_download_insecure
+          box_download_checksum_type = machine.config.vm.box_download_checksum_type
+          box_download_checksum = machine.config.vm.box_download_checksum
+          box_download_location_trusted = machine.config.vm.box_download_location_trusted
+          box_formats = machine.provider_options[:box_format] ||
+            machine.provider_name
+
+          version_ui = machine.config.vm.box_version
+          version_ui ||= ">= 0"
+
+          env[:ui].output(I18n.t(
+            "vagrant.box_auto_adding", name: machine.config.vm.box))
+          env[:ui].detail("Box Provider: #{Array(box_formats).join(", ")}")
+          env[:ui].detail("Box Version: #{version_ui}")
+
+          begin
+            env[:action_runner].run(Vagrant::Action.action_box_add, env.merge({
+              box_name: machine.config.vm.box,
+              box_url: machine.config.vm.box_url || machine.config.vm.box,
+              box_server_url: machine.config.vm.box_server_url,
+              box_provider: box_formats,
+              box_version: machine.config.vm.box_version,
+              box_download_client_cert: box_download_client_cert,
+              box_download_ca_cert: box_download_ca_cert,
+              box_download_ca_path: box_download_ca_path,
+              box_download_insecure: box_download_insecure,
+              box_checksum_type: box_download_checksum_type,
+              box_checksum: box_download_checksum,
+              box_download_location_trusted: box_download_location_trusted,
+            }))
+          rescue Errors::BoxAlreadyExists
+            # Just ignore this, since it means the next part will succeed!
+            # This can happen in a multi-threaded environment.
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/handle_box_url.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  module Action
+    module Builtin
+      class HandleBoxUrl < HandleBox
+        def call(env)
+          env[:ui].warn("HandleBoxUrl middleware is deprecated. Use HandleBox instead.")
+          env[:ui].warn("This is a bug with the provider. Please contact the creator")
+          env[:ui].warn("of the provider you use to fix this.")
+          super
+        end
+      end
+    end
+  end
+end