bolt 1.45.0 → 1.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b4c5859fab6ec57cac9d5ad791434aabfea666711f773f307d296df25274a9
-  data.tar.gz: 8dceb70532864e93b15c9237fff7ef803dba83650519f54dc60bbbce7e85a991
+  metadata.gz: 8d8c51d1ab9354303ccda2f36ebd31553fa0d8bf91adfe2e505e701cb8fc32eb
+  data.tar.gz: f092a00fc4ea73fea86b54e6d36f535e873a15d79d00bc85bae433b5fa6eace5
 SHA512:
-  metadata.gz: 88716d23b4acaf2bf97fa73dbd96d802c185591bc1ffa1115268c1c27362be35e6a3e94e8f9a75c3d65e437c5aaf176776a2789ce2c9d7cbeeddd3db88496659
-  data.tar.gz: 8875843ed41a1cba383997f5fbc7e865ae0f8e0a401e84196d9339fd9fdde58652ca99128ed1527a61afa46fbb526abbf13dafd67f22729b14db5739a176f53c
+  metadata.gz: 741f8a885261e3b50413201fcfb0688d5a0c39a593a6225e9472c2822a114ae135be3b3fb30ee0433d0572ec4440f6cc0f505e10727098d55613b722fd9d86aa
+  data.tar.gz: 3bce21f684265bd81f23b2a182c6d3bdc858a742faa28591a2483836dea04c736282d0e3551cd54843c7276d85d2e27e1f0794e956a7d973f57493e18973311a

data/lib/bolt/config.rb

@@ -4,6 +4,7 @@ require 'etc'
 require 'logging'
 require 'pathname'
 require 'bolt/boltdir'
+require 'bolt/logger'
 require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
 require 'bolt/transport/orch'
@@ -36,11 +37,69 @@ module Bolt
                   :puppetfile_config, :plugins, :plugin_hooks, :future, :trusted_external
     attr_writer :modulepath
 
-    TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions sudo-executable
-                           private-key tty tmpdir user connect-timeout disconnect-timeout
-                           cacert token-file service-url interpreters file-protocol smb-port realm].freeze
-
-    PUPPETFILE_OPTIONS = %w[proxy forge].freeze
+    OPTIONS = {
+      "color"                    => "Whether to use colored output when printing messages to the console.",
+      "compile-concurrency"      => "The maximum number of simultaneous manifest block compiles.",
+      "concurrency"              => "The number of threads to use when executing on remote targets.",
+      "format"                   => "The format to use when printing results. Options are `human` and `json`.",
+      "hiera-config"             => "The path to your Hiera config.",
+      "interpreters"             => "A map of an extension name to the absolute path of an executable, "\
+                                    "enabling you to override the shebang defined in a task executable. The "\
+                                    "extension can optionally be specified with the `.` character (`.py` and "\
+                                    "`py` both map to a task executable `task.py`) and the extension is case "\
+                                    "sensitive. The transports that support interpreter configuration are "\
+                                    "`docker`, `local`, `ssh`, and `winrm`. When a target's name is `localhost`, "\
+                                    "Ruby tasks run with the Bolt Ruby interpreter by default.",
+      "inventoryfile"            => "The path to a structured data inventory file used to refer to groups of "\
+                                    "targets on the command line and from plans.",
+      "log"                      => "The configuration of the logfile output. Configuration can be set for "\
+                                    "`console` and the path to a log file, such as `~/.puppetlabs/bolt/debug.log`.",
+      "modulepath"               => "The module path for loading tasks and plan code. This is either an array "\
+                                    "of directories or a string containing a list of directories separated by the "\
+                                    "OS-specific PATH separator.",
+      "plugin_hooks"             => "Which plugins a specific hook should use.",
+      "puppetfile"               => "A map containing options for the `bolt puppetfile install` command.",
+      "save-rerun"               => "Whether to update `.rerun.json` in the Bolt project directory. If "\
+                                    "your target names include passwords, set this value to `false` to avoid "\
+                                    "writing passwords to disk.",
+      "transport"                => "The default transport to use when the transport for a target is not "\
+                                    "specified in the URL or inventory.",
+      "trusted-external-command" => "The path to an executable on the Bolt controller that can produce "\
+                                    "external trusted facts. **External trusted facts are experimental in both "\
+                                    "Puppet and Bolt and this API may change or be removed.**",
+      "future"                   => "Whether to use new, breaking changes. This allows testing if Bolt content "\
+                                    "is compatible with expected future behavior."
+    }.freeze
+
+    DEFAULT_OPTIONS = {
+      "color" => true,
+      "concurrency" => 100,
+      "compile-concurrency" => "Number of cores",
+      "format" => "human",
+      "hiera-config" => "Boltdir/hiera.yaml",
+      "inventoryfile" => "Boltdir/inventory.yaml",
+      "modulepath" => ["Boltdir/modules", "Boltdir/site-modules", "Boltdir/site"],
+      "save-rerun" => true,
+      "future" => false
+    }.freeze
+
+    PUPPETFILE_OPTIONS = {
+      "forge" => "A subsection that can have its own `proxy` setting to set an HTTP proxy for Forge operations "\
+                 "only, and a `baseurl` setting to specify a different Forge host.",
+      "proxy" => "The HTTP proxy to use for Git and Forge operations."
+    }.freeze
+
+    LOG_OPTIONS = {
+      "append" => "Add output to an existing log file. Available only for logs output to a "\
+                  "filepath.",
+      "level"  => "The type of information in the log. Either `debug`, `info`, `notice`, "\
+                  "`warn`, or `error`."
+    }.freeze
+
+    DEFAULT_LOG_OPTIONS = {
+      "append" => true,
+      "level"  => "`warn` for console, `notice` for file"
+    }.freeze
 
     def self.default
       new(Bolt::Boltdir.new('.'), {})
