vagrant 1.5.0 → 2.4.4

data/lib/vagrant/util/guest_inspection.rb

@@ -0,0 +1,118 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Helper methods for inspecting guests to determine if specific services
+    # or applications are installed and in use
+    module GuestInspection
+      # Linux specific inspection helpers
+      module Linux
+
+        ## systemd helpers
+
+        # systemd is in use
+        #
+        # @return [Boolean]
+        def systemd?(comm)
+          comm.test("ps -o comm= 1 | grep systemd", sudo: true)
+        end
+
+        # systemd-networkd.service is in use
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        def systemd_networkd?(comm)
+          comm.test("systemctl -q is-active systemd-networkd.service", sudo: true)
+        end
+
+        # NetworkManager.service is in use
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        def systemd_network_manager?(comm)
+          comm.test("systemctl -q is-active NetworkManager.service", sudo: true)
+        end
+
+        # Check if a unit file with the given name is defined. Name can
+        # be a pattern or explicit name.
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @param [String] name Name or pattern to search
+        # @return [Boolean]
+        def systemd_unit_file?(comm, name)
+          comm.test("systemctl -q list-unit-files | grep \"#{name}\"")
+        end
+
+        # Check if a unit is currently active within systemd
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @param [String] name Name or pattern to search
+        # @return [Boolean]
+        def systemd_unit?(comm, name)
+          comm.test("systemctl -q list-units | grep \"#{name}\"")
+        end
+
+        # Check if given service is controlled by systemd
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @param [String] service_name Name of the service to check
+        # @return [Boolean]
+        def systemd_controlled?(comm, service_name)
+          comm.test("systemctl -q is-active #{service_name}", sudo: true)
+        end
+
+        # systemd hostname set is via hostnamectl
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        # NOTE: This test includes actually calling `hostnamectl` to verify
+        # that it is in working order. This prevents attempts to use the
+        # hostnamectl command when it is available, but dbus is not which
+        # renders the command useless
+        def hostnamectl?(comm)
+          comm.test("command -v hostnamectl && hostnamectl")
+        end
+
+        ## netplan helpers
+
+        # netplan is installed
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        def netplan?(comm)
+          comm.test("command -v netplan")
+        end
+
+        # is networkd isntalled
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        def networkd?(comm)
+          comm.test("command -v networkd")
+        end
+
+        ## nmcli helpers
+
+        # nmcli is installed
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @return [Boolean]
+        def nmcli?(comm)
+          comm.test("command -v nmcli")
+        end
+
+        # NetworkManager currently controls device
+        #
+        # @param [Vagrant::Plugin::V2::Communicator] comm Guest communicator
+        # @param device_name [String]
+        # @return [Boolean]
+        def nm_controlled?(comm, device_name)
+          comm.test("nmcli -t d show #{device_name}") &&
+            !comm.test("nmcli -t d show #{device_name} | grep unmanaged")
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant/util/guest_networks.rb

