vagrant 1.5.0 → 2.4.4

data/plugins/providers/docker/action.rb

@@ -0,0 +1,319 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action starts another container just like the real one running
+      # but only for the purpose of running a single command rather than
+      # to exist long-running.
+      def self.action_run_command
+        Vagrant::Action::Builder.new.tap do |b|
+          # We just call the "up" action. We create a separate action
+          # to hold this though in case we modify it in the future, and
+          # so that we can switch on the "machine_action" env var.
+          b.use action_up
+        end
+      end
+
+      # This action brings the "machine" up from nothing, including creating the
+      # container, configuring metadata, and booting.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use HandleBox
+            end
+          end
+
+          b.use ConfigValidate
+          b.use HostMachine
+
+          # Yeah, this is supposed to be here twice (once more above). This
+          # catches the case when the container was supposed to be created,
+          # but the host state was unknown, and now we know its not actually
+          # created.
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use HandleBox
+              b2.use DestroyBuildImage
+            end
+          end
+
+          b.use action_start
+        end
+      end
+
+      def self.action_package
+        lambda do |env|
+          raise Errors::PackageNotSupported
+        end
+      end
+
+      # This action just runs the provisioners on the machine.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("docker_provider.messages.not_created")
+              next
+            end
+
+            b2.use Call, IsState, :running do |env2, b3|
+              if !env2[:result]
+                b3.use Message, I18n.t("docker_provider.messages.not_running")
+                next
+              end
+
+              b3.use Call, HasProvisioner do |env3, b4|
+                b4.use Provision
+              end
+            end
+          end
+        end
+      end
+
+      # This is the action that is primarily responsible for halting
+      # the virtual machine, gracefully or by force.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :host_state_unknown do |env, b2|
+            if env[:result]
+              b2.use HostMachine
+            end
+          end
+
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("docker_provider.messages.not_created")
+              next
+            end
+
+            b2.use Stop
+          end
+        end
+      end
+
+      # This action is responsible for reloading the machine, which
+      # brings it down, sucks in new configuration, and brings the
+      # machine back up with the new configuration.
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("docker_provider.messages.not_created")
+              next
+            end
+
+            b2.use action_halt
+
+            b2.use Call, IsBuild do |env2, b3|
+              if env2[:result]
+                b3.use EnvSet, force_halt: true
+                b3.use action_halt
+                b3.use HostMachineSyncFoldersDisable
+                b3.use Destroy
+                b3.use ProvisionerCleanup
+              end
+            end
+
+            b2.use action_start
+          end
+        end
+      end
+
+      # This is the action that is primarily responsible for completely
+      # freeing the resources of the underlying virtual machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsHostMachineCreated do |env, b2|
+            if !env[:result]
+              b2.use Message, I18n.t("docker_provider.messages.not_created")
+              next
+            end
+
+            b2.use Call, IsState, :host_state_unknown do |env2, b3|
+              if env2[:result]
+                b3.use HostMachine
+              end
+            end
+
+            b2.use Call, IsState, :not_created do |env2, b3|
+              if env2[:result]
+                b3.use Message,
+                  I18n.t("docker_provider.messages.not_created")
+                next
+              end
+
+              b3.use Call, DestroyConfirm do |env3, b4|
+                if env3[:result]
+                  b4.use ConfigValidate
+                  b4.use ProvisionerCleanup, :before
+                  b4.use EnvSet, force_halt: true
+                  b4.use action_halt
+                  b4.use HostMachineSyncFoldersDisable
+                  b4.use Destroy
+                  b4.use DestroyNetwork
+                  b4.use DestroyBuildImage
+                else
+                  b4.use Message,
+                    I18n.t("docker_provider.messages.will_not_destroy")
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # This is the action that will exec into an SSH shell.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              raise Errors::ContainerNotCreatedError
+            end
+
+            b2.use Call, IsState, :running do |env2, b3|
+              if !env2[:result]
+                raise Errors::ContainerNotRunningError
+              end
+
+              b3.use PrepareSSH
+              b3.use SSHExec
+            end
+          end
+        end
+      end
+
+      # This is the action that will run a single SSH command.
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              raise Errors::ContainerNotCreatedError
+            end
+
+            b2.use Call, IsState, :running do |env2, b3|
+              if !env2[:result]
+                raise Errors::ContainerNotRunningError
+              end
+
+              b3.use SSHRun
+            end
+          end
+        end
+      end
+
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :running do |env, b2|
+            if env[:machine_action] != :run_command
+              b2.use Call, HasProvisioner do |env2, b3|
+                b3.use Provision
+              end
+            end
+
+            # If the container is running and we're doing a run, we're done
+            next if env[:result] && env[:machine_action] != :run_command
+
+            b2.use Call, IsState, :not_created do |env2, b3|
+              if env2[:result]
+                # First time making this thing, set to the "preparing" state
+                b3.use InitState
+              else
+                b3.use EnvSet, host_machine_sync_folders: false
+              end
+            end
+
+            b2.use HostMachineBuildDir
+            b2.use HostMachineSyncFolders
+            b2.use PrepareNFSValidIds
+            b2.use SyncedFolderCleanup
+            b2.use SyncedFolders
+            b2.use PrepareNFSSettings
+            b2.use PrepareNetworks
+            b2.use Login
+            b2.use Build
+
+            if env[:machine_action] != :run_command
+              # If the container is NOT created yet, then do some setup steps
+              # necessary for creating it.
+
+              b2.use Call, IsState, :preparing do |env2, b3|
+                if env2[:result]
+                  b3.use EnvSet, port_collision_repair: true
+                  b3.use HostMachinePortWarning
+                  b3.use HostMachinePortChecker
+                  b3.use ForwardedPorts # This action converts the `ports` param into proper network configs
+                  b3.use PrepareForwardedPortCollisionParams
+                  b3.use HandleForwardedPortCollisions
+                  b3.use Pull
+                  b3.use Create
+                  b3.use WaitForRunning
+                else
+                  b3.use CompareSyncedFolders
+                end
+              end
+
+              b2.use ConnectNetworks
+              b2.use Start
+              b2.use WaitForRunning
+
+              b2.use Call, HasSSH do |env2, b3|
+                if env2[:result]
+                  b3.use WaitForCommunicator
+                end
+              end
+            else
+              # We're in a run command, so we do things a bit differently.
+              b2.use Create
+            end
+          end
+        end
+      end
+
+      def self.action_suspend
+        lambda do |env|
+          raise Errors::SuspendNotSupported
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :Build, action_root.join("build")
+      autoload :CompareSyncedFolders, action_root.join("compare_synced_folders")
+      autoload :ConnectNetworks, action_root.join("connect_networks")
+      autoload :Create, action_root.join("create")
+      autoload :Destroy, action_root.join("destroy")
+      autoload :DestroyBuildImage, action_root.join("destroy_build_image")
+      autoload :DestroyNetwork, action_root.join("destroy_network")
+      autoload :ForwardedPorts, action_root.join("forwarded_ports")
+      autoload :HasSSH, action_root.join("has_ssh")
+      autoload :HostMachine, action_root.join("host_machine")
+      autoload :HostMachineBuildDir, action_root.join("host_machine_build_dir")
+      autoload :HostMachinePortChecker, action_root.join("host_machine_port_checker")
+      autoload :HostMachinePortWarning, action_root.join("host_machine_port_warning")
+      autoload :HostMachineRequired, action_root.join("host_machine_required")
+      autoload :HostMachineSyncFolders, action_root.join("host_machine_sync_folders")
+      autoload :HostMachineSyncFoldersDisable, action_root.join("host_machine_sync_folders_disable")
+      autoload :InitState, action_root.join("init_state")
+      autoload :IsBuild, action_root.join("is_build")
+      autoload :IsHostMachineCreated, action_root.join("is_host_machine_created")
+      autoload :Login, action_root.join("login")
+      autoload :PrepareForwardedPortCollisionParams, action_root.join("prepare_forwarded_port_collision_params")
+      autoload :PrepareNetworks, action_root.join("prepare_networks")
+      autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+      autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+      autoload :PrepareSSH, action_root.join("prepare_ssh")
+      autoload :Pull, action_root.join("pull")
+      autoload :Start, action_root.join("start")
+      autoload :Stop, action_root.join("stop")
+      autoload :WaitForRunning, action_root.join("wait_for_running")
+    end
+  end
+end

