bolt 1.31.1 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f18043cfb3f91f5ce7fa45d339bc9aba13132d09592516f6ce02af8557bba712
-  data.tar.gz: f8814932c524a3e753b775f719894950a1e57f93db9287b29dc0b966e9f70bf9
+  metadata.gz: 40fdd97c4150459a56f711d9ece1e1c0b57ff19c4e64ddb88459ea947bf4bbab
+  data.tar.gz: d2079c900a66e50d0bd9cccd17da37ab965686c6b6c9402b262f148ba2549c44
 SHA512:
-  metadata.gz: 6cbc17086c5324dd743bfe073b3c7ebbba25e82fc3fe96af819aee84aa27d3b81d3a6ec2b1535816932a4717f5ca5c0aa792dfa80c9ce76f1cda8d10ae3edac9
-  data.tar.gz: e8491955503d7e3b2a0c83faeea77b7fb85393fae307c644f62761116d07048b2396007e0b873ac6e98a82d6da3666a4e3c0f7413a75014560df56c98e236238
+  metadata.gz: bd59adfaa8bb6178de571eef84a08f124666ca94abb9a2a0550127ff105dc7c55e47ba789f9d09c1eae33a517dd4baaf95fce21543dc77bdedfb35c9472ffe88
+  data.tar.gz: 7f80fcb3d13a832338ab4da986d2ac25bdfbf67785f3fd863692cbd4eb018a30e7a687020c8d7c551ec1f58da9abefadbcd3976820c3d83a3c1cdfd9efb79f47

data/bolt-modules/boltlib/lib/puppet/datatypes/target.rb

@@ -1,22 +1,55 @@
 # frozen_string_literal: true
 
 Puppet::DataTypes.create_type('Target') do
-  interface <<-PUPPET
-    attributes => {
-      uri => String[1],
-      options => { type => Hash[String[1], Data], value => {} }
-    },
-    functions => {
-      name => Callable[[], String[1]],
-      host => Callable[[], Optional[String]],
-      password => Callable[[], Optional[String[1]]],
-      port => Callable[[], Optional[Integer]],
-      protocol => Callable[[], Optional[String[1]]],
-      user => Callable[[], Optional[String[1]]],
-    }
-  PUPPET
-
+  begin
+    inventory = Puppet.lookup(:bolt_inventory)
+    inventory_version = inventory.version
+    if inventory_version != 1
+      target_implementation_class = inventory.target_implementation_class
+    end
+  rescue Puppet::Context::UndefinedBindingError
+    inventory_version = 1
+  end
   load_file('bolt/target')
 
-  implementation_class Bolt::Target
+  if inventory_version == 1
+    interface <<-PUPPET
+      attributes => {
+        uri => String[1],
+        options => { type => Hash[String[1], Data], value => {} }
+      },
+      functions => {
+        name => Callable[[], String[1]],
+        host => Callable[[], Optional[String]],
+        password => Callable[[], Optional[String[1]]],
+        port => Callable[[], Optional[Integer]],
+        protocol => Callable[[], Optional[String[1]]],
+        user => Callable[[], Optional[String[1]]],
+      }
+    PUPPET
+    implementation_class Bolt::Target
+  else
+    interface <<-PUPPET
+      attributes => {
+        uri => { type => Optional[String[1]], kind => given_or_derived },
+        name => { type => Optional[String[1]] , kind => given_or_derived },
+        target_alias => { type => Optional[Variant[String[1], Array[String[1]]]], kind => given_or_derived },
+        config => { type => Optional[Hash[String[1], Data]], kind => given_or_derived },
+        vars => { type => Optional[Hash[String[1], Data]], kind => given_or_derived  },
+        facts => { type => Optional[Hash[String[1], Data]], kind => given_or_derived  },
+        features => { type => Optional[Array[String[1]]], kind => given_or_derived },
+        plugin_hooks => { type => Optional[Hash[String[1], Data]], kind => given_or_derived  }
+      },
+      functions => {
+        safe_name => Callable[[], String[1]],
+        host => Callable[[], Optional[String]],
+        password => Callable[[], Optional[String[1]]],
+        port => Callable[[], Optional[Integer]],
+        protocol => Callable[[], Optional[String[1]]],
+        user => Callable[[], Optional[String[1]]],
+      }
+    PUPPET
+
+    implementation_class target_implementation_class
+  end
 end

