vagrant 1.5.0 → 2.4.4

data/plugins/providers/docker/action/prepare_networks.rb

@@ -0,0 +1,372 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'ipaddr'
+require 'log4r'
+
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareNetworks
+
+        include Vagrant::Util::ScopedHashOverride
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant::plugins::docker::preparenetworks')
+        end
+
+        # Generate CLI arguments for creating the docker network.
+        #
+        # @param [Hash] options Options from the network config
+        # @returns[Array<String>] Network create arguments
+        def generate_create_cli_arguments(options)
+          options.map do |key, value|
+            # If value is false, option is not set
+            next if value.to_s == "false"
+            # If value is true, consider feature flag with no value
+            opt = value.to_s == "true" ? [] : [value]
+            opt.unshift("--#{key.to_s.tr("_", "-")}")
+          end.flatten.compact
+        end
+
+        # @return [Array<Socket::Ifaddr>] interface list
+        def list_interfaces
+          Socket.getifaddrs.find_all do |i|
+            !i.addr.nil? && i.addr.ip? && !i.addr.ipv4_loopback? &&
+              !i.addr.ipv6_loopback? && !i.addr.ipv6_linklocal?
+          end
+        end
+
+        # Validates that a network name exists. If it does not
+        # exist, an exception is raised.
+        #
+        # @param [String] network_name Name of existing network
+        # @param [Hash] env Local call env
+        # @return [Boolean]
+        def validate_network_name!(network_name, env)
+          if !env[:machine].provider.driver.existing_named_network?(network_name)
+            raise Errors::NetworkNameUndefined,
+              network_name: network_name
+          end
+          true
+        end
+
+        # Validates that the provided options are compatible with a
+        # pre-existing network. Raises exceptions on invalid configurations
+        #
+        # @param [String] network_name Name of the network
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [Driver] driver Docker driver
+        # @return [Boolean]
+        def validate_network_configuration!(network_name, root_options, network_options, driver)
+          if root_options[:ip] &&
+              driver.network_containing_address(root_options[:ip]) != network_name
+            raise Errors::NetworkAddressInvalid,
+              address: root_options[:ip],
+              network_name: network_name
+          end
+          if network_options[:subnet] &&
+              driver.network_containing_address(network_options[:subnet]) != network_name
+            raise Errors::NetworkSubnetInvalid,
+              subnet: network_options[:subnet],
+              network_name: network_name
+          end
+          true
+        end
+
+        # Generate configuration for private network
+        #
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] net_options Docker scoped networking options
+        # @param [Hash] env Local call env
+        # @return [String, Hash] Network name and updated network_options
+        def process_private_network(root_options, network_options, env)
+          if root_options[:name] && validate_network_name!(root_options[:name], env)
+            network_name = root_options[:name]
+          end
+
+          if root_options[:type].to_s == "dhcp"
+            if !root_options[:ip] && !root_options[:subnet]
+              network_name = "vagrant_network" if !network_name
+              return [network_name, network_options]
+            end
+            if root_options[:subnet]
+              addr = IPAddr.new(root_options[:subnet])
+              root_options[:netmask] = addr.prefix
+            end
+          end
+
+          if root_options[:ip]
+            addr = IPAddr.new(root_options[:ip])
+          elsif addr.nil?
+            raise Errors::NetworkIPAddressRequired
+          end
+
+          # If address is ipv6, enable ipv6 support
+          network_options[:ipv6] = addr.ipv6?
+
+          # If no mask is provided, attempt to locate any existing
+          # network which contains the assigned IP address
+          if !root_options[:netmask] && !network_name
+            network_name = env[:machine].provider.driver.
+              network_containing_address(root_options[:ip])
+            # When no existing network is found, we are creating
+            # a new network. Since no mask was provided, default
+            # to /24 for ipv4 and /64 for ipv6
+            if !network_name
+              root_options[:netmask] = addr.ipv4? ? 24 : 64
+            end
+          end
+
+          # With no network name, process options to find or determine
+          # name for new network
+          if !network_name
+            if !root_options[:subnet]
+              # Only generate a subnet if not given one
+              subnet = IPAddr.new("#{addr}/#{root_options[:netmask]}")
+              network = "#{subnet}/#{root_options[:netmask]}"
+            else
+              network = root_options[:subnet]
+            end
+
+            network_options[:subnet] = network
+            existing_network = env[:machine].provider.driver.
+              network_defined?(network)
+
+            if !existing_network
+              network_name = "vagrant_network_#{network}"
+            else
+              if !existing_network.to_s.start_with?("vagrant_network")
+                env[:ui].warn(I18n.t("docker_provider.subnet_exists",
+                  network_name: existing_network,
+                  subnet: network))
+              end
+              network_name = existing_network
+            end
+          end
+
+          [network_name, network_options]
+        end
+
+        # Generate configuration for public network
+        #
+        # TODO: When the Vagrant installer upgrades to Ruby 2.5.x,
+        # remove all instances of the roundabout way of determining a prefix
+        # and instead just use the built-in `.prefix` method
+        #
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] net_options Docker scoped networking options
+        # @param [Hash] env Local call env
+        # @return [String, Hash] Network name and updated network_options
+        def process_public_network(root_options, net_options, env)
+          if root_options[:name] && validate_network_name!(root_options[:name], env)
+            network_name = root_options[:name]
+          end
+          if !network_name
+            valid_interfaces = list_interfaces
+            if valid_interfaces.empty?
+              raise Errors::NetworkNoInterfaces
+            elsif valid_interfaces.size == 1
+              bridge_interface = valid_interfaces.first
+            elsif idx = valid_interfaces.detect{|i| Array(root_options[:bridge]).include?(i.name) }
+              bridge_interface = idx
+            end
+            if !bridge_interface
+              env[:ui].info(I18n.t("vagrant.actions.vm.bridged_networking.available"),
+                prefix: false)
+              valid_interfaces.each_with_index do |int, i|
+                env[:ui].info("#{i + 1}) #{int.name}", prefix: false)
+              end
+              env[:ui].info(I18n.t(
+                "vagrant.actions.vm.bridged_networking.choice_help") + "\n",
+                prefix: false
+              )
+            end
+            while !bridge_interface
+              choice = env[:ui].ask(
+                I18n.t("vagrant.actions.vm.bridged_networking.select_interface") + " ",
+                prefix: false)
+              bridge_interface = valid_interfaces[choice.to_i - 1]
+            end
+            base_opts = Vagrant::Util::HashWithIndifferentAccess.new
+            base_opts[:opt] = "parent=#{bridge_interface.name}"
+            subnet = IPAddr.new(bridge_interface.addr.ip_address <<
+              "/" << bridge_interface.netmask.ip_unpack.first)
+            netmask = bridge_interface.netmask.ip_unpack.first
+            prefix = IPAddr.new("255.255.255.255/#{netmask}").to_i.to_s(2).count("1")
+            base_opts[:subnet] = "#{subnet}/#{prefix}"
+            subnet_addr = IPAddr.new(base_opts[:subnet])
+            base_opts[:driver] = "macvlan"
+            base_opts[:gateway] = subnet_addr.succ.to_s
+            base_opts[:ipv6] = subnet_addr.ipv6?
+            network_options = base_opts.merge(net_options)
+
+            # Check if network already exists for this subnet
+            network_name = env[:machine].provider.driver.
+              network_containing_address(network_options[:gateway])
+            if !network_name
+              network_name = "vagrant_network_public_#{bridge_interface.name}"
+            end
+
+            # If the network doesn't already exist, gather available address range
+            # within subnet which docker can provide addressing
+            if !env[:machine].provider.driver.existing_named_network?(network_name)
+              if !net_options[:gateway]
+                network_options[:gateway] = request_public_gateway(
+                  network_options, bridge_interface.name, env)
+              end
+              network_options[:ip_range] = request_public_iprange(
+                network_options, bridge_interface, env)
+            end
+          end
+          [network_name, network_options]
+        end
+
+        # Request the gateway address for the public network
+        #
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [String] interface The bridge interface used
+        # @param [Hash] env Local call env
+        # @return [String] Gateway address
+        def request_public_gateway(network_options, interface, env)
+          subnet = IPAddr.new(network_options[:subnet])
+          gateway = nil
+          while !gateway
+            gateway = env[:ui].ask(I18n.t(
+              "docker_provider.network_bridge_gateway_request",
+              interface: interface,
+              default_gateway: network_options[:gateway]) + " ",
+              prefix: false
+            ).strip
+            if gateway.empty?
+              gateway = network_options[:gateway]
+            end
+            begin
+              gateway = IPAddr.new(gateway)
+              if !subnet.include?(gateway)
+                env[:ui].warn(I18n.t("docker_provider.network_bridge_gateway_outofbounds",
+                  gateway: gateway,
+                  subnet: network_options[:subnet]) + "\n", prefix: false)
+              end
+            rescue IPAddr::InvalidAddressError
+              env[:ui].warn(I18n.t("docker_provider.network_bridge_gateway_invalid",
+                gateway: gateway) + "\n", prefix: false)
+              gateway = nil
+            end
+          end
+          gateway.to_s
+        end
+
+        # Request the IP range allowed for use by docker when creating a new
+        # public network
+        #
+        # TODO: When the Vagrant installer upgrades to Ruby 2.5.x,
+        # remove all instances of the roundabout way of determining a prefix
+        # and instead just use the built-in `.prefix` method
+        #
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [Socket::Ifaddr] interface The bridge interface used
+        # @param [Hash] env Local call env
+        # @return [String] Address range
+        def request_public_iprange(network_options, interface, env)
+          return network_options[:ip_range] if network_options[:ip_range]
+          subnet = IPAddr.new(network_options[:subnet])
+          env[:ui].info(I18n.t(
+            "docker_provider.network_bridge_iprange_info") + "\n",
+            prefix: false
+          )
+          range = nil
+          while !range
+            range = env[:ui].ask(I18n.t(
+              "docker_provider.network_bridge_iprange_request",
+              interface: interface.name,
+              default_range: network_options[:subnet]) + " ",
+              prefix: false
+            ).strip
+            if range.empty?
+              range = network_options[:subnet]
+            end
+            begin
+              range = IPAddr.new(range)
+              if !subnet.include?(range)
+                netmask = interface.netmask.ip_unpack.first
+                prefix = IPAddr.new("255.255.255.255/#{netmask}").to_i.to_s(2).count("1")
+                env[:ui].warn(I18n.t(
+                  "docker_provider.network_bridge_iprange_outofbounds",
+                  subnet: network_options[:subnet],
+                  range: "#{range}/#{prefix}"
+                ) + "\n", prefix: false)
+                range = nil
+              end
+            rescue IPAddr::InvalidAddressError
+              env[:ui].warn(I18n.t(
+                "docker_provider.network_bridge_iprange_invalid",
+                range: range) + "\n", prefix: false)
+              range = nil
+            end
+          end
+
+          netmask = interface.netmask.ip_unpack.first
+          prefix = IPAddr.new("255.255.255.255/#{netmask}").to_i.to_s(2).count("1")
+          "#{range}/#{prefix}"
+        end
+
+        # Execute the action
+        def call(env)
+          # If we are using a host VM, then don't worry about it
+          machine = env[:machine]
+          if machine.provider.host_vm?
+            @logger.debug("Not setting up networks because docker host_vm is in use")
+            return @app.call(env)
+          end
+
+          connections = {}
+          @@lock.synchronize do
+            machine.env.lock("docker-network-create", retry: true) do
+              env[:ui].info(I18n.t("docker_provider.network_create"))
+              machine.config.vm.networks.each_with_index do |net_info, net_idx|
+                type, options = net_info
+                network_options = scoped_hash_override(options, :docker_network)
+                network_options.delete_if{|k,_| options.key?(k)}
+
+                case type
+                when :public_network
+                  network_name, network_options = process_public_network(
+                    options, network_options, env)
+                when :private_network
+                  network_name, network_options = process_private_network(
+                    options, network_options, env)
+                else
+                  next # unsupported type so ignore
+                end
+
+                if !network_name
+                  raise Errors::NetworkInvalidOption, container: machine.name
+                end
+
+                if !machine.provider.driver.existing_named_network?(network_name)
+                  @logger.debug("Creating network #{network_name}")
+                  cli_opts = generate_create_cli_arguments(network_options)
+                  machine.provider.driver.create_network(network_name, cli_opts)
+                else
+                  @logger.debug("Network #{network_name} already created")
+                  validate_network_configuration!(network_name, options, network_options, machine.provider.driver)
+                end
+                connections[net_idx] = network_name
+              end
+            end
+          end
+
+          env[:docker_connects] = connections
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/prepare_nfs_settings.rb

