bolt 1.42.0 → 1.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d70e65622c7ae119fafb6212eda5fa66e517bf190f404d00f150d98efa616ce8
-  data.tar.gz: 9fdfbbf45efc6b1a3ec4f0364dfaf2d2682de8a30c3ab17b7893db9091da3e9f
+  metadata.gz: 2c237cb6fec506c63071962c4d8cf16fafb0b196abe720c5e0af8b9d8d350f11
+  data.tar.gz: b7505bc572e3e123b265b869ed2386bbb784882365102a3b816ab1b5e5599ab1
 SHA512:
-  metadata.gz: 3ba016ff367bf902b3a512ec7a6f3c46bac6fed6a16ef207400af12a741821a5aa5baa18b38e8dbbed201d555e71f88eafb38912e4acdb3e715362bb27ec8f51
-  data.tar.gz: a37fa6e6f3a703d3d2b7b00c578884a617578800c190105bfbc6398a5febdca5475fa96737f82fd0677b22f174932bf20fb30271964a65f959ebc6cea4dfce6f
+  metadata.gz: '0178352d34985cdd7c2960a018ff4a502b813763df806e72dd21f302bf26b173eeaa54eb2b44092b340e82b682b141fca5f72ba6e11bda6475556983dcbcf0ee'
+  data.tar.gz: 4473441d248c6023b3fe87364439f6c32498b6a6ac71b61925116838ab72eab22a457e309189cac2d4a0ebd58b57e7ded0140c902dc2367c5f45d76cbba5932a

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

@@ -3,6 +3,7 @@
 Puppet::DataTypes.create_type('Target') do
   begin
     inventory = Puppet.lookup(:bolt_inventory)
+
     inventory_version = inventory.version
     if inventory_version != 1
       target_implementation_class = inventory.target_implementation_class
@@ -10,7 +11,7 @@ Puppet::DataTypes.create_type('Target') do
   rescue Puppet::Context::UndefinedBindingError
     inventory_version = 1
   end
-  load_file('bolt/target')
+  require 'bolt/target'
 
   if inventory_version == 1
     interface <<-PUPPET
@@ -33,15 +34,15 @@ Puppet::DataTypes.create_type('Target') do
       attributes => {
         uri => { type => Optional[String[1]], kind => given_or_derived },
         name => { type => Optional[String[1]] , kind => given_or_derived },
+        safe_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  },
+        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  }
+        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]],

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

@@ -12,14 +12,14 @@ Puppet::Functions.create_function(:catch_errors) do
   #         otherwise the result will be returned
   # @example Catch errors for a block
   #   catch_errors() || {
-  #     run_command("whoami", $nodes)
-  #     run_command("adduser ryan", $nodes)
+  #     run_command("whoami", $targets)
+  #     run_command("adduser ryan", $targets)
   #   }
   # @example Catch parse errors for a block of code
   #   catch_errors(['bolt/parse-error']) || {
-  #    run_plan('canary', $nodes)
+  #    run_plan('canary', $targets)
   #    run_plan('other_plan)
-  #    apply($nodes) || {
+  #    apply($targets) || {
   #      notify { "Hello": }
   #    }
   #   }

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

@@ -4,10 +4,9 @@ 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:** Calling `get_target('all')` returns an empty array.
 # **NOTE:** Only compatible with inventory v2
+# **NOTE:** Not available in apply block when `future` is true
 Puppet::Functions.create_function(:get_target) do
   # @param name A Target name.
   # @return A single target, either new or from inventory.

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

@@ -3,10 +3,9 @@
 require 'bolt/error'
 
 # Parses common ways of referring to targets and returns an array of Targets.
-#
-# **NOTE:** Calling `get_targets` inside an `apply` block with a
-# version 2 inventory creates a new Target object.
 # `get_targets('all')` returns an empty array.
+#
+# **NOTE:** Not available in apply block when `future` is true
 Puppet::Functions.create_function(:get_targets) do
   # @param names A pattern or array of patterns identifying a set of targets.
   # @return A list of unique Targets resolved from any target URIs and groups.

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

@@ -11,7 +11,7 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
   # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @return [PlanResult] The result of running the plan. Undef if plan does not explicitly return results.
   # @example Run a plan
-  #   run_plan('canary', 'command' => 'false', 'nodes' => $targets, '_catch_errors' => true)
+  #   run_plan('canary', 'command' => 'false', 'targets' => $targets, '_catch_errors' => true)
   dispatch :run_plan do
     scope_param
     param 'String', :plan_name
@@ -19,13 +19,22 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
     return_type 'Boltlib::PlanResult'
   end
 