data/bolt-modules/boltlib/lib/puppet/functions/get_resources.rb

@@ -6,7 +6,10 @@ require 'bolt/task'
 # The results are returned as a list of hashes representing each resource.
 #
 # Requires the Puppet Agent be installed on the target, which can be accomplished with apply_prep
-# or by directly running the puppet_agent::install task.
+# or by directly running the puppet_agent::install task. In order to be able to reference types without
+# string quoting (for example `get_resources($target, Package)` instead of `get_resources($target, 'Package')`)
+# run the command `bolt puppetfile generate-types` to generate type references in `$Boldir/.resource_types`.
+#
 #
 # **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:get_resources) do
@@ -16,7 +19,7 @@ Puppet::Functions.create_function(:get_resources) do
   #   get_resources('target1,target2', [Package, File[/etc/puppetlabs]])
   dispatch :get_resources do
     param 'Boltlib::TargetSpec', :targets
-    param 'Variant[String, Resource, Array[Variant[String, Resource]]]', :resources
+    param 'Variant[String, Type[Resource], Array[Variant[String, Type[Resource]]]]', :resources
   end
 
   def script_compiler
@@ -44,6 +47,10 @@ Puppet::Functions.create_function(:get_resources) do
     inventory = Puppet.lookup(:bolt_inventory)
 
     resources = [resources].flatten
+
+    # Stringify resource types to pass to task
+    resources.map! { |r| r.is_a?(String) ? r : r.to_s }
+
     resources.each do |resource|
       if resource !~ /^\w+$/ && resource !~ /^\w+\[.+\]$/
         raise Bolt::Error.new("#{resource} is not a valid resource type or type instance name", 'bolt/get-resources')

data/bolt-modules/boltlib/lib/puppet/functions/get_target.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Get a single target from inventory if it exists, otherwise create a new Target.
+#
+# **NOTE:** Calling `get_target` inside an `apply` block with a
+# version 2 inventory creates a new Target object.
+# `get_target('all')` returns an empty array.
+# **NOTE:** Only compatible with inventory v2
+Puppet::Functions.create_function(:get_target) do
+  # @param name A Target name.
+  # @return A single target, either new or from inventory.
+  # @example Create a new Target from a URI
+  #   get_target('winrm://host2:54321')
+  # @example Get an existing Target from inventory
+  #   get_target('existing-target')
+  dispatch :get_target do
+    param 'Boltlib::TargetSpec', :name
+    return_type 'Target'
+  end
+
+  def get_target(name)
+    inventory = Puppet.lookup(:bolt_inventory)
+    # Bolt executor not expected when invoked from apply block
+    executor = Puppet.lookup(:bolt_executor) { nil }
+    executor&.report_function_call(self.class.name)
+
+    unless inventory.version > 1
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::UNSUPPORTED_INVENTORY_VERSION, action: 'get_target')
+    end
+
+    inventory.get_target(name)
+  end
+end

data/bolt-modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -83,6 +83,22 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
       executor.report_yaml_plan(closure.model.body)
     end
 
+    # If a TargetSpec parameter is passed, ensure it is in inventory
+    inventory = Puppet.lookup(:bolt_inventory)
+
+    if inventory.version > 1
+      param_types = closure.parameters.each_with_object({}) do |param, param_acc|
+        param_acc[param.name] = extract_parameter_types(param.type_expr).flatten
+      end
+      params.each do |param, value|
+        # Note the safe lookup operator is needed to handle case where a parameter is passed to a
+        # plan that the plan is not expecting
+        if param_types[param]&.include?('TargetSpec') || param_types[param]&.include?('Boltlib::TargetSpec')
+          inventory.get_targets(value)
+        end
+      end
+    end
+
     # wrap plan execution in logging messages
     executor.log_plan(plan_name) do
       result = nil
