bolt 2.29.0 → 2.33.2

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']
@@ -143,12 +147,13 @@ module Bolt
 
             execute_options[:stdin] = stdin
             execute_options[:sudoable] = true if run_as
-            output = execute(remote_task_path, execute_options)
+            output = execute(remote_task_path, **execute_options)
           end
           Bolt::Result.for_task(target, output.stdout.string,
                                 output.stderr.string,
                                 output.exit_code,
-                                task.name)
+                                task.name,
+                                position)
         end
       end
 
@@ -202,13 +207,14 @@ module Bolt
       end
 
       def handle_sudo_errors(err)
-        if err =~ /^#{conn.user} is not in the sudoers file\./
+        case err
+        when /^#{conn.user} is not in the sudoers file\./
           @logger.trace { err }
           raise Bolt::Node::EscalateError.new(
             "User #{conn.user} does not have sudo permission on #{target}",
             'SUDO_DENIED'
           )
-        elsif err =~ /^Sorry, try again\./
+        when /^Sorry, try again\./
           @logger.trace { err }
           raise Bolt::Node::EscalateError.new(
             "Sudo password for user #{conn.user} not recognized on #{target}",

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