bolt 3.14.1 → 3.17.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/inventory/inventory.rb

@@ -6,7 +6,7 @@ require 'bolt/inventory/target'
 module Bolt
   class Inventory
     class Inventory
-      attr_reader :config, :plugins, :source, :targets, :transport
+      attr_reader :plugins, :source, :targets, :transport
 
       class WildcardError < Bolt::Error
         def initialize(target)
@@ -14,25 +14,15 @@ module Bolt
         end
       end
 
-      # TODO: Pass transport config instead of config object
       def initialize(data, transport, transports, plugins, source = nil)
-        @logger       = Bolt::Logger.logger(self)
-        @data         = data || {}
-        @transport    = transport
-        @config       = transports
-        @plugins      = plugins
-        @groups       = Group.new(@data, plugins, all_group: true)
-        @group_lookup = {}
-        @targets      = {}
-        @source       = source
-
-        @groups.resolve_string_targets(@groups.target_aliases, @groups.all_targets)
-
-        collect_groups
-      end
-
-      def validate
-        @groups.validate
+        @logger          = Bolt::Logger.logger(self)
+        @data            = data || {}
+        @transport       = transport
+        @config          = transports
+        @config_resolved = transports.values.all?(&:resolved?)
+        @plugins         = plugins
+        @targets         = {}
+        @source          = source
       end
 
       def version
@@ -43,13 +33,52 @@ module Bolt
         Bolt::Target
       end
 
-      def collect_groups
-        # Provide a lookup map for finding a group by name
-        @group_lookup = @groups.collect_groups
+      # Load and resolve the groups in the inventory. Loading groups resolves
+      # all plugin references except for those for target data and config.
+      #
+      # @return [Bolt::Inventory::Group]
+      #
+      def groups
+        @groups ||= Group.new(@data, @plugins, all_group: true).tap do |groups|
+          groups.resolve_string_targets(groups.target_aliases, groups.all_targets)
+          groups.validate
+        end
       end
 
+      # Return a list of all group names in the inventory.
+      #
+      # @return [Array[String]]
+      #
       def group_names
-        @group_lookup.keys
+        group_lookup.keys
+      end
+
+      # Return a map of all groups in the inventory.
+      #
+      # @return [Hash[String, Bolt::Inventory::Group]]
+      #
+      def group_lookup
+        @group_lookup ||= groups.collect_groups
+      end
+
+      # Return a map of transport configuration for the inventory. Any
+      # unresolved plugin references are resolved.
+      #
+      # @return [Hash[String, Bolt::Config::Transport]]
+      #
+      def config
+        if @config_resolved
+          @config
+        else
+          @config_resolved = true
+          @config.transform_values! { |t| t.resolved? ? t : t.resolve(@plugins) }
+        end
+      end
+
+      # Validates the inventory.
+      #
+      def validate
+        groups.validate
       end
 
       def group_names_for(target_name)
@@ -57,7 +86,7 @@ module Bolt
       end
 
       def target_names
-        @groups.all_targets
+        groups.all_targets
       end
       # alias for analytics
       alias node_names target_names
@@ -81,7 +110,7 @@ module Bolt
 
       #### PRIVATE ####
       def group_data_for(target_name)
-        @groups.group_collect(target_name)
+        groups.group_collect(target_name)
       end
 
       # If target is a group name, expand it to the members of that group.
@@ -89,15 +118,15 @@ module Bolt
       # If a wildcard string, error if no matches are found.
       # Else fall back to [target] if no matches are found.
       def resolve_name(target)
-        if (group = @group_lookup[target])
+        if (group = group_lookup[target])
           group.all_targets
         else
           # Try to wildcard match targets in inventory
           # Ignore case because hostnames are generally case-insensitive
           regexp = Regexp.new("^#{Regexp.escape(target).gsub('\*', '.*?')}$", Regexp::IGNORECASE)
 
-          targets = @groups.all_targets.select { |targ| targ =~ regexp }
-          targets += @groups.target_aliases.select { |target_alias, _target| target_alias =~ regexp }.values
+          targets = groups.all_targets.select { |targ| targ =~ regexp }
+          targets += groups.target_aliases.select { |target_alias, _target| target_alias =~ regexp }.values
 
           if targets.empty?
             raise(WildcardError, target) if target.include?('*')
@@ -165,7 +194,7 @@ module Bolt
       # associated references. This is used when a target is resolved by
       # get_targets.
       def create_target_from_inventory(target_name)
-        target_data = @groups.target_collect(target_name) || { 'uri' => target_name }
+        target_data = groups.target_collect(target_name) || { 'uri' => target_name }
 
         target = Bolt::Inventory::Target.new(target_data, self)
         @targets[target.name] = target
@@ -187,24 +216,24 @@ module Bolt
         @targets[new_target.name] = new_target
 
         if existing_target
