openbolt 5.0.0.rc1

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'bolt/logger'
+require 'bolt/task'
+
+# Installs the `puppet-agent` package on targets if needed, then collects facts,
+# including any custom facts found in Bolt's module path. The package is
+# installed using either the configured plugin or the `task` plugin with the
+# `puppet_agent::install` task.
+#
+# Agent installation will be skipped if the target includes the `puppet-agent`
+# feature, either as a property of its transport (PCP) or by explicitly setting
+# it as a feature in Bolt's inventory.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:apply_prep) do
+  # @param targets A pattern or array of patterns identifying a set of targets.
+  # @param options Options hash.
+  # @option options [Boolean] _catch_errors Whether to catch raised errors.
+  # @option options [Array] _required_modules An array of modules to sync to the target.
+  # @option options [String] _run_as User to run as using privilege escalation.
+  # @return [Bolt::ResultSet]
+  # @example Prepare targets by name.
+  #   apply_prep('target1,target2')
+  dispatch :apply_prep do
+    param 'Boltlib::TargetSpec', :targets
+    optional_param 'Hash[String, Data]', :options
+  end
+
+  def apply_prep(target_spec, options = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'apply_prep')
+    end
+
+    options = options.slice(*%w[_catch_errors _required_modules _run_as])
+    targets = inventory.get_targets(target_spec)
+
+    executor.report_function_call(self.class.name)
+
+    executor.log_action('install puppet and gather facts', targets) do
+      executor.without_default_logging do
+        install_results = install_agents(targets, options)
+        facts_results   = get_facts(install_results.ok_set.targets, options)
+
+        Bolt::ResultSet.new(install_results.error_set.results + facts_results.results)
+      end
+    end
+  end
+
+  def applicator
+    @applicator ||= Puppet.lookup(:apply_executor)
+  end
+
+  def executor
+    @executor ||= Puppet.lookup(:bolt_executor)
+  end
+
+  def inventory
+    @inventory ||= Puppet.lookup(:bolt_inventory)
+  end
+
+  # Runs a task. This method is called by the puppet_library hook.
+  #
+  def run_task(targets, task, args = {}, options = {})
+    executor.run_task(targets, task, args, options)
+  end
+
+  # Returns true if the target has the puppet-agent feature defined, either from
+  # inventory or transport.
+  #
+  private def agent?(target)
+    inventory.features(target).include?('puppet-agent') ||
+    executor.transport(target.transport).provided_features.include?('puppet-agent') ||
+    target.remote?
+  end
+
+  # Generate the plugin tarball.
+  #
+  private def build_plugin_tarball(required_modules)
+    if required_modules.any?
+      Puppet.debug("Syncing only required modules: #{required_modules.join(',')}.")
+    end
+
+    tarball = applicator.build_plugin_tarball do |mod|
+      next unless required_modules.empty? || required_modules.include?(mod.name)
+      search_dirs = []
+      search_dirs << mod.plugins if mod.plugins?
+      search_dirs << mod.pluginfacts if mod.pluginfacts?
+      search_dirs
+    end
+
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(tarball)
+  end
+
+  # Install the puppet-agent package on targets that need it.
+  #
+  private def install_agents(targets, options)
+    results = []
+
+    agent_targets, agentless_targets = targets.partition { |target| agent?(target) }
+
+    agent_targets.each do |target|
+      Puppet.debug("Puppet Agent feature declared for #{target}")
+      results << Bolt::Result.new(target)
+    end
+
+    unless agentless_targets.empty?
+      hooks, errors = get_hooks(agentless_targets, options)
+      hook_results  = run_hooks(hooks)
+
+      hook_results.each do |result|
+        next unless result.ok?
+        inventory.set_feature(result.target, 'puppet-agent')
+      end
+
+      results.concat(hook_results).concat(errors)
+    end
+
+    Bolt::ResultSet.new(results).tap do |resultset|
+      unless resultset.ok? || options['_catch_errors']
+        raise Bolt::RunFailure.new(resultset.error_set, 'apply_prep')
+      end
+    end
+  end
+
+  # Retrieve facts from each target and add them to inventory.
+  #
+  private def get_facts(targets, options)
+    return Bolt::ResultSet.new([]) unless targets.any?
+
+    task    = applicator.custom_facts_task
+    args    = { 'plugins' => build_plugin_tarball(options.delete('_required_modules').to_a) }
+    results = run_task(targets, task, args, options)
+
+    unless results.ok? || options['_catch_errors']
+      raise Bolt::RunFailure.new(results, 'run_task', task.name)
+    end
+
+    results.each do |result|
+      next unless result.ok?
+
+      if unsupported_puppet?(result['clientversion'])
+        Bolt::Logger.deprecate(
+          "unsupported_puppet",
+          "Detected unsupported Puppet agent version #{result['clientversion']} on target "\
+          "#{result.target}. Bolt supports Puppet agent 6.0.0 and higher."
+        )
+      end
+
+      inventory.add_facts(result.target, result.value)
+    end
+
+    results
+  end
+
+  # Return a list of targets and their puppet_library hooks.
+  #
+  private def get_hooks(targets, options)
+    hooks  = []
+    errors = []
+
+    targets.each do |target|
+      plugin_opts = target.plugin_hooks.fetch('puppet_library').dup
+      plugin_name = plugin_opts.delete('plugin')
+      hook        = inventory.plugins.get_hook(plugin_name, :puppet_library)
+
+      hooks << { 'target' => target,
+                 'proc'   => hook.call(plugin_opts.merge(options), target, self) }
+    rescue StandardError => e
+      errors << Bolt::Result.from_exception(target, e)
+    end
+
+    [hooks, errors]
+  end
+
+  # Runs the puppet_library hook for each target, returning the result
+  # of each.
+  #
+  private def run_hooks(hooks)
+    require 'concurrent'
+    pool = Concurrent::ThreadPoolExecutor.new
+
+    futures = hooks.map do |hook|
+      Concurrent::Future.execute(executor: pool) do
+        hook['proc'].call
+      end
+    end
+
+    futures.zip(hooks).map do |future, hook|
+      future.value || Bolt::Result.from_exception(hook['target'], future.reason)
+    end
+  end
+
+  # Returns true if the client's major version is < 6.
+  #
+  private def unsupported_puppet?(client_version)
+    if client_version.nil?
+      false
+    else
+      begin
+        Integer(client_version.split('.').first) < 6
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Starts a block of code in parallel with the main plan without blocking.
+# Returns a Future object.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:background, Puppet::Functions::InternalFunction) do
+  # Starts a block of code in parallel with the main plan without blocking.
+  # Returns a Future object.
+  # @param name An optional name for legible logs.
+  # @param block The code block to run in the background.
+  # @return A Bolt Future object
+  # @example Start a long-running process
+  #   background() || {
+  #     run_task('superlong::task', $targets)
+  #   }
+  #   run_command("echo 'Continue immediately'", $targets)
+  dispatch :background do
+    scope_param
+    optional_param 'String[1]', :name
+    block_param 'Callable[0, 0]', :block
+    return_type 'Future'
+  end
+
+  def background(scope, name = nil, &block)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'background')
+    end
+
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call(self.class.name)
+
+    plan_id = executor.get_current_plan_id(fiber: Fiber.current)
+    executor.create_future(scope: scope, name: name, plan_id: plan_id) do |newscope|
+      # Catch 'return' calls inside the block
+      result = catch(:return) do
+        # Execute the block. Individual plan steps in the block will yield
+        # the Fiber if they haven't finished, so all this needs to do is run
+        # the block.
+        block.closure.call_by_name_with_scope(newscope, {}, true)
+      end
+
+      # If we got a return from the block, get its value
+      # Otherwise the result is the last line from the block
+      result = result.value if result.is_a?(Puppet::Pops::Evaluator::Return)
+
+      # Validate the result is a PlanResult
+      unless Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult').instance?(result)
+        raise Bolt::InvalidParallelResult.new(result.to_s, *Puppet::Pops::PuppetStack.top_of_stack)
+      end
+
+      result
+    rescue Puppet::PreformattedError => e
+      if e.cause.is_a?(Bolt::Error)
+        e.cause
+      else
+        raise e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Catches errors in a given block and returns them. This will return the
+# output of the block if no errors are raised. Accepts an optional list of
+# error kinds to catch.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:catch_errors) do
+  # @param error_types An array of error types to catch
+  # @param block The block of steps to catch errors on
+  # @return If an error is raised in the block then the error will be returned,
+  #         otherwise the result will be returned
+  # @example Catch errors for a block
+  #   catch_errors() || {
+  #     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', $targets)
+  #    run_plan('other_plan)
+  #    apply($targets) || {
+  #      notify { "Hello": }
+  #    }
+  #   }
+  dispatch :catch_errors do
+    optional_param 'Array[String[1]]', :error_types
+    block_param 'Callable[0, 0]', :block
+    return_type 'Any'
+  end
+
+  def catch_errors(error_types = nil)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+                              action: self.class.name)
+    end
+
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    begin
+      yield
+    rescue Puppet::PreformattedError => e
+      if e.cause.is_a?(Bolt::Error)
+        if error_types.nil? || error_types.include?(e.cause.to_h['kind'])
+          e.cause.to_puppet_error
+        else
+          raise e
+        end
+      else
+        raise e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'bolt/error'
+
+# Downloads the given file or directory from the given set of targets and saves it to a directory
+# matching the target's name under the given destination directory. Returns the result from each
+# download. This does nothing if the list of targets is empty.
+#
+# > **Note:** Existing content in the destination directory is deleted before downloading from
+# > the targets.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:download_file, Puppet::Functions::InternalFunction) do
+  # Download a file or directory.
+  # @param source The absolute path to the file or directory on the target(s).
+  # @param destination The relative path to the destination directory on the local system. Expands
+  #                    relative to `<project>/downloads/`.
+  # @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 [String] _run_as User to run as using privilege escalation.
+  # @return A list of results, one entry per target, with the path to the downloaded file under the
+  #         `path` key.
+  # @example Download a file from multiple Linux targets to a destination directory
+  #   download_file('/etc/ssh/ssh_config', '~/Downloads', $targets)
+  # @example Download a directory from multiple Linux targets to a project downloads directory
+  #   download_file('/etc/ssh', 'ssh', $targets)
+  # @example Download a file from multiple Linux targets and compare its contents to a local file
+  #   $results = download_file($source, $destination, $targets)
+  #
+  #   $local_content = file::read($source)
+  #
+  #   $mismatched_files = $results.filter |$result| {
+  #     $remote_content = file::read($result['path'])
+  #     $remote_content == $local_content
+  #   }
+  dispatch :download_file do
+    param 'String[1]', :source
+    param 'String[1]', :destination
+    param 'Boltlib::TargetSpec', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
+  end
+
+  # Download a file or directory, logging the provided description.
+  # @param source The absolute path to the file or directory on the target(s).
+  # @param destination The relative path to the destination directory on the local system. Expands
+  #                    relative to `<project>/downloads/`.
+  # @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 [String] _run_as User to run as using privilege escalation.
+  # @return A list of results, one entry per target, with the path to the downloaded file under the
+  #         `path` key.
+  # @example Download a file from multiple Linux targets to a destination directory
+  #   download_file('/etc/ssh/ssh_config', '~/Downloads', $targets, 'Downloading remote SSH config')
+  dispatch :download_file_with_description do
+    param 'String[1]', :source
+    param 'String[1]', :destination
+    param 'Boltlib::TargetSpec', :targets
+    param 'String', :description
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
+  end
+
+  def download_file(source, destination, targets, options = {})
+    download_file_with_description(source, destination, targets, nil, options)
+  end
+
+  def download_file_with_description(source, destination, targets, description = nil, options = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'download_file')
+    end
+
+    options = options.select { |opt| opt.start_with?('_') }.transform_keys { |k| k.sub(/^_/, '').to_sym }
+    options[:description] = description if description
+
+    executor = Puppet.lookup(:bolt_executor)
+    inventory = Puppet.lookup(:bolt_inventory)
+
+    if (destination = destination.strip).empty?
+      raise Bolt::ValidationError, "Destination cannot be an empty string"
+    end
+
+    if (destination = Pathname.new(destination)).absolute?
+      raise Bolt::ValidationError, "Destination must be a relative path, received absolute path #{destination}"
+    end
+
+    # Prevent path traversal so downloads can't be saved outside of the project downloads directory
+    if (destination.each_filename.to_a & %w[. ..]).any?
+      raise Bolt::ValidationError, "Destination must not include path traversal, received #{destination}"
+    end
+
+    # Paths expand relative to the default downloads directory for the project
+    # e.g. ~/.puppetlabs/bolt/downloads/
+    destination = Puppet.lookup(:bolt_project).downloads + destination
+
+    # If the destination directory already exists, delete any existing contents
+    if Dir.exist?(destination)
+      FileUtils.rm_r(Dir.glob(destination + '*'), secure: true)
+    end
+
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    # Ensure that that given targets are all Target instances
+    targets = inventory.get_targets(targets)
+    if targets.empty?
+      call_function('debug', "Simulating file download of '#{source}' - no targets given - no action taken")
+      Bolt::ResultSet.new([])
+    else
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.download_file(targets, source, destination, options, file_line)
+            end
+          else
+            executor.download_file(targets, source, destination, options, file_line)
+          end
+
+      if !r.ok && !options[:catch_errors]
+        raise Bolt::RunFailure.new(r, 'download_file', source)
+      end
+      r
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Returns the facts hash for a target.
+#
+# Using the `facts` function does not automatically collect facts for a target,
+# and will only return facts that are currently set in the inventory. To collect
+# facts from a target and set them in the inventory, run the
+# [facts](writing_plans.md#collect-facts-from-targets) plan or
+# [puppetdb_fact](writing_plans.md#collect-facts-from-puppetdb) plan.
+Puppet::Functions.create_function(:facts) do
+  # @param target A target.
+  # @return The target's facts.
+  # @example Getting facts
+  #   facts($target)
+  dispatch :facts do
+    param 'Target', :target
+    return_type 'Hash[String, Data]'
+  end
+
+  def facts(target)
+    inventory = Puppet.lookup(:bolt_inventory)
+    # Bolt executor not expected when invoked from apply block
+    executor = Puppet.lookup(:bolt_executor) { nil }
+    # Send Analytics Report
+    executor&.report_function_call(self.class.name)
+
+    inventory.facts(target)
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Raises a `Bolt::PlanFailure` exception to signal to callers that the plan failed.
+#
+# Plan authors should call this function when their plan is not successful. The
+# error may then be caught by another plans `run_plan` function or in Bolt itself
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:fail_plan) do
+  # Fail a plan, generating an exception from the parameters.
+  # @param msg An error message.
+  # @param kind An easily matchable error kind.
+  # @param details Machine-parseable details about the error.
+  # @param issue_code Unused.
+  # @return Raises an exception.
+  # @example Raise an exception
+  #   fail_plan('We goofed up', 'task-unexpected-result', { 'result' => 'null' })
+  dispatch :from_args do
+    param 'String[1]', :msg
+    optional_param 'String[1]', :kind
+    optional_param 'Hash[String[1], Any]', :details
+    optional_param 'String[1]', :issue_code
+  end
+
+  # Fail a plan, generating an exception from an existing Error object.
+  # @param error An error object.
+  # @return Raises an exception.
+  # @example Raise an exception
+  #   fail_plan(Error('We goofed up', 'task-unexpected-result', { 'result' => 'null' }))
+  dispatch :from_error do
+    param 'Error', :error
+  end
+
+  def from_args(msg, kind = nil, details = nil, issue_code = nil)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'fail_plan')
+    end
+
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    raise Bolt::PlanFailure.new(msg, kind || 'bolt/plan-failure', details, issue_code)
+  end
+
+  def from_error(err)
+    from_args(err.message, err.kind, err.details, err.issue_code)
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'bolt/task'
+
+# Query the state of resources on a list of targets using resource definitions in Bolt's module path.
+# 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. 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
+  # @param targets A pattern or array of patterns identifying a set of targets.
+  # @param resources A resource type or instance, or an array of such.
+  # @return A result set with a list of hashes representing each resource.
+  # @example Collect resource states for packages and a file
+  #   get_resources('target1,target2', [Package, File[/etc/puppetlabs]])
+  dispatch :get_resources do
+    param 'Boltlib::TargetSpec', :targets
+    param 'Variant[String, Type[Resource], Array[Variant[String, Type[Resource]]]]', :resources
+    return_type 'ResultSet'
+  end
+
+  def script_compiler
+    @script_compiler ||= Puppet::Pal::ScriptCompiler.new(closure_scope.compiler)
+  end
+
+  def run_task(executor, targets, name, args = {})
+    tasksig = script_compiler.task_signature(name)
+    raise Bolt::Error.new("#{name} could not be found", 'bolt/get-resources') unless tasksig
+
+    task = Bolt::Task.from_task_signature(tasksig)
+    results = executor.run_task(targets, task, args)
+    raise Bolt::RunFailure.new(results, 'run_task', task.name) unless results.ok?
+    results
+  end
+
+  def get_resources(target_spec, resources)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'get_resources')
+    end
+
+    applicator = Puppet.lookup(:apply_executor)
+    executor = Puppet.lookup(:bolt_executor)
+    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')
+      end
+    end
+
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    targets = inventory.get_targets(target_spec)
+
+    executor.log_action('gather resources', targets) do
+      executor.without_default_logging do
+        # Gather facts, including custom facts
+        plugins = applicator.build_plugin_tarball do |mod|
+          search_dirs = []
+          search_dirs << mod.plugins if mod.plugins?
+          search_dirs << mod.pluginfacts if mod.pluginfacts?
+          search_dirs
+        end
+
+        task = applicator.query_resources_task
+        arguments = {
+          'resources' => resources,
+          'plugins' => Puppet::Pops::Types::PSensitiveType::Sensitive.new(plugins)
+        }
+        results = executor.run_task(targets, task, arguments)
+        raise Bolt::RunFailure.new(results, 'run_task', task.name) unless results.ok?
+        results
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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('all')` returns an empty array.
+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 }
+    # 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: 'get_target')
+    end
+
+    inventory.get_target(name)
+  end
+end