vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,138 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "tempfile"
+require "yaml"
+
+require_relative "../../../../lib/vagrant/util/template_renderer"
+
+module VagrantPlugins
+  module GuestCoreOS
+    module Cap
+      class ConfigureNetworks
+        extend Vagrant::Util::GuestInspection::Linux
+
+        NETWORK_MANAGER_CONN_DIR = "/etc/NetworkManager/system-connections".freeze
+        DEFAULT_ENVIRONMENT_IP = "127.0.0.1".freeze
+
+        def self.configure_networks(machine, networks)
+          comm = machine.communicate
+          return configure_networks_cloud_init(machine, networks) if comm.test("command -v cloud-init")
+
+          interfaces = machine.guest.capability(:network_interfaces)
+          nm_dev = {}
+          comm.execute("nmcli -t c show") do |type, data|
+            if type == :stdout
+              _, id, _, dev = data.strip.split(":")
+              nm_dev[dev] = id
+            end
+          end
+          comm.sudo("rm #{File.join(NETWORK_MANAGER_CONN_DIR, 'vagrant-*.conf')}",
+            error_check: false)
+
+          networks.each_with_index do |network, i|
+            network[:device] = interfaces[network[:interface]]
+            addr = IPAddr.new(network[:ip])
+            mask = addr.mask(network[:netmask])
+            if !network[:mac_address]
+              comm.execute("cat /sys/class/net/#{network[:device]}/address") do |type, data|
+                if type == :stdout
+                  network[:mac_address] = data
+                end
+              end
+            end
+
+            f = Tempfile.new("vagrant-coreos-network")
+            {
+              connection: {
+                type: "ethernet",
+                id: network[:device],
+                "interface-name": network[:device]
+              },
+              ethernet: {
+                "mac-address": network[:mac_address]
+              },
+              ipv4: {
+                method: "manual",
+                addresses: "#{network[:ip]}/#{mask.prefix}",
+                gateway: network.fetch(:gateway, mask.to_range.first.succ),
+              },
+            }.each_pair do |section, content|
+              f.puts "[#{section}]"
+              content.each_pair do |key, value|
+                f.puts "#{key}=#{value}"
+              end
+            end
+            f.close
+            comm.sudo("nmcli d disconnect '#{network[:device]}'", error_check: false)
+            comm.sudo("nmcli c delete '#{nm_dev[network[:device]]}'", error_check: false)
+            dst = File.join("/var/tmp", "vagrant-#{network[:device]}.conf")
+            final = File.join(NETWORK_MANAGER_CONN_DIR, "vagrant-#{network[:device]}.conf")
+            comm.upload(f.path, dst)
+            comm.sudo("chown root:root '#{dst}'")
+            comm.sudo("chmod 0600 '#{dst}'")
+            comm.sudo("mv '#{dst}' '#{final}'")
+            comm.sudo("nmcli c load '#{final}'")
+            comm.sudo("nmcli d connect '#{network[:device]}'")
+            f.delete
+          end
+        end
+
+        def self.configure_networks_cloud_init(machine, networks)
+          cloud_config = {}
+          # Locate configured IP addresses to drop in /etc/environment
+          # for export. If no addresses found, fall back to default
+          public_ip = catch(:public_ip) do
+            machine.config.vm.networks.each do |type, opts|
+              next if type != :public_network
+              throw(:public_ip, opts[:ip]) if opts[:ip]
+            end
+            DEFAULT_ENVIRONMENT_IP
+          end
+          private_ip = catch(:private_ip) do
+            machine.config.vm.networks.each do |type, opts|
+              next if type != :private_network
+              throw(:private_ip, opts[:ip]) if opts[:ip]
+            end
+            public_ip
+          end
+          cloud_config["write_files"] = [
+            {"path" => "/etc/environment",
+              "content" => "COREOS_PUBLIC_IPV4=#{public_ip}\nCOREOS_PRIVATE_IPV4=#{private_ip}"}
+          ]
+
+          # Generate configuration for any static network interfaces
+          # which have been defined
+          interfaces = machine.guest.capability(:network_interfaces)
+          units = networks.map do |network|
+            iface = network[:interface].to_i
+            unit_name = "50-vagrant#{iface}.network"
+            device = interfaces[iface]
+            if network[:type].to_s == "dhcp"
+              network_content = "DHCP=yes"
+            else
+              prefix = IPAddr.new("255.255.255.255/#{network[:netmask]}").to_i.to_s(2).count("1")
+              address = "#{network[:ip]}/#{prefix}"
+              network_content = "Address=#{address}"
+            end
+            {"name" => unit_name,
+              "runtime" => "no",
+              "content" => "[Match]\nName=#{device}\n[Network]\n#{network_content}"}
+          end
+          cloud_config["coreos"] = {"units" => units.compact}
+
+          # Upload configuration and apply
+          file = Tempfile.new("vagrant-coreos-networks")
+          file.puts("#cloud-config\n")
+          file.puts(cloud_config.to_yaml)
+          file.close
+
+          dst = "/var/tmp/networks.yml"
+          svc_path = dst.tr("/", "-")[1..-1]
+          machine.communicate.upload(file.path, dst)
+          machine.communicate.sudo("systemctl start system-cloudinit@#{svc_path}.service")
+        end
+      end
+    end
+  end
+end

