vagrant 1.5.0 → 2.4.4

data/plugins/providers/docker/plugin.rb

@@ -0,0 +1,89 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    autoload :Action, File.expand_path("../action", __FILE__)
+    autoload :Driver, File.expand_path("../driver", __FILE__)
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    module Executor
+      autoload :Local, File.expand_path("../executor/local", __FILE__)
+      autoload :Vagrant, File.expand_path("../executor/vagrant", __FILE__)
+    end
+
+    class Plugin < Vagrant.plugin("2")
+      name "docker-provider"
+      description <<-EOF
+      The Docker provider allows Vagrant to manage and control
+      Docker containers.
+      EOF
+
+      provider(:docker, box_optional: true, parallel: true, defaultable: false) do
+        require_relative 'provider'
+        init!
+        Provider
+      end
+
+      command("docker-exec", primary: false) do
+        require_relative "command/exec"
+        init!
+        Command::Exec
+      end
+
+      command("docker-logs", primary: false) do
+        require_relative "command/logs"
+        init!
+        Command::Logs
+      end
+
+      command("docker-run", primary: false) do
+        require_relative "command/run"
+        init!
+        Command::Run
+      end
+
+      communicator(:docker_hostvm) do
+        require_relative "communicator"
+        init!
+        Communicator
+      end
+
+      config(:docker, :provider) do
+        require_relative 'config'
+        init!
+        Config
+      end
+
+      synced_folder(:docker) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      provider_capability("docker", "public_address") do
+        require_relative "cap/public_address"
+        Cap::PublicAddress
+      end
+
+      provider_capability("docker", "proxy_machine") do
+        require_relative "cap/proxy_machine"
+        Cap::ProxyMachine
+      end
+
+      provider_capability("docker", "has_communicator") do
+        require_relative "cap/has_communicator"
+        Cap::HasCommunicator
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path(
+          "templates/locales/providers_docker.yml", Vagrant.source_root)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/plugins/providers/docker/provider.rb

