bolt 3.6.1 → 3.9.0

data/lib/bolt/fiber_executor.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'bolt/logger'
+require 'bolt/plan_future'
+
+module Bolt
+  class FiberExecutor
+    attr_reader :plan_futures
+
+    def initialize
+      @logger = Bolt::Logger.logger(self)
+      @id = 0
+      @plan_futures = []
+    end
+
+    # Whether there is more than one fiber running in parallel.
+    #
+    def in_parallel?
+      plan_futures.length > 1
+    end
+
+    # Creates a new Puppet scope from the current Plan scope so that variables
+    # can be used inside the block and won't interact with the outer scope.
+    # Then creates a new Fiber to execute the block, wraps the Fiber in a
+    # Bolt::PlanFuture, and returns the Bolt::PlanFuture.
+    #
+    def create_future(scope: nil, name: nil)
+      newscope = nil
+      if scope
+        # Save existing variables to the new scope before starting the future
+        # itself so that if the plan returns before the backgrounded block
+        # starts, we still have the variables.
+        newscope = Puppet::Parser::Scope.new(scope.compiler)
+        local = Puppet::Parser::Scope::LocalScope.new
+
+        # Compress the current scopes into a single vars hash to add to the new scope
+        scope.to_hash.each_pair { |k, v| local[k] = v }
+        newscope.push_ephemerals([local])
+      end
+
+      # Create a new Fiber that will execute the provided block.
+      future = Fiber.new do
+        # Yield the new scope - this should be ignored by the block if
+        # `newscope` is nil.
+        yield newscope
+      end
+
+      # PlanFutures are assigned an ID, which is just a global incrementing
+      # integer. The main plan should always have ID 0.
+      @id += 1
+      future = Bolt::PlanFuture.new(future, @id, name)
+      @logger.trace("Created future #{future.name}")
+
+      # Register the PlanFuture with the FiberExecutor to be executed
+      plan_futures << future
+      future
+    end
+
+    # Visit each PlanFuture registered with the FiberExecutor and resume it.
+    # Fibers will yield themselves back, either if they kicked off a
+    # long-running process or if the current long-running process hasn't
+    # completed. If the Fiber finishes after being resumed, store the result in
+    # the PlanFuture and remove the PlanFuture from the FiberExecutor.
+    #
+    def round_robin
+      plan_futures.each do |future|
+        # If the Fiber is still running and can be resumed, then resume it
+        @logger.trace("Checking future '#{future.name}'")
+        if future.alive?
+          @logger.trace("Resuming future '#{future.name}'")
+          future.resume
+        end
+
+        # Once we've restarted the Fiber, check to see if it's finished again
+        # and cleanup if it has.
+        next if future.alive?
+        @logger.trace("Cleaning up future '#{future.name}'")
+
+        # If the future errored and the main plan has already exited, log the
+        # error at warn level.
+        unless plan_futures.map(&:id).include?(0) || future.state == "done"
+          Bolt::Logger.warn('errored_futures', "Error in future '#{future.name}': #{future.value}")
+        end
+
+        # Remove the PlanFuture from the FiberExecutor.
+        plan_futures.delete(future)
+      end
+
+      # If the Fiber immediately returned or if the Fiber is blocking on a
+      # `wait` call, Bolt should pause for long enough that something can
+      # execute before checking again. This mitigates CPU
+      # thrashing.
+      return unless plan_futures.all? { |f| %i[returned_immediately unfinished].include?(f.value) }
+      @logger.trace("Nothing can be resumed. Rechecking in 0.5 seconds.")
+
+      sleep(0.5)
+    end
+
+    # Whether all PlanFutures have finished executing, indicating that the
+    # entire plan (main plan and any PlanFutures it spawned) has finished and
+    # Bolt can exit.
+    #
+    def plan_complete?
+      plan_futures.empty?
+    end
+
+    # Block until the provided PlanFuture objects have finished, or the timeout is reached.
+    #
+    def wait(futures, timeout: nil, catch_errors: false, **_kwargs)
+      if timeout.nil?
+        Fiber.yield(:unfinished) until futures.map(&:alive?).none?
+      else
+        start = Time.now
+        Fiber.yield(:unfinished) until (Time.now - start > timeout) || futures.map(&:alive?).none?
+        # Raise an error for any futures that are still alive
+        futures.each do |f|
+          if f.alive?
+            f.raise(Bolt::FutureTimeoutError.new(f.name, timeout))
+          end
+        end
+      end
+
+      results = futures.map(&:value)
+
+      failed_indices = results.each_index.select do |i|
+        results[i].is_a?(Bolt::Error)
+      end
+
+      if failed_indices.any?
+        if catch_errors
+          failed_indices.each { |i| results[i] = results[i].to_puppet_error }
+        else
+          # Do this after handling errors for simplicity and pretty printing
+          raise Bolt::ParallelFailure.new(results, failed_indices)
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/bolt/inventory.rb

