bolt 2.32.0 → 2.33.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b010e9146d3269d88005be58db6b788f57ea3046f96f28756641b0c7266eec2
-  data.tar.gz: ce8d15031143acabc664a7025ef004c69211c25316f9691783388ba74e61dec9
+  metadata.gz: cf27b6c8b1a7e3cfb2eb61617bd7ab4927161c577df4915d959182fd8bce7eaf
+  data.tar.gz: '05578a39ce18d1d63bf9455c8890e1e328bdcb3f52dacc3d6d5047251bca833e'
 SHA512:
-  metadata.gz: b45657eb2b985f8e97c59ff4603ad049fd17ee6585292463a57bde3b5c7ca55451883b5e88cb0f61e55c05f1d5415cbde3874320ae446124d646a3d3e8ffa812
-  data.tar.gz: 673e3f3310bf4f22602153bf8300851fa3a832db8e73abc9352874bea7c0b1fd50a5baa42d18474885caea7ec9fad4aa50c25f44aa27974097e10ea03b31e07e
+  metadata.gz: 11b3fad81f576fa435b570b15ee7cbab14b7c099b4b179770eb20dbc7f2a2db9b2d2de6c4a52eb09021a9794d13c4da704eb3a2ed362cfd50ab1946e7ef5998d
+  data.tar.gz: 300b9fa2214a66d239218b7a8c12518a97c2cf2fafd401c860a3ff9cdd439355608b30d72d5a82f157eea842a25a7c5bc9d484dd9f616837ebfe4beff26c0795

data/Puppetfile

@@ -6,16 +6,16 @@ moduledir File.join(File.dirname(__FILE__), 'modules')
 
 # Core modules used by 'apply'
 mod 'puppetlabs-service', '1.3.0'
-mod 'puppetlabs-puppet_agent', '4.1.1'
+mod 'puppetlabs-puppet_agent', '4.2.0'
 mod 'puppetlabs-facts', '1.1.0'
 
 # Core types and providers for Puppet 6
 mod 'puppetlabs-augeas_core', '1.1.1'
 mod 'puppetlabs-host_core', '1.0.3'
 mod 'puppetlabs-scheduled_task', '2.2.1'
-mod 'puppetlabs-sshkeys_core', '2.1.0'
-mod 'puppetlabs-zfs_core', '1.1.0'
-mod 'puppetlabs-cron_core', '1.0.4'
+mod 'puppetlabs-sshkeys_core', '2.2.0'
+mod 'puppetlabs-zfs_core', '1.2.0'
+mod 'puppetlabs-cron_core', '1.0.5'
 mod 'puppetlabs-mount_core', '1.0.4'
 mod 'puppetlabs-selinux_core', '1.0.4'
 mod 'puppetlabs-yumrepo_core', '1.0.7'
@@ -36,6 +36,7 @@ mod 'puppetlabs-azure_inventory', '0.4.1'
 mod 'puppetlabs-gcloud_inventory', '0.1.3'
 mod 'puppetlabs-http_request', '0.2.0'
 mod 'puppetlabs-pkcs7', '0.1.1'
+mod 'puppetlabs-secure_env_vars', '0.1.0'
 mod 'puppetlabs-terraform', '0.5.0'
 mod 'puppetlabs-vault', '0.3.0'
 mod 'puppetlabs-yaml', '0.2.0'
@@ -44,4 +45,3 @@ mod 'puppetlabs-yaml', '0.2.0'
 mod 'canary', local: true
 mod 'aggregate', local: true
 mod 'puppetdb_fact', local: true
-mod 'secure_env_vars', local: true

data/bolt-modules/boltlib/lib/puppet/functions/download_file.rb