data/plugins/guests/coreos/cap/docker.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestCoreOS
+    module Cap
+      module Docker
+        def self.docker_daemon_running(machine)
+          machine.communicate.test("test -S /run/docker.sock")
+        end
+      end
+    end
+  end
+end

data/plugins/guests/coreos/guest.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestCoreOS
+    class Guest < Vagrant.plugin("2", :guest)
+      def detect?(machine)
+        machine.communicate.test("(cat /etc/os-release | grep ID=coreos) || (cat /etc/os-release | grep -E 'ID_LIKE=.*coreos.*')")
+      end
+    end
+  end
+end

data/plugins/guests/coreos/plugin.rb

@@ -0,0 +1,33 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestCoreOS
+    class Plugin < Vagrant.plugin("2")
+      name "CoreOS guest"
+      description "CoreOS guest support."
+
+      guest(:coreos, :linux) do
+        require_relative "guest"
+        Guest
+      end
+
+      guest_capability(:coreos, :change_host_name) do
+        require_relative "cap/change_host_name"
+        Cap::ChangeHostName
+      end
+
+      guest_capability(:coreos, :configure_networks) do
+        require_relative "cap/configure_networks"
+        Cap::ConfigureNetworks
+      end
+
+      guest_capability(:coreos, :docker_daemon_running) do
+        require_relative "cap/docker"
+        Cap::Docker
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/guest_hosts'
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class ChangeHostName
+        extend Vagrant::Util::GuestHosts::BSD
+
+        def self.change_host_name(machine, name)
+          comm = machine.communicate
+
+          if !comm.test("hostname -f | grep '^#{name}$'", sudo: false)
+            basename = name.split(".", 2)[0]
+
+            # LocalHostName should not contain dots - it is used by Bonjour and
+            # visible through file sharing services.
+            comm.sudo <<-EOH.gsub(/^ */, '')
+              # Set hostname
+              scutil --set ComputerName '#{name}' &&
+                scutil --set HostName '#{name}' &&
+                scutil --set LocalHostName '#{basename}'
+              result=$?
+              if [ $result -ne 0 ]; then
+                exit $result
+              fi
+
+              hostname '#{name}'
+            EOH
+          end
+          network_with_hostname = machine.config.vm.networks.map {|_, c| c if c[:hostname] }.compact[0]
+          if network_with_hostname
+            replace_host(comm, name, network_with_hostname[:ip])
+          else
+            add_hostname_to_loopback_interface(comm, name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      module ChooseAddressableIPAddr
+        def self.choose_addressable_ip_addr(machine, possible)
+          comm = machine.communicate
+
+          possible.each do |ip|
+            if comm.test("ping -c1 -t1 #{ip}")
+              return ip
+            end
+          end
+
+          # If we got this far, there are no addressable IPs
+          return nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "tempfile"
+
+require "vagrant/util/template_renderer"
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class ConfigureNetworks
+        @@logger = Log4r::Logger.new("vagrant::guest::darwin::configure_networks")
+
+        include Vagrant::Util
+
+        def self.configure_networks(machine, networks)
+          if !machine.provider.capability?(:nic_mac_addresses)
+            raise Vagrant::Errors::CantReadMACAddresses,
+                  provider: machine.provider_name.to_s
+          end
+
+          nic_mac_addresses = machine.provider.capability(:nic_mac_addresses)
+          @@logger.debug("mac addresses: #{nic_mac_addresses.inspect}")
+
+          mac_service_map = create_mac_service_map(machine)
+
+          networks.each do |network|
+            mac_address = nic_mac_addresses[network[:interface]+1]
+            if mac_address.nil?
+              @@logger.warn("Could not find mac address for network #{network.inspect}")
+              next
+            end
+
+            service_name = mac_service_map[mac_address]
+            if service_name.nil?
+              @@logger.warn("Could not find network service for mac address #{mac_address}")
+              next
+            end
+
+            network_type = network[:type].to_sym
+            case network_type.to_sym
+            when :static
+              command = "networksetup -setmanual \"#{service_name}\" #{network[:ip]} #{network[:netmask]} #{network[:router]}"
+            when :static6
+              command = "networksetup -setv6manual \"#{service_name}\" #{network[:ip]} #{network[:netmask]} #{network[:router]}"
+            when :dhcp
+              command = "networksetup -setdhcp \"#{service_name}\""
+            when :dhcp6
+              # This is not actually possible yet in Vagrant, but when we do
+              # enable IPv6 across the board, Darwin will already have support.
+              command = "networksetup -setv6automatic \"#{service_name}\""
+            else
+              raise Vagrant::Errors::NetworkTypeNotSupported, type: network_type
+            end
+
+            machine.communicate.sudo(command)
+          end
+        end
+
+        # Creates a hash mapping MAC addresses to network service name
+        # Example: { "00C100A1B2C3" => "Thunderbolt Ethernet" }
+        def self.create_mac_service_map(machine)
+          tmp_ints = File.join(Dir.tmpdir, File.basename("#{machine.id}.interfaces"))
+          tmp_hw = File.join(Dir.tmpdir, File.basename("#{machine.id}.hardware"))
+
+          machine.communicate.tap do |comm|
+            comm.sudo("networksetup -detectnewhardware")
+            comm.sudo("networksetup -listnetworkserviceorder > /tmp/vagrant.interfaces")
+            comm.sudo("networksetup -listallhardwareports > /tmp/vagrant.hardware")
+            comm.download("/tmp/vagrant.interfaces", tmp_ints)
+            comm.download("/tmp/vagrant.hardware", tmp_hw)
+          end
+
+          interface_map = {}
+          ints = ::IO.read(tmp_ints)
+          ints.split(/\n\n/m).each do |i|
+            if i.match(/Hardware/) && i.match(/Ethernet/)
+              # Ethernet, should be 2 lines,
+              # (3) Thunderbolt Ethernet
+              # (Hardware Port: Thunderbolt Ethernet, Device: en1)
+
+              # multiline, should match "Thunderbolt Ethernet", "en1"
+              devicearry = i.match(/\([0-9]+\) (.+)\n.*Device: (.+)\)/m)
+              service = devicearry[1]
+              interface = devicearry[2]
+
+              # Should map interface to service { "en1" => "Thunderbolt Ethernet" }
+              interface_map[interface] = service
+            end
+          end
+          File.delete(tmp_ints)
+
+          mac_service_map = {}
+          macs = ::IO.read(tmp_hw)
+          macs.split(/\n\n/m).each do |i|
+            if i.match(/Hardware/) && i.match(/Ethernet/)
+              # Ethernet, should be 3 lines,
+              # Hardware Port: Thunderbolt 1
+              # Device: en1
+              # Ethernet Address: a1:b2:c3:d4:e5:f6
+
+              # multiline, should match "en1", "00:c1:00:a1:b2:c3"
+              devicearry = i.match(/Device: (.+)\nEthernet Address: (.+)/m)
+              interface = devicearry[1]
+              naked_mac = devicearry[2].gsub(':','').upcase
+
+              # Skip hardware ports without MAC (bridges, bluetooth, etc.)
+              next if naked_mac == "N/A"
+
+              if !interface_map[interface]
+                @@logger.warn("Could not find network service for interface #{interface}")
+                next
+              end
+
+              # Should map MAC to service, { "00C100A1B2C3" => "Thunderbolt Ethernet" }
+              mac_service_map[naked_mac] = interface_map[interface]
+            end
+          end
+          File.delete(tmp_hw)
+
+          mac_service_map
+        end
+      end
+    end
+  end
+end

