bolt 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41eb3934a2ddce5d1021b66f5aca6eccfdb91bdedd5dc08cfdc1cfb4664f91e8
-  data.tar.gz: 8a04142fd9de53e8812cff0c540098a8548a8b18245e300835896b457a86d348
+  metadata.gz: aa3e5ea7d868b032557568e9635fcf159f00b81e4961dce4032246cc150a7c16
+  data.tar.gz: 0e9fada8a0518ab174412e21ec843091272cb0afe87980703ebd6d8ed91002dd
 SHA512:
-  metadata.gz: 24bc37edf14e9c5d3ef1b8df5d5ed9dd0161ebb44da96e0b2777703c5b71182179ebed740e5d67c04bad41b9ecdb6e0a40d5fcb5ec08eb59171da36a3d5a3756
-  data.tar.gz: 0e5795469709939091282a51df744076e87e40e5dad0f5bc6395d0d7927dcbf5f788bccf23bd5c455c29232faa958ddcbe5130626eb82d056404f8cb1e088cdd
+  metadata.gz: 66d8df12e0142b6d5872a40f7c0d97b0438c833e4681be6646e17b85496c3a9e1148ff0a2ff34572e0ce788861d928c406dddcb97feb5281ac0d7eb2d7d14ead
+  data.tar.gz: f6dafaa37a4af7633610e26cc084d69c865f0b8df18221d407f2ee077e58e0a582e88cccf49d3a590e7984d56d8ac467ee8704e6ac0e60cc7e37b1a846396d26

data/lib/bolt/analytics.rb

@@ -29,7 +29,7 @@ module Bolt
       yaml_plan_count: :cd13
     }.freeze
 
-    def self.build_client
+    def self.build_client(enabled = true)
       logger = Bolt::Logger.logger(self)
       begin
         config_file = config_path
@@ -38,7 +38,7 @@ module Bolt
         config = { 'disabled' => true }
       end
 
-      if config['disabled'] || ENV['BOLT_DISABLE_ANALYTICS']
+      if !enabled || config['disabled'] || ENV['BOLT_DISABLE_ANALYTICS']
         logger.debug "Analytics opt-out is set, analytics will be disabled"
         NoopClient.new
       else
@@ -80,12 +80,8 @@ module Bolt
         unless ENV['BOLT_DISABLE_ANALYTICS']
           msg = <<~ANALYTICS
             Bolt collects data about how you use it. You can opt out of providing this data.
-
-            To disable analytics data collection, add this line to ~/.puppetlabs/etc/bolt/analytics.yaml :
-              disabled: true
-
-            Read more about what data Bolt collects and why here:
-              https://puppet.com/docs/bolt/latest/bolt_installing.html#analytics-data-collection
+            To learn how to disable data collection, or see what data Bolt collects and why,
+            see http://pup.pt/bolt-analytics
           ANALYTICS
           Bolt::Logger.warn_once('analytics_opt_out', msg)
         end

data/lib/bolt/cli.rb

@@ -541,7 +541,11 @@ module Bolt
         end
         code = apply_manifest(options[:code], options[:targets], options[:object], options[:noop])
       else
-        executor = Bolt::Executor.new(config.concurrency, analytics, options[:noop], config.modified_concurrency)
+        executor = Bolt::Executor.new(config.concurrency,
+                                      analytics,
+                                      options[:noop],
+                                      config.modified_concurrency,
+                                      config.future)
         targets = options[:targets]
 
         results = nil
@@ -631,7 +635,18 @@ module Bolt
 
     def list_targets
       inventoryfile = config.inventoryfile || config.default_inventoryfile
+      outputter.print_targets(group_targets_by_source, inventoryfile)
+    end
 
+    def show_targets
+      inventoryfile = config.inventoryfile || config.default_inventoryfile
+      outputter.print_target_info(group_targets_by_source, inventoryfile)
+    end
+
+    # Returns a hash of targets sorted by those that are found in the
+    # inventory and those that are provided on the command line.
+    #
+    private def group_targets_by_source
       # Retrieve the known group and target names. This needs to be done before
       # updating targets, as that will add adhoc targets to the inventory.
       known_names = inventory.target_names
@@ -642,17 +657,7 @@ module Bolt
         known_names.include?(target.name)
       end
 
