vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,29 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class is used to delay execution until the end of
+      # a configured stack
+      class Delayed
+        # @param [Object] callable The object to call (must respond to #call)
+        def initialize(app, env, callable)
+          if !callable.respond_to?(:call)
+            raise TypeError, "Callable argument is expected to respond to `#call`"
+          end
+          @app         = app
+          @env         = env
+          @callable    = callable
+        end
+
+        def call(env)
+          # Allow the rest of the call stack to execute
+          @app.call(env)
+          # Now call our delayed stack
+          @callable.call(env)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,55 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "json"
+
+module Vagrant
+  module Action
+    module Builtin
+      class Disk
+        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
+          configured_disks = {}
+          if !defined_disks.empty?
+            if machine.provider.capability?(:configure_disks)
+             configured_disks = machine.provider.capability(:configure_disks, defined_disks)
+            else
+              env[:ui].warn(I18n.t("vagrant.actions.disk.provider_unsupported",
+                                 provider: machine.provider_name))
+            end
+          end
+
+          write_disk_metadata(machine, configured_disks) unless configured_disks.empty?
+
+          # Continue On
+          @app.call(env)
+        end
+
+        def write_disk_metadata(machine, current_disks)
+          meta_file = machine.data_dir.join("disk_meta")
+          @logger.debug("Writing disk metadata file to #{meta_file}")
+          File.open(meta_file.to_s, "w+") do |file|
+            file.write(JSON.dump(current_disks))
+          end
+        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/env_set.rb

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

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

@@ -0,0 +1,111 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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 || machine.config.vm.box.to_s.empty?
+            @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_download_disable_ssl_revoke_best_effort = machine.config.vm.box_download_disable_ssl_revoke_best_effort
+          box_extra_download_options = machine.config.vm.box_extra_download_options
+          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_architecture: machine.config.vm.box_architecture,
+              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,
+              box_download_disable_ssl_revoke_best_effort: box_download_disable_ssl_revoke_best_effort,
+              box_extra_download_options: box_extra_download_options,
+            }))
+          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/lib/vagrant/action/builtin/handle_box_url.rb

@@ -0,0 +1,17 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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

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