@@ -0,0 +1,215 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "digest/md5"
+require "fileutils"
+require "thread"
+require "log4r"
+
+require "vagrant/util/silence_warnings"
+
+module VagrantPlugins
+  module DockerProvider
+    class Provider < Vagrant.plugin("2", :provider)
+      @@host_vm_mutex = Mutex.new
+
+      def self.usable?(raise_error=false)
+        Driver.new.execute("docker", "version")
+        true
+      rescue Vagrant::Errors::CommandUnavailable, Errors::ExecuteError
+        raise if raise_error
+        return false
+      end
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::docker")
+        @machine = machine
+
+        if host_vm?
+          # We need to use a special communicator that proxies our
+          # SSH requests over our host VM to the container itself.
+          @machine.config.vm.communicator = :docker_hostvm
+        end
+      end
+
+      # @see Vagrant::Plugin::V2::Provider#action
+      def action(name)
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # Returns the driver instance for this provider.
+      def driver
+        if !@driver
+          if @machine.provider_config.compose
+            @driver = Driver::Compose.new(@machine)
+          else
+            @driver = Driver.new
+          end
+        end
+        if host_vm?
+          @driver.executor = Executor::Vagrant.new(host_vm)
+        end
+
+        @driver
+      end
+
+      # This returns the {Vagrant::Machine} that is our host machine.
+      # It does not perform any action on the machine or verify it is
+      # running.
+      #
+      # @return [Vagrant::Machine]
+      def host_vm
+        return @host_vm if @host_vm
+
+        vf_path           = @machine.provider_config.vagrant_vagrantfile
+        host_machine_name = @machine.provider_config.vagrant_machine || :default
+        if !vf_path
+          # We don't have a Vagrantfile path set, so we're going to use
+          # the default but we need to copy it into the data dir so that
+          # we don't write into our installation dir (we can't).
+          default_path = File.expand_path("../hostmachine/Vagrantfile", __FILE__)
+          vf_path      = @machine.env.data_dir.join("docker-host", "Vagrantfile")
+          begin
+            @machine.env.lock("docker-provider-hostvm") do
+              vf_path.dirname.mkpath
+              FileUtils.cp(default_path, vf_path)
+            end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            # Lock contention, just retry
+            retry
+          end
+
+          # Set the machine name since we hardcode that for the default
+          host_machine_name = :default
+        end
+
+        # Expand it so that the home directories and so on get processed
+        # properly.
+        vf_path = File.expand_path(vf_path, @machine.env.root_path)
+
+        vf_file = File.basename(vf_path)
+        vf_path = File.dirname(vf_path)
+
+        # Create the env to manage this machine
+        @host_vm = Vagrant::Util::SilenceWarnings.silence! do
+          host_env = Vagrant::Environment.new(
+            cwd: vf_path,
+            home_path: @machine.env.home_path,
+            ui_class: @machine.env.ui_class,
+            vagrantfile_name: vf_file,
+          )
+
+          # If there is no root path, then the Vagrantfile wasn't found
+          # and it is an error...
+          raise Errors::VagrantfileNotFound if !host_env.root_path
+
+          host_env.machine(
+            host_machine_name,
+            host_env.default_provider(
+              exclude: [:docker],
+              force_default: false,
+            ))
+        end
+
+        @host_vm
+      end
+
+      # This acquires a lock on the host VM.
+      def host_vm_lock
+        hash = Digest::MD5.hexdigest(host_vm.data_dir.to_s)
+
+        # We do a process-level mutex on the outside, since we can
+        # wait for that a short amount of time. Then, we do a process lock
+        # on the inside, which will raise an exception if locked.
+        host_vm_mutex.synchronize do
+          @machine.env.lock(hash) do
+            return yield
+          end
+        end
+      end
+
+      # This is a process-local mutex that can be used by parallel
+      # providers to lock the host VM access.
+      def host_vm_mutex
+        @@host_vm_mutex
+      end
+
+      # This says whether or not Docker will be running within a VM
+      # rather than directly on our system. Docker needs to run in a VM
+      # when we're not on Linux, or not on a Linux that supports Docker.
+      def host_vm?
+        @machine.provider_config.force_host_vm
+      end
+
+      # Returns the SSH info for accessing the Container.
+      def ssh_info
+        # If the container isn't running, we can't SSH into it
+        return nil if state.id != :running
+
+        port_name = "#{@machine.config.ssh.guest_port}/tcp"
+        network   = driver.inspect_container(@machine.id)['NetworkSettings']
+
+        if network["Ports"][port_name].respond_to?(:first)
+          port_info = network["Ports"][port_name].first
+        else
+          ip = network["IPAddress"]
+          port = @machine.config.ssh.guest_port
+          if !ip.to_s.empty?
+            port_info = {
+              "HostIp" => ip,
+              "HostPort" => port
+            }
+          end
+        end
+
+        # If we were not able to identify the container's IP, we return nil
+        # here and we let Vagrant core deal with it ;)
+        return nil if port_info.nil? || port_info.empty?
+
+        {
+          host: port_info['HostIp'],
+          port: port_info['HostPort']
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@machine.id
+
+        begin
+          state_id = :host_state_unknown if !state_id && \
+            host_vm? && !host_vm.communicate.ready?
+        rescue Errors::VagrantfileNotFound
+          state_id = :host_state_unknown
+        end
+
+        state_id = :not_created if !state_id && \
+          (!@machine.id || !driver.created?(@machine.id))
+        state_id = driver.state(@machine.id) if @machine.id && !state_id
+        state_id = :unknown if !state_id
+
+        # This is a special pseudo-state so that we don't set the
+        # NOT_CREATED_ID while we're setting up the machine. This avoids
+        # clearing the data dir.
+        state_id = :preparing if @machine.id == "preparing"
+
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("docker_provider.status.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id ? @machine.id : "new container"
+        "Docker (#{id})"
+      end
+    end
+  end
+end

data/plugins/providers/docker/synced_folder.rb

@@ -0,0 +1,35 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module DockerProvider
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine, raise_error=false)
+        # These synced folders only work if the provider is Docker
+        if machine.provider_name != :docker
+          if raise_error
+            raise Errors::SyncedFolderNonDocker,
+              provider: machine.provider_name.to_s
+          end
+
+          return false
+        end
+
+        true
+      end
+
+      def prepare(machine, folders, _opts)
+        folders.each do |id, data|
+          next if data[:ignore]
+
+          host_path  = data[:hostpath]
+          guest_path = data[:guestpath]
+          # Append consistency option if it exists, otherwise let it nil out
+          consistency = data[:docker_consistency]
+          consistency &&= ":" + consistency
+          machine.provider_config.volumes << "#{host_path}:#{guest_path}#{consistency}"
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/check_access.rb

@@ -0,0 +1,27 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class CheckAccess
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:ui].output("Verifying Hyper-V is accessible...")
+          result = env[:machine].provider.driver.execute(:check_hyperv_access,
+            "Path" => Vagrant::Util::Platform.wsl_to_windows_path(env[:machine].data_dir).gsub("/", "\\")
+          )
+          if !result["result"]
+            raise Errors::SystemAccessRequired,
+              root_dir: result["root_dir"]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/check_enabled.rb

