vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,116 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware checks if there are outdated boxes. By default,
+      # it only checks locally, but if `box_outdated_refresh` is set, it
+      # will refresh the metadata associated with a box.
+      class BoxCheckOutdated
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            "vagrant::action::builtin::box_check_outdated")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          if !env[:box_outdated_force]
+            if !machine.config.vm.box_check_update
+              @logger.debug(
+                "Not checking for update: no force and no update config")
+              return @app.call(env)
+            end
+          end
+
+          if !machine.box
+            # We don't have a box. Just ignore, we can't check for
+            # outdated...
+            @logger.warn("Not checking for update, no box")
+            return @app.call(env)
+          end
+
+          box = machine.box
+          if box.version == "0" && !box.metadata_url
+            return @app.call(env)
+          end
+
+          constraints = machine.config.vm.box_version
+          # Have download options specified in the environment override
+          # options specified for the machine.
+          download_options = {
+            automatic_check: !env[:box_outdated_force],
+            ca_cert: env[:ca_cert] || machine.config.vm.box_download_ca_cert,
+            ca_path: env[:ca_path] || machine.config.vm.box_download_ca_path,
+            client_cert: env[:client_cert] ||
+                           machine.config.vm.box_download_client_cert,
+            insecure: !env[:insecure].nil? ?
+                        env[:insecure] : machine.config.vm.box_download_insecure,
+            disable_ssl_revoke_best_effort: env.fetch(:box_download_disable_ssl_revoke_best_effort,
+                                                      machine.config.vm.box_download_disable_ssl_revoke_best_effort),
+            box_extra_download_options: env[:box_extra_download_options] || machine.config.vm.box_extra_download_options,
+          }
+
+          env[:ui].output(I18n.t(
+            "vagrant.box_outdated_checking_with_refresh",
+            name: box.name,
+            version: box.version))
+          update = nil
+          begin
+            update = box.has_update?(constraints, download_options: download_options)
+          rescue Errors::BoxMetadataDownloadError => e
+            env[:ui].warn(I18n.t(
+              "vagrant.box_outdated_metadata_download_error",
+              message: e.extra_data[:message]))
+          rescue Errors::BoxMetadataMalformed  => e
+            @logger.warn(e.to_s)
+            env[:ui].warn(I18n.t("vagrant.box_malformed_continue_on_update"))
+          rescue Errors::VagrantError => e
+            raise if !env[:box_outdated_ignore_errors]
+            env[:ui].detail(I18n.t(
+              "vagrant.box_outdated_metadata_error_single",
+              message: e.message))
+          end
+          env[:box_outdated] = update != nil
+          local_update = check_outdated_local(env)
+          if update && (local_update.nil? || (local_update.version < update[1].version))
+            env[:ui].warn(I18n.t(
+              "vagrant.box_outdated_single",
+              name: update[0].name,
+              provider: box.provider,
+              current: box.version,
+              latest: update[1].version))
+          elsif local_update
+            env[:ui].warn(I18n.t(
+              "vagrant.box_outdated_local",
+              name: local_update.name,
+              old: box.version,
+              new: local_update.version))
+            env[:box_outdated] = true
+          else
+            env[:box_outdated] = false
+          end
+
+          @app.call(env)
+        end
+
+        def check_outdated_local(env)
+          machine = env[:machine]
+
+          # Make sure we respect the constraints set within the Vagrantfile
+          version = machine.config.vm.box_version
+          version += ", " if version
+          version ||= ""
+          version += "> #{machine.box.version}"
+
+          env[:box_collection].find(
+            machine.box.name, machine.box.provider, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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_architecture = env[:box_architecture] if env[:box_architecture]
+          box_provider = env[:box_provider].to_sym if env[:box_provider]
+          box_version  = env[:box_version]
+          box_remove_all_versions = env[:box_remove_all_versions]
+          box_remove_all_providers = env[:box_remove_all_providers]
+          box_remove_all_architectures = env[:box_remove_all_architectures]
+
+          box_info = Util::HashWithIndifferentAccess.new
+          env[:box_collection].all.each do |name, version, provider, architecture|
+            next if name != box_name
+            box_info[version] ||= Util::HashWithIndifferentAccess.new
+            box_info[version][provider] ||= []
+            box_info[version][provider] << architecture
+          end
+
+          # If there's no box info, then the box doesn't exist here
+          if box_info.empty?
+            raise Errors::BoxRemoveNotFound, name: box_name
+          end
+
+          # Filtering only matters if not removing all versions
+          if !box_remove_all_versions
+            # If no version was provided, and not removing all versions,
+            # only allow one version to proceed
+            if !box_version && box_info.size > 1
+              raise Errors::BoxRemoveMultiVersion,
+                name: box_name,
+                versions: box_info.keys.sort.map { |k| " * #{k}" }.join("\n")
+            end
+
+            # If a version was provided, make sure it exists
+            if box_version
+              if !box_info.keys.include?(box_version)
+                raise Errors::BoxRemoveVersionNotFound,
+                  name: box_name,
+                  version: box_version,
+                  versions: box_info.keys.sort.map { |k| " * #{k}" }.join("\n")
+              else
+                box_info.delete_if { |k, _| k != box_version }
+              end
+            end
+
+            # Only a single version remains
+            box_version = box_info.keys.first
+
+            # Further filtering only matters if not removing all providers
+            if !box_remove_all_providers
+              # If no provider was given, check if there are more
+              # than a single provider for the version
+              if !box_provider && box_info.values.first.size > 1
+                raise Errors::BoxRemoveMultiProvider,
+                  name: box_name,
+                  version: box_version,
+                  providers: box_info.values.first.keys.map(&:to_s).sort.join(", ")
+              end
+
+              # If a provider was given, check the version has it
+              if box_provider
+                if !box_info.values.first.key?(box_provider)
+                  raise Errors::BoxRemoveProviderNotFound,
+                    name: box_name,
+                    version: box_version,
+                    provider: box_provider.to_s,
+                    providers: box_info.values.first.keys.map(&:to_s).sort.join(", ")
+                else
+                  box_info.values.first.delete_if { |k, _| k.to_s != box_provider.to_s }
+                end
+              end
+
+              # Only a single provider remains
+              box_provider = box_info.values.first.keys.first
+
+              # Further filtering only matters if not removing all architectures
+              if !box_remove_all_architectures
+                # If no architecture was given, check if there are more
+                # than a single architecture for the provider in version
+                if !box_architecture && box_info.values.first.values.first.size > 1
+                  raise Errors::BoxRemoveMultiArchitecture,
+                    name: box_name,
+                    version: box_version,
+                    provider: box_provider.to_s,
+                    architectures: box_info.values.first.values.first.sort.join(", ")
+                end
+
+                # If architecture was given, check the provider for the version has it
+                if box_architecture
+                  if !box_info.values.first.values.first.include?(box_architecture)
+                    raise Errors::BoxRemoveArchitectureNotFound,
+                      name: box_name,
+                      version: box_version,
+                      provider: box_provider.to_s,
+                      architecture: box_architecture,
+                      architectures: box_info.values.first.values.first.sort.join(", ")
+                  else
+                    box_info.values.first.values.first.delete_if { |v| v != box_architecture }
+                  end
+                end
+              end
+            end
+          end
+
+          box_info.each do |version, provider_info|
+            provider_info.each do |provider, architecture_info|
+              provider = provider.to_sym
+              architecture_info.each do |architecture|
+                box = env[:box_collection].find(
+                  box_name, provider, version, architecture
+                )
+
+                # 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,
+                    architecture: box.architecture,
+                    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
+
+                  # Keep used boxes, even if "force" is applied
+                  keep_used_boxes = env[:keep_used_boxes]
+
+                  result = env[:action_runner].run(stack, env)
+                  if !result[:result] || keep_used_boxes
+                    # They said "no", so continue with the next box
+                    next
+                  end
+                end
+
+                env[:ui].info(I18n.t("vagrant.commands.box.removing",
+                  name: box.name,
+                  architecture: box.architecture,
+                  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
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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/lib/vagrant/action/builtin/call.rb

@@ -0,0 +1,69 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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/lib/vagrant/action/builtin/cleanup_disks.rb

@@ -0,0 +1,59 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "json"
+
+module Vagrant
+  module Action
+    module Builtin
+      class CleanupDisks
+        # Removes any attached disks no longer defined in a Vagrantfile config
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::disk")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          defined_disks = get_disks(machine, env)
+
+          # Call into providers machine implementation for disk management
+          disk_meta_file = read_disk_metadata(machine)
+
+          if !disk_meta_file.empty?
+            if machine.provider.capability?(:cleanup_disks)
+              machine.provider.capability(:cleanup_disks, defined_disks, disk_meta_file)
+            else
+              env[:ui].warn(I18n.t("vagrant.actions.disk.provider_unsupported",
+                                   provider: machine.provider_name))
+            end
+          end
+
+          # Continue On
+          @app.call(env)
+        end
+
+        def read_disk_metadata(machine)
+          meta_file = machine.data_dir.join("disk_meta")
+          if File.file?(meta_file)
+            disk_meta = JSON.parse(meta_file.read)
+          else
+            @logger.info("No previous disk_meta file defined for guest #{machine.name}")
+            disk_meta = {}
+          end
+
+          return disk_meta
+        end
+
+        def get_disks(machine, env)
+          return @_disks if @_disks
+
+          @_disks = []
+          @_disks = machine.config.vm.disks
+
+          @_disks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/mime'
+require 'tmpdir'
+
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitSetup
+        TEMP_PREFIX = "vagrant-cloud-init-iso-temp-".freeze
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinit::setup")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          user_data_configs = machine.config.vm.cloud_init_configs
+                                                  .select { |c| c.type == :user_data }
+
+          if !user_data_configs.empty?
+            user_data = setup_user_data(machine, env, user_data_configs)
+            meta_data = { "instance-id" => "i-#{machine.id.split('-').join}" }
+
+            write_cfg_iso(machine, env, user_data, meta_data)
+          end
+
+          # Continue On
+          @app.call(env)
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [Array<#VagrantPlugins::Kernel_V2::VagrantConfigCloudInit>] user_data_cfgs
+        # @return [Vagrant::Util::Mime::MultiPart] user_data
+        def setup_user_data(machine, env, user_data_cfgs)
+          machine.ui.info(I18n.t("vagrant.actions.vm.cloud_init_user_data_setup"))
+
+          text_cfgs = user_data_cfgs.map { |cfg| read_text_cfg(machine, cfg) }
+
+          user_data = generate_cfg_msg(machine, text_cfgs)
+          user_data
+        end
+
+        # Reads an individual cloud_init config and stores its contents and the
+        # content_type as a MIME text
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigCloudInit] cfg
+        # @return [Vagrant::Util::Mime::Entity] text_msg
+        def read_text_cfg(machine, cfg)
+          if cfg.path
+            text = File.read(Pathname.new(cfg.path).expand_path(machine.env.root_path))
+          else
+            text = cfg.inline
+          end
+
+          text_msg = Vagrant::Util::Mime::Entity.new(text, cfg.content_type)
+          text_msg.disposition = "attachment; filename=\"#{File.basename(cfg.content_disposition_filename).gsub('"', '\"')}\"" if cfg.content_disposition_filename
+          text_msg
+        end
+
+        # Combines all known cloud_init configs into a multipart mixed MIME text
+        # message
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Array<Vagrant::Util::Mime::Entity>] text_msg - One or more text configs
+        # @return [Vagrant::Util::Mime::Multipart] msg
+        def generate_cfg_msg(machine, text_cfgs)
+          msg = Vagrant::Util::Mime::Multipart.new
+          msg.headers["MIME-Version"] = "1.0"
+
+          text_cfgs.each do |c|
+            msg.add(c)
+          end
+
+          msg
+        end
+
+        # Writes the contents of the guests cloud_init config to a tmp
+        # dir and passes that source directory along to the host cap to be
+        # written to an iso
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Util::Mime::Multipart] user_data
+        # @param [Hash] meta_data
+        def write_cfg_iso(machine, env, user_data, meta_data)
+          iso_path = nil
+
+          if env[:env].host.capability?(:create_iso)
+            begin
+              source_dir = Pathname.new(Dir.mktmpdir(TEMP_PREFIX))
+              File.open("#{source_dir}/user-data", 'w') { |file| file.write(user_data.to_s) }
+
+              File.open("#{source_dir}/meta-data", 'w') { |file| file.write(meta_data.to_yaml) }
+
+              iso_path = env[:env].host.capability(:create_iso,
+                                                   source_dir, volume_id: "cidata")
+              attach_disk_config(machine, env, iso_path.to_path)
+            ensure
+              FileUtils.remove_entry(source_dir)
+            end
+          else
+            raise Errors::CreateIsoHostCapNotFound
+          end
+        end
+
+        # Adds a new :dvd disk config with the given iso_path to be attached
+        # to the guest later
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [String] iso_path
+        def attach_disk_config(machine, env, iso_path)
+          @logger.info("Adding cloud_init iso '#{iso_path}' to disk config")
+          machine.config.vm.disk :dvd, file: iso_path, name: "vagrant-cloud_init-disk"
+          machine.config.vm.disks.each { |d| d.finalize! if d.type == :dvd && d.file == iso_path }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitWait
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinitwait")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          cloud_init_wait_cmd = "cloud-init status --wait"
+          if !machine.config.vm.cloud_init_configs.empty?
+            if machine.communicate.test("command -v cloud-init")
+              env[:ui].output(I18n.t("vagrant.cloud_init_waiting"))
+              result = machine.communicate.sudo(cloud_init_wait_cmd, error_check: false)
+              if result != 0
+                raise Vagrant::Errors::CloudInitCommandFailed, cmd: cloud_init_wait_cmd, guest_name: machine.name
+              end
+            else
+              raise Vagrant::Errors::CloudInitNotFound, guest_name: machine.name
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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], env[:ignore_provider])
+
+            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,51 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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