bolt 1.32.0 → 1.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40fdd97c4150459a56f711d9ece1e1c0b57ff19c4e64ddb88459ea947bf4bbab
-  data.tar.gz: d2079c900a66e50d0bd9cccd17da37ab965686c6b6c9402b262f148ba2549c44
+  metadata.gz: 8529a13b894e496846dd0720d8980e98b4fa6146216089e7792e30ece43e7e17
+  data.tar.gz: 319d8cfe5375164d4c94868131a8b5a048d3b8b7b95e45e892e79a470ec4b8d9
 SHA512:
-  metadata.gz: bd59adfaa8bb6178de571eef84a08f124666ca94abb9a2a0550127ff105dc7c55e47ba789f9d09c1eae33a517dd4baaf95fce21543dc77bdedfb35c9472ffe88
-  data.tar.gz: 7f80fcb3d13a832338ab4da986d2ac25bdfbf67785f3fd863692cbd4eb018a30e7a687020c8d7c551ec1f58da9abefadbcd3976820c3d83a3c1cdfd9efb79f47
+  metadata.gz: 12b4179334e1849115a5648148193c7aab3da768061ce17b4694c35fa836ccb7184258dca2a3376e0a7bca8c9edbe1439d49f5a1f3e3a30929bd67a7ea5e0930
+  data.tar.gz: b57dc487c0ae46c76206a51f9ed27a1791595e8eab63aa9701f1dcc0785e2b52dc051900109b7f3a74d4a7d9ba1b507b879f5fca4a6b9611737e0e092588dc88

data/bolt-modules/boltlib/lib/puppet/datatypes/resultset.rb

@@ -17,6 +17,9 @@ Puppet::DataTypes.create_type('ResultSet') do
       ok_set => Callable[[], ResultSet],
       targets => Callable[[], Array[Target]],
       to_data => Callable[[], Array[Hash]],
+      '[]' => Variant[Callable[[Integer], Optional[Variant[Result, ApplyResult, Array[Variant[Result, ApplyResult]]]]],
+                      Callable[[Integer, Integer], Optional[Variant[Result, ApplyResult, Array[Variant[Result, ApplyResult]]]]]
+                     ]
     }
   PUPPET
 

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

@@ -37,18 +37,19 @@ Puppet::Functions.create_function(:run_command) do
     return_type 'ResultSet'
   end
 
-  def run_command(command, targets, options = nil)
+  def run_command(command, targets, options = {})
     run_command_with_description(command, targets, nil, options)
   end
 
-  def run_command_with_description(command, targets, description = nil, options = nil)
+  def run_command_with_description(command, targets, description = nil, options = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_command')
     end
 
-    options ||= {}
-    options = options.merge('_description' => description) if description
+    options = options.map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
+    options[:description] = description if description
+
     executor = Puppet.lookup(:bolt_executor)
     inventory = Puppet.lookup(:bolt_inventory)
 
@@ -64,7 +65,7 @@ Puppet::Functions.create_function(:run_command) do
       r = executor.run_command(targets, command, options)
     end
 
-    if !r.ok && !options['_catch_errors']
+    if !r.ok && !options[:catch_errors]
       raise Bolt::RunFailure.new(r, 'run_command', command)
     end
     r

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

@@ -8,20 +8,20 @@ require 'bolt/error'
 Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction) do
   # Run a plan
   # @param plan_name The plan to run.
-  # @param named_args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
+  # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @return [PlanResult] The result of running the plan. Undef if plan does not explicitly return results.
   # @example Run a plan
   #   run_plan('canary', 'command' => 'false', 'nodes' => $targets, '_catch_errors' => true)
   dispatch :run_plan do
     scope_param
     param 'String', :plan_name
-    optional_param 'Hash', :named_args
+    optional_param 'Hash', :args
     return_type 'Boltlib::PlanResult'
   end
 
   # Run a plan, specifying $nodes as a positional argument.
   # @param plan_name The plan to run.
-  # @param named_args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
+  # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
   # @return [PlanResult] The result of running the plan. Undef if plan does not explicitly return results.
   # @example Run a plan
@@ -30,21 +30,21 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
     scope_param
     param 'String', :plan_name
     param 'Boltlib::TargetSpec', :targets
-    optional_param 'Hash', :named_args
+    optional_param 'Hash', :args
     return_type 'Boltlib::PlanResult'
   end
 
-  def run_plan_with_targetspec(scope, plan_name, targets, named_args = {})
-    unless named_args['nodes'].nil?
+  def run_plan_with_targetspec(scope, plan_name, targets, args = {})
+    unless args['nodes'].nil?
       raise ArgumentError,
             "A plan's 'nodes' parameter may be specified as the second positional argument to " \
             "run_plan(), but in that case 'nodes' must not be specified in the named arguments " \
             "hash."
     end
-    run_plan(scope, plan_name, named_args.merge('nodes' => targets))
+    run_plan(scope, plan_name, args.merge('nodes' => targets))
   end
 