@@ -112,7 +112,7 @@ Puppet::Functions.create_function(:download_file, Puppet::Functions::InternalFun
       call_function('debug', "Simulating file download of '#{source}' - no targets given - no action taken")
       r = Bolt::ResultSet.new([])
     else
-      r = executor.download_file(targets, source, destination, options)
+      r = executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
     end
 
     if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/facts.rb

@@ -3,6 +3,12 @@
 require 'bolt/error'
 
 # Returns the facts hash for a target.
+#
+# Using the `facts` function does not automatically collect facts for a target,
+# and will only return facts that are currently set in the inventory. To collect
+# facts from a target and set them in the inventory, run the
+# [facts](writing_plans.md#collect-facts-from-targets) plan or
+# [puppetdb_fact](writing_plans.md#collect-facts-from-puppetdb) plan.
 Puppet::Functions.create_function(:facts) do
   # @param target A target.
   # @return The target's facts.

data/bolt-modules/boltlib/lib/puppet/functions/puppetdb_query.rb

@@ -2,12 +2,12 @@
 
 require 'bolt/error'
 
-# Makes a query to {https://puppet.com/docs/puppetdb/latest/index.html puppetdb}
+# Makes a query to [puppetdb](https://puppet.com/docs/puppetdb/latest/index.html)
 # using Bolt's PuppetDB client.
 Puppet::Functions.create_function(:puppetdb_query) do
   # rubocop:disable Layout/LineLength
   # @param query A PQL query.
-  #   {https://puppet.com/docs/puppetdb/latest/api/query/tutorial-pql.html Learn more about Puppet's query language, PQL}
+  #   Learn more about [Puppet's query language](https://puppet.com/docs/puppetdb/latest/api/query/tutorial-pql.html), PQL.
   # @return Results of the PuppetDB query.
   # @example Request certnames for all nodes
   #   puppetdb_query('nodes[certname] {}')

data/bolt-modules/boltlib/lib/puppet/functions/run_command.rb

@@ -69,7 +69,7 @@ Puppet::Functions.create_function(:run_command) do
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
       r = Bolt::ResultSet.new([])
     else
-      r = executor.run_command(targets, command, options)
+      r = executor.run_command(targets, command, options, Puppet::Pops::PuppetStack.top_of_stack)
     end
 
     if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/run_script.rb

@@ -87,7 +87,7 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     r = if targets.empty?
           Bolt::ResultSet.new([])
         else
-          executor.run_script(targets, found, arguments, options)
+          executor.run_script(targets, found, arguments, options, Puppet::Pops::PuppetStack.top_of_stack)
         end
 
     if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/run_task.rb

@@ -133,7 +133,7 @@ Puppet::Functions.create_function(:run_task) do
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      result = executor.run_task(targets, task, params, options)
+      result = executor.run_task(targets, task, params, options, Puppet::Pops::PuppetStack.top_of_stack)
       if !result.ok && !options[:catch_errors]
         raise Bolt::RunFailure.new(result, 'run_task', task_name)
       end

data/bolt-modules/boltlib/lib/puppet/functions/run_task_with.rb

@@ -180,7 +180,7 @@ Puppet::Functions.create_function(:run_task_with) do
     else
       # Combine the results from the task run with any failing results that were
       # generated earlier when creating the target mapping
-      task_result = executor.run_task_with(target_mapping, task, options)
+      task_result = executor.run_task_with(target_mapping, task, options, Puppet::Pops::PuppetStack.top_of_stack)
       result = Bolt::ResultSet.new(task_result.results + error_set)
 
       if !result.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/upload_file.rb

@@ -83,7 +83,7 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
       call_function('debug', "Simulating file upload of '#{found}' - no targets given - no action taken")
       r = Bolt::ResultSet.new([])
     else
-      r = executor.upload_file(targets, found, destination, options)
+      r = executor.upload_file(targets, found, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
     end
 
     if !r.ok && !options[:catch_errors]

data/guides/logging.txt

@@ -0,0 +1,18 @@
+TOPIC
+    logging
+
+DESCRIPTION
+    Bolt prints messages both to the console and to log files. Messages can
+    either come from Bolt's 'outputter', which logs user-facing messages like
+    progress and results, or from the 'logger', which logs warnings, errors, and
+    log-structured output to log files. Both of these message streams are
+    configurable.
+
+    By default, Bolt logs to the console at 'warn' level and writes a log file to
+    '<project>/bolt-debug.log' at 'debug' level. Unless you are running a plan,
+    Bolt runs in verbose mode by default.
+
+    To learn more about projects, see the 'project' guide.
+
+DOCUMENTATION
+    https://pup.pt/bolt-logging

data/lib/bolt/config/transport/options.rb

@@ -357,7 +357,7 @@ module Bolt
             description: "The URL of the host used for API requests.",
             format: "uri",
             _plugin: true,
-            _example: "https://api.example.com"
+            _example: "https://api.example.com:<port>"
           },
           "shell-command" => {
             type: String,

data/lib/bolt/error.rb

@@ -24,6 +24,10 @@ module Bolt
       h
     end
 
+    def add_filelineno(details)
+      @details.merge!(details) unless @details['file']
+    end
+
     def to_json(opts = nil)
       to_h.to_json(opts)
     end

data/lib/bolt/executor.rb

@@ -253,33 +253,33 @@ module Bolt
       result
     end
 
-    def run_command(targets, command, options = {})
+    def run_command(targets, command, options = {}, position = [])
       description = options.fetch(:description, "command '#{command}'")
       log_action(description, targets) do
         options[:run_as] = run_as if run_as && !options.key?(:run_as)
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Running command '#{command}'", batch) do
-            transport.batch_command(batch, command, options, &method(:publish_event))
+            transport.batch_command(batch, command, options, position, &method(:publish_event))
           end
         end
       end
     end
 
-    def run_script(targets, script, arguments, options = {})
+    def run_script(targets, script, arguments, options = {}, position = [])
       description = options.fetch(:description, "script #{script}")
       log_action(description, targets) do
         options[:run_as] = run_as if run_as && !options.key?(:run_as)
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Running script #{script} with '#{arguments.to_json}'", batch) do
-            transport.batch_script(batch, script, arguments, options, &method(:publish_event))
+            transport.batch_script(batch, script, arguments, options, position, &method(:publish_event))
           end
         end
       end
     end
 
-    def run_task(targets, task, arguments, options = {})
+    def run_task(targets, task, arguments, options = {}, position = [])
       description = options.fetch(:description, "task #{task.name}")
       log_action(description, targets) do
         options[:run_as] = run_as if run_as && !options.key?(:run_as)
@@ -287,13 +287,13 @@ module Bolt
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Running task #{task.name} with '#{arguments.to_json}'", batch) do
-            transport.batch_task(batch, task, arguments, options, &method(:publish_event))
+            transport.batch_task(batch, task, arguments, options, position, &method(:publish_event))
           end
         end
       end
     end
 
-    def run_task_with(target_mapping, task, options = {})
+    def run_task_with(target_mapping, task, options = {}, position = [])
       targets = target_mapping.keys
       description = options.fetch(:description, "task #{task.name}")
 
@@ -303,26 +303,26 @@ module Bolt
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Running task #{task.name}'", batch) do
-            transport.batch_task_with(batch, task, target_mapping, options, &method(:publish_event))
+            transport.batch_task_with(batch, task, target_mapping, options, position, &method(:publish_event))
           end
         end
       end
     end
 
-    def upload_file(targets, source, destination, options = {})
+    def upload_file(targets, source, destination, options = {}, position = [])
       description = options.fetch(:description, "file upload from #{source} to #{destination}")
       log_action(description, targets) do
         options[:run_as] = run_as if run_as && !options.key?(:run_as)
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Uploading file #{source} to #{destination}", batch) do
-            transport.batch_upload(batch, source, destination, options, &method(:publish_event))
+            transport.batch_upload(batch, source, destination, options, position, &method(:publish_event))
           end
         end
       end
     end
 
-    def download_file(targets, source, destination, options = {})
+    def download_file(targets, source, destination, options = {}, position = [])
       description = options.fetch(:description, "file download from #{source} to #{destination}")
 
       begin
@@ -337,7 +337,7 @@ module Bolt
 
         batch_execute(targets) do |transport, batch|
           with_node_logging("Downloading file #{source} to #{destination}", batch) do
-            transport.batch_download(batch, source, destination, options, &method(:publish_event))
+            transport.batch_download(batch, source, destination, options, position, &method(:publish_event))
           end
         end
       end

data/lib/bolt/module_installer.rb

@@ -187,6 +187,7 @@ module Bolt
       ok = Installer.new(config).install(path, moduledir)
 
       # Automatically generate types after installing modules
+      @outputter.print_action_step("Generating type references")
       @pal.generate_types
 
       @outputter.print_puppetfile_result(ok, path, moduledir)

data/lib/bolt/pal.rb

@@ -14,17 +14,11 @@ module Bolt
     # Bolt::Errors
     class PALError < Bolt::Error
       def self.from_preformatted_error(err)
-        if err.cause.is_a? Bolt::Error
-          err.cause
-        else
-          from_error(err)
-        end
-      end
-
-      # Generate a Bolt::Pal::PALError for non-bolt errors
-      def self.from_error(err)
-        # Use the original error message if available
-        message = err.cause ? err.cause.message : err.message
+        error = if err.cause.is_a? Bolt::Error
+                  err.cause
+                else
+                  from_error(err)
+                end
 
         # Provide the location of an error if it came from a plan
         details = {}
@@ -32,8 +26,15 @@ module Bolt
         details[:line]   = err.line if defined?(err.line)
         details[:column] = err.pos if defined?(err.pos)
 
-        e = new(message, details.compact)
+        error.add_filelineno(details)
+        error
+      end
 
+      # Generate a Bolt::Pal::PALError for non-bolt errors
+      def self.from_error(err)
+        # Use the original error message if available
+        message = err.cause ? err.cause.message : err.message
+        e = new(message)
         e.set_backtrace(err.backtrace)
         e
       end
@@ -256,19 +257,24 @@ module Bolt
 
     # TODO: PUP-8553 should replace this
     def with_puppet_settings
-      Dir.mktmpdir('bolt') do |dir|
-        cli = []
-        Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
-          cli << "--#{setting}" << dir
-        end
-        Puppet.settings.send(:clear_everything_for_tests)
-        Puppet.initialize_settings(cli)
-        Puppet::GettextConfig.create_default_text_domain
-        Puppet[:trusted_external_command] = @trusted_external
-        Puppet.settings[:hiera_config] = @hiera_config
-        self.class.configure_logging
-        yield
+      dir = Dir.mktmpdir('bolt')
+
+      cli = []
+      Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
+        cli << "--#{setting}" << dir
       end
+      Puppet.settings.send(:clear_everything_for_tests)
+      Puppet.initialize_settings(cli)
+      Puppet::GettextConfig.create_default_text_domain
+      Puppet[:trusted_external_command] = @trusted_external
+      Puppet.settings[:hiera_config] = @hiera_config
+      self.class.configure_logging
+      yield
+    ensure
+      # Delete the tmpdir if it still exists. This check is needed to
+      # prevent Bolt from erroring if the tmpdir is somehow deleted
+      # before reaching this point.
+      FileUtils.remove_entry_secure(dir) if File.exist?(dir)
     end
 
     # Parses a snippet of Puppet manifest code and returns the AST represented

data/lib/bolt/pal/yaml_plan.rb

@@ -98,10 +98,12 @@ module Bolt
       # subclasses this parent class in order to implement its own evaluation
       # logic.
       class EvaluableString
-        attr_reader :value
+        attr_reader :file, :line, :value
 
-        def initialize(value)
+        def initialize(value, file = nil, line = nil)
           @value = value
+          @file  = file
+          @line  = line
         end
 
         def ==(other)

data/lib/bolt/pal/yaml_plan/evaluator.rb

@@ -191,7 +191,11 @@ module Bolt
               o[key] = evaluate_code_blocks(scope, v)
             end
           when EvaluableString
-            value.evaluate(scope, @evaluator)
+            begin
+              value.evaluate(scope, @evaluator)
+            rescue StandardError => e
+              raise format_evaluate_error(e, value)
+            end
           else
             value
           end
@@ -203,6 +207,24 @@ module Bolt
         def evaluate(value, _scope)
           value
         end
+
+        def format_evaluate_error(error, value)
+          # The Puppet::PreformattedError includes the line number of the
+          # evaluable string that caused the error, while the value includes the
+          # line number of the YAML plan that the string began on. To get the
+          # actual line number of the error, add these two numbers together.
+          line = error.line + value.line
+
+          # If the evaluable string is not a scalar literal, correct for it
+          # being on the same line as the step key.
+          line -= 1 if value.is_a?(BareString)
+
+          Bolt::PlanFailure.new(
+            error.basic_message,
+            'bolt/evaluation-error',
+            { file: value.file, line: line }
+          )
+        end
       end
     end
   end

data/lib/bolt/pal/yaml_plan/loader.rb

@@ -9,10 +9,15 @@ module Bolt
     class YamlPlan
       class Loader
         class PuppetVisitor < Psych::Visitors::NoAliasRuby
-          def self.create_visitor
+          def initialize(scanner, class_loader, file)
+            super(scanner, class_loader)
+            @file = file
+          end
+
+          def self.create_visitor(source_ref)
             class_loader = Psych::ClassLoader::Restricted.new([], [])
             scanner = Psych::ScalarScanner.new(class_loader)
-            new(scanner, class_loader)
+            new(scanner, class_loader, source_ref)
           end
 
           def deserialize(node)
@@ -23,18 +28,18 @@ module Bolt
                 # @ss is a ScalarScanner, from the base ToRuby visitor class
                 node.value
               when Psych::Nodes::Scalar::DOUBLE_QUOTED
-                DoubleQuotedString.new(node.value)
-              # | style string or > style string
-              when Psych::Nodes::Scalar::LITERAL, Psych::Nodes::Scalar::FOLDED
-                CodeLiteral.new(node.value)
-              # This one shouldn't be possible
+                DoubleQuotedString.new(node.value, @file, node.start_line + 1)
+              # | style string
+              when Psych::Nodes::Scalar::LITERAL
+                CodeLiteral.new(node.value, @file, node.start_line + 1)
+              # > style string
               else
                 @ss.tokenize(node.value)
               end
             else
               value = @ss.tokenize(node.value)
               if value.is_a?(String)
-                BareString.new(value)
+                BareString.new(value, @file, node.start_line + 1)
               else
                 value
               end
@@ -50,7 +55,7 @@ module Bolt
                        else
                          Psych.parse(yaml_string, source_ref)
                        end
-          PuppetVisitor.create_visitor.accept(parse_tree)
+          PuppetVisitor.create_visitor(source_ref).accept(parse_tree)
         end
 
         def self.from_string(name, yaml_string, source_ref)

data/lib/bolt/result.rb

@@ -7,47 +7,58 @@ module Bolt
   class Result
     attr_reader :target, :value, :action, :object
 
-    def self.from_exception(target, exception, action: 'action')
+    def self.from_exception(target, exception, action: 'action', position: [])
+      details = create_details(position)
       if exception.is_a?(Bolt::Error)
-        error = exception.to_h
+        error = Bolt::Util.deep_merge({ 'details' => details }, exception.to_h)
       else
+        details['class'] = exception.class.to_s
         error = {
           'kind' => 'puppetlabs.tasks/exception-error',
           'issue_code' => 'EXCEPTION',
           'msg' => exception.message,
-          'details' => { 'class' => exception.class.to_s }
+          'details' => details
         }
         error['details']['stack_trace'] = exception.backtrace.join('\n') if exception.backtrace
       end
       Result.new(target, error: error, action: action)
     end
 
-    def self.for_command(target, stdout, stderr, exit_code, action, command)
+    def self.create_details(position)
+      %w[file line].zip(position).to_h.compact
+    end
+
+    def self.for_command(target, stdout, stderr, exit_code, action, command, position)
       value = {
         'stdout' => stdout,
         'stderr' => stderr,
         'exit_code' => exit_code
       }
+
+      details = create_details(position)
       unless exit_code == 0
+        details['exit_code'] = exit_code
         value['_error'] = {
           'kind' => 'puppetlabs.tasks/command-error',
           'issue_code' => 'COMMAND_ERROR',
           'msg' => "The command failed with exit code #{exit_code}",
-          'details' => { 'exit_code' => exit_code }
+          'details' => details
         }
       end
       new(target, value: value, action: action, object: command)
     end
 
-    def self.for_task(target, stdout, stderr, exit_code, task)
+    def self.for_task(target, stdout, stderr, exit_code, task, position)
       stdout.force_encoding('utf-8') unless stdout.encoding == Encoding::UTF_8
+
+      details = create_details(position)
       value = if stdout.valid_encoding?
                 parse_hash(stdout) || { '_output' => stdout }
               else
                 { '_error' => { 'kind' => 'puppetlabs.tasks/task-error',
                                 'issue_code' => 'TASK_ERROR',
                                 'msg' => 'The task result contained invalid UTF-8 on stdout',
-                                'details' => {} } }
+                                'details' => details } }
               end
 
       if exit_code != 0 && value['_error'].nil?
