bolt 3.15.0 → 3.16.0

data/lib/bolt/fiber_executor.rb

@@ -52,7 +52,7 @@ module Bolt
       # tracking which Futures to wait on when `wait()` is called without
       # arguments.
       @id += 1
-      future = Bolt::PlanFuture.new(future, @id, name: name, plan_id: plan_id)
+      future = Bolt::PlanFuture.new(future, @id, name: name, plan_id: plan_id, scope: newscope)
       @logger.trace("Created future #{future.name}")
 
       # Register the PlanFuture with the FiberExecutor to be executed
@@ -68,11 +68,15 @@ module Bolt
     #
     def round_robin
       active_futures.each do |future|
-        # If the Fiber is still running and can be resumed, then resume it
+        # If the Fiber is still running and can be resumed, then resume it.
+        # Override Puppet's global_scope to prevent ephemerals in other scopes
+        # from being popped off in the wrong order due to race conditions.
+        # This primarily happens when running executor functions from custom
+        # Puppet language functions, but may happen elsewhere.
         @logger.trace("Checking future '#{future.name}'")
         if future.alive?
           @logger.trace("Resuming future '#{future.name}'")
-          future.resume
+          Puppet.override(global_scope: future.scope) { future.resume }
         end
 
         # Once we've restarted the Fiber, check to see if it's finished again

data/lib/bolt/outputter/human.rb

@@ -310,7 +310,12 @@ module Bolt
         )
       end
 
-      def print_tasks(tasks, modulepath)
+      # List available tasks.
+      #
+      # @param tasks [Array] A list of task names and descriptions.
+      # @param modulepath [Array] The modulepath.
+      #
+      def print_tasks(tasks:, modulepath:)
         command = Bolt::Util.powershell? ? 'Get-BoltTask -Name <TASK NAME>' : 'bolt task show <TASK NAME>'
 
         tasks = tasks.map do |name, description|
@@ -330,8 +335,11 @@ module Bolt
         @stream.puts indent(2, "Use '#{command}' to view details and parameters for a specific task.")
       end
 
-      # @param [Hash] task A hash representing the task
-      def print_task_info(task)
+      # Print information about a task.
+      #
+      # @param task [Bolt::Task] The task information.
+      #
+      def print_task_info(task:)
         params = (task.parameters || []).sort
 
         info = +''
@@ -443,7 +451,7 @@ module Bolt
         @stream.puts info
       end
 
-      def print_plans(plans, modulepath)
+      def print_plans(plans:, modulepath:)
         command = Bolt::Util.powershell? ? 'Get-BoltPlan -Name <PLAN NAME>' : 'bolt plan show <PLAN NAME>'
 
         plans = plans.map do |name, description|
@@ -463,7 +471,11 @@ module Bolt
         @stream.puts indent(2, "Use '#{command}' to view details and parameters for a specific plan.")
       end
 
-      def print_topics(topics)
+      # Print available guide topics.
+      #
+      # @param topics [Array] The available topics.
+      #
+      def print_topics(topics:, **_kwargs)
         info = +"#{colorize(:cyan, 'Topics')}\n"
         info << indent(2, topics.join("\n"))
         info << "\n\n#{colorize(:cyan, 'Additional information')}\n"
@@ -471,7 +483,11 @@ module Bolt
         @stream.puts info
       end
 
-      def print_guide(topic:, guide:, documentation: nil)
+      # Print the guide for the specified topic.
+      #
+      # @param guide [String] The guide.
+      #
+      def print_guide(topic:, guide:, documentation: nil, **_kwargs)
         info = +"#{colorize(:cyan, topic)}\n"
         info << indent(2, guide)
 
@@ -595,17 +611,17 @@ module Bolt
         @stream.puts info
       end
 
-      def print_plugin_list(plugin_list, modulepath)
+      def print_plugin_list(plugins:, modulepath:)
         info   = +''
-        length = plugin_list.values.map(&:keys).flatten.map(&:length).max + 4
+        length = plugins.values.map(&:keys).flatten.map(&:length).max + 4
 