data/plugins/guests/darwin/cap/darwin_version.rb

@@ -0,0 +1,43 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class DarwinVersion
+        
+        VERSION_REGEX = /\d+.\d+.?\d*/.freeze
+
+        # Get the darwin version
+        #
+        # @param [Machine]
+        # @return [String] version of drawin
+        def self.darwin_version(machine)
+          output = ""
+          machine.communicate.sudo("sysctl kern.osrelease") do |_, data|
+            output = data
+          end
+          output.scan(VERSION_REGEX).first
+        end
+
+        # Get the darwin major version
+        #
+        # @param [Machine]
+        # @return [int] major version of drawin (nil if version is not detected)
+        def self.darwin_major_version(machine)
+          output = ""
+          machine.communicate.sudo("sysctl kern.osrelease") do |_, data|
+            output = data
+          end
+          version_string = output.scan(VERSION_REGEX).first
+          if version_string
+            major_version = version_string.split(".").first.to_i
+          else
+            major_version = nil
+          end
+          major_version
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class Halt
+        def self.halt(machine)
+          begin
+            # Darwin does not support the `-p` option like the rest of the
+            # BSD-based guests, so it needs its own cap.
+            machine.communicate.sudo("/sbin/shutdown -h now")
+          rescue IOError, Vagrant::Errors::SSHDisconnected
+            # Do nothing because SSH connection closed and it probably
+            # means the VM just shut down really fast.
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/darwin/cap/mount_smb_shared_folder.rb