-  def run_plan(scope, plan_name, named_args = {})
+  def run_plan(scope, plan_name, args = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_plan')
@@ -52,17 +52,18 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
 
     executor = Puppet.lookup(:bolt_executor)
 
+    options, params = args.partition { |k, _v| k.start_with?('_') }.map(&:to_h)
+    options = options.map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
+
     # Bolt calls this function internally to trigger plans from the CLI. We
     # don't want to count those invocations.
-    unless named_args['_bolt_api_call']
+    unless options[:bolt_api_call]
       executor.report_function_call(self.class.name)
     end
 
     # Report bundled content, this should capture plans run from both CLI and Plans
     executor.report_bundled_content('Plan', plan_name)
 
-    params = named_args.reject { |k, _| k.start_with?('_') }
-
     loaders = closure_scope.compiler.loaders
     # The perspective of the environment is wanted here (for now) to not have to
     # require modules to have dependencies defined in meta data.
@@ -73,7 +74,7 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
       raise Bolt::Error.unknown_plan(plan_name)
     end
 
-    if (run_as = named_args['_run_as'])
+    if (run_as = options[:run_as])
       old_run_as = executor.run_as
       executor.run_as = run_as
     end
@@ -118,7 +119,7 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
 
         result
       rescue Puppet::PreformattedError => e
-        if named_args['_catch_errors'] && e.cause.is_a?(Bolt::Error)
+        if options[:catch_errors] && e.cause.is_a?(Bolt::Error)
           result = e.cause.to_puppet_error
         else
           raise e

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

@@ -43,18 +43,20 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     return_type 'ResultSet'
   end
 
-  def run_script(scope, script, targets, options = nil)
+  def run_script(scope, script, targets, options = {})
     run_script_with_description(scope, script, targets, nil, options)
   end
 
-  def run_script_with_description(scope, script, targets, description = nil, options = nil)
+  def run_script_with_description(scope, script, targets, description = nil, options = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_script')
     end
 
-    options ||= {}
-    options = options.merge('_description' => description) if description
+    arguments = options['arguments'] || []
+    options = options.select { |opt| opt.start_with?('_') }.map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
+    options[:description] = description if description
+
     executor = Puppet.lookup(:bolt_executor)
     inventory = Puppet.lookup(:bolt_inventory)
 
@@ -78,10 +80,10 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     r = if targets.empty?
           Bolt::ResultSet.new([])
         else
-          executor.run_script(targets, found, options['arguments'] || [], options.reject { |k, _| k == 'arguments' })
+          executor.run_script(targets, found, arguments, options)
         end
 
-    if !r.ok && !options['_catch_errors']
+    if !r.ok && !options[:catch_errors]
       raise Bolt::RunFailure.new(r, 'run_script', script)
     end
     r

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

@@ -12,14 +12,14 @@ Puppet::Functions.create_function(:run_task) do
   # Run a task.
   # @param task_name The task to run.
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
-  # @param task_args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
+  # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @return A list of results, one entry per target.
   # @example Run a task as root
   #   run_task('facts', $targets, '_run_as' => 'root')
   dispatch :run_task do
     param 'String[1]', :task_name
     param 'Boltlib::TargetSpec', :targets
-    optional_param 'Hash[String[1], Any]', :task_args
+    optional_param 'Hash[String[1], Any]', :args
     return_type 'ResultSet'
   end
 
@@ -27,7 +27,7 @@ Puppet::Functions.create_function(:run_task) do
   # @param task_name The task to run.
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
   # @param description A description to be output when calling this function.
-  # @param task_args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
+  # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @return A list of results, one entry per target.
   # @example Run a task
   #   run_task('facts', $targets, 'Gather OS facts')
@@ -35,27 +35,29 @@ Puppet::Functions.create_function(:run_task) do
     param 'String[1]', :task_name
     param 'Boltlib::TargetSpec', :targets
     param 'Optional[String]', :description
-    optional_param 'Hash[String[1], Any]', :task_args
+    optional_param 'Hash[String[1], Any]', :args
     return_type 'ResultSet'
   end
 
-  def run_task(task_name, targets, task_args = nil)
-    run_task_with_description(task_name, targets, nil, task_args)
+  def run_task(task_name, targets, args = {})
+    run_task_with_description(task_name, targets, nil, args)
   end
 
-  def run_task_with_description(task_name, targets, description, task_args = nil)
+  def run_task_with_description(task_name, targets, description, args = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_task')
     end
 
-    task_args ||= {}
+    options, params = args.partition { |k, _v| k.start_with?('_') }.map(&:to_h)
+    options = options.map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
+
     executor = Puppet.lookup(:bolt_executor)
     inventory = Puppet.lookup(:bolt_inventory)
 
     # Bolt calls this function internally to trigger tasks from the CLI. We
     # don't want to count those invocations.
-    unless task_args['_bolt_api_call']
+    unless options[:bolt_api_call]
       executor.report_function_call(self.class.name)
     end
 
@@ -65,9 +67,7 @@ Puppet::Functions.create_function(:run_task) do
     # Ensure that given targets are all Target instances
     targets = inventory.get_targets(targets)
 
-    options, use_args = task_args.partition { |k, _| k.start_with?('_') }.map(&:to_h)
-
-    options['_description'] = description if description
+    options[:description] = description if description
 
     # Don't bother loading the local task definition if all targets use the 'pcp' transport.
     if !targets.empty? && targets.all? { |t| t.transport == 'pcp' }
@@ -80,37 +80,37 @@ Puppet::Functions.create_function(:run_task) do
         raise Bolt::Error.unknown_task(task_name)
       end
 
-      task_signature.runnable_with?(use_args) do |mismatch_message|
+      task_signature.runnable_with?(params) do |mismatch_message|
         raise with_stack(:TYPE_MISMATCH, mismatch_message)
       end || (raise with_stack(:TYPE_MISMATCH, 'Task parameters do not match'))
 
       task = Bolt::Task.new(task_signature.task_hash)
     end
 
-    unless Puppet::Pops::Types::TypeFactory.data.instance?(use_args)
+    unless Puppet::Pops::Types::TypeFactory.data.instance?(params)
       # generate a helpful error message about the type-mismatch between the type Data
-      # and the actual type of use_args
-      use_args_t = Puppet::Pops::Types::TypeCalculator.infer_set(use_args)
+      # and the actual type of params
+      params_t = Puppet::Pops::Types::TypeCalculator.infer_set(params)
       desc = Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch(
         'Task parameters are not of type Data. run_task()',
-        Puppet::Pops::Types::TypeFactory.data, use_args_t
+        Puppet::Pops::Types::TypeFactory.data, params_t
       )
       raise with_stack(:TYPE_NOT_DATA, desc)
     end
 
     # Wrap parameters marked with '"sensitive": true' in the task metadata with a
     # Sensitive wrapper type. This way it's not shown in logs.
-    if (params = task.parameters)
-      use_args.each do |k, v|
-        if params[k] && params[k]['sensitive']
-          use_args[k] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(v)
+    if (param_spec = task.parameters)
+      params.each do |k, v|
+        if param_spec[k] && param_spec[k]['sensitive']
+          params[k] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(v)
         end
       end
     end
 
     if executor.noop
       if task.supports_noop
-        use_args['_noop'] = true
+        params['_noop'] = true
       else
         raise with_stack(:TASK_NO_NOOP, 'Task does not support noop')
       end
@@ -119,8 +119,8 @@ Puppet::Functions.create_function(:run_task) do
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      result = executor.run_task(targets, task, use_args, options)
-      if !result.ok && !task_args['_catch_errors']
+      result = executor.run_task(targets, task, params, options)
+      if !result.ok && !options[:catch_errors]
         raise Bolt::RunFailure.new(result, 'run_task', task_name)
       end
       result

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

@@ -47,18 +47,19 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
     return_type 'ResultSet'
   end
 
-  def upload_file(scope, source, destination, targets, options = nil)
+  def upload_file(scope, source, destination, targets, options = {})
     upload_file_with_description(scope, source, destination, targets, nil, options)
   end
 
-  def upload_file_with_description(scope, source, destination, targets, description = nil, options = nil)
+  def upload_file_with_description(scope, source, destination, targets, description = nil, options = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'upload_file')
     end
 
-    options ||= {}
-    options = options.merge('_description' => description) if description
+    options = options.select { |opt| opt.start_with?('_') }.map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
+    options[:description] = description if description
+
     executor = Puppet.lookup(:bolt_executor)
     inventory = Puppet.lookup(:bolt_inventory)
 
@@ -80,7 +81,7 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
       r = executor.upload_file(targets, found, destination, options)
     end
 
-    if !r.ok && !options['_catch_errors']
+    if !r.ok && !options[:catch_errors]
       raise Bolt::RunFailure.new(r, 'upload_file', source)
     end
     r

data/lib/bolt/applicator.rb

@@ -81,7 +81,7 @@ module Bolt
     end
 
     def compile(target, ast, plan_vars)
-      trusted = Puppet::Context::TrustedInformation.new('local', target.host, {})
+      trusted = Puppet::Context::TrustedInformation.new('local', target.name, {})
       facts = @inventory.facts(target).merge('bolt' => true)
 
       catalog_input = {
@@ -90,7 +90,7 @@ module Bolt
         pdb_config: @pdb_client.config.to_hash,
         hiera_config: @hiera_config,
         target: {
-          name: target.host,
+          name: target.name,
           facts: facts,
           variables: @inventory.vars(target).merge(plan_vars),
           trusted: trusted.to_h
@@ -150,7 +150,7 @@ module Bolt
       if args.count > 1
         type1 = Puppet.lookup(:pal_script_compiler).type('Hash[String, Data]')
         Puppet::Pal.assert_type(type1, args[1], 'apply options')
-        options = args[1]
+        options = args[1].map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
       end
 
       # collect plan vars and merge them over target vars
@@ -196,7 +196,7 @@ module Bolt
                 'catalog' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(catalog),
                 'plugins' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(plugins),
                 '_task' => catalog_apply_task.name,
-                '_noop' => options['_noop']
+                '_noop' => options[:noop]
               }
 
               callback = proc do |event|
@@ -206,7 +206,8 @@ module Bolt
                 @executor.publish_event(event)
               end
               # Respect the run_as default set on the executor
-              options = { '_run_as' => @executor.run_as }.merge(options) if @executor.run_as
+              options[:run_as] = @executor.run_as if @executor.run_as && !options.key?(:run_as)
+
               results = transport.batch_task(batch, catalog_apply_task, arguments, options, &callback)
               Array(results).map { |result| ApplyResult.from_task_result(result) }
             end
@@ -220,7 +221,7 @@ module Bolt
       resource_counts = r.ok_set.map { |result| result.event_metrics&.fetch('total') }.compact
       @executor.report_apply(count_statements(raw_ast), resource_counts)
 
-      if !r.ok && !options['_catch_errors']
+      if !r.ok && !options[:catch_errors]
         raise Bolt::ApplyFailure, r
       end
       r

data/lib/bolt/cli.rb

@@ -341,7 +341,7 @@ module Bolt
 
         elapsed_time = Benchmark.realtime do
           executor_opts = {}
-          executor_opts['_description'] = options[:description] if options.key?(:description)
+          executor_opts[:description] = options[:description] if options.key?(:description)
           executor.subscribe(outputter)
           executor.subscribe(log_outputter)
           results =
@@ -462,7 +462,7 @@ module Bolt
         end
 
         results = pal.with_bolt_executor(executor, inventory, puppetdb_client) do
-          Puppet.lookup(:apply_executor).apply_ast(ast, targets, '_catch_errors' => true, '_noop' => noop)
+          Puppet.lookup(:apply_executor).apply_ast(ast, targets, catch_errors: true, noop: noop)
         end
       end
 

data/lib/bolt/executor.rb

@@ -218,16 +218,16 @@ module Bolt
     end
 
     def with_node_logging(description, batch)
-      @logger.info("#{description} on #{batch.map(&:uri)}")
+      @logger.info("#{description} on #{batch.map(&:safe_name)}")
       result = yield
       @logger.info(result.to_json)
       result
     end
 
     def run_command(targets, command, options = {})
-      description = options.fetch('_description', "command '#{command}'")
+      description = options.fetch(:description, "command '#{command}'")
       log_action(description, targets) do
-        options = { '_run_as' => run_as }.merge(options) if run_as
+        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
@@ -238,9 +238,9 @@ module Bolt
     end
 
     def run_script(targets, script, arguments, options = {})
-      description = options.fetch('_description', "script #{script}")
+      description = options.fetch(:description, "script #{script}")
       log_action(description, targets) do
-        options = { '_run_as' => run_as }.merge(options) if run_as
+        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
@@ -251,9 +251,9 @@ module Bolt
     end
 
     def run_task(targets, task, arguments, options = {})
-      description = options.fetch('_description', "task #{task.name}")
+      description = options.fetch(:description, "task #{task.name}")
       log_action(description, targets) do
-        options = { '_run_as' => run_as }.merge(options) if run_as
+        options[:run_as] = run_as if run_as && !options.key?(:run_as)
         arguments['_task'] = task.name
 
         batch_execute(targets) do |transport, batch|
@@ -265,9 +265,9 @@ module Bolt
     end
 
     def upload_file(targets, source, destination, options = {})
-      description = options.fetch('_description', "file upload from #{source} to #{destination}")
+      description = options.fetch(:description, "file upload from #{source} to #{destination}")
       log_action(description, targets) do
-        options = { '_run_as' => run_as }.merge(options) if run_as
+        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

data/lib/bolt/outputter/human.rb

@@ -73,14 +73,14 @@ module Bolt
       end
 
       def print_start(target)
-        @stream.puts(colorize(:green, "Started on #{target.host}..."))
+        @stream.puts(colorize(:green, "Started on #{target.safe_name}..."))
       end
 
       def print_result(result)
         if result.success?
-          @stream.puts(colorize(:green, "Finished on #{result.target.host}:"))
+          @stream.puts(colorize(:green, "Finished on #{result.target.safe_name}:"))
         else
-          @stream.puts(colorize(:red, "Failed on #{result.target.host}:"))
+          @stream.puts(colorize(:red, "Failed on #{result.target.safe_name}:"))
         end
 
         if result.error_hash
@@ -170,7 +170,7 @@ module Bolt
           @stream.puts format('Successful on %<size>d node%<plural>s: %<names>s',
                               size: ok_set.size,
                               plural: ok_set.size == 1 ? '' : 's',
-                              names: ok_set.names.join(','))
+                              names: ok_set.targets.map(&:safe_name).join(','))
         end
 
         error_set = results.error_set
@@ -179,7 +179,7 @@ module Bolt
                                 format('Failed on %<size>d node%<plural>s: %<names>s',
                                        size: error_set.size,
                                        plural: error_set.size == 1 ? '' : 's',
-                                       names: error_set.names.join(',')))
+                                       names: error_set.targets.map(&:safe_name).join(',')))
         end
 
         total_msg = format('Ran on %<size>d node%<plural>s',

data/lib/bolt/plugin.rb

@@ -143,11 +143,12 @@ module Bolt
       @analytics = analytics
       @plugin_context = PluginContext.new(config, pal)
       @plugins = {}
+      @pal = pal
       @unknown = Set.new
     end
 
     def modules
-      @modules ||= Bolt::Module.discover(@config.modulepath)
+      @modules ||= Bolt::Module.discover(@pal.modulepath)
     end
 
     # Generally this is private. Puppetdb is special though

data/lib/bolt/plugin/module.rb

@@ -164,7 +164,7 @@ module Bolt
         params = params.merge(metaparams)
 
         # There are no executor options to pass now.
-        options = { "_catch_errors" => true }
+        options = { catch_errors: true }
 
         result = @context.run_local_task(task,
                                          params,

data/lib/bolt/plugin/pkcs7.rb

@@ -39,7 +39,7 @@ module Bolt
 
       def private_key_path
         path = @options['private-key'] || 'keys/private_key.pkcs7.pem'
-        path = File.absolute_path(path, boltdir)
+        path = File.expand_path(path, boltdir)
         @logger.debug("Using private-key: #{path}")
         path
       end
@@ -50,7 +50,7 @@ module Bolt
 
       def public_key_path
         path = @options['public-key'] || 'keys/public_key.pkcs7.pem'
-        path = File.absolute_path(path, boltdir)
+        path = File.expand_path(path, boltdir)
         @logger.debug("Using public-key: #{path}")
         path
       end

data/lib/bolt/plugin/task.rb

@@ -19,7 +19,7 @@ module Bolt
 
       def run_task(opts)
         params = opts['parameters'] || {}
-        options = { '_catch_errors' => true }
+        options = { catch_errors: true }
 
         raise Bolt::ValidationError, "Task plugin requires that the 'task' is specified" unless opts['task']
         task = @context.get_validated_task(opts['task'], params)

data/lib/bolt/result_set.rb

@@ -106,5 +106,13 @@ module Bolt
     def ==(other)
       eql?(other)
     end
+
+    def [](from, up_to = nil)
+      if up_to
+        @results[from..up_to]
+      else
+        @results[from]
+      end
+    end
   end
 end

data/lib/bolt/target.rb

@@ -147,6 +147,11 @@ module Bolt
       Addressable::URI.unencode_component(component)
     end
     private :unencode
+
+    def eql?(other)
+      self.class.equal?(other.class) && @name == other.name
+    end
+    alias == eql?
   end
 
   class Target
@@ -247,13 +252,10 @@ module Bolt
     # should we just compare names? is there something else that is meaninful?
     def eql?(other)
       if self.class.equal?(other.class)
-        if @uri
-          return @uri == other.uri
-        else
-          @name = other.name
-        end
+        @uri ? @uri == other.uri : @name == other.name
+      else
+        false
       end
-      false
     end
     alias == eql?
 
@@ -281,6 +283,7 @@ module Bolt
     def host
       @uri_obj&.hostname || @host
     end
+    alias safe_name host
 
     def name
       @name || @uri

data/lib/bolt/task/run.rb

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

data/lib/bolt/transport/base.rb

@@ -125,7 +125,7 @@ module Bolt
         assert_batch_size_one("batch_task()", targets)
         target = targets.first
         with_events(target, callback) do
-          @logger.debug { "Running task run '#{task}' on #{target.uri}" }
+          @logger.debug { "Running task run '#{task}' on #{target.safe_name}" }
           run_task(target, task, arguments, options)
         end
       end
@@ -139,7 +139,7 @@ module Bolt
         assert_batch_size_one("batch_command()", targets)
         target = targets.first
         with_events(target, callback) do
-          @logger.debug("Running command '#{command}' on #{target.uri}")
+          @logger.debug("Running command '#{command}' on #{target.safe_name}")
           run_command(target, command, options)
         end
       end
@@ -153,7 +153,7 @@ module Bolt
         assert_batch_size_one("batch_script()", targets)
         target = targets.first
         with_events(target, callback) do
-          @logger.debug { "Running script '#{script}' on #{target.uri}" }
+          @logger.debug { "Running script '#{script}' on #{target.safe_name}" }
           run_script(target, script, arguments, options)
         end
       end
@@ -167,7 +167,7 @@ module Bolt
         assert_batch_size_one("batch_upload()", targets)
         target = targets.first
         with_events(target, callback) do
-          @logger.debug { "Uploading: '#{source}' to #{destination} on #{target.uri}" }
+          @logger.debug { "Uploading: '#{source}' to #{destination} on #{target.safe_name}" }
           upload(target, source, destination, options)
         end
       end

data/lib/bolt/transport/docker/connection.rb

@@ -8,9 +8,9 @@ module Bolt
     class Docker < Base
       class Connection
         def initialize(target)
-          raise Bolt::ValidationError, "Target #{target.name} does not have a host" unless target.host
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
           @target = target
-          @logger = Logging.logger[target.host]
+          @logger = Logging.logger[target.safe_name]
           @docker_host = @target.options['service-url']
         end
 
@@ -28,7 +28,7 @@ module Bolt
           true
         rescue StandardError => e
           raise Bolt::Node::ConnectError.new(
-            "Failed to connect to #{@target.uri}: #{e.message}",
+            "Failed to connect to #{@target.safe_name}: #{e.message}",
             'CONNECT_ERROR'
           )
         end
@@ -79,6 +79,7 @@ module Bolt
         end
 
         def write_remote_file(source, destination)
+          @logger.debug { "Uploading #{source}, to #{destination}" }
           _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
           raise "Error writing file to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
         rescue StandardError => e
@@ -86,6 +87,7 @@ module Bolt
         end
 
         def write_remote_directory(source, destination)
+          @logger.debug { "Uploading #{source}, to #{destination}" }
           _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
           raise "Error writing directory to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
         rescue StandardError => e

data/lib/bolt/transport/local/shell.rb

@@ -73,6 +73,7 @@ module Bolt
         end
 
         def copy_file(source, dest)
+          @logger.debug { "Uploading #{source}, to #{dest}" }
           if source.is_a?(StringIO)
             File.open("tempfile", "w") { |f| f.write(source.read) }
             execute(['mv', 'tempfile', dest])

data/lib/bolt/transport/local_windows.rb

@@ -27,7 +27,7 @@ module Bolt
 
       def self.validate(options)
         logger = Logging.logger[self]
-        if options['sudo-password'] || options['run-as'] || options['run-as-command'] || options['_run_as']
+        if options['sudo-password'] || options['run-as'] || options['run-as-command'] || options[:run_as]
           logger.warn("run-as is not supported for Windows hosts using the local transport")
         end
       end
@@ -47,6 +47,7 @@ module Bolt
       private :in_tmpdir
 
       def copy_file(source, destination)
+        logger.debug { "Uploading #{source}, to #{destination}" }
         FileUtils.cp_r(source, destination, remove_destination: true)
       rescue StandardError => e
         raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')

data/lib/bolt/transport/orch.rb

@@ -81,7 +81,7 @@ module Bolt
               target,
               value: { '_error' => {
                 'kind' => 'puppetlabs.tasks/skipped-node',
-                'msg' => "Node #{target.host} was skipped",
+                'msg' => "Node #{target.safe_name} was skipped",
                 'details' => {}
               } },
               action: 'task', object: task_name

data/lib/bolt/transport/orch/connection.rb

@@ -78,7 +78,7 @@ module Bolt
         end
 
         def run_task(targets, task, arguments, options)
-          body = build_request(targets, task, arguments, options['_description'])
+          body = build_request(targets, task, arguments, options[:description])
           @client.run_task(body)
         end
 

data/lib/bolt/transport/ssh.rb

@@ -73,7 +73,7 @@ module Bolt
         begin
           conn&.disconnect
         rescue StandardError => e
-          logger.info("Failed to close connection to #{target.uri} : #{e.message}")
+          logger.info("Failed to close connection to #{target.safe_name} : #{e.message}")
         end
       end
 

data/lib/bolt/transport/ssh/connection.rb

@@ -19,7 +19,7 @@ module Bolt
           require 'net/ssh'
           require 'net/ssh/proxy/jump'
 
-          raise Bolt::ValidationError, "Target #{target.name} does not have a host" unless target.host
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
           @sudo_id = SecureRandom.uuid
 
           @target = target
@@ -30,7 +30,7 @@ module Bolt
           @run_as = nil
           @strict_host_key_checking = ssh_config[:strict_host_key_checking]
 
-          @logger = Logging.logger[@target.host]
+          @logger = Logging.logger[@target.safe_name]
           @transport_logger = transport_logger
 
           if target.options['private-key']&.instance_of?(String)
@@ -119,17 +119,17 @@ module Bolt
           )
         rescue Net::SSH::HostKeyError => e
           raise Bolt::Node::ConnectError.new(
-            "Host key verification failed for #{target.uri}: #{e.message}",
+            "Host key verification failed for #{target.safe_name}: #{e.message}",
             'HOST_KEY_ERROR'
           )
         rescue Net::SSH::ConnectionTimeout
           raise Bolt::Node::ConnectError.new(
-            "Timeout after #{target.options['connect-timeout']} seconds connecting to #{target.uri}",
+            "Timeout after #{target.options['connect-timeout']} seconds connecting to #{target.safe_name}",
             'CONNECT_ERROR'
           )
         rescue StandardError => e
           raise Bolt::Node::ConnectError.new(
-            "Failed to connect to #{target.uri}: #{e.message}",
+            "Failed to connect to #{target.safe_name}: #{e.message}",
             'CONNECT_ERROR'
           )
         end
@@ -155,7 +155,7 @@ module Bolt
               # Cancel the sudo prompt to prevent later commands getting stuck
               channel.close
               raise Bolt::Node::EscalateError.new(
-                "Sudo password for user #{@user} was not provided for #{target.uri}",
+                "Sudo password for user #{@user} was not provided for #{target.safe_name}",
                 'NO_PASSWORD'
               )
             end
@@ -168,13 +168,13 @@ module Bolt
           elsif data =~ /^#{@user} is not in the sudoers file\./
             @logger.debug { data }
             raise Bolt::Node::EscalateError.new(
-              "User #{@user} does not have sudo permission on #{target.uri}",
+              "User #{@user} does not have sudo permission on #{target.safe_name}",
               'SUDO_DENIED'
             )
           elsif data =~ /^Sorry, try again\./
             @logger.debug { data }
             raise Bolt::Node::EscalateError.new(
-              "Sudo password for user #{@user} not recognized on #{target.uri}",
+              "Sudo password for user #{@user} not recognized on #{target.safe_name}",
               'BAD_PASSWORD'
             )
           end
@@ -261,18 +261,13 @@ module Bolt
         end
 
         def copy_file(source, destination)
+          # Do not log wrapper script content
+          @logger.debug { "Uploading #{source}, to #{destination}" } unless source.is_a?(StringIO)
           @session.scp.upload!(source, destination, recursive: true)
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
-        def write_executable_from_content(dest, content, filename)
-          remote_path = File.join(dest.to_s, filename)
-          @session.scp.upload!(StringIO.new(content), remote_path)
-          make_executable(remote_path)
-          remote_path
-        end
-
         # This handles renaming Net::SSH verifiers between version 4.x and 5.x
         # of the gem
         def net_ssh_verifier(verifier)

data/lib/bolt/transport/sudoable.rb

@@ -19,7 +19,7 @@ module Bolt
 
       def run_command(target, command, options = {})
         with_connection(target) do |conn|
-          conn.running_as(options['_run_as']) do
+          conn.running_as(options[:run_as]) do
             output = conn.execute(command, sudoable: true)
             Bolt::Result.for_command(target,
                                      output.stdout.string,
@@ -32,7 +32,7 @@ module Bolt
 
       def upload(target, source, destination, options = {})
         with_connection(target) do |conn|
-          conn.running_as(options['_run_as']) do
+          conn.running_as(options[:run_as]) do
             conn.with_tempdir do |dir|
               basename = File.basename(destination)
               tmpfile = File.join(dir.to_s, basename)
@@ -55,7 +55,7 @@ module Bolt
         arguments = unwrap_sensitive_args(arguments)
 
         with_connection(target) do |conn|
-          conn.running_as(options['_run_as']) do
+          conn.running_as(options[:run_as]) do
             conn.with_tempdir do |dir|
               path = conn.write_executable(dir.to_s, script)
               dir.chown(conn.run_as)
@@ -77,7 +77,7 @@ module Bolt
         extra_files = implementation['files']
 
         with_connection(target) do |conn|
-          conn.running_as(options['_run_as']) do
+          conn.running_as(options[:run_as]) do
             stdin, output = nil
             execute_options = {}
             execute_options[:interpreter] = select_interpreter(executable, target.options['interpreters'])

data/lib/bolt/transport/sudoable/connection.rb

@@ -10,7 +10,7 @@ module Bolt
         def initialize(target)
           @target = target
           @run_as = nil
-          @logger = Logging.logger[@target.host]
+          @logger = Logging.logger[@target.safe_name]
         end
 
         # This method allows the @run_as variable to be used as a per-operation

data/lib/bolt/transport/winrm.rb

@@ -75,7 +75,7 @@ module Bolt
         begin
           conn&.disconnect
         rescue StandardError => e
-          logger.info("Failed to close connection to #{target.uri} : #{e.message}")
+          logger.info("Failed to close connection to #{target.safe_name} : #{e.message}")
         end
       end
 

data/lib/bolt/transport/winrm/connection.rb

@@ -12,7 +12,7 @@ module Bolt
         DEFAULT_EXTENSIONS = ['.ps1', '.rb', '.pp'].freeze
 
         def initialize(target, transport_logger)
-          raise Bolt::ValidationError, "Target #{target.name} does not have a host" unless target.host
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
           @target = target
 
           default_port = target.options['ssl'] ? HTTPS_PORT : HTTP_PORT
@@ -23,7 +23,7 @@ module Bolt
           extensions += target.options['interpreters'].keys if target.options['interpreters']
           @extensions = DEFAULT_EXTENSIONS.to_set.merge(extensions)
 
-          @logger = Logging.logger[@target.host]
+          @logger = Logging.logger[@target.safe_name]
           @transport_logger = transport_logger
         end
 
@@ -148,6 +148,7 @@ module Bolt
         end
 
         def write_remote_file(source, destination)
+          @logger.debug { "Uploading #{source}, to #{destination}" }
           if target.options['file-protocol'] == 'smb'
             write_remote_file_smb(source, destination)
           else
@@ -223,13 +224,6 @@ module Bolt
           remote_path
         end
 
-        def write_executable_from_content(dir, content, filename)
-          validate_extensions(File.extname(filename))
-          remote_path = "#{dir}\\#{filename}"
-          write_remote_file(content, remote_path)
-          remote_path
-        end
-
         private
 
         def smb_client_login
@@ -243,12 +237,12 @@ module Bolt
             @logger.debug { "Connected to #{@client.dns_host_name}" }
           when WindowsError::NTStatus::STATUS_LOGON_FAILURE
             raise Bolt::Node::ConnectError.new(
-              "SMB authentication failed for #{target.host}",
+              "SMB authentication failed for #{target.safe_name}",
               'AUTH_ERROR'
             )
           else
             raise Bolt::Node::ConnectError.new(
-              "Failed to connect to #{target.host} using SMB: #{status.description}",
+              "Failed to connect to #{target.safe_name} using SMB: #{status.description}",
               'CONNECT_ERROR'
             )
           end
@@ -267,12 +261,12 @@ module Bolt
         rescue Errno::ECONNREFUSED => e
           # handle this to prevent obscuring error message as SMB problem
           raise Bolt::Node::ConnectError.new(
-            "Failed to connect to #{target.host} using SMB: #{e.message}",
+            "Failed to connect to #{target.safe_name} using SMB: #{e.message}",
             'CONNECT_ERROR'
           )
         rescue Timeout::Error
           raise Bolt::Node::ConnectError.new(
-            "Timeout after #{target.options['connect-timeout']} seconds connecting to #{target.host}",
+            "Timeout after #{target.options['connect-timeout']} seconds connecting to #{target.safe_name}",
             'CONNECT_ERROR'
           )
         end

data/lib/bolt/version.rb

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

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

@@ -35,7 +35,8 @@ module BoltSpec
       # Public methods
 
       def with_params(params)
-        @invocation[:options] = params
+        @invocation[:options] = params.select { |k, _v| k.start_with?('_') }
+                                      .map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
         self
       end
     end

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

@@ -44,6 +44,7 @@ module BoltSpec
         @invocation[:params] = params
         @invocation[:arguments] = params['arguments']
         @invocation[:options] = params.select { |k, _v| k.start_with?('_') }
+                                      .map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
         self
       end
     end

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

@@ -46,6 +46,7 @@ module BoltSpec
         @invocation[:params] = params
         @invocation[:arguments] = params.reject { |k, _v| k.start_with?('_') }
         @invocation[:options] = params.select { |k, _v| k.start_with?('_') }
+                                      .map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
         self
       end
     end

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

@@ -56,7 +56,8 @@ module BoltSpec
       end
 
       def with_params(params)
-        @invocation[:options] = params
+        @invocation[:options] = params.select { |k, _v| k.start_with?('_') }
+                                      .map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
         self
       end
     end

data/lib/bolt_spec/run.rb

@@ -202,7 +202,7 @@ module BoltSpec
         end
 
         pal.with_bolt_executor(executor, inventory, puppetdb_client) do
-          Puppet.lookup(:apply_executor).apply_ast(ast, targets, '_catch_errors' => true, '_noop' => noop)
+          Puppet.lookup(:apply_executor).apply_ast(ast, targets, catch_errors: true, noop: noop)
         end
       end
     end

data/lib/plan_executor/executor.rb

@@ -79,7 +79,7 @@ module PlanExecutor
     end
 
     def run_command(targets, command, options = {})
-      description = options.fetch('_description', "command '#{command}'")
+      description = options.fetch(:description, "command '#{command}'")
       log_action(description, targets) do
         results = as_resultset(targets) do
           @orch_client.run_command(targets, command, options)
@@ -90,7 +90,7 @@ module PlanExecutor
     end
 
     def run_script(targets, script, arguments, options = {})
-      description = options.fetch('_description', "script #{script}")
+      description = options.fetch(:description, "script #{script}")
       log_action(description, targets) do
         results = as_resultset(targets) do
           @orch_client.run_script(targets, script, arguments, options)
@@ -101,7 +101,7 @@ module PlanExecutor
     end
 
     def run_task(targets, task, arguments, options = {})
-      description = options.fetch('_description', "task #{task.name}")
+      description = options.fetch(:description, "task #{task.name}")
       log_action(description, targets) do
         arguments['_task'] = task.name
 
@@ -114,7 +114,7 @@ module PlanExecutor
     end
 
     def upload_file(targets, source, destination, options = {})
-      description = options.fetch('_description', "file upload from #{source} to #{destination}")
+      description = options.fetch(:description, "file upload from #{source} to #{destination}")
       log_action(description, targets) do
         results = as_resultset(targets) do
           @orch_client.file_upload(targets, source, destination, options)

data/lib/plan_executor/orch_client.rb

@@ -61,7 +61,7 @@ module PlanExecutor
     end
 
     def send_request(targets, task, arguments, options = {})
-      description = options['_description']
+      description = options[:description]
       body = { task: task.name,
                environment: @environment,
                noop: arguments['_noop'],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.32.0
+  version: 1.33.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-03 00:00:00.000000000 Z
+date: 2019-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable