vagrant-unbundled 1.9.1.1 → 1.9.5.1

data/lib/vagrant/shared_helpers.rb

@@ -12,6 +12,12 @@ module Vagrant
   # @return [String]
   DEFAULT_SERVER_URL = "https://atlas.hashicorp.com"
 
+  # Max number of seconds to wait for joining an active thread.
+  #
+  # @return [Integer]
+  # @note This is not the maxium time for a thread to complete.
+  THREAD_MAX_JOIN_TIMEOUT = 60
+
   # This holds a global lock for the duration of the block. This should
   # be invoked around anything that is modifying process state (such as
   # environmental variables).
@@ -102,4 +108,12 @@ module Vagrant
 
     Pathname.new(path).expand_path
   end
+
+  # This returns true/false if the running version of Vagrant is
+  # a pre-release version (development)
+  #
+  # @return [Boolean]
+  def self.prerelease?
+    Gem::Version.new(Vagrant::VERSION).prerelease?
+  end
 end

data/lib/vagrant/ui.rb

@@ -53,7 +53,7 @@ module Vagrant
             # We're being called in a trap-context. Wrap in a thread.
             Thread.new do
               @logger.info { "#{method}: #{message}" }
-            end.join
+            end.join(THREAD_MAX_JOIN_TIMEOUT)
           end
         end
       end
@@ -128,7 +128,7 @@ module Vagrant
           @lock.synchronize do
             safe_puts("#{Time.now.utc.to_i},#{target},#{type},#{data.join(",")}")
           end
-        end.join
+        end.join(THREAD_MAX_JOIN_TIMEOUT)
       end
     end
 
@@ -244,7 +244,7 @@ module Vagrant
             safe_puts(format_message(type, message, **opts),
                       io: channel, printer: printer)
           end
-        end.join
+        end.join(THREAD_MAX_JOIN_TIMEOUT)
       end
 
       def format_message(type, message, **opts)

data/lib/vagrant/util.rb

@@ -1,15 +1,21 @@
 module Vagrant
   module Util
     autoload :Busy,                      'vagrant/util/busy'
+    autoload :CommandDeprecation,        'vagrant/util/command_deprecation'
     autoload :Counter,                   'vagrant/util/counter'
+    autoload :CredentialScrubber,        'vagrant/util/credential_scrubber'
+    autoload :DeepMerge,                 'vagrant/util/deep_merge'
     autoload :Env,                       'vagrant/util/env'
     autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :GuestInspection,           'vagrant/util/guest_inspection'
     autoload :Platform,                  'vagrant/util/platform'
     autoload :Retryable,                 'vagrant/util/retryable'
     autoload :SafeExec,                  'vagrant/util/safe_exec'
+    autoload :SilenceWarnings,           'vagrant/util/silence_warnings'
     autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
-    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
     autoload :StringBlockEditor,         'vagrant/util/string_block_editor'
     autoload :Subprocess,                'vagrant/util/subprocess'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
+    autoload :Which,                     'vagrant/util/which'
   end
 end

data/lib/vagrant/util/command_deprecation.rb

@@ -0,0 +1,56 @@
+module Vagrant
+  module Util
+    # Automatically add deprecation notices to commands
+    module CommandDeprecation
+
+      # @return [String] generated name of command
+      def deprecation_command_name
+        name_parts = self.class.name.split("::")
+        [
+          name_parts[1].sub('Command', ''),
+          name_parts[3]
+        ].compact.map(&:downcase).join(" ")
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          class << self
+            if method_defined?(:synopsis)
+              alias_method :non_deprecated_synopsis, :synopsis
+
+              def synopsis
+                if !non_deprecated_synopsis.to_s.empty?
+                  "#{non_deprecated_synopsis} [DEPRECATED]"
+                else
+                  non_deprecated_synopsis
+                end
+              end
+            end
+          end
+          alias_method :non_deprecated_execute, :execute
+
+          def execute(*args, &block)
+            @env[:ui].warn(I18n.t("vagrant.commands.deprecated",
+              name: deprecation_command_name
+            ) + "\n")
+            non_deprecated_execute(*args, &block)
+          end
+        end
+      end
+
+      # Mark command deprecation complete and fully disable
+      # the command's functionality
+      module Complete
+        def self.included(klass)
+          klass.include(CommandDeprecation)
+          klass.class_eval do
+            def execute(*_)
+              raise Vagrant::Errors::CommandDeprecated,
+                name: deprecation_command_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/credential_scrubber.rb