-  # Run a plan, specifying $nodes as a positional argument.
+  # Run a plan, specifying $nodes or $targets as a positional argument.
+  #
+  # When running a plan with a $nodes parameter, the second positional argument will always specify
+  # the $nodes parameter. When running a plan with a $targets parameter and no $nodes parameter, the
+  # second positional argument specifies the $targets parameter.
+  #
+  # Deprecation Warning: Starting with Bolt 2.0, a plan with both a $nodes and $targets parameter
+  # cannot specify either parameter using the second positional argument and will result in the plan
+  # failing to run.
+  #
   # @param plan_name The plan to run.
   # @param args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
   # @return [PlanResult] The result of running the plan. Undef if plan does not explicitly return results.
   # @example Run a plan
-  #   run_plan('canary', $nodes, 'command' => 'false')
+  #   run_plan('canary', $targets, 'command' => 'false')
   dispatch :run_plan_with_targetspec do
     scope_param
     param 'String', :plan_name
@@ -35,16 +44,14 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
   end
 
   def run_plan_with_targetspec(scope, plan_name, targets, args = {})
-    unless args['nodes'].nil?
-      raise ArgumentError,
-            "A plan's 'nodes' parameter may be specified as the second positional argument to " \
-            "run_plan(), but in that case 'nodes' must not be specified in the named arguments " \
-            "hash."
-    end
-    run_plan(scope, plan_name, args.merge('nodes' => targets))
+    run_inner_plan(scope, plan_name, targets, args)
   end
 
   def run_plan(scope, plan_name, args = {})
+    run_inner_plan(scope, plan_name, nil, args)
+  end
+
+  def run_inner_plan(scope, plan_name, targets, args = {})
     unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue
         .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_plan')
@@ -87,10 +94,13 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
     # If a TargetSpec parameter is passed, ensure it is in inventory
     inventory = Puppet.lookup(:bolt_inventory)
 
+    param_types = closure.parameters.each_with_object({}) do |param, param_acc|
+      param_acc[param.name] = extract_parameter_types(param.type_expr)&.flatten
+    end
+
+    targets_to_param(targets, params, param_types, executor) if targets
+
     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
@@ -159,4 +169,54 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
       extract_parameter_types(type_expr.element_type)
     end
   end
+
+  def targets_to_param(targets, params, param_types, executor)
+    nodes_param = param_types.include?('nodes')
+    targets_param = param_types['targets']&.any? { |p| p.match?(/TargetSpec/) }
+
+    # Both a 'TargetSpec $nodes' and 'TargetSpec $targets' parameter are present in the plan
+    # 1.x behavior: Populate $nodes and warn user that this will error in 2.x
+    # 2.x behavior: Error
+    if nodes_param && targets_param
+      # rubocop:disable Style/GlobalVars
+      if $future
+        raise ArgumentError,
+              "A plan with both a $nodes and $targets parameter cannot have either parameter specified " \
+              "as the second positional argument to run_plan()."
+      else
+        msg = <<~WARNING
+              Deprecation Warning: A plan with both a $nodes and $targets parameter can only specify
+              the $nodes parameter as the second positional argument to run_plan(). Starting in
+              Bolt 2.0, a plan with both a $nodes and $targets parameter will not be able to specify
+              either parameter as the second positional argument to run_plan() and will result in the
+              plan failing.
+              WARNING
+        executor.deprecation(msg)
+      end
+      # rubocop:enable Style/GlobalVars
+    end
+
+    # Always populate a $nodes parameter over $targets
+    if nodes_param
+      if params['nodes']
+        raise ArgumentError,
+              "A plan's 'nodes' parameter may be specified as the second positional argument to " \
+              "run_plan(), but in that case 'nodes' must not be specified in the named arguments " \
+              "hash."
+      end
+      params['nodes'] = targets
+    # If there is only a $targets parameter, then populate it
+    elsif targets_param
+      if params['targets']
+        raise ArgumentError,
+              "A plan's 'targets' parameter may be specified as the second positional argument to " \
+              "run_plan(), but in that case 'targets' must not be specified in the named arguments " \
+              "hash."
+      end
+      params['targets'] = targets
+    # If a plan has neither parameter, just fall back to $nodes
+    else
+      params['nodes'] = targets
+    end
+  end
 end

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

@@ -13,8 +13,8 @@ Puppet::Functions.create_function(:without_default_logging) do
   # @example Suppress default logging for a series of functions
   #   without_default_logging() || {
   #     notice("Deploying on ${nodes}")
-  #     get_targets($nodes).each |$node| {
-  #       run_task(deploy, $node)
+  #     get_targets($targets).each |$target| {
+  #       run_task(deploy, $target)
   #     }
   #   }
   dispatch :without_default_logging do

data/lib/bolt/applicator.rb

@@ -8,6 +8,7 @@ require 'open3'
 require 'bolt/error'
 require 'bolt/task'
 require 'bolt/apply_result'
+require 'bolt/apply_target'
 require 'bolt/util/puppet_log_level'
 
 module Bolt
@@ -129,6 +130,49 @@ module Bolt
       JSON.parse(out)
     end
 
