bolt 1.49.0 → 2.0.0

data/lib/bolt/inventory.rb

@@ -3,9 +3,10 @@
 require 'set'
 require 'bolt/config'
 require 'bolt/inventory/group'
-require 'bolt/inventory/inventory2'
+require 'bolt/inventory/inventory'
 require 'bolt/target'
 require 'bolt/util'
+require 'bolt/plugin'
 require 'yaml'
 
 module Bolt
@@ -43,7 +44,7 @@ module Bolt
       end
     end
 
-    def self.from_config(config, plugins = nil)
+    def self.from_config(config, plugins)
       if ENV.include?(ENVIRONMENT_VAR)
         begin
           data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
@@ -65,378 +66,19 @@ module Bolt
     end
 
     def self.create_version(data, config, plugins)
-      version = (data || {}).delete('version') { 1 }
+      version = (data || {}).delete('version') { 2 }
       case version
-      when 1
-        new(data, config, plugins: plugins)
       when 2
-        Bolt::Inventory::Inventory2.new(data, config, plugins: plugins)
+        Bolt::Inventory::Inventory.new(data, config, plugins: plugins)
       else
         raise ValidationError.new("Unsupported version #{version} specified in inventory", nil)
       end
     end
 
-    attr_reader :plugins, :config
-
-    def initialize(data, config = nil, plugins: nil, target_vars: {},
-                   target_facts: {}, target_features: {}, target_plugin_hooks: {})
-      @logger = Logging.logger[self]
-      # Config is saved to add config options to targets
-      @config = config || Bolt::Config.default
-      @data = data ||= {}
-      @groups = Group.new(data.merge('name' => 'all'))
-      @group_lookup = {}
-      @target_vars = target_vars
-      @target_facts = target_facts
-      @target_features = target_features
-      @plugins = plugins
-      @target_plugin_hooks = target_plugin_hooks
-
-      @groups.resolve_aliases(@groups.node_aliases)
-      collect_groups
-
-      deprecation unless @data.empty?
-    end
-
-    def validate
-      @groups.validate
-    end
-
-    def version
-      1
-    end
-
-    def deprecation
-      msg = <<~MSG
-        Deprecation Warning: Starting with Bolt 2.0, inventory file v1 will no longer
-        be supported. v1 inventory files can be automatically migrated to v2 using
-        'bolt project migrate'. Inventory files are modified in place and will not
-        preserve formatting or comments.
-      MSG
-      @logger.warn(msg)
-    end
-    private :deprecation
-
-    def collect_groups
-      # Provide a lookup map for finding a group by name
-      @group_lookup = @groups.collect_groups
-    end
-
-    def group_names
-      @group_lookup.keys
-    end
-
-    def node_names
-      @groups.node_names
-    end
-
-    def plugin_hooks(target)
-      @target_plugin_hooks[target.name] || {}
-    end
-
-    def get_targets(targets)
-      targets = expand_targets(targets)
-      targets = if targets.is_a? Array
-                  targets.flatten.uniq(&:name)
-                else
-                  [targets]
-                end
-      targets.map { |t| update_target(t) }
-    end
-
-    def add_to_group(targets, desired_group)
-      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)
-          end
-          add_node(@groups, target, desired_group)
-        end
-      else
-        raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
-      end
-    end
-
-    def remove_from_group(target, desired_group)
-      unless target.length == 1
-        raise ValidationError.new("'remove_from_group' expects a single Target, got #{target.length}", nil)
-      end
-
-      if desired_group == 'all'
-        raise ValidationError.new("Cannot remove Target from Group 'all'", nil)
-      end
-
-      if group_names.include?(desired_group)
-        invalidate_group_cache!(target.first)
-        remove_node(@groups, target.first, desired_group)
-      else
-        raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
-      end
-    end
-
-    def set_var(target, var_hash)
-      set_vars_from_hash(target.name, var_hash)
-    end
-
-    def vars(target)
-      @target_vars[target.name] || {}
-    end
-
-    def add_facts(target, new_facts = {})
-      @logger.warn("No facts to add") if new_facts.empty?
-      facts = set_facts(target.name, new_facts)
-      # rubocop:disable Style/GlobalVars
-      $future ? target : facts
-      # rubocop:enable Style/GlobalVars
-    end
-
-    def facts(target)
-      @target_facts[target.name] || {}
-    end
-
-    def set_feature(target, feature, value = true)
-      @target_features[target.name] ||= Set.new
-      if value
-        @target_features[target.name] << feature
-      else
-        @target_features[target.name].delete(feature)
-      end
-    end
-
-    def features(target)
-      @target_features[target.name] || Set.new
-    end
-
-    def target_alias(target)
-      @groups.node_aliases.each_with_object([]) do |(alia, name), acc|
-        if target.name == name
-          acc << alia
-        end
-      end.uniq
-    end
-
-    def data_hash
-      {
-        data: @data,
-        target_hash: {
-          target_vars: @target_vars,
-          target_facts: @target_facts,
-          target_features: @target_features
-        },
-        config: @config.transport_data_get
-      }
-    end
-
-    #### PRIVATE ####
-    #
-    # For debugging only now
-    def groups_in(node_name)
-      @groups.data_for(node_name)['groups'] || {}
-    end
-    private :groups_in
-
-    # TODO: Possibly refactor this once inventory v2 is more stable
-    def self.localhost_defaults(data)
-      defaults = {
-        'config' => {
-          'transport' => 'local',
-          'local' => { 'interpreters' => { '.rb' => RbConfig.ruby } }
-        },
-        'features' => ['puppet-agent']
-      }
-      data = Bolt::Util.deep_merge(defaults, data)
-      # If features is an empty array deep_merge won't add the puppet-agent
-      data['features'] += ['puppet-agent'] if data['features'].empty?
-      data
-    end
-
-    # Pass a target to get_targets for a public version of this
-    # Should this reconfigure configured targets?
-    def update_target(target)
-      data = @groups.data_for(target.name)
-      data ||= {}
-
-      unless data['config']
-        @logger.debug("Did not find config for #{target.name} in inventory")
-        data['config'] = {}
-      end
-
-      data = self.class.localhost_defaults(data) if target.name == 'localhost'
-      # These should only get set from the inventory if they have not yet
-      # been instantiated
-      set_vars_from_hash(target.name, data['vars']) unless @target_vars[target.name]
-      set_facts(target.name, data['facts']) unless @target_facts[target.name]
-      data['features']&.each { |feature| set_feature(target, feature) } unless @target_features[target.name]
-      unless @target_plugin_hooks[target.name]
-        set_plugin_hooks(target.name, (@plugins&.plugin_hooks || {}).merge(data['plugin_hooks'] || {}))
-      end
-
-      # Use Config object to ensure config section is treated consistently with config file
-      conf = @config.deep_clone
-      conf.update_from_inventory(data['config'])
-      conf.validate
-
-      target.update_conf(conf.transport_conf)
-
-      unless target.transport.nil? || Bolt::TRANSPORTS.include?(target.transport.to_sym)
-        raise Bolt::UnknownTransportError.new(target.transport, target.uri)
-      end
-
-      target
-    end
-    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.
-    # 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
-      else
-        # Try to wildcard match nodes 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
-
-        if nodes.empty?
-          raise(WildcardError, target) if target.include?('*')
-          [target]
-        else
-          nodes
-        end
-      end
-    end
-    private :resolve_name
-
-    def create_target(data)
-      Bolt::Target.new(data)
-    end
-    private :create_target
-
-    def expand_targets(targets)
-      if targets.is_a? Bolt::Target
-        targets.inventory = self
-        targets
-      elsif targets.is_a? Array
-        targets.map { |tish| expand_targets(tish) }
-      elsif targets.is_a? String
-        # Expand a comma-separated list
-        targets.split(/[[:space:],]+/).reject(&:empty?).map do |name|
-          ts = resolve_name(name)
-          ts.map do |t|
-            target = create_target(t)
-            target.inventory = self
-            target
-          end
-        end
-      end
-    end
-    private :expand_targets
-
-    def set_vars_from_hash(tname, data)
-      if data
-        # Instantiate empty vars hash in case no vars are defined
-        @target_vars[tname] ||= {}
-        # Assign target new merged vars hash
-        # This is essentially a copy-on-write to maintain the immutability of @target_vars
-        @target_vars[tname] = @target_vars[tname].merge(data).freeze
-      end
-    end
-    private :set_vars_from_hash
-
-    def set_facts(tname, hash)
-      if hash
-        @target_facts[tname] ||= {}
-        @target_facts[tname] = Bolt::Util.deep_merge(@target_facts[tname], hash).freeze
-      end
-    end
-    private :set_facts
-
-    def set_plugin_hooks(tname, hash)
-      if hash
-        @target_plugin_hooks[tname] ||= {}
-        @target_plugin_hooks[tname].merge!(hash)
-      end
-    end
-    private :set_plugin_hooks
-
-    def remove_node(current_group, target, desired_group, track = { 'all' => nil })
-      # Remove the target from the group
-      if current_group.name == desired_group
-        current_group.nodes.delete(target.name)
-      # If the target remains in the group, add the group data to the cache
-      elsif current_group.node_names.include?(target.name)
-        add_group_data_to_cache(current_group, target, track)
-      end
-      current_group.groups.each do |child_group|
-        # If target was in current group, remove it from all child groups
-        desired_group = child_group.name if current_group.name == desired_group
-        track[child_group.name] = current_group
-        remove_node(child_group, target, desired_group)
-      end
-    end
-    private :remove_node
-
-    def add_node(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_group_data_to_cache(current_group, target, track)
-        return true
-      end
-      # 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)
-      end
-    end
-    private :add_node
-
-    def add_group_data_to_cache(current_group, target, track)
-      t_name = target.name
-      current_group_data = { facts: current_group.facts,
-                             vars: current_group.vars,
-                             features: current_group.features,
-                             plugin_hooks: current_group.plugin_hooks }
-      data = inherit_data(track, current_group.name, current_group_data)
-      set_facts(t_name, @target_facts[t_name] ? data[:facts].merge(@target_facts[t_name]) : data[:facts])
-      set_vars_from_hash(t_name, @target_vars[t_name] ? data[:vars].merge(@target_vars[t_name]) : data[:vars])
-      data[:features].each do |feature|
-        set_feature(target, feature)
-      end
-      hook_data = @config.plugin_hooks.merge(data[:plugin_hooks])
-      hash = if @target_plugin_hooks[t_name]
-               hook_data.merge(@target_plugin_hooks[t_name])
-             else
-               hook_data
-             end
-      set_plugin_hooks(t_name, hash)
-    end
-    private :add_group_data_to_cache
-
-    def inherit_data(track, name, data)
-      unless track[name].nil?
-        data[:facts] = track[name].facts.merge(data[:facts])
-        data[:vars] = track[name].vars.merge(data[:vars])
-        data[:features].concat(track[name].features)
-        data[:plugin_hooks] = track[name].plugin_hooks.merge(data[:plugin_hooks])
-        inherit_data(track, track[name].name, data)
-      end
-      data
-    end
-    private :inherit_data
-
-    def invalidate_group_cache!(target)
-      @target_facts.delete(target.name)
-      @target_features.delete(target.name)
-      @target_vars.delete(target.name)
-      @target_plugin_hooks.delete(target.name)
+    def self.empty
+      config = Bolt::Config.default
+      plugins = Bolt::Plugin.setup(config, nil, nil, Bolt::Analytics::NoopClient)
+      create_version({}, config, plugins)
     end
-    private :invalidate_group_cache!
   end
 end

data/lib/bolt/inventory/group.rb

@@ -1,258 +1,376 @@
 # frozen_string_literal: true
 
+require 'bolt/inventory/group'
+require 'bolt/inventory/inventory'
+require 'bolt/inventory/target'
+
 module Bolt
   class Inventory
-    # Group is a specific implementation of Inventory based on nested
-    # structured data.
     class Group
-      attr_accessor :name, :nodes, :aliases, :name_or_alias, :groups,
-                    :config, :rest, :facts, :vars, :features, :plugin_hooks
+      attr_accessor :name, :groups
 
       # Regex used to validate group names and target aliases.
       NAME_REGEX = /\A[a-z0-9_][a-z0-9_-]*\Z/.freeze
 
-      DATA_KEYS = %w[name config facts vars features plugin_hooks].freeze
-      NODE_KEYS = DATA_KEYS + ['alias']
-      GROUP_KEYS = DATA_KEYS + %w[groups nodes]
+      DATA_KEYS = %w[config facts vars features plugin_hooks].freeze
+      TARGET_KEYS = DATA_KEYS + %w[name alias uri]
+      GROUP_KEYS = DATA_KEYS + %w[name groups targets]
       CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
 
-      def initialize(data)
+      def initialize(input, plugins)
         @logger = Logging.logger[self]
+        @plugins = plugins
+
+        input = @plugins.resolve_top_level_references(input) if @plugins.reference?(input)
 
-        raise ValidationError.new("Expected group to be a Hash, not #{data.class}", nil) unless data.is_a?(Hash)
-        raise ValidationError.new("Group does not have a name", nil) unless data.key?('name')
+        raise ValidationError.new("Group does not have a name", nil) unless input.key?('name')
+
+        @name = @plugins.resolve_references(input['name'])
 
-        @name = data['name']
         raise ValidationError.new("Group name must be a String, not #{@name.inspect}", nil) unless @name.is_a?(String)
         raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ NAME_REGEX
 
-        unless (unexpected_keys = data.keys - GROUP_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in group #{@name}"
-          @logger.warn(msg)
-        end
+        validate_group_input(input)
 
-        @vars = fetch_value(data, 'vars', Hash)
-        @facts = fetch_value(data, 'facts', Hash)
-        @features = fetch_value(data, 'features', Array)
-        @plugin_hooks = fetch_value(data, 'plugin_hooks', Hash)
-        @config = fetch_value(data, 'config', Hash)
+        @input = input
 
-        unless (unexpected_keys = @config.keys - CONFIG_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for group #{@name}"
-          @logger.warn(msg)
-        end
+        validate_data_keys(@input)
+
+        targets = @plugins.resolve_top_level_references(input.fetch('targets', []))
 
-        nodes = fetch_value(data, 'nodes', Array)
-        groups = fetch_value(data, 'groups', Array)
+        @unresolved_targets = {}
+        @resolved_targets = {}
 
-        @nodes = {}
         @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)
+        @string_targets = []
+
+        Array(targets).each do |target|
+          # If target is a string, it can either be trivially defining a target
+          # or it could be a name/alias of a target defined in another group.
+          # We can't tell the difference until all groups have been resolved,
+          # so we store the string on its own here and process it later.
+          if target.is_a?(String)
+            @string_targets << target
+          # Handle plugins at this level so that lookups cannot trigger recursive lookups
+          elsif target.is_a?(Hash)
+            add_target_definition(target)
+          else
+            raise ValidationError.new("Target entry must be a String or Hash, not #{target.class}", @name)
           end
+        end
 
-          if @nodes.include?(node['name'])
-            @logger.warn("Ignoring duplicate node in #{@name}: #{node}")
-            next
-          end
+        groups = input.fetch('groups', [])
+        # 'groups' can be a _plugin reference, in which case we want to resolve
+        # it. That can itself return a reference, so we want to keep resolving
+        # them until we have a value. We don't just use resolve_references
+        # though, since that will resolve any nested references and we want to
+        # leave it to the group to do that lazily.
+        groups = @plugins.resolve_top_level_references(groups)
 
-          raise ValidationError.new("Node #{node} does not have a name", @name) unless node['name']
-          @nodes[node['name']] = node
+        @groups = Array(groups).map { |g| Group.new(g, plugins) }
+      end
 
-          unless (unexpected_keys = node.keys - NODE_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in node #{node['name']}"
-            @logger.warn(msg)
-          end
+      def target_data(target_name)
+        if @unresolved_targets.key?(target_name)
+          target = @unresolved_targets.delete(target_name)
+          resolved_data = resolve_data_keys(target, target_name).merge(
+            'name' => target['name'],
+            'uri' => target['uri'],
+            'alias' => target['alias'],
+            # groups come from group_data
+            'groups' => []
+          )
+          @resolved_targets[target_name] = resolved_data
+        else
+          @resolved_targets[target_name]
+        end
+      end
 
-          unless node['config'].nil? || node['config'].is_a?(Hash)
-            raise ValidationError.new("Invalid configuration for node: #{node['name']}", @name)
-          end
+      def all_target_names
+        @unresolved_targets.keys + @resolved_targets.keys
+      end
 
-          config_keys = node['config']&.keys || []
-          unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for node #{node['name']}"
-            @logger.warn(msg)
-          end
+      def add_target_definition(target)
+        # This check ensures target lookup plugins do not returns bare strings.
+        # Remove it if we decide to allows task plugins to return string Target
+        # names.
+        unless target.is_a?(Hash)
+          raise ValidationError.new("Target entry must be a Hash, not #{target.class}", @name)
+        end
+
+        target['name'] = @plugins.resolve_references(target['name']) if target.key?('name')
+        target['uri'] = @plugins.resolve_references(target['uri']) if target.key?('uri')
+        target['alias'] = @plugins.resolve_references(target['alias']) if target.key?('alias')
+
+        t_name = target['name'] || target['uri']
+
+        if t_name.nil? || t_name.empty?
+          raise ValidationError.new("No name or uri for target: #{target}", @name)
+        end
+
+        unless t_name.is_a? String
+          raise ValidationError.new("Target name must be a String, not #{t_name.class}", @name)
+        end
+
+        unless t_name.ascii_only?
+          raise ValidationError.new("Target name must be ASCII characters: #{target}", @name)
+        end
+
+        if local_targets.include?(t_name)
+          @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
+          return
+        end
+
+        unless (unexpected_keys = target.keys - TARGET_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{t_name}"
+          @logger.warn(msg)
+        end
 
-          next unless node.include?('alias')
+        validate_data_keys(target, t_name)
 
-          aliases = node['alias']
+        if target.include?('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 #{t_name} must be a String or Array, not #{aliases.class}"
             raise ValidationError.new(msg, @name)
           end
 
-          aliases.each do |alia|
-            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)
-            end
-            @aliases[alia] = node['name']
-          end
+          insert_alia(t_name, aliases)
         end
 
-        # If node is a string, it can refer to either a node 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) }
+        @unresolved_targets[t_name] = target
+      end
+
+      def remove_target(target)
+        @resolved_targets.delete(target.name)
+        @unresolved_targets.delete(target.name)
+      end
 
-        @groups = groups.map { |g| Group.new(g) }
+      def add_target(target)
+        @resolved_targets[target.name] = { 'name' => target.name }
       end
 
-      private def fetch_value(data, key, type)
-        value = data.fetch(key, type.new)
-        unless value.is_a?(type)
-          raise ValidationError.new("Expected #{key} to be of type #{type}, not #{value.class}", @name)
+      def insert_alia(target_name, aliases)
+        aliases.each do |alia|
+          raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
+
+          if (found = @aliases[alia])
+            raise ValidationError.new(alias_conflict(alia, found, target_name), @name)
+          end
+          @aliases[alia] = target_name
         end
-        value
       end
 
-      def resolve_aliases(aliases)
-        @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.
-          node_name = aliases[name_or_alias] || name_or_alias
+      def clear_alia(target_name)
+        @aliases.reject! { |_alias, name| name == target_name }
+      end
+
+      def data_merge(data1, data2)
+        if data2.nil? || data1.nil?
+          return data2 || data1
+        end
+
+        {
+          'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
+          'name' => data1['name'] || data2['name'],
+          'uri' => data1['uri'] || data2['uri'],
+          # Collect all aliases across all groups for each target uri
+          'alias' => [*data1['alias'], *data2['alias']],
+          # Shallow merge instead of deep merge so that vars with a hash value
+          # are assigned a new hash, rather than merging the existing value
+          # with the value meant to replace it
+          'vars' => data1['vars'].merge(data2['vars']),
+          'facts' => Bolt::Util.deep_merge(data1['facts'], data2['facts']),
+          'features' => data1['features'] | data2['features'],
+          'plugin_hooks' => data1['plugin_hooks'].merge(data2['plugin_hooks']),
+          'groups' => data2['groups'] + data1['groups']
+        }
+      end
 
-          if @nodes.include?(node_name)
-            @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+      def resolve_string_targets(aliases, known_targets)
+        @string_targets.each do |string_target|
+          # If this is the name of a target defined elsewhere, then insert the
+          # target into this group as just a name. Otherwise, add a new target
+          # with the string as the URI.
+          if known_targets.include?(string_target)
+            @unresolved_targets[string_target] = { 'name' => string_target }
+          # If this is an alias for an existing target, then add it to this group
+          elsif (canonical_name = aliases[string_target])
+            if local_targets.include?(canonical_name)
+              @logger.warn("Ignoring duplicate target in #{@name}: #{canonical_name}")
+            else
+              @unresolved_targets[canonical_name] = { 'name' => canonical_name }
+            end
+          # If it's not the name or alias of an existing target, then make a
+          # new target using the string as the URI
+          elsif local_targets.include?(string_target)
+            @logger.warn("Ignoring duplicate target in #{@name}: #{string_target}")
           else
-            @nodes[node_name] = { 'name' => node_name }
+            @unresolved_targets[string_target] = { 'uri' => string_target }
           end
         end
 
-        @groups.each { |g| g.resolve_aliases(aliases) }
+        @groups.each { |g| g.resolve_string_targets(aliases, known_targets) }
       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_target_conflict(name)
+        "Target name #{name} conflicts with alias of the same name"
       end
 
-      private def alias_node_conflict(name)
-        "Node name #{name} conflicts with alias of the same name"
+      def validate_group_input(input)
+        raise ValidationError.new("Expected group to be a Hash, not #{input.class}", nil) unless input.is_a?(Hash)
+
+        # DEPRECATION : remove this before finalization
+        if input.key?('target-lookups')
+          msg = "'target-lookups' are no longer a separate key. Merge 'target-lookups' and 'targets' lists and replace 'plugin' with '_plugin'" # rubocop:disable Layout/LineLength
+          raise ValidationError.new(msg, @name)
+        end
+
+        if input.key?('nodes')
+          msg = <<~MSG.chomp
+                Found 'nodes' key in group #{@name}. This looks like a v1 inventory file, which is
+                no longer supported by Bolt. Migrate to a v2 inventory file automatically using
+                'bolt project migrate'.
+                MSG
+          raise ValidationError.new(msg, nil)
+        end
+
+        unless (unexpected_keys = input.keys - GROUP_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in group #{@name}"
+          @logger.warn(msg)
+        end
+
+        Bolt::Util.walk_keys(input) do |key|
+          if @plugins.reference?(key)
+            raise ValidationError.new("Group keys cannot be specified as _plugin references", @name)
+          else
+            key
+          end
+        end
       end
 
-      def validate(used_names = Set.new, node_names = Set.new, aliased = {}, depth = 0)
+      def validate(used_group_names = Set.new, used_target_names = Set.new, used_aliases = {})
         # 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_alias_conflict(@name), @name) if aliased.include?(@name)
+        raise ValidationError.new("Tried to redefine group #{@name}", @name) if used_group_names.include?(@name)
+        raise ValidationError.new(group_target_conflict(@name), @name) if used_target_names.include?(@name)
+        raise ValidationError.new(group_alias_conflict(@name), @name) if used_aliases.include?(@name)
 
-        used_names << @name
+        used_group_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.
+        @unresolved_targets.merge(@resolved_targets).each do |t_name, t_data|
+          # Require targets to be parseable as a Target.
           begin
-            Bolt::Target.new(n)
+            # Catch malformed URI here
+            Bolt::Inventory::Target.parse_uri(t_data['uri'])
           rescue Bolt::ParseError => e
             @logger.debug(e)
-            raise ValidationError.new("Invalid node name #{n}", @name)
+            raise ValidationError.new("Invalid target uri #{t_data['uri']}", @name)
           end
 
-          raise ValidationError.new(group_node_conflict(n), @name) if used_names.include?(n)
-          raise ValidationError.new(alias_node_conflict(n), @name) if aliased.include?(n)
+          raise ValidationError.new(group_target_conflict(t_name), @name) if used_group_names.include?(t_name)
+          if used_aliases.include?(t_name)
+            raise ValidationError.new(alias_target_conflict(t_name), @name)
+          end
 
-          node_names << n
+          used_target_names << t_name
         end
 
         @aliases.each do |n, target|
-          raise ValidationError.new(group_alias_conflict(n), @name) if used_names.include?(n)
-          raise ValidationError.new(alias_node_conflict(n), @name) if node_names.include?(n)
+          raise ValidationError.new(group_alias_conflict(n), @name) if used_group_names.include?(n)
+          if used_target_names.include?(n)
+            raise ValidationError.new(alias_target_conflict(n), @name)
+          end
 
-          if aliased.include?(n) && aliased[n] != target
-            raise ValidationError.new(alias_conflict(n, target, aliased[n]), @name)
+          if used_aliases.include?(n)
+            raise ValidationError.new(alias_conflict(n, target, used_aliases[n]), @name)
           end
 
-          aliased[n] = target
+          used_aliases[n] = target
         end
 
         @groups.each do |g|
-          begin
-            g.validate(used_names, node_names, aliased, depth + 1)
-          rescue ValidationError => e
-            e.add_parent(@name)
-            raise e
-          end
+          g.validate(used_group_names, used_target_names, used_aliases)
+        rescue ValidationError => e
+          e.add_parent(@name)
+          raise e
         end
 
         nil
       end
 
-      # 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 resolve_data_keys(data, target = nil)
+        result = {
+          'config' => @plugins.resolve_references(data.fetch('config', {})),
+          'vars' => @plugins.resolve_references(data.fetch('vars', {})),
+          'facts' => @plugins.resolve_references(data.fetch('facts', {})),
+          'features' => @plugins.resolve_references(data.fetch('features', [])),
+          'plugin_hooks' => @plugins.resolve_references(data.fetch('plugin_hooks', {}))
+        }
+        validate_data_keys(result, target)
+        result['features'] = Set.new(result['features'].flatten)
+        result
       end
 
-      def node_data(node_name)
-        if (data = @nodes[node_name])
-          { 'config' => data['config'] || {},
-            'vars' => data['vars'] || {},
-            'facts' => data['facts'] || {},
-            'features' => data['features'] || [],
-            'plugin_hooks' => data['plugin_hooks'] || {},
-            # groups come from group_data
-            'groups' => [] }
+      def validate_data_keys(data, target = nil)
+        {
+          'config' => Hash,
+          'vars' => Hash,
+          'facts' => Hash,
+          'features' => Array,
+          'plugin_hooks' => Hash
+        }.each do |key, expected_type|
+          next if !data.key?(key) || data[key].is_a?(expected_type) || @plugins.reference?(data[key])
+
+          msg = +"Expected #{key} to be of type #{expected_type}, not #{data[key].class}"
+          msg << " for target #{target}" if target
+          raise ValidationError.new(msg, @name)
+        end
+        unless @plugins.reference?(data['config'])
+          unexpected_keys = data.fetch('config', {}).keys - CONFIG_KEYS
+          if unexpected_keys.any?
+            msg = +"Found unexpected key(s) #{unexpected_keys.join(', ')} in config for"
+            msg << " target #{target} in" if target
+            msg << " group #{@name}"
+            @logger.warn(msg)
+          end
         end
       end
 
       def group_data
-        { 'config' => @config,
-          'vars' => @vars,
-          'facts' => @facts,
-          'features' => @features,
-          'plugin_hooks' => @plugin_hooks,
-          'groups' => [@name] }
+        @group_data ||= resolve_data_keys(@input).merge('groups' => [@name])
       end
 
-      def empty_data
-        { 'config' => {},
-          'vars' => {},
-          'facts' => {},
-          'features' => [],
-          'plugin_hooks' => {},
-          'groups' => [] }
-      end
-
-      def data_merge(data1, data2)
-        if data2.nil? || data1.nil?
-          return data2 || data1
-        end
-
-        {
-          'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
-          # Shallow merge instead of deep merge so that vars with a hash value
-          # are assigned a new hash, rather than merging the existing value
-          # with the value meant to replace it
-          'vars' => data1['vars'].merge(data2['vars']),
-          'facts' => Bolt::Util.deep_merge(data1['facts'], data2['facts']),
-          'features' => data1['features'] | data2['features'],
-          'plugin_hooks' => data1['plugin_hooks'].merge(data2['plugin_hooks']),
-          'groups' => data2['groups'] + data1['groups']
-        }
+      # Returns targets contained directly within the group, ignoring subgroups
+      def local_targets
+        Set.new(@unresolved_targets.keys) + Set.new(@resolved_targets.keys)
       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 all_targets
+        @groups.inject(local_targets) do |acc, g|
+          acc.merge(g.all_targets)
         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
 
@@ -263,35 +381,28 @@ module Bolt
         end
       end
 
-      def local_node_names
-        Set.new(@nodes.keys)
-      end
-      private :local_node_names
-
-      def node_collect(node_name)
-        data = @groups.inject(nil) do |acc, g|
-          if (d = g.node_collect(node_name))
-            data_merge(d, acc)
-          else
-            acc
-          end
+      def target_collect(target_name)
+        child_data = @groups.map { |group| group.target_collect(target_name) }
+        # Data from earlier groups wins
+        child_result = child_data.inject do |acc, group_data|
+          data_merge(group_data, acc)
         end
-        data_merge(node_data(node_name), data)
+        # Children override the parent
+        data_merge(target_data(target_name), child_result)
       end
 
-      def group_collect(node_name)
-        data = @groups.inject(nil) do |acc, g|
-          if (d = g.data_for(node_name))
-            data_merge(d, acc)
-          else
-            acc
-          end
+      def group_collect(target_name)
+        child_data = @groups.map { |group| group.group_collect(target_name) }
+        # Data from earlier groups wins
+        child_result = child_data.inject do |acc, group_data|
+          data_merge(group_data, acc)
         end
 
-        if data
-          data_merge(group_data, data)
-        elsif @nodes.include?(node_name)
-          group_data
+        # If this group has the target or one of the child groups has the
+        # target, return the data, otherwise return nil
+        if child_result || local_targets.include?(target_name)
+          # Children override the parent
+          data_merge(group_data, child_result)
         end
       end
     end