@@ -60,24 +71,26 @@ module Bolt
               else
                 "The task failed with exit code #{exit_code}"
               end
+        details['exit_code'] = exit_code
         value['_error'] = { 'kind' => 'puppetlabs.tasks/task-error',
                             'issue_code' => 'TASK_ERROR',
                             'msg' => msg,
-                            'details' => { 'exit_code' => exit_code } }
+                            'details' => details }
       end
 
       if value.key?('_error')
         unless value['_error'].is_a?(Hash) && value['_error'].key?('msg')
+          details['original_error'] = value['_error']
           value['_error'] = {
             'msg'     => "Invalid error returned from task #{task}: #{value['_error'].inspect}. Error "\
                          "must be an object with a msg key.",
             'kind'    => 'bolt/invalid-task-error',
-            'details' => { 'original_error' => value['_error'] }
+            'details' => details
           }
         end
 
         value['_error']['kind']    ||= 'bolt/error'
-        value['_error']['details'] ||= {}
+        value['_error']['details'] ||= details
       end
 
       if value.key?('_sensitive')
@@ -221,7 +234,6 @@ module Bolt
     def error
       if error_hash
         Puppet::DataTypes::Error.from_asserted_hash(error_hash)
-
       end
     end
 

data/lib/bolt/shell/bash.rb

