vagrant-unbundled 2.2.6.2 → 2.2.14.0

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,27 +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, \
-             Errno::EADDRNOTAVAIL
-        # 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

@@ -0,0 +1,69 @@
+require "log4r"
+
+module Vagrant
+  module Util
+    class Numeric
+
+      # Authors Note: This conversion has been borrowed from the ActiveSupport Numeric class
+      # Conversion helper constants
+      KILOBYTE = 1024
+      MEGABYTE = KILOBYTE * 1024
+      GIGABYTE = MEGABYTE * 1024
+      TERABYTE = GIGABYTE * 1024
+      PETABYTE = TERABYTE * 1024
+      EXABYTE  = PETABYTE * 1024
+
+      BYTES_CONVERSION_MAP = {KB: KILOBYTE, MB: MEGABYTE, GB: GIGABYTE, TB: TERABYTE,
+                              PB: PETABYTE, EB: EXABYTE}
+
+      # Regex borrowed from the vagrant-disksize config class
+      SHORTHAND_MATCH_REGEX = /^(?<number>[0-9]+)\s?(?<unit>KB|MB|GB|TB)?$/
+
+      class << self
+        LOGGER = Log4r::Logger.new("vagrant::util::numeric")
+
+        # A helper that converts a shortcut string to its bytes representation.
+        # The expected format of `str` is essentially: "<Number>XX"
+        # Where `XX` is shorthand for KB, MB, GB, TB, PB, or EB. For example, 50 megabytes:
+        #
+        # str = "50MB"
+        #
+        # @param [String] - str
+        # @return [Integer,nil] - bytes - returns nil if method fails to convert to bytes
+        def string_to_bytes(str)
+          bytes = nil
+
+          str = str.to_s.strip
+          matches = SHORTHAND_MATCH_REGEX.match(str)
+          if matches
+            number = matches[:number].to_i
+            unit = matches[:unit].to_sym
+
+            if BYTES_CONVERSION_MAP.key?(unit)
+              bytes = number * BYTES_CONVERSION_MAP[unit]
+            else
+              LOGGER.error("An invalid unit or format was given, string_to_bytes cannot convert #{str}")
+            end
+          end
+
+          bytes
+        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.
+        def reset!
+          instance_variables.each(&method(:remove_instance_variable))
+        end
+      end
+    end
+  end
+end

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

@@ -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/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

data/lib/vagrant/util/uploader.rb

@@ -13,9 +13,11 @@ module Vagrant
     # a hand-rolled Ruby library, so we defer to its expertise.
     class Uploader
 
-      # @param [String] destination - valid URL to upload file to
-      # @param [String] file - location of file to upload on disk
-      # @param [Hash]   options
+      # @param [String] destination Valid URL to upload file to
+      # @param [String] file Location of file to upload on disk
+      # @param [Hash] options
+      # @option options [Vagrant::UI] :ui UI interface for output
+      # @option options [String, Symbol] :method Request method for upload
       def initialize(destination, file, options=nil)
         options ||= {}
         @logger         = Log4r::Logger.new("vagrant::util::uploader")
@@ -27,6 +29,7 @@ module Vagrant
         if !@request_method
           @request_method = "PUT"
         end
+        @request_method = @request_method.to_s.upcase
       end
 
       def upload!
@@ -51,7 +54,7 @@ module Vagrant
       protected
 
       def build_options
-        options = [@destination, "--request", @request_method, "--upload-file", @file]
+        options = [@destination, "--request", @request_method, "--upload-file", @file, "--fail"]
         return options
       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