@@ -0,0 +1,25 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "log4r"
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class CheckEnabled
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:ui].output("Verifying Hyper-V is enabled...")
+          result = env[:machine].provider.driver.execute("check_hyperv.ps1", {})
+          raise Errors::PowerShellFeaturesDisabled if !result["result"]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/configure.rb

@@ -0,0 +1,115 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "log4r"
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class Configure
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::hyperv::configure")
+        end
+
+        def call(env)
+          switches = env[:machine].provider.driver.execute(:get_switches)
+          if switches.empty?
+            raise Errors::NoSwitches
+          end
+
+          switch = nil
+          env[:machine].config.vm.networks.each do |type, opts|
+            next if type != :public_network && type != :private_network
+
+            if opts[:bridge]
+              @logger.debug("Looking for switch with name or ID: #{opts[:bridge]}")
+              switch = switches.find{ |s|
+                s["Name"].downcase == opts[:bridge].to_s.downcase ||
+                  s["Id"].downcase == opts[:bridge].to_s.downcase
+              }
+              if switch
+                @logger.debug("Found switch - Name: #{switch["Name"]} ID: #{switch["Id"]}")
+                switch = switch["Id"]
+                break
+              end
+            end
+          end
+
+          # If we already configured previously don't prompt for switch
+          sentinel = env[:machine].data_dir.join("action_configure")
+
+          if !switch && !sentinel.file?
+            if switches.length > 1
+              env[:ui].detail(I18n.t("vagrant_hyperv.choose_switch") + "\n ")
+              switches.each_index do |i|
+                switch = switches[i]
+                env[:ui].detail("#{i+1}) #{switch["Name"]}")
+              end
+              env[:ui].detail(" ")
+
+              switch = nil
+              while !switch
+                switch = env[:ui].ask("What switch would you like to use? ")
+                next if !switch
+                switch = switch.to_i - 1
+                switch = nil if switch < 0 || switch >= switches.length
+              end
+              switch = switches[switch]["Id"]
+            else
+              switch = switches.first["Id"]
+              @logger.debug("Only single switch available so using that.")
+            end
+          end
+
+          options = {
+            "VMID" => env[:machine].id,
+            "SwitchID" => switch,
+            "Memory" => env[:machine].provider_config.memory,
+            "MaxMemory" => env[:machine].provider_config.maxmemory,
+            "Processors" => env[:machine].provider_config.cpus,
+            "AutoStartAction" => env[:machine].provider_config.auto_start_action,
+            "AutoStopAction" => env[:machine].provider_config.auto_stop_action,
+            "EnableCheckpoints" => env[:machine].provider_config.enable_checkpoints,
+            "EnableAutomaticCheckpoints" => env[:machine].provider_config.enable_automatic_checkpoints,
+            "VirtualizationExtensions" => !!env[:machine].provider_config.enable_virtualization_extensions,
+          }
+          options.delete_if{|_,v| v.nil? }
+
+          env[:ui].detail("Configuring the VM...")
+          env[:machine].provider.driver.execute(:configure_vm, options)
+
+          # Create the sentinel
+          if !sentinel.file?
+            sentinel.open("w") do |f|
+              f.write(Time.now.to_i.to_s)
+            end
+          end
+
+          if !env[:machine].provider_config.vm_integration_services.empty?
+            env[:ui].detail("Setting VM Integration Services")
+
+            env[:machine].provider_config.vm_integration_services.each do |key, value|
+              state = value ? "enabled" : "disabled"
+              env[:ui].output("#{key} is #{state}")
+            end
+
+            env[:machine].provider.driver.set_vm_integration_services(
+              env[:machine].provider_config.vm_integration_services)
+          end
+
+          if env[:machine].provider_config.enable_enhanced_session_mode
+            env[:ui].detail(I18n.t("vagrant.hyperv_enable_enhanced_session"))
+            env[:machine].provider.driver.set_enhanced_session_transport_type("HvSocket")
+          else
+            env[:ui].detail(I18n.t("vagrant.hyperv_disable_enhanced_session"))
+            env[:machine].provider.driver.set_enhanced_session_transport_type("VMBus")
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/delete_vm.rb

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class DeleteVM
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info("Deleting the machine...")
+          env[:machine].provider.driver.delete_vm
+          # NOTE: We remove the data directory and recreate it
+          #       to overcome an issue seen when running within
+          #       the WSL. Hyper-V will successfully remove the
+          #       VM and the files will appear to be gone, but
+          #       on a subsequent up, they will cause collisions.
+          #       This forces them to be gone for real.
+          FileUtils.rm_rf(env[:machine].data_dir)
+          FileUtils.mkdir_p(env[:machine].data_dir)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/export.rb