-      target_list = {
-        inventory: inventory_targets,
-        adhoc:     adhoc_targets
-      }
-
-      outputter.print_targets(target_list, inventoryfile)
-    end
-
-    def show_targets
-      update_targets(options)
-      outputter.print_target_info(options[:targets])
+      { inventory: inventory_targets, adhoc: adhoc_targets }
     end
 
     def list_groups
@@ -688,7 +693,11 @@ module Bolt
       plan_context = { plan_name: plan_name,
                        params: plan_arguments }
 
-      executor = Bolt::Executor.new(config.concurrency, analytics, options[:noop], config.modified_concurrency)
+      executor = Bolt::Executor.new(config.concurrency,
+                                    analytics,
+                                    options[:noop],
+                                    config.modified_concurrency,
+                                    config.future)
       if %w[human rainbow].include?(options.fetch(:format, 'human'))
         executor.subscribe(outputter)
       else
@@ -724,7 +733,11 @@ module Bolt
         Bolt::Logger.warn("empty_manifest", message)
       end
 
-      executor = Bolt::Executor.new(config.concurrency, analytics, noop, config.modified_concurrency)
+      executor = Bolt::Executor.new(config.concurrency,
+                                    analytics,
+                                    noop,
+                                    config.modified_concurrency,
+                                    config.future)
       executor.subscribe(outputter) if options.fetch(:format, 'human') == 'human'
       executor.subscribe(log_outputter)
       # apply logging looks like plan logging, so tell the outputter we're in a
@@ -809,15 +822,10 @@ module Bolt
     #
     def assert_project_file(project)
       unless project.project_file?
-        msg = if project.config_file.exist?
-                command = Bolt::Util.powershell? ? 'Update-BoltProject' : 'bolt project migrate'
-                "Detected Bolt configuration file #{project.config_file}, unable to install "\
-                "modules. To update to a project configuration file, run '#{command}'."
-              else
-                command = Bolt::Util.powershell? ? 'New-BoltProject' : 'bolt project init'
-                "Could not find project configuration file #{project.project_file}, unable "\
-                "to install modules. To create a Bolt project, run '#{command}'."
-              end
+        command = Bolt::Util.powershell? ? 'New-BoltProject' : 'bolt project init'
+
+        msg = "Could not find project configuration file #{project.project_file}, unable "\
+              "to install modules. To create a Bolt project, run '#{command}'."
 
         raise Bolt::Error.new(msg, 'bolt/missing-project-config-error')
       end
@@ -935,7 +943,7 @@ module Bolt
 
     def analytics
       @analytics ||= begin
-        client = Bolt::Analytics.build_client
+        client = Bolt::Analytics.build_client(config.analytics)
         client.bundled_content = bundled_content
         client
       end

data/lib/bolt/config.rb