@@ -86,6 +86,7 @@ module Bolt
         if config.default_inventoryfile.exist?
           logger.debug("Loaded inventory from #{config.default_inventoryfile}")
         else
+          source = nil
           logger.debug("Tried to load inventory from #{config.default_inventoryfile}, but the file does not exist")
         end
       end
@@ -100,17 +101,17 @@ module Bolt
         validator.warnings.each { |warning| Bolt::Logger.warn(warning[:id], warning[:msg]) }
       end
 
-      inventory = create_version(data, config.transport, config.transports, plugins)
+      inventory = create_version(data, config.transport, config.transports, plugins, source)
       inventory.validate
       inventory
     end
 
-    def self.create_version(data, transport, transports, plugins)
+    def self.create_version(data, transport, transports, plugins, source = nil)
       version = (data || {}).delete('version') { 2 }
 
       case version
       when 2
-        Bolt::Inventory::Inventory.new(data, transport, transports, plugins)
+        Bolt::Inventory::Inventory.new(data, transport, transports, plugins, source)
       else
         raise ValidationError.new("Unsupported version #{version} specified in inventory", nil)
       end
@@ -120,7 +121,7 @@ module Bolt
       config  = Bolt::Config.default
       plugins = Bolt::Plugin.setup(config, nil)
 
-      create_version({}, config.transport, config.transports, plugins)
+      create_version({}, config.transport, config.transports, plugins, nil)
     end
   end
 end

data/lib/bolt/inventory/inventory.rb

@@ -6,7 +6,7 @@ require 'bolt/inventory/target'
 module Bolt
   class Inventory
     class Inventory
-      attr_reader :targets, :plugins, :config, :transport
+      attr_reader :config, :plugins, :source, :targets, :transport
 
       class WildcardError < Bolt::Error
         def initialize(target)
@@ -15,7 +15,7 @@ module Bolt
       end
 
       # TODO: Pass transport config instead of config object
-      def initialize(data, transport, transports, plugins)
+      def initialize(data, transport, transports, plugins, source = nil)
         @logger       = Bolt::Logger.logger(self)
         @data         = data || {}
         @transport    = transport
@@ -24,6 +24,7 @@ module Bolt
         @groups       = Group.new(@data, plugins, all_group: true)
         @group_lookup = {}
         @targets      = {}
+        @source       = source
 
         @groups.resolve_string_targets(@groups.target_aliases, @groups.all_targets)
 

data/lib/bolt/logger.rb

@@ -203,7 +203,7 @@ module Bolt
     def self.flush_queue
       @mutex.synchronize do
         @message_queue.each do |message|
-          log_message(message)
+          log_message(**message)
         end
 
         @message_queue.clear

data/lib/bolt/module_installer/specs.rb

@@ -55,7 +55,7 @@ module Bolt
           Invalid module specification:
           #{hash.to_yaml.lines.drop(1).join.chomp}
 