@@ -0,0 +1,60 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareNFSSettings
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+
+          @app.call(env)
+
+          if using_nfs? && !privileged_container?
+            raise Errors::NfsWithoutPrivilegedError
+          end
+
+          if using_nfs?
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            add_ips_to_env!(env)
+          end
+        end
+
+        # We're using NFS if we have any synced folder with NFS configured. If
+        # we are not using NFS we don't need to do the extra work to
+        # populate these fields in the environment.
+        def using_nfs?
+          @machine.config.vm.synced_folders.any? { |_, opts| opts[:type] == :nfs }
+        end
+
+        def privileged_container?
+          @machine.provider.driver.privileged?(@machine.id)
+        end
+
+        # Extracts the proper host and guest IPs for NFS mounts and stores them
+        # in the environment for the SyncedFolder action to use them in
+        # mounting.
+        #
+        # The ! indicates that this method modifies its argument.
+        def add_ips_to_env!(env)
+          provider = env[:machine].provider
+
+          host_ip    = provider.driver.docker_bridge_ip
+          machine_ip = provider.ssh_info[:host]
+
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
+
+          env[:nfs_host_ip]    = host_ip
+          env[:nfs_machine_ip] = machine_ip
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/prepare_nfs_valid_ids.rb

@@ -0,0 +1,22 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          env[:nfs_valid_ids] = machine.provider.driver.all_containers
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/prepare_ssh.rb

