bolt 1.16.0 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b815f57b892f3750786159c9251e03f34cae09c721a6c18a2ace76d7319324b3
-  data.tar.gz: 13d51985236eee75d10bd527a8fe4c0328b362175dc9313a84f519967c690d9a
+  metadata.gz: a9fe11fc4842de35277e098cfe7740eb274df8aa5a6e1049cab373c31d196612
+  data.tar.gz: 7884fb6bbc0292e0545a9429ba134dc3bbcb5045d86b924391cdafb523eba1f9
 SHA512:
-  metadata.gz: f904cf6c228379b8f790ed6d102da43244cdc5b0fa8630f04758957e35c083ee9955d09b0d212c22ea5a9e07f989e72f73e88b07f99d984c9427a813386713f3
-  data.tar.gz: a755bc82082397a067d8a8bdbfc81f7687071bbb2aa993c3a95e0db24feeda4e28c7b34644cbb1a2195f3211918c9de7fafd8c232ce38acd7ce5c42cfd5359da
+  metadata.gz: 8a9a4298796b099efb223ae4a9277a2a6b589f1f8d27267af0de768494579aa820bc3191338cb6eaa73c0f8a23112c48bef2e2037d5dea72d3b3d5204a0bb4ce
+  data.tar.gz: 89c4a471a4b4c23e71cc1fb25df7fcd29e5b76374eb63564deca6b6a113c7c5c0c052d461c0277f668c1b5c8be644d3796c3de2f5078ce0127e32d4090591ec4

data/lib/bolt/bolt_option_parser.rb

@@ -149,6 +149,12 @@ Usage: bolt apply <manifest.pp> [options]
       @query = define('-q', '--query QUERY', 'Query PuppetDB to determine the targets') do |query|
         @options[:query] = query
       end.extend(SwitchHider)
+      @rerun = define('--rerun FILTER', 'Retry on nodes from the last run',
+                      "'all' all nodes that were part of the last run.",
+                      "'failure' nodes that failed in the last run.",
+                      "'success' nodes that succeeded in the last run.") do |rerun|
+        @options[:rerun] = rerun
+      end.extend(SwitchHider)
       define('--noop', 'Execute a task that supports it in noop mode') do |_|
         @options[:noop] = true
       end
@@ -238,6 +244,9 @@ Usage: bolt apply <manifest.pp> [options]
         end
         @options[:inventoryfile] = File.expand_path(path)
       end