@@ -0,0 +1,46 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/retryable"
+require "shellwords"
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class MountSMBSharedFolder
+        extend Vagrant::Util::Retryable
+        def self.mount_smb_shared_folder(machine, name, guestpath, options)
+          expanded_guest_path = machine.guest.capability(:shell_expand_guest_path, guestpath)
+
+          mount_point_owner = options[:owner];
+          if mount_point_owner
+            machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+            machine.communicate.sudo("chown #{mount_point_owner} #{expanded_guest_path}")
+          else
+            # fallback to assumption that user has permission
+            # to create the specified mountpoint
+            machine.communicate.execute("mkdir -p #{expanded_guest_path}")
+          end
+
+          smb_password = Shellwords.shellescape(options[:smb_password])
+          # Ensure password is scrubbed
+          Vagrant::Util::CredentialScrubber.sensitive(smb_password)
+
+          mount_options = options[:mount_options];
+          mount_command = "mount -t smbfs " +
+            (mount_options ? "-o '#{mount_options.join(",")}' " : "") +
+            "//#{options[:smb_username]}:#{smb_password}@#{options[:smb_host]}/#{name} " +
+            "#{expanded_guest_path}"
+          retryable(on: Vagrant::Errors::DarwinMountFailed, tries: 10, sleep: 2) do
+            result = machine.communicate.execute(mount_command)
+            if result.exit_code != 0
+              raise Vagrant::Errors::DarwinMountFailed,
+                command: mount_command,
+                output: result.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/darwin/cap/mount_vmware_shared_folder.rb