@@ -0,0 +1,48 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareSSH
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # If we aren't using a host VM, then don't worry about it
+          return @app.call(env) if !env[:machine].provider.host_vm?
+
+          env[:machine].ui.output(I18n.t(
+            "docker_provider.ssh_through_host_vm"))
+
+          # Modify the SSH info to be the host VM's info
+          env[:ssh_info] = env[:machine].provider.host_vm.ssh_info
+
+          # Modify the SSH options for when we `vagrant ssh`...
+          ssh_opts = env[:ssh_opts] || {}
+
+          # Build the command we'll execute within the Docker host machine:
+          ssh_command = env[:machine].communicate.container_ssh_command
+          if !Array(ssh_opts[:extra_args]).empty?
+            ssh_command << " #{Array(ssh_opts[:extra_args]).join(" ")}"
+          end
+
+          # Modify the SSH options for the original command:
+          # Append "-t" to force a TTY allocation
+          ssh_opts[:extra_args] = ["-t"]
+          # Enable Agent forwarding when requested for the target VM
+          if env[:machine].ssh_info[:forward_agent]
+            ssh_opts[:extra_args] << "-o ForwardAgent=yes"
+          end
+          ssh_opts[:extra_args] << ssh_command
+
+          # Set the opts
+          env[:ssh_opts] = ssh_opts
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/pull.rb

