vagrant 1.5.0 → 2.4.4

data/plugins/guests/tinycore/plugin.rb

@@ -0,0 +1,43 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestTinyCore
+    class Plugin < Vagrant.plugin("2")
+      name "TinyCore Linux guest."
+      description "TinyCore Linux guest support."
+
+      guest(:tinycore, :linux) do
+        require_relative "guest"
+        Guest
+      end
+
+      guest_capability(:tinycore, :configure_networks) do
+        require_relative "cap/configure_networks"
+        Cap::ConfigureNetworks
+      end
+
+      guest_capability(:tinycore, :change_host_name) do
+        require_relative "cap/change_host_name"
+        Cap::ChangeHostName
+      end
+
+      guest_capability(:tinycore, :halt) do
+        require_relative "cap/halt"
+        Cap::Halt
+      end
+
+      guest_capability(:tinycore, :rsync_install) do
+        require_relative "cap/rsync"
+        Cap::RSync
+      end
+
+      guest_capability(:tinycore, :mount_nfs_folder) do
+        require_relative "cap/mount_nfs"
+        Cap::MountNFS
+      end
+    end
+  end
+end

data/plugins/guests/trisquel/guest.rb

@@ -0,0 +1,12 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestTrisquel
+    class Guest < Vagrant.plugin("2", :guest)
+      def detect?(machine)
+        machine.communicate.test("[ -x /usr/bin/lsb_release ] && /usr/bin/lsb_release -i 2>/dev/null | grep Trisquel")
+      end
+    end
+  end
+end

data/plugins/guests/trisquel/plugin.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestTrisquel
+    class Plugin < Vagrant.plugin("2")
+      name "Trisquel guest"
+      description "Trisquel guest support."
+
+      guest(:trisquel, :ubuntu) do
+        require_relative "guest"
+        Guest
+      end
+    end
+  end
+end

data/plugins/guests/ubuntu/guest.rb

@@ -0,0 +1,13 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative '../linux/guest'
+
+module VagrantPlugins
+  module GuestUbuntu
+    class Guest < VagrantPlugins::GuestLinux::Guest
+      # Name used for guest detection
+      GUEST_DETECTION_NAME = "ubuntu".freeze
+    end
+  end
+end

data/plugins/guests/ubuntu/plugin.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestUbuntu
+    class Plugin < Vagrant.plugin("2")
+      name "Ubuntu guest"
+      description "Ubuntu guest support."
+
+      guest(:ubuntu, :debian) do
+        require_relative "guest"
+        Guest
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/change_host_name.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      module ChangeHostName
+        def self.change_host_name(machine, name)
+          change_host_name_and_wait(machine, name, machine.config.vm.graceful_halt_timeout)
+        end
+
+        def self.change_host_name_and_wait(machine, name, sleep_timeout)
+          # If the configured name matches the current name, then bail
+          # We cannot use %ComputerName% because it truncates at 15 chars
+          return if machine.communicate.test("if ([System.Net.Dns]::GetHostName() -eq '#{name}') { exit 0 } exit 1")
+
+          # Rename and reboot host if rename succeeded
+          script = <<-EOH
+            $computer = Get-WmiObject -Class Win32_ComputerSystem
+            $retval = $computer.rename("#{name}").returnvalue
+            exit $retval
+          EOH
+
+          machine.communicate.execute(
+            script,
+            error_class: Errors::RenameComputerFailed,
+            error_key: :rename_computer_failed)
+
+          machine.guest.capability(:reboot)
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/choose_addressable_ip_addr.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      module ChooseAddressableIPAddr
+        def self.choose_addressable_ip_addr(machine, possible)
+          machine.communicate.tap do |comm|
+            possible.each do |ip|
+              command = "ping -n 1 -w 1 #{ip}"
+              if comm.test(command)
+                return ip
+              end
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/configure_networks.rb