-        plugin_list.each do |hook, plugins|
-          next if plugins.empty?
+        plugins.each do |hook, plugin|
+          next if plugin.empty?
           next if hook == :validate_resolve_reference
 
           info << colorize(:cyan, "#{hook}\n")
 
-          plugins.each do |name, description|
+          plugin.each do |name, description|
             info << indent(2, name.ljust(length))
             info << truncate(description, 80 - length) if description
             info << "\n"
@@ -623,12 +639,37 @@ module Bolt
         @stream.puts info.chomp
       end
 
-      def print_targets(target_list, inventory_source, default_inventory, target_flag)
-        adhoc = colorize(:yellow, "(Not found in inventory file)")
+      def print_new_plan(name:, path:)
+        if Bolt::Util.powershell?
+          show_command = 'Get-BoltPlan -Name '
+          run_command  = 'Invoke-BoltPlan -Name '
+        else
+          show_command = 'bolt plan show'
+          run_command  = 'bolt plan run'
+        end
+
+        print_message(<<~OUTPUT)
+          Created plan '#{name}' at '#{path}'
+  
+          Show this plan with:
+              #{show_command} #{name}
+          Run this plan with:
+              #{run_command} #{name}
+        OUTPUT
+      end
+
+      # Print target names and where they came from.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param flag [Boolean] Whether a targeting command-line option was used.
+      #
+      def print_targets(adhoc:, inventory:, flag:, **_kwargs)
+        adhoc_text = colorize(:yellow, "(Not found in inventory file)")
 
         targets  = []
-        targets += target_list[:inventory].map { |target| [target.name, nil] }
-        targets += target_list[:adhoc].map { |target| [target.name, adhoc] }
+        targets += inventory[:targets].map { |target| [target['name'], nil] }
+        targets += adhoc[:targets].map { |target| [target['name'], adhoc_text] }
 
         info = +''
 
@@ -641,27 +682,31 @@ module Bolt
                 end
         info << "\n\n"
 
-        info << format_inventory_source(inventory_source, default_inventory)
-        info << format_target_summary(target_list[:inventory].count, target_list[:adhoc].count, target_flag, false)
+        info << format_inventory_source(inventory[:file], inventory[:default])
+        info << format_target_summary(inventory[:count], adhoc[:count], flag, false)
 
         @stream.puts info
       end
 
-      def print_target_info(target_list, inventory_source, default_inventory, target_flag)
-        adhoc_targets     = target_list[:adhoc].map(&:name).to_set
-        inventory_targets = target_list[:inventory].map(&:name).to_set
-        targets           = target_list.values.flatten.sort_by(&:name)
+      # Print detailed target information.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param flag [Boolean] Whether a targeting command-line option was used.
+      #
+      def print_target_info(adhoc:, inventory:, flag:, **_kwargs)
+        targets = (adhoc[:targets] + inventory[:targets]).sort_by { |t| t['name'] }
 
         info = +''
 
         if targets.any?
-          adhoc = colorize(:yellow, " (Not found in inventory file)")
+          adhoc_text = colorize(:yellow, " (Not found in inventory file)")
 
           targets.each do |target|
-            info << colorize(:cyan, target.name)
-            info << adhoc if adhoc_targets.include?(target.name)
+            info << colorize(:cyan, target['name'])
+            info << adhoc_text if adhoc[:targets].include?(target)
             info << "\n"
-            info << indent(2, target.detail.to_yaml.lines.drop(1).join)
+            info << indent(2, target.to_yaml.lines.drop(1).join)
             info << "\n"
           end
         else
@@ -669,8 +714,8 @@ module Bolt
           info << indent(2, "No targets\n\n")
         end
 
-        info << format_inventory_source(inventory_source, default_inventory)
-        info << format_target_summary(inventory_targets.count, adhoc_targets.count, target_flag, true)
+        info << format_inventory_source(inventory[:file], inventory[:default])
+        info << format_target_summary(inventory[:count], adhoc[:count], flag, true)
 
         @stream.puts info
       end
@@ -716,7 +761,13 @@ module Bolt
         info
       end
 