@@ -21,14 +21,16 @@ module Bolt
         ['shell']
       end
 
-      def run_command(command, options = {})
+      def run_command(command, options = {}, position = [])
         running_as(options[:run_as]) do
           output = execute(command, environment: options[:env_vars], sudoable: true)
           Bolt::Result.for_command(target,
                                    output.stdout.string,
                                    output.stderr.string,
                                    output.exit_code,
-                                   'command', command)
+                                   'command',
+                                   command,
+                                   position)
         end
       end
 
@@ -71,7 +73,7 @@ module Bolt
         end
       end
 
-      def run_script(script, arguments, options = {})
+      def run_script(script, arguments, options = {}, position = [])
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
 
@@ -84,12 +86,14 @@ module Bolt
                                      output.stdout.string,
                                      output.stderr.string,
                                      output.exit_code,
-                                     'script', script)
+                                     'script',
+                                     script,
+                                     position)
           end
         end
       end
 
-      def run_task(task, arguments, options = {})
+      def run_task(task, arguments, options = {}, position = [])
         implementation = select_implementation(target, task)
         executable = implementation['path']
         input_method = implementation['input_method']
@@ -148,7 +152,8 @@ module Bolt
           Bolt::Result.for_task(target, output.stdout.string,
                                 output.stderr.string,
                                 output.exit_code,
-                                task.name)
+                                task.name,
+                                position)
         end
       end
 