+    def future_compile(target, catalog_input)
+      trusted = Puppet::Context::TrustedInformation.new('local', target.name, {})
+      catalog_input[:target] = {
+        name: target.name,
+        facts: @inventory.facts(target).merge('bolt' => true),
+        variables: @inventory.vars(target),
+        trusted: trusted.to_h
+      }
+      # rubocop:disable Style/GlobalVars
+      catalog_input[:future] = $future
+      # rubocop:enable Style/GlobalVars
+
+      bolt_catalog_exe = File.join(libexec, 'bolt_catalog')
+      old_path = ENV['PATH']
+      ENV['PATH'] = "#{RbConfig::CONFIG['bindir']}#{File::PATH_SEPARATOR}#{old_path}"
+      out, err, stat = Open3.capture3('ruby', bolt_catalog_exe, 'compile', stdin_data: catalog_input.to_json)
+      ENV['PATH'] = old_path
+
+      # stderr may contain formatted logs from Puppet's logger or other errors.
+      # Print them in order, but handle them separately. Anything not a formatted log is assumed
+      # to be an error message.
+      logs = err.lines.map do |l|
+        begin
+          JSON.parse(l)
+        rescue StandardError
+          l
+        end
+      end
+      logs.each do |log|
+        if log.is_a?(String)
+          @logger.error(log.chomp)
+        else
+          log.map { |k, v| [k.to_sym, v] }.each do |level, msg|
+            bolt_level = Bolt::Util::PuppetLogLevel::MAPPING[level]
+            @logger.send(bolt_level, "#{target.name}: #{msg.chomp}")
+          end
+        end
+      end
+
+      raise(ApplyError, target.name) unless stat.success?
+      JSON.parse(out)
+    end
+
     def validate_hiera_config(hiera_config)
       if File.exist?(File.path(hiera_config))
         data = File.open(File.path(hiera_config), "r:UTF-8") { |f| YAML.safe_load(f.read, [Symbol]) }
@@ -155,7 +199,6 @@ module Bolt
         options = args[1].map { |k, v| [k.sub(/^_/, '').to_sym, v] }.to_h
       end
 
-      # collect plan vars and merge them over target vars
       plan_vars = scope.to_hash(true, true)
       %w[trusted server_facts facts].each { |k| plan_vars.delete(k) }
 
@@ -179,11 +222,33 @@ module Bolt
     def apply_ast(raw_ast, targets, options, plan_vars = {})
       ast = Puppet::Pops::Serialization::ToDataConverter.convert(raw_ast, rich_data: true, symbol_to_string: true)
 
+      # rubocop:disable Style/GlobalVars
+      if $future
+        # Serialize as pcore for *Result* objects
+        plan_vars = Puppet::Pops::Serialization::ToDataConverter.convert(plan_vars,
+                                                                         rich_data: true,
+                                                                         symbol_as_string: true,
+                                                                         type_by_reference: true,
+                                                                         local_reference: false)
+        scope = {
+          code_ast: ast,
+          modulepath: @modulepath,
+          pdb_config: @pdb_client.config.to_hash,
+          hiera_config: @hiera_config,
+          plan_vars: plan_vars,
+          # This data isn't available on the target config hash
+          config: @inventory.config.transport_data_get
+        }
+      end
+      # rubocop:enable Style/GlobalVars
+
       r = @executor.log_action('apply catalog', targets) do
         futures = targets.map do |target|
           Concurrent::Future.execute(executor: @pool) do
             @executor.with_node_logging("Compiling manifest block", [target]) do
-              compile(target, ast, plan_vars)
+              # rubocop:disable Style/GlobalVars
+              $future ? future_compile(target, scope) : compile(target, ast, plan_vars)
+              # rubocop:enable Style/GlobalVars
             end
           end
         end

data/lib/bolt/apply_inventory.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'bolt/boltdir'
+require 'bolt/config'
+require 'bolt/error'
+
+module Bolt
+  class ApplyInventory
+    class InvalidFunctionCall < Bolt::Error
+      def initialize(function)
+        super("The function '#{function}' is not callable within an apply block",
+              'bolt.inventory/invalid-function-call')
+      end
+    end
+
+    attr_reader :config_hash
+
+    def initialize(config_hash = {})
+      @config_hash = config_hash
+      @targets = {}
+    end
+
+    def create_apply_target(target)
+      @targets[target.name] = target
+    end
+
+    def validate
+      @groups.validate
+    end
+
+    def version
+      2
+    end
+
+    def target_implementation_class
+      Bolt::ApplyTarget
+    end
+
+    def get_targets(*_params)
+      raise InvalidFunctionCall, 'get_targets'
+    end
+
+    def get_target(*_params)
+      raise InvalidFunctionCall, 'get_target'
+    end
+
+    # rubocop:disable Naming/AccessorMethodName
+    def set_var(*_params)
+      raise InvalidFunctionCall, 'set_var'
+    end
+
+    def set_feature(*_params)
+      raise InvalidFunctionCall, 'set_feature'
+    end
+    # rubocop:enable Naming/AccessorMethodName
+
+    def vars(target)
+      @targets[target.name].vars
+    end
+
+    def add_facts(*_params)
+      raise InvalidFunctionCall, 'add_facts'
+    end
+
+    def facts(target)
+      @targets[target.name].facts
+    end
+
+    def features(target)
+      @targets[target.name].features
+    end
+
+    def add_to_group(*_params)
+      raise InvalidFunctionCall, 'add_to_group'
+    end
+
+    def plugin_hooks(target)
+      @targets[target.name].plugin_hooks
+    end
+
+    def set_config(_target, _key_or_key_path, _value)
+      raise InvalidFunctionCall, 'set_config'
+    end
+
+    def target_config(target)
+      @targets[target.name].config
+    end
+  end
+end

