vagrant-unbundled 2.2.9.0 → 2.2.10.0

data/lib/vagrant/ui.rb

@@ -227,7 +227,7 @@ module Vagrant
 
       # This method handles actually outputting a message of a given type
       # to the console.
-      def say(type, message, **opts)
+      def say(type, message, opts={})
         defaults = { new_line: true, prefix: true }
         opts     = defaults.merge(@opts).merge(opts)
 

data/lib/vagrant/util/ansi_escape_code_remover.rb

@@ -19,7 +19,7 @@ module Vagrant
                     /\e\[\?[1-9][hl]/,     # Matches \e[?2h
                     /\e\[20[hl]/,          # Matches \e[20l]
                     /\e[DME78H]/,          # Matches \eD, \eH, etc.
-                    /\e\[[0-2]?[JK]/,      # Matches \e[0J, \e[K, etc.
+                    /\e\[[0-3]?[JK]/,      # Matches \e[0J, \e[K, etc.
                     ]
 
         # Take each matcher and replace it with emptiness.

data/lib/vagrant/util/caps.rb

@@ -0,0 +1,48 @@
+require "tempfile"
+require "fileutils"
+require "pathname"
+require "vagrant/util/directory"
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    module Caps
+      module BuildISO
+
+        # Builds an iso given a compatible iso_command
+        #
+        # @param [List<String>] command to build iso
+        # @param [Pathname] input directory for iso build
+        # @param [Pathname] output file for iso build
+        def build_iso(iso_command, source_directory, file_destination)
+          FileUtils.mkdir_p(file_destination.dirname)
+          if !file_destination.exist? || Vagrant::Util::Directory.directory_changed?(source_directory, file_destination.mtime)
+            result = Vagrant::Util::Subprocess.execute(*iso_command)
+            if result.exit_code != 0
+              raise Vagrant::Errors::ISOBuildFailed, cmd: iso_command.join(" "), stdout: result.stdout, stderr: result.stderr
+            end
+          end
+        end
+
+        protected
+
+        def ensure_output_iso(file_destination)
+          if file_destination.nil?
+            tmpfile = Tempfile.new(["vagrant", ".iso"])
+            file_destination = Pathname.new(tmpfile.path)
+            tmpfile.close
+            tmpfile.unlink
+          else
+            file_destination = Pathname.new(file_destination.to_s)
+            # If the file destination path is a folder, target the output to a randomly named
+            # file in that dir
+            if file_destination.extname != ".iso"
+              file_destination = file_destination.join("#{SecureRandom.hex(3)}_vagrant.iso")
+            end
+          end
+          file_destination
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/credential_scrubber.rb

@@ -32,7 +32,7 @@ module Vagrant
       def self.desensitize(string)
         string = string.to_s.dup
         sensitive_strings.each do |remove|
-          string.gsub!(remove, REPLACEMENT_TEXT)
+          string.gsub!(/(\W|^)#{Regexp.escape(remove)}(\W|$)/, "\\1#{REPLACEMENT_TEXT}\\2")
         end
         string
       end

data/lib/vagrant/util/directory.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+
+module Vagrant
+  module Util
+    class Directory
+      # Check if directory has any new updates
+      #
+      # @param [Pathname, String] Path to directory
+      # @param [Time] time to compare to eg. has any file in dir_path
+      #               changed since this time
+      # @return [Boolean]
+      def self.directory_changed?(dir_path, threshold_time)
+        Dir.glob(Pathname.new(dir_path).join("**", "*")).any? do |path|
+          Pathname.new(path).mtime > threshold_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/downloader.rb

@@ -1,3 +1,4 @@
+require "cgi"
 require "uri"
 
 require "log4r"
@@ -9,7 +10,6 @@ require "vagrant/util/platform"
 require "vagrant/util/subprocess"
 require "vagrant/util/curl_helper"
 require "vagrant/util/file_checksum"
-require "vagrant/util/map_command_options"
 
 module Vagrant
   module Util
@@ -42,8 +42,8 @@ module Vagrant
         begin
           url = URI.parse(@source)
           if url.scheme && url.scheme.start_with?("http") && url.user
-            auth = "#{URI.unescape(url.user)}"
-            auth += ":#{URI.unescape(url.password)}" if url.password
+            auth = "#{CGI.unescape(url.user)}"
+            auth += ":#{CGI.unescape(url.password)}" if url.password
             url.user = nil
             url.password = nil
             options[:auth] ||= auth

data/lib/vagrant/util/guest_hosts.rb

@@ -0,0 +1,68 @@
+module Vagrant
+  module Util
+    # Helper methods for modfiying guests /etc/hosts file
+    module GuestHosts
+
+      module Unix
+        DEAFAULT_LOOPBACK_CHECK_LIMIT = 5.freeze
+
+        # Add hostname to a loopback address on /etc/hosts if not already there
+        # Will insert name at the first free address of the form 127.0.X.1, up to
+        # the loop_bound
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [int] (option) defines the upper bound for searching for an available loopback address
+        def add_hostname_to_loopback_interface(comm, name, loop_bound=DEAFAULT_LOOPBACK_CHECK_LIMIT)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          grep -w '#{name}' /etc/hosts || {
+            for i in {1..#{loop_bound}}; do
+              grep -w "127.0.${i}.1" /etc/hosts || {
+                echo "127.0.${i}.1 #{name} #{basename}" >> /etc/hosts
+                break
+              }
+            done
+          }
+          EOH
+        end
+      end
+
+      # Linux specific inspection helpers
+      module Linux
+        include Unix
+        # Remove any line in /etc/hosts that contains hostname,
+        # then add hostname with associated ip 
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [String] target ip
+        def replace_host(comm, name, ip)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          sed -i '/#{name}/d' /etc/hosts
+          sed -i'' '1i '#{ip}'\\t#{name}\\t#{basename}' /etc/hosts
+          EOH
+        end
+      end
+
+      # BSD specific inspection helpers
+      module BSD
+        include Unix
+        # Remove any line in /etc/hosts that contains hostname,
+        # then add hostname with associated ip 
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [String] target ip
+        def replace_host(comm, name, ip)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          sed -i.bak '/#{name}/d' /etc/hosts
+          sed -i.bak '1i\\\n#{ip}\t#{name}\t#{basename}\n' /etc/hosts
+          EOH
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/install_cli_autocomplete.rb

@@ -0,0 +1,118 @@
+module Vagrant
+  module Util
+    # Generic installation of content to shell config file
+    class InstallShellConfig
+
+      PERPEND_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 = PERPEND_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.exists?(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/ipv4_interfaces.rb

@@ -0,0 +1,15 @@
+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

@@ -1,5 +1,4 @@
 require "socket"
-require "timeout"
 
 module Vagrant
   module Util
@@ -14,26 +13,16 @@ module Vagrant
       # @return [Boolean] `true` if the port is open (listening), `false`
       #   otherwise.
       def is_port_open?(host, port)
-        # We wrap this in a timeout because once in awhile the TCPSocket
-        # _will_ hang, but this signals that the port is closed.
-        Timeout.timeout(1) do
-          # Attempt to make a connection
-          s = TCPSocket.new(host, port)
-
-          # A connection was made! Properly clean up the socket, not caring
-          # at all if any exception is raised, because we already know the
-          # result.
-          s.close rescue nil
-
-          # The port is open if we reached this point, since we were able
-          # to connect.
-          return true
+        begin
+          Socket.tcp(host, port, connect_timeout: 0.1).close
+          true
+        rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
+            Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN
+          false
         end
-      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
-             Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN
-        # Any of the above exceptions signal that the port is closed.
-        return false
       end
+
+      extend IsPortOpen
     end
   end
 end

data/lib/vagrant/util/network_ip.rb

@@ -3,11 +3,21 @@ require "ipaddr"
 module Vagrant
   module Util
     module NetworkIP
+
+      DEFAULT_MASK = "255.255.255.0".freeze
+
+      LOGGER = Log4r::Logger.new("vagrant::util::NetworkIP")
+
       # Returns the network address of the given IP and subnet.
       #
       # @return [String]
       def network_address(ip, subnet)
-        IPAddr.new(ip).mask(subnet).to_s
+        begin
+          IPAddr.new(ip).mask(subnet).to_s
+        rescue IPAddr::InvalidPrefixError
+          LOGGER.warn("Provided mask '#{subnet}' is invalid. Falling back to using mask '#{DEFAULT_MASK}'")
+          IPAddr.new(ip).mask(DEFAULT_MASK).to_s
+        end
       end
     end
   end

data/lib/vagrant/util/powershell.rb

@@ -231,7 +231,7 @@ module Vagrant
             "-PassThru -WindowStyle Hidden -Wait -Verb RunAs; if($p){ exit $p.ExitCode; }else{ exit 1 }"
 
           cmd = [
-            "powershell",
+            executable,
             "-NoLogo",
             "-NoProfile",
             "-NonInteractive",

data/lib/vagrant/util/subprocess.rb

@@ -90,6 +90,8 @@ module Vagrant
         process.io.stdout = stdout_writer
         process.io.stderr = stderr_writer
         process.duplex = true
+        process.leader = true if @options[:detach]
+        process.detach = true if @options[:detach]
 
         # Special installer-related things
         if Vagrant.in_installer?
@@ -158,6 +160,12 @@ module Vagrant
           raise LaunchError.new(ex.message)
         end
 
+        # If running with the detach option, no need to capture IO or
+        # ensure program exists.
+        if @options[:detach]
+          return
+        end
+
         # Make sure the stdin does not buffer
         process.io.stdin.sync = true
 
@@ -261,7 +269,7 @@ module Vagrant
         # Return an exit status container
         return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
       ensure
-        if process && process.alive?
+        if process && process.alive? && !@options[:detach]
           # Make sure no matter what happens, the process exits
           process.stop(2)
         end

data/lib/vagrant/vagrantfile.rb

@@ -197,7 +197,7 @@ module Vagrant
         local_keys = keys.dup
 
         # Load the box Vagrantfile, if there is one
-        if config.vm.box && boxes
+        if !config.vm.box.to_s.empty? && boxes
           box = boxes.find(config.vm.box, box_formats, config.vm.box_version)
           if box
             box_vagrantfile = find_vagrantfile(box.directory)

data/plugins/commands/autocomplete/command/install.rb

@@ -0,0 +1,49 @@
+require 'optparse'
+
+require 'vagrant/util/install_cli_autocomplete'
+
+module VagrantPlugins
+  module CommandAutocomplete
+    module Command
+      class Install < Vagrant.plugin("2", :command)
+        def execute
+          options = {
+            shells: []
+          }
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant autocomplete install [-h] [shell name]"
+            o.separator ""
+            o.separator "Available shells: #{Vagrant::Util::InstallCLIAutocomplete::SUPPORTED_SHELLS.keys.join(' ')}"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-b", "--bash", "Install bash autocomplete") do |c|
+              options[:shells].append("bash")
+            end
+
+            o.on("-z", "--zsh", "Install zsh autocomplete") do |c|
+              options[:shells].append("zsh")
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
+
+          written_paths = Vagrant::Util::InstallCLIAutocomplete.install(options[:shells])
+          if written_paths && written_paths.length > 0
+            @env.ui.info(I18n.t("vagrant.autocomplete.installed", paths: written_paths.join("\n- ")))
+          else
+            @env.ui.info(I18n.t("vagrant.autocomplete.not_installed"))
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end