data/lib/bolt/shell/powershell.rb

@@ -174,7 +174,7 @@ module Bolt
         Bolt::Result.for_download(target, source, destination, download)
       end
 
-      def run_command(command, options = {})
+      def run_command(command, options = {}, position = [])
         command = [*env_declarations(options[:env_vars]), command].join("\r\n") if options[:env_vars]
 
         output = execute(command)
@@ -182,10 +182,12 @@ module Bolt
                                  output.stdout.string,
                                  output.stderr.string,
                                  output.exit_code,
-                                 'command', command)
+                                 'command',
+                                 command,
+                                 position)
       end
 
-      def run_script(script, arguments, options = {})
+      def run_script(script, arguments, options = {}, position = [])
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
         with_tmpdir do |dir|
@@ -204,11 +206,13 @@ module Bolt
                                    output.stdout.string,
                                    output.stderr.string,
                                    output.exit_code,
-                                   'script', script)
+                                   'script',
+                                   script,
+                                   position)
         end
       end
 
-      def run_task(task, arguments, _options = {})
+      def run_task(task, arguments, _options = {}, position = [])
         implementation = select_implementation(target, task)
         executable = implementation['path']
         input_method = implementation['input_method']
@@ -259,7 +263,8 @@ module Bolt
           Bolt::Result.for_task(target, output.stdout.string,
                                 output.stderr.string,
                                 output.exit_code,
-                                task.name)
+                                task.name,
+                                position)
         end
       end
 

data/lib/bolt/transport/base.rb

@@ -43,13 +43,13 @@ module Bolt
         @logger = Bolt::Logger.logger(self)
       end
 
-      def with_events(target, callback, action)
+      def with_events(target, callback, action, position)
         callback&.call(type: :node_start, target: target)
 
         result = begin
           yield
         rescue StandardError, NotImplementedError => e
-          Bolt::Result.from_exception(target, e, action: action)
+          Bolt::Result.from_exception(target, e, action: action, position: position)
         end
 
         callback&.call(type: :node_result, result: result)
@@ -100,12 +100,12 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implement their own batch processing.
-      def batch_task(targets, task, arguments, options = {}, &callback)
+      def batch_task(targets, task, arguments, options = {}, position = [], &callback)
         assert_batch_size_one("batch_task()", targets)
         target = targets.first
-        with_events(target, callback, 'task') do
+        with_events(target, callback, 'task', position) do
           @logger.debug { "Running task '#{task.name}' on #{target.safe_name}" }
-          run_task(target, task, arguments, options)
+          run_task(target, task, arguments, options, position)
         end
       end
 