data/lib/bolt/apply_result.rb

@@ -85,6 +85,13 @@ module Bolt
       end
     end
 
+    # Other pcore methods are inherited from Result
+    def _pcore_init_hash
+      { 'target' => @target,
+        'error' => value['_error'],
+        'report' => value['report'] }
+    end
+
     def initialize(target, error: nil, report: nil)
       @target = target
       @value = {}

data/lib/bolt/apply_target.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Bolt
+  class ApplyTarget
+    ATTRIBUTES = %i[uri name target_alias config vars facts features
+                    plugin_hooks safe_name].freeze
+    COMPUTED = %i[host password port protocol user].freeze
+
+    attr_reader(*ATTRIBUTES)
+    attr_accessor(*COMPUTED)
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # Target.new from a plan initialized with a hash
+    def self.from_asserted_hash(hash)
+      raise Bolt::Error.new("Target objects cannot be instantiated inside apply blocks", 'bolt/apply-error')
+    end
+
+    # Target.new from a plan with just a uri.
+    def self.from_asserted_args(uri = nil,
+                                name = nil,
+                                safe_name = nil,
+                                target_alias = nil,
+                                config = nil,
+                                facts = nil,
+                                vars = nil,
+                                features = nil,
+                                plugin_hooks = nil)
+      raise Bolt::Error.new("Target objects cannot be instantiated inside apply blocks", 'bolt/apply-error')
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    def self._pcore_init_from_hash
+      raise "ApplyTarget shouldn't be instantiated from a pcore_init class method. How did this get called?"
+    end
+
+    def _pcore_init_from_hash(init_hash)
+      inventory = Puppet.lookup(:bolt_inventory)
+      initialize(init_hash, inventory.config_hash)
+      inventory.create_apply_target(self)
+      self
+    end
+
+    def initialize(target_hash, config)
+      ATTRIBUTES.each do |attr|
+        instance_variable_set("@#{attr}", target_hash[attr.to_s])
+      end
+
+      # Merge the config hash with inventory config
+      config = Bolt::Util.deep_merge(config, @config)
+      transport = config['transport'] || 'ssh'
+      t_conf = config['transports'][transport] || {}
+      uri_obj = parse_uri(uri)
+      @host = uri_obj.hostname || t_conf['host']
+      @password = Addressable::URI.unencode_component(uri_obj.password) || t_conf['password']
+      @port = uri_obj.port || t_conf['port']
+      @protocol = uri_obj.scheme || transport
+      @user = Addressable::URI.unencode_component(uri_obj.user) || t_conf['user']
+    end
+
+    def parse_uri(string)
+      require 'addressable/uri'
+      if string.nil?
+        Addressable::URI.new
+        # Forbid empty uri
+      elsif string.empty?
+        raise Bolt::ParseError, "Could not parse target URI: URI is empty string"
+      elsif string =~ %r{^[^:]+://}
+        Addressable::URI.parse(string)
+      else
+        # Initialize with an empty scheme to ensure we parse the hostname correctly
+        Addressable::URI.parse("//#{string}")
+      end
+    rescue Addressable::URI::InvalidURIError => e
+      raise Bolt::ParseError, "Could not parse target URI: #{e.message}"
+    end
+  end
+end

data/lib/bolt/bolt_option_parser.rb

@@ -8,7 +8,7 @@ module Bolt
   class BoltOptionParser < OptionParser
     OPTIONS = { inventory: %w[nodes targets query rerun description],
                 authentication: %w[user password password-prompt private-key host-key-check ssl ssl-verify],
-                escalation: %w[run-as sudo-password sudo-password-prompt],
+                escalation: %w[run-as sudo-password sudo-password-prompt sudo-executable],
                 run_context: %w[concurrency inventoryfile save-rerun],
                 global_config_setters: %w[modulepath boltdir configfile],
                 transports: %w[transport connect-timeout tty],
@@ -703,6 +703,10 @@ module Bolt
         @options[:'sudo-password'] = STDIN.noecho(&:gets).chomp
         STDERR.puts
       end
+      define('--sudo-executable EXEC', "Specify an executable for running as another user.",
+             "This option is experimental.") do |exec|
+        @options[:'sudo-executable'] = exec
+      end
 
       separator "\nRUN CONTEXT OPTIONS"
       define('-c', '--concurrency CONCURRENCY', Integer,

data/lib/bolt/catalog.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'bolt/apply_target'
 require 'bolt/config'
+require 'bolt/error'
 require 'bolt/inventory'
+require 'bolt/apply_inventory'
 require 'bolt/pal'
 require 'bolt/puppetdb'
 require 'bolt/util'
@@ -65,17 +68,29 @@ module Bolt
       target = request['target']
       pdb_client = Bolt::PuppetDB::Client.new(Bolt::PuppetDB::Config.new(request['pdb_config']))
       options = request['puppet_config'] || {}
+
       with_puppet_settings(request['hiera_config']) do
         Puppet[:rich_data] = true
         Puppet[:node_name_value] = target['name']
-        Puppet::Pal.in_tmp_environment('bolt_catalog',
-                                       modulepath: request["modulepath"] || [],
-                                       facts: target["facts"] || {},
-                                       variables: target["variables"] || {}) do |pal|
+        env_conf = { modulepath: request['modulepath'] || [],
+                     facts: target['facts'] || {} }
+        env_conf[:variables] = request['future'] ? {} : target['variables']
+        Puppet::Pal.in_tmp_environment('bolt_catalog', env_conf) do |pal|
+          inv = if request['future']
+                  Bolt::ApplyInventory.new(request['config'])
+                else
+                  setup_inventory(request['inventory'])
+                end
           Puppet.override(bolt_pdb_client: pdb_client,
-                          bolt_inventory: setup_inventory(request['inventory'])) do
+                          bolt_inventory: inv) do
             Puppet.lookup(:pal_current_node).trusted_data = target['trusted']
             pal.with_catalog_compiler do |compiler|
+              if request['future']
+                # This needs to happen inside the catalog compiler so loaders are initialized for loading
+                vars = Puppet::Pops::Serialization::FromDataConverter.convert(request['plan_vars'])
+                pal.send(:add_variables, compiler.send(:topscope), vars.merge(target['variables']))
+              end
+
               # Configure language strictness in the CatalogCompiler. We want Bolt to be able
               # to compile most Puppet 4+ manifests, so we default to allowing deprecated functions.
               Puppet[:strict] = options['strict'] || :warning

data/lib/bolt/config.rb

@@ -36,7 +36,7 @@ module Bolt
                   :puppetfile_config, :plugins, :plugin_hooks, :future
     attr_writer :modulepath
 
-    TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions
+    TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions sudo-executable
                            private-key tty tmpdir user connect-timeout disconnect-timeout
                            cacert token-file service-url interpreters file-protocol smb-port realm].freeze
 

data/lib/bolt/error.rb

@@ -61,7 +61,8 @@ module Bolt
         'result_set' => result_set
       }
       object_msg = " '#{object}'" if object