data/plugins/providers/docker/cap/has_communicator.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Cap
+      module HasCommunicator
+        def self.has_communicator(machine)
+          return machine.provider_config.has_ssh
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/cap/proxy_machine.rb

@@ -0,0 +1,15 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Cap
+      module ProxyMachine
+        def self.proxy_machine(machine)
+          return nil if !machine.provider.host_vm?
+          machine.provider.host_vm
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/cap/public_address.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Cap
+      module PublicAddress
+        def self.public_address(machine)
+          return nil if machine.state.id != :running
+
+          # If we're using a host VM, then return the IP of that
+          # rather than of our own machine.
+          if machine.provider.host_vm?
+            host_machine = machine.provider.host_vm
+            return nil if !host_machine.provider.capability?(:public_address)
+            return host_machine.provider.capability(:public_address)
+          end
+
+          ssh_info = machine.ssh_info
+          return nil if !ssh_info
+          ssh_info[:host]
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/command/exec.rb

@@ -0,0 +1,112 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/safe_exec'
+
+module VagrantPlugins
+  module DockerProvider
+    module Command
+      class Exec < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "attach to an already-running docker container"
+        end
+
+        def execute
+          options = {}
+          options[:detach] = false
+          options[:pty] = false
+          options[:interactive] = false
+          options[:prefix] = true
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant docker-exec [options] [name] -- <command> [args]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--[no-]detach", "Run in the background") do |d|
+              options[:detach] = d
+            end
+
+            o.on("-i", "--[no-]interactive", "Keep STDIN open even if not attached") do |i|
+              options[:interactive] = i
+            end
+
+            o.on("-t", "--[no-]tty", "Allocate a pty") do |t|
+              options[:pty] = t
+            end
+
+            o.on("-u", "--user USER", "User or UID") do |u|
+              options[:user] = u
+            end
+
+            o.on("--[no-]prefix", "Prefix output with machine names") do |p|
+              options[:prefix] = p
+            end
+          end
+
+          # Parse out the extra args to send to SSH, which is everything
+          # after the "--"
+          command     = nil
+          split_index = @argv.index("--")
+          if split_index
+            command = @argv.drop(split_index + 1)
+            @argv   = @argv.take(split_index)
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          # Show the error if we don't have "--" _after_ parse_options
+          # so that "-h" and "--help" work properly.
+          if !split_index
+            raise Errors::ExecCommandRequired
+          end
+
+          target_opts = { provider: :docker }
+          target_opts[:single_target] = options[:pty]
+
+          with_target_vms(argv, target_opts) do |machine|
+            if machine.state.id != :running
+              @env.ui.info("#{machine.id} is not running.")
+              next
+            end
+            exec_command(machine, command, options)
+          end
+
+          return 0
+        end
+
+        def exec_command(machine, command, options)
+          exec_cmd = %w(docker exec)
+          exec_cmd << "-i" if options[:interactive]
+          exec_cmd << "-t" if options[:pty]
+          exec_cmd << "-u" << options[:user] if options[:user]
+          exec_cmd << machine.id
+          exec_cmd += options[:extra_args] if options[:extra_args]
+          exec_cmd += command
+
+          # Run this interactively if asked.
+          exec_options = options
+
+          if options[:pty]
+            Vagrant::Util::SafeExec.exec(exec_cmd[0], *exec_cmd[1..-1])
+          else
+            output = ""
+            machine.provider.driver.execute(*exec_cmd, **exec_options) do |type, data|
+              output += data
+            end
+
+            output_options = {}
+            output_options[:prefix] = false if !options[:prefix]
+
+            if !output.empty?
+              machine.ui.output(output.chomp, **output_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/command/logs.rb

@@ -0,0 +1,111 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Command
+      class Logs < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "outputs the logs from the Docker container"
+        end
+
+        def execute
+          options = {}
+          options[:follow] = false
+          options[:prefix] = true
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant docker-logs [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--[no-]follow", "Continue streaming in log output") do |f|
+              options[:follow] = f
+            end
+
+            o.on("--[no-]prefix", "Prefix output with machine names") do |p|
+              options[:prefix] = p
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          # This keeps track of if we ran our action on any machines...
+          any_success = false
+
+          # Start a batch action that sends all the logs to stdout. This
+          # will parallelize, if enabled, across all containers that are
+          # chosen.
+          @env.batch do |batch|
+            with_target_vms(argv) do |machine|
+              if machine.provider_name != :docker
+                machine.ui.output(I18n.t("docker_provider.not_docker_provider"))
+                next
+              end
+
+              state = machine.state.id
+              if state == :host_state_unknown
+                machine.ui.output(I18n.t("docker_provider.logs_host_state_unknown"))
+                next
+              elsif state == :not_created
+                machine.ui.output(I18n.t("docker_provider.not_created_skip"))
+                next
+              end
+
+              # At least one was run!
+              any_success = true
+
+              batch.custom(machine) do |m|
+                execute_single(m, options)
+              end
+            end
+          end
+
+          # If we didn't run on any machines, then exit status 1
+          return any_success ? 0 : 1
+        end
+
+        protected
+
+        # Executes the "docker logs" command on a single machine and proxies
+        # the output to our UI.
+        def execute_single(machine, options)
+          command = ["docker", "logs"]
+          command << "--follow" if options[:follow]
+          command << machine.id
+
+          output_options = {}
+          output_options[:prefix] = false if !options[:prefix]
+
+          data_acc = ""
+          machine.provider.driver.execute(*command) do |type, data|
+            # Accumulate the data so we only output lines at a time
+            data_acc << data
+
+            # If we have a newline, then output all the lines we have so far
+            if data_acc.include?("\n")
+              lines    = data_acc.split("\n")
+
+              if !data_acc.end_with?("\n")
+                data_acc = lines.pop.chomp
+              else
+                data_acc = ""
+              end
+
+              lines.each do |line|
+                line = " " if line == ""
+                machine.ui.output(line, **output_options)
+              end
+            end
+          end
+
+          # Output any remaining data
+          machine.ui.output(data_acc, **output_options) if !data_acc.empty?
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/command/run.rb

@@ -0,0 +1,76 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    module Command
+      class Run < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "run a one-off command in the context of a container"
+        end
+
+        def execute
+          options = {}
+          options[:detach] = false
+          options[:pty] = false
+          options[:rm] = true
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant docker-run [command...]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--[no-]detach", "Run in the background") do |d|
+              options[:detach] = d
+            end
+
+            o.on("-t", "--[no-]tty", "Allocate a pty") do |t|
+              options[:pty] = t
+            end
+
+            o.on("-r,", "--[no-]rm", "Remove container after execution") do |r|
+              options[:rm] = r
+            end
+          end
+
+          # Parse out the extra args to send to SSH, which is everything
+          # after the "--"
+          command     = nil
+          split_index = @argv.index("--")
+          if split_index
+            command = @argv.drop(split_index + 1)
+            @argv   = @argv.take(split_index)
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          # Show the error if we don't have "--" _after_ parse_options
+          # so that "-h" and "--help" work properly.
+          if !split_index
+            @env.ui.error(I18n.t("docker_provider.run_command_required"))
+            return 1
+          end
+
+          target_opts = { provider: :docker }
+          target_opts[:single_target] = options[:pty]
+
+          with_target_vms(argv, target_opts) do |machine|
+            # Run it!
+            machine.action(
+              :run_command,
+              run_command: command,
+              run_detach: options[:detach],
+              run_pty: options[:pty],
+              run_rm: options[:rm]
+            )
+          end
+
+          0
+        end
+      end
+    end
+  end
+end