bolt 1.19.0 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d56ec91fb5d2a032a164f87f30ece4f103b93e3957dbff221ea775e5c52af0e1
-  data.tar.gz: cad130dc12fcba0d3fa39feb61603b9fe801373c04c62a9306958dff7bac13cd
+  metadata.gz: 12222d708d8694206992e7cb2e89271c4b94ee9a56c40800f723d4f88899ba2f
+  data.tar.gz: 8206b12db4fdd4fc2503252b1671f97f34e4870533baa244accf8b8bb94214e6
 SHA512:
-  metadata.gz: 566a3c7f134067783fb458db050eee4058c43d97ac44f87caf598589f9a6761b68e6150b65bac8cb8f63e65708d1c73a9391501244f87732ae89802f9a169302
-  data.tar.gz: c69f7762b1f76c311526ac63ed01c60d993b2b638acc84e76920fb4971edc41aec1bb7a227cc4475c35189733fe50748d9c1c556d2dd7e290d35df7bd7141f99
+  metadata.gz: eb78a8b55b5490ca241c513a4be0be6b1ab062109c1895fcdcd11bf802c9540da4cfee2625b8b080821e20d8902795e3845244669cf2b9efe2e15be102bd8662
+  data.tar.gz: ad3321dc6ab500619ddb65083e0af52ff73949fea3e0330da15d0f7c3641d08a0a7a8fd44fca7705063952a654f2ed32893520b3cdcff7bc73dcecc3e07c5d6c

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

@@ -10,6 +10,8 @@ Puppet::DataTypes.create_type('ApplyResult') do
       error => Callable[[], Optional[Error]],
       ok => Callable[[], Boolean],
       message => Callable[[], Optional[String]],
+      action => Callable[[], String],
+      to_data => Callable[[], Hash],
     }
   PUPPET
 

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

@@ -9,6 +9,8 @@ Puppet::DataTypes.create_type('Result') do
     functions => {
       error => Callable[[], Optional[Error]],
       message => Callable[[], Optional[String]],
+      action => Callable[[], String],
+      to_data => Callable[[], Hash],
       ok => Callable[[], Boolean],
       '[]' => Callable[[String[1]], Data]
     }

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

@@ -15,6 +15,7 @@ Puppet::DataTypes.create_type('ResultSet') do
       ok => Callable[[], Boolean],
       ok_set => Callable[[], ResultSet],
       targets => Callable[[], Array[Target]],
+      to_data => Callable[[], Array[Hash]],
     }
   PUPPET
 

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

@@ -23,16 +23,9 @@ Puppet::Functions.create_function(:add_facts) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_facts')
     end
 
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('add facts')
-      )
-    end
-
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    executor&.report_function_call('add_facts')
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call('add_facts')
 
     inventory.add_facts(target, facts)
   end

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

@@ -27,16 +27,9 @@ Puppet::Functions.create_function(:add_to_group) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_to_group')
     end
 
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('process targets through inventory')
-      )
-    end
-
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    executor&.report_function_call('add_to_group')
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call('add_to_group')
 
     inventory.add_to_group(inventory.get_targets(targets), group)
   end

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

@@ -46,15 +46,9 @@ Puppet::Functions.create_function(:apply_prep) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'apply_prep')
     end
 
-    applicator = Puppet.lookup(:apply_executor) { nil }
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless applicator && executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('apply_prep')
-      )
-    end
+    applicator = Puppet.lookup(:apply_executor)
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     executor.report_function_call('apply_prep')
 

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

@@ -14,14 +14,8 @@ Puppet::Functions.create_function(:facts) do
   end
 
   def facts(target)
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('get facts for a target')
-      )
-    end
-
+    inventory = Puppet.lookup(:bolt_inventory)
+    # Bolt executor not expected when invoked from apply block
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('facts')
 

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

@@ -39,8 +39,8 @@ Puppet::Functions.create_function(:fail_plan) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'fail_plan')
     end
 
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    executor&.report_function_call('fail_plan')
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call('fail_plan')
 
     raise Bolt::PlanFailure.new(msg, kind || 'bolt/plan-failure', details, issue_code)
   end

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

@@ -39,14 +39,9 @@ Puppet::Functions.create_function(:get_resources) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'get_resources')
     end
 
-    applicator = Puppet.lookup(:apply_executor) { nil }
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless applicator && executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('get_resources')
-      )
-    end
+    applicator = Puppet.lookup(:apply_executor)
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     resources = [resources].flatten
     resources.each do |resource|

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

@@ -22,14 +22,8 @@ Puppet::Functions.create_function(:get_targets) do
   end
 
   def get_targets(names)
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('process targets through inventory')
-      )
-    end
-
+    inventory = Puppet.lookup(:bolt_inventory)
+    # Bolt executor not expected when invoked from apply block
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('get_targets')
 

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

@@ -17,13 +17,8 @@ Puppet::Functions.create_function(:puppetdb_fact) do
   end
 
   def puppetdb_fact(certnames)
-    puppetdb_client = Puppet.lookup(:bolt_pdb_client) { nil }
-    unless puppetdb_client
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('query facts from puppetdb')
-      )
-    end
-
+    puppetdb_client = Puppet.lookup(:bolt_pdb_client)
+    # Bolt executor not expected when invoked from apply block
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('puppetdb_fact')
 

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

@@ -19,13 +19,8 @@ Puppet::Functions.create_function(:puppetdb_query) do
   # The query type could be more specific ASTQuery = Array[Variant[String, ASTQuery]]
 
   def make_query(query)
-    puppetdb_client = Puppet.lookup(:bolt_pdb_client) { nil }
-    unless puppetdb_client
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('query facts from puppetdb')
-      )
-    end
-
+    puppetdb_client = Puppet.lookup(:bolt_pdb_client)
+    # Bolt executor not expected when invoked from apply block
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('puppetdb_query')
 

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

