vagrant 1.5.0 → 2.4.4

data/plugins/hosts/bsd/cap/nfs.rb

@@ -0,0 +1,218 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require "vagrant/util"
+require "vagrant/util/shell_quote"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module HostBSD
+    module Cap
+      class NFS
+        def self.nfs_export(environment, ui, id, ips, folders)
+          nfs_exports_template = environment.host.capability(:nfs_exports_template)
+          nfs_restart_command  = environment.host.capability(:nfs_restart_command)
+          nfs_status_command  = environment.host.capability(:nfs_status_command)
+          nfs_update_command  = environment.host.capability(:nfs_update_command)
+          logger = Log4r::Logger.new("vagrant::hosts::bsd")
+
+          nfs_checkexports! if File.file?("/etc/exports")
+
+          # We need to build up mapping of directories that are enclosed
+          # within each other because the exports file has to have subdirectories
+          # of an exported directory on the same line. e.g.:
+          #
+          #   "/foo" "/foo/bar" ...
+          #   "/bar"
+          #
+          # We build up this mapping within the following hash.
+          logger.debug("Compiling map of sub-directories for NFS exports...")
+          dirmap = {}
+          folders.sort_by { |_, opts| opts[:hostpath] }.each do |_, opts|
+            opts[:hostpath] = environment.host.capability(:resolve_host_path, opts[:hostpath].gsub('"', '\"'))
+            hostpath = opts[:hostpath].dup
+
+            found = false
+            dirmap.each do |dirs, diropts|
+              dirs.each do |dir|
+                if dir.start_with?(hostpath) || hostpath.start_with?(dir)
+                  # TODO: verify opts and diropts are _identical_, raise an error
+                  # if not. NFS mandates subdirectories have identical options.
+                  dirs << hostpath
+                  found = true
+                  break
+                end
+              end
+
+              break if found
+            end
+
+            if !found
+              dirmap[[hostpath]] = opts.dup
+            end
+          end
+
+          # Sort all the keys by length so that the directory closest to
+          # the root is exported first. Also, remove duplicates so that
+          # checkexports will work properly.
+          dirmap.each do |dirs, _|
+            dirs.uniq!
+            dirs.sort_by! { |d| d.length }
+          end
+
+          # Setup the NFS options
+          dirmap.each do |dirs, opts|
+            if !opts[:bsd__nfs_options]
+              opts[:bsd__nfs_options] = ["alldirs"]
+            end
+
+            hasmapall = false
+            opts[:bsd__nfs_options].each do |opt|
+              # mapall/maproot are mutually exclusive, so we have to check
+              # for both here.
+              if opt =~ /^mapall=/ || opt =~ /^maproot=/
+                hasmapall = true
+                break
+              end
+            end
+
+            if !hasmapall
+              opts[:bsd__nfs_options] << "mapall=#{opts[:map_uid]}:#{opts[:map_gid]}"
+            end
+
+            opts[:bsd__compiled_nfs_options] = opts[:bsd__nfs_options].map do |opt|
+              "-#{opt}"
+            end.join(" ")
+          end
+
+          logger.info("Exporting the following for NFS...")
+          dirmap.each do |dirs, opts|
+            logger.info("NFS DIR: #{dirs.inspect}")
+            logger.info("NFS OPTS: #{opts.inspect}")
+          end
+
+          output = Vagrant::Util::TemplateRenderer.render(nfs_exports_template,
+                                           uuid: id,
+                                           ips: ips,
+                                           folders: dirmap,
+                                           user: Process.uid)
+
+          # The sleep ensures that the output is truly flushed before any `sudo`
+          # commands are issued.
+          ui.info I18n.t("vagrant.hosts.bsd.nfs_export")
+          sleep 0.5
+
+          # First, clean up the old entry
+          nfs_cleanup(id)
+
+          # Only use "sudo" if we can't write to /etc/exports directly
+          sudo_command = ""
+          sudo_command = "sudo " if !File.writable?("/etc/exports")
+
+          # Output the rendered template into the exports
+          output.split("\n").each do |line|
+            line = Vagrant::Util::ShellQuote.escape(line, "'")
+            system(
+              "echo '#{line}' | " +
+              "#{sudo_command}/usr/bin/tee -a /etc/exports >/dev/null")
+          end
+
+          # Check if nfsd is running, and update or restart depending on the result
+          if nfs_running?(nfs_status_command)
+            system(*nfs_update_command)
+          else
+            system(*nfs_restart_command)
+          end
+        end
+
+        def self.nfs_exports_template(environment)
+          "nfs/exports_bsd"
+        end
+
+        def self.nfs_installed(environment)
+          !!Vagrant::Util::Which.which("nfsd")
+        end
+
+        def self.nfs_prune(environment, ui, valid_ids)
+          return if !File.exist?("/etc/exports")
+
+          logger = Log4r::Logger.new("vagrant::hosts::bsd")
+          logger.info("Pruning invalid NFS entries...")
+
+          output = false
+          user = Process.uid
+
+          File.read("/etc/exports").lines.each do |line|
+            if id = line[/^# VAGRANT-BEGIN:( #{user})? ([\.\/A-Za-z0-9\-_:]+?)$/, 2]
+              if valid_ids.include?(id)
+                logger.debug("Valid ID: #{id}")
+              else
+                if !output
+                  # We want to warn the user but we only want to output once
+                  ui.info I18n.t("vagrant.hosts.bsd.nfs_prune")
+                  output = true
+                end
+
+                logger.info("Invalid ID, pruning: #{id}")
+                nfs_cleanup(id)
+              end
+            end
+          end
+        rescue Errno::EACCES
+          raise Vagrant::Errors::NFSCantReadExports
+        end
+
+        def self.nfs_running?(check_command)
+          Vagrant::Util::Subprocess.execute(*check_command).exit_code == 0
+        end
+
+        def self.nfs_restart_command(environment)
+          ["sudo", "nfsd", "restart"]
+        end
+
+        def self.nfs_update_command(environment)
+          ["sudo", "nfsd", "update"]
+        end
+
+        def self.nfs_status_command(environment)
+          ["sudo", "nfsd", "status"]
+        end
+
+        protected
+
+        def self.nfs_cleanup(id)
+          return if !File.exist?("/etc/exports")
+
+          # Escape sed-sensitive characters:
+          id = id.gsub("/", "\\/")
+          id = id.gsub(".", "\\.")
+
+          user = Process.uid
+
+          command = []
+          command << "sudo" if !File.writable?("/etc/exports")
+          command += [
+            "sed", "-E", "-e",
+            "/^# VAGRANT-BEGIN:( #{user})? #{id}/," +
+            "/^# VAGRANT-END:( #{user})? #{id}/ d",
+            "-ibak",
+            "/etc/exports"
+          ]
+
+          # Use sed to just strip out the block of code which was inserted
+          # by Vagrant, and restart NFS.
+          system(*command)
+        end
+
+        def self.nfs_checkexports!
+          r = Vagrant::Util::Subprocess.execute("nfsd", "checkexports")
+          if r.exit_code != 0
+            raise Vagrant::Errors::NFSBadExports, output: r.stderr
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/bsd/cap/path.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HostBSD
+    module Cap
+      class Path
+        def self.resolve_host_path(env, path)
+          path
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/bsd/cap/ssh.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HostBSD
+    module Cap
+      class SSH
+        # Set the ownership and permissions for SSH
+        # private key
+        #
+        # @param [Vagrant::Environment] env
+        # @param [Pathname] key_path
+        def self.set_ssh_key_permissions(env, key_path)
+          key_path.chmod(0600)
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/bsd/host.rb

@@ -0,0 +1,15 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module HostBSD
+    # Represents a BSD host, such as FreeBSD.
+    class Host < Vagrant.plugin("2", :host)
+      def detect?(env)
+        Vagrant::Util::Platform.darwin?
+      end
+    end
+  end
+end

data/plugins/hosts/bsd/plugin.rb

@@ -0,0 +1,63 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module HostBSD
+    class Plugin < Vagrant.plugin("2")
+      name "BSD host"
+      description "BSD host support."
+
+      host("bsd") do
+        require File.expand_path("../host", __FILE__)
+        Host
+      end
+
+      host_capability("bsd", "nfs_export") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_exports_template") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_installed") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_prune") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_restart_command") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_update_command") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "nfs_status_command") do
+        require_relative "cap/nfs"
+        Cap::NFS
+      end
+
+      host_capability("bsd", "resolve_host_path") do
+        require_relative "cap/path"
+        Cap::Path
+      end
+
+      host_capability("bsd", "set_ssh_key_permissions") do
+        require_relative "cap/ssh"
+        Cap::SSH
+      end
+    end
+  end
+end

data/plugins/hosts/darwin/cap/configured_ip_addresses.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "socket"
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class ConfiguredIPAddresses
+
+        def self.configured_ip_addresses(env)
+          Socket.getifaddrs.map do |interface|
+            if interface.addr.ipv4? && !interface.addr.ipv4_loopback?
+              interface.addr.ip_address
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/darwin/cap/fs_iso.rb

@@ -0,0 +1,52 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+require "vagrant/util/caps"
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class FsISO
+        extend Vagrant::Util::Caps::BuildISO
+        
+        @@logger = Log4r::Logger.new("vagrant::host::darwin::fs_iso")
+
+        BUILD_ISO_CMD = "hdiutil".freeze
+
+        # Check that the host has the ability to generate ISOs
+        #
+        # @param [Vagrant::Environment] env
+        # @return [Boolean]
+        def self.isofs_available(env)
+          !!Vagrant::Util::Which.which(BUILD_ISO_CMD)
+        end
+
+        # Generate an ISO file of the given source directory
+        #
+        # @param [Vagrant::Environment] env
+        # @param [String] source_directory Contents of ISO
+        # @param [Map] extra arguments to pass to the iso building command
+        #              :file_destination (string) location to store ISO
+        #              :volume_id (String) to set the volume name 
+        # @return [Pathname] ISO location
+        # @note If file_destination exists, source_directory will be checked
+        #       for recent modifications and a new ISO will be generated if requried.
+        def self.create_iso(env, source_directory, extra_opts={})
+          source_directory = Pathname.new(source_directory)
+          file_destination = self.ensure_output_iso(extra_opts[:file_destination])
+
+          iso_command = [BUILD_ISO_CMD, "makehybrid", "-iso", "-joliet", "-ov"]
+          iso_command.concat(["-default-volume-name", extra_opts[:volume_id]]) if extra_opts[:volume_id]
+          iso_command << "-o"
+          iso_command << file_destination.to_s
+          iso_command << source_directory.to_s
+          self.build_iso(iso_command, source_directory, file_destination)
+
+          @@logger.info("ISO available at #{file_destination}")
+          file_destination
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/darwin/cap/nfs.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class NFS
+        def self.nfs_exports_template(environment)
+          "nfs/exports_darwin"
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/darwin/cap/path.rb

