vagrant 1.5.0 → 2.4.4

data/lib/vagrant/util/powershell.rb

@@ -0,0 +1,316 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "base64"
+require "tmpdir"
+
+require_relative "subprocess"
+require_relative "which"
+
+module Vagrant
+  module Util
+    # Executes PowerShell scripts.
+    #
+    # This is primarily a convenience wrapper around Subprocess that
+    # properly sets powershell flags for you.
+    class PowerShell
+      # NOTE: Version checks are only on Major
+      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 = ["pwsh", "powershell"].map(&:freeze).freeze
+      # Paths to powershell executable
+      POWERSHELL_PATHS = [
+        "%SYSTEMROOT%/System32/WindowsPowerShell/v1.0",
+        "%WINDIR%/System32/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)
+          prefer_name = ENV["VAGRANT_PREFERRED_POWERSHELL"].to_s.sub(".exe", "")
+          if !POWERSHELL_NAMES.include?(prefer_name)
+            prefer_name = POWERSHELL_NAMES.first
+          end
+
+          LOGGER.debug("preferred powershell executable name: #{prefer_name}")
+
+          # First start with detecting executable on configured path
+          found_shells = Hash.new.tap do |found|
+            POWERSHELL_NAMES.each do |psh|
+              psh_path = Which.which(psh)
+              psh_path = Which.which(psh + ".exe") if !psh_path
+              next if !psh_path
+
+              LOGGER.debug("detected powershell for #{psh.inspect} - #{psh_path}")
+              found[psh] = psh_path
+            end
+          end
+
+          # Done if preferred shell was found
+          if found_shells.key?(prefer_name)
+            LOGGER.debug("using preferred powershell #{prefer_name.inspect} - #{found_shells[prefer_name]}")
+            return @_powershell_executable = found_shells[prefer_name]
+          end
+
+          # 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
+
+          paths.each do |psh_path|
+            POWERSHELL_NAMES.each do |psh|
+              next if found_shells.key?(psh)
+
+              path = File.join(psh_path, psh)
+              [path, "#{path}.exe", path.sub(/^([A-Za-z]):/, "/mnt/\\1")].each do |full_path|
+                if File.executable?(full_path)
+                  found_shells[psh] = full_path
+                  break
+                end
+              end
+            end
+          end
+
+          # Done if preferred shell was found
+          if found_shells.key?(prefer_name)
+            LOGGER.debug("using preferred powershell #{prefer_name.inspect} - #{found_shells[prefer_name]}")
+            return @_powershell_executable = found_shells[prefer_name]
+          end
+
+          # Iterate names and return first found
+          POWERSHELL_NAMES.each do |psh|
+            LOGGER.debug("using powershell #{prefer_name.inspect} - #{found_shells[prefer_name]}")
+            return @_powershell_executable = found_shells[psh] if found_shells.key?(psh)
+          end
+        end
+        @_powershell_executable
+      end
+
+      # @return [Boolean] powershell executable available on PATH
+      def self.available?
+        !executable.nil?
+      end
+
+      # Execute a powershell script.
+      #
+      # @param [String] path Path to the PowerShell script to execute.
+      # @param [Array<String>] args Command arguments
+      # @param [Hash] opts Options passed to execute
+      # @option opts [Hash] :env Custom environment variables
+      # @return [Subprocess::Result]
+      def self.execute(path, *args, **opts, &block)
+        validate_install!
+        if opts.delete(:sudo) || opts.delete(:runas)
+          powerup_command(path, args, opts)
+        else
+          if mpath = opts.delete(:module_path)
+            m_env = opts.fetch(:env, {})
+            m_env["PSModulePath"] = "$env:PSModulePath+';#{mpath}'"
+            opts[:env] = m_env
+          end
+          if env = opts.delete(:env)
+            env = env.map{|k,v| "$env:#{k}=#{v}"}.join(";") + "; "
+          end
+          command = [
+            executable,
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy", "Bypass",
+            "-Command",
+            "#{env}&('#{path}')",
+            args
+          ].flatten
+
+          # Append on the options hash since Subprocess doesn't use
+          # Ruby 2.0 style options yet.
+          command << opts
+
+          Subprocess.execute(*command, &block)
+        end
+      end
+
+      # Execute a powershell command.
+      #
+      # @param [String] command PowerShell command to execute.
+      # @param [Hash] opts Extra options
+      # @option opts [Hash] :env Custom environment variables
+      # @return [nil, String] Returns nil if exit code is non-zero.
+      #   Returns stdout string if exit code is zero.
+      def self.execute_cmd(command, **opts)
+        validate_install!
+        if mpath = opts.delete(:module_path)
+          m_env = opts.fetch(:env, {})
+          m_env["PSModulePath"] = "$env:PSModulePath+';#{mpath}'"
+          opts[:env] = m_env
+        end
+        if env = opts.delete(:env)
+          env = env.map{|k,v| "$env:#{k}=#{v}"}.join(";") + "; "
+        end
+        c = [
+          executable,
+          "-NoLogo",
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy", "Bypass",
+          "-Command",
+          "#{env}#{command}"
+        ].flatten.compact
+
+        r = Subprocess.execute(*c)
+        return nil if r.exit_code != 0
+        return r.stdout.chomp
+      end
+
+      # Execute a powershell command and return a result
+      #
+      # @param [String] command PowerShell command to execute.
+      # @param [Hash] opts A collection of options for subprocess::execute
+      # @option opts [Hash] :env Custom environment variables
+      # @param [Block] block Ruby block
+      def self.execute_inline(*command, **opts, &block)
+        validate_install!
+        if mpath = opts.delete(:module_path)
+          m_env = opts.fetch(:env, {})
+          m_env["PSModulePath"] = "$env:PSModulePath+';#{mpath}'"
+          opts[:env] = m_env
+        end
+        if env = opts.delete(:env)
+          env = env.map{|k,v| "$env:#{k}=#{v}"}.join(";") + "; "
+        end
+
+        command = command.join(' ')
+
+        c = [
+          executable,
+          "-NoLogo",
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy", "Bypass",
+          "-Command",
+          "#{env}#{command}"
+        ].flatten.compact
+        c << opts
+
+        Subprocess.execute(*c, &block)
+      end
+
+      # Returns the version of PowerShell that is installed.
+      #
+      # @return [String]
+      def self.version
+        if !defined?(@_powershell_version)
+          command = [
+            executable,
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy", "Bypass",
+            "-Command",
+            "Write-Output $PSVersionTable.PSVersion.Major"
+          ].flatten
+
+          version = nil
+          timeout = ENV["VAGRANT_POWERSHELL_VERSION_DETECTION_TIMEOUT"].to_i
+          if timeout < 1
+            timeout = DEFAULT_VERSION_DETECTION_TIMEOUT
+          end
+          begin
+            r = Subprocess.execute(*command,
+              notify: [:stdout, :stderr],
+              timeout: timeout,
+            ) {|io_name,data| version = data}
+          rescue Vagrant::Util::Subprocess::TimeoutExceeded
+            LOGGER.debug("Timeout exceeded while attempting to determine version of Powershell.")
+          end
+
+          @_powershell_version = version
+        end
+        @_powershell_version
+      end
+
+      # Validates that powershell is installed, available, and
+      # at or above minimum required version
+      #
+      # @return [Boolean]
+      # @raises []
+      def self.validate_install!
+        if !defined?(@_powershell_validation)
+          raise Errors::PowerShellNotFound if !available?
+          if version.to_i < MINIMUM_REQUIRED_VERSION
+            raise Errors::PowerShellInvalidVersion,
+              minimum_version: MINIMUM_REQUIRED_VERSION,
+              installed_version: version ? version : "N/A"
+          end
+          @_powershell_validation = true
+        end
+        @_powershell_validation
+      end
+
+      # Powerup the given command to perform privileged operations.
+      #
+      # @param [String] path
+      # @param [Array<String>] args
+      # @return [Array<String>]
+      def self.powerup_command(path, args, opts)
+        Dir.mktmpdir("vagrant") do |dpath|
+          all_args = [path] + args.flatten.map{ |a|
+            a.gsub(/^['"](.+)['"]$/, "\\1")
+          }
+          arg_list = "\"" + all_args.join("\" \"") + "\""
+          stdout = File.join(dpath, "stdout.txt")
+          stderr = File.join(dpath, "stderr.txt")
+
+          script = "& #{arg_list} ; exit $LASTEXITCODE;"
+          script_content = Base64.strict_encode64(script.encode("UTF-16LE", "UTF-8"))
+
+          # Wrap so we can redirect output to read later
+          wrapper = "$p = Start-Process -FilePath powershell -ArgumentList @('-NoLogo', '-NoProfile', " \
+            "'-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', '#{script_content}') " \
+            "-PassThru -WindowStyle Hidden -Wait -RedirectStandardOutput '#{stdout}' -RedirectStandardError '#{stderr}'; " \
+            "if($p){ exit $p.ExitCode; }else{ exit 1 }"
+          wrapper_content = Base64.strict_encode64(wrapper.encode("UTF-16LE", "UTF-8"))
+
+          powerup = "$p = Start-Process -FilePath powershell -ArgumentList @('-NoLogo', '-NoProfile', " \
+            "'-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', '#{wrapper_content}') " \
+            "-PassThru -WindowStyle Hidden -Wait -Verb RunAs; if($p){ exit $p.ExitCode; }else{ exit 1 }"
+
+          cmd = [
+            executable,
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy", "Bypass",
+            "-Command", powerup
+          ]
+
+          result = Subprocess.execute(*cmd.push(opts))
+          r_stdout = result.stdout
+          if File.exist?(stdout)
+            r_stdout += File.read(stdout)
+          end
+          r_stderr = result.stderr
+          if File.exist?(stderr)
+            r_stderr += File.read(stderr)
+          end
+
+          Subprocess::Result.new(result.exit_code, r_stdout, r_stderr)
+        end
+      end
+
+      # @private
+      # Reset the cached values for platform. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        instance_variables.each(&method(:remove_instance_variable))
+      end
+    end
+  end
+end

data/lib/vagrant/util/presence.rb

@@ -0,0 +1,48 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module Presence
+      extend self
+
+      # Determines if the given object is "present". A String is considered
+      # present if the stripped contents are not empty. An Array/Hash is
+      # considered present if they have a length of more than 1. "true" is
+      # always present and `false` and `nil` are always not present. Any other
+      # object is considered to be present.
+      #
+      # @return [true, false]
+      def present?(obj)
+        case obj
+        when String
+          !obj.strip.empty?
+        when Symbol
+          !obj.to_s.strip.empty?
+        when Array
+          !obj.compact.empty?
+        when Hash
+          !obj.empty?
+        when TrueClass, FalseClass
+          obj
+        when NilClass
+          false
+        when Object
+          true
+        end
+      end
+
+      # Returns the presence of the object. If the object is {present?}, it is
+      # returned. Otherwise `false` is returned.
+      #
+      # @return [Object, false]
+      def presence(obj)
+        if present?(obj)
+          obj
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Util
+    module Retryable
+      # Retries a given block a specified number of times in the
+      # event the specified exception is raised. If the retries
+      # run out, the final exception is raised.
+      #
+      # This code is adapted slightly from the following blog post:
+      # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+      def retryable(opts=nil)
+        logger = nil
+        opts   = { tries: 1, on: Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on] => e
+          if (opts[:tries] -= 1) > 0
+            logger = Log4r::Logger.new("vagrant::util::retryable")
+            logger.info("Retryable exception raised: #{e.inspect}")
+
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_chdir.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'thread'
+
+module Vagrant
+  module Util
+    class SafeChdir
+      @@chdir_lock  = Mutex.new
+
+      # Safely changes directory of this process by putting a lock around
+      # it so that it is thread safe. This will yield a block and when the
+      # block exits it changes back to the original directory.
+      #
+      # @param [String] dir Dir to change to temporarily
+      def self.safe_chdir(dir)
+        lock = @@chdir_lock
+
+        begin
+          @@chdir_lock.synchronize {}
+        rescue ThreadError
+          # If we already hold the lock, just create a new lock so we
+          # definitely don't block and don't get an error.
+          lock = Mutex.new
+        end
+
+        lock.synchronize do
+          Dir.chdir(dir) do
+            return yield
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/util/safe_env.rb

@@ -0,0 +1,17 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class SafeEnv
+      # This yields an environment hash to change and catches any issues
+      # while changing the environment variables and raises a helpful error
+      # to end users.
+      def self.change_env
+        yield ENV
+      rescue Errno::EINVAL
+        raise Errors::EnvInval
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_exec.rb

@@ -0,0 +1,78 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # This module provides a `safe_exec` method which is a drop-in
+    # replacement for `Kernel.exec` which addresses a specific issue
+    # which manifests on OS X 10.5 (GH-51) and perhaps other operating systems.
+    # This issue causes `exec` to fail if there is more than one system
+    # thread. In that case, `safe_exec` automatically falls back to
+    # forking.
+    class SafeExec
+
+      @@logger = Log4r::Logger.new("vagrant::util::safe_exec")
+
+      def self.exec(command, *args)
+        # Create a list of things to rescue from. Since this is OS
+        # specific, we need to do some defined? checks here to make
+        # sure they exist.
+        rescue_from = []
+        rescue_from << Errno::EOPNOTSUPP if defined?(Errno::EOPNOTSUPP)
+        rescue_from << Errno::E045 if defined?(Errno::E045)
+        rescue_from << SystemCallError
+
+        fork_instead = false
+        begin
+          if fork_instead
+            if Vagrant::Util::Platform.windows?
+              @@logger.debug("Using subprocess because windows platform")
+              args = args.dup << {notify: [:stdout, :stderr]}
+              result = Vagrant::Util::Subprocess.execute(command, *args) do |type, data|
+                case type
+                when :stdout
+                  @@logger.info(data, new_line: false)
+                when :stderr
+                  @@logger.info(data, new_line: false)
+                end
+              end
+              Kernel.exit(result.exit_code)
+            else
+              pid = fork
+              Kernel.exec(command, *args)
+              Process.wait(pid)
+            end
+          else
+            if Vagrant::Util::Platform.windows?
+              # Re-generate strings to ensure common encoding
+              @@logger.debug("Converting command and arguments to common UTF-8 encoding for exec.")
+              @@logger.debug("Command: `#{command.inspect}` Args: `#{args.inspect}`")
+              begin
+                command = "#{command}".encode("UTF-8")
+              rescue Encoding::UndefinedConversionError => e
+                @@logger.warn("Failed to convert command - #{e.class}: #{e} (`#{command}`)")
+              end
+              args = args.map do |arg|
+                begin
+                  "#{arg}".encode("UTF-8")
+                rescue Encoding::UndefinedConversionError => e
+                  @@logger.warn("Failed to convert command argument - #{e.class}: #{e} (`#{arg}`)")
+                  arg
+                end
+              end
+              @@logger.debug("Converted - Command: `#{command.inspect}` Args: `#{args.inspect}`")
+            end
+            Kernel.exec(command, *args)
+          end
+        rescue *rescue_from
+          # We retried already, raise the issue and be done
+          raise if fork_instead
+
+          # The error manifested itself, retry with a fork.
+          fork_instead = true
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_puts.rb

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # This module provides a `safe_puts` method which outputs to
+    # the given IO object, and rescues any broken pipe errors and
+    # ignores them. This is useful in cases where you're outputting
+    # to stdout, for example, and the stdout is closed, but you want to
+    # keep running.
+    module SafePuts
+      # Uses `puts` on the given IO object and safely ignores any
+      # Errno::EPIPE.
+      #
+      # @param [String] message Message to output.
+      # @param [Hash] opts Options hash.
+      def safe_puts(message=nil, opts=nil)
+        message ||= ""
+        opts = {
+          io: $stdout,
+          printer: :puts
+        }.merge(opts || {})
+
+        begin
+          opts[:io].send(opts[:printer], message)
+        rescue Errno::EPIPE
+          # This is what makes this a `safe` puts.
+          return
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/util/scoped_hash_override.rb

@@ -0,0 +1,47 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # This allows for hash options to be overridden by a scope key
+    # prefix. An example speaks best here. Imagine the following hash:
+    #
+    #     original = {
+    #       id: "foo",
+    #       mitchellh__id: "bar",
+    #       mitchellh__other: "foo"
+    #     }
+    #
+    #     scoped = scoped_hash_override(original, "mitchellh")
+    #
+    #     scoped == {
+    #       id: "bar",
+    #       other: "foo"
+    #     }
+    #
+    module ScopedHashOverride
+      def scoped_hash_override(original, scope)
+        # Convert the scope to a string in case a symbol was given since
+        # we use string comparisons for everything.
+        scope = scope.to_s
+
+        # Shallow copy the hash for the result
+        result = original.dup
+
+        original.each do |key, value|
+          parts = key.to_s.split("__", 2)
+
+          # If we don't have the proper parts, then bail
+          next if parts.length != 2
+
+          # If this is our scope, then override
+          if parts[0] == scope
+            result[parts[1].to_sym] = value
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/vagrant/util/shell_quote.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module ShellQuote
+      # This will auto-escape the text with the given quote mark type.
+      #
+      # @param [String] text Text to escape
+      # @param [String] quote The quote character, such as "
+      def self.escape(text, quote)
+        text.gsub(/#{quote}/) do |m|
+          "#{m}\\#{m}#{m}"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/silence_warnings.rb

@@ -0,0 +1,17 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module SilenceWarnings
+      # This silences any Ruby warnings.
+      def self.silence!
+        original = $VERBOSE
+        $VERBOSE = nil
+        return yield
+      ensure
+        $VERBOSE = original
+      end
+    end
+  end
+end