@@ -0,0 +1,83 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require_relative "../guest_network"
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      module ConfigureNetworks
+        @@logger = Log4r::Logger.new("vagrant::guest::windows::configure_networks")
+
+        def self.configure_networks(machine, networks)
+          @@logger.debug("Networks: #{networks.inspect}")
+
+          guest_network = GuestNetwork.new(machine.communicate)
+          if machine.provider_name.to_s.start_with?("vmware")
+            machine.ui.warn("Configuring secondary network adapters through VMware ")
+            machine.ui.warn("on Windows is not yet supported. You will need to manually")
+            machine.ui.warn("configure the network adapter.")
+          else
+            vm_interface_map = create_vm_interface_map(machine, guest_network)
+            networks.each do |network|
+              interface = vm_interface_map[network[:interface]+1]
+              if interface.nil?
+                @@logger.warn("Could not find interface for network #{network.inspect}")
+                next
+              end
+
+              network_type = network[:type].to_sym
+              if network_type == :static
+                guest_network.configure_static_interface(
+                  interface[:index],
+                  interface[:net_connection_id],
+                  network[:ip],
+                  network[:netmask])
+              elsif network_type == :dhcp
+                guest_network.configure_dhcp_interface(
+                  interface[:index],
+                  interface[:net_connection_id])
+              else
+                raise "#{network_type} network type is not supported, try static or dhcp"
+              end
+            end
+          end
+
+          if machine.config.windows.set_work_network
+            guest_network.set_all_networks_to_work
+          end
+        end
+
+        def self.create_vm_interface_map(machine, guest_network)
+          if !machine.provider.capability?(:nic_mac_addresses)
+            raise Vagrant::Errors::CantReadMACAddresses,
+              provider: machine.provider_name.to_s
+          end
+
+          driver_mac_address = machine.provider.capability(:nic_mac_addresses).invert
+          @@logger.debug("mac addresses: #{driver_mac_address.inspect}")
+
+          vm_interface_map = {}
+          guest_network.network_adapters.each do |nic|
+            @@logger.debug("nic: #{nic.inspect}")
+            naked_mac = nic[:mac_address].gsub(':','')
+            # If the :net_connection_id entry is nil then it is probably a virtual connection
+            # and should be ignored.
+            if driver_mac_address[naked_mac] && !nic[:net_connection_id].nil?
+              vm_interface_map[driver_mac_address[naked_mac]] = {
+                net_connection_id: nic[:net_connection_id],
+                mac_address: naked_mac,
+                interface_index: nic[:interface_index],
+                index: nic[:index] }
+            end
+          end
+
+          @@logger.debug("vm_interface_map: #{vm_interface_map.inspect}")
+          vm_interface_map
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/file_system.rb

@@ -0,0 +1,68 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class FileSystem
+        # Create a temporary file or directory on the guest
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [Hash] opts Path options
+        # @return [String] path to temporary file or directory
+        def self.create_tmp_path(machine, opts)
+          comm = machine.communicate
+          path = ""
+          cmd = "Write-Output ([System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), " \
+            "[System.IO.Path]::GetRandomFileName())) | Out-String -Width 2048"
+          comm.execute(cmd, shell: :powershell) do |type, data|
+            if type == :stdout
+              path << data
+            end
+          end
+          path.strip!
+          if opts[:extension]
+            path << opts[:extension].to_s
+          end
+          if opts[:type] == :directory
+            comm.execute("[System.IO.Directory]::CreateDirectory('#{path}')")
+          end
+          path
+        end
+
+        # Decompress zip file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_zip(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          destination = destination.tr("/", "\\")
+          if opts[:type] == :directory
+            cmds << "New-Item -ItemType Directory -Force -Path \"#{destination}\""
+          else
+            d_parts = destination.split("\\")
+            d_parts.pop
+            parent_dir = d_parts.join("\\") + "\\"
+            cmds << "New-Item -ItemType Directory -Force -Path \"#{parent_dir}\""
+          end
+          cmd = "$f = \"#{compressed_file}\"; $d = \"#{extract_dir}\"; "
+          cmd << '$s = New-Object -ComObject "Shell.Application"; $z = $s.NameSpace($f); '
+          cmd << 'foreach($i in $z.items()){ $s.Namespace($d).copyhere($i); }'
+          cmds << cmd
+          cmds += [
+            "Move-Item -Force -Path \"#{extract_dir}\\*\" -Destination \"#{destination}\\\"",
+            "Remove-Item -Path \"#{compressed_file}\" -Force",
+            "Remove-Item -Path \"#{extract_dir}\" -Recurse -Force"
+          ]
+          cmds.each do |cmd|
+            comm.execute(cmd, shell: :powershell)
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/halt.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      module Halt
+        def self.halt(machine)
+          # Fix vagrant-windows GH-129, if there's an existing scheduled
+          # reboot cancel it so shutdown succeeds
+          machine.communicate.execute("shutdown -a", error_check: false)
+
+          # Force shutdown the machine now
+          machine.communicate.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/mount_shared_folder.rb