@@ -116,4 +132,30 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
       result
     end
   end
+
+  # Recursively examine the type_expr to build a list of types
+  def extract_parameter_types(type_expr)
+    # No type
+    if type_expr.nil?
+      []
+    # Multiple types to extract (ex. Variant[TargetSpec, String])
+    elsif defined?(type_expr.keys)
+      type_expr.keys.flat_map { |param| extract_parameter_types(param) }
+    # Store cased value
+    elsif defined?(type_expr.cased_value)
+      [type_expr.cased_value]
+    # Type alias, able to resolve alias
+    elsif defined?(type_expr.resolved_type.name)
+      [type_expr.resolved_type.name]
+    # Nested type alias, recurse
+    elsif defined?(type_expr.type)
+      extract_parameter_types(type_expr.type)
+    # Array conatins alias types
+    elsif defined?(type_expr.types)
+      type_expr.types.flat_map { |param| extract_parameter_types(param) }
+    # Each element can be handled by a resolver above
+    elsif defined?(type_expr.element_type)
+      extract_parameter_types(type_expr.element_type)
+    end
+  end
 end

data/bolt-modules/boltlib/lib/puppet/functions/set_config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Set configuration options on a target
+#
+# **NOTE:** Not available in apply block
+# **NOTE:** Only compatible with inventory v2
+Puppet::Functions.create_function(:set_config) do
+  # @param target The Target object to configure. See {get_targets}.
+  # @param key_or_key_path The configuration setting to update.
+  # @param value The configuration value
+  # @return The Target with the updated config
+  # @example Set the transport for a target
+  #   set_config($target, 'transport', 'ssh')
+  # @example Set the ssh password
+  #   set_config($target, ['ssh', 'password'], 'secret')
+  # @example Overwrite ssh config
+  #   set_config($target, 'ssh', { user => 'me', password => 'secret' })
+  dispatch :set_config do
+    param 'Target', :target
+    param 'Variant[String, Array[String]]', :key_or_key_path
+    param 'Any', :value
+    return_type 'Target'
+  end
+
+  def set_config(target, key_or_key_path, value = true)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_config')
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call(self.class.name)
+
+    unless inventory.version > 1
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::UNSUPPORTED_INVENTORY_VERSION, action: 'set_config')
+    end
+
+    inventory.set_config(target, key_or_key_path, value)
+
+    target
+  end
+end

data/bolt-modules/boltlib/lib/puppet/functions/set_feature.rb

@@ -22,6 +22,7 @@ Puppet::Functions.create_function(:set_feature) do
     param 'Target', :target
     param 'String', :feature
     optional_param 'Boolean', :value
+    return_type 'Target'
   end
 
   def set_feature(target, feature, value = true)

data/bolt-modules/boltlib/lib/puppet/functions/set_var.rb

@@ -9,13 +9,14 @@ Puppet::Functions.create_function(:set_var) do
   # @param target The Target object to set the variable for. See {get_targets}.
   # @param key The key for the variable.
   # @param value The value of the variable.
-  # @return [Undef]
+  # @return The target with the updated feature
   # @example Set a variable on a target
   #   $target.set_var('ephemeral', true)
   dispatch :set_var do
     param 'Target', :target
     param 'String', :key
     param 'Data', :value
+    return_type 'Target'
   end
 
   def set_var(target, key, value)
@@ -28,6 +29,9 @@ Puppet::Functions.create_function(:set_var) do
     executor = Puppet.lookup(:bolt_executor)
     executor.report_function_call(self.class.name)
 
-    inventory.set_var(target, key, value)
+    var_hash = { key => value }
+    inventory.set_var(target, var_hash)
+
+    target
   end
 end

data/lib/bolt/analytics.rb

@@ -107,7 +107,7 @@ module Bolt
       end
 
       def report_bundled_content(mode, name)
-        if bundled_content[mode.split.first]&.include?(name)
+        if bundled_content[mode.split(' ').first]&.include?(name)
           event('Bundled Content', mode, label: name)
         end
       end