@@ -0,0 +1,107 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Helper methods for configuring guest networks
+    module GuestNetworks
+      module Linux
+        NETWORK_MANAGER_DEVICE_DIRECTORY = "/etc/NetworkManager/system-connections".freeze
+
+        def configure_network_manager(machine, networks, **opts)
+          comm = machine.communicate
+          nm_directory = opts.fetch(:nm_directory, NETWORK_MANAGER_DEVICE_DIRECTORY)
+
+          interfaces = machine.guest.capability(:network_interfaces)
+          net_configs = machine.config.vm.networks.find_all { |type, _| type.to_s.end_with?("_network") }.map(&:last)
+
+          # Get IDs of currently configured devices
+          current_devs = Hash.new.tap do |cd|
+            comm.execute("nmcli -t c show") do |type, data|
+              if type == :stdout
+                _, id, _, dev = data.strip.split(":")
+                cd[dev] = id
+              end
+            end
+          end
+
+          networks.each.with_index do |network, i|
+            net_opts = (net_configs[i] || {}).merge(network)
+            net_opts[:type] = net_opts[:type].to_s
+            net_opts[:device] = interfaces[network[:interface]]
+
+            if !net_opts[:mac_address]
+              comm.execute("cat /sys/class/net/#{net_opts[:device]}/address") do |type, data|
+                net_opts[:mac_address] = data if type == :stdout
+              end
+            end
+
+            tmpl_opts = {
+              interface_name: net_opts[:device],
+              type: net_opts[:type],
+              mac_address: net_opts[:mac_address],
+              uuid: SecureRandom.uuid
+            }
+
+            if net_opts[:type] != "dhcp"
+              begin
+                addr = IPAddr.new("#{net_opts[:ip]}")
+                if addr.ipv4?
+                  tmpl_opts[:ipv4] = addr.to_string
+                  masked = addr.mask(net_opts[:netmask])
+
+                  tmpl_opts[:ipv4_mask] = masked.prefix
+                  tmpl_opts[:ipv4_gateway] = masked.succ.to_string
+                else
+                  tmpl_opts[:ipv6] = addr.to_string
+                  masked = addr.mask(net_opts[:netmask])
+
+                  tmpl_opts[:ipv6_mask] = masked.prefix
+                  tmpl_opts[:ipv6_gateway] = masked.succ.to_string
+                end
+              rescue IPAddr::Error => err
+                raise NetworkAddressInvalid,
+                      address: net_opts[:ip],
+                      mask: net_opts[:netmask],
+                      error: err.to_s
+              end
+            end
+
+            entry = TemplateRenderer.render("networking/network_manager/network_manager_device", options: tmpl_opts)
+            remote_path = "/tmp/vagrant-network-entry-#{net_opts[:device]}-#{Time.now.to_i}-#{i}"
+            final_path = "#{nm_directory}/#{net_opts[:device]}.nmconnection"
+
+            Tempfile.open("vagrant-nm-configure-networks") do |f|
+              f.binmode
+              f.write(entry)
+              f.fsync
+              f.close
+              comm.upload(f.path, remote_path)
+            end
+
+            # Remove the device if it already exists
+            if device_id = current_devs[net_opts[:device]]
+              [
+                "nmcli d disconnect '#{net_opts[:device]}'",
+                "nmcli c delete '#{device_id}'",
+              ].each do |cmd|
+                comm.sudo(cmd, error_check: false)
+              end
+            end
+
+            # Apply the config
+            [
+              "chown root:root '#{remote_path}'",
+              "chmod 0600 '#{remote_path}'",
+              "mv '#{remote_path}' '#{final_path}'",
+              "nmcli c load '#{final_path}'",
+              "nmcli d connect '#{net_opts[:device]}'"
+            ].each do |cmd|
+              comm.sudo(cmd)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/hash_with_indifferent_access.rb

@@ -0,0 +1,66 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # A hash with indifferent access. Mostly taken from Thor/Rails (thanks).
+    # Normally I'm not a fan of using an indifferent access hash since Symbols
+    # are basically memory leaks in Ruby, but since Vagrant is typically a quick
+    # one-off binary run and it doesn't use too many hash keys where this is
+    # used, the effect should be minimal.
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #
+    class HashWithIndifferentAccess < ::Hash
+      def initialize(hash={}, &block)
+        super(&block)
+
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+    end
+  end
+end

data/lib/vagrant/util/install_cli_autocomplete.rb

@@ -0,0 +1,121 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Generic installation of content to shell config file
+    class InstallShellConfig
+
+      PREPEND_STRING = "# >>>> Vagrant command completion (start)".freeze
+      APPEND_STRING = "# <<<<  Vagrant command completion (end)".freeze
+
+      attr_accessor :prepend_string
+      attr_accessor :string_insert
+      attr_accessor :append_string
+      attr_accessor :config_paths
+
+      def initialize(string_insert, config_paths)
+        @prepend_string = PREPEND_STRING
+        @string_insert = string_insert
+        @append_string = APPEND_STRING
+        @config_paths = config_paths
+        @logger = Log4r::Logger.new("vagrant::util::install_shell_config")
+      end
+
+      # Searches a users home dir for a shell config file based on a
+      # given home dir and a configured set of config paths. If there
+      # are multiple config paths, it will return the first match.
+      #
+      # @param [string] path to users home dir
+      # @return [string] path to shell config file if exists
+      def shell_installed(home)
+        @logger.info("Searching for config in home #{home}")
+        @config_paths.each do |path|
+          config_file = File.join(home, path)
+          if File.exist?(config_file)
+            @logger.info("Found config file #{config_file}")
+            return config_file
+          end
+        end
+        return nil
+      end
+
+      # Searches a given file for the existence of a set prepend string.
+      # This can be used to find if vagrant has inserted some strings to a file
+      #
+      # @param [string] path to a file (config file)
+      # @return [boolean] true if the prepend string is found in the file
+      def is_installed(path)
+        File.foreach(path) do |line|
+          if line.include?(@prepend_string)
+            @logger.info("Found completion already installed in #{path}")
+            return true
+          end
+        end
+        return false
+      end
+
+      # Given a path to the users home dir, will install some given strings
+      # marked by a prepend and append string
+      #
+      # @param [string] path to users home dir
+      # @return [string] path to shell config file that was modified if exists
+      def install(home)
+        path = shell_installed(home)
+        if path && !is_installed(path)
+          File.open(path, "a") do |f|
+            f.write("\n")
+            f.write(@prepend_string)
+            f.write("\n")
+            f.write(@string_insert)
+            f.write("\n")
+            f.write(@append_string)
+            f.write("\n")
+          end
+        end
+        return path
+      end
+    end
+
+    # Install autocomplete script to zsh config located as .zshrc
+    class InstallZSHShellConfig < InstallShellConfig
+      def initialize
+        string_insert = """fpath=(#{File.join(Vagrant.source_root, "contrib", "zsh")} $fpath)\ncompinit""".freeze
+        config_paths = [".zshrc".freeze].freeze
+        super(string_insert, config_paths)
+      end
+    end
+
+    # Install autocomplete script to bash config located as .bashrc or .bash_profile
+    class InstallBashShellConfig < InstallShellConfig
+      def initialize
+        string_insert = ". #{File.join(Vagrant.source_root, 'contrib', 'bash', 'completion.sh')}".freeze
+        config_paths = [".bashrc".freeze, ".bash_profile".freeze].freeze
+        super(string_insert, config_paths)
+      end
+    end
+
+    # Install autocomplete script for supported shells
+    class InstallCLIAutocomplete
+      SUPPORTED_SHELLS = {
+        "zsh" => Vagrant::Util::InstallZSHShellConfig.new(),
+        "bash" => Vagrant::Util::InstallBashShellConfig.new()
+      }
+
+      def self.install(shells=[])
+        shells = SUPPORTED_SHELLS.keys() if shells.empty?
+        home = Dir.home
+        written_paths = []
+        
+        shells.map do |shell|
+          if SUPPORTED_SHELLS[shell]
+            written_paths.push(SUPPORTED_SHELLS[shell].install(home))
+          else
+            raise ArgumentError, "shell must be in #{SUPPORTED_SHELLS.keys()}"
+          end
+        end.compact
+        return written_paths
+      end
+    end
+  end
+end