@@ -114,14 +114,14 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implment their own batch processing.
-      def batch_task_with(targets, task, target_mapping, options = {}, &callback)
+      def batch_task_with(targets, task, target_mapping, options = {}, position = [], &callback)
         assert_batch_size_one("batch_task_with()", targets)
         target = targets.first
         arguments = target_mapping[target]
 
-        with_events(target, callback, 'task') do
+        with_events(target, callback, 'task', position) do
           @logger.debug { "Running task '#{task.name}' on #{target.safe_name} with '#{arguments.to_json}'" }
-          run_task(target, task, arguments, options)
+          run_task(target, task, arguments, options, position)
         end
       end
 
@@ -130,12 +130,12 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implement their own batch processing.
-      def batch_command(targets, command, options = {}, &callback)
+      def batch_command(targets, command, options = {}, position = [], &callback)
         assert_batch_size_one("batch_command()", targets)
         target = targets.first
-        with_events(target, callback, 'command') do
+        with_events(target, callback, 'command', position) do
           @logger.debug("Running command '#{command}' on #{target.safe_name}")
-          run_command(target, command, options)
+          run_command(target, command, options, position)
         end
       end
 
@@ -144,12 +144,12 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implement their own batch processing.
-      def batch_script(targets, script, arguments, options = {}, &callback)
+      def batch_script(targets, script, arguments, options = {}, position = [], &callback)
         assert_batch_size_one("batch_script()", targets)
         target = targets.first
-        with_events(target, callback, 'script') do
+        with_events(target, callback, 'script', position) do
           @logger.debug { "Running script '#{script}' on #{target.safe_name}" }
-          run_script(target, script, arguments, options)
+          run_script(target, script, arguments, options, position)
         end
       end
 
@@ -158,10 +158,10 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implement their own batch processing.
-      def batch_upload(targets, source, destination, options = {}, &callback)
+      def batch_upload(targets, source, destination, options = {}, position = [], &callback)
         assert_batch_size_one("batch_upload()", targets)
         target = targets.first
-        with_events(target, callback, 'upload') do
+        with_events(target, callback, 'upload', position) do
           @logger.debug { "Uploading: '#{source}' to #{destination} on #{target.safe_name}" }
           upload(target, source, destination, options)
         end
@@ -173,12 +173,12 @@ module Bolt
       # The default implementation only supports batches of size 1 and will fail otherwise.
       #
       # Transports may override this method to implement their own batch processing.
-      def batch_download(targets, source, destination, options = {}, &callback)
+      def batch_download(targets, source, destination, options = {}, position = [], &callback)
         require 'erb'
 
         assert_batch_size_one("batch_download()", targets)
         target = targets.first
-        with_events(target, callback, 'download') do
+        with_events(target, callback, 'download', position) do
           escaped_name = ERB::Util.url_encode(target.safe_name)
           target_destination = File.expand_path(escaped_name, destination)
           @logger.debug { "Downloading: '#{source}' on #{target.safe_name} to #{target_destination}" }

data/lib/bolt/transport/docker.rb

@@ -46,7 +46,7 @@ module Bolt
         end
       end
 
-      def run_command(target, command, options = {})
+      def run_command(target, command, options = {}, position = [])
         execute_options = {}
         execute_options[:tty] = target.options['tty']
         execute_options[:environment] = options[:env_vars]
@@ -58,11 +58,17 @@ module Bolt
         end
         with_connection(target) do |conn|
           stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), execute_options)
-          Bolt::Result.for_command(target, stdout, stderr, exitcode, 'command', command)
+          Bolt::Result.for_command(target,
+                                   stdout,
+                                   stderr,
+                                   exitcode,
+                                   'command',
+                                   command,
+                                   position)
         end
       end
 
-      def run_script(target, script, arguments, options = {})
+      def run_script(target, script, arguments, options = {}, position = [])
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
         execute_options = {}
@@ -72,12 +78,18 @@ module Bolt
           conn.with_remote_tmpdir do |dir|
             remote_path = conn.write_remote_executable(dir, script)
             stdout, stderr, exitcode = conn.execute(remote_path, *arguments, execute_options)
-            Bolt::Result.for_command(target, stdout, stderr, exitcode, 'script', script)
+            Bolt::Result.for_command(target,
+                                     stdout,
+                                     stderr,
+                                     exitcode,
+                                     'script',
+                                     script,
+                                     position)
           end
         end
       end
 
-      def run_task(target, task, arguments, _options = {})
+      def run_task(target, task, arguments, _options = {}, position = [])
         implementation = task.select_implementation(target, provided_features)
         executable = implementation['path']
         input_method = implementation['input_method']
@@ -113,7 +125,12 @@ module Bolt
             end
 
             stdout, stderr, exitcode = conn.execute(remote_task_path, execute_options)
-            Bolt::Result.for_task(target, stdout, stderr, exitcode, task.name)
+            Bolt::Result.for_task(target,
+                                  stdout,
+                                  stderr,
+                                  exitcode,
+                                  task.name,
+                                  position)
           end
         end
       end

data/lib/bolt/transport/orch.rb

@@ -53,7 +53,7 @@ module Bolt
         conn
       end
 
-      def process_run_results(targets, results, task_name)
+      def process_run_results(targets, results, task_name, position = [])
         targets_by_name = Hash[targets.map { |t| t.host || t.name }.zip(targets)]
         results.map do |node_result|
           target = targets_by_name[node_result['name']]
