bolt 2.31.0 → 2.35.0

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

@@ -11,7 +11,7 @@ module Bolt
       def initialize(target, conn)
         super
 
-        extensions = [target.options['extensions'] || []].flatten.map { |ext| ext[0] != '.' ? '.' + ext : ext }
+        extensions = [target.options['extensions'] || []].flatten.map { |ext| ext[0] == '.' ? ext : '.' + ext }
         extensions += target.options['interpreters'].keys if target.options['interpreters']
         @extensions = DEFAULT_EXTENSIONS + extensions
       end
@@ -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/task/run.rb

@@ -42,7 +42,7 @@ module Bolt
         if targets.empty?
           Bolt::ResultSet.new([])
         else
-          result = executor.run_task(targets, task, params, options)
+          result = executor.run_task_with_minimal_logging(targets, task, params, options)
 
           if !result.ok && !options[:catch_errors]
             raise Bolt::RunFailure.new(result, 'run_task', task.name)

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

@@ -10,11 +10,6 @@ require 'bolt/transport/orch/connection'
 module Bolt
   module Transport
     class Orch < Base
-      CONF_FILE = if !ENV['HOME'].nil?
-                    File.expand_path('~/.puppetlabs/client-tools/orchestrator.conf')
-                  else
-                    '/etc/puppetlabs/client-tools/orchestrator.conf'
-                  end
       BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
       BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
       BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
@@ -53,7 +48,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 +58,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 +94,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 +103,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 +116,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 +157,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 +173,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 +202,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 +212,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 +224,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 +250,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