vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/box_remove.rb

@@ -1,125 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/box_update.rb

@@ -1,20 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/call.rb

@@ -1,66 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/config_validate.rb

@@ -1,30 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/confirm.rb

@@ -1,48 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/destroy_confirm.rb

@@ -1,21 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/env_set.rb

@@ -1,24 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/graceful_halt.rb

@@ -1,85 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/handle_box.rb

@@ -1,104 +0,0 @@
-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, downloading 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.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/handle_box_url.rb

@@ -1,14 +0,0 @@
-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