@@ -63,25 +63,31 @@ module Bolt
           # If it's finished or already has a proper error simply pass it to the
           # the result otherwise make sure an error is generated
           if state == 'finished' || (result && result['_error'])
+            if result['_error']
+              file_line = %w[file line].zip(position).to_h.compact
+              result['_error']['details'].merge!(file_line) unless result['_error']['details']['file']
+            end
+
             Bolt::Result.new(target, value: result, action: 'task', object: task_name)
           elsif state == 'skipped'
+            details = %w[file line].zip(position).to_h.compact
             Bolt::Result.new(
               target,
               value: { '_error' => {
                 'kind' => 'puppetlabs.tasks/skipped-node',
                 'msg' => "Target #{target.safe_name} was skipped",
-                'details' => {}
+                'details' => details
               } },
               action: 'task', object: task_name
             )
           else
             # Make a generic error with a unkown exit_code
-            Bolt::Result.for_task(target, result.to_json, '', 'unknown', task_name)
+            Bolt::Result.for_task(target, result.to_json, '', 'unknown', task_name, position)
           end
         end
       end
 
-      def batch_command(targets, command, options = {}, &callback)
+      def batch_command(targets, command, options = {}, position = [], &callback)
         if options[:env_vars] && !options[:env_vars].empty?
           raise NotImplementedError, "pcp transport does not support setting environment variables"
         end
@@ -93,6 +99,7 @@ module Bolt
                                BOLT_COMMAND_TASK,
                                params,
                                options,
+                               position,
                                &callback)
         callback ||= proc {}
         results.map! { |result| unwrap_bolt_result(result.target, result, 'command', command) }
@@ -101,7 +108,7 @@ module Bolt
         end
       end
 
-      def batch_script(targets, script, arguments, options = {}, &callback)
+      def batch_script(targets, script, arguments, options = {}, position = [], &callback)
         if options[:env_vars] && !options[:env_vars].empty?
           raise NotImplementedError, "pcp transport does not support setting environment variables"
         end
@@ -114,7 +121,7 @@ module Bolt
           'name' => Pathname(script).basename.to_s
         }
         callback ||= proc {}
-        results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)
+        results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, position, &callback)
         results.map! { |result| unwrap_bolt_result(result.target, result, 'script', script) }
         results.each do |result|
           callback.call(type: :node_result, result: result)
@@ -155,7 +162,7 @@ module Bolt
         output&.close
       end
 
-      def batch_upload(targets, source, destination, options = {}, &callback)
+      def batch_upload(targets, source, destination, options = {}, position = [], &callback)
         stat = File.stat(source)
         content = if stat.directory?
                     pack(source)
@@ -171,7 +178,7 @@ module Bolt
           'directory' => stat.directory?
         }
         callback ||= proc {}
-        results = run_task_job(targets, BOLT_UPLOAD_TASK, params, options, &callback)
+        results = run_task_job(targets, BOLT_UPLOAD_TASK, params, options, position, &callback)
         results.map! do |result|
           if result.error_hash
             result
@@ -200,7 +207,7 @@ module Bolt
         targets.group_by { |target| Connection.get_key(target.options) }.values
       end
 
-      def run_task_job(targets, task, arguments, options)
+      def run_task_job(targets, task, arguments, options, position)
         targets.each do |target|
           yield(type: :node_start, target: target) if block_given?
         end
@@ -210,7 +217,7 @@ module Bolt
           arguments = unwrap_sensitive_args(arguments)
           results = get_connection(targets.first.options).run_task(targets, task, arguments, options)
 
-          process_run_results(targets, results, task.name)
+          process_run_results(targets, results, task.name, position)
         rescue OrchestratorClient::ApiError => e
           targets.map do |target|
             Bolt::Result.new(target, error: e.data)
@@ -222,15 +229,15 @@ module Bolt
         end
       end
 
-      def batch_task(targets, task, arguments, options = {}, &callback)
+      def batch_task(targets, task, arguments, options = {}, position = [], &callback)
         callback ||= proc {}
-        results = run_task_job(targets, task, arguments, options, &callback)
+        results = run_task_job(targets, task, arguments, options, position, &callback)
         results.each do |result|
           callback.call(type: :node_result, result: result)
         end
       end
 
-      def batch_task_with(_targets, _task, _target_mapping, _options = {})
+      def batch_task_with(_targets, _task, _target_mapping, _options = {}, _position = [])
         raise NotImplementedError, "pcp transport does not support run_task_with()"
       end
 
@@ -248,11 +255,13 @@ module Bolt
           return result
         end
 
+        # If we get here, there's no error so we don't need the file or line
+        # number
         Bolt::Result.for_command(target,
                                  result.value['stdout'],
                                  result.value['stderr'],
                                  result.value['exit_code'],
-                                 action, obj)
+                                 action, obj, [])
       end
     end
   end

data/lib/bolt/transport/remote.rb

@@ -26,14 +26,14 @@ module Bolt
       end
 
       # Cannot batch because arugments differ
-      def run_task(target, task, arguments, options = {})
+      def run_task(target, task, arguments, options = {}, position = [])
         proxy_target = get_proxy(target)
         transport = @executor.transport(proxy_target.transport)
         arguments = arguments.merge('_target' => target.to_h.reject { |_, v| v.nil? })
 
         remote_task = task.remote_instance
 