data/lib/bolt/apply_result.rb

@@ -46,6 +46,25 @@ module Bolt
       end
     end
 
+    def self.invalid_report_error(result)
+      # These are the keys ApplyResult methods rely on.
+      expected_report_keys = %w[metrics resource_statuses status]
+      missing_keys = expected_report_keys.reject { |k| result.value.include?(k) }
+
+      unless missing_keys.empty?
+        if result['_output']
+          # rubocop:disable Metrics/LineLength
+          msg = "Report result contains an '_output' key. Catalog application may have printed extraneous output to stdout: #{result['_output']}"
+          # rubocop:enable Metrics/LineLength
+        else
+          msg = "Report did not contain all expected keys missing: #{missing_keys.join(' ,')}"
+        end
+
+        { 'msg' => msg,
+          'kind' => 'bolt/invalid-report' }
+      end
+    end
+
     def self.from_task_result(result)
       if (puppet_missing = puppet_missing_error(result))
         new(result.target,
@@ -53,6 +72,10 @@ module Bolt
             report: result.value.reject { |k| k == '_error' })
       elsif !result.ok?
         new(result.target, error: result.error_hash)
+      elsif (invalid_report = invalid_report_error(result))
+        new(result.target,
+            error: invalid_report,
+            report: result.value.reject { |k| %w[_error _output].include?(k) })
       elsif (resource_error = resource_error(result))
         new(result.target,
             error: resource_error,

data/lib/bolt/bolt_option_parser.rb

@@ -54,6 +54,9 @@ module Bolt
         when 'show-modules'
           { flags: OPTIONS[:global] + OPTIONS[:global_config_setters],
             banner: PUPPETFILE_SHOWMODULES_HELP }
+        when 'generate-types'
+          { flags: OPTIONS[:global] + OPTIONS[:global_config_setters],
+            banner: PUPPETFILE_GENERATETYPES_HELP }
         else
           { flags: OPTIONS[:global] + OPTIONS[:global_config_setters],
             banner: PUPPETFILE_HELP }
@@ -229,6 +232,7 @@ module Bolt
       Available actions are:
         install                          Install modules from a Puppetfile into a Boltdir
         show-modules                     List modules available to Bolt
+        generate-types                   Generate type references to register in Plans
 
       Install modules into the local Boltdir
         bolt puppetfile install
@@ -248,6 +252,18 @@ module Bolt
     PUPPETFILE_SHOWMODULES_HELP = <<~HELP
       Usage: bolt puppetfile show-modules
 
+      List modules available to Bolt
+        bolt puppetfile show-modules
+
+      Available options are:
+    HELP
+
+    PUPPETFILE_GENERATETYPES_HELP = <<~HELP
+      Usage: bolt puppetfile generate-types
+
+      Generate type references to register in Plans
+        bolt puppetfile generate-types
+
       Available options are:
     HELP
 

data/lib/bolt/boltdir.rb

@@ -6,7 +6,8 @@ module Bolt
   class Boltdir
     BOLTDIR_NAME = 'Boltdir'
 
-    attr_reader :path, :config_file, :inventory_file, :modulepath, :hiera_config, :puppetfile, :rerunfile, :type
+    attr_reader :path, :config_file, :inventory_file, :modulepath, :hiera_config,
+                :puppetfile, :rerunfile, :type, :resource_types
 
     def self.default_boltdir
       Boltdir.new(File.join('~', '.puppetlabs', 'bolt'), 'user')
@@ -37,6 +38,7 @@ module Bolt
       @hiera_config = @path + 'hiera.yaml'
       @puppetfile = @path + 'Puppetfile'
       @rerunfile = @path + '.rerun.json'
+      @resource_types = @path + '.resource_types'
       @type = type
     end
 

data/lib/bolt/cli.rb

@@ -33,7 +33,7 @@ module Bolt
                  'task' => %w[show run],
                  'plan' => %w[show run convert],
                  'file' => %w[upload],
-                 'puppetfile' => %w[install show-modules],
+                 'puppetfile' => %w[install show-modules generate-types],
                  'secret' => %w[encrypt decrypt createkeys],
                  'inventory' => %w[show],
                  'apply' => %w[] }.freeze