@@ -0,0 +1,135 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "securerandom"
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class MountVmwareSharedFolder
+
+        MACOS_BIGSUR_DARWIN_VERSION = 20.freeze
+
+        # Entry point for hook to called delayed actions
+        # which finalizing the synced folders setup on
+        # the guest
+        def self.write_apfs_firmlinks(env)
+          if env && env[:machine] && delayed = apfs_firmlinks_delayed.delete(env[:machine].id)
+            delayed.call
+          end
+        end
+
+        # @return [Hash] storage location for delayed actions
+        def self.apfs_firmlinks_delayed
+          if !@_apfs_firmlinks
+            @_apfs_firmlinks = {}
+          end
+          @_apfs_firmlinks
+        end
+
+        # we seem to be unable to ask 'mount -t vmhgfs' to mount the roots
+        # of specific shares, so instead we symlink from what is already
+        # mounted by the guest tools
+        # (ie. the behaviour of the VMware_fusion provider prior to 0.8.x)
+
+        def self.mount_vmware_shared_folder(machine, name, guestpath, options)
+          # Use this variable to determine which machines
+          # have been registered with after hook
+          @apply_firmlinks ||= Hash.new{ |h, k| h[k] = {bootstrap: false, content: []} }
+
+          machine.communicate.tap do |comm|
+            # check if we are dealing with an APFS root container
+            if comm.test("test -d /System/Volumes/Data")
+              parts = Pathname.new(guestpath).descend.to_a
+              firmlink = parts[1].to_s
+              firmlink.slice!(0, 1) if firmlink.start_with?("/")
+              if parts.size > 2
+                guestpath = File.join("/System/Volumes/Data", guestpath)
+              else
+                guestpath = nil
+              end
+            end
+
+            # Remove existing symlink or directory if defined
+            if guestpath
+              if comm.test("test -L \"#{guestpath}\"")
+                comm.sudo("rm -f \"#{guestpath}\"")
+              elsif comm.test("test -d \"#{guestpath}\"")
+                comm.sudo("rm -Rf \"#{guestpath}\"")
+              end
+
+              # create intermediate directories if needed
+              intermediate_dir = File.dirname(guestpath)
+              if intermediate_dir != "/"
+                comm.sudo("mkdir -p \"#{intermediate_dir}\"")
+              end
+
+              comm.sudo("ln -s \"/Volumes/VMware Shared Folders/#{name}\" \"#{guestpath}\"")
+            end
+
+            if firmlink && !system_firmlink?(firmlink)
+              if guestpath.nil?
+                guestpath = "/Volumes/VMware Shared Folders/#{name}"
+              else
+                guestpath = File.join("/System/Volumes/Data", firmlink)
+              end
+
+              share_line = "#{firmlink}\t#{guestpath}"
+
+              # Check if the line is already defined. If so, bail since we are done
+              if !comm.test("[[ \"$(</etc/synthetic.conf)\" = *\"#{share_line}\"* ]]")
+                @apply_firmlinks[machine.id][:bootstrap] = true
+              end
+
+              # If we haven't already added our hook to apply firmlinks, do it now
+              if @apply_firmlinks[machine.id][:content].empty?
+                apfs_firmlinks_delayed[machine.id] = proc do
+                  content = @apply_firmlinks[machine.id][:content].join("\n")
+                  # Write out the synthetic file
+                  comm.sudo("echo -e #{content.inspect} > /etc/synthetic.conf")
+                  if @apply_firmlinks[machine.id][:bootstrap]
+                    if machine.guest.capability("darwin_major_version").to_i < MACOS_BIGSUR_DARWIN_VERSION
+                      apfs_bootstrap_flag = "-B"
+                      expected_rc = 0
+                    else
+                      apfs_bootstrap_flag = "-t"
+                      expected_rc = 253
+                    end
+                    # Re-bootstrap the root container to pick up firmlink updates
+                    comm.sudo("/System/Library/Filesystems/apfs.fs/Contents/Resources/apfs.util #{apfs_bootstrap_flag}", good_exit: [expected_rc])
+                  end
+                end
+              end
+              @apply_firmlinks[machine.id][:content] << share_line
+            end
+          end
+        end
+
+        # Check if firmlink is provided by the system
+        #
+        # @param [String] firmlink Firmlink path
+        # @return [Boolean]
+        def self.system_firmlink?(firmlink)
+          if !@_firmlinks
+            if File.exist?("/usr/share/firmlinks")
+              @_firmlinks = File.readlines("/usr/share/firmlinks").map do |line|
+                line.split.first
+              end
+            else
+              @_firmlinks = []
+            end
+          end
+          firmlink = "/#{firmlink}" if !firmlink.start_with?("/")
+          @_firmlinks.include?(firmlink)
+        end
+
+        # @private
+        # Reset the cached values for capability. This is not considered a public
+        # API and should only be used for testing.
+        def self.reset!
+          instance_variables.each(&method(:remove_instance_variable))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../../../synced_folders/rsync/default_unix_cap"
+
+module VagrantPlugins
+  module GuestDarwin
+    module Cap
+      class RSync
+        extend VagrantPlugins::SyncedFolderRSync::DefaultUnixCap
+      end
+    end
+  end
+end