-      def print_groups(groups, inventory_source, default_inventory)
+      # Print inventory group information.
+      #
+      # @param count [Integer] Number of groups in the inventory.
+      # @param groups [Array] Names of groups in the inventory.
+      # @param inventory [Hash] Where the inventory was loaded from.
+      #
+      def print_groups(count:, groups:, inventory:)
         info = +''
 
         # Add group list
@@ -725,18 +776,18 @@ module Bolt
         info << "\n\n"
 
         # Add inventory file source
-        info << format_inventory_source(inventory_source, default_inventory)
+        info << format_inventory_source(inventory[:source], inventory[:default])
 
         # Add group count summary
         info << colorize(:cyan, "Group count\n")
-        info << indent(2, "#{groups.count} total")
+        info << indent(2, "#{count} total")
 
         @stream.puts info
       end
 
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`
-      def print_apply_result(apply_result, elapsed_time)
-        print_summary(apply_result, elapsed_time)
+      def print_apply_result(apply_result)
+        print_summary(apply_result, apply_result.elapsed_time)
       end
 
       # @param [Bolt::PlanResult] plan_result A PlanResult object

data/lib/bolt/outputter/json.rb

@@ -49,7 +49,11 @@ module Bolt
       alias print_module_list print_table
       alias print_module_info print_table
 
-      def print_task_info(task)
+      # Print information about a task.
+      #
+      # @param task [Bolt::Task] The task information.
+      #
+      def print_task_info(task:)
         path = task.files.first['path'].chomp("/tasks/#{task.files.first['name']}")
         module_dir = if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
                        "built-in module"
@@ -59,11 +63,16 @@ module Bolt
         @stream.puts task.to_h.merge(module_dir: module_dir).to_json
       end
 
-      def print_tasks(tasks, modulepath)
-        print_table('tasks' => tasks, 'modulepath' => modulepath)
+      # List available tasks.
+      #
+      # @param tasks [Array] A list of task names and descriptions.
+      # @param modulepath [Array] The modulepath.
+      #
+      def print_tasks(**kwargs)
+        print_table(**kwargs)
       end
 
-      def print_plugin_list(plugins, modulepath)
+      def print_plugin_list(plugins:, modulepath:)
         plugins.delete(:validate_resolve_reference)
         print_table('plugins' => plugins, 'modulepath' => modulepath)
       end
@@ -78,11 +87,15 @@ module Bolt
         @stream.puts plan.to_json
       end
 
-      def print_plans(plans, modulepath)
-        print_table('plans' => plans, 'modulepath' => modulepath)
+      def print_plans(**kwargs)
+        print_table(**kwargs)
       end
 
-      def print_apply_result(apply_result, _elapsed_time)
+      def print_new_plan(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_apply_result(apply_result)
         @stream.puts apply_result.to_json
       end
 
@@ -95,10 +108,19 @@ module Bolt
         @stream.puts result_set.to_json
       end
 
-      def print_topics(topics)
-        print_table('topics' => topics)
+      # Print available guide topics.
+      #
+      # @param topics [Array] The available topics.
+      #
+      def print_topics(**kwargs)
+        print_table(kwargs)
       end
 
+      # Print the guide for the specified topic.
+      #
+      # @param guide [String] The guide.
+      # @param topic [String] The topic.
+      #
       def print_guide(**kwargs)
         @stream.puts(kwargs.to_json)
       end
@@ -113,35 +135,38 @@ module Bolt
                        moduledir: moduledir.to_s }.to_json)
       end
 
-      def print_targets(target_list, inventory_source, default_inventory, _target_flag)
-        @stream.puts ::JSON.pretty_generate(
-          inventory: {
-            targets: target_list[:inventory].map(&:name),
-            count: target_list[:inventory].count,
-            file: (inventory_source || default_inventory).to_s
-          },
-          adhoc: {
-            targets: target_list[:adhoc].map(&:name),
-            count: target_list[:adhoc].count
-          },
-          targets: target_list.values.flatten.map(&:name),
-          count: target_list.values.flatten.count
-        )
-      end
-
-      def print_target_info(target_list, _inventory_source, _default_inventory, _target_flag)
-        targets = target_list.values.flatten
-
-        @stream.puts ::JSON.pretty_generate(
-          targets: targets.map(&:detail),
-          count: targets.count
-        )
-      end
-
-      def print_groups(groups, _inventory_source, _default_inventory)
-        count = groups.count
-        @stream.puts({ groups: groups,
-                       count: count }.to_json)
+      # Print target names and where they came from.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param targets [Array] All targets.
+      # @param count [Integer] Number of targets.
+      #
+      def print_targets(adhoc:, inventory:, targets:, count:, **_kwargs)
+        adhoc[:targets]     = adhoc[:targets].map { |t| t['name'] }
+        inventory[:targets] = inventory[:targets].map { |t| t['name'] }
+        targets             = targets.map { |t| t['name'] }
+        @stream.puts({ adhoc: adhoc, inventory: inventory, targets: targets, count: count }.to_json)
+      end
+
+      # Print target names and where they came from.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param targets [Array] All targets.
+      # @param count [Integer] Number of targets.
+      #
+      def print_target_info(adhoc:, inventory:, targets:, count:, **_kwargs)
+        @stream.puts({ adhoc: adhoc, inventory: inventory, targets: targets, count: count }.to_json)
+      end
+
+      # Print inventory group information.
+      #
+      # @param count [Integer] Number of groups in the inventory.
+      # @param groups [Array] Names of groups in the inventory.
+      #
+      def print_groups(count:, groups:, **_kwargs)
+        @stream.puts({ count: count, groups: groups }.to_json)
       end
 
       def fatal_error(err)

data/lib/bolt/plan_creator.rb

@@ -51,7 +51,7 @@ module Bolt
       end
     end
 
-    def self.create_plan(plans_path, plan_name, outputter, is_puppet)
+    def self.create_plan(plans_path, plan_name, is_puppet)
       _, name_segments, basename = segment_plan_name(plan_name)
       dir_path = plans_path.join(*name_segments)
 
@@ -77,25 +77,7 @@ module Bolt
         )
       end
 
-      if Bolt::Util.powershell?
-        show_command = 'Get-BoltPlan -Name '
-        run_command  = 'Invoke-BoltPlan -Name '
-      else
-        show_command = 'bolt plan show'
-        run_command  = 'bolt plan run'
-      end
-
-      output = <<~OUTPUT
-        Created plan '#{plan_name}' at '#{plan_path}'
-
-        Show this plan with:
-            #{show_command} #{plan_name}
-        Run this plan with:
-            #{run_command} #{plan_name}
-      OUTPUT
-
-      outputter.print_message(output)
-      0
+      { name: plan_name, path: plan_path }
     end
 
     def self.segment_plan_name(plan_name)

data/lib/bolt/plan_future.rb

@@ -4,14 +4,19 @@ require 'fiber'
 
 module Bolt
   class PlanFuture
-    attr_reader :fiber, :id
+    attr_reader :fiber, :id, :scope
     attr_accessor :value, :plan_stack
 
-    def initialize(fiber, id, plan_id:, name: nil)
-      @fiber   = fiber
-      @id      = id
-      @name    = name
-      @value   = nil
+    def initialize(fiber, id, plan_id:, name: nil, scope: nil)
+      @fiber = fiber
+      @id    = id
+      @name  = name
+      @value = nil
+
+      # Default to Puppet's current global_scope, otherwise things will
+      # blow up when the Fiber Executor tries to override the global_scope.
+      @scope = scope || Puppet.lookup(:global_scope) { nil }
+
       # The plan invocation ID when the Future is created may be
       # different from the plan ID of the Future when we switch to it if a new
       # plan was run inside the Future, so keep track of the plans that a

data/lib/bolt/plan_result.rb

@@ -6,7 +6,7 @@ require 'bolt/util'
 
 module Bolt
   class PlanResult
-    attr_accessor :value, :status
+    attr_accessor :status, :value
 
     # This must be called from inside a compiler
     def self.from_pcore(result, status)