@@ -76,7 +76,6 @@ module Bolt
 
     def parse
       parser = BoltOptionParser.new(options)
-
       # This part aims to handle both `bolt <mode> --help` and `bolt help <mode>`.
       remaining = handle_parser_errors { parser.permute(@argv) } unless @argv.empty?
       if @argv.empty? || help?(remaining)
@@ -320,7 +319,11 @@ module Bolt
       when 'plan'
         code = run_plan(options[:object], options[:task_options], options[:target_args], options)
       when 'puppetfile'
-        code = install_puppetfile(@config.puppetfile_config, @config.puppetfile, @config.modulepath)
+        if options[:action] == 'generate-types'
+          code = generate_types
+        elsif options[:action] == 'install'
+          code = install_puppetfile(@config.puppetfile_config, @config.puppetfile, @config.modulepath)
+        end
       when 'secret'
         code = Bolt::Secret.execute(plugins, outputter, options)
       when 'apply'
@@ -474,6 +477,12 @@ module Bolt
       outputter.print_module_list(pal.list_modules)
     end
 
+    def generate_types
+      # generate_types will surface a nice error with helpful message if it fails
+      pal.generate_types
+      0
+    end
+
     def install_puppetfile(config, puppetfile, modulepath)
       require 'r10k/cli'
       require 'bolt/r10k_log_proxy'
@@ -495,6 +504,8 @@ module Bolt
 
         ok = install_action.call
         outputter.print_puppetfile_result(ok, puppetfile, moduledir)
+        # Automatically generate types after installing modules
+        pal.generate_types
 
         ok ? 0 : 1
       else
@@ -505,7 +516,10 @@ module Bolt
     end
 
     def pal
-      @pal ||= Bolt::PAL.new(config.modulepath, config.hiera_config, config.compile_concurrency)
+      @pal ||= Bolt::PAL.new(config.modulepath,
+                             config.hiera_config,
+                             config.boltdir.resource_types,
+                             config.compile_concurrency)
     end
 
     def convert_plan(plan)
@@ -544,9 +558,9 @@ module Bolt
       # We only need to enumerate bundled content when running a task or plan
       content = { 'Plan' => [],
                   'Task' => [],
-                  'Plugin' => %w[puppetdb pkcs7 prompt terraform task] }
+                  'Plugin' => Bolt::Plugin::BUILTIN_PLUGINS }
       if %w[plan task].include?(options[:subcommand]) && options[:action] == 'run'
-        default_content = Bolt::PAL.new([], nil)
+        default_content = Bolt::PAL.new([], nil, nil)
         content['Plan'] = default_content.list_plans.each_with_object([]) do |iter, col|
           col << iter&.first
         end

data/lib/bolt/config.rb

@@ -276,9 +276,7 @@ module Bolt
         raise Bolt::ValidationError, "Unsupported format: '#{@format}'"
       end
 
-      if @hiera_config && !(File.file?(@hiera_config) && File.readable?(@hiera_config))
-        raise Bolt::FileError, "Could not read hiera-config file #{@hiera_config}", @hiera_config
-      end
+      Bolt::Util.validate_file('hiera-config', @hiera_config) if @hiera_config
 
       unless @transport.nil? || Bolt::TRANSPORTS.include?(@transport.to_sym)
         raise UnknownTransportError, @transport

data/lib/bolt/inventory/group2.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
 require 'bolt/inventory/group'
+require 'bolt/inventory/inventory2'
 
 module Bolt
   class Inventory
     class Group2
       attr_accessor :name, :targets, :aliases, :name_or_alias, :groups,
-                    :config, :rest, :facts, :vars, :features, :plugin_hooks
+                    :config, :facts, :vars, :features, :plugin_hooks
 
       # THESE are duplicates with the old groups for now.
       # 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 + %w[alias uri]