@@ -0,0 +1,30 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Pull
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env             = env
+          @machine         = env[:machine]
+          @provider_config = @machine.provider_config
+          @driver          = @machine.provider.driver
+
+          # Skip pulling if the image is built
+          return @app.call(env) if @env[:create_image] || !@provider_config.pull
+
+          image = @provider_config.image
+          env[:ui].output(I18n.t("docker_provider.pull", image: image))
+          @driver.pull(image)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/start.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Start
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          driver  = machine.provider.driver
+
+          machine.ui.output(I18n.t("docker_provider.messages.starting"))
+          driver.start(machine.id)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/stop.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Stop
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          driver  = machine.provider.driver
+          if driver.running?(machine.id)
+            env[:ui].info I18n.t("docker_provider.messages.stopping")
+            driver.stop(machine.id, machine.provider_config.stop_timeout)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/wait_for_running.rb

@@ -0,0 +1,70 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "thread"
+require "log4r"
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class WaitForRunning
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::docker::waitforrunning")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          wait = true
+          if !machine.provider_config.remains_running
+            @logger.debug("remains_running is false")
+            wait = false
+          elsif machine.state.id == :running
+            @logger.debug("container is already running")
+            wait = false
+          end
+
+          # If we're not waiting, just return
+          return @app.call(env) if !wait
+
+          machine.ui.output(I18n.t("docker_provider.waiting_for_running"))
+
+          # First, make sure it leaves the stopped state if its supposed to.
+          after = sleeper(5)
+          while machine.state.id == :stopped
+            if after[:done]
+              raise Errors::StateStopped
+            end
+            sleep 0.2
+          end
+
+          # Then, wait for it to become running
+          after = sleeper(30)
+          while true
+            state = machine.state
+            break if state.id == :running
+            @logger.info("Waiting for container to run. State: #{state.id}")
+
+            if after[:done]
+              raise Errors::StateNotRunning
+            end
+
+            sleep 0.2
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        def sleeper(duration)
+          Thread.new(duration) do |d|
+            sleep(d)
+            Thread.current[:done] = true
+          end
+        end
+      end
+    end
+  end
+end