-        result = transport.run_task(proxy_target, remote_task, arguments, options)
+        result = transport.run_task(proxy_target, remote_task, arguments, options, position)
         Bolt::Result.new(target, value: result.value, action: 'task', object: task.name)
       end
     end

data/lib/bolt/transport/simple.rb

@@ -20,9 +20,9 @@ module Bolt
         false
       end
 
-      def run_command(target, command, options = {})
+      def run_command(target, command, options = {}, position = [])
         with_connection(target) do |conn|
-          conn.shell.run_command(command, options)
+          conn.shell.run_command(command, options, position)
         end
       end
 
@@ -38,15 +38,15 @@ module Bolt
         end
       end
 
-      def run_script(target, script, arguments, options = {})
+      def run_script(target, script, arguments, options = {}, position = [])
         with_connection(target) do |conn|
-          conn.shell.run_script(script, arguments, options)
+          conn.shell.run_script(script, arguments, options, position)
         end
       end
 
-      def run_task(target, task, arguments, options = {})
+      def run_task(target, task, arguments, options = {}, position = [])
         with_connection(target) do |conn|
-          conn.shell.run_task(task, arguments, options)
+          conn.shell.run_task(task, arguments, options, position)
         end
       end
     end

data/lib/bolt/version.rb

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

data/lib/bolt_spec/plans/action_stubs/command_stub.rb

@@ -29,7 +29,7 @@ module BoltSpec
       end
 
       def result_for(target, stdout: '', stderr: '')
-        Bolt::Result.for_command(target, stdout, stderr, 0, 'command', '')
+        Bolt::Result.for_command(target, stdout, stderr, 0, 'command', '', [])
       end
 
       # Public methods

data/lib/bolt_spec/plans/action_stubs/script_stub.rb

@@ -35,7 +35,7 @@ module BoltSpec
       end
 
       def result_for(target, stdout: '', stderr: '')
-        Bolt::Result.for_command(target, stdout, stderr, 0, 'script', '')
+        Bolt::Result.for_command(target, stdout, stderr, 0, 'script', '', [])
       end
 
       # Public methods

data/lib/bolt_spec/plans/mock_executor.rb

@@ -48,7 +48,7 @@ module BoltSpec
         ([segments[0]] + segments[2..-1]).join('/')
       end
 
-      def run_command(targets, command, options = {})
+      def run_command(targets, command, options = {}, _position = [])
         result = nil
         if (doub = @command_doubles[command] || @command_doubles[:default])
           result = doub.process(targets, command, options)
@@ -61,7 +61,7 @@ module BoltSpec
         result
       end
 
-      def run_script(targets, script_path, arguments, options = {})
+      def run_script(targets, script_path, arguments, options = {}, _position = [])
         script = module_file_id(script_path)
         result = nil
         if (doub = @script_doubles[script] || @script_doubles[:default])
@@ -76,7 +76,7 @@ module BoltSpec
         result
       end
 
-      def run_task(targets, task, arguments, options = {})
+      def run_task(targets, task, arguments, options = {}, _position = [])
         result = nil
         if (doub = @task_doubles[task.name] || @task_doubles[:default])
           result = doub.process(targets, task.name, arguments, options)
@@ -90,7 +90,7 @@ module BoltSpec
         result
       end
 
-      def download_file(targets, source, destination, options = {})
+      def download_file(targets, source, destination, options = {}, _position = [])
         result = nil
         if (doub = @download_doubles[source] || @download_doubles[:default])
           result = doub.process(targets, source, destination, options)
@@ -103,7 +103,7 @@ module BoltSpec
         result
       end
 
-      def upload_file(targets, source_path, destination, options = {})
+      def upload_file(targets, source_path, destination, options = {}, _position = [])
         source = module_file_id(source_path)
         result = nil
         if (doub = @upload_doubles[source] || @upload_doubles[:default])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 2.32.0
+  version: 2.33.1
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2020-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -438,6 +438,7 @@ files:
 - bolt-modules/system/lib/puppet/functions/system/env.rb
 - exe/bolt
 - guides/inventory.txt
+- guides/logging.txt
 - guides/module.txt
 - guides/modulepath.txt
 - guides/project.txt
@@ -597,7 +598,6 @@ files:
 - modules/canary/lib/puppet/functions/canary/skip.rb
 - modules/canary/plans/init.pp
 - modules/puppetdb_fact/plans/init.pp
-- modules/secure_env_vars/plans/init.pp
 homepage: https://github.com/puppetlabs/bolt
 licenses:
 - Apache-2.0

data/modules/secure_env_vars/plans/init.pp

@@ -1,20 +0,0 @@
-plan secure_env_vars(
-  TargetSpec $targets,
-  Optional[String] $command = undef,
-  Optional[String] $script = undef
-) {
-  $env_vars = parsejson(system::env('BOLT_ENV_VARS'))
-  unless type($command) == Undef or type($script) == Undef {
-      fail_plan('Cannot specify both script and command for secure_env_vars')
-  }
-
-  return if $command {
-           run_command($command, $targets, '_env_vars' => $env_vars)
-         }
-         elsif $script {
-           run_script($script, $targets, '_env_vars' => $env_vars)
-         }
-         else {
-           fail_plan('Must specify either script or command for secure_env_vars')
-         }
-}