@@ -0,0 +1,29 @@
+module Vagrant
+  module Util
+    # Utility class to remove credential information from strings
+    class CredentialScrubber
+      # String used to replace credential information
+      REPLACEMENT_TEXT = "*****".freeze
+
+      # Attempt to remove detected credentials from string
+      #
+      # @param [String] string
+      # @return [String]
+      def self.scrub(string)
+        string = url_scrubber(string)
+      end
+
+      # Detect URLs and remove any embedded credentials
+      #
+      # @param [String] string
+      # @return [String]
+      def self.url_scrubber(string)
+        string.gsub(%r{(ftp|https?)://[^\s]+@[^\s]+}) do |address|
+          uri = URI.parse(address)
+          uri.user = uri.password = REPLACEMENT_TEXT
+          uri.to_s
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/guest_inspection.rb

@@ -0,0 +1,47 @@
+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 used
+        #
+        # @return [Boolean]
+        def systemd?(comm)
+          comm.test("systemctl | grep '^-\.mount'")
+        end
+
+        # systemd hostname set is via hostnamectl
+        #
+        # @return [Boolean]
+        def hostnamectl?(comm)
+          comm.test("hostnamectl")
+        end
+
+        ## nmcli helpers
+
+        # nmcli is installed
+        #
+        # @return [Boolean]
+        def nmcli?(comm)
+          comm.test("nmcli")
+        end
+
+        # NetworkManager currently controls device
+        #
+        # @param comm [Communicator]
+        # @param device_name [String]
+        # @return [Boolean]
+        def nm_controlled?(comm, device_name)
+          comm.test("nmcli d show #{device_name}") &&
+            !comm.test("nmcli d show #{device_name} | grep unmanaged")
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -3,6 +3,7 @@ require "shellwords"
 require "tmpdir"
 
 require "vagrant/util/subprocess"
+require "vagrant/util/powershell"
 
 module Vagrant
   module Util
@@ -27,6 +28,23 @@ module Vagrant
           return @_cygwin
         end
 
+        def wsl?
+          if !defined?(@_wsl)
+            @_wsl = false
+            SilenceWarnings.silence! do
+              # Use PATH values to check for `/mnt/c` path indicative of WSL
+              if ENV.fetch("PATH", "").downcase.include?("/mnt/c")
+                # Validate WSL via uname output
+                uname = Subprocess.execute("uname", "-r")
+                if uname.exit_code == 0 && uname.stdout.downcase.include?("microsoft")
+                  @_wsl = true
+                end
+              end
+            end
+          end
+          @_wsl
+        end
+
         [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
           define_method("#{type}?") do
             platform.include?(type.to_s)
@@ -42,27 +60,17 @@ module Vagrant
         # Checks if the user running Vagrant on Windows has administrative
         # privileges.
         #
+        # From: https://support.microsoft.com/en-us/kb/243330
+        # SID: S-1-5-19
+        #
         # @return [Boolean]
         def windows_admin?
           return @_windows_admin if defined?(@_windows_admin)
 
-          # We lazily-load this because it is only available on Windows
-          require "win32/registry"
-
-          # Verify that we have administrative privileges. The odd method of
-          # detecting this is based on this StackOverflow question:
-          #
-          # https://stackoverflow.com/questions/560366/
-          #   detect-if-running-with-administrator-privileges-under-windows-xp
           @_windows_admin = -> {
-            begin
-              Win32::Registry::HKEY_USERS.open("S-1-5-19") {}
-
-              # The above doesn't seem to be 100% bullet proof. See GH-5616.
-              return (`reg query HKU\\S-1-5-19 2>&1` =~ /ERROR/).nil?
-            rescue Win32::Registry::Error
-              return false
-            end
+            ps_cmd = '(new-object System.Security.Principal.WindowsPrincipal([System.Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)'
+            output = Vagrant::Util::PowerShell.execute_cmd(ps_cmd)
+            return output == 'True'
           }.call
 
           return @_windows_admin
@@ -78,15 +86,13 @@ module Vagrant
         # @return [Boolean]
         def windows_hyperv_admin?
           return @_windows_hyperv_admin if defined?(@_windows_hyperv_admin)
+
           @_windows_hyperv_admin = -> {
-            begin
-              username = ENV["USERNAME"]
-              process = Subprocess.execute("net", "localgroup", "Hyper-V Administrators")
-              return process.stdout.include?(username)
-            rescue Errors::CommandUnavailableWindows
-              return false
-            end
+            ps_cmd = "[System.Security.Principal.WindowsIdentity]::GetCurrent().Groups | ForEach-Object { if ($_.Value -eq 'S-1-5-32-578'){ Write-Host 'true'; break }}"
+            output = Vagrant::Util::PowerShell.execute_cmd(ps_cmd)
+            return output == 'true'
           }.call
+
           return @_windows_hyperv_admin
         end
 
@@ -199,11 +205,16 @@ module Vagrant
         def windows_unc_path(path)
           path = path.gsub("/", "\\")
 
-          # If the path is just a drive letter, then return that as-is
-          return path + "\\" if path =~ /^[a-zA-Z]:\\?$/
-
           # Convert to UNC path
-          "\\\\?\\" + path.gsub("/", "\\")
+          if path =~ /^[a-zA-Z]:\\?$/
+            # If the path is just a drive letter, then return that as-is
+            path + "\\"
+          elsif path.start_with?("\\\\")
+            # If the path already starts with `\\` assume UNC and return as-is
+            path
+          else
+            "\\\\?\\" + path.gsub("/", "\\")
+          end
         end
 
         # Returns a boolean noting whether the terminal supports color.
@@ -229,6 +240,185 @@ module Vagrant
           return @_platform
         end
 
+        # Determine if given path is within the WSL rootfs. Returns
+        # true if within the subsystem, or false if outside the subsystem.
+        #
+        # @param [String] path Path to check
+        # @return [Boolean] path is within subsystem
+        def wsl_path?(path)
+          wsl? && !path.to_s.downcase.start_with?("/mnt/")
+        end
+
+        # Convert a WSL path to the local Windows path. This is useful
+        # for conversion when calling out to Windows executables from
+        # the WSL
+        #
+        # @param [String, Pathname] path Path to convert
+        # @return [String]
+        def wsl_to_windows_path(path)
+          if wsl? && wsl_windows_access?
+            if wsl_path?(path)
+              parts = path.split("/")
+              parts.delete_if(&:empty?)
+              [wsl_windows_appdata_local, "lxss", *parts].join("\\")
+            else
+              path = path.to_s.sub("/mnt/", "")
+              parts = path.split("/")
+              parts.first << ":"
+              path = parts.join("\\")
+              path
+            end
+          else
+            path
+          end
+        end
+
+        # Automatically convert a given path to a Windows path. Will only
+        # be applied if running on a Windows host. If running on Windows
+        # host within the WSL, the actual Windows path will be returned.
+        #
+        # @param [Pathname, String] path Path to convert
+        # @return [String]
+        def windows_path(path)
+          path = cygwin_windows_path(path)
+          path = wsl_to_windows_path(path)
+          if windows? || wsl?
+            path = windows_unc_path(path)
+          end
+          path
+        end
+
+        # Allow Vagrant to access Vagrant managed machines outside the
+        # Windows Subsystem for Linux
+        #
+        # @return [Boolean]
+        def wsl_windows_access?
+          if !defined?(@_wsl_windows_access)
+            @_wsl_windows_access = wsl? && ENV["VAGRANT_WSL_ENABLE_WINDOWS_ACCESS"]
+          end
+          @_wsl_windows_access
+        end
+
+        # The allowed windows system path Vagrant can manage from the Windows
+        # Subsystem for Linux
+        #
+        # @return [Pathname]
+        def wsl_windows_accessible_path
+          if !defined?(@_wsl_windows_accessible_path)
+            access_path = ENV["VAGRANT_WSL_WINDOWS_ACCESS_USER_HOME_PATH"]
+            if access_path.to_s.empty?
+              access_path = wsl_windows_home.gsub("\\", "/").sub(":", "")
+              access_path[0] = access_path[0].downcase
+              access_path = "/mnt/#{access_path}"
+            end
+            @_wsl_windows_accessible_path = Pathname.new(access_path)
+          end
+          @_wsl_windows_accessible_path
+        end
+
+        # Checks given path to determine if Vagrant is allowed to bypass checks
+        #
+        # @param [String] path Path to check
+        # @return [Boolean] Vagrant is allowed to bypass checks
+        def wsl_windows_access_bypass?(path)
+          wsl? && wsl_windows_access? &&
+            path.to_s.start_with?(wsl_windows_accessible_path.to_s)
+        end
+
+        # If running within the Windows Subsystem for Linux, this will provide
+        # simple setup to allow sharing of the user's VAGRANT_HOME directory
+        # within the subsystem
+        #
+        # @param [Environment] env
+        # @param [Logger] logger Optional logger to display information
+        def wsl_init(env, logger=nil)
+          if wsl?
+            if ENV["VAGRANT_WSL_ENABLE_WINDOWS_ACCESS"]
+              wsl_validate_matching_vagrant_versions!
+              shared_user = ENV["VAGRANT_WSL_WINDOWS_ACCESS_USER"]
+              if shared_user.to_s.empty?
+                shared_user = wsl_windows_username
+              end
+              if logger
+                logger.warn("Windows Subsystem for Linux detected. Allowing access to user: #{shared_user}")
+                logger.warn("Vagrant will be allowed to control Vagrant managed machines within the user's home path.")
+              end
+              if ENV["VAGRANT_HOME"] || ENV["VAGRANT_WSL_DISABLE_VAGRANT_HOME"]
+                logger.warn("VAGRANT_HOME environment variable already set. Not overriding!") if logger
+              else
+                home_path = wsl_windows_accessible_path.to_s
+                ENV["VAGRANT_HOME"] = File.join(home_path, ".vagrant.d")
+                if logger
+                  logger.info("Overriding VAGRANT_HOME environment variable to configured windows user. (#{ENV["VAGRANT_HOME"]})")
+                end
+                true
+              end
+            else
+              if env.local_data_path.to_s.start_with?("/mnt/")
+                raise Vagrant::Errors::WSLVagrantAccessError
+              end
+            end
+          end
+        end
+
+        # Fetch the Windows username currently in use
+        #
+        # @return [String, Nil]
+        def wsl_windows_username
+          if !@_wsl_windows_username
+            result = Util::Subprocess.execute("cmd.exe", "/c", "echo %USERNAME%")
+            if result.exit_code == 0
+              @_wsl_windows_username = result.stdout.strip
+            end
+          end
+          @_wsl_windows_username
+        end
+
+        # Fetch the Windows user home directory
+        #
+        # @return [String, Nil]
+        def wsl_windows_home
+          if !@_wsl_windows_home
+            result = Util::Subprocess.execute("cmd.exe", "/c" "echo %USERPROFILE%")
+            if result.exit_code == 0
+              @_wsl_windows_home = result.stdout.gsub("\"", "").strip
+            end
+          end
+          @_wsl_windows_home
+        end
+
+        # Fetch the Windows user local app data directory
+        #
+        # @return [String, Nil]
+        def wsl_windows_appdata_local
+          if !@_wsl_windows_appdata_local
+            result = Util::Subprocess.execute("cmd.exe", "/c", "echo %LOCALAPPDATA%")
+            if result.exit_code == 0
+              @_wsl_windows_appdata_local = result.stdout.gsub("\"", "").strip
+            end
+          end
+          @_wsl_windows_appdata_local
+        end
+
+        # Confirm Vagrant versions installed within the WSL and the Windows system
+        # are the same. Raise error if they do not match.
+        def wsl_validate_matching_vagrant_versions!
+          valid = false
+          result = Util::Subprocess.execute("vagrant.exe", "version")
+          if result.exit_code == 0
+            windows_version = result.stdout.match(/Installed Version: (?<version>.+$)/)
+            if windows_version
+              windows_version = windows_version[:version].strip
+              valid = windows_version == Vagrant::VERSION
+            end
+          end
+          if !valid
+            raise Vagrant::Errors::WSLVagrantVersionMismatch,
+              wsl_version: Vagrant::VERSION,
+              windows_version: windows_version || "unknown"
+          end
+        end
+
         # @private
         # Reset the cached values for platform. This is not considered a public
         # API and should only be used for testing.