bolt 3.5.0 → 3.8.0

data/lib/bolt/config/transport/podman.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+require 'bolt/config/transport/base'
+
+module Bolt
+  class Config
+    module Transport
+      class Podman < Base
+        OPTIONS = %w[
+          cleanup
+          host
+          interpreters
+          shell-command
+          tmpdir
+          tty
+        ].freeze
+
+        DEFAULTS = {
+          'cleanup' => true
+        }.freeze
+
+        private def validate
+          super
+
+          if @config['interpreters']
+            @config['interpreters'] = normalize_interpreters(@config['interpreters'])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/executor.rb

@@ -12,34 +12,37 @@ require 'bolt/config'
 require 'bolt/result_set'
 require 'bolt/puppetdb'
 # Load transports
-require 'bolt/transport/ssh'
-require 'bolt/transport/winrm'
-require 'bolt/transport/orch'
+require 'bolt/transport/docker'
 require 'bolt/transport/local'
 require 'bolt/transport/lxd'
-require 'bolt/transport/docker'
+require 'bolt/transport/orch'
+require 'bolt/transport/podman'
 require 'bolt/transport/remote'
+require 'bolt/transport/ssh'
+require 'bolt/transport/winrm'
 require 'bolt/yarn'
 
 module Bolt
   TRANSPORTS = {
-    ssh: Bolt::Transport::SSH,
-    winrm: Bolt::Transport::WinRM,
-    pcp: Bolt::Transport::Orch,
+    docker: Bolt::Transport::Docker,
     local: Bolt::Transport::Local,
     lxd: Bolt::Transport::LXD,
-    docker: Bolt::Transport::Docker,
-    remote: Bolt::Transport::Remote
+    pcp: Bolt::Transport::Orch,
+    podman: Bolt::Transport::Podman,
+    remote: Bolt::Transport::Remote,
+    ssh: Bolt::Transport::SSH,
+    winrm: Bolt::Transport::WinRM
   }.freeze
 
   class Executor
-    attr_reader :noop, :transports, :in_parallel
+    attr_reader :noop, :transports, :in_parallel, :future
     attr_accessor :run_as
 
     def initialize(concurrency = 1,
                    analytics = Bolt::Analytics::NoopClient.new,
                    noop = false,
-                   modified_concurrency = false)
+                   modified_concurrency = false,
+                   future = {})
       # lazy-load expensive gem code
       require 'concurrent'
       @analytics = analytics
@@ -64,6 +67,7 @@ module Bolt
       @noop = noop
       @run_as = nil
       @in_parallel = false
+      @future = future
       @pool = if concurrency > 0
                 Concurrent::ThreadPoolExecutor.new(name: 'exec', max_threads: concurrency)
               else

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/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

@@ -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",
@@ -173,12 +174,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
@@ -292,7 +297,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)
@@ -313,78 +318,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
+        info << "\n\n"
 
-        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>]"
+        # 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"
 
-        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>")
+        # 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_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 usage
+        info << colorize(:cyan, "Usage\n")
+        info << indent(2, wrap(usage))
+        info << "\n"
 
-        path = plan['module']
-        plan_info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
-                       "built-in module"
-                     else
-                       path
-                     end
-        @stream.puts(plan_info)
+        # 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
+
+        # 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
+
+        @stream.puts info
       end
 
       def print_plans(plans, modulepath)
@@ -445,42 +487,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`