-          To read more about specifying modules, see https://pup.pt/bolt-modules
+          To read more about specifying modules, see https://pup.pt/bolt-module-specs
         MESSAGE
       end
 

data/lib/bolt/module_installer/specs/git_spec.rb

@@ -67,8 +67,7 @@ module Bolt
                  elsif git.start_with?('https://github.com')
                    git.split('https://github.com/').last.split('.git').first
                  else
-                   raise Bolt::ValidationError,
-                         "Invalid git source: #{git}. Only GitHub modules are supported."
+                   raise Bolt::ValidationError, invalid_git_msg(git)
                  end
 
           [git, repo]
@@ -89,6 +88,14 @@ module Bolt
           }
         end
 
+        # Returns an error message that the provided repo is not a git repo or
+        # is private.
+        #
+        private def invalid_git_msg(repo_name)
+          "#{repo_name} is not a public GitHub repository. See https://pup.pt/no-resolve "\
+            "for information on how to install this module."
+        end
+
         # Returns a PuppetfileResolver::Model::GitModule object for resolving.
         #
         def to_resolver_module
@@ -157,10 +164,7 @@ module Bolt
 
               raise Bolt::Error.new(message, 'bolt/github-api-rate-limit-error')
             when Net::HTTPNotFound
-              raise Bolt::Error.new(
-                "#{git} is not a git repository.",
-                "bolt/missing-git-repository-error"
-              )
+              raise Bolt::Error.new(invalid_git_msg(git), "bolt/missing-git-repository-error")
             else
               raise Bolt::Error.new(
                 "Ref #{ref} at #{git} is not a commit, tag, or branch.",

data/lib/bolt/outputter/human.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'bolt/container_result'
 require 'bolt/pal'
 
 module Bolt
@@ -174,12 +175,16 @@ module Bolt
             @stream.puts(remove_trail(indent(2, result.message)))
           end
 
-          # Use special handling if the result looks like a command or script result
-          if result.generic_value.keys == %w[stdout stderr merged_output exit_code]
+          case result.action
+          when 'command', 'script'
             safe_value = result.safe_value
             @stream.puts(indent(2, safe_value['merged_output'])) unless safe_value['merged_output'].strip.empty?
-          elsif result.generic_value.any?
-            @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
+          when 'lookup'
+            @stream.puts(indent(2, result['value']))
+          else
+            if result.generic_value.any?
+              @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
+            end
           end
         end
       end
@@ -293,7 +298,7 @@ module Bolt
       end
 
       def print_tasks(tasks, modulepath)
-        command = Bolt::Util.powershell? ? 'Get-BoltTask -Task <TASK NAME>' : 'bolt task show <TASK NAME>'
+        command = Bolt::Util.powershell? ? 'Get-BoltTask -Name <TASK NAME>' : 'bolt task show <TASK NAME>'
 
         tasks = tasks.map do |name, description|
           description = truncate(description, 72)
@@ -483,7 +488,7 @@ module Bolt
         end
       end
 
-      def print_targets(target_list, inventoryfile)
+      def print_targets(target_list, inventory_source, default_inventory, target_flag)
         adhoc = colorize(:yellow, "(Not found in inventory file)")
 
         targets  = []
@@ -501,16 +506,13 @@ module Bolt
                 end
         info << "\n\n"
 
-        @stream.puts info
+        info << format_inventory_source(inventory_source, default_inventory)
+        info << format_target_summary(target_list[:inventory].count, target_list[:adhoc].count, target_flag, false)
 
-        print_inventory_summary(
-          target_list[:inventory].count,
-          target_list[:adhoc].count,
-          inventoryfile
-        )
+        @stream.puts info
       end
 
-      def print_target_info(target_list, inventoryfile)
+      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)
@@ -532,26 +534,27 @@ module Bolt
           info << indent(2, "No targets\n\n")
         end
 
-        @stream.puts info
+        info << format_inventory_source(inventory_source, default_inventory)
+        info << format_target_summary(inventory_targets.count, adhoc_targets.count, target_flag, true)
 