@@ -0,0 +1,45 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class Export
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          @env[:ui].info @env[:machine].state.id.to_s
+
+          raise Vagrant::Errors::VMPowerOffToPackage if
+            @env[:machine].state.id != :off
+
+          export
+
+          @app.call(env)
+        end
+
+        def export
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          export_tmp_dir = Vagrant::Util::Platform.wsl_to_windows_path(@env["export.temp_dir"])
+          @env[:machine].provider.driver.export(export_tmp_dir) do |progress|
+            @env[:ui].rewriting do |ui|
+              ui.clear_line
+              ui.report_progress(progress.percent, 100, false)
+            end
+          end
+
+          # Clear the line a final time so the next data can appear
+          # alone on the line.
+          @env[:ui].clear_line
+        end
+
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/import.rb

@@ -0,0 +1,86 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "log4r"
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class Import
+
+        VALID_HD_EXTENSIONS = [".vhd".freeze, ".vhdx".freeze].freeze
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::hyperv::import")
+        end
+
+        def call(env)
+          vm_dir = env[:machine].box.directory.join("Virtual Machines")
+          hd_dir = env[:machine].box.directory.join("Virtual Hard Disks")
+
+          if !vm_dir.directory? || !hd_dir.directory?
+            @logger.error("Required virtual machine directory not found!")
+            raise Errors::BoxInvalid, name: env[:machine].name
+          end
+
+          valid_config_ext = [".xml"]
+          if env[:machine].provider.driver.has_vmcx_support?
+            valid_config_ext << ".vmcx"
+          end
+
+          config_path = nil
+          vm_dir.each_child do |file|
+            if valid_config_ext.include?(file.extname.downcase)
+              config_path = file
+              break
+            end
+          end
+
+          if !config_path
+            @logger.error("Failed to locate box configuration path")
+            raise Errors::BoxInvalid, name: env[:machine].name
+          else
+            @logger.info("Found box configuration path: #{config_path}")
+          end
+
+          image_path = nil
+          hd_dir.each_child do |file|
+            if VALID_HD_EXTENSIONS.include?(file.extname.downcase)
+              image_path = file
+              break
+            end
+          end
+
+          if !image_path
+            @logger.error("Failed to locate box image path")
+            raise Errors::BoxInvalid, name: env[:machine].name
+          else
+            @logger.info("Found box image path: #{image_path}")
+          end
+
+          env[:ui].output("Importing a Hyper-V instance")
+          dest_path = env[:machine].data_dir.join("Virtual Hard Disks").join(image_path.basename).to_s
+
+          options = {
+            "VMConfigFile" => Vagrant::Util::Platform.wsl_to_windows_path(config_path).gsub("/", "\\"),
+            "DestinationPath" => Vagrant::Util::Platform.wsl_to_windows_path(dest_path).gsub("/", "\\"),
+            "DataPath" => Vagrant::Util::Platform.wsl_to_windows_path(env[:machine].data_dir).gsub("/", "\\"),
+            "LinkedClone" => !!env[:machine].provider_config.linked_clone,
+            "SourcePath" => Vagrant::Util::Platform.wsl_to_windows_path(image_path).gsub("/", "\\"),
+            "VMName" => env[:machine].provider_config.vmname,
+          }
+
+
+          env[:ui].detail("Creating and registering the VM...")
+          server = env[:machine].provider.driver.import(options)
+
+          env[:ui].detail("Successfully imported VM")
+          env[:machine].id = server["id"]
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/action/is_windows.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HyperV
+    module Action
+      class IsWindows
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].config.vm.guest == :windows
+          @app.call(env)
+        end
+      end
+    end
+  end
+end