@@ -169,6 +169,7 @@ module Bolt
       @config_files = []
 
       default_data = {
+        'analytics'           => true,
         'apply-settings'      => {},
         'color'               => true,
         'compile-concurrency' => Etc.nprocessors,
@@ -263,6 +264,8 @@ module Bolt
           # Disabled warnings are concatenated
           when 'disable-warnings'
             val1.concat(val2)
+          when 'analytics'
+            val1 && val2
           # All other values are overwritten
           else
             val2
@@ -328,13 +331,6 @@ module Bolt
     end
 
     def validate
-      if @data['future']
-        Bolt::Logger.warn(
-          "future_option",
-          "Configuration option 'future' no longer exposes future behavior."
-        )
-      end
-
       if @data['modulepath']&.include?(@project.managed_moduledir.to_s)
         raise Bolt::ValidationError,
               "Found invalid path in modulepath: #{@project.managed_moduledir}. This path "\
@@ -395,6 +391,10 @@ module Bolt
       @data['format'] = value
     end
 
+    def future
+      @data['future']
+    end
+
     def trace
       @data['trace']
     end
@@ -459,6 +459,10 @@ module Bolt
       Set.new(@project.disable_warnings + @data['disable-warnings'])
     end
 
+    def analytics
+      @data['analytics']
+    end
+
     # Check if there is a case-insensitive match to the path
     def check_path_case(type, paths)
       return if paths.nil?

data/lib/bolt/config/options.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require 'bolt/config/transport/ssh'
-require 'bolt/config/transport/winrm'
-require 'bolt/config/transport/orch'
+require 'bolt/config/transport/docker'
 require 'bolt/config/transport/local'
 require 'bolt/config/transport/lxd'
-require 'bolt/config/transport/docker'
+require 'bolt/config/transport/orch'
+require 'bolt/config/transport/podman'
 require 'bolt/config/transport/remote'
+require 'bolt/config/transport/ssh'
+require 'bolt/config/transport/winrm'
 
 module Bolt
   class Config
@@ -14,13 +15,14 @@ module Bolt
       # Transport config classes. Used to load default transport config which
       # gets passed along to the inventory.
       TRANSPORT_CONFIG = {
-        'ssh'    => Bolt::Config::Transport::SSH,
-        'winrm'  => Bolt::Config::Transport::WinRM,
-        'pcp'    => Bolt::Config::Transport::Orch,
+        'docker' => Bolt::Config::Transport::Docker,
         'local'  => Bolt::Config::Transport::Local,
         'lxd'    => Bolt::Config::Transport::LXD,
-        'docker' => Bolt::Config::Transport::Docker,
-        'remote' => Bolt::Config::Transport::Remote
+        'pcp'    => Bolt::Config::Transport::Orch,
+        'podman' => Bolt::Config::Transport::Podman,
+        'remote' => Bolt::Config::Transport::Remote,
+        'ssh'    => Bolt::Config::Transport::SSH,
+        'winrm'  => Bolt::Config::Transport::WinRM
       }.freeze
 
       # Plugin definition. This is used by the JSON schemas to indicate that an option
@@ -55,6 +57,13 @@ module Bolt
       # Definitions used to validate config options.
       # https://github.com/puppetlabs/bolt/blob/main/schemas/README.md
       OPTIONS = {
+        "analytics" => {
+          description: "Whether to disable analytics. Setting this option to 'false' in the system-wide "\
+                       "or user-level configuration will disable analytics for all projects, even if this "\
+                       "option is set to 'true' at the project level.",
+          type: [TrueClass, FalseClass],
+          _example: false
+        },
         "apply-settings" => {
           description: "A map of Puppet settings to use when applying Puppet code using the `apply` "\
                        "plan function or the `bolt apply` command.",
@@ -133,6 +142,20 @@ module Bolt
           _example: "json",
           _default: "human"
         },
+        "future" => {
+          description: "Enable new Bolt features that may include breaking changes.",
+          type: Hash,
+          properties: {
+            "file_paths" => {
+              description: "Load scripts from the `scripts/` directory of a module",
+              type: [TrueClass, FalseClass],
+              _example: true,
+              _default: false
+            }
+          },
+          _plugin: false,
+          _example: { 'file_paths' => true }
+        },
         "hiera-config" => {
           description: "The path to the Hiera configuration file.",
           type: String,
@@ -497,6 +520,12 @@ module Bolt
           _plugin: true,
           _example: { "job-poll-interval" => 15, "job-poll-timeout" => 30 }
         },
+        "podman" => {
+          description: "A map of configuration options for the podman transport.",
+          type: Hash,
+          _plugin: true,
+          _example: { "cleanup" => false, "tmpdir" => "/mount/tmp" }
+        },
         "remote" => {
           description: "A map of configuration options for the remote transport.",
           type: Hash,
@@ -532,6 +561,7 @@ module Bolt
 
       # Options that are available in a bolt-defaults.yaml file
       DEFAULTS_OPTIONS = %w[
+        analytics
         color
         compile-concurrency
         concurrency
@@ -551,12 +581,14 @@ module Bolt
 
       # Options that are available in a bolt-project.yaml file
       PROJECT_OPTIONS = %w[
+        analytics
         apply-settings
         color
         compile-concurrency
         concurrency
         disable-warnings
         format
+        future
         hiera-config
         log
         modulepath

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/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",
@@ -313,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
+        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)
@@ -452,29 +490,77 @@ module Bolt
         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 = +''
+
+        # 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"
+
+        @stream.puts info
+
+        print_inventory_summary(
+          target_list[:inventory].count,
+          target_list[:adhoc].count,
+          inventoryfile
+        )
+      end
+
+      def print_target_info(target_list, inventoryfile)
+        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 = +''
 
-        @stream.puts "INVENTORY FILE:"
-        if File.exist?(inventoryfile)
-          @stream.puts inventoryfile
+        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"
-      end
+        @stream.puts info
 
-      def print_target_info(targets)
-        @stream.puts ::JSON.pretty_generate(
-          targets: targets.map(&:detail)
+        print_inventory_summary(
+          inventory_targets.count,
+          adhoc_targets.count,
+          inventoryfile
         )
-        count = "#{targets.count} target#{'s' unless targets.count == 1}"
-        @stream.puts colorize(:green, count)
+      end
+
+      private def print_inventory_summary(inventory_count, adhoc_count, inventoryfile)
+        info = +''
+
+        # Add inventory file source
+        info << colorize(:cyan, "Inventory file\n")
+        info << if File.exist?(inventoryfile)
+                  indent(2, "#{inventoryfile}\n")
+                else
+                  indent(2, wrap("Tried to load inventory from #{inventoryfile}, but the file does not exist\n"))
+                end
+        info << "\n"
+
+        # 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)
+
+        @stream.puts info
       end
 
       def print_groups(groups)

data/lib/bolt/outputter/json.rb

@@ -116,7 +116,9 @@ module Bolt
         )
       end
 
-      def print_target_info(targets)
+      def print_target_info(target_list, _inventoryfile)
+        targets = target_list.values.flatten
+
         @stream.puts ::JSON.pretty_generate(
           targets: targets.map(&:detail),
           count: targets.count

data/lib/bolt/plugin.rb

@@ -178,8 +178,6 @@ module Bolt
     end
 
     def add_ruby_plugin(plugin_name)
-      raise PluginError::LoadingDisabled, plugin_name unless @load_plugins
-
       cls_name = Bolt::Util.snake_name_to_class_name(plugin_name)
       filename = "bolt/plugin/#{plugin_name}"
       require filename
@@ -203,8 +201,6 @@ module Bolt
       }
 
       mod = modules[plugin_name]
-      raise PluginError::Unknown, plugin_name unless mod&.plugin?
-      raise PluginError::LoadingDisabled, plugin_name unless @load_plugins
 
       plugin = Bolt::Plugin::Module.load(mod, opts)
       add_plugin(plugin)
@@ -224,6 +220,12 @@ module Bolt
       end
     end
 
+    def known_plugin?(plugin_name)
+      @plugins.include?(plugin_name) ||
+        RUBY_PLUGINS.include?(plugin_name) ||
+        (modules.include?(plugin_name) && modules[plugin_name].plugin?)
+    end
+
     def get_hook(plugin_name, hook)
       plugin = by_name(plugin_name)
       raise PluginError::Unknown, plugin_name unless plugin
@@ -235,16 +237,16 @@ module Bolt
 
     # Calling by_name or get_hook will load any module based plugin automatically
     def by_name(plugin_name)
-      return @plugins[plugin_name] if @plugins.include?(plugin_name)
-      begin
-        if RUBY_PLUGINS.include?(plugin_name)
+      if known_plugin?(plugin_name)
+        if @plugins.include?(plugin_name)
+          @plugins[plugin_name]
+        elsif !@load_plugins
+          raise PluginError::LoadingDisabled, plugin_name
+        elsif RUBY_PLUGINS.include?(plugin_name)
           add_ruby_plugin(plugin_name)
-        elsif !@unknown.include?(plugin_name)
+        else
           add_module_plugin(plugin_name)
         end
-      rescue PluginError::Unknown
-        @unknown << plugin_name
-        nil
       end
     end
 

data/lib/bolt/transport/docker.rb

@@ -2,7 +2,7 @@
 
 require 'json'
 require 'shellwords'
-require 'bolt/transport/base'
+require 'bolt/transport/simple'
 
 module Bolt
   module Transport

data/lib/bolt/transport/docker/connection.rb

@@ -34,6 +34,10 @@ module Bolt
           @container_info["Id"]
         end
 
+        def run_cmd(cmd, env_vars)
+          Bolt::Util.exec_docker(cmd, env_vars)
+        end
+
         private def env_hash
           # Set the DOCKER_HOST if we are using a non-default service-url
           @docker_host.nil? ? {} : { 'DOCKER_HOST' => @docker_host }
@@ -90,7 +94,7 @@ module Bolt
 
         def upload_file(source, destination)
           @logger.trace { "Uploading #{source} to #{destination}" }
-          _out, err, stat = Bolt::Util.exec_docker(['cp', source, "#{container_id}:#{destination}"], env_hash)
+          _out, err, stat = run_cmd(['cp', source, "#{container_id}:#{destination}"], env_hash)
           unless stat.exitstatus.zero?
             raise "Error writing to container #{container_id}: #{err}"
           end
@@ -104,7 +108,7 @@ module Bolt
           # copy the *contents* of the directory.
           # https://docs.docker.com/engine/reference/commandline/cp/
           FileUtils.mkdir_p(destination)
-          _out, err, stat = Bolt::Util.exec_docker(['cp', "#{container_id}:#{source}", destination], env_hash)
+          _out, err, stat = run_cmd(['cp', "#{container_id}:#{source}", destination], env_hash)
           unless stat.exitstatus.zero?
             raise "Error downloading content from container #{container_id}: #{err}"
           end
@@ -119,9 +123,9 @@ module Bolt
         # @param arguments [Array] Arguments to pass to the docker command
         #   e.g. 'src' and 'dest' for `docker cp <src> <dest>
         # @return [Object] Ruby object representation of the JSON string
-        private def execute_local_json_command(subcommand, arguments = [])
+        def execute_local_json_command(subcommand, arguments = [])
           cmd = [subcommand, '--format', '{{json .}}'].concat(arguments)
-          out, _err, _stat = Bolt::Util.exec_docker(cmd, env_hash)
+          out, _err, _stat = run_cmd(cmd, env_hash)
           extract_json(out)
         end
 

data/lib/bolt/transport/podman.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+require 'bolt/transport/base'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      def with_connection(target)
+        conn = Connection.new(target)
+        conn.connect
+        yield conn
+      end
+    end
+  end
+end
+
+require 'bolt/transport/podman/connection'

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'logging'
+require 'bolt/node/errors'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      class Connection < Connection
+        attr_reader :user, :target
+
+        def initialize(target)
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
+          @target = target
+          @user = ENV['USER'] || Etc.getlogin
+          @logger = Bolt::Logger.logger(target.safe_name)
+          @container_info = {}
+          @logger.trace("Initializing podman connection to #{target.safe_name}")
+        end
+
+        def run_cmd(cmd, env_vars)
+          Bolt::Util.exec_podman(cmd, env_vars)
+        end
+
+        def shell
+          @shell ||= if Bolt::Util.windows?
+                       Bolt::Shell::Powershell.new(target, self)
+                     else
+                       Bolt::Shell::Bash.new(target, self)
+                     end
+        end
+
+        def connect
+          # We don't actually have a connection, but we do need to
+          # check that the container exists and is running.
+          ps = execute_local_json_command('ps')
+          container = Array(ps).find { |item|
+            item["ID"].to_s.eql?(@target.host) ||
+              item["Id"].to_s.start_with?(@target.host) ||
+              Array(item["Names"]).include?(@target.host)
+          }
+          raise "Could not find a container with name or ID matching '#{@target.host}'" if container.nil?
+          # Now find the indepth container information
+          id = container["ID"] || container["Id"]
+          output = execute_local_json_command('inspect', [id])
+          # Store the container information for later
+          @container_info = output.first
+          @logger.trace { "Opened session" }
+          true
+        rescue StandardError => e
+          raise Bolt::Node::ConnectError.new(
+            "Failed to connect to #{target.safe_name}: #{e.message}",
+            'CONNECT_ERROR'
+          )
+        end
+
+        # Executes a command inside the target container. This is called from the shell class.
+        #
+        # @param command [string] The command to run
+        def execute(command)
+          args = []
+          args += %w[--interactive]
+          args += %w[--tty] if target.options['tty']
+          args += @env_vars if @env_vars
+
+          if target.options['shell-command'] && !target.options['shell-command'].empty?
+            # escape any double quotes in command
+            command = command.gsub('"', '\"')
+            command = "#{target.options['shell-command']} \"#{command}\""
+          end
+
+          podman_command = %w[podman exec] + args + [container_id] + Shellwords.split(command)
+          @logger.trace { "Executing: #{podman_command.join(' ')}" }
+
+          Open3.popen3(*podman_command)
+        rescue StandardError
+          @logger.trace { "Command aborted" }
+          raise
+        end
+
+        # Converts the JSON encoded STDOUT string from the podman cli into ruby objects
+        #
+        # @param stdout [String] The string to convert
+        # @return [Object] Ruby object representation of the JSON string
+        private def extract_json(stdout)
+          # Podman renders the output in pretty JSON, which results in a newline
+          # appearing in the output before the closing bracket.
+          # should we only get a single line with no newline at all, we also
+          # assume it is a single minified JSON object
+          stdout.strip!
+          newline = stdout.index("\n") || -1
+          bracket = stdout.index('}') || -1
+          JSON.parse(stdout) if bracket > newline
+        end
+      end
+    end
+  end
+end

data/lib/bolt/util.rb

@@ -343,6 +343,17 @@ module Bolt
         Open3.capture3(env, 'docker', *cmd, { binmode: true })
       end
 
+      # Executes a Podman CLI command. This is useful for running commands as
+      # part of this class without having to go through the `execute`
+      # function and manage pipes.
+      #
+      # @param cmd [String] The podman command and arguments to run
+      #   e.g. 'cp <src> <dest>' for `podman cp <src> <dest>`
+      # @return [String, String, Process::Status] The output of the command: STDOUT, STDERR, Process Status
+      def exec_podman(cmd, env = {})
+        Open3.capture3(env, 'podman', *cmd, { binmode: true })
+      end
+
       # Formats a map of environment variables to be passed to a command that
       # accepts repeated `--env` flags
       #

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '3.5.0'
+  VERSION = '3.6.0'
 end

data/lib/bolt_server/transport_app.rb

@@ -703,6 +703,9 @@ module BoltServer
           connect_plugin = BoltServer::Plugin::PuppetConnectData.new(body['puppet_connect_data'])
           plugins = Bolt::Plugin.setup(context[:config], context[:pal], load_plugins: false)
           plugins.add_plugin(connect_plugin)
+          %w[aws_inventory azure_inventory gcloud_inventory].each do |plugin_name|
+            plugins.add_module_plugin(plugin_name) if plugins.known_plugin?(plugin_name)
+          end
           inventory = Bolt::Inventory.from_config(context[:config], plugins)
           target_list = inventory.get_targets('all').map do |targ|
             targ.to_h.merge({ 'transport' => targ.transport, 'plugin_hooks' => targ.plugin_hooks })

data/lib/bolt_spec/plans/mock_executor.rb

@@ -17,13 +17,14 @@ module BoltSpec
 
     # Nothing on the executor is 'public'
     class MockExecutor
-      attr_reader :noop, :error_message, :in_parallel, :transports
+      attr_reader :noop, :error_message, :in_parallel, :transports, :future
       attr_accessor :run_as, :transport_features, :execute_any_plan
 
       def initialize(modulepath)
         @noop = false
         @run_as = nil
         @in_parallel = false
+        @future = {}
         @error_message = nil
         @allow_apply = false
         @modulepath = [modulepath].flatten.map { |path| File.absolute_path(path) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-29 00:00:00.000000000 Z
+date: 2021-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -473,6 +473,7 @@ files:
 - lib/bolt/config/transport/lxd.rb
 - lib/bolt/config/transport/options.rb
 - lib/bolt/config/transport/orch.rb
+- lib/bolt/config/transport/podman.rb
 - lib/bolt/config/transport/remote.rb
 - lib/bolt/config/transport/ssh.rb
 - lib/bolt/config/transport/winrm.rb
@@ -564,6 +565,8 @@ files:
 - lib/bolt/transport/lxd/connection.rb
 - lib/bolt/transport/orch.rb
 - lib/bolt/transport/orch/connection.rb
+- lib/bolt/transport/podman.rb
+- lib/bolt/transport/podman/connection.rb
 - lib/bolt/transport/remote.rb
 - lib/bolt/transport/simple.rb
 - lib/bolt/transport/ssh.rb