@@ -194,8 +253,10 @@ module Bolt
       @compile_concurrency = options[:'compile-concurrency'] if options[:'compile-concurrency']
 
       TRANSPORTS.each_key do |transport|
+        # Get the options first since transport is modified in the next line
+        transport_options = TRANSPORTS[transport]::OPTIONS.keys.map(&:to_sym)
         transport = @transports[transport]
-        TRANSPORT_OPTIONS.each do |key|
+        transport_options.each do |key|
           if options[key]
             transport[key.to_s] = Bolt::Util.walk_keys(options[key], &:to_s)
           end

data/lib/bolt/outputter/human.rb

@@ -96,12 +96,15 @@ module Bolt
           end
         end
 
-        if result.message
-          @stream.puts(remove_trail(indent(2, result.message)))
-        end
+        # Only print results if there's something other than empty string and hash
+        if result.value.empty? || (result.value.keys == ['_output'] && !result.message?)
+          @stream.puts(indent(2, "#{result.action.capitalize} completed successfully with no result"))
+        else
+          # Only print messages that have something other than whitespace
+          if result.message?
+            @stream.puts(remove_trail(indent(2, result.message)))
+          end
 
-        # There is more information to output
-        if result.generic_value
           # Use special handling if the result looks like a command or script result
           if result.generic_value.keys == %w[stdout stderr exit_code]
             unless result['stdout'].strip.empty?
@@ -112,7 +115,7 @@ module Bolt
               @stream.puts(indent(2, "STDERR:"))
               @stream.puts(indent(4, result['stderr']))
             end
-          else
+          elsif result.generic_value.any?
             @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
           end
         end

data/lib/bolt/plugin.rb

@@ -142,7 +142,7 @@ module Bolt
       plugins
     end
 
-    RUBY_PLUGINS = %w[install_agent task pkcs7 prompt].freeze
+    RUBY_PLUGINS = %w[task pkcs7 prompt].freeze
     BUILTIN_PLUGINS = %w[task terraform pkcs7 prompt vault aws_inventory puppetdb azure_inventory yaml].freeze
     DEFAULT_PLUGIN_HOOKS = { 'puppet_library' => { 'plugin' => 'puppet_agent', 'stop_service' => true } }.freeze
 

