bolt 3.3.0 → 3.7.0

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/inventory/options.rb

@@ -11,8 +11,10 @@ module Bolt
         facts
         features
         groups
+        plugin_hooks
         targets
         vars
+        version
       ].freeze
 
       # Definitions used to validate the data.
@@ -123,6 +125,13 @@ module Bolt
           description: "A map of variables for the group or target.",
           type: Hash,
           _plugin: true
+        },
+        "version" => {
+          description: "The version of the inventory file.",
+          type: Integer,
+          _plugin: false,
+          _example: 2,
+          _default: 2
         }
       }.freeze
     end

data/lib/bolt/inventory/target.rb

@@ -92,6 +92,7 @@ module Bolt
       end
 
       def add_facts(new_facts = {})
+        validate_fact_names(new_facts)
         @facts = Bolt::Util.deep_merge(@facts, new_facts)
       end
 
@@ -153,9 +154,24 @@ module Bolt
           raise Bolt::UnknownTransportError.new(transport, uri)
         end
 
+        validate_fact_names(facts)
+
         transport_config
       end
 
+      # Validate fact names and issue a deprecation warning if any fact names have a dot.
+      #
+      private def validate_fact_names(facts)
+        if (dotted = facts.keys.select { |name| name.include?('.') }).any?
+          Bolt::Logger.deprecate(
+            'dotted_fact_name',
+            "Target '#{safe_name}' includes dotted fact names: '#{dotted.join("', '")}'. Dotted fact "\
+            "names are deprecated and Bolt does not automatically convert facts with dotted names to "\
+            "structured facts. For more information, see https://pup.pt/bolt-dotted-facts"
+          )
+        end
+      end
+
       def host
         @uri_obj.hostname || transport_config['host']
       end

data/lib/bolt/node/output.rb

@@ -6,13 +6,23 @@ require 'bolt/result'
 module Bolt
   class Node
     class Output
-      attr_reader :stdout, :stderr
+      attr_reader :stderr, :stdout, :merged_output
       attr_accessor :exit_code
 
       def initialize
-        @stdout = StringIO.new
-        @stderr = StringIO.new
-        @exit_code = 'unknown'
+        @stdout        = StringIO.new
+        @stderr        = StringIO.new
+        @merged_output = StringIO.new
+        @exit_code     = 'unknown'
+      end
+
+      def to_h
+        {
+          'stdout'        => @stdout.string,
+          'stderr'        => @stderr.string,
+          'merged_output' => @merged_output.string,
+          'exit_code'     => @exit_code
+        }
       end
     end
   end

data/lib/bolt/outputter/human.rb

@@ -6,6 +6,7 @@ module Bolt
   class Outputter
     class Human < Bolt::Outputter
       COLORS = {
+        dim:    "2", # Dim, the other color of the rainbow
         red:    "31",
         green:  "32",
         yellow: "33",
@@ -92,6 +93,10 @@ module Bolt
             print_plan_start(event)
           when :plan_finish
             print_plan_finish(event)
+          when :container_start
+            print_container_start(event) if plan_logging?
+          when :container_finish
+            print_container_finish(event) if plan_logging?
           when :start_spin
             start_spin
           when :stop_spin
@@ -112,6 +117,34 @@ module Bolt
         @stream.puts(colorize(:green, "Started on #{target.safe_name}..."))
       end
 
+      def print_container_result(result)
+        if result.success?
+          @stream.puts(colorize(:green, "Finished running container #{result.object}:"))
+        else
+          @stream.puts(colorize(:red, "Failed running container #{result.object}:"))
+        end
+
+        if result.error_hash
+          @stream.puts(colorize(:red, remove_trail(indent(2, result.error_hash['msg']))))
+          return 0
+        end
+
+        # Only print results if there's something other than empty string and hash
+        safe_value = result.safe_value
+        if safe_value['stdout'].strip.empty? && safe_value['stderr'].strip.empty?
+          @stream.puts(indent(2, "Running container #{result.object} completed successfully with no result"))
+        else
+          unless safe_value['stdout'].strip && safe_value['stdout'].strip.empty?
+            @stream.puts(indent(2, "STDOUT:"))
+            @stream.puts(indent(4, safe_value['stdout']))
+          end
+          unless safe_value['stderr'].strip.empty?
+            @stream.puts(indent(2, "STDERR:"))
+            @stream.puts(indent(4, safe_value['stderr']))
+          end
+        end
+      end
+
       def print_result(result)
         if result.success?
           @stream.puts(colorize(:green, "Finished on #{result.target.safe_name}:"))
@@ -142,16 +175,9 @@ module Bolt
           end
 
           # Use special handling if the result looks like a command or script result
-          if result.generic_value.keys == %w[stdout stderr exit_code]
+          if result.generic_value.keys == %w[stdout stderr merged_output exit_code]
             safe_value = result.safe_value
-            unless safe_value['stdout'].strip.empty?
-              @stream.puts(indent(2, "STDOUT:"))
-              @stream.puts(indent(4, safe_value['stdout']))
-            end
-            unless safe_value['stderr'].strip.empty?
-              @stream.puts(indent(2, "STDERR:"))
-              @stream.puts(indent(4, safe_value['stderr']))
-            end
+            @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)))
           end
