vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/lib/vagrant/util/io.rb

@@ -29,42 +29,22 @@ module Vagrant
               break if !results || results[0].empty?
 
               # Read!
-              data << io.readpartial(READ_CHUNK_SIZE).encode("UTF-8", Encoding.default_external)
+              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 Exception => e
-            # The catch-all rescue here is to support multiple Ruby versions,
-            # since we use some Ruby 1.9 specific exceptions.
-
-            breakable = false
-            if e.is_a?(EOFError)
-              # An `EOFError` means this IO object is done!
-              breakable = true
-            elsif defined?(::IO::WaitReadable) && e.is_a?(::IO::WaitReadable)
-              # IO::WaitReadable is only available on Ruby 1.9+
-
-              # An IO::WaitReadable means there may be more IO but this
-              # IO object is not ready to be read from yet. No problem,
-              # we read as much as we can, so we break.
-              breakable = true
-            elsif e.is_a?(Errno::EAGAIN)
-              # Otherwise, we just look for the EAGAIN error which should be
-              # all that IO::WaitReadable does in Ruby 1.9.
-              breakable = true
-            end
-
-            # Break out if we're supposed to. Otherwise re-raise the error
-            # because it is a real problem.
-            break if breakable
-            raise
+          rescue EOFError, Errno::EAGAIN, ::IO::WaitReadable
+            break
           end
         end
 
         data
       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, Errno::EALREADY
+          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/map_command_options.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  module Util
+    class MapCommandOptions
+      # Given a hash map of user specified argments, will generate
+      # a list. Set the key to the command flag, and the value to 
+      # it's value. If the value is boolean (true), only the flag is
+      # added. eg.
+      # {a: "opt-a", b: true} -> ["--a", "opt-a", "--b"]
+      #
+      # @param [Hash]   map of commands
+      # @param [String] string prepended to cmd line flags (keys)
+      #
+      # @return[Array<String>] commands in list form
+      def self.map_to_command_options(map, cmd_flag="--")
+        opt_list = []
+        if map == nil
+          return opt_list
+        end
+        map.each do |k, v|
+          # If the value is true (bool) add the key as the cmd flag
+          if v.is_a?(TrueClass)
+            opt_list.push("#{cmd_flag}#{k}")
+          # If the value is a string, add the key as the flag, and value as the flags argument
+          elsif v.is_a?(String)
+            opt_list.push("#{cmd_flag}#{k}")
+            opt_list.push(v)
+          end
+        end
+        return opt_list
+      end
+    end
+  end
+end

data/lib/vagrant/util/mime.rb

@@ -0,0 +1,92 @@
+require 'mime/types'
+require 'securerandom'
+
+module Vagrant
+  module Util
+    module Mime
+      class Multipart
+
+        # @return [Array<String>] collection of content part of the multipart mime
+        attr_accessor :content
+
+        # @return [String] type of the content
+        attr_accessor :content_type
+
+        # @return [Hash] headers for the mime
+        attr_accessor :headers
+
+        # @param [String] (optional) mime content type
+        # @param [String] (optional) mime version
+        def initialize(content_type="multipart/mixed")
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+          @boundary = "Boundary_#{SecureRandom.alphanumeric(24)}"
+          @content_type = MIME::Types[content_type].first
+          @content = []
+          @headers = {
+            "Content-ID"=> "<#{@content_id}>",
+            "Content-Type"=> "#{content_type}; boundary=#{@boundary}",
+          }
+        end
+
+        # Add an entry to the multipart mime
+        #
+        # @param entry to add
+        def add(entry)
+          content << entry
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = ""
+          headers.each do |k, v|
+            output_string += "#{k}: #{v}\n"
+          end
+          output_string += "\n--#{@boundary}\n"
+          @content.each do |entry|
+            output_string += entry.to_s
+            output_string += "\n--#{@boundary}\n"
+          end
+          output_string
+        end
+      end
+
+      class Entity
+
+        # @return [String] entity content 
+        attr_reader :content
+
+        # @return [String] type of the entity content
+        attr_reader :content_type
+
+        # @return [String] content disposition
+        attr_accessor :disposition
+
+        # @param [String] entity content
+        # @param [String] type of the entity content
+        def initialize(content, content_type)
+          if !MIME::Types.include?(content_type)
+            MIME::Types.add(MIME::Type.new(content_type))
+          end
+          @content = content
+          @content_type = MIME::Types[content_type].first
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = "Content-ID: <#{@content_id}>\n"
+          output_string += "Content-Type: #{@content_type}\n"
+          if disposition
+            output_string += "Content-Disposition: #{@disposition}\n"
+          end
+          output_string += "\n#{content}"
+          output_string
+        end
+      end
+    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/numeric.rb

@@ -49,6 +49,34 @@ module Vagrant
           bytes
         end
 