+      TARGET_KEYS = DATA_KEYS + %w[alias uri]
       GROUP_KEYS = DATA_KEYS + %w[groups targets]
       CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
 
@@ -59,8 +60,10 @@ module Bolt
         groups = fetch_value(data, 'groups', Array)
 
         @targets = {}
+        # @target_objects = {}
         @aliases = {}
         @name_or_alias = []
+
         targets.each do |target|
           # 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
@@ -152,6 +155,7 @@ module Bolt
         unless target.is_a?(Hash)
           raise ValidationError.new("Node entry must be a Hash, not #{target.class}", @name)
         end
+
         # This check prevents plugins from returning plugins
         raise ValidationError.new("Cannot set target with plugin", @name) if target.key?('_plugin')
         target.each do |k, v|
@@ -159,56 +163,57 @@ module Bolt
           validate_config_plugin(v, k, @name)
         end
 
-        target['name'] ||= target['uri']
+        t_name = target['name'] || target['uri']
 
-        if target['name'].nil? || target['name'].empty?
+        if t_name.nil? || t_name.empty?
           raise ValidationError.new("No name or uri for target: #{target}", @name)
         end
 
-        if @targets.include?(target['name'])
+        unless t_name.ascii_only?
+          raise ValidationError.new("Target name must be ASCII characters: #{target}", @name)
+        end
+
+        if @targets.include?(t_name)
           @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
           return
         end
 
-        raise ValidationError.new("Node #{target} does not have a name", @name) unless target['name']
-        @targets[target['name']] = target
-
-        unless (unexpected_keys = target.keys - NODE_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{target['name']}"
+        unless (unexpected_keys = target.keys - TARGET_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{t_name}"
           @logger.warn(msg)
         end
 
         unless target['config'].nil? || target['config'].is_a?(Hash)
-          raise ValidationError.new("Invalid configuration for target: #{target['name']}", @name)
+          raise ValidationError.new("Invalid configuration for target: #{t_name}", @name)
         end
 
         config_keys = target['config']&.keys || []
         unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for target #{target['name']}"
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for target #{t_name}"
           @logger.warn(msg)
         end
 
         target['config'] = config_only_plugin(target['config'])
 
-        unless target.include?('alias')
-          return
-        end
-
-        aliases = target['alias']
-        aliases = [aliases] if aliases.is_a?(String)
-        unless aliases.is_a?(Array)
-          msg = "Alias entry on #{target['name']} must be a String or Array, not #{aliases.class}"
-          raise ValidationError.new(msg, @name)
-        end
+        if target.include?('alias')
+          aliases = target['alias']
+          aliases = [aliases] if aliases.is_a?(String)
+          unless aliases.is_a?(Array)
+            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
+          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)
+            if (found = @aliases[alia])
+              raise ValidationError.new(alias_conflict(alia, found, t_name), @name)
+            end
+            @aliases[alia] = t_name
           end
-          @aliases[alia] = target['name']
         end
+
+        @targets[t_name] = target
       end
 
       def lookup_targets(lookup)
@@ -307,21 +312,22 @@ module Bolt
 
         # 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|
+        @targets.each do |t_name, t_data|
           # Require targets to be parseable as a Target.
           begin
-            Target.new(n)
+            # Catch malformed URI here
+            Bolt::Inventory::Inventory2.parse_uri(t_data['uri'])
           rescue Bolt::ParseError => e
             @logger.debug(e)
-            raise ValidationError.new("Invalid target name #{n}", @name)
+            raise ValidationError.new("Invalid target uri #{t_data['uri']}", @name)
           end
 
-          raise ValidationError.new(group_target_conflict(n), @name) if used_names.include?(n)
-          if aliased.include?(n)
-            raise ValidationError.new(alias_target_conflict(n), @name)
+          raise ValidationError.new(group_target_conflict(t_name), @name) if used_names.include?(t_name)
+          if aliased.include?(t_name)
+            raise ValidationError.new(alias_target_conflict(t_name), @name)
           end
 
-          target_names << n
+          target_names << t_name
         end
 
         @aliases.each do |n, target|