@@ -0,0 +1,300 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "set"
+require "log4r"
+require "socket"
+
+require "vagrant/util/is_port_open"
+require "vagrant/util/ipv4_interfaces"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class will detect and handle collisions with
+      # forwarded ports, whether that means raising an error or repairing
+      # them automatically.
+      #
+      # Parameters it takes from the environment hash:
+      #
+      #   * `:port_collision_repair` - If true, it will attempt to repair
+      #     port collisions. If false, it will raise an exception when
+      #     there is a collision.
+      #
+      #   * `:port_collision_extra_in_use` - An array of ports that are
+      #     considered in use.
+      #
+      #   * `:port_collision_remap` - A hash remapping certain host ports
+      #     to other host ports.
+      #
+      class HandleForwardedPortCollisions
+        include Util::IsPortOpen
+        include Util::IPv4Interfaces
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_port_collisions")
+        end
+
+        def call(env)
+          @leased  = []
+          @machine = env[:machine]
+
+          # Acquire a process-level lock so that we don't choose a port
+          # that someone else also chose.
+          begin
+            env[:machine].env.lock("fpcollision") do
+              handle(env)
+            end
+          rescue Errors::EnvironmentLockedError
+            sleep 1
+            retry
+          end
+
+          @app.call(env)
+
+          # Always run the recover method so that we release leases
+          recover(env)
+        end
+
+        def recover(env)
+          lease_release
+        end
+
+        protected
+
+        def handle(env)
+          @logger.info("Detecting any forwarded port collisions...")
+
+          # Get the extra ports we consider in use
+          extra_in_use = env[:port_collision_extra_in_use] || {}
+
+          # If extras are provided as an Array (previous behavior) convert
+          # to Hash as expected for IP aliasing support
+          if extra_in_use.is_a?(Array)
+            extra_in_use = Hash[extra_in_use.map{|port| [port, Set.new(["*"])]}]
+          end
+
+          # Get the remap
+          remap = env[:port_collision_remap] || {}
+
+          # Determine the handler we'll use if we have any port collisions
+          repair = !!env[:port_collision_repair]
+
+          # The method we'll use to check if a port is open.
+          port_checker = env[:port_collision_port_check]
+          port_checker ||= method(:port_check)
+
+          # Log out some of our parameters
+          @logger.debug("Extra in use: #{extra_in_use.inspect}")
+          @logger.debug("Remap: #{remap.inspect}")
+          @logger.debug("Repair: #{repair.inspect}")
+
+          # Determine a list of usable ports for repair
+          usable_ports = Set.new(env[:machine].config.vm.usable_port_range)
+          usable_ports.subtract(extra_in_use.keys)
+
+          # Pass one, remove all defined host ports from usable ports
+          with_forwarded_ports(env) do |options|
+            usable_ports.delete(options[:host])
+          end
+
+          # Pass two, detect/handle any collisions
+          with_forwarded_ports(env) do |options|
+            guest_port = options[:guest]
+            host_port  = options[:host]
+            host_ip    = options[:host_ip]
+
+            if options[:disabled]
+              @logger.debug("Skipping disabled port #{host_port}.")
+              next
+            end
+
+            if options[:protocol] && options[:protocol] != "tcp"
+              @logger.debug("Skipping #{host_port} because UDP protocol.")
+              next
+            end
+
+            if remap[host_port]
+              remap_port = remap[host_port]
+              @logger.debug("Remap port override: #{host_port} => #{remap_port}")
+              host_port = remap_port
+            end
+
+            # If the port is open (listening for TCP connections)
+            in_use = is_forwarded_already(extra_in_use, host_port, host_ip) ||
+              call_port_checker(port_checker, host_ip, host_port) ||
+              lease_check(host_ip, host_port)
+
+            if in_use
+              if !repair || !options[:auto_correct]
+                raise Errors::ForwardPortCollision,
+                  guest_port: guest_port.to_s,
+                  host_port:  host_port.to_s
+              end
+
+              @logger.info("Attempting to repair FP collision: #{host_port}")
+
+              repaired_port = nil
+              while !usable_ports.empty?
+                # Attempt to repair the forwarded port
+                repaired_port = usable_ports.to_a.sort[0]
+                usable_ports.delete(repaired_port)
+
+                # If the port is in use, then we can't use this either...
+                in_use = is_forwarded_already(extra_in_use, repaired_port, host_ip) ||
+                  call_port_checker(port_checker, host_ip, repaired_port) ||
+                  lease_check(host_ip, repaired_port)
+                if in_use
+                  @logger.info("Repaired port also in use: #{repaired_port}. Trying another...")
+                  next
+                end
+
+                # We have a port so break out
+                break
+              end
+
+              # If we have no usable ports then we can't repair
+              if !repaired_port && usable_ports.empty?
+                raise Errors::ForwardPortAutolistEmpty,
+                  vm_name:    env[:machine].name,
+                  guest_port: guest_port.to_s,
+                  host_port:  host_port.to_s
+              end
+
+              # Modify the args in place
+              options[:host] = repaired_port
+
+              @logger.info("Repaired FP collision: #{host_port} to #{repaired_port}")
+
+              # Notify the user
+              env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
+                                   host_port:  host_port.to_s,
+                                   guest_port: guest_port.to_s,
+                                   new_port:   repaired_port.to_s))
+            end
+          end
+        end
+
+        def lease_check(host_ip=nil, host_port)
+          # Check if this port is "leased". We use a leasing system of
+          # about 60 seconds to avoid any forwarded port collisions in
+          # a highly parallelized environment.
+          leasedir = @machine.env.data_dir.join("fp-leases")
+          leasedir.mkpath
+
+          if host_ip.nil?
+            lease_file_name = host_port.to_s
+          else
+            lease_file_name = "#{host_ip.gsub('.','_')}_#{host_port.to_s}"
+          end
+
+          invalid = false
+          oldest  = Time.now.to_i - 60
+          leasedir.children.each do |child|
+            # Delete old, invalid leases while we're looking
+            if child.file? && child.mtime.to_i < oldest
+              child.delete
+            end
+
+            if child.basename.to_s == lease_file_name
+              invalid = true
+            end
+          end
+
+          # If its invalid, then the port is "open" and in use
+          return true if invalid
+
+          # Otherwise, create the lease
+          leasedir.join(lease_file_name).open("w+") do |f|
+            f.binmode
+            f.write(Time.now.to_i.to_s + "\n")
+          end
+
+          # Add to the leased array so we unlease it right away
+          @leased << lease_file_name
+
+          # Things look good to us!
+          false
+        end
+
+        def lease_release
+          leasedir = @machine.env.data_dir.join("fp-leases")
+
+          @leased.each do |port|
+            path = leasedir.join(port)
+            path.delete if path.file?
+          end
+        end
+
+        # This functions checks to see if the current instance's hostport and
+        # hostip for forwarding is in use by the virtual machines created
+        # previously.
+        def is_forwarded_already(extra_in_use, hostport, hostip)
+          hostip = '*' if hostip.nil? || hostip.empty?
+          # ret. false if none of the VMs we spun up had this port forwarded.
+          return false if not extra_in_use.has_key?(hostport)
+
+          # ret. true if the user has requested to bind on all interfaces but
+          # we already have a rule in one the VMs we spun up.
+          if hostip == '*'
+            if extra_in_use.fetch(hostport).size != 0
+              return true
+            else
+              return false
+            end
+          end
+
+          return extra_in_use.fetch(hostport).include?(hostip)
+        end
+
+        def port_check(host_ip, host_port)
+          self.class.port_check(@machine, host_ip, host_port)
+        end
+
+        def self.port_check(machine, host_ip, host_port)
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_port_collisions")
+          # If no host_ip is specified, intention taken to be listen on all interfaces.
+          test_host_ip = host_ip || "0.0.0.0"
+          if Util::Platform.windows? && test_host_ip == "0.0.0.0"
+            @logger.debug("Testing port #{host_port} on all IPv4 interfaces...")
+            available_interfaces = Vagrant::Util::IPv4Interfaces.ipv4_interfaces.select do |interface|
+              @logger.debug("Testing #{interface[0]} with IP address #{interface[1]}")
+              !Vagrant::Util::IsPortOpen.is_port_open?(interface[1], host_port)
+            end
+            if available_interfaces.empty?
+              @logger.debug("Cannot forward port #{host_port} on any interfaces.")
+              true
+            else
+              @logger.debug("Port #{host_port} will forward to the guest on the following interfaces: #{available_interfaces}")
+              false
+            end
+          else
+            # Do a regular check
+            if test_host_ip != "0.0.0.0" && !Addrinfo.ip(test_host_ip).ipv4_loopback? &&
+                Vagrant::Util::IPv4Interfaces.ipv4_interfaces.none? { |iface| iface[1] == test_host_ip }
+              @logger.warn("host IP address is not local to this device host_ip=#{test_host_ip}")
+            end
+            Vagrant::Util::IsPortOpen.is_port_open?(test_host_ip, host_port)
+          end
+        end
+
+        def with_forwarded_ports(env)
+          env[:machine].config.vm.networks.each do |type, options|
+            # Ignore anything but forwarded ports
+            next if type != :forwarded_port
+
+            yield options
+          end
+        end
+
+        def call_port_checker(port_checker, host_ip, host_port)
+          call_args = [host_ip, host_port]
+          # Trim args if checker method does not support inclusion of host_ip
+          call_args = call_args.slice(call_args.size - port_checker.arity.abs, port_checker.arity.abs)
+          port_checker[*call_args]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware is used with Call to test if this machine
+      # has available provisioners
+      class HasProvisioner
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::has_provisioner")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          if machine.provider.capability?(:has_communicator)
+            has_communicator = machine.provider.capability(:has_communicator)
+          else
+            has_communicator = true
+          end
+
+          env[:skip] = []
+          if !has_communicator
+            machine.config.vm.provisioners.each do |p|
+              if p.communicator_required
+                env[:skip].push(p)
+                @logger.info("Skipping running provisioner #{p.name || 'no name'}, type: #{p.type}")
+                p.run = :never
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end