@@ -187,6 +213,25 @@ module Bolt
         @stream.puts(colorize(:green, message))
       end
 
+      def print_container_start(image:, **_kwargs)
+        @stream.puts(colorize(:green, "Starting: run container '#{image}'"))
+      end
+
+      def print_container_finish(event)
+        result = if event[:result].is_a?(Bolt::ContainerFailure)
+                   event[:result].result
+                 else
+                   event[:result]
+                 end
+
+        if result.success?
+          @stream.puts(colorize(:green, "Finished: run container '#{result.object}' succeeded."))
+        else
+          @stream.puts(colorize(:red, "Finished: run container '#{result.object}' failed."))
+        end
+        print_container_result(result) if @verbose
+      end
+
       def print_plan_start(event)
         @plan_depth += 1
         # We use this event to both mark the start of a plan _and_ to enable
@@ -269,78 +314,115 @@ module Bolt
 
       # @param [Hash] task A hash representing the task
       def print_task_info(task)
-        # Building lots of strings...
-        pretty_params = +""
-        task_info = +""
-        usage = if Bolt::Util.powershell?
-                  +"Invoke-BoltTask -Name #{task.name} -Targets <targets>"
+        params = (task.parameters || []).sort
+
+        info = +''
+
+        # Add task name and description
+        info << colorize(:cyan, "#{task.name}\n")
+        info << if task.description
+                  indent(2, task.description.chomp)
                 else
-                  +"bolt task run #{task.name} --targets <targets>"
+                  indent(2, 'No description')
                 end
-
-        task.parameters&.each do |k, v|
-          pretty_params << "- #{k}: #{v['type'] || 'Any'}\n"
-          pretty_params << "    Default: #{v['default'].inspect}\n" if v.key?('default')
-          pretty_params << "    #{v['description']}\n" if v['description']
-          usage << if v['type'].start_with?("Optional")
-                     " [#{k}=<value>]"
+        info << "\n\n"
+
+        # Build usage string
+        usage = +''
+        usage << if Bolt::Util.powershell?
+                   "Invoke-BoltTask -Name #{task.name} -Targets <targets>"
+                 else
+                   "bolt task run #{task.name} --targets <targets>"
+                 end
+        usage << (Bolt::Util.powershell? ? ' [-Noop]' : ' [--noop]') if task.supports_noop
+        params.each do |name, data|
+          usage << if data['type']&.start_with?('Optional')
+                     " [#{name}=<value>]"
                    else
-                     " #{k}=<value>"
+                     " #{name}=<value>"
                    end
         end
 
-        if task.supports_noop
-          usage << Bolt::Util.powershell? ? '[-Noop]' : '[--noop]'
+        # Add usage
+        info << colorize(:cyan, "Usage\n")
+        info << indent(2, wrap(usage))
+        info << "\n"
+
+        # Add parameters, if any
+        if params.any?
+          info << colorize(:cyan, "Parameters\n")
+          params.each do |name, data|
+            info << indent(2, "#{colorize(:yellow, name)}  #{colorize(:dim, data['type'] || 'Any')}\n")
+            info << indent(4, "#{wrap(data['description']).chomp}\n") if data['description']
+            info << indent(4, "Default: #{data['default'].inspect}\n") if data.key?('default')
+            info << "\n"
+          end
         end
 
-        task_info << "\n#{task.name}"
-        task_info << " - #{task.description}" if task.description
-        task_info << "\n\n"
-        task_info << "USAGE:\n#{usage}\n\n"
-        task_info << "PARAMETERS:\n#{pretty_params}\n" unless pretty_params.empty?
-        task_info << "MODULE:\n"
-
+        # Add module location
         path = task.files.first['path'].chomp("/tasks/#{task.files.first['name']}")
-        task_info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
-                       "built-in module"
-                     else
-                       path
-                     end
-        @stream.puts(task_info)
+        info << colorize(:cyan, "Module\n")
+        info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
+                  indent(2, 'built-in module')
+                else
+                  indent(2, path)
+                end
+
+        @stream.puts info
       end
 
       # @param [Hash] plan A hash representing the plan
       def print_plan_info(plan)
-        # Building lots of strings...
-        pretty_params = +""
-        plan_info = +""
-        usage = if Bolt::Util.powershell?
-                  +"Invoke-BoltPlan -Name #{plan['name']}"
+        params = plan['parameters'].sort
+
+        info = +''
+
+        # Add plan name and description
+        info << colorize(:cyan, "#{plan['name']}\n")
+        info << if plan['description']
+                  indent(2, plan['description'].chomp)
                 else
-                  +"bolt plan run #{plan['name']}"
+                  indent(2, 'No description')
                 end
+        info << "\n\n"
+
+        # Build the usage string
+        usage = +''
+        usage << if Bolt::Util.powershell?
+                   "Invoke-BoltPlan -Name #{plan['name']}"
+                 else
+                   "bolt plan run #{plan['name']}"
+                 end
+        params.each do |name, data|
+          usage << (data.include?('default_value') ? " [#{name}=<value>]" : " #{name}=<value>")
+        end
 
