bolt 2.30.0 → 2.34.0

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,10 +10,10 @@ 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
+      CONF_FILE = if ENV['HOME'].nil?
                     '/etc/puppetlabs/client-tools/orchestrator.conf'
+                  else
+                    File.expand_path('~/.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
@@ -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? })
+        arguments = arguments.merge('_target' => target.to_h.compact)
 
         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/transport/ssh/connection.rb

@@ -30,7 +30,7 @@ module Bolt
           @transport_logger = transport_logger
           @logger.trace("Initializing ssh connection to #{@target.safe_name}")
 
-          if target.options['private-key']&.instance_of?(String)
+          if target.options['private-key'].instance_of?(String)
             begin
               Bolt::Util.validate_file('ssh key', target.options['private-key'])
             rescue Bolt::FileError => e

data/lib/bolt/util.rb

@@ -273,6 +273,11 @@ module Bolt
         !!File::ALT_SEPARATOR
       end
 
+      # Returns true if running in PowerShell.
+      def powershell?
+        !!ENV['PSModulePath']
+      end
+
       # Accept hash and return hash with top level keys of type "String" converted to symbols.
       def symbolize_top_level_keys(hsh)
         hsh.each_with_object({}) { |(k, v), h| k.is_a?(String) ? h[k.to_sym] = v : h[k] = v }

data/lib/bolt/version.rb

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

data/lib/bolt_server/file_cache.rb

@@ -63,6 +63,7 @@ module BoltServer
     end
 
     def client
+      # rubocop:disable Naming/VariableNumber
       @client ||= begin
         uri = URI(@config['file-server-uri'])
         https = Net::HTTP.new(uri.host, uri.port)
@@ -75,6 +76,7 @@ module BoltServer
         https.open_timeout = @config['file-server-conn-timeout']
         https
       end
+      # rubocop:enable Naming/VariableNumber
     end
 
     def request_file(path, params, file)

data/lib/bolt_server/schemas/partials/task.json

@@ -63,9 +63,24 @@
                   "environment": {
                     "description": "Environment the task is in",
                     "type": "string"
+                  },
+                  "project": {
+                    "description": "Project the task is in",
+                    "type": "string"
                   }
                 },
-                "required": ["environment"],
+                "oneOf": [
+                  {
+                    "required": [
+                      "environment"
+                    ]
+                  },
+                  {
+                    "required": [
+                      "project"
+                    ]
+                  }
+                ],              
                 "additionalProperties": true
               }
             },
@@ -90,5 +105,5 @@
     }
   },
   "required": ["name", "files"],
-  "additionalProperties": false
+  "additionalProperties": true
 }