bolt 2.16.0 → 2.17.0

data/lib/bolt/logger.rb

@@ -89,8 +89,10 @@ module Bolt
       :notice
     end
 
+    # Explicitly check the log level names instead of the log level number, as levels
+    # that are stringified integers (e.g. "level" => "42") will return a truthy value
     def self.valid_level?(level)
-      !Logging.level_num(level).nil?
+      Logging::LEVELS.include?(Logging.levelify(level))
     end
 
     def self.levels

data/lib/bolt/outputter.rb

@@ -26,5 +26,5 @@ end
 
 require 'bolt/outputter/human'
 require 'bolt/outputter/json'
-require 'bolt/outputter/rainbow'
 require 'bolt/outputter/logger'
+require 'bolt/outputter/rainbow'

data/lib/bolt/outputter/rainbow.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require 'bolt/pal'
-require 'paint'
 
 module Bolt
   class Outputter
     class Rainbow < Bolt::Outputter::Human
       def initialize(color, verbose, trace, stream = $stdout)
+        begin
+          require 'paint'
+        rescue LoadError
+          raise "The 'paint' gem is required to use the rainbow outputter."
+        end
         super
         @line_color = 0
         @color = 0

data/lib/bolt/pal.rb

@@ -15,25 +15,36 @@ module Bolt
     # PALError is used to convert errors from executing puppet code into
     # Bolt::Errors
     class PALError < Bolt::Error
-      # Puppet sometimes rescues exceptions notes the location and reraises.
-      # Return the original error.
       def self.from_preformatted_error(err)
         if err.cause&.is_a? Bolt::Error
           err.cause
         else
-          from_error(err.cause || err)
+          from_error(err)
         end
       end
 
       # Generate a Bolt::Pal::PALError for non-bolt errors
       def self.from_error(err)
-        e = new(err.message)
+        # Use the original error message if available
+        message = err.cause ? err.cause.message : err.message
+
+        # Provide the location of an error if it came from a plan
+        details = if defined?(err.file) && err.file
+                    { file:   err.file,
+                      line:   err.line,
+                      column: err.pos }.compact
+                  else
+                    {}
+                  end
+
+        e = new(message, details)
+
         e.set_backtrace(err.backtrace)
         e
       end
 
-      def initialize(msg)
-        super(msg, 'bolt/pal-error')
+      def initialize(msg, details = {})
+        super(msg, 'bolt/pal-error', details)
       end
     end
 
@@ -159,8 +170,9 @@ module Bolt
               if e.issue_code == :UNKNOWN_VARIABLE &&
                  %w[facts trusted server_facts settings].include?(e.arguments[:name])
                 message = "Evaluation Error: Variable '#{e.arguments[:name]}' is not available in the current scope "\
-                  "unless explicitly defined. (file: #{e.file}, line: #{e.line}, column: #{e.pos})"
-                PALError.new(message)
+                          "unless explicitly defined."
+                details = { file: e.file, line: e.line, column: e.pos }
+                PALError.new(message, details)
               else
                 PALError.from_preformatted_error(e)
               end

data/lib/bolt/shell/bash.rb

@@ -23,7 +23,7 @@ module Bolt
 
       def run_command(command, options = {})
         running_as(options[:run_as]) do