@@ -49,13 +49,8 @@ Puppet::Functions.create_function(:run_command) do
 
     options ||= {}
     options = options.merge('_description' => description) if description
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a command')
-      )
-    end
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     executor.report_function_call('run_command')
 

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

@@ -24,12 +24,7 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_plan')
     end
 
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    unless executor && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a plan')
-      )
-    end
+    executor = Puppet.lookup(:bolt_executor)
 
     # Bolt calls this function internally to trigger plans from the CLI. We
     # don't want to count those invocations.

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

@@ -55,13 +55,8 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
 
     options ||= {}
     options = options.merge('_description' => description) if description
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a script')
-      )
-    end
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     executor.report_function_call('run_script')
 

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

@@ -32,26 +32,10 @@ Puppet::Functions.create_function(:run_task) do
   # @example Run a task
   #   run_task('facts', $targets, 'Gather OS facts')
   dispatch :run_task_with_description do
-    param 'String[1]', :task_name
-    param 'Boltlib::TargetSpec', :targets
-    param 'String', :description
-    optional_param 'Hash[String[1], Any]', :task_args
-    return_type 'ResultSet'
-  end
-
-  # Run a task, calling the block as each node starts and finishes execution. This is used from 'bolt task run'
-  # @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 block A block that's invoked as actions are started and finished on each node.
-  # @return A list of results, one entry per target.
-  dispatch :run_task_raw do
     param 'String[1]', :task_name
     param 'Boltlib::TargetSpec', :targets
     param 'Optional[String]', :description
     optional_param 'Hash[String[1], Any]', :task_args
-    block_param 'Callable[Struct[{type => Enum[node_start, node_result], target => Target}], 1, 1]', :block
     return_type 'ResultSet'
   end
 
@@ -60,28 +44,14 @@ Puppet::Functions.create_function(:run_task) do
   end
 
   def run_task_with_description(task_name, targets, description, task_args = nil)
-    task_args ||= {}
-    r = run_task_raw(task_name, targets, description, task_args)
-    if !r.ok && !task_args['_catch_errors']
-      raise Bolt::RunFailure.new(r, 'run_task', task_name)
-    end
-    r
-  end
-
-  def run_task_raw(task_name, targets, description = nil, task_args = nil, &block)
     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 ||= {}
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('run a task')
-      )
-    end
+    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.
@@ -149,7 +119,11 @@ Puppet::Functions.create_function(:run_task) do
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      executor.run_task(targets, task, use_args, options, &block)
+      result = executor.run_task(targets, task, use_args, options)
+      if !result.ok && !task_args['_catch_errors']
+        raise Bolt::RunFailure.new(result, 'run_task', task_name)
+      end
+      result
     end
   end
 

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

@@ -30,16 +30,9 @@ Puppet::Functions.create_function(:set_feature) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_feature')
     end
 
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('set feature')
-      )
-    end
-
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    executor&.report_function_call('set_feature')
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call('set_feature')
 
     inventory.set_feature(target, feature, value)
 

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

@@ -24,16 +24,9 @@ Puppet::Functions.create_function(:set_var) do
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_var')
     end
 
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('set a var on a target')
-      )
-    end
-
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    executor&.report_function_call('set_var')
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call('set_var')
 
     inventory.set_var(target, key, value)
   end

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

@@ -59,13 +59,8 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
 
     options ||= {}
     options = options.merge('_description' => description) if description
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('do file uploads')
-      )
-    end
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     executor.report_function_call('upload_file')
 

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

@@ -18,14 +18,8 @@ Puppet::Functions.create_function(:vars) do
   end
 
   def vars(target)
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-
-    unless inventory
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('get vars')
-      )
-    end
-
+    inventory = Puppet.lookup(:bolt_inventory)
+    # Bolt executor not expected when invoked from apply block
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('vars')
 

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

@@ -26,13 +26,8 @@ Puppet::Functions.create_function(:wait_until_available) do
     end
 
     options ||= {}
-    executor = Puppet.lookup(:bolt_executor) { nil }
-    inventory = Puppet.lookup(:bolt_inventory) { nil }
-    unless executor && inventory && Puppet.features.bolt?
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('wait until targets are available')
-      )
-    end
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
 
     executor.report_function_call('wait_until_available')
 

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

@@ -28,7 +28,7 @@ Puppet::Functions.create_function(:without_default_logging) do
                               action: 'without_default_logging')
     end
 
-    executor = Puppet.lookup(:bolt_executor) { nil }
+    executor = Puppet.lookup(:bolt_executor)
     executor.report_function_call('without_default_logging')
 
     executor.without_default_logging do

data/lib/bolt/applicator.rb

@@ -177,8 +177,6 @@ module Bolt
     def apply_ast(raw_ast, targets, options, plan_vars = {})
       ast = Puppet::Pops::Serialization::ToDataConverter.convert(raw_ast, rich_data: true, symbol_to_string: true)
 
-      notify = proc { |_| nil }
-
       r = @executor.log_action('apply catalog', targets) do
         futures = targets.map do |target|
           Concurrent::Future.execute(executor: @pool) do
@@ -200,7 +198,13 @@ module Bolt
                 '_noop' => options['_noop']
               }
 
-              results = transport.batch_task(batch, catalog_apply_task, arguments, options, &notify)
+              callback = proc do |event|
+                if event[:type] == :node_result
+                  event = event.merge(result: ApplyResult.from_task_result(event[:result]))
+                end
+                @executor.publish_event(event)
+              end
+              results = transport.batch_task(batch, catalog_apply_task, arguments, options, &callback)
               Array(results).map { |result| ApplyResult.from_task_result(result) }
             end
           end