openbolt 5.0.0.rc1

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+require 'bolt/pal'
+require 'bolt/task'
+
+# Runs a given instance of a `Task` on the given set of targets and returns the result from each.
+# This function does nothing if the list of targets is empty.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:run_task) do
+  # Run a task.
+  # @param task_name The task to run.
+  # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param args A hash of arguments to the task. Can also include additional options.
+  # @option args [Boolean] _catch_errors Whether to catch raised errors.
+  # @option args [String] _run_as User to run as using privilege escalation.
+  # @option args [Boolean] _noop Run the task in noop mode if available.
+  # @return A list of results, one entry per target.
+  # @example Run a task as root
+  #   run_task('facts', $targets, '_run_as' => 'root')
+  dispatch :run_task do
+    param 'String[1]', :task_name
+    param 'Boltlib::TargetSpec', :targets
+    optional_param 'Hash[String[1], Any]', :args
+    return_type 'ResultSet'
+  end
+
+  # Run a task, logging the provided description.
+  # @param task_name The task to run.
+  # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param description A description to be output when calling this function.
+  # @param args A hash of arguments to the task. Can also include additional options.
+  # @option args [Boolean] _catch_errors Whether to catch raised errors.
+  # @option args [String] _run_as User to run as using privilege escalation.
+  # @option args [Boolean] _noop Run the task in noop mode if available.
+  # @return A list of results, one entry per target.
+  # @example Run a task
+  #   run_task('facts', $targets, 'Gather OS facts')
+  dispatch :run_task_with_description do
+    param 'String[1]', :task_name
+    param 'Boltlib::TargetSpec', :targets
+    param 'Optional[String]', :description
+    optional_param 'Hash[String[1], Any]', :args
+    return_type 'ResultSet'
+  end
+
+  def run_task(task_name, targets, args = {})
+    run_task_with_description(task_name, targets, nil, args)
+  end
+
+  def run_task_with_description(task_name, targets, description, args = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_task')
+    end
+
+    options, params = args.partition { |k, _v| k.start_with?('_') }.map(&:to_h)
+    options = options.transform_keys { |k| k.sub(/^_/, '').to_sym }
+    options[:description] = description if description
+
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
+
+    # Bolt calls this function internally to trigger tasks from the CLI. We
+    # don't want to count those invocations.
+    unless options[:bolt_api_call]
+      # Send Analytics Report
+      executor.report_function_call(self.class.name)
+    end
+
+    # Report Analytics for bundled content, this should capture tasks run from
+    # both CLI and Plans.
+    executor.report_bundled_content('Task', task_name)
+
+    # Ensure that given targets are all Target instances.
+    targets = inventory.get_targets(targets)
+
+    # Return early if there are no targets.
+    if targets.empty?
+      return Bolt::ResultSet.new([])
+    end
+
+    # If all targets use the PCP transport, create a fake task instead of
+    # loading the actual task definition.
+    if targets.all? { |t| t.transport == 'pcp' }
+      task = Bolt::Task.new(task_name,
+                            { 'supports_noop' => true },
+                            [{ 'name' => '', 'path' => '' }])
+    else
+      # TODO: use the compiler injection once PUP-8237 lands
+      task_signature = Puppet::Pal::ScriptCompiler.new(closure_scope.compiler).task_signature(task_name)
+      if task_signature.nil?
+        raise Bolt::Error.unknown_task(task_name)
+      end
+
+      task = Bolt::Task.from_task_signature(task_signature)
+
+      # Set the default value for any params that have one and were not provided
+      # or are undef.
+      params = task.parameter_defaults.merge(params) do |_, default, passed|
+        passed.nil? ? default : passed
+      end
+
+      task_signature.runnable_with?(params) do |mismatch_message|
+        raise with_stack(:TYPE_MISMATCH, mismatch_message)
+      end || (raise with_stack(:TYPE_MISMATCH, 'Task parameters do not match'))
+    end
+
+    # Generate a helpful error message about the type-mismatch between the type
+    # Data and the actual type of params.
+    unless Puppet::Pops::Types::TypeFactory.data.instance?(params)
+      params_t = Puppet::Pops::Types::TypeCalculator.infer_set(params)
+      desc = Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch(
+        'Task parameters are not of type Data. run_task()',
+        Puppet::Pops::Types::TypeFactory.data, params_t
+      )
+      raise with_stack(:TYPE_NOT_DATA, desc)
+    end
+
+    # Wrap parameters marked with '"sensitive": true' in the task metadata with a
+    # Sensitive wrapper type. This way it's not shown in logs.
+    if (param_spec = task.parameters)
+      params.each do |k, v|
+        if param_spec[k] && param_spec[k]['sensitive']
+          params[k] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(v)
+        end
+      end
+    end
+
+    # executor.noop is set when run task is called from the CLI
+    # options[:noop] is set when it's called from a plan
+    if executor.noop || options[:noop]
+      if task.supports_noop
+        params['_noop'] = true
+      else
+        raise with_stack(:TASK_NO_NOOP, 'Task does not support noop')
+      end
+    end
+
+    # Report whether the task was run in noop mode.
+    executor.report_noop_mode(executor.noop || options[:noop])
+
+    file_line = Puppet::Pops::PuppetStack.top_of_stack
+    result = if executor.in_parallel?
+               executor.run_in_thread do
+                 executor.run_task(targets, task, params, options, file_line)
+               end
+             else
+               executor.run_task(targets, task, params, options, file_line)
+             end
+
+    if !result.ok && !options[:catch_errors]
+      raise Bolt::RunFailure.new(result, 'run_task', task_name)
+    end
+
+    result
+  end
+
+  def with_stack(kind, msg)
+    issue = Puppet::Pops::Issues.issue(kind) { msg }
+    Puppet::ParseErrorWithIssue.from_issue_and_stack(issue)
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+require 'bolt/pal'
+require 'bolt/task'
+
+# Runs a given instance of a `Task` with target-specific parameters on the given set of targets and
+# returns the result from each. This function differs from {run_task} by accepting a block that returns
+# a `Hash` of target-specific parameters that are passed to the task. This can be used to send parameters
+# based on a target's attributes, such as its `facts`, or to use conditional logic to determine the
+# parameters a task should receive for a specific target.
+#
+# This function does nothing if the list of targets is empty.
+#
+# > **Note:** Not available in apply block
+#
+# > **Note:** Not available to targets using the pcp transport
+Puppet::Functions.create_function(:run_task_with) do
+  # Run a task with target-specific parameters.
+  # @param task_name The task to run.
+  # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param options A hash of additional options.
+  # @option options [Boolean] _catch_errors Whether to catch raised errors.
+  # @option options [Boolean] _noop Run the task in noop mode if available.
+  # @option options [String] _run_as User to run as using privilege escalation.
+  # @param block A block that returns a `Hash` of target-specific parameters for the task.
+  # @return A list of results, one entry per target.
+  # @example Run a task with target-specific parameters as root
+  #   run_task_with('my_task', $targets, '_run_as' => 'root') |$t| {
+  #     { 'param1' => $t.vars['var1'],
+  #       'param2' => $t.vars['var2'] }
+  #   }
+  dispatch :run_task_with do
+    param 'String[1]', :task_name
+    param 'Boltlib::TargetSpec', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    required_block_param 'Callable[Target]', :block
+    return_type 'ResultSet'
+  end
+
+  # Run a task with target-specific parameters, logging the provided description.
+  # @param task_name The task to run.
+  # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param description A description to be output when calling this function.
+  # @param options A hash of additional options.
+  # @option options [Boolean] _catch_errors Whether to catch raised errors.
+  # @option options [Boolean] _noop Run the task in noop mode if available.
+  # @option options [String] _run_as User to run as using privilege escalation.
+  # @param block A block that returns a `Hash` of target-specific parameters for the task.
+  # @return A list of results, one entry per target.
+  # @example Run a task with target-specific parameters and a description
+  #   run_task_with('my_task', $targets, 'Update system packages') |$t| {
+  #     { 'param1' => $t.vars['var1'],
+  #       'param2' => $t.vars['var2'] }
+  #   }
+  dispatch :run_task_with_with_description do
+    param 'String[1]', :task_name
+    param 'Boltlib::TargetSpec', :targets
+    param 'Optional[String]', :description
+    optional_param 'Hash[String[1], Any]', :options
+    required_block_param 'Callable[Target]', :block
+    return_type 'ResultSet'
+  end
+
+  def run_task_with(task_name, targets, options = {}, &block)
+    run_task_with_with_description(task_name, targets, nil, options, &block)
+  end
+
+  def run_task_with_with_description(task_name, targets, description, options = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(
+          Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+          action: 'run_task_with'
+        )
+    end
+
+    executor  = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
+    error_set = []
+
+    # Report to analytics
+    executor.report_function_call(self.class.name)
+    executor.report_bundled_content('Task', task_name)
+
+    # Keep valid metaparameters, discarding everything else
+    options = options.select { |k, _v| k.start_with?('_') }
+                     .transform_keys { |k| k.sub(/^_/, '').to_sym }
+
+    options[:description] = description if description
+
+    # Get all the targets
+    targets = Array(inventory.get_targets(targets))
+
+    # Return early if there are no targets.
+    if targets.empty?
+      return Bolt::ResultSet.new([])
+    end
+
+    # If all targets use the 'pcp' transport, use a fake task instead of loading the local definition
+    # Otherwise, load the local task definition
+    if (pcp_only = targets.all? { |t| t.transport == 'pcp' })
+      task = Bolt::Task.new(task_name,
+                            { 'supports_noop' => true },
+                            [{ 'name' => '', 'path' => '' }])
+    else
+      task_signature = Puppet::Pal::ScriptCompiler.new(closure_scope.compiler).task_signature(task_name)
+
+      if task_signature.nil?
+        raise Bolt::Error.unknown_task(task_name)
+      end
+
+      task = Bolt::Task.from_task_signature(task_signature)
+    end
+
+    # Map the targets to their specific parameters and merge with the defaults
+    target_mapping = targets.each_with_object({}) do |target, mapping|
+      params = yield(target)
+
+      # Parameters returned from the block should be a Hash. If they're not, create a failing
+      # Result for the target that will later be added to the ResultSet.
+      unless params.is_a?(Hash)
+        exception = with_stack(
+          :TYPE_MISMATCH,
+          "Block must return a Hash of parameters, received #{params.class}"
+        )
+        error_set << Bolt::Result.from_exception(target, exception, action: 'task')
+        next
+      end
+
+      # If parameters are mismatched, create a failing result for the target that will later
+      # be added to the ResultSet.
+      unless pcp_only
+        # Set the default value for any params that have one and were not provided or are undef
+        params = task.parameter_defaults.merge(params) do |_, default, passed|
+          passed.nil? ? default : passed
+        end
+
+        type_match = task_signature.runnable_with?(params) do |mismatch_message|
+          exception = with_stack(:TYPE_MISMATCH, mismatch_message)
+          error_set << Bolt::Result.from_exception(target, exception, action: 'task')
+        end
+
+        next unless type_match
+      end
+
+      # If there is a type mismatch between the type Data and the type of the params, create
+      # a failing result for the target that will later be added to the ResultSet.
+      unless Puppet::Pops::Types::TypeFactory.data.instance?(params)
+        params_t = Puppet::Pops::Types::TypeCalculator.infer_set(params)
+        desc = Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch(
+          'Task parameters are not of type Data. run_task_with()',
+          Puppet::Pops::Types::TypeFactory.data, params_t
+        )
+        exception = with_stack(:TYPE_NOT_DATA, desc)
+        error_set << Bolt::Result.from_exception(target, exception, action: 'task')
+        next
+      end
+
+      # Wrap parameters marked with '"sensitive": true' in the task metadata with a
+      # Sensitive wrapper type. This way it's not shown in logs.
+      if (param_spec = task.parameters)
+        params.each do |k, v|
+          if param_spec[k] && param_spec[k]['sensitive']
+            params[k] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(v)
+          end
+        end
+      end
+
+      # Set the default value for any params that have one and were not provided or are undef
+      mapping[target] = task.parameter_defaults.merge(params) do |_, default, passed|
+        passed.nil? ? default : passed
+      end
+    end
+
+    # Add a noop parameter if the function was called with the noop metaparameter.
+    if options[:noop]
+      if task.supports_noop
+        target_mapping.each_value { |params| params['_noop'] = true }
+      else
+        raise with_stack(:TASK_NO_NOOP, 'Task does not support noop')
+      end
+    end
+
+    # Report whether the task was run in noop mode.
+    executor.report_noop_mode(executor.noop || options[:noop])
+
+    # Combine the results from the task run with any failing results that were
+    # generated earlier when creating the target mapping
+    file_line = Puppet::Pops::PuppetStack.top_of_stack
+    task_result = if executor.in_parallel?
+                    executor.run_in_thread do
+                      executor.run_task_with(target_mapping, task, options, file_line)
+                    end
+                  else
+                    executor.run_task_with(target_mapping, task, options, file_line)
+                  end
+    result = Bolt::ResultSet.new(task_result.results + error_set)
+
+    if !result.ok && !options[:catch_errors]
+      raise Bolt::RunFailure.new(result, 'run_task', task_name)
+    end
+
+    result
+  end
+
+  def with_stack(kind, msg)
+    issue = Puppet::Pops::Issues.issue(kind) { msg }
+    Puppet::ParseErrorWithIssue.from_issue_and_stack(issue)
+  end
+end

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

@@ -0,0 +1,48 @@
+# 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)
+    # Send Analytics Report
+    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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Sets a particular feature to present on a target.
+#
+# Features are used to determine what implementation of a task should be run.
+# Supported features are:
+# - `powershell`
+# - `shell`
+# - `puppet-agent`
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:set_feature) do
+  # @param target The Target object to add features to. See {get_targets}.
+  # @param feature The string identifying the feature.
+  # @param value Whether the feature is supported.
+  # @return The target with the updated feature
+  # @example Add the `puppet-agent` feature to a target
+  #   set_feature($target, 'puppet-agent', true)
+  dispatch :set_feature do
+    param 'Target', :target
+    param 'String', :feature
+    optional_param 'Boolean', :value
+    return_type 'Target'
+  end
+
+  def set_feature(target, feature, value = true)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_feature')
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    inventory.set_feature(target, feature, value)
+
+    target
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Sets one or more ResourceInstances on a Target. This function does not apply or modify
+# resources on a target.
+#
+# For more information about resources see [the
+# documentation](https://puppet.com/docs/puppet/latest/lang_resources.html).
+#
+# > **Note:** The `ResourceInstance` data type is under active development and is subject to
+#   change. You can read more about the data type in the [experimental features
+#   documentation](experimental_features.md#resourceinstance-data-type).
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:set_resources) do
+  # Set a single resource from a data hash.
+  # @param target The `Target` object to add a resource to. See {get_targets}.
+  # @param resource The resource data hash used to set a resource on the target.
+  # @return An array with the added `ResourceInstance` object.
+  # @example Add a resource to a target from a data hash.
+  #   $resource_hash = {
+  #     'type'  => File,
+  #     'title' => '/etc/puppetlabs',
+  #     'state' => { 'ensure' => 'present' }
+  #   }
+  #
+  #   $target.set_resources($resource_hash)
+  dispatch :set_single_resource_from_hash do
+    param 'Target', :target
+    param 'Hash', :resource
+    return_type 'Array[ResourceInstance]'
+  end
+
+  # Set a single resource from a `ResourceInstance` object
+  # @param target The `Target` object to add a resource to. See {get_targets}.
+  # @param resource The `ResourceInstance` object to set on the target.
+  # @return An array with the added `ResourceInstance` object.
+  # @example Add a resource to a target from a `ResourceInstance` object.
+  #   $resource_instance = ResourceInstance.new(
+  #     'target' => $target,
+  #     'type'   => File,
+  #     'title'  => '/etc/puppetlabs',
+  #     'state'  => { 'ensure' => 'present' }
+  #   )
+  #
+  #   $target.set_resources($resource_instance)
+  dispatch :set_single_resource_from_object do
+    param 'Target', :target
+    param 'ResourceInstance', :resource
+    return_type 'Array[ResourceInstance]'
+  end
+
+  # Set multiple resources from an array of data hashes and `ResourceInstance` objects.
+  # @param target The `Target` object to add resources to. See {get_targets}.
+  # @param resources The resource data hashes and `ResourceInstance` objects to set on the target.
+  # @return An array of the added `ResourceInstance` objects.
+  # @example Add resources from resource data hashes returned from an apply block.
+  #   $apply_results = apply($targets) {
+  #     File { '/etc/puppetlabs':
+  #       ensure => present
+  #     }
+  #     Package { 'openssl':
+  #       ensure => installed
+  #     }
+  #   }
+  #
+  #   $apply_results.each |$result| {
+  #     $result.target.set_resources($result.report['resource_statuses'].values)
+  #   }
+  # @example Add resources retrieved with [`get_resources`](#get_resources) to a target.
+  #   $resources = $target.get_resources(Package).first['resources']
+  #   $target.set_resources($resources)
+  dispatch :set_resources do
+    param 'Target', :target
+    param 'Array[Variant[Hash, ResourceInstance]]', :resources
+    return_type 'Array[ResourceInstance]'
+  end
+
+  def set_single_resource_from_hash(target, resource)
+    set_resources(target, [resource])
+  end
+
+  def set_single_resource_from_object(target, resource)
+    set_resources(target, [resource])
+  end
+
+  def set_resources(target, resources)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(
+          Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+          action: 'set_resources'
+        )
+    end
+
+    # Send Analytics Report
+    Puppet.lookup(:bolt_executor).report_function_call(self.class.name)
+    inventory = Puppet.lookup(:bolt_inventory)
+
+    resources.uniq.map do |resource|
+      if resource.is_a?(Hash)
+        # ResourceInstance expects a Target object, so either get a specified target from
+        # the inventory or use the target this function was called on.
+        resource_target = if resource.key?('target')
+                            inventory.get_target(resource['target'])
+                          else
+                            target
+                          end
+
+        # Observed state from get_resources() is under the 'parameters' key
+        resource_state = resource['state'] || resource['parameters']
+
+        # Type from apply results is under the 'resource_type' key
+        resource_type = resource['type'] || resource['resource_type']
+
+        init_hash = {
+          'target'        => resource_target,
+          'type'          => resource_type,
+          'title'         => resource['title'],
+          'state'         => resource_state,
+          'desired_state' => resource['desired_state'],
+          'events'        => resource['events']
+        }
+
+        # Calling Bolt::ResourceInstance.new or Bolt::ResourceInstance.from_asserted_hash
+        # will not perform any validation on the parameters. Instead, we need to use the
+        # Puppet constructor to initialize the object, which will first validate the parameters
+        # and then call Bolt::ResourceInstance.from_asserted_hash internally. To do this we
+        # first need to get the Puppet datatype and then call the new function on that type.
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('ResourceInstance')
+        resource = call_function('new', type, init_hash)
+      end
+
+      unless resource.target == target
+        file, line = Puppet::Pops::PuppetStack.top_of_stack
+        raise Bolt::ValidationError, "Cannot set resource #{resource.reference} for target "\
+                                     "#{resource.target} on target #{target}. "\
+                                     "#{Puppet::Util::Errors.error_location(file, line)}"
+      end
+
+      target.set_resource(resource)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Sets a variable `{ key => value }` for a target.
+#
+# > **Note:** Not available in apply block
+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 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)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_var')
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    var_hash = { key => value }
+    inventory.set_var(target, var_hash)
+
+    target
+  end
+end