data/lib/bolt/result.rb

@@ -95,7 +95,6 @@ module Bolt
       @value = value || {}
       @action = action
       @object = object
-      @value_set = !value.nil?
       if error && !error.is_a?(Hash)
         raise "TODO: how did we get a string error"
       end
@@ -107,6 +106,10 @@ module Bolt
       @value['_output']
     end
 
+    def message?
+      message && !message.strip.empty?
+    end
+
     def status_hash
       # DEPRECATION: node in status hashes is deprecated and should be removed in 2.0
       base = {
@@ -121,9 +124,7 @@ module Bolt
     end
 
     def generic_value
-      if @value_set
-        value.reject { |k, _| %w[_error _output].include? k }
-      end
+      value.reject { |k, _| %w[_error _output].include? k }
     end
 
     def eql?(other)

data/lib/bolt/target.rb

@@ -157,9 +157,37 @@ module Bolt
 
     # Satisfies the Puppet datatypes API
     def self.from_asserted_hash(hash)
+      if hash['uri'] && hash['options']
+        logger = Logging.logger[self]
+        msg = <<~MSG
+          #{Puppet::Pops::PuppetStack.top_of_stack.join(':')}
+            Deprecation Warning: Starting with Bolt 2.0, using 'Target.new' with an 'options' hash key will no
+            will no longer be supported. Use 'Target.new(<config>)', where 'config' is a hash with the same
+            structure used to define targets in the inventory V2 file. For more information see
+            https://puppet.com/docs/bolt/latest/writing_plans.html#creating-target-objects
+        MSG
+        logger.warn(msg)
+      end
+
       new(hash['uri'], hash['options'])
     end
 
+    def self.from_asserted_args(uri, options = nil)
+      if options
+        logger = Logging.logger[self]
+        msg = <<~MSG
+          #{Puppet::Pops::PuppetStack.top_of_stack.join(':')}
+            Deprecation Warning: Starting with Bolt 2.0, 'Target.new(<uri>, <options>)' will no
+            longer be supported. Use 'Target.new(<config>)', where 'config' is a hash with the same
+            structure used to define targets in the inventory V2 file. For more information see
+            https://puppet.com/docs/bolt/latest/writing_plans.html#creating-target-objects
+        MSG
+        logger.warn(msg)
+      end
+
+      new(uri, options)
+    end
+
     # URI can be passes as nil
     def initialize(uri, options = nil)
       # lazy-load expensive gem code

data/lib/bolt/transport/docker.rb

@@ -7,8 +7,22 @@ require 'bolt/transport/base'
 module Bolt
   module Transport
     class Docker < Base
+      OPTIONS = {
+        "host"          => "Host name.",
+        "interpreters"  => "A map of an extension name to the absolute path of an executable, "\
+                            "enabling you to override the shebang defined in a task executable. The "\
+                            "extension can optionally be specified with the `.` character (`.py` and "\
+                            "`py` both map to a task executable `task.py`) and the extension is case "\
+                            "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
+                            "Bolt Ruby interpreter by default.",
+        "service-url"   => "URL of the Docker host used for API requests.",
+        "shell-command" => "A shell command to wrap any Docker exec commands in, such as `bash -lc`.",
+        "tmpdir"        => "The directory to upload and execute temporary files on the target.",
+        "tty"           => "Whether to enable tty on exec commands."
+      }.freeze
+
       def self.options
-        %w[host service-url tmpdir interpreters shell-command tty]
+        OPTIONS.keys
       end
 
       def provided_features

data/lib/bolt/transport/local.rb

@@ -3,8 +3,30 @@
 module Bolt
   module Transport
     class Local < Sudoable
+      OPTIONS = {
+        "interpreters"    => "A map of an extension name to the absolute path of an executable, "\
+                              "enabling you to override the shebang defined in a task executable. The "\
+                              "extension can optionally be specified with the `.` character (`.py` and "\
+                              "`py` both map to a task executable `task.py`) and the extension is case "\
+                              "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
+                              "Bolt Ruby interpreter by default.",
+        "run-as"          => "A different user to run commands as after login.",
+        "run-as-command"  => "The command to elevate permissions. Bolt appends the user and command "\
+                              "strings to the configured `run-as-command` before running it on the target. "\
+                              "This command must not require an interactive password prompt, and the "\
+                              "`sudo-password` option is ignored when `run-as-command` is specified. The "\
+                              "`run-as-command` must be specified as an array.",
+        "sudo-executable" => "The executable to use when escalating to the configured `run-as` user. This "\
+                              "is useful when you want to escalate using the configured `sudo-password`, since "\
+                              "`run-as-command` does not use `sudo-password` or support prompting. The command "\
+                              "executed on the target is `<sudo-executable> -S -u <user> -p custom_bolt_prompt "\
+                              "<command>`. **This option is experimental.**",
+        "sudo-password"   => "Password to use when changing users via `run-as`.",
+        "tmpdir"          => "The directory to copy and execute temporary files."
+      }.freeze
+
       def self.options
-        %w[tmpdir interpreters sudo-password run-as run-as-command sudo-executable]
+        OPTIONS.keys
       end
 
       def provided_features

data/lib/bolt/transport/local_windows.rb

@@ -12,8 +12,25 @@ require 'bolt/util'
 module Bolt
   module Transport
     class LocalWindows < Base
+      OPTIONS = {
+        "interpreters"   => "A map of an extension name to the absolute path of an executable, "\
+                            "enabling you to override the shebang defined in a task executable. The "\
+                            "extension can optionally be specified with the `.` character (`.py` and "\
+                            "`py` both map to a task executable `task.py`) and the extension is case "\
+                            "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
+                            "Bolt Ruby interpreter by default.",
+        "run-as"         => "A different user to run commands as after login.",
+        "run-as-command" => "The command to elevate permissions. Bolt appends the user and command "\
+                            "strings to the configured `run-as-command` before running it on the target. "\
+                            "This command must not require an interactive password prompt, and the "\
+                            "`sudo-password` option is ignored when `run-as-command` is specified. The "\
+                            "`run-as-command` must be specified as an array.",
+        "sudo-password"  => "Password to use when changing users via `run-as`.",
+        "tmpdir"         => "The directory to copy and execute temporary files."
+      }.freeze
+
       def self.options
-        %w[tmpdir interpreters run-as run-as-command sudo-password]
+        OPTIONS.keys
       end
 
       def provided_features

data/lib/bolt/transport/orch.rb

@@ -21,8 +21,18 @@ module Bolt
 
       attr_writer :plan_context
 
+      OPTIONS = {
+        "cacert"            => "The path to the CA certificate.",
+        "host"              => "Host name.",
+        "job-poll-interval" => "Set interval to poll orchestrator for job status.",
+        "job-poll-timeout"  => "Set time to wait for orchestrator job status.",
+        "service-url"       => "The URL of the orchestrator API.",
+        "task-environment"  => "The environment the orchestrator loads task code from.",
+        "token-file"        => "The path to the token file."
+      }.freeze
+
       def self.options
-        %w[host service-url cacert token-file task-environment job-poll-interval job-poll-timeout]
+        OPTIONS.keys
       end
 
       def self.default_options

data/lib/bolt/transport/remote.rb

@@ -6,6 +6,10 @@ require 'bolt/transport/base'
 module Bolt
   module Transport
     class Remote < Base
+      OPTIONS = {
+        "run-on" => "The proxy target that the task executes on."
+      }.freeze
+
       # The options for the remote transport not defined.
       def self.filter_options(unfiltered)
         unfiltered

data/lib/bolt/transport/ssh.rb

@@ -8,9 +8,49 @@ require 'shellwords'
 module Bolt
   module Transport
     class SSH < Sudoable
+      OPTIONS = {
+        "connect-timeout"    => "How long to wait when establishing connections.",
+        "disconnect-timeout" => "How long to wait before force-closing a connection.",
+        "host"               => "Host name.",
+        "host-key-check"     => "Whether to perform host key validation when connecting.",
+        "interpreters"       => "A map of an extension name to the absolute path of an executable, "\
+                                "enabling you to override the shebang defined in a task executable. The "\
+                                "extension can optionally be specified with the `.` character (`.py` and "\
+                                "`py` both map to a task executable `task.py`) and the extension is case "\
+                                "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
+                                "Bolt Ruby interpreter by default.",
+        "password"           => "Login password.",
+        "port"               => "Connection port.",
+        "private-key"        => "Either the path to the private key file to use for authentication, or a "\
+                                "hash with the key `key-data` and the contents of the private key.",
+        "proxyjump"          => "A jump host to proxy connections through, and an optional user to "\
+                                "connect with.",
+        "run-as"             => "A different user to run commands as after login.",
+        "run-as-command"     => "The command to elevate permissions. Bolt appends the user and command "\
+                                "strings to the configured `run-as-command` before running it on the "\
+                                "target. This command must not require an interactive password prompt, "\
+                                "and the `sudo-password` option is ignored when `run-as-command` is "\
+                                "specified. The `run-as-command` must be specified as an array.",
+        "script-dir"         => "The subdirectory of the tmpdir to use in place of a randomized "\
+                                "subdirectory for uploading and executing temporary files on the "\
+                                "target. It's expected that this directory already exists as a subdir "\
+                                "of tmpdir, which is either configured or defaults to `/tmp`.",
+        "sudo-executable"    => "The executable to use when escalating to the configured `run-as` "\
+                                "user. This is useful when you want to escalate using the configured "\
+                                "`sudo-password`, since `run-as-command` does not use `sudo-password` "\
+                                "or support prompting. The command executed on the target is "\
+                                "`<sudo-executable> -S -u <user> -p custom_bolt_prompt <command>`. "\
+                                "**This option is experimental.**",
+        "sudo-password"      => "Password to use when changing users via `run-as`.",
+        "tmpdir"             => "The directory to upload and execute temporary files on the target.",
+        "tty"                => "Request a pseudo tty for the session. This option is generally "\
+                                "only used in conjunction with the `run-as` option when the sudoers "\
+                                "policy requires a `tty`.",
+        "user"               => "Login user."
+      }.freeze
+
       def self.options
-        %w[host port user password sudo-password private-key host-key-check sudo-executable
-           connect-timeout disconnect-timeout tmpdir script-dir run-as tty run-as-command proxyjump interpreters]
+        OPTIONS.keys
       end
 
       def self.default_options

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

@@ -36,7 +36,7 @@ module Bolt
 
           @sudo_password = @target.options['sudo-password']
           # rubocop:disable Style/GlobalVars
-          @sudo_password ||= @target.options['password'] if $future
+          @sudo_password ||= @target.password if $future
           # rubocop:enable Style/GlobalVars
 
           if target.options['private-key']&.instance_of?(String)
@@ -197,13 +197,13 @@ module Bolt
           if escalate
             if use_sudo
               sudo_exec = target.options['sudo-executable'] || "sudo"
-              sudo_flags = [sudo_exec, "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
+              sudo_flags = [sudo_exec, "-S", "-H", "-u", run_as, "-p", Sudoable.sudo_prompt]
               sudo_flags += ["-E"] if options[:environment]
               sudo_str = Shellwords.shelljoin(sudo_flags)
             else
               sudo_str = Shellwords.shelljoin(@target.options['run-as-command'] + [run_as])
             end
-            command_str = build_sudoable_command_str(command_str, sudo_str, @sudo_id, options)
+            command_str = build_sudoable_command_str(command_str, sudo_str, @sudo_id, options.merge(reset_cwd: true))
           end
 
           # Including the environment declarations in the shelljoin will escape

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

@@ -77,17 +77,24 @@ module Bolt
         # a random string is echoed to stderr indicating that the stdin is available
         # for task input data because the sudo password has already either been
         # provided on stdin or was not needed.
-        def prepend_sudo_success(sudo_id, command_str)
+        def prepend_sudo_success(sudo_id, command_str, reset_cwd)
+          command_str = "cd && #{command_str}" if reset_cwd
           "sh -c 'echo #{sudo_id} 1>&2; #{command_str}'"
         end
 
+        def prepend_chdir(command_str)
+          "sh -c 'cd && #{command_str}'"
+        end
+
         # A helper to build up a single string that contains all of the options for
         # privilege escalation. A wrapper script is used to direct task input to stdin
         # when a tty is allocated and thus we do not need to prepend_sudo_success when
         # using the wrapper or when the task does not require stdin data.
         def build_sudoable_command_str(command_str, sudo_str, sudo_id, options)
           if options[:stdin] && !options[:wrapper]
-            "#{sudo_str} #{prepend_sudo_success(sudo_id, command_str)}"
+            "#{sudo_str} #{prepend_sudo_success(sudo_id, command_str, options[:reset_cwd])}"
+          elsif options[:reset_cwd]
+            "#{sudo_str} #{prepend_chdir(command_str)}"
           else
             "#{sudo_str} #{command_str}"
           end

data/lib/bolt/transport/winrm.rb

@@ -7,11 +7,35 @@ require 'bolt/transport/powershell'
 module Bolt
   module Transport
     class WinRM < Base
+      OPTIONS = {
+        "cacert"          => "The path to the CA certificate.",
+        "connect-timeout" => "How long Bolt should wait when establishing connections.",
+        "extensions"      => "List of file extensions that are accepted for scripts or tasks. "\
+                              "Scripts with these file extensions rely on the target's file type "\
+                              "association to run. For example, if Python is installed on the system, "\
+                              "a `.py` script runs with `python.exe`. The extensions `.ps1`, `.rb`, and "\
+                              "`.pp` are always allowed and run via hard-coded executables.",
+        "file-protocol"   => "Which file transfer protocol to use. Either `winrm` or `smb`. Using `smb` is "\
+                              "recommended for large file transfers.",
+        "host"            => "Host name.",
+        "interpreters"    => "A map of an extension name to the absolute path of an executable, "\
+                              "enabling you to override the shebang defined in a task executable. The "\
+                              "extension can optionally be specified with the `.` character (`.py` and "\
+                              "`py` both map to a task executable `task.py`) and the extension is case "\
+                              "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
+                              "Bolt Ruby interpreter by default.",
+        "password"        => "Login password. **Required unless using Kerberos.**",
+        "port"            => "Connection port.",
+        "realm"           => "Kerberos realm (Active Directory domain) to authenticate against.",
+        "smb-port"        => "With file-protocol set to smb, this is the port to establish a connection on.",
+        "ssl"             => "When true, Bolt uses secure https connections for WinRM.",
+        "ssl-verify"      => "When true, verifies the targets certificate matches the cacert.",
+        "tmpdir"          => "The directory to upload and execute temporary files on the target.",
+        "user"            => "Login user. **Required unless using Kerberos.**"
+      }.freeze
+
       def self.options
-        %w[
-          host port user password connect-timeout ssl ssl-verify tmpdir
-          cacert extensions interpreters file-protocol smb-port realm
-        ]
+        OPTIONS.keys
       end
 
       def self.default_options

data/lib/bolt/version.rb

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

data/lib/bolt_server/transport_app.rb

@@ -200,6 +200,19 @@ module BoltServer
       end
     end
 
+    def pe_plan_info(pal, module_name, plan_name)
+      # Handle case where plan name is simply module name with special `init.pp` plan
+      plan_name = if plan_name == 'init' || plan_name.nil?
+                    module_name
+                  else
+                    "#{module_name}::#{plan_name}"
+                  end
+      plan_info = pal.get_plan_info(plan_name)
+      # Path to module is meaningless in PE
+      plan_info.delete('module')
+      plan_info
+    end
+
     get '/' do
       200
     end
@@ -305,7 +318,7 @@ module BoltServer
     # @param environment [String] the environment to fetch the plan from
     get '/plans/:module_name/:plan_name' do
       in_pe_pal_env(params['environment']) do |pal|
-        plan_info = pal.get_plan_info("#{params[:module_name]}::#{params[:plan_name]}")
+        plan_info = pe_plan_info(pal, params[:module_name], params[:plan_name])
         [200, plan_info.to_json]
       end
     end
@@ -318,7 +331,11 @@ module BoltServer
       in_pe_pal_env(params['environment']) do |pal|
         plans = pal.list_plans.flatten
         if params['metadata']
-          plan_info = plans.each_with_object({}) { |plan_name, acc| acc[plan_name] = pal.get_plan_info(plan_name) }
+          plan_info = plans.each_with_object({}) do |full_name, acc|
+            # Break apart module name from plan name
+            module_name, plan_name = full_name.split('::', 2)
+            acc[full_name] = pe_plan_info(pal, module_name, plan_name)
+          end
           [200, plan_info.to_json]
         else
           # We structure this array of plans to be an array of hashes so that it matches the structure

data/libexec/apply_catalog.rb

@@ -39,7 +39,8 @@ begin
 
   Tempfile.open('plugins.tar.gz') do |plugins|
     File.binwrite(plugins, Base64.decode64(args['plugins']))
-    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, Etc.getlogin || Etc.getpwuid.name)
+    user = Etc.getpwuid.nil? ? Etc.getlogin : Etc.getpwuid.name
+    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, user)
   end
 
   env = Puppet.lookup(:environments).get('production')