@@ -0,0 +1,60 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/template_renderer"
+require "base64"
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class MountSharedFolder
+        def self.mount_virtualbox_shared_folder(machine, name, guestpath, options)
+          mount_shared_folder(machine, name, guestpath, "\\\\vboxsvr\\")
+        end
+
+        def self.mount_vmware_shared_folder(machine, name, guestpath, options)
+          mount_shared_folder(machine, name, guestpath, "\\\\vmware-host\\Shared Folders\\")
+        end
+
+        def self.mount_parallels_shared_folder(machine, name, guestpath, options)
+          mount_shared_folder(machine, name, guestpath, "\\\\psf\\")
+        end
+
+        def self.mount_smb_shared_folder(machine, name, guestpath, options)
+          if !options[:smb_password].to_s.empty?
+            # Ensure password is scrubbed
+            Vagrant::Util::CredentialScrubber.sensitive(options[:smb_password])
+          end
+          machine.communicate.execute("cmdkey /add:#{options[:smb_host]} /user:#{options[:smb_username]} /pass:\"#{options[:smb_password]}\"", {shell: :powershell, elevated: true})
+          mount_shared_folder(machine, name, guestpath, "\\\\#{options[:smb_host]}\\")
+        end
+
+        protected
+
+        def self.mount_shared_folder(machine, name, guestpath, vm_provider_unc_base)
+          name = name.gsub(/[\/\/]/,'_').sub(/^_/, '')
+
+          path = File.expand_path("../../scripts/mount_volume.ps1", __FILE__)
+          script = Vagrant::Util::TemplateRenderer.render(path, options: {
+            mount_point: guestpath,
+            share_name: name,
+            vm_provider_unc_path: vm_provider_unc_base + name,
+          })
+
+          if machine.config.vm.communicator == :winrm || machine.config.vm.communicator == :winssh
+            machine.communicate.execute(script, shell: :powershell)
+          else
+            # Convert script to double byte unicode string then base64 encode
+            # just like PowerShell -EncodedCommand expects.
+            # Suppress the progress stream from leaking to stderr.
+            wrapped_encoded_command = Base64.strict_encode64(
+              "$ProgressPreference='SilentlyContinue'; #{script}; exit $LASTEXITCODE".encode('UTF-16LE', 'UTF-8'))
+            # Execute encoded PowerShell script via OpenSSH shell
+            machine.communicate.execute("powershell.exe -noprofile -executionpolicy bypass " +
+              "-encodedcommand '#{wrapped_encoded_command}'", shell: "sh")
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/public_key.rb

@@ -0,0 +1,87 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "tempfile"
+
+require_relative '../../../communicators/winssh/communicator'
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class PublicKey
+        def self.insert_public_key(machine, contents)
+          if machine.communicate.is_a?(CommunicatorWinSSH::Communicator)
+            contents = contents.strip
+            winssh_modify_authorized_keys machine do |keys|
+              if !keys.include?(contents)
+                keys << contents
+              end
+            end
+          else
+            raise Vagrant::Errors::SSHInsertKeyUnsupported
+          end
+        end
+
+        def self.remove_public_key(machine, contents)
+          if machine.communicate.is_a?(CommunicatorWinSSH::Communicator)
+            winssh_modify_authorized_keys machine do |keys|
+              keys.delete(contents)
+            end
+          else
+            raise Vagrant::Errors::SSHInsertKeyUnsupported
+          end
+        end
+
+        def self.winssh_modify_authorized_keys(machine)
+          comm = machine.communicate
+          directories = fetch_guest_paths(comm)
+          home_dir = directories[:home]
+          temp_dir = directories[:temp]
+
+          # Ensure the user's ssh directory exists
+          remote_ssh_dir = "#{home_dir}\\.ssh"
+          comm.execute("New-Item -Path '#{remote_ssh_dir}' -ItemType directory -Force", shell: "powershell")
+          remote_upload_path = "#{temp_dir}\\vagrant-insert-pubkey-#{Time.now.to_i}"
+          remote_authkeys_path = "#{remote_ssh_dir}\\authorized_keys"
+
+          keys_file = Tempfile.new("vagrant-windows-insert-public-key")
+          keys_file.close
+          # Check if an authorized_keys file already exists
+          result = comm.execute("dir \"#{remote_authkeys_path}\"", shell: "cmd", error_check: false)
+          if result == 0
+            comm.download(remote_authkeys_path, keys_file.path)
+            keys = File.read(keys_file.path).split(/[\r\n]+/)
+          else
+            keys = []
+          end
+          yield keys
+          File.write(keys_file.path, keys.join("\r\n") + "\r\n")
+          comm.upload(keys_file.path, remote_upload_path)
+          keys_file.delete
+          comm.execute(<<-EOC.gsub(/^\s*/, ""), shell: "powershell")
+            Set-Acl "#{remote_upload_path}" (Get-Acl "#{remote_authkeys_path}")
+            Move-Item -Force "#{remote_upload_path}" "#{remote_authkeys_path}"
+          EOC
+        end
+
+        # Fetch user's temporary and home directory paths from the Windows guest
+        #
+        # @param [Communicator]
+        # @return [Hash] {:temp, :home}
+        def self.fetch_guest_paths(communicator)
+          output = ""
+          communicator.execute("Write-Output $env:TEMP\nWrite-Output $env:USERPROFILE", shell: "powershell") do |type, data|
+            if type == :stdout
+              output << data
+            end
+          end
+          temp_dir, home_dir = output.strip.split(/[\r\n]+/)
+          if temp_dir.nil? || home_dir.nil?
+            raise Errors::PublicKeyDirectoryFailure
+          end
+          {temp: temp_dir, home: home_dir}
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/reboot.rb