-          clear_alia_from_group(@groups, new_target.name)
+          clear_alia_from_group(groups, new_target.name)
         else
           add_to_group([new_target], 'all')
         end
 
         if new_target.target_alias
-          @groups.insert_alia(new_target.name, Array(new_target.target_alias))
+          groups.insert_alia(new_target.name, Array(new_target.target_alias))
         end
 
         new_target
       end
 
       def validate_target_from_hash(target)
-        groups = Set.new(group_names)
-        targets = target_names
+        used_groups  = Set.new(group_names)
+        used_targets = target_names
 
         # Make sure there are no group name conflicts
-        if groups.include?(target.name)
+        if used_groups.include?(target.name)
           raise ValidationError.new("Target name #{target.name} conflicts with group of the same name", nil)
         end
 
@@ -217,11 +246,11 @@ module Bolt
         end
 
         # Make sure there are no conflicts with the new target aliases
-        used_aliases = @groups.target_aliases
+        used_aliases = groups.target_aliases
         Array(target.target_alias).each do |alia|
-          if groups.include?(alia)
+          if used_groups.include?(alia)
             raise ValidationError.new("Alias #{alia} conflicts with group of the same name", nil)
-          elsif targets.include?(alia)
+          elsif used_targets.include?(alia)
             raise ValidationError.new("Alias #{alia} conflicts with target of the same name", nil)
           elsif used_aliases[alia] && used_aliases[alia] != target.name
             raise ValidationError.new(
@@ -250,7 +279,7 @@ module Bolt
         end
 
         if group_names.include?(desired_group)
-          remove_target(@groups, @targets[target.first.name], desired_group)
+          remove_target(groups, @targets[target.first.name], desired_group)
         else
           raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
         end
@@ -260,7 +289,7 @@ module Bolt
         if group_names.include?(desired_group)
           targets.each do |target|
             # Add the inventory copy of the target
-            add_target(@groups, @targets[target.name], desired_group)
+            add_target(groups, @targets[target.name], desired_group)
           end
         else
           raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)

data/lib/bolt/inventory.rb

@@ -91,19 +91,12 @@ module Bolt
         end
       end
 
-      # Resolve plugin references from transport config
-      config.transports.each_value do |t|
-        t.resolve(plugins) unless t.resolved?
-      end
-
       Bolt::Validator.new.tap do |validator|
         validator.validate(data, schema, source)
         validator.warnings.each { |warning| Bolt::Logger.warn(warning[:id], warning[:msg]) }
       end
 
-      inventory = create_version(data, config.transport, config.transports, plugins, source)
-      inventory.validate
-      inventory
+      create_version(data, config.transport, config.transports, plugins, source)
     end
 
     def self.create_version(data, transport, transports, plugins, source = nil)
@@ -119,7 +112,7 @@ module Bolt
 
     def self.empty
       config  = Bolt::Config.default
-      plugins = Bolt::Plugin.setup(config, nil)
+      plugins = Bolt::Plugin.new(config, nil)
 
       create_version({}, config.transport, config.transports, plugins, nil)
     end

data/lib/bolt/module_installer/puppetfile.rb

@@ -97,20 +97,34 @@ module Bolt
           end
         end
 
-        return if unsatisfied_specs.empty?
-
+        versionless_mods = @modules.select { |mod| mod.is_a?(ForgeModule) && mod.version.nil? }
         command = Bolt::Util.windows? ? 'Install-BoltModule -Force' : 'bolt module install --force'
 
-        message = <<~MESSAGE.chomp
-          Puppetfile does not include modules that satisfy the following specifications:
+        if unsatisfied_specs.any?
+          message = <<~MESSAGE.chomp
+            Puppetfile does not include modules that satisfy the following specifications:
+
+            #{unsatisfied_specs.map(&:to_hash).to_yaml.lines.drop(1).join.chomp}
+            
+            This Puppetfile might not be managed by Bolt. To forcibly overwrite the
+            Puppetfile, run '#{command}'.
+          MESSAGE
 
-          #{unsatisfied_specs.map(&:to_hash).to_yaml.lines.drop(1).join.chomp}
-          
-          This Puppetfile might not be managed by Bolt. To forcibly overwrite the
-          Puppetfile, run '#{command}'.
-        MESSAGE
+          raise Bolt::Error.new(message, 'bolt/missing-module-specs')
+        end
 
-        raise Bolt::Error.new(message, 'bolt/missing-module-specs')
+        if versionless_mods.any?
+          message = <<~MESSAGE.chomp
+            Puppetfile includes Forge modules without a version requirement:
+            
+            #{versionless_mods.map(&:to_spec).join.chomp}
+            
+            This Puppetfile might not be managed by Bolt. To forcibly overwrite the
+            Puppetfile, run '#{command}'.
+          MESSAGE
+
+          raise Bolt::Error.new(message, 'bolt/missing-module-version-specs')
+        end
       end
     end
   end

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