-          output = execute(command, sudoable: true)
+          output = execute(command, environment: options[:env_vars], sudoable: true)
           Bolt::Result.for_command(target,
                                    output.stdout.string,
                                    output.stderr.string,
@@ -58,7 +58,7 @@ module Bolt
           with_tmpdir do |dir|
             path = write_executable(dir.to_s, script)
             dir.chown(run_as)
-            output = execute([path, *arguments], sudoable: true)
+            output = execute([path, *arguments], environment: options[:env_vars], sudoable: true)
             Bolt::Result.for_command(target,
                                      output.stdout.string,
                                      output.stderr.string,
@@ -170,7 +170,7 @@ module Bolt
       def check_sudo(out, inp, stdin)
         buffer = out.readpartial(CHUNK_SIZE)
         # Split on newlines, including the newline
-        lines = buffer.split(/(?<=[\n])/)
+        lines = buffer.split(/(?<=\n)/)
         # handle_sudo will return the line if it is not a sudo prompt or error
         lines.map! { |line| handle_sudo(inp, line, stdin) }
         lines.join("")
@@ -277,31 +277,8 @@ module Bolt
         end
       end
 
-      # In the case where a task is run with elevated privilege and needs stdin
-      # a random string is echoed to stderr indicating that the stdin is available
-      # for task input data because the sudo password has already either been
-      # provided on stdin or was not needed.
-      def prepend_sudo_success(sudo_id, command_str)
-        command_str = "cd; #{command_str}" if conn.reset_cwd?
-        "sh -c #{Shellwords.shellescape("echo #{sudo_id} 1>&2; #{command_str}")}"
-      end
-
-      def prepend_chdir(command_str)
-        "sh -c #{Shellwords.shellescape("cd; #{command_str}")}"
-      end
-
-      # A helper to build up a single string that contains all of the options for
-      # privilege escalation. A wrapper script is used to direct task input to stdin
-      # when a tty is allocated and thus we do not need to prepend_sudo_success when
-      # using the wrapper or when the task does not require stdin data.
-      def build_sudoable_command_str(command_str, sudo_str, sudo_id, options)
-        if options[:stdin] && !options[:wrapper]
-          "#{sudo_str} #{prepend_sudo_success(sudo_id, command_str)}"
-        elsif conn.reset_cwd?
-          "#{sudo_str} #{prepend_chdir(command_str)}"
-        else
-          "#{sudo_str} #{command_str}"
-        end
+      def sudo_success(sudo_id)
+        "echo #{sudo_id} 1>&2"
       end
 
       # Returns string with the interpreter conditionally prepended
@@ -322,13 +299,15 @@ module Bolt
         escalate = sudoable && run_as && conn.user != run_as
         use_sudo = escalate && @target.options['run-as-command'].nil?
 
-        command_str = inject_interpreter(options[:interpreter], command)
+        # Depending on the transport, whether we're using sudo and whether
+        # there are environment variables to set, we may need to stitch
+        # together multiple commands into a single sh invocation
+        commands = [inject_interpreter(options[:interpreter], command)]
 
         if options[:environment]
-          env_decls = options[:environment].map do |env, val|
+          env_decl = options[:environment].map do |env, val|
             "#{env}=#{Shellwords.shellescape(val)}"
-          end
-          command_str = "#{env_decls.join(' ')} #{command_str}"
+          end.join(' ')
         end
 
         if escalate
@@ -340,9 +319,18 @@ module Bolt
                      else
                        Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
                      end
-          command_str = build_sudoable_command_str(command_str, sudo_str, @sudo_id, options)
+          commands.unshift('cd') if conn.reset_cwd?
+          commands.unshift(sudo_success(@sudo_id)) if options[:stdin] && !options[:wrapper]
         end
 
+        command_str = if sudo_str || env_decl
+                        "sh -c #{Shellwords.shellescape(commands.join('; '))}"
+                      else
+                        commands.last
+                      end
+
+        command_str = [sudo_str, env_decl, command_str].compact.join(' ')
+
         @logger.debug { "Executing: #{command_str}" }
 
         in_buffer = if !use_sudo && options[:stdin]

data/lib/bolt/shell/powershell.rb

@@ -71,8 +71,10 @@ module Bolt
         end
       end
 
-      def set_env(arg, val)
-        "[Environment]::SetEnvironmentVariable('#{arg}', @'\n#{val}\n'@)"
+      def env_declarations(env_vars)
+        env_vars.map do |var, val|
+          "[Environment]::SetEnvironmentVariable('#{var}', @'\n#{val}\n'@)"
+        end
       end
 
       def quote_string(string)
@@ -166,7 +168,9 @@ module Bolt
         Bolt::Result.for_upload(target, source, destination)
       end
 
-      def run_command(command, _options = {})
+      def run_command(command, options = {})
+        command = [*env_declarations(options[:env_vars]), command].join("\r\n") if options[:env_vars]
+
         output = execute(command)
         Bolt::Result.for_command(target,
                                  output.stdout.string,
@@ -175,7 +179,7 @@ module Bolt
                                  'command', command)
       end
 
-      def run_script(script, arguments, _options = {})
+      def run_script(script, arguments, options = {})
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
         with_tmpdir do |dir|
@@ -187,6 +191,8 @@ module Bolt
                       args += escape_arguments(arguments)
                       execute_process(path, args)
                     end
+          command = [*env_declarations(options[:env_vars]), command].join("\r\n") if options[:env_vars]
+
           output = execute(command)
           Bolt::Result.for_command(target,
                                    output.stdout.string,
@@ -237,9 +243,7 @@ module Bolt
                     end
 
           env_assignments = if Bolt::Task::ENVIRONMENT_METHODS.include?(input_method)
-                              envify_params(arguments).map do |(arg, val)|
-                                set_env(arg, val)
-                              end
+                              env_declarations(envify_params(arguments))
                             else
                               []
                             end

data/lib/bolt/transport/docker.rb

@@ -39,7 +39,9 @@ module Bolt
       end
 
       def run_command(target, command, options = {})
-        options[:tty] = target.options['tty']
+        execute_options = {}
+        execute_options[:tty] = target.options['tty']
+        execute_options[:environment] = options[:env_vars]
 
         if target.options['shell-command'] && !target.options['shell-command'].empty?
           # escape any double quotes in command
@@ -47,19 +49,21 @@ module Bolt
           command = "#{target.options['shell-command']} \" #{command}\""
         end
         with_connection(target) do |conn|
-          stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), options)
+          stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), execute_options)
           Bolt::Result.for_command(target, stdout, stderr, exitcode, 'command', command)
         end
       end
 
-      def run_script(target, script, arguments, _options = {})
+      def run_script(target, script, arguments, options = {})
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
+        execute_options = {}
+        execute_options[:environment] = options[:env_vars]
 
         with_connection(target) do |conn|
           conn.with_remote_tmpdir do |dir|
             remote_path = conn.write_remote_executable(dir, script)
-            stdout, stderr, exitcode = conn.execute(remote_path, *arguments, {})
+            stdout, stderr, exitcode = conn.execute(remote_path, *arguments, execute_options)
             Bolt::Result.for_command(target, stdout, stderr, exitcode, 'script', script)
           end
         end

data/lib/bolt/transport/orch.rb

@@ -82,6 +82,10 @@ module Bolt
       end
 
       def batch_command(targets, command, options = {}, &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
         params = {
           'command' => command
         }
@@ -98,6 +102,10 @@ module Bolt
       end
 
       def batch_script(targets, script, arguments, options = {}, &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
         content = File.open(script, &:read)
         content = Base64.encode64(content)
         params = {

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '2.16.0'
+  VERSION = '2.17.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 2.16.0
+  version: 2.17.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -178,20 +178,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: paint
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: puppet
   requirement: !ruby/object:Gem::Requirement
@@ -213,47 +199,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7'
 - !ruby/object:Gem::Dependency
-  name: puppet-resource_api
+  name: puppetfile-resolver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
-  name: puppet-strings
+  name: puppet-resource_api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: 1.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: 1.8.1
 - !ruby/object:Gem::Dependency
-  name: puppetfile-resolver
+  name: puppet-strings
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: r10k
   requirement: !ruby/object:Gem::Requirement