@@ -0,0 +1,66 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class Path
+        @@logger = Log4r::Logger.new("vagrant::host::darwin::path")
+
+        FIRMLINK_DEFS = "/usr/share/firmlinks".freeze
+        FIRMLINK_DATA_PATH = "/System/Volumes/Data".freeze
+        CATALINA_CONSTRAINT = Gem::Requirement.new("~> 10.15")
+
+        # Resolve the given host path to the actual
+        # usable system path by detecting firmlinks
+        # if available on the current system
+        #
+        # @param [String] path Host system path
+        # @return [String] resolved path
+        def self.resolve_host_path(env, path)
+          path = File.expand_path(path)
+          # Only expand firmlink paths on Catalina
+          host_version = env.host.capability(:version)
+          return path if !CATALINA_CONSTRAINT.satisfied_by?(host_version)
+
+          firmlink = firmlink_map.detect do |mount_path, data_path|
+            path.start_with?(mount_path)
+          end
+          return path if firmlink.nil?
+          current_prefix, new_suffix = firmlink
+          new_prefix = File.join(FIRMLINK_DATA_PATH, new_suffix)
+          new_path = path.sub(current_prefix, new_prefix)
+          @@logger.debug("Resolved given path `#{path}` to `#{new_path}`")
+          new_path
+        end
+
+        # Generate mapping of firmlinks if available on the host
+        #
+        # @return [Hash<String,String>]
+        def self.firmlink_map
+          if !@firmlink_map
+            return @firmlink_map = {} if !File.exist?(FIRMLINK_DEFS)
+            begin
+              @firmlink_map = Hash[
+                File.readlines(FIRMLINK_DEFS).map { |d|
+                  d.strip.split(/\s+/, 2)
+                }
+              ]
+            rescue => err
+              @@logger.warn("Failed to parse firmlink definitions: #{err}")
+              @firmlink_map = {}
+            end
+          end
+          @firmlink_map
+        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/hosts/darwin/cap/provider_install_virtualbox.rb

