bolt 3.3.0 → 3.7.0

data/lib/bolt/outputter/json.rb

@@ -100,12 +100,12 @@ module Bolt
                        moduledir: moduledir.to_s }.to_json)
       end
 
-      def print_targets(target_list, inventoryfile)
+      def print_targets(target_list, inventory_source, default_inventory, _target_flag)
         @stream.puts ::JSON.pretty_generate(
           inventory: {
             targets: target_list[:inventory].map(&:name),
             count: target_list[:inventory].count,
-            file: inventoryfile.to_s
+            file: (inventory_source || default_inventory).to_s
           },
           adhoc: {
             targets: target_list[:adhoc].map(&:name),
@@ -116,14 +116,16 @@ module Bolt
         )
       end
 
-      def print_target_info(targets)
+      def print_target_info(target_list, _inventory_source, _default_inventory, _target_flag)
+        targets = target_list.values.flatten
+
         @stream.puts ::JSON.pretty_generate(
           targets: targets.map(&:detail),
           count: targets.count
         )
       end
 
-      def print_groups(groups)
+      def print_groups(groups, _inventory_source, _default_inventory)
         count = groups.count
         @stream.puts({ groups: groups,
                        count: count }.to_json)

data/lib/bolt/outputter/logger.rb

@@ -20,6 +20,10 @@ module Bolt
           log_plan_start(event)
         when :plan_finish
           log_plan_finish(event)
+        when :container_start
+          log_container_start(event)
+        when :container_finish
+          log_container_finish(event)
         end
       end
 
@@ -48,6 +52,19 @@ module Bolt
         duration = event[:duration]
         @logger.info("Finished: plan #{plan} in #{duration.round(2)} sec")
       end
+
+      def log_container_start(event)
+        @logger.info("Starting: run container '#{event[:image]}'")
+      end
+
+      def log_container_finish(event)
+        result = event[:result]
+        if result.success?
+          @logger.info("Finished: run container '#{result.object}' succeeded.")
+        else
+          @logger.info("Finished: run container '#{result.object}' failed.")
+        end
+      end
     end
   end
 end

data/lib/bolt/pal.rb

@@ -521,10 +521,30 @@ module Bolt
       end
     end
 
-    def convert_plan(plan_path)
+    def convert_plan(plan)
+      path = File.expand_path(plan)
+
+      # If the path doesn't exist, check if it's a plan name
+      unless File.exist?(path)
+        in_bolt_compiler do |compiler|
+          sig = compiler.plan_signature(plan)
+
+          # If the plan was loaded, look for it on the module loader
+          # There has to be an easier way to do this...
+          if sig
+            type = compiler.list_plans.find { |p| p.name == plan }
+            path = sig.instance_variable_get(:@plan_func)
+                      .loader
+                      .find(type)
+                      .origin
+                      .first
+          end
+        end
+      end
+
       Puppet[:tasks] = true
       transpiler = YamlPlan::Transpiler.new
-      transpiler.transpile(plan_path)
+      transpiler.transpile(path)
     end
 
     # Returns a mapping of all modules available to the Bolt compiler

data/lib/bolt/pal/yaml_plan/step.rb

@@ -122,9 +122,11 @@ module Bolt
               raise StepError.new("Parameters key must be a hash", body['name'], step_number)
             end
 
-            metaparams = option_keys.map { |key| "_#{key}" }
+            metaparams = body['parameters'].keys
+                                           .select { |key| key.start_with?('_') }
+                                           .map { |key| key.sub(/^_/, '') }
 
-            if (dups = body['parameters'].keys & metaparams).any?
+            if (dups = body.keys & metaparams).any?
               raise StepError.new(
                 "Cannot specify metaparameters when using top-level keys with same name: #{dups.join(', ')}",
                 body['name'],

data/lib/bolt/pal/yaml_plan/step/command.rb

@@ -13,6 +13,14 @@ module Bolt
             Set['command', 'targets']
           end
 
+          def self.validate_step_keys(body, number)
+            super
+
+            if body.key?('env_vars') && ![Hash, String].include?(body['env_vars'].class)
+              raise StepError.new('env_vars key must be a hash or evaluable string', body['name'], number)
+            end
+          end
+
           # Returns an array of arguments to pass to the step's function call
           #
           private def format_args(body)

data/lib/bolt/pal/yaml_plan/step/script.rb

@@ -27,6 +27,10 @@ module Bolt
             if body.key?('pwsh_params') && !body['pwsh_params'].nil? && !body['pwsh_params'].is_a?(Hash)
               raise StepError.new('pwsh_params key must be a hash', body['name'], number)
             end
+
+            if body.key?('env_vars') && ![Hash, String].include?(body['env_vars'].class)
+              raise StepError.new('env_vars key must be a hash or evaluable string', body['name'], number)
+            end
           end
 
           # Returns an array of arguments to pass to the step's function call

data/lib/bolt/pal/yaml_plan/transpiler.rb

@@ -14,8 +14,8 @@ module Bolt
           end
         end
 
-        def transpile(relative_path)
-          @plan_path = File.expand_path(relative_path)
+        def transpile(plan_path)
+          @plan_path = plan_path
           @modulename = Bolt::Util.module_name(@plan_path)
           @filename = @plan_path.split(File::SEPARATOR)[-1]
           validate_path

data/lib/bolt/plan_creator.rb

@@ -36,8 +36,8 @@ module Bolt
       prefix, _, basename = segment_plan_name(plan_name)
 
       unless prefix == project.name
-        message = "First segment of plan name '#{plan_name}' must match project name '#{project.name}'. "\
-                  "Did you mean '#{project.name}::#{plan_name}'?"
+        message = "Incomplete plan name: A plan name must be prefixed with the name of the "\
+          "project or module. Did you mean '#{project.name}::#{plan_name}'?"
 
         raise Bolt::ValidationError, message
       end

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/puppetdb/client.rb

@@ -95,6 +95,60 @@ module Bolt
         make_query(query, path)
       end
 
+      # Sends a command to PuppetDB using version 1 of the commands API.
+      # https://puppet.com/docs/puppetdb/latest/api/command/v1/commands.html
+      #
+      # @param command [String] The command to invoke.
+      # @param version [Integer] The version of the command to invoke.
+      # @param payload [Hash] The payload to send with the command.
+      # @return A UUID identifying the submitted command.
+      #
+      def send_command(command, version, payload)
+        command = command.dup.force_encoding('utf-8')
+        body    = JSON.generate(payload)
+
+        # PDB requires the following query parameters to the POST request.
+        # Error early if there's no certname, as PDB does not return a
+        # message indicating it's required.
+        unless payload['certname']
+          raise Bolt::Error.new(
+            "Payload must include 'certname', unable to invoke command.",
+            'bolt/pdb-command'
+          )
+        end
+
+        url = uri.tap do |u|
+          u.path         = 'pdb/cmd/v1'
+          u.query_values = { 'command'  => command,
+                             'version'  => version,
+                             'certname' => payload['certname'] }
+        end
+
+        # Send the command to PDB
+        begin
+          @logger.debug("Sending PuppetDB command '#{command}' to #{url}")
+          response = http_client.post(url.to_s, body: body, header: headers)
+        rescue StandardError => e
+          raise Bolt::PuppetDBFailoverError, "Failed to invoke PuppetDB command: #{e}"
+        end
+
+        @logger.debug("Got response code #{response.code} from PuppetDB")
+        if response.code != 200
+          raise Bolt::PuppetDBError, "Failed to invoke PuppetDB command: #{response.body}"
+        end
+
+        # Return the UUID string from the response body
+        begin
+          JSON.parse(response.body).fetch('uuid', nil)
+        rescue JSON::ParserError
+          raise Bolt::PuppetDBError, "Unable to parse response as JSON: #{response.body}"
+        end
+      rescue Bolt::PuppetDBFailoverError => e
+        @logger.error("Request to puppetdb at #{@current_url} failed with #{e}.")
+        reject_url
+        send_command(command, version, payload)
+      end
+
       def http_client
         return @http if @http
         # lazy-load expensive gem code

data/lib/bolt/result.rb

@@ -28,20 +28,14 @@ module Bolt
       %w[file line].zip(position).to_h.compact
     end
 
-    def self.for_command(target, stdout, stderr, exit_code, action, command, position)
-      value = {
-        'stdout' => stdout,
-        'stderr' => stderr,
-        'exit_code' => exit_code
-      }
-
+    def self.for_command(target, value, action, command, position)
       details = create_details(position)
-      unless exit_code == 0
-        details['exit_code'] = exit_code
+      unless value['exit_code'] == 0
+        details['exit_code'] = value['exit_code']
         value['_error'] = {
           'kind' => 'puppetlabs.tasks/command-error',
           'issue_code' => 'COMMAND_ERROR',
-          'msg' => "The command failed with exit code #{exit_code}",
+          'msg' => "The command failed with exit code #{value['exit_code']}",
           'details' => details
         }
       end
@@ -170,15 +164,12 @@ module Bolt
         target == other.target &&
         value == other.value
     end
+    alias == eql?
 
     def [](key)
       value[key]
     end
 
-    def ==(other)
-      eql?(other)
-    end
-
     def to_json(opts = nil)
       to_data.to_json(opts)
     end

data/lib/bolt/shell/bash.rb

@@ -24,9 +24,7 @@ module Bolt
         running_as(options[:run_as]) do
           output = execute(command, environment: options[:env_vars], sudoable: true)
           Bolt::Result.for_command(target,
-                                   output.stdout.string,
-                                   output.stderr.string,
-                                   output.exit_code,
+                                   output.to_h,
                                    'command',
                                    command,
                                    position)
@@ -98,9 +96,7 @@ module Bolt
             dir.chown(run_as)
             output = execute([path, *arguments], environment: options[:env_vars], sudoable: true)
             Bolt::Result.for_command(target,
-                                     output.stdout.string,
-                                     output.stderr.string,
-                                     output.exit_code,
+                                     output.to_h,
                                      'script',
                                      script,
                                      position)
@@ -149,21 +145,21 @@ module Bolt
 
             remote_task_path = write_executable(task_dir, executable)
 
+            execute_options[:stdin] = stdin
+
             # Avoid the horrors of passing data on stdin via a tty on multiple platforms
             # by writing a wrapper script that directs stdin to the task.
             if stdin && target.options['tty']
               wrapper = make_wrapper_stringio(remote_task_path, stdin, execute_options[:interpreter])
+              # Wrapper script handles interpreter and stdin. Delete these execute options
               execute_options.delete(:interpreter)
+              execute_options.delete(:stdin)
               execute_options[:wrapper] = true
               remote_task_path = write_executable(dir, wrapper, 'wrapper.sh')
             end
 
             dir.chown(run_as)
 
-            # Don't pass parameters on stdin if using a tty, as the parameters are
-            # already part of the wrapper script.
-            execute_options[:stdin] = stdin unless stdin && target.options['tty']
-
             execute_options[:sudoable] = true if run_as
             output = execute(remote_task_path, **execute_options)
           end
@@ -400,7 +396,12 @@ module Bolt
         # See if there's a sudo prompt
         if use_sudo
           ready_read = select([err], nil, nil, timeout * 5)
-          read_streams[err] << check_sudo(err, inp, options[:stdin]) if ready_read
+          to_print = check_sudo(err, inp, options[:stdin]) if ready_read
+          unless to_print.nil?
+            log_stream(to_print, 'err')
+            read_streams[err]           << to_print
+            result_output.merged_output << to_print
+          end
         end
 
         # True while the process is running or waiting for IO input
@@ -416,15 +417,9 @@ module Bolt
                        else
                          stream.readpartial(CHUNK_SIZE)
                        end
-
-            if !to_print.chomp.empty? && @stream_logger
-              formatted = to_print.lines.map do |msg|
-                "[#{@target.safe_name}] #{stream_name}: #{msg.chomp}"
-              end.join("\n")
-              @stream_logger.warn(formatted)
-            end
-
-            read_streams[stream] << to_print
+            log_stream(to_print, stream_name)
+            read_streams[stream]        << to_print
+            result_output.merged_output << to_print
           rescue EOFError
           end
 
@@ -461,7 +456,13 @@ module Bolt
         # Read any remaining data in the pipe. Do not wait for
         # EOF in case the pipe is inherited by a child process.
         read_streams.each do |stream, _|
-          loop { read_streams[stream] << stream.read_nonblock(CHUNK_SIZE) }
+          stream_name = stream == out ? 'out' : 'err'
+          loop {
+            to_print = stream.read_nonblock(CHUNK_SIZE)
+            log_stream(to_print, stream_name)
+            read_streams[stream]        << to_print
+            result_output.merged_output << to_print
+          }
         rescue Errno::EAGAIN, EOFError
         end
         result_output.stdout << read_streams[out]
@@ -474,7 +475,8 @@ module Bolt
         when 126
           msg = "\n\nThis might be caused by the default tmpdir being mounted "\
             "using 'noexec'. See http://pup.pt/task-failure for details and workarounds."
-          result_output.stderr << msg
+          result_output.stderr        << msg
+          result_output.merged_output << msg
           @logger.trace { "Command #{command_str} failed with exit code #{result_output.exit_code}" }
         else
           @logger.trace { "Command #{command_str} failed with exit code #{result_output.exit_code}" }
@@ -491,6 +493,15 @@ module Bolt
       def sudo_prompt
         '[sudo] Bolt needs to run as another user, password: '
       end
+
+      private def log_stream(to_print, stream_name)
+        if !to_print.chomp.empty? && @stream_logger
+          formatted = to_print.lines.map do |msg|
+            "[#{@target.safe_name}] #{stream_name}: #{msg.chomp}"
+          end.join("\n")
+          @stream_logger.warn(formatted)
+        end
+      end
     end
   end
 end

data/lib/bolt/shell/powershell.rb

@@ -195,9 +195,7 @@ module Bolt
         wrap_command = conn.is_a?(Bolt::Transport::Local::Connection)
         output = execute(command, wrap_command)
         Bolt::Result.for_command(target,
-                                 output.stdout.string,
-                                 output.stderr.string,
-                                 output.exit_code,
+                                 output.to_h,
                                  'command',
                                  command,
                                  position)
@@ -224,9 +222,7 @@ module Bolt
           output = execute([shell_init, *env_assignments, command].join("\r\n"))
 
           Bolt::Result.for_command(target,
-                                   output.stdout.string,
-                                   output.stderr.string,
-                                   output.exit_code,
+                                   output.to_h,
                                    'script',
                                    script,
                                    position)
@@ -322,7 +318,8 @@ module Bolt
             end.join("\n")
             @stream_logger.warn(formatted)
           end
-          result.stdout << to_print
+          result.stdout        << to_print
+          result.merged_output << to_print
         end
         stderr = Thread.new do
           encoding = err.external_encoding
@@ -334,7 +331,8 @@ module Bolt
             end.join("\n")
             @stream_logger.warn(formatted)
           end
-          result.stderr << to_print
+          result.stderr        << to_print
+          result.merged_output << to_print
         end
 
         stdout.join