data/lib/vagrant/util/io.rb

@@ -0,0 +1,53 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/platform"
+
+module Vagrant
+  module Util
+    class IO
+      # The chunk size for reading from subprocess IO.
+      READ_CHUNK_SIZE = 4096
+
+      # Reads data from an IO object while it can, returning the data it reads.
+      # When it encounters a case when it can't read anymore, it returns the
+      # data.
+      #
+      # @return [String]
+      def self.read_until_block(io)
+        data = ""
+
+        while true
+          begin
+            if Platform.windows?
+              # Windows doesn't support non-blocking reads on
+              # file descriptors or pipes so we have to get
+              # a bit more creative.
+
+              # Check if data is actually ready on this IO device.
+              # We have to do this since `readpartial` will actually block
+              # until data is available, which can cause blocking forever
+              # in some cases.
+              results = ::IO.select([io], nil, nil, 1.0)
+              break if !results || results[0].empty?
+
+              # Read!
+              data << io.readpartial(READ_CHUNK_SIZE).encode(
+                "UTF-8", Encoding.default_external,
+                invalid: :replace,
+                undef: :replace
+              )
+            else
+              # Do a simple non-blocking read on the IO object
+              data << io.read_nonblock(READ_CHUNK_SIZE)
+            end
+          rescue EOFError, Errno::EAGAIN, ::IO::WaitReadable
+            break
+          end
+        end
+
+        data
+      end
+    end
+  end
+end

data/lib/vagrant/util/ipv4_interfaces.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module IPv4Interfaces
+      def ipv4_interfaces
+        Socket.getifaddrs.select do |ifaddr|
+          ifaddr.addr && ifaddr.addr.ipv4?
+        end.map do |ifaddr|
+          [ifaddr.name, ifaddr.addr.ip_address]
+        end
+      end
+
+      extend IPv4Interfaces
+    end
+  end
+end

data/lib/vagrant/util/is_port_open.rb

@@ -0,0 +1,31 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "socket"
+
+module Vagrant
+  module Util
+    # Contains the method {#is_port_open?} to check if a port is open
+    # (listening) or closed (not in use). This method isn't completely
+    # fool-proof, but it works enough of the time to be useful.
+    module IsPortOpen
+      # Checks if a port is open (listening) on a given host and port.
+      #
+      # @param [String] host Hostname or IP address.
+      # @param [Integer] port Port to check.
+      # @return [Boolean] `true` if the port is open (listening), `false`
+      #   otherwise.
+      def is_port_open?(host, port)
+        begin
+          Socket.tcp(host, port, connect_timeout: 0.1).close
+          true
+        rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
+            Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN, Errno::EALREADY
+          false
+        end
+      end
+
+      extend IsPortOpen
+    end
+  end
+end