@@ -0,0 +1,64 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+require "tempfile"
+
+require "vagrant/util/downloader"
+require "vagrant/util/file_checksum"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class ProviderInstallVirtualBox
+        # The URL to download VirtualBox is hardcoded so we can have a
+        # known-good version to download.
+        URL = "http://download.virtualbox.org/virtualbox/5.0.10/VirtualBox-5.0.10-104061-OSX.dmg".freeze
+        VERSION = "5.0.10".freeze
+        SHA256SUM = "62f933115498e51ddf5f2dab47dc1eebb42eb78ea1a7665cb91c53edacc847c6".freeze
+
+        def self.provider_install_virtualbox(env)
+          path = Dir::Tmpname.create("vagrant-provider-install-virtualbox") {}
+
+          # Prefixed UI for prettiness
+          ui = Vagrant::UI::Prefixed.new(env.ui, "")
+
+          # Start by downloading the file using the standard mechanism
+          ui.output(I18n.t(
+            "vagrant.hosts.darwin.virtualbox_install_download",
+            version: VERSION))
+          ui.detail(I18n.t(
+            "vagrant.hosts.darwin.virtualbox_install_detail"))
+          dl = Vagrant::Util::Downloader.new(URL, path, ui: ui)
+          dl.download!
+
+          # Validate that the file checksum matches
+          actual = FileChecksum.new(path, Digest::SHA2).checksum
+          if actual != SHA256SUM
+            raise Vagrant::Errors::ProviderChecksumMismatch,
+              provider: "virtualbox",
+              actual: actual,
+              expected: SHA256SUM
+          end
+
+          # Launch it
+          ui.output(I18n.t(
+            "vagrant.hosts.darwin.virtualbox_install_install"))
+          ui.detail(I18n.t(
+            "vagrant.hosts.darwin.virtualbox_install_install_detail"))
+          script = File.expand_path("../../scripts/install_virtualbox.sh", __FILE__)
+          result = Vagrant::Util::Subprocess.execute("bash", script, path)
+          if result.exit_code != 0
+            raise Vagrant::Errors::ProviderInstallFailed,
+              provider: "virtualbox",
+              stdout: result.stdout,
+              stderr: result.stderr
+          end
+
+          ui.success(I18n.t("vagrant.hosts.darwin.virtualbox_install_success"))
+        end
+      end
+    end
+  end
+end

data/plugins/hosts/darwin/cap/rdp.rb

@@ -0,0 +1,64 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+require "tmpdir"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module HostDarwin
+    module Cap
+      class RDP
+        def self.rdp_client(env, rdp_info)
+          config_path = self.generate_config_file(rdp_info)
+          begin
+            Vagrant::Util::Subprocess.execute("open", config_path.to_s)
+          ensure
+            # Note: this technically will never get run; neither would an
+            # at_exit call. The reason is that `exec` replaces this process,
+            # effectively the same as `kill -9`. This is solely here to prove
+            # that and so that future developers do not waste a ton of time
+            # try to identify why Vagrant is leaking RDP connection files.
+            # There is a catch-22 here in that we can't delete the file before
+            # we exec, and we can't delete the file after we exec :(.
+            File.unlink(config_path) if File.file?(config_path)
+          end
+        end
+
+        protected
+
+        # Generates an RDP connection file and returns the resulting path.
+        # @return [String]
+        def self.generate_config_file(rdp_info)
+          opts   = {
+            "drivestoredirect:s"       => "*",
+            "full address:s"           => "#{rdp_info[:host]}:#{rdp_info[:port]}",
+            "prompt for credentials:i" => "1",
+            "username:s"               => rdp_info[:username],
+          }
+
+          # Create the ".rdp" file
+          t = ::Tempfile.new(["vagrant-rdp", ".rdp"]).tap do |f|
+            f.binmode
+
+            opts.each do |k, v|
+              f.puts("#{k}:#{v}")
+            end
+
+            if rdp_info[:extra_args]
+              rdp_info[:extra_args].each do |arg|
+                f.puts("#{arg}")
+              end
+            end
+
+            f.fsync
+            f.close
+          end
+
+          return t.path
+        end
+      end
+    end
+  end
+end