-        plan['parameters'].each do |name, p|
-          pretty_params << "- #{name}: #{p['type']}\n"
-          pretty_params << "    Default: #{p['default_value']}\n" unless p['default_value'].nil?
-          pretty_params << "    #{p['description']}\n" if p['description']
-          usage << (p.include?('default_value') ? " [#{name}=<value>]" : " #{name}=<value>")
+        # Add usage
+        info << colorize(:cyan, "Usage\n")
+        info << indent(2, wrap(usage))
+        info << "\n"
+
+        # Add parameters, if any
+        if params.any?
+          info << colorize(:cyan, "Parameters\n")
+
+          params.each do |name, data|
+            info << indent(2, "#{colorize(:yellow, name)}  #{colorize(:dim, data['type'])}\n")
+            info << indent(4, "#{wrap(data['description']).chomp}\n") if data['description']
+            info << indent(4, "Default: #{data['default_value']}\n") unless data['default_value'].nil?
+            info << "\n"
+          end
         end
 
-        plan_info << "\n#{plan['name']}"
-        plan_info << " - #{plan['description']}" if plan['description']
-        plan_info << "\n\n"
-        plan_info << "USAGE:\n#{usage}\n\n"
-        plan_info << "PARAMETERS:\n#{pretty_params}\n" unless plan['parameters'].empty?
-        plan_info << "MODULE:\n"
+        # Add module location
+        info << colorize(:cyan, "Module\n")
+        info << if plan['module'].start_with?(Bolt::Config::Modulepath::MODULES_PATH)
+                  indent(2, 'built-in module')
+                else
+                  indent(2, plan['module'])
+                end
 
-        path = plan['module']
-        plan_info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
-                       "built-in module"
-                     else
-                       path
-                     end
-        @stream.puts(plan_info)
+        @stream.puts info
       end
 
       def print_plans(plans, modulepath)
@@ -401,42 +483,115 @@ 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  = []
         targets += target_list[:inventory].map { |target| [target.name, nil] }
         targets += target_list[:adhoc].map { |target| [target.name, adhoc] }
 
-        if targets.any?
-          @stream.puts format_table(targets, 0, 2)
-          @stream.puts
-        end
+        info = +''
 
-        @stream.puts "INVENTORY FILE:"
-        if File.exist?(inventoryfile)
-          @stream.puts inventoryfile
+        # Add target list
+        info << colorize(:cyan, "Targets\n")
+        info << if targets.any?
+                  format_table(targets, 2, 2).to_s
+                else
+                  indent(2, 'No targets')
+                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)
+
+        @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)
+
+        info = +''
+
+        if targets.any?
+          adhoc = 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 << "\n"
+            info << indent(2, target.detail.to_yaml.lines.drop(1).join)
+            info << "\n"
+          end
         else
-          @stream.puts wrap("Tried to load inventory from #{inventoryfile}, but the file does not exist")
+          info << colorize(:cyan, "Targets\n")
+          info << indent(2, "No targets\n\n")
         end
 
-        @stream.puts "\nTARGET COUNT:"
-        @stream.puts "#{targets.count} total, #{target_list[:inventory].count} from inventory, "\
-                     "#{target_list[:adhoc].count} adhoc"
+        info << format_inventory_source(inventory_source, default_inventory)
+        info << format_target_summary(inventory_targets.count, adhoc_targets.count, target_flag, true)
+
+        @stream.puts info
       end
 
-      def print_target_info(targets)
-        @stream.puts ::JSON.pretty_generate(
-          targets: targets.map(&:detail)
-        )
-        count = "#{targets.count} target#{'s' unless targets.count == 1}"
-        @stream.puts colorize(:green, count)
+      private def format_inventory_source(inventory_source, default_inventory)
+        info = +''
+
+        # Add inventory file source
+        info << colorize(:cyan, "Inventory source\n")
+        info << if inventory_source
+                  indent(2, "#{inventory_source}\n")
+                else
+                  indent(2, wrap("Tried to load inventory from #{default_inventory}, but the file does not exist\n"))
+                end
+        info << "\n"
       end
 
-      def print_groups(groups)
-        count = "#{groups.count} group#{'s' unless groups.count == 1}"
-        @stream.puts groups.join("\n")
-        @stream.puts colorize(:green, count)
+      private def format_target_summary(inventory_count, adhoc_count, target_flag, detail_flag)
+        info = +''
+
+        # Add target count summary
+        count = "#{inventory_count + adhoc_count} total, "\
+                "#{inventory_count} from inventory, "\
+                "#{adhoc_count} adhoc"
+        info << colorize(:cyan, "Target count\n")
+        info << indent(2, count)
+
+        # 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, 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`
@@ -452,6 +607,10 @@ module Bolt
           @stream.puts("Plan completed successfully with no result")
         when Bolt::ApplyFailure, Bolt::RunFailure
           print_result_set(value.result_set)
+        when Bolt::ContainerResult
+          print_container_result(value)
+        when Bolt::ContainerFailure
+          print_container_result(value.result)
         when Bolt::ResultSet
           print_result_set(value)
         else