@@ -0,0 +1,63 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class Reboot
+        DEFAULT_MAX_REBOOT_RETRY_DURATION = 120
+        WAIT_SLEEP_TIME = 5
+
+        def self.reboot(machine)
+          @logger = Log4r::Logger.new("vagrant::windows::reboot")
+          reboot_script = "shutdown /r /t 5 /f /d p:4:1 /c \"Vagrant Reboot Computer\""
+
+          comm = machine.communicate
+
+          script  = File.expand_path("../../scripts/reboot_detect.ps1", __FILE__)
+          script  = File.read(script)
+          if comm.test(script, error_check: false, shell: :powershell)
+            @logger.debug("Issuing reboot command for guest")
+            comm.execute(reboot_script, shell: :powershell)
+          else
+            @logger.debug("A reboot is already in progress")
+          end
+
+          machine.ui.info(I18n.t("vagrant.guests.capabilities.rebooting"))
+
+          @logger.debug("Waiting for machine to finish rebooting")
+
+          wait_remaining = ENV.fetch("VAGRANT_MAX_REBOOT_RETRY_DURATION",
+            DEFAULT_MAX_REBOOT_RETRY_DURATION).to_i
+          wait_remaining = DEFAULT_MAX_REBOOT_RETRY_DURATION if wait_remaining < 1
+
+          begin
+            wait_for_reboot(machine)
+          rescue => err
+            raise if wait_remaining < 0
+            @logger.debug("Exception caught while waiting for reboot: #{err}")
+            @logger.warn("Machine not ready, cannot start reboot yet. Trying again")
+            sleep(WAIT_SLEEP_TIME)
+            wait_remaining -= WAIT_SLEEP_TIME
+            retry
+          end
+        end
+
+        def self.wait_for_reboot(machine)
+          script  = File.expand_path("../../scripts/reboot_detect.ps1", __FILE__)
+          script  = File.read(script)
+
+          while machine.guest.ready? && machine.communicate.execute(script, error_check: false, shell: :powershell) != 0
+            sleep 10
+          end
+
+          # This re-establishes our symbolic links if they were
+          # created between now and a reboot
+          machine.communicate.execute("net use", error_check: false, shell: :powershell)
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/cap/rsync.rb

@@ -0,0 +1,29 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class RSync
+        def self.rsync_scrub_guestpath( machine, opts )
+          # Windows guests most often use cygwin-dependent rsync utilities
+          # that expect "/cygdrive/c" instead of "c:" as the path prefix
+          # some vagrant code may pass guest paths with drive-lettered paths here
+          opts[:guestpath].gsub( /^([a-zA-Z]):/, '/cygdrive/\1' )
+        end
+
+        def self.rsync_pre(machine, opts)
+          machine.communicate.tap do |comm|
+            # rsync does not construct any gaps in the path to the target directory
+            # make sure that all subdirectories are created
+            # NB: Per #11878, the `mkdir` command on Windows is different than used on Unix.
+            # This formulation matches the form used in the WinRM communicator plugin.
+            # This will ignore any -p switches, which are redundant in PowerShell,
+            # and ambiguous in PowerShell 4+
+            comm.execute("mkdir \"#{opts[:guestpath]}\" -force")
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/windows/config.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :set_work_network
+
+      def initialize
+        @set_work_network = UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << "windows.set_work_network cannot be nil." if @set_work_network.nil?
+
+        { "Windows Guest" => errors }
+      end
+
+      def finalize!
+        @set_work_network = false if @set_work_network == UNSET_VALUE
+      end
+    end
+  end
+end

data/plugins/guests/windows/errors.rb

@@ -0,0 +1,25 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    module Errors
+      # A convenient superclass for all our errors.
+      class WindowsError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_windows.errors")
+      end
+
+      class NetworkWinRMRequired < WindowsError
+        error_key(:network_winrm_required)
+      end
+
+      class RenameComputerFailed < WindowsError
+        error_key(:rename_computer_failed)
+      end
+
+      class PublicKeyDirectoryFailure < WindowsError
+        error_key(:public_key_directory_failure)
+      end
+    end
+  end
+end

data/plugins/guests/windows/guest.rb

@@ -0,0 +1,13 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestWindows
+    class Guest < Vagrant.plugin("2", :guest)
+      def detect?(machine)
+        # See if the Windows directory is present.
+        machine.communicate.test("test -d $Env:SystemRoot")
+      end
+    end
+  end
+end