-        print_inventory_summary(
-          inventory_targets.count,
-          adhoc_targets.count,
-          inventoryfile
-        )
+        @stream.puts info
       end
 
-      private def print_inventory_summary(inventory_count, adhoc_count, inventoryfile)
+      private def format_inventory_source(inventory_source, default_inventory)
         info = +''
 
         # Add inventory file source
-        info << colorize(:cyan, "Inventory file\n")
-        info << if File.exist?(inventoryfile)
-                  indent(2, "#{inventoryfile}\n")
+        info << colorize(:cyan, "Inventory source\n")
+        info << if inventory_source
+                  indent(2, "#{inventory_source}\n")
                 else
-                  indent(2, wrap("Tried to load inventory from #{inventoryfile}, but the file does not exist\n"))
+                  indent(2, wrap("Tried to load inventory from #{default_inventory}, but the file does not exist\n"))
                 end
         info << "\n"
+      end
+
+      private def format_target_summary(inventory_count, adhoc_count, target_flag, detail_flag)
+        info = +''
 
         # Add target count summary
         count = "#{inventory_count + adhoc_count} total, "\
@@ -560,13 +563,40 @@ module Bolt
         info << colorize(:cyan, "Target count\n")
         info << indent(2, count)
 
-        @stream.puts info
+        # Add filtering information
+        unless target_flag && detail_flag
+          info << colorize(:cyan, "\n\nAdditional information\n")
+
+          unless target_flag
+            opt = Bolt::Util.windows? ? "'-Targets', '-Query', or '-Rerun'" : "'--targets', '--query', or '--rerun'"
+            info << indent(2, "Use the #{opt} option to view specific targets\n")
+          end
+
+          unless detail_flag
+            opt = Bolt::Util.windows? ? '-Detail' : '--detail'
+            info << indent(2, "Use the '#{opt}' option to view target configuration and data")
+          end
+        end
+
+        info
       end
 
-      def print_groups(groups)
-        count = "#{groups.count} group#{'s' unless groups.count == 1}"
-        @stream.puts groups.join("\n")
-        @stream.puts colorize(:green, count)
+      def print_groups(groups, inventory_source, default_inventory)
+        info = +''
+
+        # Add group list
+        info << colorize(:cyan, "Groups\n")
+        info << indent(2, groups.join("\n"))
+        info << "\n\n"
+
+        # Add inventory file source
+        info << format_inventory_source(inventory_source, default_inventory)
+
+        # Add group count summary
+        info << colorize(:cyan, "Group count\n")
+        info << indent(2, "#{groups.count} total")
+
+        @stream.puts info
       end
 
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`

data/lib/bolt/outputter/json.rb

@@ -83,6 +83,10 @@ module Bolt
         @stream.puts result.to_json
       end
 
+      def print_result_set(result_set)
+        @stream.puts result_set.to_json
+      end
+
       def print_topics(topics)
         print_table('topics' => topics)
       end
@@ -100,12 +104,12 @@ module Bolt
                        moduledir: moduledir.to_s }.to_json)
       end
 
-      def print_targets(target_list, inventoryfile)
+      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: inventoryfile.to_s
+            file: (inventory_source || default_inventory).to_s
           },
           adhoc: {
             targets: target_list[:adhoc].map(&:name),
@@ -116,7 +120,7 @@ module Bolt
         )
       end
 
-      def print_target_info(target_list, _inventoryfile)
+      def print_target_info(target_list, _inventory_source, _default_inventory, _target_flag)
         targets = target_list.values.flatten
 
         @stream.puts ::JSON.pretty_generate(
@@ -125,7 +129,7 @@ module Bolt
         )
       end
 
-      def print_groups(groups)
+      def print_groups(groups, _inventory_source, _default_inventory)
         count = groups.count
         @stream.puts({ groups: groups,
                        count: count }.to_json)