+      define('--[no-]save-rerun', 'Whether to update the rerun file after this command.') do |save|
+        @options[:'save-rerun'] = save
+      end
 
       separator 'Transports:'
       define('--transport TRANSPORT', TRANSPORTS.keys.map(&:to_s),
@@ -282,16 +291,14 @@ Usage: bolt apply <manifest.pp> [options]
     end
 
     def update
-      # show the --nodes and --query switches by default
-      @nodes.hide = @query.hide = false
+      # show the --nodes, --query, and --rerun switches by default
+      @nodes.hide = @query.hide = @rerun.hide = false
       # Don't show the --execute switch except for `apply`
       @execute.hide = true
 
       # Update the banner according to the subcommand
       self.banner = case @options[:subcommand]
                     when 'plan'
-                      # don't show the --nodes and --query switches in the plan help
-                      @nodes.hide = @query.hide = true
                       PLAN_HELP
                     when 'command'
                       COMMAND_HELP
@@ -302,6 +309,8 @@ Usage: bolt apply <manifest.pp> [options]
                     when 'file'
                       FILE_HELP
                     when 'puppetfile'
+                      # Don't show targeting options for puppetfile
+                      @nodes.hide = @query.hide = @rerun.hide = true
                       PUPPETFILE_HELP
                     when 'apply'
                       @execute.hide = false

data/lib/bolt/boltdir.rb

@@ -6,7 +6,7 @@ module Bolt
   class Boltdir
     BOLTDIR_NAME = 'Boltdir'
 
-    attr_reader :path, :config_file, :inventory_file, :modulepath, :hiera_config, :puppetfile
+    attr_reader :path, :config_file, :inventory_file, :modulepath, :hiera_config, :puppetfile, :rerunfile
 
     def self.default_boltdir
       Boltdir.new(File.join('~', '.puppetlabs', 'bolt'))
@@ -36,6 +36,7 @@ module Bolt
       @modulepath = [(@path + 'modules').to_s, (@path + 'site-modules').to_s, (@path + 'site').to_s]
       @hiera_config = @path + 'hiera.yaml'
       @puppetfile = @path + 'Puppetfile'
+      @rerunfile = @path + '.rerun.json'
     end
 
     def to_s

data/lib/bolt/cli.rb

@@ -15,6 +15,7 @@ require 'bolt/config'
 require 'bolt/error'
 require 'bolt/executor'
 require 'bolt/inventory'
+require 'bolt/rerun'
 require 'bolt/logger'
 require 'bolt/outputter'
 require 'bolt/puppetdb'
@@ -117,16 +118,7 @@ module Bolt
 
       # After validation, initialize inventory and targets. Errors here are better to catch early.
       unless options[:subcommand] == 'puppetfile' || options[:action] == 'show'
-        if options[:query]
-          if options[:nodes].any?
-            raise Bolt::CLIError, "Only one of '--nodes' or '--query' may be specified"
-          end
-          nodes = query_puppetdb_nodes(options[:query])
-          options[:targets] = inventory.get_targets(nodes)
-          options[:nodes] = nodes if options[:subcommand] == 'plan'
-        else
-          options[:targets] = inventory.get_targets(options[:nodes])
-        end
+        options[:targets] = get_targets(options)
       end
 
       options
@@ -135,6 +127,25 @@ module Bolt
       raise e
     end
 
+    def get_targets(options)
+      target_opts =  options.keys.select { |opt| %i[query rerun].include?(opt) }
+      target_opts << :nodes unless options[:nodes].empty?
+      if target_opts.length > 1
+        raise Bolt::CLIError, "Only one of '--nodes', '--rerun', or '--query' may be specified"
+      end
+
+      if options[:query]
+        nodes = query_puppetdb_nodes(options[:query])
+        options[:nodes] = nodes if options[:subcommand] == 'plan'
+      elsif options[:rerun]
+        nodes = rerun.get_targets(options[:rerun])
+        options[:nodes] = nodes if options[:subcommand] == 'plan'
+      else
+        nodes = options[:nodes]
+      end
+      inventory.get_targets(nodes)
+    end
+
     def validate(options)
       unless COMMANDS.include?(options[:subcommand])
         raise Bolt::CLIError,
@@ -174,10 +185,10 @@ module Bolt
       end
 
       if !%w[plan puppetfile].include?(options[:subcommand]) && options[:action] != 'show'
-        if options[:nodes].empty? && options[:query].nil?
-          raise Bolt::CLIError, "Targets must be specified with '--nodes' or '--query'"
+        if options[:nodes].empty? && options[:query].nil? && options[:rerun].nil?
+          raise Bolt::CLIError, "Targets must be specified with '--nodes', '--query' or '--rerun'"
         elsif options[:nodes].any? && options[:query]
-          raise Bolt::CLIError, "Only one of '--nodes' or '--query' may be specified"
+          raise Bolt::CLIError, "Only one of '--nodes', '--query', or '--rerun'  may be specified"
         end
       end
 
@@ -329,6 +340,7 @@ module Bolt
             end
         end
 
+        rerun.update(results)
         outputter.print_summary(results, elapsed_time)
         code = results.ok ? 0 : 2
       end
@@ -380,6 +392,7 @@ module Bolt
 
       # If a non-bolt exception bubbles up the plan won't get finished
       executor.finish_plan(result)
+      rerun.update(result)
       outputter.print_plan_result(result)
       result.ok? ? 0 : 1
     end
@@ -400,6 +413,7 @@ module Bolt
       end
 
       outputter.print_apply_result(results)
+      rerun.update(results)
 
       results.ok ? 0 : 1
     end
@@ -465,6 +479,10 @@ module Bolt
       File.stat(path)
     end
 
+    def rerun
+      @rerun ||= Bolt::Rerun.new(@config.rerunfile, @config.save_rerun)
+    end
+
     def outputter
       @outputter ||= Bolt::Outputter.for_format(config.format, config.color, config.trace)
     end

data/lib/bolt/config.rb

@@ -31,8 +31,8 @@ module Bolt
   end
 
   class Config
-    attr_accessor :concurrency, :format, :trace, :log, :puppetdb, :color,
-                  :transport, :transports, :inventoryfile, :compile_concurrency
+    attr_accessor :concurrency, :format, :trace, :log, :puppetdb, :color, :save_rerun,
+                  :transport, :transports, :inventoryfile, :compile_concurrency, :boltdir
     attr_writer :modulepath
 
     TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions
@@ -65,6 +65,7 @@ module Bolt
       @format = 'human'
       @puppetdb = {}
       @color = true
+      @save_rerun = true
 
       # add an entry for the default console logger
       @log = { 'console' => {} }
@@ -147,6 +148,8 @@ module Bolt
       @hiera_config = File.expand_path(data['hiera-config'], @boltdir.path) if data.key?('hiera-config')
       @compile_concurrency = data['compile-concurrency'] if data.key?('compile-concurrency')
 
+      @save_rerun = data['save-rerun'] if data.key?('save-rerun')
+
       %w[concurrency format puppetdb color transport].each do |key|
         send("#{key}=", data[key]) if data.key?(key)
       end
@@ -168,6 +171,8 @@ module Bolt
         send("#{key}=", options[key]) if options.key?(key)
       end
 
+      @save_rerun = options[:'save-rerun'] if options.key?(:'save-rerun')
+
       if options[:debug]
         @log['console'][:level] = :debug
       elsif options[:verbose]
@@ -215,6 +220,10 @@ module Bolt
       [@boltdir.inventory_file]
     end
 
+    def rerunfile
+      @boltdir.rerunfile
+    end
+
     def hiera_config
       @hiera_config || @boltdir.hiera_config
     end

data/lib/bolt/inventory/group2.rb

@@ -5,7 +5,7 @@ require 'bolt/inventory/group'
 module Bolt
   class Inventory
     class Group2
-      attr_accessor :name, :nodes, :aliases, :name_or_alias, :groups, :config, :rest, :facts, :vars, :features
+      attr_accessor :name, :targets, :aliases, :name_or_alias, :groups, :config, :rest, :facts, :vars, :features
 
       # THESE are duplicates with the old groups for now.
       # Regex used to validate group names and target aliases.
@@ -13,7 +13,7 @@ module Bolt
 
       DATA_KEYS = %w[name config facts vars features].freeze
       NODE_KEYS = DATA_KEYS + %w[alias uri]
-      GROUP_KEYS = DATA_KEYS + %w[groups nodes]
+      GROUP_KEYS = DATA_KEYS + %w[groups targets]
       CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
 
       def initialize(data)
@@ -41,46 +41,46 @@ module Bolt
           @logger.warn(msg)
         end
 
-        nodes = fetch_value(data, 'nodes', Array)
+        targets = fetch_value(data, 'targets', Array)
         groups = fetch_value(data, 'groups', Array)
 
-        @nodes = {}
+        @targets = {}
         @aliases = {}
-        nodes.reject { |node| node.is_a?(String) }.each do |node|
-          unless node.is_a?(Hash)
-            raise ValidationError.new("Node entry must be a String or Hash, not #{node.class}", @name)
+        targets.reject { |target| target.is_a?(String) }.each do |target|
+          unless target.is_a?(Hash)
+            raise ValidationError.new("Node entry must be a String or Hash, not #{target.class}", @name)
           end
 
-          node['name'] ||= node['uri']
+          target['name'] ||= target['uri']
 
-          if node['name'].nil? || node['name'].empty?
-            raise ValidationError.new("No name or uri for node: #{node}", @name)
+          if target['name'].nil? || target['name'].empty?
+            raise ValidationError.new("No name or uri for target: #{target}", @name)
           end
 
-          if @nodes.include?(node['name'])
-            @logger.warn("Ignoring duplicate node in #{@name}: #{node}")
+          if @targets.include?(target['name'])
+            @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
             next
           end
 
-          raise ValidationError.new("Node #{node} does not have a name", @name) unless node['name']
-          @nodes[node['name']] = node
+          raise ValidationError.new("Node #{target} does not have a name", @name) unless target['name']
+          @targets[target['name']] = target
 
-          unless (unexpected_keys = node.keys - NODE_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in node #{node['name']}"
+          unless (unexpected_keys = target.keys - NODE_KEYS).empty?
+            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{target['name']}"
             @logger.warn(msg)
           end
-          config_keys = node['config']&.keys || []
+          config_keys = target['config']&.keys || []
           unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for node #{node['name']}"
+            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for target #{target['name']}"
             @logger.warn(msg)
           end
 
-          next unless node.include?('alias')
+          next unless target.include?('alias')
 
-          aliases = node['alias']
+          aliases = target['alias']
           aliases = [aliases] if aliases.is_a?(String)
           unless aliases.is_a?(Array)
-            msg = "Alias entry on #{node['name']} must be a String or Array, not #{aliases.class}"
+            msg = "Alias entry on #{target['name']} must be a String or Array, not #{aliases.class}"
             raise ValidationError.new(msg, @name)
           end
 
@@ -88,26 +88,26 @@ module Bolt
             raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
 
             if (found = @aliases[alia])
-              raise ValidationError.new(alias_conflict(alia, found, node['name']), @name)
+              raise ValidationError.new(alias_conflict(alia, found, target['name']), @name)
             end
-            @aliases[alia] = node['name']
+            @aliases[alia] = target['name']
           end
         end
 
-        # If node is a string, it can refer to either a node name or alias. Which can't be determined
+        # If target is a string, it can refer to either a target name or alias. Which can't be determined
         # until all groups have been resolved, and requires a depth-first traversal to categorize them.
-        @name_or_alias = nodes.select { |node| node.is_a?(String) }
+        @name_or_alias = targets.select { |target| target.is_a?(String) }
 
         @groups = groups.map { |g| Group2.new(g) }
       end
 
-      def node_data(node_name)
-        if (data = @nodes[node_name])
+      def target_data(target_name)
+        if (data = @targets[target_name])
           { 'config' => data['config'] || {},
             'vars' => data['vars'] || {},
             'facts' => data['facts'] || {},
             'features' => data['features'] || [],
-            # This allows us to determine if a node was found?
+            # This allows us to determine if a target was found?
             'name' => data['name'] || nil,
             'uri' => data['uri'] || nil,
             # groups come from group_data
@@ -142,78 +142,78 @@ module Bolt
         value
       end
 
-      def resolve_aliases(aliases, node_names)
+      def resolve_aliases(aliases, target_names)
         @name_or_alias.each do |name_or_alias|
-          # If an alias is found, insert the name into this group. Otherwise use the name as a new node's uri.
-          if node_names.include?(name_or_alias)
-            @nodes[name_or_alias] = { 'name' => name_or_alias }
-          elsif (node_name = aliases[name_or_alias])
-            if @nodes.include?(node_name)
-              @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+          # If an alias is found, insert the name into this group. Otherwise use the name as a new target's uri.
+          if target_names.include?(name_or_alias)
+            @targets[name_or_alias] = { 'name' => name_or_alias }
+          elsif (target_name = aliases[name_or_alias])
+            if @targets.include?(target_name)
+              @logger.warn("Ignoring duplicate target in #{@name}: #{target_name}")
             else
-              @nodes[node_name] = { 'name' => node_name }
+              @targets[target_name] = { 'name' => target_name }
             end
           else
-            node_name = name_or_alias
+            target_name = name_or_alias
 
-            if @nodes.include?(node_name)
-              @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+            if @targets.include?(target_name)
+              @logger.warn("Ignoring duplicate target in #{@name}: #{target_name}")
             else
-              @nodes[node_name] = { 'uri' => node_name }
+              @targets[target_name] = { 'uri' => target_name }
             end
           end
         end
 
-        @groups.each { |g| g.resolve_aliases(aliases, node_names) }
+        @groups.each { |g| g.resolve_aliases(aliases, target_names) }
       end
 
-      private def alias_conflict(name, node1, node2)
-        "Alias #{name} refers to multiple targets: #{node1} and #{node2}"
+      private def alias_conflict(name, target1, target2)
+        "Alias #{name} refers to multiple targets: #{target1} and #{target2}"
       end
 
       private def group_alias_conflict(name)
         "Group #{name} conflicts with alias of the same name"
       end
 
-      private def group_node_conflict(name)
-        "Group #{name} conflicts with node of the same name"
+      private def group_target_conflict(name)
+        "Group #{name} conflicts with target of the same name"
       end
 
-      private def alias_node_conflict(name)
+      private def alias_target_conflict(name)
         "Node name #{name} conflicts with alias of the same name"
       end
 
-      def validate(used_names = Set.new, node_names = Set.new, aliased = {}, depth = 0)
+      def validate(used_names = Set.new, target_names = Set.new, aliased = {}, depth = 0)
         # Test if this group name conflicts with anything used before.
         raise ValidationError.new("Tried to redefine group #{@name}", @name) if used_names.include?(@name)
-        raise ValidationError.new(group_node_conflict(@name), @name) if node_names.include?(@name)
+        raise ValidationError.new(group_target_conflict(@name), @name) if target_names.include?(@name)
         raise ValidationError.new(group_alias_conflict(@name), @name) if aliased.include?(@name)
 
         used_names << @name
 
-        # Collect node names and aliases into a list used to validate that subgroups don't conflict.
-        # Used names validate that previously used group names don't conflict with new node names/aliases.
-        @nodes.each_key do |n|
-          # Require nodes to be parseable as a Target.
+        # Collect target names and aliases into a list used to validate that subgroups don't conflict.
+        # Used names validate that previously used group names don't conflict with new target names/aliases.
+        @targets.each_key do |n|
+          # Require targets to be parseable as a Target.
           begin
             Target.new(n)
           rescue Bolt::ParseError => e
             @logger.debug(e)
-            raise ValidationError.new("Invalid node name #{n}", @name)
+            raise ValidationError.new("Invalid target name #{n}", @name)
           end
 
-          raise ValidationError.new(group_node_conflict(n), @name) if used_names.include?(n)
+          raise ValidationError.new(group_target_conflict(n), @name) if used_names.include?(n)
           if aliased.include?(n)
-            raise ValidationError.new(alias_node_conflict(n), @name)
+            raise ValidationError.new(alias_target_conflict(n), @name)
           end
 
-          node_names << n
+          target_names << n
         end
 
         @aliases.each do |n, target|
           raise ValidationError.new(group_alias_conflict(n), @name) if used_names.include?(n)
-          if node_names.include?(n)
-            raise ValidationError.new(alias_node_conflict(n), @name)
+          if target_names.include?(n)
+            raise ValidationError.new(alias_target_conflict(n), @name)
           end
 
           if aliased.include?(n)
@@ -225,7 +225,7 @@ module Bolt
 
         @groups.each do |g|
           begin
-            g.validate(used_names, node_names, aliased, depth + 1)
+            g.validate(used_names, target_names, aliased, depth + 1)
           rescue ValidationError => e
             e.add_parent(@name)
             raise e
@@ -237,8 +237,8 @@ module Bolt
 
       # The data functions below expect and return nil or a hash of the schema
       # { 'config' => Hash , 'vars' => Hash, 'facts' => Hash, 'features' => Array, groups => Array }
-      def data_for(node_name)
-        data_merge(group_collect(node_name), node_collect(node_name))
+      def data_for(target_name)
+        data_merge(group_collect(target_name), target_collect(target_name))
       end
 
       def group_data
@@ -257,17 +257,17 @@ module Bolt
           'groups' => [] }
       end
 
-      # Returns all nodes contained within the group, which includes nodes from subgroups.
-      def node_names
-        @groups.inject(local_node_names) do |acc, g|
-          acc.merge(g.node_names)
+      # Returns all targets contained within the group, which includes targets from subgroups.
+      def target_names
+        @groups.inject(local_target_names) do |acc, g|
+          acc.merge(g.target_names)
         end
       end
 
-      # Returns a mapping of aliases to nodes contained within the group, which includes subgroups.
-      def node_aliases
+      # Returns a mapping of aliases to targets contained within the group, which includes subgroups.
+      def target_aliases
         @groups.inject(@aliases) do |acc, g|
-          acc.merge(g.node_aliases)
+          acc.merge(g.target_aliases)
         end
       end
 
@@ -278,25 +278,25 @@ module Bolt
         end
       end
 
-      def local_node_names
-        Set.new(@nodes.keys)
+      def local_target_names
+        Set.new(@targets.keys)
       end
-      private :local_node_names
+      private :local_target_names
 
-      def node_collect(node_name)
+      def target_collect(target_name)
         data = @groups.inject(nil) do |acc, g|
-          if (d = g.node_collect(node_name))
+          if (d = g.target_collect(target_name))
             data_merge(d, acc)
           else
             acc
           end
         end
-        data_merge(node_data(node_name), data)
+        data_merge(target_data(target_name), data)
       end
 
-      def group_collect(node_name)
+      def group_collect(target_name)
         data = @groups.inject(nil) do |acc, g|
-          if (d = g.data_for(node_name))
+          if (d = g.data_for(target_name))
             data_merge(d, acc)
           else
             acc
@@ -305,7 +305,7 @@ module Bolt
 
         if data
           data_merge(group_data, data)
-        elsif @nodes.include?(node_name)
+        elsif @targets.include?(target_name)
           group_data
         end
       end

data/lib/bolt/inventory/inventory2.rb

@@ -5,6 +5,13 @@ require 'bolt/inventory/group2'
 module Bolt
   class Inventory
     class Inventory2
+      # This uses "targets" in the message instead of "nodes"
+      class WildcardError < Bolt::Error
+        def initialize(target)
+          super("Found 0 targets matching wildcard pattern #{target}", 'bolt.inventory/wildcard-error')
+        end
+      end
+
       def initialize(data, config = nil, target_vars: {}, target_facts: {}, target_features: {})
         @logger = Logging.logger[self]
         # Config is saved to add config options to targets
@@ -16,7 +23,7 @@ module Bolt
         @target_facts = target_facts
         @target_features = target_features
 
-        @groups.resolve_aliases(@groups.node_aliases, @groups.node_names)
+        @groups.resolve_aliases(@groups.target_aliases, @groups.target_names)
         collect_groups
       end
 
@@ -33,9 +40,11 @@ module Bolt
         @group_lookup.keys
       end
 
-      def node_names
-        @groups.node_names
+      def target_names
+        @groups.target_names
       end
+      # alias for analytics
+      alias node_names target_names
 
       def get_targets(targets)
         targets = expand_targets(targets)
@@ -51,9 +60,9 @@ module Bolt
         if group_names.include?(desired_group)
           targets.each do |target|
             if group_names.include?(target.name)
-              raise ValidationError.new("Group #{target.name} conflicts with node of the same name", target.name)
+              raise ValidationError.new("Group #{target.name} conflicts with target of the same name", target.name)
             end
-            add_node(@groups, target, desired_group)
+            add_target(@groups, target, desired_group)
           end
         else
           raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
@@ -106,8 +115,8 @@ module Bolt
       #### PRIVATE ####
       #
       # For debugging only now
-      def groups_in(node_name)
-        @groups.data_for(node_name)['groups'] || {}
+      def groups_in(target_name)
+        @groups.data_for(target_name)['groups'] || {}
       end
       private :groups_in
 
@@ -145,25 +154,25 @@ module Bolt
       private :update_target
 
       # If target is a group name, expand it to the members of that group.
-      # Else match against nodes in inventory by name or alias.
+      # Else match against targets in inventory by name or alias.
       # If a wildcard string, error if no matches are found.
       # Else fall back to [target] if no matches are found.
       def resolve_name(target)
         if (group = @group_lookup[target])
-          group.node_names
+          group.target_names
         else
-          # Try to wildcard match nodes in inventory
+          # Try to wildcard match targets in inventory
           # Ignore case because hostnames are generally case-insensitive
           regexp = Regexp.new("^#{Regexp.escape(target).gsub('\*', '.*?')}$", Regexp::IGNORECASE)
 
-          nodes = @groups.node_names.select { |node| node =~ regexp }
-          nodes += @groups.node_aliases.select { |target_alias, _node| target_alias =~ regexp }.values
+          targets = @groups.target_names.select { |targ| targ =~ regexp }
+          targets += @groups.target_aliases.select { |target_alias, _target| target_alias =~ regexp }.values
 
-          if nodes.empty?
+          if targets.empty?
             raise(WildcardError, target) if target.include?('*')
             [target]
           else
-            nodes
+            targets
           end
         end
       end
@@ -208,12 +217,15 @@ module Bolt
       end
       private :set_facts
 
-      def add_node(current_group, target, desired_group, track = { 'all' => nil })
+      def add_target(current_group, target, desired_group, track = { 'all' => nil })
         if current_group.name == desired_group
           # Group to add to is found
           t_name = target.name
-          # Add target to nodes hash
-          current_group.nodes[t_name] = { 'name' => t_name }.merge(target.options)
+          # Add target to targets hash
+          target_hash = { 'name' => t_name }.merge(target.options)
+          target_hash['uri'] = target.uri if target.uri
+          current_group.targets[t_name] = target_hash
+
           # Inherit facts, vars, and features from hierarchy
           current_group_data = { facts: current_group.facts,
                                  vars: current_group.vars,
@@ -229,10 +241,10 @@ module Bolt
         # Recurse on children Groups if not desired_group
         current_group.groups.each do |child_group|
           track[child_group.name] = current_group
-          add_node(child_group, target, desired_group, track)
+          add_target(child_group, target, desired_group, track)
         end
       end
-      private :add_node
+      private :add_target
 
       def inherit_data(track, name, data)
         unless track[name].nil?
@@ -250,7 +262,7 @@ module Bolt
         name_opt = {}
         name_opt['name'] = data['name'] if data['name']
 
-        # If there is no name then this node was only referred to as a string.
+        # If there is no name then this target was only referred to as a string.
         uri = data['uri']
         uri ||= target_name unless data['name']
 

data/lib/bolt/rerun.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logging'
+
+module Bolt
+  class Rerun
+    def initialize(path, save_failures)
+      @path = path
+      @save_failures = save_failures
+      @logger = Logging.logger[self]
+    end
+
+    def data
+      @data ||= JSON.parse(File.read(@path))
+      unless @data.is_a?(Array) && @data.all? { |r| r['target'] && r['status'] }
+        raise Bolt::FileError.new("Missing data in rerun file: #{@path}", @path)
+      end
+      @data
+    rescue JSON::ParserError
+      raise Bolt::FileError.new("Could not parse rerun file: #{@path}", @path)
+    rescue IOError, SystemCallError
+      raise Bolt::FileError.new("Could not read rerun file: #{@path}", @path)
+    end
+
+    def get_targets(filter)
+      filtered = case filter
+                 when 'all'
+                   data
+                 when 'failure'
+                   data.select { |result| result['status'] == 'failure' }
+                 when 'success'
+                   data.select { |result| result['status'] == 'success' }
+                 else
+                   raise Bolt::CLIError, "Unexpected option #{filter} for '--retry'"
+                 end
+      filtered.map { |result| result['target'] }
+    end
+
+    def update(result_set)
+      unless @save_failures == false
+        if result_set.is_a?(Bolt::PlanResult)
+          result_set = result_set.value
+          result_set = result_set.result_set if result_set.is_a?(Bolt::RunFailure)
+        end
+
+        if result_set.is_a?(Bolt::ResultSet)
+          data = result_set.map { |res| res.status_hash.select { |k, _| %i[target status].include? k } }
+          File.write(@path, data.to_json)
+        elsif File.exist?(@path)
+          FileUtils.rm(@path)
+        end
+      end
+    rescue StandardError => e
+      @logger.warn("Failed to save result to #{@path}: #{e.message}")
+    end
+  end
+end

data/lib/bolt/result.rb

@@ -91,7 +91,9 @@ module Bolt
     end
 
     def status_hash
+      # DEPRECATION: node in status hashes is deprecated and should be removed in 2.0
       { node: @target.name,
+        target: @target.name,
         type: type,
         object: object,
         status: ok? ? 'success' : 'failure',

data/lib/bolt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.17.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-11 00:00:00.000000000 Z
+date: 2019-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -385,6 +385,7 @@ files:
 - lib/bolt/puppetdb/client.rb
 - lib/bolt/puppetdb/config.rb
 - lib/bolt/r10k_log_proxy.rb
+- lib/bolt/rerun.rb
 - lib/bolt/result.rb
 - lib/bolt/result_set.rb
 - lib/bolt/target.rb