data/libexec/custom_facts.rb

@@ -21,7 +21,8 @@ Dir.mktmpdir do |puppet_root|
 
   Tempfile.open('plugins.tar.gz') do |plugins|
     File.binwrite(plugins, Base64.decode64(args['plugins']))
-    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, Etc.getlogin || Etc.getpwuid.name)
+    user = Etc.getpwuid.nil? ? Etc.getlogin : Etc.getpwuid.name
+    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, user)
   end
 
   env = Puppet.lookup(:environments).get('production')

data/libexec/query_resources.rb

@@ -28,7 +28,8 @@ Dir.mktmpdir do |puppet_root|
 
   Tempfile.open('plugins.tar.gz') do |plugins|
     File.binwrite(plugins, Base64.decode64(args['plugins']))
-    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, Etc.getlogin || Etc.getpwuid.name)
+    user = Etc.getpwuid.nil? ? Etc.getlogin : Etc.getpwuid.name
+    Puppet::ModuleTool::Tar.instance.unpack(plugins, moduledir, user)
   end
 
   env = Puppet.lookup(:environments).get('production')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.45.0
+  version: 1.47.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-13 00:00:00.000000000 Z
+date: 2020-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -420,7 +420,6 @@ files:
 - lib/bolt/pal/yaml_plan/transpiler.rb
 - lib/bolt/plan_result.rb
 - lib/bolt/plugin.rb
-- lib/bolt/plugin/install_agent.rb
 - lib/bolt/plugin/module.rb
 - lib/bolt/plugin/pkcs7.rb
 - lib/bolt/plugin/prompt.rb

data/lib/bolt/plugin/install_agent.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  class Plugin
-    class InstallAgent
-      def hooks
-        %i[puppet_library]
-      end
-
-      def name
-        'install_agent'
-      end
-
-      def initialize(*args); end
-
-      def puppet_library(_opts, target, apply_prep)
-        install_task = apply_prep.get_task("puppet_agent::install")
-        service_task = apply_prep.get_task("service", 'action' => 'stop', 'name' => 'puppet')
-        proc do
-          apply_prep.run_task([target], install_task).first
-          apply_prep.set_agent_feature(target)
-          apply_prep.run_task([target], service_task, 'action' => 'stop', 'name' => 'puppet').first
-          apply_prep.run_task([target], service_task, 'action' => 'disable', 'name' => 'puppet').first
-        end
-      end
-    end
-  end
-end