-      message = "Plan aborted: #{action}#{object_msg} failed on #{result_set.error_set.length} nodes"
+      message = "Plan aborted: #{action}#{object_msg} failed on #{result_set.error_set.length} target"
+      message += "s" unless result_set.error_set.length == 1
       super(message, 'bolt/run-failure', details)
       @result_set = result_set
       @error_code = 2

data/lib/bolt/executor.rb

@@ -338,5 +338,9 @@ module Bolt
     ensure
       publish_event(type: :enable_default_output)
     end
+
+    def deprecation(msg)
+      @logger.warn msg
+    end
   end
 end

data/lib/bolt/outputter/human.rb

@@ -167,7 +167,7 @@ module Bolt
       def print_summary(results, elapsed_time = nil)
         ok_set = results.ok_set
         unless ok_set.empty?
-          @stream.puts format('Successful on %<size>d node%<plural>s: %<names>s',
+          @stream.puts format('Successful on %<size>d target%<plural>s: %<names>s',
                               size: ok_set.size,
                               plural: ok_set.size == 1 ? '' : 's',
                               names: ok_set.targets.map(&:safe_name).join(','))
@@ -176,13 +176,13 @@ module Bolt
         error_set = results.error_set
         unless error_set.empty?
           @stream.puts colorize(:red,
-                                format('Failed on %<size>d node%<plural>s: %<names>s',
+                                format('Failed on %<size>d target%<plural>s: %<names>s',
                                        size: error_set.size,
                                        plural: error_set.size == 1 ? '' : 's',
                                        names: error_set.targets.map(&:safe_name).join(',')))
         end
 
-        total_msg = format('Ran on %<size>d node%<plural>s',
+        total_msg = format('Ran on %<size>d target%<plural>s',
                            size: results.size,
                            plural: results.size == 1 ? '' : 's')
         total_msg << " in #{duration_to_string(elapsed_time)}" unless elapsed_time.nil?

data/lib/bolt/outputter/json.rb

@@ -36,9 +36,17 @@ module Bolt
         @stream.puts "],\n"
         @preceding_item = false
         @items_open = false
-        @stream.puts format('"node_count": %<size>d, "elapsed_time": %<elapsed>d }',
-                            size: results.size,
-                            elapsed: elapsed_time)
+        # rubocop:disable Style/GlobalVars
+        if $future
+          @stream.puts format('"target_count": %<size>d, "elapsed_time": %<elapsed>d }',
+                              size: results.size,
+                              elapsed: elapsed_time)
+        else
+          @stream.puts format('"node_count": %<size>d, "elapsed_time": %<elapsed>d }',
+                              size: results.size,
+                              elapsed: elapsed_time)
+        end
+        # rubocop:enable Style/GlobalVars
       end
 
       def print_table(results)

data/lib/bolt/result.rb

@@ -72,6 +72,24 @@ module Bolt
       new(target, value: value)
     end
 
+    def self._pcore_init_from_hash
+      raise "Result shouldn't be instantiated from a pcore_init class method. How did this get called?"
+    end
+
+    def _pcore_init_from_hash(init_hash)
+      opts = init_hash.reject { |k, _v| k == 'target' }
+      initialize(init_hash['target'], opts.map { |k, v| [k.to_sym, v] }.to_h)
+    end
+
+    def _pcore_init_hash
+      { 'target' => @target,
+        'error' => @value['_error'],
+        'message' => @value['_output'],
+        'value' => @value,
+        'action' => @action,
+        'object' => @object }
+    end
+
     def initialize(target, error: nil, message: nil, value: nil, action: nil, object: nil)
       @target = target
       @value = value || {}

data/lib/bolt/result_set.rb

@@ -12,6 +12,18 @@ module Bolt
       include(Puppet::Pops::Types::IteratorProducer)
     end
 
+    def self._pcore_init_from_hash
+      raise "ResultSet shouldn't be instantiated from a pcore_init class method. How did this get called?"
+    end
+
+    def _pcore_init_from_hash(init_hash)
+      initialize(init_hash['results'])
+    end
+
+    def _pcore_init_hash
+      { 'results' => @results }
+    end
+
     def iterator
       if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops) &&
          self.class.included_modules.include?(Puppet::Pops::Types::Iterable)

data/lib/bolt/target.rb

@@ -20,6 +20,7 @@ module Bolt
     # rubocop:disable Lint/UnusedMethodArgument
     def self.from_asserted_args(uri = nil,
                                 name = nil,
+                                safe_name = nil,
                                 target_alias = nil,
                                 config = nil,
                                 facts = nil,

data/lib/bolt/transport/local.rb

@@ -4,7 +4,7 @@ module Bolt
   module Transport
     class Local < Sudoable
       def self.options
-        %w[tmpdir interpreters sudo-password run-as run-as-command]
+        %w[tmpdir interpreters sudo-password run-as run-as-command sudo-executable]
       end
 
       def provided_features

data/lib/bolt/transport/local/shell.rb

@@ -126,7 +126,8 @@ module Bolt
 
           if escalate
             if use_sudo
-              sudo_flags = ["sudo", "-k", "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
+              sudo_exec = target.options['sudo-executable'] || "sudo"
+              sudo_flags = [sudo_exec, "-k", "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
               sudo_flags += ["-E"] if options[:environment]
               sudo_str = Shellwords.shelljoin(sudo_flags)
             else

data/lib/bolt/transport/ssh.rb

@@ -9,8 +9,8 @@ module Bolt
   module Transport
     class SSH < Sudoable
       def self.options
-        %w[host port user password sudo-password private-key host-key-check
-           connect-timeout disconnect-timeout tmpdir run-as tty run-as-command proxyjump interpreters]
+        %w[host port user password sudo-password private-key host-key-check sudo-executable
+           connect-timeout disconnect-timeout tmpdir script-dir run-as tty run-as-command proxyjump interpreters]
       end
 
       def self.default_options
@@ -48,6 +48,12 @@ module Bolt
             raise Bolt::ValidationError, error_msg
           end
         end
+
+        if (dir_opt = options['script-dir'])
+          unless dir_opt.is_a?(String) && !dir_opt.empty?
+            raise Bolt::ValidationError, "script-dir option must be a non-empty string"
+          end
+        end
       end
 
       def initialize

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

@@ -194,10 +194,10 @@ module Bolt
           use_sudo = escalate && @target.options['run-as-command'].nil?
 
           command_str = inject_interpreter(options[:interpreter], command)
-
           if escalate
             if use_sudo
-              sudo_flags = ["sudo", "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
+              sudo_exec = target.options['sudo-executable'] || "sudo"
+              sudo_flags = [sudo_exec, "-S", "-u", run_as, "-p", Sudoable.sudo_prompt]
               sudo_flags += ["-E"] if options[:environment]
               sudo_str = Shellwords.shelljoin(sudo_flags)
             else

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

@@ -7,6 +7,7 @@ module Bolt
     class Sudoable < Base
       class Connection
         attr_accessor :target
+
         def initialize(target)
           @target = target
           @run_as = nil
@@ -38,7 +39,8 @@ module Bolt
 
         def make_tempdir
           tmpdir = @target.options.fetch('tmpdir', '/tmp')
-          tmppath = "#{tmpdir}/#{SecureRandom.uuid}"
+          script_dir = @target.options.fetch('script-dir', SecureRandom.uuid)
+          tmppath = File.join(tmpdir, script_dir)
           command = ['mkdir', '-m', 700, tmppath]
 
           result = execute(command)

data/lib/bolt/version.rb

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

data/modules/aggregate/lib/puppet/functions/aggregate/count.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Aggregates the key/value pairs in the results of a ResultSet into a hash
-# mapping the keys to a hash of each distinct value and how many nodes returned
+# mapping the keys to a hash of each distinct value and how many targets returned
 # that value for the key.
 Puppet::Functions.create_function(:'aggregate::count') do
   dispatch :aggregate_count do

data/modules/aggregate/lib/puppet/functions/aggregate/nodes.rb

@@ -19,3 +19,4 @@ Puppet::Functions.create_function(:'aggregate::nodes') do
     end
   end
 end
+

data/modules/aggregate/lib/puppet/functions/aggregate/targets.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Aggregates the key/value pairs in the results of a ResultSet into a hash
+# mapping the keys to a hash of each distinct value and the list of targets
+# returning that value for the key.
+Puppet::Functions.create_function(:'aggregate::targets') do
+  dispatch :aggregate_targets do
+    param 'ResultSet', :resultset
+  end
+
+  def aggregate_targets(resultset)
+    resultset.each_with_object({}) do |result, agg|
+      result.value.each do |key, val|
+        agg[key] ||= {}
+        agg[key][val.to_s] ||= []
+        agg[key][val.to_s] << result.target.name
+      end
+      agg
+    end
+  end
+end

data/modules/aggregate/plans/count.pp

@@ -2,7 +2,7 @@ plan aggregate::count(
   Optional[String[0]] $task = undef,
   Optional[String[0]] $command = undef,
   Optional[String[0]] $script = undef,
-  TargetSpec $nodes,
+  TargetSpec $targets,
   Hash[String, Data] $params = {}
 ) {
 
@@ -24,11 +24,11 @@ plan aggregate::count(
   }
 
   $res = if ($task) {
-    run_task($task, $nodes, $params)
+    run_task($task, $targets, $params)
   } elsif ($command) {
-    run_command($command, $nodes, $params)
+    run_command($command, $targets, $params)
   } elsif ($script) {
-    run_script($script, $nodes, $params)
+    run_script($script, $targets, $params)
   }
 
   return aggregate::count($res)

data/modules/aggregate/plans/nodes.pp

@@ -33,3 +33,4 @@ plan aggregate::nodes(
 
   return aggregate::nodes($res)
 }
+

data/modules/aggregate/plans/targets.pp

@@ -0,0 +1,35 @@
+plan aggregate::targets(
+  Optional[String[0]] $task = undef,
+  Optional[String[0]] $command = undef,
+  Optional[String[0]] $script = undef,
+  TargetSpec $targets,
+  Hash[String, Data] $params = {}
+) {
+
+  # Validation
+  $type_count = [$task, $command, $script].reduce(0) |$acc, $v| {
+    if ($v) {
+      $acc + 1
+    } else {
+      $acc
+    }
+  }
+
+  if ($type_count == 0) {
+    fail_plan("Must specify a command, script, or task to run", 'aggregate/invalid-params')
+  }
+
+  if ($type_count > 1) {
+    fail_plan("Must specify only one command, script, or task to run", 'aggregate/invalid-params')
+  }
+
+  $res = if ($task) {
+    run_task($task, $targets, $params)
+  } elsif ($command) {
+    run_command($command, $targets, $params)
+  } elsif ($script) {
+    run_script($script, $targets, $params)
+  }
+
+  return aggregate::targets($res)
+}

data/modules/canary/lib/puppet/functions/canary/skip.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-# Returns a ResultSet with canary/skipped-node errors for each Target provided.
+# Returns a ResultSet with canary/skipped-target errors for each Target provided.
 #
 # This function takes a single parameter:
-# * List of nodes (Array[Variant[Target,String]])
+# * List of targets (Array[Variant[Target,String]])
 #
 # Returns a ResultSet.
 Puppet::Functions.create_function(:'canary::skip') do
   dispatch :skip_result do
-    param 'Array[Variant[Target,String]]', :nodes
+    param 'Array[Variant[Target,String]]', :targets
   end
 
-  def skip_result(nodes)
-    results = nodes.map do |node|
-      node = Bolt::Target.new(node) unless node.is_a? Bolt::Target
-      Bolt::Result.new(node, value: { '_error' => {
-                         'msg' => "Skipped #{node.name} because of a previous failure",
-                         'kind' => 'canary/skipped-node',
+  def skip_result(targets)
+    results = targets.map do |target|
+      target = Bolt::Target.new(target) unless target.is_a? Bolt::Target
+      Bolt::Result.new(target, value: { '_error' => {
+                         'msg' => "Skipped #{target.name} because of a previous failure",
+                         'kind' => 'canary/skipped-target',
                          'details' => {}
                        } })
     end

data/modules/canary/plans/init.pp

@@ -1,11 +1,11 @@
 # @summary
-#   Run a task, command or script on canary nodes before running it on all nodes.
+#   Run a task, command or script on canary targets before running it on all targets.
 #
-# This plan accepts a action and a $nodes parameter. The action can be the name
+# This plan accepts a action and a $targets parameter. The action can be the name
 # of a task, a script or a command to run. It will run the action on a canary
-# group of nodes and only continue to the rest of the nodes if it succeeds on
-# all canaries. This returns a ResultSet object with a Result for every node.
-# Any skipped nodes will have a 'canary/skipped-node' error kind.
+# group of targets and only continue to the rest of the targets if it succeeds on
+# all canaries. This returns a ResultSet object with a Result for every target.
+# Any skipped targets will have a 'canary/skipped-target' error kind.
 #
 # @param task
 #  The name of the task to run. Mutually exclusive with command and script.
@@ -13,7 +13,7 @@
 #   The command to run. Mutually exclusive with task and script.
 # @param script
 #   The script to run. Mutually exclusive with task and command.
-# @param nodes
+# @param targets
 #   The target to run on.
 # @param params
 #   The parameters to use for the task.
@@ -23,13 +23,13 @@
 # @return ResultSet a merged resultset from running the action on all targets
 #
 # @example Run a command
-#   run_plan(canary, command => 'whoami', nodes => $mynodes)
+#   run_plan(canary, command => 'whoami', targets => $mytargets)
 #
 plan canary(
   Optional[String[0]] $task = undef,
   Optional[String[0]] $command = undef,
   Optional[String[0]] $script = undef,
-  TargetSpec $nodes,
+  TargetSpec $targets,
   Hash[String, Data] $params = {},
   Integer $canary_size = 1
 ) {
@@ -51,7 +51,7 @@ plan canary(
     fail_plan("Must specify only one command, script, or task to run", 'canary/invalid-params')
   }
 
-  [$canaries, $rest] = canary::random_split(get_targets($nodes), $canary_size)
+  [$canaries, $rest] = canary::random_split(get_targets($targets), $canary_size)
   $catch_params = $params + { '_catch_errors' => true }
 
   if ($task) {

data/modules/puppetdb_fact/plans/init.pp

@@ -1,8 +1,8 @@
-plan puppetdb_fact(TargetSpec $nodes) {
-  $targets = get_targets($nodes)
-  $certnames = $targets.map |$target| { $target.host }
+plan puppetdb_fact(TargetSpec $targets) {
+  $targs = get_targets($targets)
+  $certnames = $targs.map |$target| { $target.host }
   $pdb_facts = puppetdb_fact($certnames)
-  $targets.each |$target| {
+  $targs.each |$target| {
     add_facts($target, $pdb_facts[$target.host])
   }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.42.0
+  version: 1.43.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2019-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -377,7 +377,9 @@ files:
 - lib/bolt.rb
 - lib/bolt/analytics.rb
 - lib/bolt/applicator.rb
+- lib/bolt/apply_inventory.rb
 - lib/bolt/apply_result.rb
+- lib/bolt/apply_target.rb
 - lib/bolt/bolt_option_parser.rb
 - lib/bolt/boltdir.rb
 - lib/bolt/catalog.rb
@@ -495,8 +497,10 @@ files:
 - libexec/query_resources.rb
 - modules/aggregate/lib/puppet/functions/aggregate/count.rb
 - modules/aggregate/lib/puppet/functions/aggregate/nodes.rb
+- modules/aggregate/lib/puppet/functions/aggregate/targets.rb
 - modules/aggregate/plans/count.pp
 - modules/aggregate/plans/nodes.pp
+- modules/aggregate/plans/targets.pp
 - modules/canary/lib/puppet/functions/canary/merge.rb
 - modules/canary/lib/puppet/functions/canary/random_split.rb
 - modules/canary/lib/puppet/functions/canary/skip.rb
@@ -521,7 +525,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Execute commands remotely over SSH and WinRM