+        # Convert bytes to a user friendly string representation
+        #
+        # @param [Numeric] bytes Number of bytes to represent
+        # @return [String] user friendly output
+        def bytes_to_string(bytes)
+          # We want to locate the size that will return the
+          # smallest whole value number
+          BYTES_CONVERSION_MAP.sort { |a, b|
+            b.last <=> a.last
+          }.each do |suffix, size|
+            val = bytes.to_f / size
+            next if val < 1
+            val = sprintf("%.2f", val)
+            val.slice!(-1, 1) while val.end_with?("0")
+            val.slice!(-1, 1) if val.end_with?(".")
+            return "#{val}#{suffix}"
+          end
+          "#{bytes} byte#{"s" if bytes > 1}"
+        end
+
+        # Rounds actual value to two decimal places
+        #
+        # @param [Integer] bytes
+        # @return [Integer] megabytes - bytes representation in megabytes
+        def bytes_to_megabytes(bytes)
+          (bytes / MEGABYTE.to_f).round(2)
+        end
+
         # @private
         # Reset the cached values for platform. This is not considered a public
         # API and should only be used for testing.

data/lib/vagrant/util/platform.rb

@@ -213,13 +213,20 @@ module Vagrant
           return path if !cygwin?
 
           # Replace all "\" with "/", otherwise cygpath doesn't work.
-          path = path.gsub("\\", "/")
+          path = unix_windows_path(path)
 
           # Call out to cygpath and gather the result
           process = Subprocess.execute("cygpath", "-w", "-l", "-a", path.to_s)
           return process.stdout.chomp
         end
 
+        # This takes any path and converts Windows-style path separators
+        # to Unix-like path separators.
+        # @return [String]
+        def unix_windows_path(path)
+          path.gsub("\\", "/")
+        end
+
         # This checks if the filesystem is case sensitive. This is not a
         # 100% correct check, since it is possible that the temporary
         # directory runs a different filesystem than the root directory.
@@ -547,6 +554,7 @@ module Vagrant
         # Get list of local mount paths that are DrvFs file systems
         #
         # @return [Array<String>]
+        # @todo(chrisroberts): Constantize types for check
         def wsl_drvfs_mounts
           if !defined?(@_wsl_drvfs_mounts)
             @_wsl_drvfs_mounts = []
@@ -554,7 +562,7 @@ module Vagrant
               result = Util::Subprocess.execute("mount")
               result.stdout.each_line do |line|
                 info = line.match(MOUNT_PATTERN)
-                if info && info[:type] == "drvfs"
+                if info && (info[:type] == "drvfs" || info[:type] == "9p")
                   @_wsl_drvfs_mounts << info[:mount]
                 end
               end

data/lib/vagrant/util/powershell.rb

@@ -14,28 +14,44 @@ module Vagrant
       MINIMUM_REQUIRED_VERSION = 3
       # Number of seconds to wait while attempting to get powershell version
       DEFAULT_VERSION_DETECTION_TIMEOUT = 30
+      # Names of the powershell executable
+      POWERSHELL_NAMES = ["powershell", "pwsh"].map(&:freeze).freeze
+      # Paths to powershell executable
+      POWERSHELL_PATHS = [
+        "%WINDIR%/WindowsPowerShell/v1.0",
+        "%PROGRAMFILES%/PowerShell/7",
+        "%PROGRAMFILES%/PowerShell/6"
+      ].map(&:freeze).freeze
+
       LOGGER = Log4r::Logger.new("vagrant::util::powershell")
 
       # @return [String|nil] a powershell executable, depending on environment
       def self.executable
         if !defined?(@_powershell_executable)
-          @_powershell_executable = "powershell"
+          # First start with detecting executable on configured path
+          POWERSHELL_NAMES.detect do |psh|
+            return @_powershell_executable = psh if Which.which(psh)
+            psh += ".exe"
+            return @_powershell_executable = psh if Which.which(psh)
+          end
 
-          if Which.which(@_powershell_executable).nil?
-            # Try to use WSL interoperability if PowerShell is not symlinked to
-            # the container.
-            if Platform.wsl?
-              @_powershell_executable += ".exe"
+          # Now attempt with paths
+          paths = POWERSHELL_PATHS.map do |ppath|
+            result = Util::Subprocess.execute("cmd.exe", "/c", "echo #{ppath}")
+            result.stdout.gsub("\"", "").strip if result.exit_code == 0
+          end.compact
 
-              if Which.which(@_powershell_executable).nil?
-                @_powershell_executable = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe"
+          paths.each do |psh_path|
+            POWERSHELL_NAMES.each do |psh|
+              path = File.join(psh_path, psh)
+              return @_powershell_executable = path if Which.which(path)
 
-                if Which.which(@_powershell_executable).nil?
-                  @_powershell_executable = nil
-                end
-              end
-            else
-              @_powershell_executable = nil
+              path += ".exe"
+              return @_powershell_executable = path if Which.which(path)
+
+              # Finally test the msys2 style path
+              path = path.sub(/^([A-Za-z]):/, "/mnt/\\1")
+              return @_powershell_executable = path if Which.which(path)
             end
           end
         end
@@ -231,7 +247,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/util/template_renderer.rb

@@ -1,7 +1,7 @@
 require 'ostruct'
 require "pathname"
 
-require 'erubis'
+require 'erubi'
 
 module Vagrant
   module Util
@@ -73,7 +73,7 @@ module Vagrant
       #
       # @return [String]
       def render_string
-        Erubis::Eruby.new(template, trim: true).result(binding)
+        binding.eval(Erubi::Engine.new(template, trim: true).src)
       end
 
       # Returns the full path to the template, taking into account the gem directory